cequel 1.10.0 → 2.0.0

data/lib/cequel/metal/updater.rb

@@ -45,7 +45,8 @@ module Cequel
       # @see DataSet#list_prepend
       #
       def list_prepend(column, elements)
-        statements << "#{column} = [?] + #{column}"
+        elements = Array(elements)
+        statements << "#{column} = ? + #{column}"
         bind_vars << elements
       end
 
@@ -59,7 +60,8 @@ module Cequel
       # @see DataSet#list_append
       #
       def list_append(column, elements)
-        statements << "#{column} = #{column} + [?]"
+        elements = Array(elements)
+        statements << "#{column} = #{column} + ?"
         bind_vars << elements
       end
 
@@ -73,7 +75,8 @@ module Cequel
       # @see DataSet#list_remove
       #
       def list_remove(column, value)
-        statements << "#{column} = #{column} - [?]"
+        value = Array(value)
+        statements << "#{column} = #{column} - ?"
         bind_vars << value
       end
 
@@ -102,8 +105,8 @@ module Cequel
       # @see DataSet#set_add
       #
       def set_add(column, values)
-        statements << "#{column} = #{column} + {?}"
-        bind_vars << values
+        statements << "#{column} = #{column} + ?"
+        bind_vars << Set.new(::Kernel.Array(values))
       end
 
       #
@@ -116,8 +119,8 @@ module Cequel
       # @see DataSet#set_remove
       #
       def set_remove(column, values)
-        statements << "#{column} = #{column} - {?}"
-        bind_vars << ::Kernel.Array(values)
+        statements << "#{column} = #{column} - ?"
+        bind_vars << Set.new(::Kernel.Array(values))
       end
 
       #
@@ -130,9 +133,8 @@ module Cequel
       # @see DataSet#map_update
       #
       def map_update(column, updates)
-        binding_pairs = ::Array.new(updates.length) { '?:?' }.join(',')
-        statements << "#{column} = #{column} + {#{binding_pairs}}"
-        bind_vars.concat(updates.flatten)
+        statements << "#{column} = #{column} + ?"
+        bind_vars << updates
       end
 
       private

data/lib/cequel/metal/writer.rb

@@ -13,6 +13,8 @@ module Cequel
     class Writer
       extend Util::Forwardable
 
+      attr_accessor :type_hints
+
       #
       # @param data_set [DataSet] data set to write to
       #
@@ -41,8 +43,8 @@ module Cequel
         consistency = options.fetch(:consistency, data_set.query_consistency)
         write_to_statement(statement, options)
         statement.append(*data_set.row_specifications_cql)
-        data_set.write_with_consistency(
-          statement.cql, statement.bind_vars, consistency)
+        data_set.write_with_options(statement,
+                                    consistency: consistency)
       end
 
       private
@@ -52,17 +54,7 @@ module Cequel
       def_delegator :statements, :empty?
 
       def prepare_upsert_value(value)
-        case value
-        when ::Array
-          yield '[?]', value
-        when ::Set then
-          yield '{?}', value.to_a
-        when ::Hash then
-          binding_pairs = ::Array.new(value.length) { '?:?' }.join(',')
-          yield "{#{binding_pairs}}", *value.flatten
-        else
-          yield '?', value
-        end
+        yield '?', value
       end
 
       #

data/lib/cequel/record/association_collection.rb

@@ -50,41 +50,14 @@ module Cequel
       end
 
       #
-      # @!method count
-      #   Get the count of child records stored in the database. This method
-      #   will always query Cassandra, even if the records are loaded in
-      #   memory.
+      # @raise [DangerousQueryError] to prevent loading the entire record set
+      #   to be counted
       #
-      #   @return [Integer] number of child records in the database
-      #   @see #size
-      #   @see #length
-      #
-      def_delegator :record_set, :count
-
-      #
-      # @!method length
-      #   The number of child instances in the in-memory collection. If the
-      #   records are not loaded in memory, they will be loaded and then
-      #   counted.
-      #
-      #   @return [Integer] length of the loaded record collection in memory
-      #   @see #size
-      #   @see #count
-      #
-      def_delegator :entries, :length
-
-      #
-      # Get the size of the child collection. If the records are loaded in
-      # memory from a previous operation, count the length of the array in
-      # memory. If the collection is unloaded, perform a `COUNT` query.
-      #
-      # @return [Integer] size of the child collection
-      # @see #length
-      # @see #count
-      #
-      def size
-        loaded? ? length : count
+      def count
+        raise Cequel::Record::DangerousQueryError.new
       end
+      alias_method :length, :count
+      alias_method :size, :count
 
       #
       # @return [Boolean] true if this collection's records are loaded in

data/lib/cequel/record/collection.rb

@@ -332,7 +332,8 @@ module Cequel
       #
       def unshift(*objects)
         objects.map!(&method(:cast_element))
-        to_update { updater.list_prepend(column_name, objects.reverse) }
+        prepared = @model.class.connection.bug8733_version? ? objects.reverse : objects
+        to_update { updater.list_prepend(column_name, prepared) }
         to_modify { super }
       end
       alias_method :prepend, :unshift

