cql-rb 2.0.0.rc0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b5d95e28951fcb350531d0899c6a4b12938677c9
-  data.tar.gz: 271b515465def1838737f6d92983958f47541f09
+  metadata.gz: fddc76ac77bf418eab2dfd497c342b5104481a99
+  data.tar.gz: f8b91abc145bf42ff716fb0af17b50d3a24b19cd
 SHA512:
-  metadata.gz: 89b8043dc895260cb8baee75a43652d7150574141863a876a663fb2427672b36ba970f3837813800edd4f106e5fc56d053d75dca2c26889ab0a25b110846a660
-  data.tar.gz: 2d910f7d38e3bb0851c6a43b1146d01f84b6c7b5c5d33682bd587dd2b0f4eb2127e5fc26798a491a4b03730fc8a16fa756bbe19445f2ddfb1b3910b8487dc51b
+  metadata.gz: 8af6c7c7acc157843d1f0f0c101a2a42da30e8f0433f7d53f870a1ceadbf233416dfa2254af425a35ecc6a3c8aa2b6a54e4ad82c3cb0b342526d792e9b7ea06d
+  data.tar.gz: 7f3472cda89cccb1674424a7bcef58bd52cdaacfa579eba56c83c6dbf2d826b4fe2ca0707c8b94eff2009e6b6377f514655ba49c8a80286adacb4b691c8c3185

data/README.md

@@ -134,10 +134,14 @@ The driver supports prepared statements. Use `#prepare` to create a statement ob
 
 ```ruby
 statement = client.prepare('SELECT date, description FROM events WHERE id = ?')
-rows = statement.execute(1235)
+
+[123, 234, 345].each do |id|
+  rows = statement.execute(id)
+  # ...
+end
 ```
 
-A prepared statement can be run many times, but the CQL parsing will only be done once. Use prepared statements for queries you run over and over again.
+A prepared statement can be run many times, but the CQL parsing will only be done once on each node. Use prepared statements for queries you run over and over again.
 
 `INSERT`, `UPDATE`, `DELETE` and `SELECT` statements can be prepared, other statements may raise `QueryError`.
 
@@ -190,28 +194,6 @@ client.batch(:counter) do |batch|
 end
 ```
 
-You can also specify the regular options such as consistency, timeout and whether or not to enable tracing:
-
-```ruby
-client.batch(:unlogged, trace: true) do |batch|
-  # ...
-end
-
-client.batch(trace: true, consistency: :all) do |batch|
-  # ...
-end
-
-batch = client.batch
-# ...
-batch.execute(consistency: :quorum)
-
-batch = client.batch(trace: true)
-# ...
-batch.execute(consistency: :quorum)
-```
-
-As you can see you can specify the options either when creating the batch or when sending it (when using the variant where you call `#execute` yourself). The options given to `#execute` take precedence. You can omit the batch type and specify the options as the only parameter when you want to use the the default batch type.
-
 If you want to execute the same prepared statement multiple times in a batch there is a special variant of the batching feature available from `PreparedStatement`:
 
 ```ruby
@@ -247,19 +229,28 @@ You can specify the default consistency to use when you create a new `Client`:
 client = Cql::Client.connect(hosts: %w[localhost], default_consistency: :all)
 ```
 
-The `#execute` (of `Client` and `PreparedStatement`) method also supports setting the desired consistency level on a per-request basis:
+The `#execute` (of `Client`, `PreparedStatement` and `Batch`) method also supports setting the desired consistency level on a per-request basis:
 
 ```ruby
-client.execute('SELECT * FROM peers', consistency: :local_quorum)
-```
+client.execute('SELECT * FROM users', consistency: :local_quorum)
 
-for backwards compatibility with v1.0 you can also pass the consistency as just a symbol:
+statement = client.prepared('SELECT * FROM users')
+statement.execute(consistency: :one)
 
-```ruby
-client.execute('SELECT * FROM peers', :local_quorum)
+batch = client.batch
+batch.add("UPDATE users SET email = 'sue@foobar.com' WHERE id = 'sue'")
+batch.add("UPDATE users SET email = 'tom@foobar.com' WHERE id = 'tom'")
+batch.execute(consistency: :all)
+
+batch = client.batch(consistency: :quorum) do |batch|
+  batch.add("UPDATE users SET email = 'sue@foobar.com' WHERE id = 'sue'")
+  batch.add("UPDATE users SET email = 'tom@foobar.com' WHERE id = 'tom'")
+end
 ```
 
-The possible values for consistency are: 
+For batches the options given to `#execute` take precedence over options given to `#batch`.
+
+The possible values for consistency are:
 
 * `:any`
 * `:one`
@@ -300,6 +291,20 @@ client = Cql::Client.connect(logger: Logger.new($stderr))
 
 Most of the logging will be when the driver connects and discovers new nodes, when connections fail and so on, but also when statements are prepared. The logging is designed to not cause much overhead and only relatively rare events are logged (e.g. normal requests are not logged).
 
