cassandra_model 0.9.21 → 1.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: da8cdc27700ca95add22df7ece2de9e050a09642
-  data.tar.gz: 7a9a39c9bd2bf63bb9dc03442461b5f860c95718
+  metadata.gz: 8caf227ae8b22d30047431ce0293f39a965c07aa
+  data.tar.gz: b03cf72cb34c9d9fa8f9e18ee4930f8e7574639a
 SHA512:
-  metadata.gz: c7a028e42484dd36523c86934ef8b9d79045354d720159cc1ab75fadb8cd9e150f2921d40b58038c2ecdd54bff87a80a07ff2fedd83ff976952ce4e5a3b0a484
-  data.tar.gz: 39dd8d3525696fc4d183a9b5f077d0cfb24f74da2d86d3c8eeba0db843d023b1257bb38d4c61f9f62da4d6c366769b8d5a722dd83e1eb53d9d0f8e1630a1928d
+  metadata.gz: e1d04f2b752b5509709bebfe0fe5e2c3ec79a57876ad4a246858e1ff2a3dc14aa27d342db54b90bf2e00a0e20c726b636511f2dd09b960c8ffbf7fc1fa76168a
+  data.tar.gz: 06b8f1d4f77529b16b0a530c0c981a2025313b20280c0627a71ef8c00ee6acc31ca0692ed89e8d99e746fe670c393ab67c8c427035b48fa8d1ae7037c60ad1c6

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright 2014-2015 Thomas RM Rogers
+Copyright 2014-2016 Thomas RM Rogers
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
@@ -10,4 +10,4 @@ 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.
+limitations under the License.

data/README.md

@@ -155,7 +155,7 @@ There are a number of features in Cassandra Model that may have missing or incom
 
 ## Copyright
 
-Copyright 2014-2015 Thomas Rogers.
+Copyright 2014-2016 Thomas Rogers.
 
 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
 

data/lib/cassandra_model.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright 2014-2015 Thomas RM Rogers
+# Copyright 2014-2016 Thomas RM Rogers
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -23,6 +23,7 @@ require 'batch_reactor'
 require 'active_support/all'
 require 'active_support/core_ext/class/attribute_accessors'
 
+require 'cassandra_model/session_compatibility'
 require 'cassandra_model/concurrency_helper'
 require 'cassandra_model/logging'
 require 'cassandra_model/global_callbacks'
@@ -39,9 +40,13 @@ require 'cassandra_model/table_definition'
 require 'cassandra_model/table_debug'
 require 'cassandra_model/table_redux'
 require 'cassandra_model/result_paginator'
+require 'cassandra_model/result_limiter'
+require 'cassandra_model/result_chunker'
+require 'cassandra_model/result_reducer'
 require 'cassandra_model/query_result'
 require 'cassandra_model/query_builder'
 require 'cassandra_model/displayable_attributes'
+require 'cassandra_model/scopes'
 require 'cassandra_model/record_debug'
 require 'cassandra_model/record'
 require 'cassandra_model/counter_record'

data/lib/cassandra_model/batch_reactor.rb

@@ -25,7 +25,7 @@ module CassandraModel
     def batch_callback(_)
       batch = @batch_klass.new
       yield batch
-      @session.execute_async(batch).on_success { |result| batch.result = result }
+      @session.execute_async(batch).then { |result| batch.result = result }
     end
 
   end

data/lib/cassandra_model/composite_record.rb

@@ -1,7 +1,17 @@
 module CassandraModel
+  module CompositeCounterRecord
+    def increment_async!(counts)
+      futures = composite_rows.map { |record| record.internal_increment_async!(counts) }
+
+      futures << internal_increment_async!(counts)
+      Cassandra::Future.all(futures).then { self }
+    end
+  end
+
   module CompositeRecord
     def self.included(klass)
       klass.extend CompositeRecordStatic
+      klass.send(:include, CompositeCounterRecord) if klass < CounterRecord
     end
 
     def save_async(options = {})
@@ -44,7 +54,7 @@ module CassandraModel
 
     def internal_attributes
       internal_columns.inject({}) do |memo, column|
-        memo.merge(column => attribute(column))
+        memo.merge!(column => attribute(column))
       end
     end
   end

data/lib/cassandra_model/composite_record_static.rb

@@ -1,30 +1,33 @@
 module CassandraModel
+  #noinspection ALL
   module CompositeRecordStatic
