whi-cassie 1.0.5 → 1.2.0

data/gemfiles/activemodel_6.gemfile

@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activemodel", "~> 6.0"
+
+group :development, :test do
+  gem "rake"
+  gem "rspec"
+  gem "appraisal"
+  gem "standard", "~>0.8.1"
+end
+
+gemspec path: "../"

data/lib/cassie.rb

@@ -1,41 +1,45 @@
-require 'cassandra'
+# frozen_string_literal: true
+
+require "cassandra"
 
 # This class provides a lightweight wrapper around the Cassandra driver. It provides
 # a foundation for maintaining a connection and constructing CQL statements.
 class Cassie
   require File.expand_path("../cassie/config.rb", __FILE__)
+  require File.expand_path("../cassie/subscribers.rb", __FILE__)
   require File.expand_path("../cassie/model.rb", __FILE__)
   require File.expand_path("../cassie/schema.rb", __FILE__)
   require File.expand_path("../cassie/testing.rb", __FILE__)
   require File.expand_path("../cassie/railtie.rb", __FILE__) if defined?(Rails)
-  
+
   class RecordNotFound < StandardError
   end
-  
+
   class RecordInvalid < StandardError
     attr_reader :record
-    
+
     def initialize(record)
       super("Errors on #{record.class.name}: #{record.errors.to_hash.inspect}")
       @record = record
     end
   end
-  
+
   # Message passed to subscribers with the statement, options, and time for each statement
   # to execute. Note that if statements are batched they will be packed into one message
   # with a Cassandra::Statements::Batch statement and empty options.
   class Message
     attr_reader :statement, :options, :elapsed_time
-    
+
     def initialize(statement, options, elapsed_time)
       @statement = statement
       @options = options
       @elapsed_time = elapsed_time
     end
   end
-  
+
   attr_reader :config, :subscribers
-  
+  attr_accessor :consistency
+
   class << self
     # A singleton instance that can be shared to communicate with a Cassandra cluster.
     def instance
@@ -45,7 +49,7 @@ class Cassie
       end
       @instance
     end
-    
+
     # Call this method to load the Cassie::Config from the specified file for the
     # specified environment.
     def configure!(options)
@@ -56,7 +60,7 @@ class Cassie
       end
       @config = Cassie::Config.new(options)
     end
-    
+
     # This method can be used to set a consistency level for all Cassandra queries
     # within a block that don't explicitly define them. It can be used where consistency
     # is important (i.e. on validation queries) but where a higher level method
@@ -70,34 +74,33 @@ class Cassie
         Thread.current[:cassie_consistency] = save_val
       end
     end
-    
+
     # Get a Logger compatible object if it has been set.
     def logger
       @logger if defined?(@logger)
     end
-    
+
     # Set a logger with a Logger compatible object.
-    def logger=(value)
-      @logger = value
-    end
+    attr_writer :logger
   end
-  
+
   def initialize(config)
     @config = config
     @monitor = Monitor.new
     @session = nil
     @prepared_statements = {}
     @last_prepare_warning = Time.now
-    @subscribers = []
+    @subscribers = Subscribers.new
+    @consistency = ((config.cluster || {})[:consistency] || :local_one)
   end
-  
+
   # Open a connection to the Cassandra cluster.
   def connect
     start_time = Time.now
     cluster_config = config.cluster
-    cluster_config = cluster_config.merge(:logger => logger) if logger
+    cluster_config = cluster_config.merge(logger: logger) if logger
     cluster = Cassandra.cluster(cluster_config)
-    logger.info("Cassie.connect with #{config.sanitized_cluster} in #{((Time.now - start_time) * 1000).round}ms") if logger
+    logger&.info("Cassie.connect with #{config.sanitized_cluster} in #{((Time.now - start_time) * 1000).round}ms")
     @monitor.synchronize do
       @session = cluster.connect(config.default_keyspace)
       @prepared_statements = {}
