cassie 1.0.0.beta.21 → 1.0.0.beta.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 44bcb0d0fb09b42a535b4e22a6bbc2b54a92af9a
-  data.tar.gz: 20a5acd5604630f500c9b06ba15804be0e9acf54
+  metadata.gz: 535c984598050fbd5ac382820afbc887b1fd57f5
+  data.tar.gz: 7f1a97fc63a2a53b4947c5f2e0ef43bcdfb594a2
 SHA512:
-  metadata.gz: 18b4e938a675a39a79e63c1dcc6477941a26ac880c077cb4254533f358ceda7acbeff1df015b123652e87c4a1ca19c02d13c7e461dd9acc7e48c5b7b6f64bc17
-  data.tar.gz: 1dcd53f870f9ff37b0878922021648e9b8973b1126f7142dadd4a957fb22f5f9d4c74bd74035d7965958d60c42b623b27d0ce47fb3bf522b9aa50c76e8169795
+  metadata.gz: e627d882bdd46544ccd753fd5b215c6fbb02d913311e3e982b3e4451039b209420d030fcd2fbd0de08bf1dd8da56a56edc74f7b867318381c1296fd392f87df9
+  data.tar.gz: 7f3eed69154aad5ed58fb1463274977462335deaa605fdec9afda5a223f7b213072ac8f1faf76a17a545e5a0539bab46325604fe9155faa0402dc9bf1afa061c

data/lib/cassie/statements/README.md

@@ -96,11 +96,11 @@ Cassie provides 3 base classes for these 3 kinds of queries. Subclass `Cassie::D
   * Adds DSL for `insert_into`, `update`, and `delete_from` statement types
   * Adds support for automatically mapping values for assignments from a domain object
 
-##### `Query`
+##### `Cassie::Query`
   Includes core functionality for prepared statement execution.
 
   * Adds DSL for `select_from` statement type
-  * Adds `fetch` and `fetch_first` methods for executing and getting results in combination
+  * Adds `fetch` and `fetch_first` methods for executing and getting results with a single method call
   * Adds support for deserializing domain objects from Cassandra rows
   * Adds support for paging through results with cursors
   * Adds support for fetching large data sets in memory-efficient batches
@@ -119,7 +119,7 @@ Defining a CQL relation (the `where`) in a cassie query class creates a setter a
 ```ruby
 query.user_id = 123
 query.fetch