-    MUTEX = Mutex.new
-
     extend Forwardable
 
     def_delegator :table_config, :composite_defaults=
+    
+    def self.extended(base)
+      base.instance_variable_set(:@mutex, Mutex.new)
+    end
 
     def partition_key
-      table_data.composite_partition_key ||= internal_partition_key.map { |column| trimmed_column(column, /^rk_/, composite_pk_map) || column }
+      table_data.composite_partition_key ||= internal_partition_key.map { |column| trim_column!(column, /^rk_/, composite_pk_map) || column }
     end
 
     def clustering_columns
-      table_data.composite_clustering_columns ||= internal_clustering_columns.map { |column| trimmed_column(column, /^ck_/, composite_ck_map) || column }
+      table_data.composite_clustering_columns ||= internal_clustering_columns.map { |column| trim_column!(column, /^ck_/, composite_ck_map) || column }
     end
 
     def primary_key
       table_data.composite_primary_key ||= (internal_partition_key + internal_clustering_columns).map do |column|
-        trimmed_column(column, /^rk_/, composite_pk_map) ||
-            trimmed_column(column, /^ck_/, composite_ck_map) ||
+        trim_column!(column, /^rk_/, composite_pk_map) ||
+            trim_column!(column, /^ck_/, composite_ck_map) ||
             column
       end.uniq
     end
 
     def columns
       unless table_data.composite_columns
-        MUTEX.synchronize do
+        @mutex.synchronize do
           return table_data.composite_columns if table_data.composite_columns
 
           table_data.composite_pk_map = {}
@@ -37,6 +40,20 @@ module CassandraModel
 
     alias :ensure_attributes_accessible! :columns
 
+    def denormalized_column_map(input_columns)
+      internal_columns.inject({}) do |memo, column|
+        result_column = input_columns.find { |input_column| input_column == column }
+        unless result_column
+          trimmed_column = trimmed_column(column, /^rk_/) ||
+              trimmed_column(column, /^ck_/) ||
+              column
+          result_column = input_columns.find { |input_column| input_column == trimmed_column }
+        end
+        memo[column] = result_column if result_column
+        memo
+      end
+    end
+
     def composite_pk_map
       ensure_attributes_accessible! unless table_data.composite_columns
       table_data.composite_pk_map
@@ -122,22 +139,27 @@ module CassandraModel
 
     def composite_columns
       internal_columns.map do |column|
-        trimmed_column(column, /^rk_/, table_data.composite_pk_map) ||
-            trimmed_column(column, /^ck_/, table_data.composite_ck_map) ||
+        trim_column!(column, /^rk_/, table_data.composite_pk_map) ||
+            trim_column!(column, /^ck_/, table_data.composite_ck_map) ||
             column
       end.uniq
     end
 
-    def trimmed_column(column, column_trim, map)
-      column_str = column.to_s
-      if column_str =~ column_trim
-        column_str.gsub(column_trim, '').to_sym.tap do |result_column|
+    def trim_column!(column, column_trim, map)
+      trimmed_column = trimmed_column(column, column_trim)
+      if trimmed_column
+        trimmed_column.tap do |result_column|
           map[result_column] = column
           map[column] = result_column
         end
       end
     end
 
+    def trimmed_column(column, column_trim)
+      column_str = column.to_s
+      column_str.gsub(column_trim, '').to_sym if column_str =~ column_trim
+    end
+
     def select_clause(select)
       select = select_columns(select) if select
       super(select)

data/lib/cassandra_model/counter_record.rb

@@ -2,6 +2,20 @@ module CassandraModel
   class CounterRecord < Record
 
     def increment_async!(options)
+      internal_increment_async!(options)
+    end
+
+    def increment!(options)
+      increment_async!(options).get
+    end
+
+    protected
+
+    def internal_save_async(options = {})
+      raise NotImplementedError
+    end
+
+    def internal_increment_async!(options)
       counter_clause = counter_clause(options)
       row_key = internal_primary_key.values
       statement = increment_statement(counter_clause)
@@ -22,14 +36,6 @@ module CassandraModel
       end.then { self }
     end
 
-    def increment!(options)
-      increment_async!(options).get
-    end
-
-    def save_async
-      raise NotImplementedError
-    end
-
     private
 
     def internal_primary_key

data/lib/cassandra_model/data_modelling.rb

@@ -5,6 +5,10 @@ module CassandraModel
       base.send(:include, CompositeRecord)
     end
 