@@ -106,19 +109,19 @@ class Cassie
 
   # Close the connections to the Cassandra cluster.
   def disconnect
-    logger.info("Cassie.disconnect from #{config.sanitized_cluster}") if logger
+    logger&.info("Cassie.disconnect from #{config.sanitized_cluster}")
     @monitor.synchronize do
-      @session.close if @session
+      @session&.close
       @session = nil
       @prepared_statements = {}
     end
   end
-  
+
   # Return true if the connection to the Cassandra cluster has been established.
   def connected?
     !!@session
   end
-  
+
   # Force reconnection. If you're using this code in conjunction in a forking server environment
   # like passenger or unicorn you should call this method after forking.
   def reconnect
@@ -147,13 +150,13 @@ class Cassie
         end
       end
     end
-    
+
     if cache_filled_up && logger && Time.now > @last_prepare_warning + 10
       # Set a throttle on how often this message is logged so we don't kill performance enven more.
       @last_prepare_warning = Time.now
       logger.warn("Cassie.prepare cache filled up. Consider increasing the size from #{config.max_prepared_statements}.")
     end
-    
+
     statement
   end
 
@@ -179,7 +182,7 @@ class Cassie
               batch_statement.add(statement)
             end
           end
-          execute(batch_statement)
+          execute(batch_statement, nil, options)
         end
       ensure
         Thread.current[:cassie_batch] = nil
@@ -207,19 +210,22 @@ class Cassie
     columns = []
     values = []
     values_hash.each do |column, value|
-      if !value.nil?
+      unless value.nil?
         columns << column
         values << value
       end
     end
-    cql = "INSERT INTO #{table} (#{columns.join(', ')}) VALUES (#{question_marks(columns.size)})"
-    
-    ttl = options[:ttl] if options
-    if ttl
-      cql << " USING TTL ?"
-      values << ttl
+    cql = "INSERT INTO #{table} (#{columns.join(", ")}) VALUES (#{question_marks(columns.size)})"
+
+    if options&.include?(:ttl)
+      options = options.dup
+      ttl = options.delete(:ttl)
+      if ttl
+        cql += " USING TTL ?"
+        values << Integer(ttl)
+      end
     end
-    
+
     batch_or_execute(cql, values, options)
   end
 
@@ -242,15 +248,20 @@ class Cassie
       end
     end
     values = update_values + key_values
-    
+
     cql = "UPDATE #{table}"
-    ttl = options[:ttl] if options
-    if ttl
-      cql << " USING TTL ?"
-      values.unshift(ttl)
+
+    if options&.include?(:ttl)
+      options = options.dup
+      ttl = options.delete(:ttl)
+      if ttl
+        cql += " USING TTL ?"
+        values.unshift(Integer(ttl))
+      end
     end
-    cql << " SET #{update_cql.join(', ')} WHERE #{key_cql}"
-    
+
+    cql += " SET #{update_cql.join(", ")} WHERE #{key_cql}"
+
     batch_or_execute(cql, values, options)
   end
 
@@ -270,37 +281,50 @@ class Cassie
     start_time = Time.now
     begin
       statement = nil
-      if cql.is_a?(String) && values.present?
-        statement = prepare(cql)
+      statement = if cql.is_a?(String)
+        if values.present?
+          prepare(cql)
+        else
+          Cassandra::Statements::Simple.new(cql)
+        end
       else
-        statement = cql
+        cql
       end
-    
+
       if values.present?
         values = Array(values)
-        options = (options ? options.merge(:arguments => values) : {:arguments => values})
+        options = (options ? options.merge(arguments: values) : {arguments: values})
       end
-    
+
       # Set a default consistency from a block context if it isn't explicitly set.
