cequel 1.0.0.pre.4 → 1.0.0.pre.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af518e804a2ce5cf3e021b7a2ba92302011c0cd4
-  data.tar.gz: dadafdee945a8c961ac58fcf29ed3a76f84e616e
+  metadata.gz: f830646acc29101f50ff14afb06933e15fa88e35
+  data.tar.gz: c3d9d72fbf56847758e5de1191e7f48200b03423
 SHA512:
-  metadata.gz: f90d210ad3a9ab787fcd6e70bba0e950f5983ade9d41f5f17f160b91eab470a84e4f5ca4f828be938db04ccb4bafda1f1be5fba1ea2db75667a2a82ee0d6043b
-  data.tar.gz: 22436304a692c25bd34ce86b58d317630b81af527a28234e3d4bc4884617699cb0fc1092138e7c1a54867059f8118b183e8c4263bef175f735041948a5a53a93
+  metadata.gz: 981a73d5f5f4a6b5a07374df3f96ccdd599642927ea29aa652a13249234ffd18a40921aaa675345355de052072b94ecd8e8f2b63d47e16c2b1bdabbb7c7150e1
+  data.tar.gz: dc9035f9e642cdffac8f3b83ab9ec2abacb3498580cdfe4e3b6e5b370ec8a70fe22ab4e5f20a9f702fc5d8eacda436098a73fb04592d7858a73f64bd1720e1c6

data/lib/cequel/errors.rb

@@ -2,4 +2,5 @@ module Cequel
   Error = Class.new(StandardError)
   EmptySubquery = Class.new(Error)
   InvalidSchemaMigration = Class.new(Error)
+  MissingKeyError = Class.new(Error)
 end

data/lib/cequel/record.rb

@@ -7,6 +7,7 @@ require 'cequel/record/properties'
 require 'cequel/record/collection'
 require 'cequel/record/persistence'
 require 'cequel/record/record_set'
+require 'cequel/record/bound'
 require 'cequel/record/scoped'
 require 'cequel/record/secondary_indexes'
 require 'cequel/record/associations'

data/lib/cequel/record/bound.rb

@@ -0,0 +1,101 @@
+module Cequel
+
+  module Record
+
+    class Bound
+      attr_reader :column, :value
+
+      def self.create(column, gt, inclusive, value)
+        implementation =
+          if column.partition_key?
+            PartitionKeyBound
+          elsif column.type?(Type::Timeuuid) && !value.is_a?(CassandraCQL::UUID)
+            TimeuuidBound
+          else
+            ClusteringColumnBound
+          end
+
+        implementation.new(column, gt, inclusive, value)
+      end
+
+      def initialize(column, gt, inclusive, value)
+        @column, @gt, @inclusive, @value = column, gt, inclusive, value
+      end
+
+      def to_cql_with_bind_variables
+        [to_cql, bind_value]
+      end
+
+
+      def gt?
+        !!@gt
+      end
+
+      def lt?
+        !gt?
+      end
+
+      def inclusive?
+        !!@inclusive
+      end
+
+      def exclusive?
+        !inclusive?
+      end
+
+      protected
+
+      def bind_value
+        column.cast(value)
+      end
+
+      def operator
+        exclusive? ? base_operator : "#{base_operator}="
+      end
+
+      def base_operator
+        lt? ? '<' : '>'
+      end
+
+    end
+
+    class PartitionKeyBound < Bound
+      def to_cql
+        "TOKEN(#{column.name}) #{operator} TOKEN(?)"
+      end
+    end
+
+    class ClusteringColumnBound < Bound
+      def to_cql
+        "#{column.name} #{operator} ?"
+      end
+    end
+
+    class TimeuuidBound < Bound
+      def to_cql
+        "#{column.name} #{operator} #{function}(?)"
+      end
+
+      protected
+
+      def operator
+        base_operator
+      end
+
+      def bind_value
+        cast_value = Type::Timestamp.instance.cast(value)
+        if inclusive?
+          lt? ? cast_value + 0.001 : cast_value - 0.001
+        else
+          cast_value
+        end
+      end
+
+      def function
+        lt? ^ exclusive? ? 'maxTimeuuid' : 'minTimeuuid'
+      end
+    end
+
+  end
+
+end

data/lib/cequel/record/collection.rb

@@ -10,10 +10,9 @@ module Cequel
       extend Forwardable
 
       def_delegators :@model, :loaded?, :updater, :deleter
+      def_delegator :@column, :name, :column_name
       def_delegators :__getobj__, :clone, :dup
 
-      attr_reader :column_name
-
       included do
         private
         define_method(
@@ -21,8 +20,8 @@ module Cequel
           BasicObject.instance_method(:method_missing))
       end
 