+    def table_properties=(value)
+      @table_properties = value
+    end
+
     def model_data
       inquirer = DataInquirer.new
       data_set = DataSet.new
@@ -17,6 +21,13 @@ module CassandraModel
                    end
 
       generate_composite_defaults_from_inquirer(inquirer)
+      columns
+    end
+
+    def serialized_column(column, serializer)
+      serialized_column = :"#{column}_data"
+      deferred_column column, on_load: ->(attributes) { serializer.load(attributes[serialized_column]) if attributes[serialized_column] },
+                      on_save: ->(attributes, value) { attributes[serialized_column] = (serializer.dump(value) if value) }
     end
 
     private
@@ -37,9 +48,9 @@ module CassandraModel
     end
 
     def meta_table(table_name, inquirer, data_set)
-      table_definition = CassandraModel::TableDefinition.from_data_model(table_name, inquirer, data_set)
+      table_definition = CassandraModel::TableDefinition.from_data_model(table_name, inquirer, data_set, @table_properties)
       CassandraModel::MetaTable.new(table_config.connection_name, table_definition)
     end
 
   end
-end
+end

data/lib/cassandra_model/data_set.rb

@@ -2,12 +2,13 @@ module CassandraModel
   class DataSet
     include TypeGuessing
 
-    attr_reader :columns, :clustering_columns, :data_rotation
+    attr_reader :columns, :data_rotation, :clustering_order
 
     def initialize
       @columns = Hash.new { |hash, key| hash[key] = :text }
       @data_rotation = {}
       @clustering_columns = []
+      @clustering_order = {}
     end
 
     def knows_about(*columns)
@@ -34,7 +35,7 @@ module CassandraModel
 
     def is_defined_by(*columns)
       knows_about(*columns)
-      @clustering_columns = columns
+      clustering_columns.concat(columns)
     end
 
     def change_type_of(column)
@@ -42,6 +43,16 @@ module CassandraModel
       ColumnType.new(column, self)
     end
 
+    def sorts(sorting)
+      unknown_column = sorting.keys.find { |column, _| !columns.include?(column) }
+      raise "Cannot sort unknown column #{unknown_column}" if unknown_column
+      clustering_order.merge!(sorting)
+    end
+
+    def clustering_columns
+      @clustering_columns ||= []
+    end
+
     private
 
     def count_column(column)

data/lib/cassandra_model/meta_table.rb

@@ -11,7 +11,7 @@ module CassandraModel
 
     def name
       @name ||= begin
-        create_table
+        table
         name_in_cassandra
       end
     end
@@ -28,7 +28,7 @@ module CassandraModel
     private
 
     def table
-      @table ||= create_table
+      keyspace.table(name_in_cassandra) || create_table
     end
 
     def keyspace
@@ -42,7 +42,13 @@ module CassandraModel
         sleep 0.100
         break if keyspace.table(name_in_cassandra)
       end
-      keyspace.table(name_in_cassandra) or raise "Could not verify the creation of table #{name_in_cassandra}"
+
+      keyspace.table(name_in_cassandra).tap do |table|
+        unless table
+          descriptor.delete
+          raise "Could not verify the creation of table #{name_in_cassandra}"
+        end
+      end
     end
 
     def create_cassandra_table(descriptor)

data/lib/cassandra_model/mock_connection.rb

@@ -1,15 +1,7 @@
 module CassandraModel
   class RawConnection
     def cluster
-      @cluster ||= begin
-        Cassandra::Mocks::Cluster.new.tap do |cluster|
-          cluster.add_keyspace(config[:keyspace])
-        end
-      end
-    end
-
-    def session
-      @session ||= Cassandra::Mocks::Session.new(config[:keyspace], cluster)
+      @cluster ||= Cassandra::Mocks::Cluster.new
     end
   end
 end

data/lib/cassandra_model/query_builder.rb

@@ -3,12 +3,13 @@ module CassandraModel
     include Enumerable
     extend Forwardable
 
-    def_delegator :async, :each
+    EMPTY_OPTION = [].freeze
 
-    def initialize(record_klass)
+    def initialize(record_klass, params = {}, options = {}, extra_options = {})
       @record_klass = record_klass
-      @params = {}
-      @options = {}
+      @params = params
+      @options = options
+      @extra_options = extra_options
     end
 
     def async
@@ -59,8 +60,7 @@ module CassandraModel
     end
 
     def check_exists