-      default_consistency = Thread.current[:cassie_consistency]
-      if default_consistency
-        options = (options ? options.reverse_merge(:consistency => default_consistency) : {:consistency => default_consistency})
+      statement_consistency = current_consistency
+      if statement_consistency
+        if options
+          options = options.merge(consistency: statement_consistency) if options[:consistency].nil?
+        else
+          options = {consistency: statement_consistency}
+        end
       end
-      
+
       session.execute(statement, options || {})
     rescue Cassandra::Errors::IOError => e
       disconnect
       raise e
     ensure
-      unless subscribers.empty?
+      if statement.is_a?(Cassandra::Statement) && !subscribers.empty?
         payload = Message.new(statement, options, Time.now - start_time)
-        subscribers.each{|subscriber| subscriber.call(payload)}
+        subscribers.each { |subscriber| subscriber.call(payload) }
       end
     end
   end
 
+  # Return the current consistency level that has been set for statements.
+  def current_consistency
+    Thread.current[:cassie_consistency] || consistency
+  end
+
   private
-  
+
   def logger
     self.class.logger
   end
@@ -309,7 +333,7 @@ class Cassie
     connect unless connected?
     @session
   end
-  
+
   def batch_or_execute(cql, values, options = nil)
     batch = Thread.current[:cassie_batch]
     if batch
@@ -321,9 +345,7 @@ class Cassie
   end
 
   def question_marks(size)
-    q = '?'
-    (size - 1).times{ q << ',?' }
-    q
+    "?#{",?" * (size - 1)}"
   end
 
   def key_clause(key_hash)
@@ -333,9 +355,9 @@ class Cassie
       cql << "#{key} = ?"
       values << value
     end
-    [cql.join(' AND '), values]
+    [cql.join(" AND "), values]
   end
-  
+
   # Extract the CQL from a statement
   def statement_cql(statement, previous = nil)
     cql = nil
@@ -344,7 +366,7 @@ class Cassie
     elsif statement.respond_to?(:statements) && (previous.nil? || !previous.include?(statement))
       previous ||= []
       previous << statement
-      cql = statement.statements.collect{|s| statement_cql(s, previous)}.join('; ')
+      cql = statement.statements.collect { |s| statement_cql(s, previous) }.join("; ")
     end
     cql
   end

data/lib/cassie/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Simple configuration for connecting to Cassandra.
 #
 # :cluster should be a Hash of the options to initialize the Cassandra cluster.
@@ -19,7 +21,7 @@
 class Cassie::Config
   attr_reader :cluster
   attr_accessor :max_prepared_statements, :schema_directory, :default_keyspace
-  
+
   def initialize(options = {})
     options = options.symbolize_keys
     @cluster = (options[:cluster] || {}).symbolize_keys
@@ -28,27 +30,27 @@ class Cassie::Config
     @schema_directory = options[:schema_directory]
     @default_keyspace = options[:default_keyspace]
   end
-  
+
   # Get the actual keyspace mapped to the abstract name.
   def keyspace(name)
     @keyspaces[name.to_s] || name.to_s
   end
-  
+
   # Get the list of keyspaces defined for the cluster.
   def keyspaces
     @keyspaces.values
   end
-  
+
   # Get the list of abstract keyspace names.
   def keyspace_names
     @keyspaces.keys
   end
-  
+
   # Add a mapping of a name to a keyspace.
   def add_keyspace(name, value)
     @keyspaces[name.to_s] = value
   end
-  
+
   # Return the cluster options without passwords or tokens. Used for logging.
   def sanitized_cluster
     options = cluster.dup
@@ -59,5 +61,4 @@ class Cassie::Config
     options[:logger] = options[:logger].class.name if options.include?(:logger)
     options
   end
-  
 end

data/lib/cassie/model.rb

@@ -1,5 +1,7 @@
-require 'active_model'
-require 'active_support/hash_with_indifferent_access'
+# frozen_string_literal: true
+
+require "active_model"
+require "active_support/hash_with_indifferent_access"
 
 # This module provides a simple interface for models backed by Cassandra tables.
 #