data/lib/cequel/record/errors.rb

@@ -44,6 +44,12 @@ module Cequel
     #
     IllegalQuery = Class.new(StandardError)
 
+    #
+    # Raised when attempting to perform a query that has detrimental effects.
+    # Typically when trying to count records.
+    #
+    DangerousQueryError = Class.new(StandardError)
+
     #
     # Raised when attempting to persist a Cequel::Record without defining all
     # primary key columns

data/lib/cequel/record/persistence.rb

@@ -274,8 +274,8 @@ module Cequel
 
       def create(options = {})
         assert_keys_present!
-        metal_scope
-          .insert(attributes.reject { |attr, value| value.nil? }, options)
+        attributes_for_write = attributes.reject { |attr, value| value.nil? }
+        metal_scope.insert(attributes_for_write, options)
         loaded!
         persisted!
       end

data/lib/cequel/record/record_set.rb

@@ -537,11 +537,10 @@ module Cequel
         end
       end
 
-      #
-      # @return [Integer] the total number of records in this record set
-      #
+      # @raise [DangerousQueryError] to prevent loading the entire record set
+      #   to be counted
       def count
-        data_set.count
+        raise Cequel::Record::DangerousQueryError.new
       end
       alias_method :length, :count
       alias_method :size, :count

data/lib/cequel/record/validations.rb

@@ -26,7 +26,7 @@ module Cequel
       included do
         include ActiveModel::Validations
         define_model_callbacks :validation
-        alias_method_chain :valid?, :callbacks
+        prepend Callback
       end
 
       #
@@ -80,11 +80,11 @@ module Cequel
         self.attributes = attributes
         save!
       end
+    end
 
-      private
-
-      def valid_with_callbacks?(context=nil)
-        run_callbacks(:validation) { valid_without_callbacks? context }
+    module Callback
+      def valid?(context=nil)
+        run_callbacks(:validation) { super context }
       end
     end
   end

data/lib/cequel/schema/table.rb

@@ -9,11 +9,6 @@ module Cequel
     # @see Keyspace#read_table
     #
     class Table
-      STORAGE_PROPERTIES = %w(
-        bloom_filter_fp_chance caching comment compaction compression
-        dclocal_read_repair_chance gc_grace_seconds read_repair_chance
-        replicate_on_write
-      )
 
       # @return [Symbol] the name of the table
       attr_reader :name
@@ -293,8 +288,11 @@ module Cequel
       end
 
       def type(type)
+        type = type.kind if type.respond_to?(:kind)
+
         ::Cequel::Type[type]
       end
+
     end
   end
 end

data/lib/cequel/schema/table_reader.rb

@@ -54,6 +54,7 @@ module Cequel
           read_clustering_columns
           read_data_columns
           read_properties
+          read_table_settings
           table
         end
       end
@@ -64,142 +65,103 @@ module Cequel
 
       private
 
-      # XXX This gets a lot easier in Cassandra 2.0: all logical columns
-      # (including keys) are returned from the `schema_columns` query, so
-      # there's no need to jump through all these hoops to figure out what the
-      # key columns look like.
-      #
-      # However, this approach works for both 1.2 and 2.0, so better to keep it
-      # for now. It will be worth refactoring this code to take advantage of
-      # 2.0's better interface in a future version of Cequel that targets 2.0+.
       def read_partition_keys
-        validators = table_data['key_validator']
-        types = parse_composite_types(validators) || [validators]
-        columns = partition_columns.sort_by { |c| c['component_index'] }
-          .map { |c| c['column_name'] }
-
-        columns.zip(types) do |name, type|
-          table.add_partition_key(name.to_sym, Type.lookup_internal(type))
+        table_data.partition_key.each do |k|
+          table.add_partition_key(k.name.to_sym, k.type)
         end
+
       end
 
-      # XXX See comment on {read_partition_keys}
       def read_clustering_columns
-        columns = cluster_columns.sort { |l, r| l['component_index'] <=> r['component_index'] }
-          .map { |c| c['column_name'] }
-        comparators = parse_composite_types(table_data['comparator'])
-        unless comparators
-          table.compact_storage = true
-          return unless column_data.empty?
-          columns << :column1 if cluster_columns.empty?
-          comparators = [table_data['comparator']]
-        end
-
-        columns.zip(comparators) do |name, type|
-          if REVERSED_TYPE_PATTERN =~ type
-            type = $1
-            clustering_order = :desc
+        table_data.clustering_columns.zip(table_data.clustering_order)
+          .each do |c,o|
+            table.add_clustering_column(c.name.to_sym, c.type, o)
           end
-          table.add_clustering_column(
-            name.to_sym,
-            Type.lookup_internal(type),
-            clustering_order
-          )
-        end
       end
 
       def read_data_columns
