cassie 1.0.0.beta.17 → 1.0.0.beta.21

data/lib/cassie/statements/core.rb

@@ -0,0 +1,23 @@
+require_relative 'statement'
+require_relative 'execution'
+require_relative 'logging'
+
+module Cassie::Statements
+  module Core
+    extend ActiveSupport::Concern
+
+    included do
+      include Statement
+      include Execution
+      include Logging
+    end
+
+    def initialize(params={})
+      params.each do |attr, value|
+        self.public_send("#{attr}=", value)
+      end
+
+      super()
+    end
+  end
+end

data/lib/cassie/{queries/statement/batches.rb → statements/execution/batched_fetching.rb}

@@ -1,9 +1,5 @@
-require_relative 'relation'
-require_relative 'loading'
-require_relative 'batches'
-
-module Cassie::Queries::Statement
-  module Batches
+module Cassie::Statements::Execution
+  module BatchedFetching
     extend ::ActiveSupport::Concern
 
     included do
@@ -54,10 +50,10 @@ module Cassie::Queries::Statement
     def fetch_in_batches(opts={})
       opts[:batch_size] ||= 1000
 
-      # clone the query as soon as the enumerable is created
-      # rather than waiting until the firt iteration is executed
-      # as the client could mutate the object between these states.
-      # However we don't want to clone twice if a block isn't passed
+      # spawn the new query as soon as the enumerable is created
+      # rather than waiting until the firt iteration is executed.
+      # The client could mutate the object between these moments,
+      # however we don't want to spawn twice if a block isn't passed.
       paged_query = opts.delete(:_paged_query) || self.clone
 
       return to_enum(:fetch_in_batches, opts.merge(_paged_query: paged_query)) unless block_given?
@@ -87,7 +83,7 @@ module Cassie::Queries::Statement
     private
 
     def page_size_changed_error(original_size)
-      Cassie::Queries::Statement::Invalid.new("Page size is no longer valid. It was #{original_size} when the batch was started, and is now #{self.page_size}. Continuing would cause unexpected results.")
+      Cassie::Statements::Statement::Invalid.new("Page size is no longer valid. It was #{original_size} when the batch was started, and is now #{self.page_size}. Continuing would cause unexpected results.")
     end
   end
 end

data/lib/cassie/{queries/statement → statements/execution}/callbacks.rb

@@ -1,4 +1,4 @@
-module Cassie::Queries::Statement
+module Cassie::Statements::Execution
   module Callbacks
     extend ActiveSupport::Concern
 

data/lib/cassie/{queries/statement → statements/execution}/consistency.rb

@@ -1,4 +1,4 @@
-module Cassie::Queries::Statement
+module Cassie::Statements::Execution
   module Consistency
     extend ActiveSupport::Concern
 

data/lib/cassie/statements/execution/deserialization.rb

@@ -0,0 +1,13 @@
+module Cassie::Statements::Execution
+  module Deserialization
+
+    protected
+
+    def build_result(row)
+      # Default implementation builds
+      # a struct with the row data for
+      # more convenient data access
+      Struct.new(*row.keys.map(&:to_sym)).new(*row.values)
+    end
+  end
+end

data/lib/cassie/{queries/statement → statements/execution}/fetching.rb

@@ -1,19 +1,15 @@
-require_relative 'relation'
-require_relative 'loading'
-require_relative 'batches'
+class Cassie::Statements::RecordNotFound < StandardError; end
 
-class Cassie::Queries::RecordNotFound < StandardError; end
+module Cassie::Statements::Execution
+  require_relative 'batched_fetching'
+  require_relative 'deserialization'
 
-module Cassie::Queries::Statement
   module Fetching
     extend ActiveSupport::Concern
 
     included do
-      include Loading
-      include Batches
-      #TODO: should this be loaded from instrumentation
-      # by using notifications when fetching is loaded?
-      include Cassie::Queries::Instrumentation::Loading
+      include BatchedFetching
+      include Deserialization
     end
 
     # Returns array of rows or empty array
@@ -27,7 +23,7 @@ module Cassie::Queries::Statement
       end
 
       execute
-      result.rows
+      result
     end
 
     # Returns first result or nil
@@ -38,15 +34,8 @@ module Cassie::Queries::Statement
     #   query.fetch_first(id: 2)
     #   => nil
     def fetch_first(args={})
-      old_limit = defined?(@limit) ? @limit : nil
-      self.limit = 1
-
-      fetch(args).first
-    ensure
-      if old_limit
-        @limit = old_limit
-      else
-        remove_instance_variable(:@limit)
+      with_limit(1) do
+        fetch(args).first
       end
     end
 