@@ -15,19 +17,19 @@ require 'active_support/hash_with_indifferent_access'
 #
 #   class Thing
 #     include Cassie::Model
-#   
+#
 #     self.table_name = "things"
 #     self.keyspace = "test"
 #     self.primary_key = [:owner, :id]
-#   
+#
 #     column :owner, :int
 #     column :id, :int, :as => :identifier
 #     column :val, :varchar, :as => :value
-#   
+#
 #     ordering_key :id, :desc
-#   
+#
 #     validates_presence_of :id, :value
-#   
+#
 #     before_save do
 #       ...
 #     end
@@ -38,22 +40,47 @@ module Cassie::Model
   include ActiveModel::Validations
   include ActiveModel::Validations::Callbacks
   extend ActiveModel::Callbacks
-    
+
   included do |base|
-    class_attribute :table_name, :instance_reader => false, :instance_writer => false
-    class_attribute :_keyspace, :instance_reader => false, :instance_writer => false
-    class_attribute :_primary_key, :instance_reader => false, :instance_writer => false
-    class_attribute :_columns, :instance_reader => false, :instance_writer => false
-    class_attribute :_column_aliases, :instance_reader => false, :instance_writer => false
-    class_attribute :_ordering_keys, :instance_reader => false, :instance_writer => false
-    class_attribute :_counter_table, :instance_reader => false, :instance_writer => false
+    class_attribute :table_name, instance_reader: false, instance_writer: false
+    class_attribute :_keyspace, instance_reader: false, instance_writer: false
+    class_attribute :_primary_key, instance_reader: false, instance_writer: false
+    class_attribute :_columns, instance_reader: false, instance_writer: false
+    class_attribute :_column_aliases, instance_reader: false, instance_writer: false
+    class_attribute :_ordering_keys, instance_reader: false, instance_writer: false
+    class_attribute :_counter_table, instance_reader: false, instance_writer: false
+    class_attribute :find_subscribers, instance_reader: false, instance_writer: false
+    class_attribute :read_consistency, instance_reader: false, instance_writer: false
+    class_attribute :write_consistency
     define_model_callbacks :create, :update, :save, :destroy
     self._columns = {}
     self._column_aliases = HashWithIndifferentAccess.new
     self._ordering_keys = {}
+    self.find_subscribers = Cassie::Subscribers.new(Cassie::Model.find_subscribers)
+  end
+
+  class << self
+    @@find_subscribers = Cassie::Subscribers.new
+
+    def find_subscribers
+      @@find_subscribers
+    end
   end
-  
-  module ClassMethods    
+
+  # Message sent to find subscribers for instrumenting find operations.
+  class FindMessage
+    attr_reader :cql, :args, :options, :elapsed_time, :rows
+
+    def initialize(cql, args, options, elapsed_time, rows)
+      @cql = cql
+      @args = args
+      @options = options
+      @elapsed_time = elapsed_time
+      @rows = rows
+    end
+  end
+
+  module ClassMethods
     # Define a column name and type from the table. Columns must be defined in order
     # to be used. This method will handle defining the getter and setter methods as well.
     #
@@ -75,54 +102,57 @@ module Cassie::Model
     def column(name, type, as: nil)
       name = name.to_sym
       type_class = nil
+      type_name = type.to_s.downcase.classify
+      # Backward compatibility with older driver versions.
+      type_name = "Text" if type_name == "Varchar"
       begin
-        type_class = "Cassandra::Types::#{type.to_s.downcase.classify}".constantize
+        type_class = "Cassandra::Types::#{type_name}".constantize
       rescue NameError
         raise ArgumentError.new("#{type.inspect} is not an allowed Cassandra type")
       end
-      
+
       self._columns = _columns.merge(name => type_class)
-      self._column_aliases = self._column_aliases.merge(name => name)
+      self._column_aliases = _column_aliases.merge(name => name)
 
       aliased = (as && as.to_s != name.to_s)
       if aliased