-        if column_data.empty?
-          table.add_data_column(
-            (compact_value['column_name'] || :value).to_sym,
-            Type.lookup_internal(table_data['default_validator']),
-            false
-          )
-        else
-          column_data.each do |result|
-            if COLLECTION_TYPE_PATTERN =~ result['validator']
-              read_collection_column(
-                result['column_name'],
-                $1.underscore,
-                *$2.split(',')
-              )
+        indexes = Hash[table_data.each_index.map{|i| [i.target, i.name]}]
+
+        ((table_data.each_column - table_data.partition_key) - table_data.clustering_columns)
+          .each do |c|
+            next if table.column(c.name.to_sym)
+            case c.type
+            when Cassandra::Types::Simple
+              opts = if indexes[c.name]
+                       {index: indexes[c.name].to_sym}
+                     else
+                       {}
+                     end
+              table.add_data_column(c.name.to_sym, c.type, opts)
+            when Cassandra::Types::List
+              table.add_list(c.name.to_sym, c.type.value_type)
+            when Cassandra::Types::Set
+              table.add_set(c.name.to_sym, c.type.value_type)
+            when Cassandra::Types::Map
+              table.add_map(c.name.to_sym, c.type.key_type, c.type.value_type)
             else
-              table.add_data_column(
-                result['column_name'].to_sym,
-                Type.lookup_internal(result['validator']),
-                result['index_name'].try(:to_sym)
-              )
+              fail "Unsupported type #{c.type.inspect}"
             end
           end
-        end
       end
 
-      def read_collection_column(name, collection_type, *internal_types)
-        types = internal_types
-          .map { |internal| Type.lookup_internal(internal) }
-        table.__send__("add_#{collection_type}", name.to_sym, *types)
-      end
+      @@prop_extractors = []
+      def self.def_property(name,
+                            option_method = name,
+                            coercion = ->(val, _table_data){ val })
 
-      def read_properties
-        table_data.slice(*Table::STORAGE_PROPERTIES).each do |name, value|
-          table.add_property(name, value)
-        end
-        compaction = JSON.parse(table_data['compaction_strategy_options'])
-          .symbolize_keys
-        compaction[:class] = table_data['compaction_strategy_class']
-        table.add_property(:compaction, compaction)
-        compression = JSON.parse(table_data['compression_parameters'])
-        table.add_property(:compression, compression)
-      end
+        @@prop_extractors << ->(table, table_data) {
+          raw_prop_val = table_data.options.public_send(option_method)
+          prop_val = coercion.call(raw_prop_val,table_data)
 
-      def parse_composite_types(type_string)
-        if COMPOSITE_TYPE_PATTERN =~ type_string
-          $1.split(',')
-        end
+          table.add_property(name, prop_val)
+        }
       end
 
-      def table_data
-        return @table_data if defined? @table_data
-        table_query = keyspace.execute(<<-CQL, keyspace.name, table_name)
-              SELECT * FROM system.schema_columnfamilies
-              WHERE keyspace_name = ? AND columnfamily_name = ?
-        CQL
-        @table_data = table_query.first.try(:to_hash)
-      end
+      def_property("bloom_filter_fp_chance")
+      def_property("caching")
+      def_property("comment")
+      def_property("local_read_repair_chance")
+      def_property("dclocal_read_repair_chance", :local_read_repair_chance)
+      def_property("compression", :compression,
+                   ->(comp, table_data) {
+                     comp.clone.tap { |r|
+                       r["chunk_length_kb"] ||= r["chunk_length_in_kb"] if r["chunk_length_in_kb"]
+                       r["crc_check_chance"] ||= table_data.options.crc_check_chance
+                     }
+                   })
+      def_property("compaction", :compaction_strategy,
+                   ->(compaction_strategy, _table_data) {
+                     compaction_strategy.options
+                       .merge(class: compaction_strategy.class_name)
+                   })
+      def_property("gc_grace_seconds")
+      def_property("read_repair_chance")
+      def_property("replicate_on_write", :replicate_on_write?)
 
-      def all_columns
-        @all_columns ||=
-          if table_data
-            column_query = keyspace.execute(<<-CQL, keyspace.name, table_name)
-              SELECT * FROM system.schema_columns
-              WHERE keyspace_name = ? AND columnfamily_name = ?
-            CQL
-            column_query.map(&:to_hash)
-          end
+      def read_properties
+        @@prop_extractors.each do |extractor|
+          extractor.call(table, table_data)
+        end
       end
 
-      def compact_value
-        @compact_value ||= all_columns.find do |column|
-          column['type'] == 'compact_value'
-        end || {}
+      def read_table_settings
+        table.compact_storage = table_data.options.compact_storage?
       end
 
-      def column_data
-        @column_data ||= all_columns.select do |column|
-          !column.key?('type') || column['type'] == 'regular'
-        end
-      end
+      def table_data
+        @table_data ||=
+          begin
+            cluster = keyspace.cluster
+            cluster.refresh_schema
 
-      def partition_columns
-        @partition_columns ||= all_columns.select do |column|
-          column['type'] == 'partition_key'
-        end
-      end
+            fail(NoSuchKeyspaceError, "No such keyspace #{keyspace.name}") if
+              !cluster.has_keyspace?(keyspace.name)
 
-      def cluster_columns
-        @cluster_columns ||= all_columns.select do |column|
-          column['type'] == 'clustering_key'
-        end
+            cluster
+              .keyspace(keyspace.name)
+              .table(table_name.to_s)
+          end
       end
     end
   end