@@ -58,7 +47,7 @@ module Cassie::Queries::Statement
     #   query.fetch_first!(id: 2)
     #   RecordNotFound: RecordNotFound
     def fetch_first!(args={})
-      fetch_first || raise(Cassie::Queries::RecordNotFound.new('CQL row does not exist'))
+      fetch_first || raise(Cassie::Statements::RecordNotFound.new('CQL row does not exist'))
     end
   end
 end

data/lib/cassie/{queries/instrumentation/execution.rb → statements/execution/instrumentation.rb}

@@ -1,5 +1,5 @@
-module Cassie::Queries::Instrumentation
-  module Execution
+module Cassie::Statements::Execution
+  module Instrumentation
 
     def execute
       instrumenter.instrument("cassie.cql.execution") do |payload|
@@ -9,6 +9,10 @@ module Cassie::Queries::Instrumentation
         execution_val
       end
     end
+
+    def instrumenter
+      Cassie::Statements.instrumenter
+    end
   end
 end
 

data/lib/cassie/statements/execution/partition_linking/cursoring_policy.rb

@@ -0,0 +1,13 @@
+require_relative 'simple_policy'
+
+module Cassie::Statements::Execution::PartitionLinking
+  class CursoringPolicy < SimplePolicy
+
+    def prepare_execution
+      super
+      # We are changing to the next partition
+      # so, reset the max cursor to start at the top
+      # execution.max_cursor = nil
+    end
+  end
+end

data/lib/cassie/statements/execution/partition_linking/policy_methods.rb

@@ -0,0 +1,128 @@
+# Note: currently supports only natural linking
+# that is in the same direction as the clustering order
+module Cassie::Statements::Execution::PartitionLinking
+  module PolicyMethods
+    extend ActiveSupport::Concern
+
+    included do
+      attr_reader :identifier, :direction, :range, :peeking_execution, :execution
+    end
+
+    def initialize(executed, identifier, direction, range)
+      @peeking_execution = executed
+      @identifier = identifier
+      @direction = direction
+      @range = range
+    end
+
+    def link
+      if end_of_partition? && partition_available?
+        prepare_execution
+        execution.execute
+        combine_results
+      else
+        peeking_execution.result
+      end
+    end
+
+    def prepare_execution
+      @execution = peeking_execution.clone
+      change_partition
+      adjust_limit
+      execution
+    end
+
+    def end_of_partition?
+      !peeking_execution.result.peeked_row
+    rescue NoMethodError => ex
+      message = "Results aren't available for linking. Did you forget to call `execute`?" if peeking_execution.result.nil?
+      message ||= "Peeking not enabled. To link partitions, peeking must be included in the execution. Did you forget to call `link_partitions`?"
+      raise ArgumentError, message
+    end
+
+    def partition_available?
+      if ascending?
+        #     |0| |1| |2| |3|
+        # |X| |✓| |✓| |✓| |X|
+        current_key < last_key && current_key >= first_key
+      else
+        # |0| |1| |2| |3|
+        # |X| |✓| |✓| |✓|  |X|
+        current_key > first_key && current_key <= last_key
+      end
+    end
+
+    protected
+
+    def first_key
+      eval_opt(range.first, peeking_execution)
+    end
+
+    def last_key
+      eval_opt(range.last, peeking_execution)
+    end
+
+    def change_partition
+      _partition = if ascending?
+        # explicitly pass key to keep policy subclass
+        # interface clear and consistent
+        next_key(current_key)
+      else
+        # explicitly pass key to keep policy subclass
+        # interface clear and consistent
+        previous_key(current_key)
+      end
+      if _partition < first_key || _partition > last_key
+        logger.warn("[WARN] linking to partition that is outside of ranges defined. #{_partition} outside of (#{first_key}..#{last_key}). This could result in unexpected records being returned.")
+      end
+
+      # define object singleton method to
+      # override getter for partition key
+      # returning the partion that needs to be linked
+      execution.define_singleton_method(identifier) do
+        _partition
+      end
+    end
+
+    def adjust_limit
+      execution.limit = execution.limit - peeked_rows.count
+    end
+
+    def current_key
+      peeking_execution.send(identifier)
+    end
+
+    def combine_results
+      rows = combine_rows(peeked_rows.to_a , execution_rows.to_a)
+      execution.result.define_singleton_method(:rows) do
+        rows
+      end
+      execution.result
+    end
+
+    def ascending?
+      [:ascending, :asc, :ASC].include? direction
+    end
+
+    def peeked_rows
+      peeking_execution.result.rows
+    end
+
+    def execution_rows
+      execution.result.rows
+    end
+
+    def logger
+      Cassie::Statements.logger
+    end
+
+    def eval_opt(value, _source=source)
+      case value
+      when Symbol
+        _source.send(value)
+      else
+        value
+      end
+    end
+  end
+end