-        self._column_aliases = self._column_aliases.merge(as => name)
+        self._column_aliases = _column_aliases.merge(as => name)
       end
 
-      if type.to_s == "counter".freeze
+      if type.to_s == "counter"
         self._counter_table = true
-        
-        define_method(name){ instance_variable_get(:"@#{name}") || 0 }
-        define_method("#{name}="){ |value| instance_variable_set(:"@#{name}", value.to_i) }
-        
-        define_method("increment_#{name}!"){ |amount=1, ttl: nil| send(:adjust_counter!, name, amount, ttl: ttl) }
-        define_method("decrement_#{name}!"){ |amount=1, ttl: nil| send(:adjust_counter!, name, -amount, ttl: ttl) }
+
+        define_method(name) { instance_variable_get(:"@#{name}") || 0 }
+        define_method("#{name}=") { |value| instance_variable_set(:"@#{name}", value.to_i) }
+
+        define_method("increment_#{name}!") { |amount = 1, ttl: nil| send(:adjust_counter!, name, amount, ttl: ttl) }
+        define_method("decrement_#{name}!") { |amount = 1, ttl: nil| send(:adjust_counter!, name, -amount, ttl: ttl) }
         if aliased
-          define_method(as){ send(name) }
-          define_method("increment_#{as}!"){ |amount=1, ttl: nil| send("increment_#{name}!", amount, ttl: ttl) }
-          define_method("decrement_#{as}!"){ |amount=1, ttl: nil| send("increment_#{name}!", amount, ttl: ttl) }
+          define_method(as) { send(name) }
+          define_method("increment_#{as}!") { |amount = 1, ttl: nil| send("increment_#{name}!", amount, ttl: ttl) }
+          define_method("decrement_#{as}!") { |amount = 1, ttl: nil| send("increment_#{name}!", amount, ttl: ttl) }
         end
       else
         attr_reader name
-        define_method("#{name}="){ |value| instance_variable_set(:"@#{name}", self.class.send(:coerce, value, type_class)) }
+        define_method("#{name}=") { |value| instance_variable_set(:"@#{name}", self.class.send(:coerce, value, type_class)) }
         attr_reader name
         if aliased
-          define_method(as){ send(name) }
-          define_method("#{as}="){|value| send("#{name}=", value) }
+          define_method(as) { send(name) }
+          define_method("#{as}=") { |value| send("#{name}=", value) }
         end
       end
     end
-    
+
     # Returns an array of the defined column names as symbols.
     def column_names
       _columns.keys
     end
-    
+
     # Returns the internal column name after resolving any aliases.
     def column_name(name_or_alias)
-      name = _column_aliases[name_or_alias] || name_or_alias
+      _column_aliases[name_or_alias] || name_or_alias
     end
-    
+
     # Set the primary key for the table. The value should be set as an array with the
     # clustering key first.
     def primary_key=(value)
@@ -134,31 +164,31 @@ module Cassie::Model
         end
       }.flatten
     end
-    
+
     # Return an array of column names for the table primary key.
     def primary_key
       _primary_key
     end
-    
+
     # Define and ordering key for the table. The order attribute should be either :asc or :desc
     def ordering_key(name, order)
       order = order.to_sym
       raise ArgumentError.new("order must be either :asc or :desc") unless order == :asc || order == :desc
       _ordering_keys[name.to_sym] = order
     end
-  
+
     # Set the keyspace for the table. The name should be an abstract keyspace name
     # that is mapped to an actual keyspace name in the configuration. If the name
     # provided is not mapped in the configuration, then the raw value will be used.
     def keyspace=(name)
       self._keyspace = name.to_s
     end
-    
+
     # Return the keyspace name where the table is located.
     def keyspace
       connection.config.keyspace(_keyspace)
     end
-    
+
     # Return the full table name including the keyspace.
     def full_table_name
       if _keyspace