-=> [#<Struct user_id=123, id="some post id">]
+#=> [#<Struct user_id=123, id="some post id">]
 ```
 
 <pre><b>
@@ -141,7 +141,7 @@ end
 ```ruby
 query.author = User.new(id: 123)
 query.fetch
-=> [#<Struct user_id=123, id="some post id">]
+#=> [#<Struct user_id=123, id="some post id">]
 ```
 
 <pre><b>
@@ -159,7 +159,7 @@ where :user_id, :eq, value: :author_id
 ```ruby
 query.author_id = 123
 query.fetch
-=> [#<Struct user_id=123, id="some post id">]
+#=> [#<Struct user_id=123, id="some post id">]
 ```
 
 <pre><b>
@@ -181,43 +181,6 @@ Relations can be conditionally evaluated:
 This can be overdone; it's recommended that one query class be in charge of one kind of query. Avoid query classes that can do too much!
 
 
-#### Column Selection (`select`)
-
-```ruby
-  select_from :posts_by_author do |t|
-    t.select :post_id
-    t.select writetime(:post_id)
-  end
-```
-which is the same as
-```ruby
-  select_from :posts_by_author
-
-  select :post_id
-  select writetime(:post_id)
-```
-
-`count`, `write_time` (also aliased as `writetime`), and `ttl` selector helpers are available.
-
-```ruby
-  select_from :posts_by_author
-
-  select count
-```
-```
-=> SELECT COUNT(*) FROM posts_by_author;
-```
-```ruby
-  select_from :posts_by_author
-
-  select :id
-  select ttl(:popular)
-  select writetime(:popular), as: :created_at
-```
-```
-=> SELECT id, TTL(popular), WRITETIME(popular) AS created_at FROM posts_by_author;
-```
-
 #### Values and Assignments (`set`)
 
 Set values (for inserts) and assignments (for updates) with the same `set` method. Similar to relations defined with `where`, assignments provide simple getters and setters.
@@ -246,7 +209,7 @@ end
 query = UpdateUserQuery.new(id: current_user.id)
 query.username = 'eprothro'
 query.execute
-=> true
+#=> true
 ```
 
 Mapping assignemtnt values from a domain object is supported.
@@ -270,7 +233,7 @@ This allows a domain object to be set for the modification object and have assig
 
 ```ruby
 user
-=> #<User:0x007ff8895ce660 @id=6539, @phone="+15555555555", @email="etp@example.com", @address=nil, @username= "etp">
+#=> #<User:0x007ff8895ce660 @id=6539, @phone="+15555555555", @email="etp@example.com", @address=nil, @username= "etp">
 UpdateUserQuery.new(user: user).execute
 ```
 
@@ -300,7 +263,7 @@ class UpdateUserQuery < Cassandra::Modification
 ```
 ```ruby
 user
-=> #<User:0x007ff8895ce660 @id=6539, @phone="+15555555555", @email="etp@example.com", @address=nil, @username= "ETP">
+#=> #<User:0x007ff8895ce660 @id=6539, @phone="+15555555555", @email="etp@example.com", @address=nil, @username= "ETP">
 UpdateUserQuery.new(user: user).execute
 ```
 
@@ -336,20 +299,79 @@ end
 
 > Note: The `term` option should be used with care. Using it innapropriately could result in inefficient use of prepared statements, and/or leave you potentially vulnerable to injection attacks.
 
+
+#### Column Selection (`select`)
+
+By default, all columns will be selected (e.g. '*'). Specify a column for selection with `select`.
+
+```ruby
+  select_from :posts_by_author do |t|
+    t.select :post_id
+    t.select writetime(:post_id)
+  end
+```
+which is the same as
+```ruby
+  select_from :posts_by_author
+
+  select :post_id
+  select writetime(:post_id)
+```
+
+`count`, `write_time` (also aliased as `writetime`), and `ttl` selector helpers are available.
+
+```ruby
+  select_from :posts_by_author
+
+  select count
+```
+```
+#=> SELECT COUNT(*) FROM posts_by_author;
+```
+
+Aliasing is supported with the `as` option.
+```ruby
+  select_from :posts_by_author
+
+  select :id
+  select ttl(:popular)
+  select writetime(:popular), as: :created_at
+```
+```
+#=> SELECT id, TTL(popular), WRITETIME(popular) AS created_at FROM posts_by_author;
+```
+Arbitrary strings are supported as well in case the DSL gets in the way.
+
+```ruby
+  select_from :posts_by_author
+
+  select 'cowboy, coder'
+```
+```
+#=> SELECT cowboy, coder FROM posts_by_author;
+```
+
 #### Consistency configuration
 
 The [consistency level](http://datastax.github.io/ruby-driver/v2.1.6/api/cassandra/#consistencies-constant) for a query is determined by your `Cassie::configuration` by default, falling to back to the `Cassandra` default if none is given.
 
 ```ruby
 Cassie.configuration[:consistency]
-=> nil
+#=> nil
 
 Cassie.cluster.instance_variable_get(:@execution_options).consistency
-=> :one
+#=> :one
 ```
 
-Cassie queries allow for a consistency level defined on the object, subclass, then base class levels. If one is found, it will override the `Cassandra` default when the query is executed.
+Cassie queries allow for a consistency level to be defined on the object, subclass, base class, and global levels. If none is found, it will default to the `cluster` default when the query is executed.
 
+Object writer:
+```ruby
+  query = MyQuery.new
+  query.consistency = :all
+  query.execute
+```
+Override Object reader:
 ```ruby
   select_from :posts_by_author_category
 
@@ -370,6 +392,7 @@ Cassie queries allow for a consistency level defined on the object, subclass, th
   end
 ```
 
+Class writer
 ```ruby
   select_from :posts_by_author_category
 
@@ -379,45 +402,85 @@ Cassie queries allow for a consistency level defined on the object, subclass, th
   consistency :quorum
 ```
 
+Cassie query classes
 ```ruby
 # lib/tasks/interesting_task.rake
 require_relative "interesting_worker"
 
 task :interesting_task do
-  Cassandra::Query.consistency = :all
+  Cassie::Modification.consistency = :all
 
   InterestingWorker.new.perform
 end
 ```
 
+Cassie global default
+```ruby
+# lib/tasks/interesting_task.rake
+require_relative "interesting_worker"
+
+task :interesting_task do
+  Cassie::Statements.default_consistency = :all
+
+  InterestingWorker.new.perform
+end
+```
+
+#### Execution and Result
+
+Executing a `Cassie::Query` populates the `result` attribute.
+
+```ruby
+query.execute
+# => true
+query.result.class
+# => Cassie::Statements::Results::QueryResult
+```
+
+The result lazily enumerates domain objects
+```ruby
+query.execute
+#=> true
+query.result.each
+#=> #<[#< Struct id=:123, username=:eprothro >]>
+```
+
+The result also delegates to the `Cassandra::Result`.
+```ruby
+query.result.execution_info
+#=> #<Cassandra::Execution::Info:0x007fb404b51390 @payload=nil, @warnings=nil, @keyspace="cassie_test", @statement=#<Cassandra::Statements::Bound:0x3fda0258dee8 @cql="SELECT * FROM users_by_username LIMIT 500;" @params=[]>, @options=#<Cassandra::Execution::Options:0x007fb404b1b880 @consistency=:local_one, @page_size=10000, @trace=false, @timeout=12, @serial_consistency=nil, @arguments=[], @type_hints=[], @paging_state=nil, @idempotent=false, @payload=nil>, @hosts=[#<Cassandra::Host:0x3fda02541390 @ip=127.0.0.1>], @consistency=:local_one, @retries=0, @trace=nil>
+query.result.rows
+#=> #<Enumerator: [{"id"=>123, "username"=>"eprothro"}]>
+```
+
 #### Finders
 
 To avoid confusion with ruby `Enumerable#find` and Rails' specific `find` functionality, Cassie::Query opts to use `fetch` and explict `fetch_first` or `fetch_first!` methods.
 
 ##### `fetch`
 
-Executes the query; returns an enumeration of results.
+Calls setters for any opts passed, executes the query, and returns the result.
 
-```
+```ruby
 UsersByResourceQuery.new.fetch(resource: some_resource).to_a
-=> [#<User id=:123, username=:eprothro>, #<User id=:456, username=:tenderlove>]
+#=> [#<User id=:123, username=:eprothro>, #<User id=:456, username=:tenderlove>]
 ```
 
 ##### `fetch_first` and `fetch_first!`
 
-Executes the query, temporarily limited to 1 result; returns a single result. Bang version raises if no result is found.
+Temporarily limits the query to 1 result; returns a single domain object. Bang version raises if no row is found.
 
-```
-UsersByUsernameQuery.new.fetch_first(username: "eprothro").username
-=> "eprothro"
+```ruby
+UsersByUsernameQuery.new.fetch_first(username: "eprothro")
+#=> #<User id=:123, username=:eprothro>
 ```
 
-```
+```ruby
 UsersByUsernameQuery.new.fetch_first(username: "ActiveRecord")
-=> nil
+#=> nil
 ```
 
-```
+```ruby
 UsersByUsernameQuery.new.fetch_first!(username: "active record").username
 Cassie::Statements::RecordNotFound: CQL row does not exist
 ```
@@ -428,19 +491,19 @@ Similar to [Rails BatchedFetching](http://guides.rubyonrails.org/v4.2/active_rec
 
 ###### `fetch_each`
 
-```
+```ruby
 UsersQuery.new.fetch_each do |user|
   # only 1000 queried and loaded at a time
 end
 ```
 
-```
+```ruby
 UsersQuery.new.fetch_each(batch_size: 500) do |user|
   # only 500 queried and loaded at a time
 end
 ```
 
-```
+```ruby
 UsersQuery.new.fetch_each.with_index do |user, index|
   # Enumerator chaining without a block
 end
@@ -448,19 +511,19 @@ end
 
 ###### `fetch_in_batches`
 
-```
+```ruby
 UsersQuery.new.fetch_in_batches do |users_array|
   # only 1000 queried and at a time
 end
 ```
 
-```
+```ruby
 UsersQuery.new.fetch_in_batches(batch_size: 500) do |users_array|
   # only 500 queried and at a time
 end
 ```
 
-```
+```ruby
 UsersQuery.new.fetch_in_batches.with_index do |group, index|
   # Enumerator chaining without a block
 end
@@ -468,19 +531,19 @@ end
 
 #### Deserialization
 
-For Selection Queries, records are deserialized as anonymous structs by default. Each field returned from the database will have an accessor.
+For `Cassie::Query` classes, records are deserialized as anonymous structs by default. Each field returned from the database will have an accessor.
 
 ```ruby
 UsersByUsernameQuery.new.fetch(username: "eprothro")
 #=> [#<Struct id=:123, username=:eprothro>]
 
-UsersByUsernameQuery.new.fetch_first(username: "eprothro").username
-=> "eprothro"
+UsersByUsernameQuery.new.fetch_first!(username: "eprothro").username
+#=> "eprothro"
 ```
 
 Most applications will want to override `build_result` to construct more useful domain objects
 
-```
+```ruby
 class UsersByUsernameQuery < Cassie::Query
 
   select_from :users_by_username
@@ -495,10 +558,10 @@ end
 
 ```ruby
 UsersByUsernameQuery.new.fetch_first(username: "eprothro")
-=> #<User:0x007fedec219cd8 @id=123, @username="eprothro">
+#=> #<User:0x007fedec219cd8 @id=123, @username="eprothro">
 ```
 
-`build_results` may be overridden as well to define completely custom processing of the rows that come back from Cassandra.
+`build_results` may be overridden as well to define custom definition of the enumeration of rows returned from Cassandra.
 
 #### Cursored paging
 
@@ -614,14 +677,14 @@ class RecordsByOwnerQuery < Cassie::Query
   end
 end
 ```
-```
+```ruby
 RecordsByOwnerQuery.new(owner: owner, min_record: 99,990).fetch.map(&:record)
 (2.9ms) SELECT * FROM records_by_owner WHERE owner_id = ? AND bucket = ? AND record >= ? LIMIT 100; [123, 0, 99990]
 (2.9ms) SELECT * FROM records_by_owner WHERE owner_id = ? AND bucket = ? AND record >= ? LIMIT 100; [123, 1, 99990]
-=> [99990, 99991, ..., 100089, 100090]
+#=> [99990, 99991, ..., 100089, 100090]
 ```
 
-The first partition queried is defined within the query class (bucket 0). The linking policy handles recognizing the end of the first partition has been reached, issuing the second query that switches to the second partition (bucket 1), and combining the results from both queries.
+The first partition queried is defined within the query class (bucket 0). The linking policy handles recognizing the end of the first partition has been reached, issuing the second query for the second partition (bucket 1), and combining the results from both queries.
 
 By default, this works for ascending and descending orderings when paging in the same order as the clustering order; it also works with cursoring.
 
@@ -629,9 +692,9 @@ Custom policies can be defined by setting `Query.partition_linker` for more comp
 
 #### Prepared statements
 
-A `Cassie::Query` will use prepared statements by default, cacheing prepared statements across all Cassie::Query objects, keyed by the bound CQL string.
+A `Cassie::Query` will use prepared statements by default, cacheing prepared statements across all `Query`, `Modification`, and `Definition` objects, keyed by the unbound CQL string.
 
-To not use prepared statements for a particular query, disable the `.prepare` class option.
+To disable prepared statements for a particular query, disable the `.prepare` class option.
 
 ```ruby
 class MySpecialQuery < Cassie::Query
@@ -657,9 +720,9 @@ set_1 = query.fetch([1, 2, 3])
 set_2 = query.fetch([7, 8, 9, 10, 11, 12])
 ```
 
-#### Unbound statements
+#### Non-positional (unbound) statements
 
-Cassie Query features are built around bound statements. However, overriding `#statement`, returning something that a `Cassandra::Session` can execute an unbound statement.
+Cassie Query features are built around using bound statements with positional arguments. However, overriding `#statement`, returning something that a `Cassandra::Session` can execute, will result in an unbound, unprepared statement.
 
 ```ruby
 class MySafeQuery < Cassie::Definition
@@ -669,7 +732,7 @@ class MySafeQuery < Cassie::Definition
 end
 ```
 
-> Note: unbound queries may be vulnerable to injection attacks.
+> Note: unbound queries can be vulnerable to injection attacks. Be careful.
 
 #### Logging
 

data/lib/cassie/statements/execution/consistency.rb

@@ -1,5 +1,14 @@
-module Cassie::Statements::Execution
-  module Consistency
+module Cassie::Statements
+  def self.default_consistency
+    return @default_consistency if defined?(@default_consistency)
+    nil
+  end
+
+  def self.default_consistency=(val)
+    @default_consistency = val
+  end
+
+  module Execution::Consistency
     extend ActiveSupport::Concern
 
     included do
@@ -8,7 +17,7 @@ module Cassie::Statements::Execution
 
     module ClassMethods
       def inherited(subclass)
-        subclass.consistency = consistency
+        subclass.consistency = consistency if defined?(@consistency)
         super
       end
 
@@ -18,7 +27,8 @@ module Cassie::Statements::Execution
 
       def consistency(val=:get)
         if val == :get
-          @consistency if defined?(@consistency)
+          return @consistency if defined?(@consistency)
+          Cassie::Statements.default_consistency
         else
           self.consistency = val
         end

data/lib/cassie/version.rb

@@ -0,0 +1,3 @@
+module Cassie
+  VERSION = "1.0.0.beta.22"
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cassie
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta.21
+  version: 1.0.0.beta.22
 platform: ruby
 authors:
 - Evan Prothro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-12 00:00:00.000000000 Z
+date: 2016-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cassandra-driver
@@ -58,6 +58,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.3'
+- !ruby/object:Gem::Dependency
+  name: gem-release
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.4
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
@@ -190,6 +218,7 @@ files:
 - lib/cassie/testing/fake/result.rb
 - lib/cassie/testing/fake/session.rb
 - lib/cassie/testing/fake/session_methods.rb
+- lib/cassie/version.rb
 homepage: https://github.com/eprothro/cassie
 licenses:
 - MIT