-      @options.merge!(check_exists: true)
-      self
+      new_instance(@params, @options.merge(check_exists: true), @extra_options)
     end
 
     def pluck(*columns)
@@ -73,12 +73,34 @@ module CassandraModel
     end
 
     def each_slice(slice_size = nil, &block)
+      raise NotImplementedError if @extra_options[:cluster]
       paginate(slice_size).async.each_slice(&block)
     end
 
+    def each(&block)
+      if @extra_options[:cluster]
+        enum = ResultChunker.new(async, @extra_options[:cluster])
+        enum = if @extra_options[:cluster_limit]
+          ResultLimiter.new(enum, @extra_options[:cluster_limit])
+        else
+          enum
+        end
+        block_given? ? enum.each(&block) : enum
+      else
+        async.each(&block)
+      end
+    end
+
+    def cluster(*columns)
+      new_instance(@params, @options, @extra_options.merge(cluster: columns))
+    end
+
+    def cluster_except(*columns)
+      cluster(*(@record_klass.primary_key - columns))
+    end
+
     def where(params)
-      @params.merge!(params)
-      self
+      new_instance(@params.merge(params.symbolize_keys), @options, @extra_options)
     end
 
     def select(*columns)
@@ -90,33 +112,55 @@ module CassandraModel
     end
 
     def limit(limit)
-      @options[:limit] = limit
-      self
+      if @extra_options[:cluster]
+        new_instance(@params, @options, @extra_options.merge(cluster_limit: limit))
+      else
+        new_instance(@params, @options.merge(limit: limit), @extra_options)
+      end
     end
 
     def trace(trace)
-      @options[:trace] = trace
-      self
+      new_instance(@params, @options.merge(trace: trace), @extra_options)
     end
 
     def paginate(page_size)
-      @options[:page_size] = page_size
-      self
+      new_instance(@params, @options.merge(page_size: page_size), @extra_options)
+    end
+
+    def ==(rhs)
+      rhs.is_a?(QueryBuilder) &&
+          rhs.record_klass == record_klass &&
+          rhs.params == params &&
+          rhs.options == options &&
+          rhs.extra_options == extra_options
+    end
+
+    def method_missing(method, *args)
+      scope = record_klass.scopes[method]
+      scope ? instance_exec(*args, &scope) : super
     end
 
+    protected
+
+    attr_reader :record_klass, :params, :options, :extra_options
+
     private
 
+    def new_instance(params, options, extra_options)
+      self.class.new(record_klass, params, options, extra_options)
+    end
+
     def append_option(columns, option)
-      @options[option] ||= []
+      new_option = (@options[option] || EMPTY_OPTION).dup
       if columns.first.is_a?(Hash)
         columns = columns.first.map do |column, direction|
-          {column => direction}
+          {column.to_sym => direction}
         end
-        @options[option].concat(columns)
+        new_option.concat(columns)
       else
-        @options[option].concat(columns)
+        new_option.concat(columns.map(&:to_sym))
       end
-      self
+      new_instance(@params, @options.merge(option => new_option), @extra_options)
     end
 
     def pluck_values(columns, result)

data/lib/cassandra_model/raw_connection.rb

@@ -1,10 +1,7 @@
 module CassandraModel
+  #noinspection RubyTooManyInstanceVariablesInspection
   class RawConnection