-      def initialize(model, column_name)
-        @model, @column_name = model, column_name
+      def initialize(model, column)
+        @model, @column = model, column
       end
 
       def inspect
@@ -40,8 +39,8 @@ module Cequel
       protected
 
       def __getobj__
-        @model.__send__(:read_attribute, @column_name) ||
-          @model.__send__(:write_attribute, @column_name, self.class.empty)
+        model.__send__(:read_attribute, column_name) ||
+          model.__send__(:write_attribute, column_name, self.class.empty)
       end
 
       def __setobj__(obj)
@@ -49,10 +48,14 @@ module Cequel
       end
 
       private
+      attr_reader :model, :column
+      def_delegator :column, :cast, :cast_collection
+      def_delegator 'column.type', :cast, :cast_element
+      private :cast_collection, :cast_element
 
       def to_modify(&block)
         if loaded?
-          @model.__send__("#{@column_name}_will_change!")
+          model.__send__("#{column_name}_will_change!")
           block.()
         else modifications << block
         end
@@ -98,11 +101,17 @@ module Cequel
         if Range === position then first, count = position.first, position.count
         else first, count = position, args[-2]
         end
-        element = args[-1]
+
+        element = args[-1] =
+          if args[-1].is_a?(Array) then cast_collection(args[-1])
+          else cast_element(args[-1])
+          end
+
         if first < 0
           raise ArgumentError,
             "Bad index #{position}: CQL lists do not support negative indices"
         end
+
         if count.nil?
           updater.list_replace(column_name, first, element)
         else
@@ -124,11 +133,13 @@ module Cequel
       end
 
       def concat(array)
+        array = cast_collection(array)
         updater.list_append(column_name, array)
         to_modify { super }
       end
 
       def delete(object)
+        object = cast_element(object)
         updater.list_remove(column_name, object)
         to_modify { super }
       end
@@ -139,17 +150,20 @@ module Cequel
       end
 
       def push(object)
+        object = cast_element(object)
         updater.list_append(column_name, object)
         to_modify { super }
       end
       alias_method :<<, :push
 
       def replace(array)
+        array = cast_collection(array)
         updater.set(column_name => array)
         to_modify { super }
       end
 
       def unshift(*objs)
+        objs.map!(&method(:cast_element))
         updater.list_prepend(column_name, objs.reverse)
         to_modify { super }
       end
@@ -175,6 +189,7 @@ module Cequel
         each { |method| undef_method(method) if method_defined? method }
 
       def add(object)
+        object = cast_element(object)
         updater.set_add(column_name, object)
         to_modify { super }
       end
@@ -186,11 +201,13 @@ module Cequel
       end
 
       def delete(object)
+        object = cast_element(object)
         updater.set_remove(column_name, object)
         to_modify { super }
       end
 
       def replace(set)
+        set = cast_collection(set)
         updater.set(column_name => set)
         to_modify { super }
       end
@@ -200,6 +217,7 @@ module Cequel
     class Map < DelegateClass(::Hash)
 
       include Collection