@@ -167,7 +197,7 @@ module Cassie::Model
         table_name
       end
     end
-  
+
     # Find all records.
     #
     # The +where+ argument can be a Hash, Array, or String WHERE clause to
@@ -186,30 +216,33 @@ module Cassie::Model
     # You can provide a block to this method in which case it will yield each
     # record as it is foundto the block instead of returning them.
     def find_all(where:, select: nil, order: nil, limit: nil, options: nil)
-      columns = (select ? Array(select).collect{|c| column_name(c)} : column_names)
-      cql = "SELECT #{columns.join(', ')} FROM #{full_table_name}"
+      start_time = Time.now
+      columns = (select ? Array(select).collect { |c| column_name(c) } : column_names)
+      cql = "SELECT #{columns.join(", ")} FROM #{full_table_name}"
       values = nil
-    
+
       raise ArgumentError.new("Where clause cannot be blank. Pass :all to find all records.") if where.blank?
       if where && where != :all
         where_clause, values = cql_where_clause(where)
       else
         values = []
       end
-      cql << " WHERE #{where_clause}" if where_clause
-    
+      cql += " WHERE #{where_clause}" if where_clause
+
       if order
-        cql << " ORDER BY #{order}"
+        cql += " ORDER BY #{order}"
       end
-    
+
       if limit
-        cql << " LIMIT ?"
+        cql += " LIMIT ?"
         values << Integer(limit)
       end
-    
-      results = connection.find(cql, values, options)
+
+      results = connection.find(cql, values, consistency_options(read_consistency, options))
       records = [] unless block_given?
+      row_count = 0
       loop do
+        row_count += results.size
         results.each do |row|
           record = new(row)
           record.instance_variable_set(:@persisted, true)
@@ -222,9 +255,15 @@ module Cassie::Model
         break if results.last_page?
         results = results.next_page
       end
+
+      if find_subscribers && !find_subscribers.empty?
+        payload = FindMessage.new(cql, values, options, Time.now - start_time, row_count)
+        find_subscribers.each { |subscriber| subscriber.call(payload) }
+      end
+
       records
     end
-    
+
     # Find a single record that matches the +where+ argument.
     def find(where)
       options = nil
@@ -234,7 +273,7 @@ module Cassie::Model
       end
       find_all(where: where, limit: 1, options: options).first
     end
-    
+
     # Find a single record that matches the +where+ argument or raise an
     # ActiveRecord::RecordNotFound error if none is found.
     def find!(where)
@@ -242,7 +281,7 @@ module Cassie::Model
       raise Cassie::RecordNotFound unless record
       record
     end
-  
+
     # Return the count of rows in the table. If the +where+ argument is specified
     # then it will be added as the WHERE clause.
     def count(where = nil)
@@ -251,21 +290,21 @@ module Cassie::Model
         where = where.dup
         options = where.delete(:options)
       end
-      
-      cql = "SELECT COUNT(*) FROM #{self.full_table_name}"
+
+      cql = "SELECT COUNT(*) FROM #{full_table_name}"
       values = nil
-    
+
       if where
         where_clause, values = cql_where_clause(where)
-        cql << " WHERE #{where_clause}"
+        cql += " WHERE #{where_clause}"
       else
-        where = connection.prepare(cql)
+        connection.prepare(cql)
       end
-      
-      results = connection.find(cql, values, options)
+
+      results = connection.find(cql, values, consistency_options(read_consistency, options))
       results.rows.first["count"]
     end
-    
+
     # Returns a newly created record. If the record is not valid then it won't be
     # persisted.
     def create(attributes)
@@ -273,7 +312,7 @@ module Cassie::Model
       record.save
       record
     end
-    
+
     # Returns a newly created record or raises an ActiveRecord::RecordInvalid error
     # if the record is not valid.
     def create!(attributes)
@@ -281,7 +320,7 @@ module Cassie::Model
       record.save!
       record
     end