+## Tracing
+
+You can request that Cassandra traces a request and records what each node had to do to process the request. To request that a query is traced you can specify the `:trace` option to `#execute`. The request will proceed as normal, but you will also get a trace ID back in your response. This ID can then be used to load up the trace data:
+
+```ruby
+result = client.execute("SELECT * FROM users", trace: true)
+session_result = client.execute("SELECT * FROM system_traces.sessions WHERE session_id = ?", result.trace_id, consistency: :one)
+events_result = client.execute("SELECT * FROM system_traces.events WHERE session_id = ?", result.trace_id, consistency: :one)
+```
+
+Notice how you can query tables in other keyspaces by prefixing their names with the keyspace name.
+
+The `system_traces.sessions` table contains information about the request itself; which node was the coordinator, the CQL, the total duration, etc. (if the `duration` column is `null` the trace hasn't been completely written yet and you should load it again later). The `events` table contains information about what happened on each node and at what time. Note that each event only contains the number of seconds that elapsed from when the node started processing the request – you can't easily sort these events in a global order.
+
 ## Thread safety
 
 Except for results and batches everything in cql-rb is thread safe. You only need a single client object in your application, in fact creating more than one is a bad idea. Similarily prepared statements are thread safe and should be shared.
@@ -370,7 +375,7 @@ Please open an issue. It should be working, but it's hard to set up and write au
 
 If you are using DataStax Enterprise earlier than 3.1 authentication is unfortunately not supported. Please open an issue and we might be able to get it working, I just need someone who's willing to test it out. DataStax backported the authentication from Cassandra 2.0 into DSE 3.0, even though it only uses Cassandra 1.2. The authentication logic might not be able to handle this and will try to authenticate with DSE using an earlier version of the protocol. In short, DSE before 3.1 uses a non-standard protocol, but it should be possible to get it working. DSE 3.1 and 4.0 have been confirmed to work.
 
-## I'm connecting to port 9160 and it doesn't work
+## I get "end of file reached" / I'm connecting to port 9160 and it doesn't work
 
 Port 9160 is the old Thrift interface, the binary protocol runs on 9042. This is also the default port for cql-rb, so unless you've changed the port in `cassandra.yaml`, don't override the port.
 
@@ -410,7 +415,7 @@ Compression works best for large requests, so if you use batching you should ben
 
 # Try experimental features
 
-To get maximum performance you can't wait for a request to complete before sending the next. At it's core cql-rb embraces this completely and uses non-blocking IO and a completely asynchronous model for the request processing. The synchronous API that you use is just a thin façade on top that exists for convenience. If you need to scale to thousands of requests per second, have a look at the client code and look at the asynchronous core, it works very much like the public API, _but using it they should be considererd **experimental**_. Experimental in this context does not mean buggy, it is the core of cql-rb after all, but it means that you cannot rely on it being backwards compatible.
+To get maximum performance you can't wait for a request to complete before sending the next. At it's core cql-rb embraces this completely and uses non-blocking IO and an asynchronous model for the request processing. The synchronous API that you use is just a thin façade on top that exists for convenience. If you need to scale to thousands of requests per second, have a look at the client code and look at the asynchronous core, it works very much like the public API, _but using it they should be considererd **experimental**_. Experimental in this context does not mean buggy, it is the core of cql-rb after all, but it means that you cannot rely on it being backwards compatible.
 
 # Changelog & versioning
 

data/lib/cql/time_uuid.rb

@@ -11,21 +11,35 @@ module Cql
     # @return [Time]
     #
     def to_time
-      n = (value >> 64)
-      t = 0
-      t |= (n & 0x0000000000000fff) << 48
-      t |= (n & 0x00000000ffff0000) << 16
-      t |= (n & 0xffffffff00000000) >> 32
-      t -= GREGORIAN_OFFSET
+      t = time_bits - GREGORIAN_OFFSET
       seconds = t/10_000_000
       microseconds = (t - seconds * 10_000_000)/10.0
       Time.at(seconds, microseconds).utc
     end
 
     def <=>(other)
-      self.value <=> other.value
+      c = self.time_bits <=> other.time_bits
+      return c unless c == 0
+      (self.value & LOWER_HALF_MASK) <=> (other.value & LOWER_HALF_MASK)
     end
 
+    protected
+
+    def time_bits
+      n = (value >> 64)
+      t = 0
+      t |= (n & 0x0000000000000fff) << 48
+      t |= (n & 0x00000000ffff0000) << 16
+      t |= (n & 0xffffffff00000000) >> 32
+      t
+    end
+
+    private
+
+    LOWER_HALF_MASK = 0xffffffff_ffffffff
+
+    public
+
     # A UUID version 1, variant 1 generator. It can generate a sequence of UUIDs
     # with reasonable uniqueness guarantees:
     #

data/lib/cql/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Cql
-  VERSION = '2.0.0.rc0'.freeze
+  VERSION = '2.0.0'.freeze
 end

data/spec/cql/time_uuid_spec.rb

@@ -14,14 +14,18 @@ module Cql
     end
 
     describe '#<=>' do
+      let :generator do
+        TimeUuid::Generator.new
+      end
+
       let :uuids do
         [
-          TimeUuid.new(175821750227570343682790694234162314858),
-          TimeUuid.new(179047849699804924671695969702288932458),
-          TimeUuid.new(179548637446269962124687370109891231338),
-          TimeUuid.new(180030188594876536196511058046351949418),
-          TimeUuid.new(180518394909134308472692603674640891498),
-          TimeUuid.new(183319310901264713895398493985212841578),
+          generator.from_time(Time.utc(2014, 5,  1,  2, 3, 4, 1), 0),
+          generator.from_time(Time.utc(2014, 5,  1,  2, 3, 4, 2), 0),
+          generator.from_time(Time.utc(2014, 5,  1,  2, 3, 5, 0), 0),
+          generator.from_time(Time.utc(2014, 5, 11, 14, 3, 4, 0), 0),
+          generator.from_time(Time.utc(2014, 5, 20,  2, 3, 4, 0), 0),
+          generator.from_time(Time.utc(2014, 6,  7,  2, 3, 4, 0), 0),
         ]
       end
 

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: cql-rb
 version: !ruby/object:Gem::Version
-  version: 2.0.0.rc0
+  version: 2.0.0
 platform: ruby
 authors:
 - Theo Hultberg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-17 00:00:00.000000000 Z
+date: 2014-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ione
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1'
 description: A pure Ruby CQL3 driver for Cassandra
 email:
 - theo@iconara.net
@@ -163,9 +163,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.1