+      extend Forwardable
 
       NON_ATOMIC_MUTATORS = [
         :default,
@@ -226,6 +244,7 @@ module Cequel
         each { |method| undef_method(method) if method_defined? method }
 
       def []=(key, value)
+        key = cast_key(key)
         updater.map_update(column_name, key => value)
         to_modify { super }
       end
@@ -237,21 +256,28 @@ module Cequel
       end
 
       def delete(key)
+        key = cast_key(key)
         deleter.map_remove(column_name, key)
         to_modify { super }
       end
 
       def merge!(hash)
+        hash = cast_collection(hash)
         updater.map_update(column_name, hash)
         to_modify { super }
       end
       alias_method :update, :merge!
 
       def replace(hash)
+        hash = cast_collection(hash)
         updater.set(column_name => hash)
         to_modify { super }
       end
 
+      private
+      def_delegator 'column.key_type', :cast, :cast_key
+      private :cast_key
+
     end
 
   end

data/lib/cequel/record/persistence.rb

@@ -41,6 +41,7 @@ module Cequel
       alias :exist? :exists?
 
       def load
+        assert_keys_present!
         unless loaded?
           row = metal_scope.first
           hydrate(row) unless row.nil?
@@ -77,6 +78,7 @@ module Cequel
       end
 
       def destroy
+        assert_keys_present!
         metal_scope.delete
         transient!
         self
@@ -105,12 +107,14 @@ module Cequel
       end
 
       def create
+        assert_keys_present!
         metal_scope.insert(attributes.reject { |attr, value| value.nil? })
         loaded!
         persisted!
       end
 
       def update
+        assert_keys_present!
         connection.batch do
           updater.execute
           deleter.execute
@@ -135,13 +139,21 @@ module Cequel
         super
       end
 
-      def write_attribute(attribute, value)
+      def write_attribute(name, value)
+        column = self.class.reflect_on_column(name)
+        raise UnknownAttributeError, "unknown attribute: #{name}" unless column
+        value = column.cast(value) unless value.nil?
+
         super.tap do
           unless new_record?
+            if key_attributes.keys.include?(name)
+              raise ArgumentError, "Can't update key #{name} on persisted record"
+            end
+
             if value.nil?
-              deleter.delete_columns(attribute)
+              deleter.delete_columns(name)
             else
-              updater.set(attribute => value)
+              updater.set(name => value)
             end
           end
         end
@@ -178,6 +190,14 @@ module Cequel
         @attributes_for_deletion ||= []
       end
 
+      def assert_keys_present!
+        missing_keys = key_attributes.select { |k, v| v.nil? }
+        if missing_keys.any?
+          raise MissingKeyError,
+            "Missing required key values: #{missing_keys.keys.join(', ')}"
+        end
+      end
+
     end
 
   end

data/lib/cequel/record/properties.rb

@@ -72,13 +72,13 @@ module Cequel
         end
 
         def def_reader(name)
-          module_eval <<-RUBY
+          module_eval <<-RUBY, __FILE__, __LINE__+1
             def #{name}; read_attribute(#{name.inspect}); end
           RUBY
         end
 
         def def_writer(name)
-          module_eval <<-RUBY
+          module_eval <<-RUBY, __FILE__, __LINE__+1
             def #{name}=(value); write_attribute(#{name.inspect}, value); end
           RUBY
         end
@@ -89,7 +89,7 @@ module Cequel
         end
 
         def def_collection_reader(name, collection_proxy_class)
-          module_eval <<-RUBY
+          module_eval <<-RUBY, __FILE__, __LINE__+1
             def #{name}
               proxy_collection(#{name.inspect}, #{collection_proxy_class})
             end
@@ -97,7 +97,7 @@ module Cequel
         end
 
         def def_collection_writer(name)
-          module_eval <<-RUBY
+          module_eval <<-RUBY, __FILE__, __LINE__+1
             def #{name}=(value)
               reset_collection_proxy(#{name.inspect})
               write_attribute(#{name.inspect}, value)
@@ -163,16 +163,14 @@ module Cequel
       end
 
       def write_attribute(name, value)
-        column = self.class.reflect_on_column(name)
-        raise UnknownAttributeError,
-          "unknown attribute: #{name}" unless column
-        @attributes[name] = value.nil? ? nil : column.cast(value)
+        @attributes[name] = value
       end
 
       private
 
-      def proxy_collection(name, proxy_class)
-        collection_proxies[name] ||= proxy_class.new(self, name)
+      def proxy_collection(column_name, proxy_class)
+        column = self.class.reflect_on_column(column_name)
+        collection_proxies[column_name] ||= proxy_class.new(self, column)
       end
 
       def reset_collection_proxy(name)

data/lib/cequel/record/record_set.rb

@@ -8,8 +8,6 @@ module Cequel
       extend Cequel::Util::HashAccessors
       include Enumerable
 
-      Bound = Struct.new(:value, :inclusive)
-
       def self.default_attributes
         {:scoped_key_values => [], :select_columns => []}
       end
@@ -34,7 +32,7 @@ module Cequel
       end
 
       def where(column_name, value)
-        column = clazz.table_schema.column(column_name)
+        column = clazz.reflect_on_column(column_name)
         raise IllegalQuery,
           "Can't scope by more than one indexed column in the same query" if scoped_indexed_column
         raise ArgumentError,
@@ -43,17 +41,21 @@ module Cequel
           "Use the `at` method to restrict scope by primary key" unless column.data_column?
         raise ArgumentError,
           "Can't scope by non-indexed column #{column_name}" unless column.indexed?
-        scoped(scoped_indexed_column: {column_name => value})
+        scoped(scoped_indexed_column: {column_name => column.cast(value)})
       end
 
       def at(*scoped_key_values)
         scoped do |attributes|
-          attributes[:scoped_key_values].concat(scoped_key_values)
+          type_cast_key_values = scoped_key_values.zip(unscoped_key_columns).
+            map { |value, column| column.cast(value) }
+          attributes[:scoped_key_values].concat(type_cast_key_values)
         end
       end
 
       def [](scoped_key_value)
-        if next_key_column
+        scoped_key_value = cast_range_key(scoped_key_value)
+
+        if next_range_key_column
           at(scoped_key_value)
         else
           attributes = {}
@@ -74,17 +76,17 @@ module Cequel
       end
 
       def after(start_key)
-        scoped(lower_bound: Bound.new(start_key, false))
+        scoped(lower_bound: bound(true, false, start_key))
       end
 
       def before(end_key)
-        scoped(upper_bound: Bound.new(end_key, false))
+        scoped(upper_bound: bound(false, false, end_key))
       end
 
       def in(range)
         scoped(
-          lower_bound: Bound.new(range.first, true),
-          upper_bound: Bound.new(range.last, !range.exclude_end?)
+          lower_bound: bound(true, true, range.first),
+          upper_bound: bound(false, !range.exclude_end?, range.last)
         )
       end
 
@@ -93,7 +95,7 @@ module Cequel
           raise IllegalQuery,
             "Can't construct exclusive range on partition key #{range_key_name}"
         end
-        scoped(lower_bound: Bound.new(start_key, true))
+        scoped(lower_bound: bound(true, true, start_key))
       end
 
       def upto(end_key)
@@ -101,7 +103,7 @@ module Cequel
           raise IllegalQuery,
             "Can't construct exclusive range on partition key #{range_key_name}"
         end
-        scoped(upper_bound: Bound.new(end_key, true))
+        scoped(upper_bound: bound(false, true, end_key))
       end
 
       def reverse
@@ -186,7 +188,7 @@ module Cequel
       end
 
       def find_nested_batches_from(row, options, &block)
-        if next_key_column
+        if next_range_key_column
           at(row[range_key_name]).
             next_batch_from(row).
             find_rows_in_batches(options, &block)
@@ -204,43 +206,57 @@ module Cequel
         end
       end
 
+      def scoped_key_names
+        scoped_key_columns.map { |column| column.name }
+      end
+
+      def scoped_key_columns
+        clazz.key_columns.first(scoped_key_values.length)
+      end
+
+      def unscoped_key_columns
+        clazz.key_columns.drop(scoped_key_values.length)
+      end
+
+      def unscoped_key_names
+        unscoped_key_columns.map { |column| column.name }
+      end
+
       def range_key_column
-        clazz.key_columns[scoped_key_values.length]
+        unscoped_key_columns.first
       end
 
       def range_key_name
         range_key_column.name
       end
 
-      def scoped_key_columns
-        clazz.key_columns.first(scoped_key_values.length)
+      def next_range_key_column
+        unscoped_key_columns.second
       end
 
-      def scoped_key_names
-        scoped_key_columns.map { |column| column.name }
+      def next_range_key_name
+        next_range_key_column.try(:name)
       end
 
       def single_partition?
         scoped_key_values.length >= clazz.partition_key_columns.length
       end
 
+      # Try to order results by the first clustering column. Fall back to partition key if none exist.
+      def order_by_column
+        clazz.clustering_columns.first.name if clazz.clustering_columns.any?
+      end
+
       private
       attr_reader :clazz
       def_delegators :clazz, :connection
-      private :connection
+      def_delegator :range_key_column, :cast, :cast_range_key
+      private :connection, :cast_range_key
 
       def method_missing(method, *args, &block)
         clazz.with_scope(self) { super }
       end
 
-      def next_key_column
-        clazz.key_columns[scoped_key_values.length + 1]
-      end
-
-      def next_key_name
-        next_key_column.name if next_key_column
-      end
-
       def construct_data_set
         data_set = connection[clazz.table_name]
         data_set = data_set.limit(row_limit) if row_limit
@@ -250,24 +266,26 @@ module Cequel
           data_set = data_set.where(key_conditions)
         end
         if lower_bound
-          fragment = construct_bound_fragment(lower_bound, '>')
-          data_set = data_set.where(fragment, lower_bound.value)
+          data_set = data_set.where(*lower_bound.to_cql_with_bind_variables)
         end
         if upper_bound
-          fragment = construct_bound_fragment(upper_bound, '<')
-          data_set = data_set.where(fragment, upper_bound.value)
+          data_set = data_set.where(*upper_bound.to_cql_with_bind_variables)
         end
-        data_set = data_set.order(range_key_name => :desc) if reversed?
+        data_set = data_set.order(order_by_column => :desc) if reversed?
         data_set = data_set.where(scoped_indexed_column) if scoped_indexed_column
         data_set
       end
 
-      def construct_bound_fragment(bound, base_operator)
-        operator = bound.inclusive ? "#{base_operator}=" : base_operator
-        single_partition? ?
-          "#{range_key_name} #{operator} ?" :
-          "TOKEN(#{range_key_name}) #{operator} TOKEN(?)"
+      def bound(gt, inclusive, value)
+        Bound.create(range_key_column, gt, inclusive, value)
+      end
 
+      def cast_range_key_for_bound(value)
+        if range_key_column.type?(Type::Timeuuid) && !value.is_a?(CassandraCQL::UUID)
+          Type::Timestamp.instance.cast(value)
+        else
+          cast_range_key(value)
+        end
       end
 
       def scoped(new_attributes = {}, &block)