-    
+
     # Delete all rows from the table that match the key hash. This method bypasses
     # any destroy callbacks defined on the model.
     def delete_all(key_hash)
@@ -289,22 +328,24 @@ module Cassie::Model
       key_hash.each do |name, value|
         cleanup_up_hash[column_name(name)] = value
       end
-      connection.delete(full_table_name, cleanup_up_hash)
+      connection.delete(full_table_name, cleanup_up_hash, consistency: write_consistency)
     end
-    
+
     # All insert, update, and delete calls within the block will be sent as a single
-    # batch to Cassandra.
-    def batch
-      connection.batch do
+    # batch to Cassandra. The consistency level will default to the write consistency
+    # level if it's been set.
+    def batch(options = nil)
+      options = consistency_options(write_consistency, options)
+      connection.batch(options) do
         yield
       end
     end
-    
+
     # Returns the Cassie instance used to communicate with Cassandra.
     def connection
       Cassie.instance
     end
-  
+
     # Since Cassandra doesn't support offset we need to find the order key of record
     # at the specified the offset.
     #
@@ -321,7 +362,7 @@ module Cassie::Model
       cluster_order = _ordering_keys[ordering_key] || :asc
       order ||= cluster_order
       order_cql = "#{ordering_key} #{order}" unless order == cluster_order
-      
+
       from = (order == :desc ? max : min)
       to = (order == :desc ? min : max)
       loop do
@@ -329,11 +370,11 @@ module Cassie::Model
         conditions_cql = []
         conditions = []
         if from
-          conditions_cql << "#{ordering_key} #{order == :desc ? '<' : '>'} ?"
+          conditions_cql << "#{ordering_key} #{order == :desc ? "<" : ">"} ?"
           conditions << from
         end
         if to
-          conditions_cql << "#{ordering_key} #{order == :desc ? '>' : '<'} ?"
+          conditions_cql << "#{ordering_key} #{order == :desc ? ">" : "<"} ?"
           conditions << to
         end
         key.each do |name, value|
@@ -342,10 +383,10 @@ module Cassie::Model
         end
         conditions.unshift(conditions_cql.join(" AND "))
 
-        results = find_all(:select => [ordering_key], :where => conditions, :limit => limit, :order => order_cql)
+        results = find_all(select: [ordering_key], where: conditions, limit: limit, order: order_cql)
         last_row = results.last if results.size == limit
         last_id = last_row.send(ordering_key) if last_row
-      
+
         if last_id.nil?
           return nil
         elsif limit >= offset
@@ -356,9 +397,9 @@ module Cassie::Model
         end
       end
     end
-  
+
     private
-  
+
     # Turn a hash of column value, array of [cql, value] or a CQL string into
     # a CQL where clause. Returns the values pulled out in an array for making
     # a prepared statement.
@@ -370,8 +411,7 @@ module Cassie::Model
         where.each do |column, value|
           col_name = column_name(column)
           if value.is_a?(Array)
-            q = '?'
-            (value.size - 1).times{ q << ',?' }
+            q = "?#{",?" * (value.size - 1)}"
             cql << "#{col_name} IN (#{q})"
             values.concat(value)
           else
@@ -379,7 +419,7 @@ module Cassie::Model
             values << coerce(value, _columns[col_name])
           end
         end
-        [cql.join(' AND '), values]
+        [cql.join(" AND "), values]
       when Array
         [where.first, where[1, where.size]]
       when String
@@ -388,7 +428,7 @@ module Cassie::Model
         raise ArgumentError.new("invalid CQL where clause #{where}")
       end
     end
-    
+
     # Force a value to be the correct Cassandra data type.
     def coerce(value, type_class)
       if value.nil?
@@ -416,23 +456,36 @@ module Cassie::Model
         type_class.new(value)
       end
     end
+
+    def consistency_options(consistency, options)
+      if consistency
+        if options
+          options = options.merge(consistency: consistency) if options[:consistency].nil?
+          options
+        else
+          {consistency: consistency}
+        end
+      else
+        options
+      end
+    end
   end
