yugabyte-ycql-driver 3.2.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0420f05d4a063e020526b1869f3c2a4bf61b7eb7
+  data.tar.gz: 594ee209ed49626772e68fcbe0b9331f1e0d8412
+SHA512:
+  metadata.gz: ef47feef7a8915c1bc87ef13f21ebc07b01520dc67690cdaa98ba8e7d691c428a9ef6a2c7c52d0e1607e910e82fbc86a7a630f4a4b681f7e80fc58922e77bae8
+  data.tar.gz: e298797101462cd87d89d0408204f34ea8dca108e2fd4ebe0ec34255d2d6bdc71d02eed339a37a161799867eddb27c3ca5b7c375dad88f666d01be1c1f67f428

data/.yardopts

@@ -0,0 +1,13 @@
+--no-private
+--markup markdown
+--type-tag expected_errors:"Expected Errors"
+--tag jira_ticket:"JIRA Ticket"
+--type-tag expected_result:"Expected Result"
+--tag test_assumptions:"Test Assumptions"
+--tag test_category:"Test Category"
+
+lib/**/*.rb
+integration/**/*.rb
+-- README
+
+load_plugins: true

data/README.md

@@ -0,0 +1,242 @@
+# YugaByte Ruby Driver for YugaByte DB's Cassandra compatible YCQL API
+
+*If you're reading this on GitHub, please note that this is the readme for the development version and that some
+features described here might not yet have been released. You can view the documentation for the latest released
+version [here](http://docs.datastax.com/en/developer/ruby-driver/latest).*
+
+[![Build Status](https://travis-ci.org/datastax/ruby-driver.svg?branch=master)](https://travis-ci.org/datastax/ruby-driver)
+
+A Ruby client driver for YugaByte DB's Cassandra compatible YCQL API. This driver works exclusively with
+the Cassandra Query Language version 3 (CQL3) and Cassandra's native protocol.
+
+- Code: https://github.com/yugabyte/cassandra-ruby-driver
+- Docs: http://docs.datastax.com/en/developer/ruby-driver
+- Mailing List: https://groups.google.com/a/lists.datastax.com/forum/#!forum/ruby-driver-user
+
+This driver is based on [the cql-rb gem](https://github.com/iconara/cql-rb) by [Theo Hultberg](https://github.com/iconara) and we added support for:
+
+* [Asynchronous execution](http://docs.datastax.com/en/developer/ruby-driver/3.1/features/asynchronous_io/)
+* One-off, [prepared](http://docs.datastax.com/en/developer/ruby-driver/3.1/features/basics/prepared_statements/) and [batch statements](http://docs.datastax.com/en/developer/ruby-driver/3.1/features/basics/batch_statements/)
+* Automatic peer discovery and cluster metadata with [support for change notifications](http://docs.datastax.com/en/developer/ruby-driver/3.1/features/state_listeners/)
+* Various [load-balancing](http://docs.datastax.com/en/developer/ruby-driver/3.1/features/load_balancing/), [retry](http://docs.datastax.com/en/developer/ruby-driver/3.1/features/retry_policies/) and [reconnection](http://docs.datastax.com/en/developer/ruby-driver/3.1/features/reconnection/) policies with [ability to write your own](http://docs.datastax.com/en/developer/ruby-driver/3.1/features/load_balancing/implementing_a_policy/)
+* [SSL encryption](http://docs.datastax.com/en/developer/ruby-driver/3.1/features/security/ssl_encryption/)
+* [Flexible and robust error handling](http://docs.datastax.com/en/developer/ruby-driver/3.1/features/error_handling/)
+* [Per-request execution information and tracing](http://docs.datastax.com/en/developer/ruby-driver/3.1/features/debugging/)
+* [Configurable address resolution](http://docs.datastax.com/en/developer/ruby-driver/3.1/features/address_resolution/)
+
+[Check out the slides from Ruby Driver Explained](https://speakerdeck.com/avalanche123/ruby-driver-explained) for a detailed overview of the Ruby Driver architecture.
+
+## Compatibility
+
+This driver works exclusively with the Cassandra Query Language v3 (CQL3) and Cassandra's native protocol.
+
+__Note__: Rubinius is not supported. 
+
+__Note__: Big-endian systems are not supported.
+
+## Quick start
+
+```ruby
+require 'ycql'
+
+cluster = Cassandra.cluster # connects to localhost by default
+
+cluster.each_host do |host| # automatically discovers all peers
+  puts "Host #{host.ip}: id=#{host.id} datacenter=#{host.datacenter} rack=#{host.rack}"
+end
+
+keyspace = 'system_schema'
+session  = cluster.connect(keyspace) # create session, optionally scoped to a keyspace, to execute queries
+
+future = session.execute_async('SELECT keyspace_name, table_name FROM tables') # fully asynchronous api
+future.on_success do |rows|
+  rows.each do |row|
+    puts "The keyspace #{row['keyspace_name']} has a table called #{row['table_name']}"
+  end
+end
+future.join
+```
+
+__Note__: The host you specify is just a seed node, the driver will automatically discover all peers in the cluster.
+
+Read more:
+
+* [`Cassandra.cluster` options](http://docs.datastax.com/en/developer/ruby-driver/3.1/api/cassandra/#cluster-class_method)
+* [`Session#execute_async` options](http://docs.datastax.com/en/developer/ruby-driver/3.1/api/cassandra/session/#execute_async-instance_method)
+* [Usage documentation](http://docs.datastax.com/en/developer/ruby-driver/3.1/features)
+
+## Installation
+
+Install via rubygems
+
+```bash
+gem install yugabyte-ycql-driver
+```
+
+Install via Gemfile
+
+```ruby
+gem 'yugabyte-ycql-driver'
+```
+
+__Note__: if you want to use compression you should also install [snappy](http://rubygems.org/gems/snappy) or [lz4-ruby](http://rubygems.org/gems/lz4-ruby). [Read more about compression.](http://docs.datastax.com/en/developer/ruby-driver/3.1/features/#compression)
+
+
+## Upgrading from cql-rb
+
+Some of the new features added to the driver have unfortunately led to changes in the original cql-rb API.
+In the examples directory, you can find [an example of how to wrap the ruby driver to achieve almost complete
+interface parity with cql-rb](https://github.com/datastax/ruby-driver/blob/v3.2.3/examples/cql-rb-wrapper.rb)
+to assist you with gradual upgrade.
+
+## What's new in v3.2
+This minor release adds support for MRI 2.4.x and also contains a few miscellaneous defect fixes. It also removes
+support for Ruby versions prior to 2.2. This was already officially the case, but the minimum version limit is
+now enforced.
+
+See the [changelog](https://github.com/datastax/ruby-driver/blob/v3.2.3/CHANGELOG.md) for more information on all
+changes in this version and past versions.
+
+## What's new in v3.1
+
+This minor release introduces features and fixes around resiliency, schema metadata, usability, and performance. One
+of the most user-impacting of these is the introduction of
+[execution profiles](http://docs.datastax.com/en/developer/ruby-driver/3.1/features/basics/execution_profiles).
+Execution profiles allow you to group various execution options into a 'profile' and you reference the desired
+profile at execution time. Get the scoop
+[here](http://docs.datastax.com/en/developer/ruby-driver/3.1/features/basics/execution_profiles).
+
+## What's new in v3.0
+
+### Features:
+
+* Add support for Apache Cassandra native protocol v4
+* Add support for smallint, tinyint, date (`Cassandra::Date`) and time (`Cassandra::Time`) data types.
+* Include schema metadata for User Defined Functions and User Defined Aggregates.
+* Augment the `Cassandra::Table` object to expose many more attributes: `id`, `options`, `keyspace`, `partition_key`, `clustering_columns`, and `clustering_order`. This makes it significantly easier to write administration scripts that report various attributes of your schema, which may help to highlight areas for improvement.
+* Include client ip addresses in request traces, only on Cassandra 3.x.
+* Add new retry policy decision `Cassandra::Retry::Policy#try_next_host`.
+* Support specifying statement idempotence with the new `idempotent` option when executing.
+* Support sending custom payloads when preparing or executing statements using the new `payload` option.
+* Expose custom payloads received with responses on server exceptions and `Cassandra::Execution::Info` instances.
+* Expose server warnings on server exceptions and `Cassandra::Execution::Info` instances.
+* Add `connections_per_local_node`, `connections_per_remote_node`, `requests_per_connection` cluster configuration options to tune parallel query execution and resource usage.
+* Add `Cassandra::Logger` class to make it easy for users to enable debug logging in the client.
+* Add `protocol_version` configuration option to allow the user to force the protocol version to use for communication with nodes.
+* Add support for materialized views and indexes in the schema metadata.
+* Support the `ReadError`, `WriteError`, and `FunctionCallError` Cassandra error responses introduced in Cassandra 2.2.
+* Add support for unset variables in bound statements.
+* Support DSE security (`DseAuthenticator`, configured for LDAP).
+* Add a timeout option to `Cassandra::Future#get`.
+
+### Breaking Changes from 2.x:
+
+* `Cassandra::Future#join` is now an alias to Cassandra::Future#get and will raise an error if the future is resolved with one.
+* Default consistency level is now LOCAL_ONE.
+* Enable tcp no-delay by default.
+* Unavailable errors are retried on the next host in the load balancing plan by default.
+* Statement execution no longer retried on timeouts, unless the statement is marked as idempotent in the call to `Cassandra::Session#execute*` or when creating a `Cassandra::Statement` object. 
+* `Cassandra::Statements::Batch#add` and `Cassandra::Session#execute*` signatures have changed in how one specifies query parameters. Specify the query parameters array as the value of the arguments key:
+ 
+```ruby
+batch.add(query, ['val1', 'val2'])
+# becomes
+batch.add(query, arguments: ['val1', 'val2'])
+
+batch.add(query, {p1: 'val1'})
+# becomes
+batch.add(query, arguments: {p1: 'val1'})
+```
+* The Datacenter-aware load balancing policy (`Cassandra::LoadBalancing::Policies::DCAwareRoundRobin`) defaults to using
+  nodes in the local DC only. In prior releases, the policy would fall back to remote nodes after exhausting local nodes.
+  Specify a positive value (or nil for unlimited) for `max_remote_hosts_to_use` when initializing the policy to allow remote node use.
+* Unspecified variables in statements previously resulted in an exception. Now they are essentially ignored or treated as null.
+
+## Code examples
+
+The DataStax Ruby Driver uses the awesome [Cucumber Framework](http://cukes.info/) for
+both end-to-end, or acceptance, testing and constructing documentation. All of the
+features supported by the driver have appropriate acceptance tests with easy-to-copy code
+examples in the `features/` directory.
+
+## Running tests
+
+If you don't feel like reading through the following instructions on how to run
+ruby-driver tests, feel free to [check out .travis.yml for the entire build code](https://github.com/datastax/ruby-driver/blob/v3.2.3/.travis.yml).
+
+* Check out the driver codebase and install test dependencies:
+
+```bash
+git clone https://github.com/yugabyte/cassandra-ruby-driver.git
+cd ruby-driver
+bundle install --without docs
+```
+
+* [Install ccm](http://www.datastax.com/dev/blog/ccm-a-development-tool-for-creating-local-cassandra-clusters)
+
+* Run tests against different versions of Cassandra:
+
+```bash
+CASSANDRA_VERSION=3.1.1 bundle exec cucumber # runs end-to-end tests (or bundle exec rake cucumber)
+CASSANDRA_VERSION=3.0.0 bundle exec rspec # runs unit tests (or bundle exec rake rspec)
+CASSANDRA_VERSION=2.1.12 bundle exec rake integration # run integration tests
+CASSANDRA_VERSION=2.1.12 bundle exec rake test # run both as well as integration tests
+```
+
+## Changelog & versioning
+
+Check out the [releases on GitHub](https://github.com/yugabyte/cassandra-ruby-driver/releases) and
+[changelog](https://github.com/yugabyte/cassandra-ruby-driver/blob/v3.2.3/CHANGELOG.md). Version
+numbering follows the [semantic versioning](http://semver.org/) scheme.
+
+Private and experimental APIs, defined as whatever is not in the
+[public API documentation][1], i.e. classes and methods marked as `@private`, will change
+without warning. If you've been recommended to try an experimental API by the maintainers,
+please let them know if you depend on that API. Experimental APIs will eventually become
+public, and knowing how they are used helps in determining their maturity.
+
+Prereleases will be stable, in the sense that they will have finished and properly tested
+features only, but may introduce APIs that will change before the final release. Please
+use the prereleases and report bugs, but don't deploy them to production without
+consulting the maintainers, or doing extensive testing yourself. If you do deploy to
+production please let the maintainers know as this helps in determining the maturity of
+the release.
+
+## Known bugs & limitations
+
+* Specifying a `protocol_version` option of 1 or 2 in cluster options will fail with a
+  `NoHostsAvailable` error rather than a `ProtocolError` against Cassandra node versions 3.0-3.4.
+* Because the driver reactor is using `IO.select`, the maximum number of tcp connections allowed is 1024.
+* Because the driver uses `IO#write_nonblock`, Windows is not supported.
+
+Please [refer to the usage documentation for more information on common pitfalls](http://docs.datastax.com/en/developer/ruby-driver/3.1/features/)
+
+## Contributing
+
+For contributing read [CONTRIBUTING.md](https://github.com/yugabyte/cassandra-ruby-driver/blob/master/CONTRIBUTING.md)
+
+## Credits
+
+This driver is based on the original work of [Theo Hultberg](https://github.com/iconara)
+on [cql-rb](https://github.com/iconara/cql-rb/) and adds a series of advanced features
+that are common across all other DataStax drivers for Apache Cassandra.
+
+The development effort to provide an up to date, high performance, fully featured Ruby
+Driver for Apache Cassandra will continue on this project, while
+[cql-rb](https://github.com/iconara/cql-rb/) has been discontinued.
+
+## Copyright
+
+Copyright DataStax, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+except in compliance with the License. You may obtain a copy of the License at
+
+[http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)
+
+Unless required by applicable law or agreed to in writing, software distributed under the
+License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the specific language governing permissions
+and limitations under the License.
+
+  [1]: http://docs.datastax.com/en/developer/ruby-driver/3.1/api

data/ext/cassandra_murmur3/cassandra_murmur3.c

@@ -0,0 +1,178 @@
+// Copyright DataStax, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <ruby.h>
+
+/*-----------------------------------------------------------------------------
+ * MurmurHash3 was written by Austin Appleby, and is placed in the public
+ * domain. The author hereby disclaims copyright to this source code.
+ */
+
+//-----------------------------------------------------------------------------
+// Platform-specific functions and macros
+
+#ifdef _MSC_VER
+typedef unsigned __int64 uint64_t;
+typedef __int64 int64_t;
+
+#define FORCE_INLINE __forceinline
+#else
+#include <stdint.h>
+#ifdef __GNUC__
+#define FORCE_INLINE __attribute__((always_inline)) inline
+#else
+#define FORCE_INLINE inline
+#endif
+#endif
+
+#define BIG_CONSTANT(x) (x##LLU)
+
+static FORCE_INLINE int64_t
+rotl(int64_t x, int8_t r)
+{
+  // cast to unsigned for logical right bitshift (to match C* MM3 implementation)
+  return (x << r) | ((int64_t) (((uint64_t) x) >> (64 - r)));
+}
+
+static FORCE_INLINE int64_t
+getblock(const int64_t* p, int i)
+{
+  return p[i];
+}
+
+static FORCE_INLINE int64_t
+fmix(int64_t k)
+{
+  // cast to unsigned for logical right bitshift (to match C* MM3 implementation)
+  k ^= ((uint64_t) k) >> 33;
+  k *= BIG_CONSTANT(0xff51afd7ed558ccd);
+  k ^= ((uint64_t) k) >> 33;
+  k *= BIG_CONSTANT(0xc4ceb9fe1a85ec53);
+  k ^= ((uint64_t) k) >> 33;
+
+  return k;
+}
+
+static VALUE
+rb_murmur3_hash(VALUE self, VALUE rb_string)
+{
+  char*   bytes;
+  int64_t length;
+
+  Check_Type(rb_string, T_STRING);
+
+  bytes  = RSTRING_PTR(rb_string);
+  length = RSTRING_LEN(rb_string);
+
+  const int nblocks = length / 16;
+  int i;
+
+  int64_t h1 = 0;
+  int64_t h2 = 0;
+
+  int64_t c1 = BIG_CONSTANT(0x87c37b91114253d5);
+  int64_t c2 = BIG_CONSTANT(0x4cf5ad432745937f);
+
+  //----------
+  // body
+
+  const int64_t* blocks = (const int64_t*)(bytes);
+
+  for(i = 0; i < nblocks; i++)
+  {
+    int64_t k1 = getblock(blocks, i * 2 + 0);
+    int64_t k2 = getblock(blocks, i * 2 + 1);
+
+    k1 *= c1;
+    k1  = rotl(k1, 31);
+    k1 *= c2;
+    h1 ^= k1;
+
+    h1  = rotl(h1, 27);
+    h1 += h2;
+    h1  = h1 * 5 + 0x52dce729;
+
+    k2 *= c2;
+    k2  = rotl(k2, 33);
+    k2 *= c1;
+    h2 ^= k2;
+
+    h2  = rotl(h2, 31);
+    h2 += h1;
+    h2  = h2 * 5 + 0x38495ab5;
+  }
+
+  //----------
+  // tail
+
+  const int8_t* tail = (const int8_t*) (bytes + nblocks * 16);
+
+  int64_t k1 = 0;
+  int64_t k2 = 0;
+
+  switch(length & 15)
+  {
+    case 15: k2 ^= ((int64_t) tail[14]) << 48;
+    case 14: k2 ^= ((int64_t) tail[13]) << 40;
+    case 13: k2 ^= ((int64_t) tail[12]) << 32;
+    case 12: k2 ^= ((int64_t) tail[11]) << 24;
+    case 11: k2 ^= ((int64_t) tail[10]) << 16;
+    case 10: k2 ^= ((int64_t) tail[ 9]) << 8;
+    case  9: k2 ^= ((int64_t) tail[ 8]) << 0;
+             k2 *= c2;
+             k2  = rotl(k2, 33);
+             k2 *= c1;
+             h2 ^= k2;
+    case  8: k1 ^= ((int64_t) tail[7]) << 56;
+    case  7: k1 ^= ((int64_t) tail[6]) << 48;
+    case  6: k1 ^= ((int64_t) tail[5]) << 40;
+    case  5: k1 ^= ((int64_t) tail[4]) << 32;
+    case  4: k1 ^= ((int64_t) tail[3]) << 24;
+    case  3: k1 ^= ((int64_t) tail[2]) << 16;
+    case  2: k1 ^= ((int64_t) tail[1]) << 8;
+    case  1: k1 ^= ((int64_t) tail[0]) << 0;
+             k1 *= c1;
+             k1  = rotl(k1, 31);
+             k1 *= c2;
+             h1 ^= k1;
+  };
+
+  //----------
+  // finalization
+
+  h1 ^= length;
+  h2 ^= length;
+
+  h1 += h2;
+  h2 += h1;
+
+  h1 = fmix(h1);
+  h2 = fmix(h2);
+
+  h1 += h2;
+  h2 += h1;
+
+  return LL2NUM(h1);
+}
+
+void
+Init_cassandra_murmur3()
+{
+  VALUE mCassandra, mMurmur3;
+
+  mCassandra = rb_define_module_under(rb_cObject, "Cassandra");
+  mMurmur3   = rb_define_module_under(mCassandra, "Murmur3");
+
+  rb_define_module_function(mMurmur3, "hash", rb_murmur3_hash, 1);
+}

data/ext/cassandra_murmur3/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile('cassandra_murmur3')

data/lib/cassandra/address_resolution.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+#--
+# Copyright DataStax, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#++
+
+module Cassandra
+  # Address Resolution policy allows translating a node ip address from what is
+  # recorded in Cassandra's system tables to an actual ip address for the driver
+  # to use. It is very useful in various multi-region scenarios (e.g. on EC2).
+  module AddressResolution
+    class Policy
+      # Resolves a node ip address.
+      #
+      # @param address [IPAddr] node ip address from Cassandra's system table
+      #
+      # @return [IPAddr] actual ip address of the node
+      def resolve(address)
+      end
+    end
+  end
+end
+
+require 'cassandra/address_resolution/policies'