data/lib/cassie/statements/execution/partition_linking/simple_policy.rb

@@ -0,0 +1,19 @@
+require_relative 'policy_methods'
+
+module Cassie::Statements::Execution::PartitionLinking
+  class SimplePolicy
+    include PolicyMethods
+
+    def combine_rows(rows_a, rows_b)
+      rows_a + rows_b
+    end
+
+    def next_key(current_key)
+      current_key + 1
+    end
+
+    def previous_key(current_key)
+      current_key - 1
+    end
+  end
+end

data/lib/cassie/statements/execution/partition_linking.rb

@@ -0,0 +1,49 @@
+module Cassie::Statements::Execution
+  module PartitionLinking
+    require_relative 'partition_linking/simple_policy'
+    require_relative 'partition_linking/cursoring_policy'
+
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def link_partitions(*args)
+        include Peeking
+        self.partition_linker_args = args
+      end
+
+      def partition_linker=(val)
+        @partition_linker = val
+      end
+
+      def partition_linker
+        @partition_linker || SimplePolicy
+      end
+
+      def partition_linker_args=(val)
+        @partition_linker_args = val
+      end
+
+      def partition_linker_args
+        @partition_linker_args if defined?(@partition_linker_args)
+      end
+    end
+
+    def execute
+      success = super
+      if success && partition_linker?
+        @result = build_partition_linker.link
+        result.success?
+      else
+        success
+      end
+    end
+
+    def build_partition_linker
+      self.class.partition_linker.new(self, *self.class.partition_linker_args)
+    end
+
+    def partition_linker?
+      !!self.class.partition_linker_args
+    end
+  end
+end

data/lib/cassie/statements/execution/peeking.rb

@@ -0,0 +1,28 @@
+module Cassie::Statements::Execution
+  module Peeking
+    extend ActiveSupport::Concern
+
+    included do
+      @result_class = Cassie::Statements::Results::PeekingResult
+    end
+
+    def execute
+      assert_limit
+      with_limit(limit + 1) { super }
+    end
+
+    protected
+
+    def result_opts
+      super.merge(limit: limit - 1)
+    end
+
+    private
+
+    def assert_limit
+      if limit.nil?
+        raise ArgumentError, "Cassie Peeking is enabled, but the statement limit is `nil`. A limit is required to peek at the next result. Did you accidentally set `Cassie::Statements.limit = nil` instead of disabling the limit for only a specific query?"
+      end
+    end
+  end
+end

data/lib/cassie/statements/execution/results/core.rb

@@ -0,0 +1,11 @@
+module Cassie::Statements::Results
+  module Core
+
+    def success?
+      # TODO: remove - don't think we need this exception
+      # raise "execution not complete, no results to parse" unless result
+
+      true
+    end
+  end
+end

data/lib/cassie/statements/execution/results/cursored_result.rb

@@ -0,0 +1,26 @@
+module Cassie::Statements::Results
+  require_relative 'querying'
+  require_relative 'peeking'
+
+  class CursoredResult < Result
+    include  Querying
+    include  Peeking
+
+    attr_reader :max_cursor_key
+
+    def after_initialize(opts)
+      super
+      @max_cursor_key = opts[:max_cursor_key]
+
+      define_singleton_method "next_max_#{max_cursor_key}" do
+        next_max_cursor
+      end
+    end
+
+    def next_max_cursor
+      if peeked_row
+        peeked_row[max_cursor_key]
+      end
+    end
+  end
+end

data/lib/cassie/statements/execution/results/instrumentation.rb

@@ -0,0 +1,18 @@
+module Cassie::Statements::Results
+  module Instrumentation
+
+    protected
+
+    def records
+      instrumenter.instrument("cassie.deserialize") do |payload|
+        records = super
+        payload[:count] = records.count if records.respond_to?(:count)
+        records
+      end
+    end
+
+    def instrumenter
+      Cassie::Statements.instrumenter
+    end
+  end
+end

data/lib/cassie/statements/execution/results/modification.rb

@@ -0,0 +1,12 @@
+module Cassie::Statements::Results
+  module Modification
+
+    def success?
+      # when using conditional update, the server will respond
+      # with a result-set containing a special result named "[applied]".
+      return false if rows.first && rows.first["[applied]"] == false
+
+      super
+    end
+  end
+end

