cequel 1.10.0 → 2.0.0

data/lib/cequel/instrumentation.rb

@@ -37,16 +37,17 @@ module Cequel
 
         define_method(:"__data_for_#{method_name}_instrumentation", &data_proc)
 
-        module_eval <<-METH
-          def #{method_name}_with_instrumentation(*args)
+        mod = Module.new
+        mod.module_eval <<-METH
+          def #{method_name}(*args)
             instrument("#{topic}",
                        __data_for_#{method_name}_instrumentation(self)) do
-              #{method_name}_without_instrumentation(*args)
+              super(*args)
             end
           end
         METH
 
-        alias_method_chain method_name, "instrumentation"
+        prepend mod
       end
     end
 

data/lib/cequel/metal/batch.rb

@@ -39,10 +39,9 @@ module Cequel
       #
       # @param (see Keyspace#execute)
       #
-      def execute(cql, *bind_vars)
-        @statement.append("#{cql}\n", *bind_vars)
-        @statement_count += 1
-        if @auto_apply && @statement_count >= @auto_apply
+      def execute(statement)
+        @statements << statement
+        if @auto_apply && @statements.size >= @auto_apply
           apply
           reset
         end
@@ -52,13 +51,20 @@ module Cequel
       # Send the batch to Cassandra
       #
       def apply
-        return if @statement_count.zero?
-        if @statement_count > 1
-          @statement.prepend(begin_statement)
-          @statement.append("APPLY BATCH\n")
+        return if @statements.empty?
+
+        statement = @statements.first
+        if @statements.size > 1
+          statement =
+            if logged?
+              keyspace.client.logged_batch
+            else
+              keyspace.client.unlogged_batch
+            end
+          @statements.each { |s| statement.add(s.prepare(keyspace), arguments: s.bind_vars) }
         end
-        @keyspace.execute_with_consistency(
-          @statement.args.first, @statement.args.drop(1), @consistency)
+
+        keyspace.execute_with_options(statement, consistency: @consistency)
         execute_on_complete_hooks
       end
 
@@ -84,30 +90,27 @@ module Cequel
       end
 
       # @private
-      def execute_with_consistency(cql, bind_vars, query_consistency)
+      def execute_with_options(statement, options)
+        query_consistency = options.fetch(:consistency)
         if query_consistency && query_consistency != @consistency
           raise ArgumentError,
                 "Attempting to perform query with consistency " \
                 "#{query_consistency.to_s.upcase} in batch with consistency " \
                 "#{@consistency.upcase}"
         end
-        execute(cql, *bind_vars)
+        execute(statement)
       end
 
       private
 
-      attr_reader :on_complete_hooks
+      attr_reader :on_complete_hooks, :keyspace
 
       def reset
-        @statement = Statement.new
+        @statements = []
         @statement_count = 0
         @on_complete_hooks = []
       end
 
-      def begin_statement
-        "BEGIN #{"UNLOGGED " if unlogged?}BATCH\n"
-      end
-
       def execute_on_complete_hooks
         on_complete_hooks.each { |hook| hook.call }
       end

data/lib/cequel/metal/data_set.rb

@@ -51,7 +51,7 @@ module Cequel
       attr_reader :query_page_size
       attr_reader :query_paging_state
 
-      def_delegator :keyspace, :write_with_consistency
+      def_delegator :keyspace, :write_with_options
 
       #
       # @param table_name [Symbol] column family for this data set
@@ -189,8 +189,8 @@ module Cequel
       # @example
       #   posts.list_prepend(:categories, ['CQL', 'ORMs'])
       #
-      # @note If multiple elements are passed, they will appear in the list in
-      #   reverse order.
+      # @note A bug (CASSANDRA-8733) exists in Cassandra versions 0.3.0-2.0.12 and 2.1.0-2.1.2 which
+      #   will make elements appear in REVERSE ORDER in the list.
       # @note If a enclosed in a Keyspace#batch block, this method will be
       #   executed as part of the batch.
       # @see #list_append
@@ -611,15 +611,16 @@ module Cequel
         Row.from_result_row(row)
       end
 
-      #
-      # @return [Fixnum] the number of rows in this data set
-      #
+      # @raise [DangerousQueryError] to prevent loading the entire record set
+      #   to be counted
       def count
-        execute_cql(*count_cql).first['count']
+        raise Cequel::Record::DangerousQueryError.new
       end
+      alias_method :length, :count
+      alias_method :size, :count
 
       #
-      # @return [String] CQL `SELECT` statement encoding this data set's scope.
+      # @return [Statement] CQL `SELECT` statement encoding this data set's scope.
       #
       def cql
         statement = Statement.new
@@ -628,25 +629,13 @@ module Cequel
           .append(*row_specifications_cql)
           .append(sort_order_cql)
           .append(limit_cql)
-          .args
-      end
-
-      #
-      # @return [String] CQL statement to get count of rows in this data set
-      #
-      def count_cql
-        Statement.new
-          .append("SELECT COUNT(*) FROM #{table_name}")
-          .append(*row_specifications_cql)
-          .append(limit_cql).args
       end
 
       #
       # @return [String]
       #
       def inspect
-        "#<#{self.class.name}: " \
-          "#{Keyspace.sanitize(cql.first, cql.drop(1))}>"
+        "#<#{self.class.name}: #{cql.inspect}>"
       end
 
       #
@@ -677,15 +666,15 @@ module Cequel
       private
 
       def results
-        @results ||= execute_cql(*cql)
+        @results ||= execute_cql(cql)
       end
 
-      def execute_cql(cql, *bind_vars)
-        keyspace.execute_with_options(cql, bind_vars, {
-          consistency: query_consistency,
-          page_size: query_page_size,
-          paging_state: query_paging_state
-        })
+      def execute_cql(cql_stmt)
+        keyspace.execute_with_options(cql_stmt,
+                                      consistency: query_consistency,
+                                      page_size: query_page_size,
+                                      paging_state: query_paging_state
+                                     )
       end
 
       def inserter(&block)

data/lib/cequel/metal/inserter.rb

@@ -23,8 +23,9 @@ module Cequel
         statement = Statement.new
         consistency = options.fetch(:consistency, data_set.query_consistency)
         write_to_statement(statement, options)
-        data_set.write_with_consistency(
-          statement.cql, statement.bind_vars, consistency)
+        data_set.write_with_options(statement,
+                                    consistency: consistency
+                                   )
       end
 
       #

data/lib/cequel/metal/keyspace.rb

@@ -46,7 +46,7 @@ module Cequel
       #
       def_delegator :write_target, :execute, :write
 
-      # @!method write_with_consistency(statement, bind_vars, consistency)
+      # @!method write_with_options(statement, bind_vars, consistency)
       #
       #   Write data to this keyspace using a CQL query at the given
       #   consistency. Will be included the current batch operation if one is
@@ -55,8 +55,8 @@ module Cequel
       #   @param (see #execute_with_consistency)
       #   @return [void]
       #
-      def_delegator :write_target, :execute_with_consistency,
-                    :write_with_consistency
+      def_delegator :write_target, :execute_with_options,
+                    :write_with_options
 
       #
       # @!method batch
@@ -187,16 +187,33 @@ module Cequel
       # @see #execute_with_consistency
       #
       def execute(statement, *bind_vars)
-        execute_with_consistency(statement, bind_vars, default_consistency)
+        execute_with_options(Statement.new(statement, bind_vars), { consistency: default_consistency })
       end
 
-      def execute_with_options(statement, bind_vars, options={})
+      #
+      # Execute a CQL query in this keyspace with the given options
+      #
+      # @param statement [String,Statement,Batch] statement to execute
+      # @param options [Options] options for statement execution
+      # @return [Enumerable] the results of the query
+      #
+      # @since 1.1.0
+      #
+      def execute_with_options(statement, options={})
         options[:consistency] ||= default_consistency
 
         retries = max_retries
-        log('CQL', statement, *bind_vars) do
+        cql, options = *case statement
+                        when Statement
+                          [client.prepare(statement.cql),
+                           {arguments: statement.bind_vars}.merge(options)]
+                        when Cassandra::Statements::Batch
+                          [statement, options]
+                        end
+
+        log('CQL', statement) do
           begin
-            client.execute(sanitize(statement, bind_vars), options)
+            client.execute(cql, options)
           rescue Cassandra::Errors::NoHostsAvailable,
                  Ione::Io::ConnectionError => e
             clear_active_connections!
@@ -206,20 +223,6 @@ module Cequel
             retry
           end
         end
-
-      end
-      #
-      # Execute a CQL query in this keyspace with the given consistency
-      #
-      # @param statement [String] CQL string
-      # @param bind_vars [Array] array of values for bind variables
-      # @param consistency [Symbol] consistency at which to execute query
-      # @return [Enumerable] the results of the query
-      #
-      # @since 1.1.0
-      #
-      def execute_with_consistency(statement, bind_vars, consistency)
-        execute_with_options(statement, bind_vars, {consistency: consistency || default_consistency})
       end
 
       #
@@ -250,14 +253,38 @@ module Cequel
 
       # @return [Boolean] true if the keyspace exists
       def exists?
+        cluster.has_keyspace?(name)
+      end
+
+      # @return [String] Cassandra version number
+      def cassandra_version
+        return @cassandra_version if @cassandra_version
+
         statement = <<-CQL
-          SELECT keyspace_name
-          FROM system.schema_keyspaces
-          WHERE keyspace_name = ?
+          SELECT release_version
+          FROM system.local
         CQL
 
-        log('CQL', statement, [name]) do
-          client_without_keyspace.execute(sanitize(statement, [name])).any?
+        log('CQL', statement) do
+          @cassandra_version = client_without_keyspace.execute(statement).first['release_version']
+        end
+      end
+
+      # return true if Cassandra server version is known to include bug CASSANDRA-8733
+      def bug8733_version?
+        version_file = File.expand_path('../../../../.cassandra-versions', __FILE__)
+        @all_versions ||= File.read(version_file).split("\n").map(&:strip)
+
+        # bug exists in versions 0.3.0-2.0.12 and 2.1.0-2.1.2
+        @bug8733_versions ||= @all_versions[0..@all_versions.index('2.0.12')] +
+            @all_versions[@all_versions.index('2.1.0')..@all_versions.index('2.1.2')]
+
+        @bug8733_versions.include?(cassandra_version)
+      end
+
+      def cluster
+        synchronize do
+          @cluster ||= Cassandra.cluster(client_options)
         end
       end
 
@@ -271,11 +298,6 @@ module Cequel
       def_delegator :lock, :synchronize
       private :lock
 
-      def cluster
-        synchronize do
-          @cluster ||= Cassandra.cluster(client_options)
-        end
-      end
 
       def client_without_keyspace
         synchronize do
@@ -301,7 +323,7 @@ module Cequel
 
       def extract_hosts_and_port(configuration)
         hosts, ports = [], Set[]
-        ports << configuration[:port] if configuration.key?(:port)
+        ports << Integer(configuration[:port]) if configuration.key?(:port)
         host_or_hosts =
           configuration.fetch(:host, configuration.fetch(:hosts, '127.0.0.1'))
         Array.wrap(host_or_hosts).each do |host_port|
@@ -311,7 +333,7 @@ module Cequel
             warn "Specifying a hostname as host:port is deprecated. Specify " \
                  "only the host IP or hostname in :hosts, and specify a " \
                  "port for all nodes using the :port option."
-            ports << port.to_i
+            ports << Integer(port)
           end
         end
 
@@ -345,6 +367,7 @@ module Cequel
         ssl_config.each { |key, value| ssl_config.delete(key) unless value }
         ssl_config
       end
+
     end
   end
 end

data/lib/cequel/metal/request_logger.rb

@@ -22,18 +22,17 @@ module Cequel
       # Log a CQL statement
       #
       # @param label [String] a logical label for this statement
-      # @param statement [String] the CQL statement to log
-      # @param bind_vars bind variables for the CQL statement
+      # @param statement [String,Statement,Batch] the CQL statement to log
       # @return [void]
       #
-      def log(label, statement, *bind_vars)
+      def log(label, statement)
         return yield if logger.nil?
 
         response = nil
         begin
           time = Benchmark.ms { response = yield }
           generate_message = lambda do
-            format_for_log(label, "#{time.round.to_i}ms", statement, bind_vars)
+            format_for_log(label, "#{time.round.to_i}ms", statement)
           end
 
           if time >= slowlog_threshold
@@ -42,7 +41,7 @@ module Cequel
             logger.debug(&generate_message)
           end
         rescue Exception => e
-          logger.error { format_for_log(label, 'ERROR', statement, bind_vars) }
+          logger.error { format_for_log(label, 'ERROR', statement) }
           raise
         end
         response
@@ -50,9 +49,24 @@ module Cequel
 
       private
 
-      def format_for_log(label, timing, statement, bind_vars)
-        bind_vars = bind_vars.map{|it| String === it ? limit_length(it) : it }
-        format('%s (%s) %s', label, timing, sanitize(statement, bind_vars))
+      def format_for_log(label, timing, statement)
+        cql_for_log =
+          case statement
+          when String
+            statement
+          when Statement
+            sanitize(statement.cql, limit_value_length(statement.bind_vars))
+          when Cassandra::Statements::Batch
+            batch_stmt = "BEGIN #{'UNLOGGED ' if statement.type == :unlogged}BATCH"
+            statement.statements.each { |s| batch_stmt << "\n" << sanitize(s.cql, limit_value_length(s.params)) }
+            batch_stmt << "END BATCH"
+          end
+
+        format('%s (%s) %s', label, timing, cql_for_log)
+      end
+
+      def limit_value_length(bind_vars)
+        bind_vars.map { |it| String === it ? limit_length(it) : it }
       end
 
       def limit_length(str)

data/lib/cequel/metal/row_specification.rb

@@ -35,15 +35,16 @@ module Cequel
       # @return [String] row specification as CQL fragment
       #
       def cql
-        case @value
-        when Array
-          if @value.length == 1
-            ["#{@column} = ?", @value.first]
-          else
-            ["#{@column} IN (?)", @value]
-          end
+        value = if Enumerable === @value && @value.count == 1
+                  @value.first
+                else
+                  @value
+                end
+
+        if Array === value
+          ["#{@column} IN ?", value]
         else
-          ["#{@column} = ?", @value]
+          ["#{@column} = ?", value]
         end
       end
     end

data/lib/cequel/metal/statement.rb

@@ -10,16 +10,30 @@ module Cequel
     class Statement
       # @return [Array] bind variables for CQL string
       attr_reader :bind_vars
+      # @return [Array] cassandra type hints for bind variables
 
-      def initialize
-        @cql, @bind_vars = [], []
+      def initialize(cql_or_prepared='', bind_vars=[])
+        cql, prepared = *case cql_or_prepared
+                         when Cassandra::Statements::Prepared
+                           [cql_or_prepared.cql, cql_or_prepared]
+                         else
+                           [cql_or_prepared.to_s, nil]
+                         end
+
+        @cql, @prepared, @bind_vars = cql, prepared, bind_vars
       end
 
       #
       # @return [String] CQL statement
       #
-      def cql
-        @cql.join
+      def to_s
+        @cql
+      end
+      alias_method :cql, :to_s
+
+      # @return [Cassandra::Statements::Prepared] prepared version of this statement
+      def prepare(keyspace)
+        @prepared ||= keyspace.client.prepare(cql)
       end
 
       #
@@ -30,7 +44,7 @@ module Cequel
       # @return [void]
       #
       def prepend(cql, *bind_vars)
-        @cql.unshift(cql)
+        @cql.prepend(cql)
         @bind_vars.unshift(*bind_vars)
       end
 
@@ -43,8 +57,10 @@ module Cequel
       # @return [void]
       #
       def append(cql, *bind_vars)
-        @cql << cql
-        @bind_vars.concat(bind_vars)
+        unless cql.nil?
+          @cql << cql
+          @bind_vars.concat(bind_vars)
+        end
         self
       end