-  
+
   def initialize(attributes = {})
     super
     @persisted = false
   end
-  
+
   # Return true if the record has been persisted to Cassandra.
   def persisted?
     @persisted
   end
-  
+
   # Return true if the table is used for a counter.
   def counter_table?
     !!self.class._counter_table
   end
-  
+
   # Save a record. Returns true if the record was persisted and false if it was invalid.
   # This method will run the save callbacks as well as either the update or create
   # callbacks as necessary.
@@ -441,13 +494,14 @@ module Cassie::Model
     valid_record = (validate ? valid? : true)
     if valid_record
       run_callbacks(:save) do
+        options = {consistency: write_consistency, ttl: (ttl || persistence_ttl)}
         if persisted?
           run_callbacks(:update) do
-            self.class.connection.update(self.class.full_table_name, values_hash, key_hash, :ttl => (ttl || persistence_ttl))
+            self.class.connection.update(self.class.full_table_name, values_hash, key_hash, options)
           end
         else
           run_callbacks(:create) do
-            self.class.connection.insert(self.class.full_table_name, attributes, :ttl => (ttl || persistence_ttl))
+            self.class.connection.insert(self.class.full_table_name, attributes, options)
             @persisted = true
           end
         end
@@ -457,26 +511,26 @@ module Cassie::Model
       false
     end
   end
-  
+
   # Save a record. Returns true if the record was saved and raises an ActiveRecord::RecordInvalid
   # error if the record is invalid.
-  def save!
-    if save
+  def save!(ttl: nil)
+    if save(ttl: ttl)
       true
     else
       raise Cassie::RecordInvalid.new(self)
     end
   end
-  
+
   # Delete a record and call the destroy callbacks.
   def destroy
     run_callbacks(:destroy) do
-      self.class.connection.delete(self.class.full_table_name, key_hash)
+      self.class.connection.delete(self.class.full_table_name, key_hash, consistency: write_consistency)
       @persisted = false
       true
     end
   end
-  
+
   # Returns a hash of column to values. Column names will be symbols.
   def attributes
     hash = {}
@@ -485,51 +539,52 @@ module Cassie::Model
     end
     hash
   end
-  
+
   # Subclasses can override this method to provide a TTL on the persisted record.
   def persistence_ttl
     nil
   end
-  
+
   def eql?(other)
     other.is_a?(self.class) && other.key_hash == key_hash
   end
-  
+
   def ==(other)
     eql?(other)
   end
-  
+
   # Returns the primary key as a hash
   def key_hash
     hash = {}
     self.class.primary_key.each do |key|
-      hash[key] = self.send(key)
+      hash[key] = send(key)
     end
     hash
   end
-  
+
   private
-  
+
   # Used for updating counter columns.
   def adjust_counter!(name, amount, ttl: nil)
     amount = amount.to_i
     if amount != 0
       run_callbacks(:update) do
         adjustment = (amount < 0 ? "#{name} = #{name} - #{amount.abs}" : "#{name} = #{name} + #{amount}")
-        self.class.connection.update(self.class.full_table_name, adjustment, key_hash, :ttl => (ttl || persistence_ttl))
+        options = {consistency: write_consistency, ttl: (ttl || persistence_ttl)}
+        self.class.connection.update(self.class.full_table_name, adjustment, key_hash, options)
       end
     end
     record = self.class.find(key_hash)
     value = (record ? record.send(name) : send(name) + amount)
     send("#{name}=", value)
   end
-  
+
   # Returns a hash of value except for the ones that constitute the primary key
   def values_hash
     pk = self.class.primary_key
     hash = {}
     self.class.column_names.each do |name|
-      hash[name] = send(name) unless pk.include?(name) 
+      hash[name] = send(name) unless pk.include?(name)
     end
     hash
   end