-    CLUSTER_MUTEX = Mutex.new
-    SESSION_MUTEX = Mutex.new
-    CONFIG_MUTEX = Mutex.new
-    STATEMENT_MUTEX = Mutex.new
-    REACTOR_MUTEX = Mutex.new
+    extend Forwardable
 
     DEFAULT_CONFIGURATION = {
         hosts: %w(localhost),
@@ -21,34 +18,46 @@ module CassandraModel
 
     include ConcurrencyHelper
 
+    def_delegator :@executor, :value, :executor
+    def_delegator :@futures_factory, :value, :futures_factory
+
     def initialize(config_name = nil)
       @config_name = config_name
-      @statement_cache = {}
+      @statement_cache = Concurrent::Map.new
+
+      @cluster_mutex = Mutex.new
+      @session_mutex = Mutex.new
+      @config_mutex = Mutex.new
+      @reactor_mutex = Mutex.new
+
+      @executor = Concurrent::Delay.new { Concurrent::CachedThreadPool.new }
+      @futures_factory = Concurrent::Delay.new { Cassandra::Future::Factory.new(executor) }
     end
 
     def config=(value)
-      CONFIG_MUTEX.synchronize { @config = DEFAULT_CONFIGURATION.merge(value) }
+      @config_mutex.synchronize { @config = DEFAULT_CONFIGURATION.merge(value) }
     end
 
     def config
-      safe_getset_variable(CONFIG_MUTEX, :@config) { load_config }
+      safe_getset_variable(@config_mutex, :@config) { load_config }
     end
 
     def cluster
-      safe_getset_variable(CLUSTER_MUTEX, :@cluster) do
+      safe_getset_variable(@cluster_mutex, :@cluster) do
         connection_configuration = config.slice(:hosts,
                                                 :compression,
                                                 :consistency,
                                                 :connection_timeout, :timeout,
                                                 :username, :password,
                                                 :address_resolution)
-        connection_configuration.merge!(logger: Logging.logger)
+        connection_configuration[:logger] = Logging.logger
+        connection_configuration[:futures_factory] = futures_factory
         Cassandra.cluster(connection_configuration)
       end
     end
 
     def session
-      safe_getset_variable(SESSION_MUTEX, :@session) { cluster.connect(config[:keyspace]) }
+      safe_getset_variable(@session_mutex, :@session) { cluster.connect(config[:keyspace]) }
     end
 
     def keyspace
@@ -68,14 +77,12 @@ module CassandraModel
     end
 
     def statement(query)
-      statement_cache[query] || begin
-        STATEMENT_MUTEX.synchronize { statement_cache[query] ||= session.prepare(query) }
-      end
+      statement_cache.fetch_or_store(query) { session.prepare(query) }
     end
 
     def shutdown
       @shutdown = true
-      REACTOR_MUTEX.synchronize do
+      @reactor_mutex.synchronize do
         @unlogged_reactor.stop.get if @unlogged_reactor
         @unlogged_reactor = nil
 
@@ -85,11 +92,11 @@ module CassandraModel
         @counter_reactor.stop.get if @counter_reactor
         @counter_reactor = nil
       end
-      SESSION_MUTEX.synchronize do
+      @session_mutex.synchronize do
         @session.close if @session
         @session = nil
       end
-      CLUSTER_MUTEX.synchronize do
+      @cluster_mutex.synchronize do
         @cluster.close if @cluster
         @cluster = nil
       end
@@ -122,7 +129,7 @@ module CassandraModel
     end
 
     def reactor(name, type)
-      safe_getset_variable(REACTOR_MUTEX, name) do
+      safe_getset_variable(@reactor_mutex, name) do
         BatchReactor.new(cluster, session, type, config[:batch_reactor] || {}).tap do |reactor|
           reactor.start.get
         end

data/lib/cassandra_model/record.rb

@@ -3,6 +3,7 @@ require_relative 'meta_columns'
 
 module CassandraModel
   class Record
+    extend Scopes
     extend QueryHelper
     include MetaColumns
     include DisplayableAttributes
@@ -34,6 +35,7 @@ module CassandraModel
         :connection_name,
 
         :write_consistency,
+        :serial_consistency,
         :read_consistency,
 
         :before_save_callbacks,
@@ -109,7 +111,9 @@ module CassandraModel
     alias :to_s :inspect
 
     def ==(rhs)
-      rhs.respond_to?(:attributes) && @attributes == rhs.attributes
+      rhs.respond_to?(:attributes) && columns.all? do |column|
+        attributes[column] == rhs.attributes[column]
+      end
     end
 
     private
@@ -228,6 +232,7 @@ module CassandraModel
     def write_query_options(options = {})
       {}.tap do |new_option|
         new_option[:consistency] = write_consistency if write_consistency
+        new_option[:serial_consistency] = serial_consistency if serial_consistency
         new_option[:trace] = true if options[:trace]
       end
     end
@@ -236,6 +241,10 @@ module CassandraModel
       self.class.write_consistency
     end
 
+    def serial_consistency
+      self.class.serial_consistency
+    end
+
     def column_values
       attributes = internal_attributes
       internal_columns.map { |column| attributes[column] }
@@ -355,7 +364,7 @@ module CassandraModel
       def_delegator :table, :primary_key, :internal_primary_key
       def_delegator :table, :name, :table_name
       def_delegator :table, :columns, :internal_columns
-      def_delegators :table_config, :write_consistency, :read_consistency, :write_consistency=, :read_consistency=
+      def_delegators :table_config, :write_consistency, :serial_consistency, :read_consistency, :write_consistency=, :serial_consistency=, :read_consistency=
 
       alias :partition_key :internal_partition_key
       alias :clustering_columns :internal_clustering_columns
@@ -394,12 +403,21 @@ module CassandraModel
         end
       end
 
+      def denormalized_column_map(input_columns)
+        (columns & input_columns).inject({}) { |memo, column| memo.merge!(column => column) }
+      end
+
+      def composite_defaults
+        []
+      end
+
       def query_for_save(options = {})
         existence_clause = options[:check_exists] && ' IF NOT EXISTS'
+        ttl_clause = options[:ttl] && " USING TTL #{options[:ttl]}"
         column_names = internal_columns.join(', ')
         column_sanitizers = (%w(?) * internal_columns.size).join(', ')
         save_query = "INSERT INTO #{table_name} (#{column_names}) VALUES (#{column_sanitizers})"
-        "#{save_query}#{existence_clause}"
+        "#{save_query}#{existence_clause}#{ttl_clause}"
       end
 
       def query_for_delete

data/lib/cassandra_model/result_chunker.rb

@@ -0,0 +1,29 @@
+module CassandraModel
+  class ResultChunker
+    include Enumerable
+
+    def initialize(enum, cluster)
+      @enum = enum
+      @cluster = cluster
+    end
+
+    def each(&block)
+      enum.chunk do |value|
+        value.attributes.values_at(*cluster)
+      end.each(&block)
+    end
+
+    alias :get :to_a
+
+    def ==(rhs)
+      rhs.is_a?(ResultChunker) &&
+          enum == rhs.enum &&
+          cluster == rhs.cluster
+    end
+
+    protected
+
+    attr_reader :enum, :cluster
+
+  end
+end

data/lib/cassandra_model/result_limiter.rb

@@ -0,0 +1,31 @@
+module CassandraModel
+  class ResultLimiter
+    include Enumerable
+
+    def initialize(enum, limit)
+      @enum = enum
+      @limit = limit
+    end
+
+    def each
+      return to_enum(:each) unless block_given?
+
+      @enum.each.with_index do |value, index|
+        break if index >= @limit
+        yield value
+      end
+    end
+
+    alias :get :to_a
+
+    def ==(rhs)
+      rhs.is_a?(ResultLimiter) &&
+          enum == rhs.enum &&
+          limit == rhs.limit
+    end
+
+    protected
+
+    attr_reader :enum, :limit
+  end
+end

data/lib/cassandra_model/result_paginator.rb

@@ -13,25 +13,44 @@ module CassandraModel
       each_slice { |slice| slice.each(&block) }
     end
 
-    def each_slice
+    def each_slice(&block)
       return to_enum(:each_slice) unless block_given?
 
       current_page = @page
-      loop do
-        page_results = current_page.get
-        modified_results = page_results.map { |result| @callback.call(result, page_results.execution_info) }
-        break if page_results.empty?
-        if page_results.last_page?
-          yield modified_results
-          break
-        else
-          current_page = page_results.next_page_async
-          yield modified_results
-        end
+      while current_page
+        current_page = iterate_page(current_page, &block)
       end
     end
 
     alias :get :to_a
 
+    private
+
+    def iterate_page(current_page, &block)
+      page_results = current_page.get
+      unless page_results.empty?
+        next_page(page_results, &block)
+      end
+    end
+
+    def next_page(page_results, &block)
+      if page_results.last_page?
+        modify_and_yield_page_results(page_results, &block)
+        nil
+      else
+        current_page = page_results.next_page_async
+        modify_and_yield_page_results(page_results, &block)
+        current_page
+      end
+    end
+
+    def modify_and_yield_page_results(page_results)
+      yield modified_page_results(page_results)
+    end
+
+    def modified_page_results(page_results)
+      page_results.map { |result| @callback[result, page_results.execution_info] }
+    end
+
   end
 end

data/lib/cassandra_model/result_reducer.rb

@@ -0,0 +1,49 @@
+module CassandraModel
+  class ResultReducer
+    include Enumerable
+
+    def initialize(enum, filter_keys)
+      @enum = enum
+      @filter_keys = filter_keys
+    end
+
+    def each(&block)
+      return to_enum(:each) unless block_given?
+
+      @enum.each do |_, rows|
+        if @filter_keys.one?
+          yield rows.first
+        elsif @filter_keys.any?
+          filter_results(rows, &block)
+        else
+          rows.each(&block)
+        end
+      end
+    end
+
+    private
+
+    def filter_results(rows)
+      prev_filter = []
+
+      rows.each.with_index do |row, index|
+        break if index >= @filter_keys.length
+        next_filter = row_filter(row, index)
+        break unless next_filter == prev_filter
+        prev_filter = next_filter << row_filter_key(index, row)
+        yield row
+      end
+    end
+
+    def row_filter(row, filter_length)
+      filter_length.times.map do |index|
+        row_filter_key(index, row)
+      end
+    end
+
+    def row_filter_key(index, row)
+      row.attributes[@filter_keys[index]]
+    end
+
+  end
+end

data/lib/cassandra_model/scopes.rb

@@ -0,0 +1,14 @@
+module CassandraModel
+  module Scopes
+    attr_reader :scopes
+
+    def scope(name, callback)
+      define_singleton_method(name, &callback)
+      scopes[name] = callback
+    end
+
+    def scopes
+      @scopes ||= {}
+    end
+  end
+end

data/lib/cassandra_model/session_compatibility.rb

@@ -0,0 +1,20 @@
+# only install this hack if our driver is incompatible with the old interface
+if Gem::Version.new(Gem.loaded_specs['cassandra-driver'].version) >= Gem::Version.new('2')
+  module Cassandra
+    class Session
+
+      alias :__execute_async :execute_async
+
+      def execute_async(statement, *args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        options = options.merge(arguments: args) unless options[:arguments]
+        __execute_async(statement, options)
+      end
+
+      def execute(statement, *args)
+        execute_async(statement, *args).get
+      end
+
+    end
+  end
+end

data/lib/cassandra_model/table_definition.rb

@@ -2,28 +2,72 @@ module CassandraModel
   class TableDefinition
     attr_reader :name
 
-    def self.from_data_model(table_name, inquirer, data_set)
-      partition_key = inquirer_partition_key(inquirer)
-      if inquirer.shard_column
-        if inquirer.shard_column.is_a?(Hash)
-          column_name, type = inquirer.shard_column.first
-          partition_key.merge!(:"rk_#{column_name}" => type)
+    class << self
+
+      def from_data_model(table_name, inquirer, data_set, properties)
+        partition_key = inquirer_partition_key(inquirer)
+        if inquirer.shard_column
+          if inquirer.shard_column.is_a?(Hash)
+            column_name, type = inquirer.shard_column.first
+            partition_key.merge!(:"rk_#{column_name}" => type)
+          else
+            partition_key.merge!(:"rk_#{inquirer.shard_column}" => :int)
+          end
+        end
+        clustering_columns = table_set_clustering_columns(data_set)
+        remaining_columns = table_set_remaining_columns(data_set)
+
+        updated_properties = table_properties_from_data_set(data_set, properties)
+
+        new(name: table_name, partition_key: partition_key,
+            clustering_columns: clustering_columns,
+            remaining_columns: remaining_columns,
+            properties: updated_properties)
+      end
+
+      private
+
+      def table_properties_from_data_set(data_set, properties)
+        if data_set.clustering_order.present?
+          updated_clustering_order = data_set.clustering_order.inject({}) do |memo, (column, order)|
+            memo.merge!(:"ck_#{column}" => order)
+          end
+          properties.merge(clustering_order: updated_clustering_order)
         else
-          partition_key.merge!(:"rk_#{inquirer.shard_column}" => :int)
+          properties
+        end
+      end
+
+      def table_set_remaining_columns(data_set)
+        data_set.columns.except(*data_set.clustering_columns)
+      end
+
+      def table_set_clustering_columns(data_set)
+        data_set.clustering_columns.inject({}) do |memo, column|
+          memo.merge!(:"ck_#{column}" => data_set.columns[column])
+        end
+      end
+
+      def inquirer_partition_key(inquirer)
+        inquirer.partition_key.inject({}) do |memo, (key, value)|
+          memo.merge!(:"rk_#{key}" => value)
         end
       end
-      clustering_columns = table_set_clustering_columns(data_set)
-      remaining_columns = table_set_remaining_columns(data_set)
-      new(name: table_name, partition_key: partition_key,
-          clustering_columns: clustering_columns,
-          remaining_columns: remaining_columns)
+
     end
 
+    attr_reader :table_id, :name_in_cassandra
+
     def initialize(options)
       @partition_key = options[:partition_key].keys
       @clustering_columns = options[:clustering_columns].keys
       @name = options[:name]
       @columns = options[:partition_key].merge(options[:clustering_columns].merge(options[:remaining_columns]))
+      @table_id = generate_table_id
+      @name_in_cassandra = "#{name}_#{table_id}"
+      @properties = (options[:properties] || {}).select do |name, _|
+        [:compaction, :clustering_order].include?(name)
+      end
     end
 
     def to_cql(options = {})
@@ -31,15 +75,18 @@ module CassandraModel
       exists = if options[:check_exists]
                  'IF NOT EXISTS '
                end
-      "CREATE TABLE #{exists}#{table_name} (#{columns}, PRIMARY KEY #{primary_key})"
-    end
-
-    def table_id
-      Digest::MD5.hexdigest(columns)
-    end
-
-    def name_in_cassandra
-      "#{name}_#{table_id}"
+      properties = if @properties.present?
+                     property_values = @properties.map do |property, definition|
+                       case property
+                         when :compaction
+                           "COMPACTION = #{to_property_string(definition)}"
+                         when :clustering_order
+                           "CLUSTERING ORDER BY #{to_clustering_order_string(definition)}"
+                       end
+                     end * ' AND '
+                     " WITH #{property_values}"
+                   end
+      "CREATE TABLE #{exists}#{table_name} (#{columns}, PRIMARY KEY #{primary_key})#{properties}"
     end
 
     def ==(rhs)
@@ -48,20 +95,16 @@ module CassandraModel
 
     private
 
-    def self.table_set_remaining_columns(data_set)
-      data_set.columns.except(*data_set.clustering_columns)
+    def to_property_string(property)
+      "{#{property.map { |key, value| "'#{key}': '#{value}'" } * ', '}}"
     end
 
-    def self.table_set_clustering_columns(data_set)
-      data_set.clustering_columns.inject({}) do |memo, column|
-        memo.merge!(:"ck_#{column}" => data_set.columns[column])
-      end
+    def to_clustering_order_string(clustering_order)
+      "(#{clustering_order.map { |column, order| "#{column} #{order.upcase}" } * ', '})"
     end
 
-    def self.inquirer_partition_key(inquirer)
-      inquirer.partition_key.inject({}) do |memo, (key, value)|
-        memo.merge!(:"rk_#{key}" => value)
-      end
+    def generate_table_id
+      Digest::MD5.hexdigest(columns)
     end
 
     def columns

data/lib/cassandra_model/table_descriptor.rb

@@ -1,6 +1,8 @@
 module CassandraModel
   class TableDescriptor < Record
 
+    self.serial_consistency = :serial
+
     class << self
       def create_async(table_definition)
         super(table_descriptor(table_definition), check_exists: true)
@@ -46,4 +48,4 @@ module CassandraModel
     end
 
   end
-end
+end

metadata

@@ -1,29 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: cassandra_model
 version: !ruby/object:Gem::Version
-  version: 0.9.21
+  version: 1.0.16
 platform: ruby
 authors:
 - Thomas RM Rogers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-14 00:00:00.000000000 Z
+date: 2016-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cassandra-driver
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
         version: '1.1'
+    - - <=
+      - !ruby/object:Gem::Version
+        version: 2.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - '>='
       - !ruby/object:Gem::Version
         version: '1.1'
+    - - <=
+      - !ruby/object:Gem::Version
+        version: 2.0.1
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -54,18 +60,38 @@ dependencies:
         version: 0.0.1
 - !ruby/object:Gem::Dependency
   name: thomas_utils
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.19
+    - - <=
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.19
+    - - <=
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.1.13
+        version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.1.13
+        version: 1.0.0
 description: |-
   Cassandra data modelling framework for Ruby that makes
   data modelling for Cassandra tables easy, fast, and stable
@@ -99,8 +125,13 @@ files:
 - lib/cassandra_model/raw_connection.rb
 - lib/cassandra_model/record.rb
 - lib/cassandra_model/record_debug.rb
+- lib/cassandra_model/result_chunker.rb
+- lib/cassandra_model/result_limiter.rb
 - lib/cassandra_model/result_paginator.rb
+- lib/cassandra_model/result_reducer.rb
 - lib/cassandra_model/rotating_table.rb
+- lib/cassandra_model/scopes.rb
+- lib/cassandra_model/session_compatibility.rb
 - lib/cassandra_model/single_token_batch.rb
 - lib/cassandra_model/single_token_counter_batch.rb
 - lib/cassandra_model/single_token_logged_batch.rb