data/lib/cassie/statements/execution/results/modification_result.rb

@@ -0,0 +1,8 @@
+module Cassie::Statements::Results
+  require_relative 'modification'
+
+  class ModificationResult < Result
+    include  Modification
+
+  end
+end

data/lib/cassie/statements/execution/results/peeking.rb

@@ -0,0 +1,42 @@
+module Cassie::Statements::Results
+  module Peeking
+    extend ActiveSupport::Concern
+
+    included do
+      attr_reader :limit
+      attr_reader :peeked_row
+    end
+
+    def peeked_result
+      return @peeked_result if defined?(@peeked_result)
+
+      @peeked_result = if peeked_row
+        each_deserializer.call(peeked_row)
+      end
+    end
+
+    protected
+
+    def after_initialize(opts={})
+      super
+      @limit = opts[:limit]
+      extract_peeked_rows_after(limit)
+    end
+
+    def extract_peeked_rows_after(limit)
+      peeked_count = rows.count - limit
+      @peeked_row = case
+      when peeked_count == 1
+        raw_rows.delete_at(-1)
+      when peeked_count <= 0
+        nil
+      else
+        raise "More than one row was peeked at. Please report this Cassie issue: https://github.com/eprothro/cassie/issues."
+      end
+    end
+
+    def raw_rows
+      __getobj__.instance_variable_get(:@rows)
+    end
+  end
+end

data/lib/cassie/statements/execution/results/peeking_result.rb

@@ -0,0 +1,10 @@
+module Cassie::Statements::Results
+  require_relative 'querying'
+  require_relative 'peeking'
+
+  class PeekingResult < Result
+    include  Querying
+    include  Peeking
+
+  end
+end

data/lib/cassie/statements/execution/results/query_result.rb

@@ -0,0 +1,9 @@
+module Cassie::Statements::Results
+  require_relative 'querying'
+
+  class QueryResult < Result
+    include  Querying
+
+  end
+end
+

data/lib/cassie/statements/execution/results/querying.rb

@@ -0,0 +1,66 @@
+module Cassie::Statements::Results
+  require_relative 'instrumentation'
+
+  module Querying
+    extend ActiveSupport::Concern
+
+    included do
+      # enumerate on domain specific models
+      # not on underlying Cassandra::Result rows
+      #
+      # e.g. include? should compare against the
+      #      deserialized objects, not the underlying
+      #      row hashes.
+      include Enumerable
+      include Instrumentation
+
+      attr_reader :deserializer
+      attr_reader :each_deserializer
+    end
+
+    def after_initialize(opts)
+      super
+      @each_deserializer = opts[:each_deserializer]
+      @deserializer = opts[:deserializer]
+      ensure_deserialization
+    end
+
+    # Deserialize each row into domain objects
+    #
+    # note: __object__.each is aliased
+    # as rows and each_row.
+    def each(&block)
+      if block_given?
+        records.each(&block)
+        self
+      else
+        records.each
+      end
+    end
+
+    def success?
+      # an empty query is still successful
+      return true if __getobj__.empty?
+
+      super
+    end
+
+    protected
+
+    def records
+      @records ||= deserializer.call(rows)
+    end
+
+    def ensure_deserialization
+      @deserializer ||= method(each_deserializer ? :map_deserialize : :pass_through_deserialize)
+    end
+
+    def pass_through_deserialize(hashes)
+      hashes
+    end
+
+    def map_deserialize(hashes)
+      hashes.map{|hash| each_deserializer.call(hash) }
+    end
+  end
+end

data/lib/cassie/statements/execution/results/result.rb

@@ -0,0 +1,23 @@
+module Cassie::Statements::Results
+  require_relative 'core'
+
+  class Result < SimpleDelegator
+    # __obj__ is Cassandra::Result, which is enumerable
+    include Core
+
+    def initialize(obj, opts={})
+      super(obj)
+      after_initialize(opts)
+    end
+
+    protected
+
+    # Result will be the superclass
+    # of concrete result classes
+    # so any overrides defined in subclasses
+    # or modules included in subclasses
+    # will get called first
+    def after_initialize(opts)
+    end
+  end
+end

data/lib/cassie/statements/execution/results.rb

@@ -0,0 +1,12 @@
+require 'delegate'
+
+module Cassie::Statements
+  module Results
+    require_relative 'results/result'
+    require_relative 'results/modification_result'
+    require_relative 'results/query_result'
+    require_relative 'results/peeking_result'
+    require_relative 'results/cursored_result'
+
+  end
+end