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

data/lib/cassie/statements/execution.rb

@@ -0,0 +1,69 @@
+module Cassie::Statements
+  module Execution
+    require_relative 'execution/consistency'
+    require_relative 'execution/callbacks'
+    require_relative 'execution/results'
+    require_relative 'execution/partition_linking'
+    require_relative 'execution/instrumentation'
+
+    extend ActiveSupport::Concern
+    included do
+      attr_reader :result
+
+      include Consistency
+      include Callbacks
+      include PartitionLinking
+      include Instrumentation
+    end
+
+    module ClassMethods
+      def inherited(subclass)
+        subclass.result_class = result_class if defined?(@result_class)
+        super
+      end
+
+      def result_class
+        return @result_class if defined?(@result_class)
+        Cassie::Statements::Results::Result
+      end
+
+      def result_class=(val)
+        @result_class = val
+      end
+    end
+
+    # Executes the statment, populates result
+    # returns true or false indicating a successful execution or not
+    def execute
+      @result = result_class.new(session.execute(statement, execution_options), result_opts)
+      result.success?
+    end
+
+    def execution_options
+      {}.tap do |opts|
+        #TODO: rework consistency module to be more
+        #      abstract implementation for all execution options
+        opts[:consistency] = consistency if consistency
+        opts[:paging_state] = paging_state if respond_to?(:paging_state) && paging_state
+        opts[:page_size] = stateless_page_size if respond_to?(:stateless_page_size) && stateless_page_size
+      end
+    end
+
+    protected
+
+    def result_class
+      self.class.result_class
+    end
+
+    def result_opts
+      {}
+    end
+
+    private
+
+    def initialize_copy(other)
+      super
+      @result = nil
+    end
+  end
+end

data/lib/cassie/statements/instrumenting.rb

@@ -0,0 +1,6 @@
+module Cassie::Statements
+
+  def self.instrumenter
+    @instrumenter ||= ActiveSupport::Notifications
+  end
+end

data/lib/cassie/{queries/logging/building_resources_event.rb → statements/logging/deserialize_event.rb}

@@ -1,5 +1,5 @@
-module Cassie::Queries::Logging
-  class BuildingResourcesEvent < ActiveSupport::Notifications::Event
+module Cassie::Statements::Logging
+  class DeserializeEvent < ActiveSupport::Notifications::Event
 
     def count
       payload[:count]
@@ -7,7 +7,7 @@ module Cassie::Queries::Logging
 
     def message
       {
-        event: "cassie.building_resources",
+        event: "cassie.deserialize",
         duration: duration.round(1),
         count: count
       }.extend(Inspector)
@@ -15,7 +15,7 @@ module Cassie::Queries::Logging
 
     module Inspector
       def inspect
-        color("(#{fetch(:duration).round(1)}ms) #{fetch(:count)} resource #{'object'.pluralize(fetch(:count))} built from Cassandra query result")
+        color("(#{fetch(:duration).round(1)}ms) #{fetch(:count)} #{'result'.pluralize(fetch(:count))} deserialized from Cassandra rows")
       end
 
       def to_s

data/lib/cassie/statements/logging/deserialize_subscriber.rb

@@ -0,0 +1,19 @@
+require_relative 'deserialize_event'
+
+module Cassie::Statements::Logging
+  class DeserializeSubscriber
+
+    def call(*args)
+      # don't log if instrumentation failed
+      unless args.last[:exception]
+        logger.debug(DeserializeEvent.new(*args).message)
+      end
+    end
+
+    def logger
+      Cassie::Statements.logger
+    end
+
+    ActiveSupport::Notifications.subscribe('cassie.deserialize', new)
+  end
+end

data/lib/cassie/{queries/logging/cql_execution_event.rb → statements/logging/execute_event.rb}

@@ -1,5 +1,5 @@
-module Cassie::Queries::Logging
-  class CqlExecutionEvent < ActiveSupport::Notifications::Event
+module Cassie::Statements::Logging
+  class ExecuteEvent < ActiveSupport::Notifications::Event
 
     def duration # in milliseconds
       return super unless traced?
@@ -26,8 +26,12 @@ module Cassie::Queries::Logging
     def statement
       if execution_info
         statement = execution_info.statement
-        str = statement.cql
-        str += " #{statement.params.map(&:to_s)}" if statement.respond_to? :params
+        if statement.respond_to? :cql
+          str = statement.cql.dup
+          str << " #{statement.params.map(&:to_s)}" if statement.respond_to? :params
+        else
+          str = statement.to_s
+        end
         str
       else
         "CQL executed: (`execution_info` was not present?)"

data/lib/cassie/statements/logging/execute_subscriber.rb

@@ -0,0 +1,19 @@
+require_relative 'execute_event'
+
+module Cassie::Statements::Logging
+  class ExecuteSubscriber
+
+    def call(*args)
+      # don't log if instrumentation failed
+      unless args.last[:exception]
+        logger.debug(ExecuteEvent.new(*args).message)
+      end
+    end
+
+    def logger
+      Cassie::Statements.logger
+    end
+
+    ActiveSupport::Notifications.subscribe('cassie.cql.execution', new)
+  end
+end

data/lib/cassie/statements/logging.rb

@@ -0,0 +1,12 @@
+module Cassie::Statements
+  require_relative 'logging/execute_subscriber'
+  require_relative 'logging/deserialize_subscriber'
+
+  def self.logger
+    @logger ||= Cassie.logger
+  end
+
+  def self.logger=(new_logger)
+    @logger = new_logger || ::Logger.new('/dev/null')
+  end
+end

data/lib/cassie/statements/modification.rb

@@ -0,0 +1,14 @@
+module Cassie::Statements
+  require_relative 'statement/inserting'
+  require_relative 'statement/updating'
+  require_relative 'statement/deleting'
+  module Modification
+    extend ActiveSupport::Concern
+
+    included do
+      include Statement::Updating
+      include Statement::Deleting
+      include Statement::Inserting
+    end
+  end
+end

data/lib/cassie/statements/query.rb

@@ -0,0 +1,12 @@
+module Cassie::Statements
+  require_relative 'statement/selection'
+  require_relative 'execution/fetching'
+  module Query
+    extend ActiveSupport::Concern
+
+    included do
+      include Statement::Selection
+      include Execution::Fetching
+    end
+  end
+end

data/lib/cassie/statements/statement/assignment.rb

@@ -0,0 +1,51 @@
+module Cassie::Statements::Statement
+  #    set "username = ?", value: :username
+  #    set :favs, term: 'favs + ?', value: "{ 'movie' : 'Cassablanca' }"
+  #    set :username
+  class Assignment
+    # https://cassandra.apache.org/doc/cql3/CQL.html#updateStmt
+
+    attr_reader :source,
+                :identifier,
+                :value,
+                :enabled,
+                :term
+
+    def initialize(source, identifier, value_method, opts={})
+      @source = source
+      @identifier = identifier
+      @value = source.send(value_method)
+      @enabled = opts.has_key?(:if) ? source_eval(opts[:if]) : true
+      @term = opts.has_key?(:term) ? source_eval(opts[:term]) : "?"
+    end
+
+    def enabled?
+      !!enabled
+    end
+
+    def argument
+      return nil unless enabled? && positional?
+      value
+    end
+
+    def positional?
+      term.to_s.include?("?")
+    end
+
+    def to_update_cql
+      return nil unless enabled?
+      "#{identifier} = #{term}"
+    end
+
+    private
+
+    def source_eval(value, _source=source)
+      case value
+      when Symbol
+        _source.send(value)
+      else
+        value
+      end
+    end
+  end
+end

data/lib/cassie/statements/statement/assignments.rb

@@ -0,0 +1,87 @@
+require_relative 'assignment'
+require_relative 'mapping'
+
+module Cassie::Statements::Statement
+  # Provides support for a set of CQL assignments
+  # and building the insert/update clause and argument list
+  # for a cql statement
+  #
+  # CQL Relation terminology:
+  #
+  #   "INSERT INTO table (id, username) VALUES (?, ?);", [1, 'eprothro']
+  #
+  # identifiers: ['id', 'username']
+  # terms:       ['?', '?']
+  # arguments:   [1, 'eprothro']
+  #
+  #   "UPDATE table SET id = ?, username = ? WHERE...;", [1, 'eprothro']
+  #
+  # identifiers: ['id', 'username']
+  # terms:       ['?', '?']
+  # arguments:   [1, 'eprothro']
+  module Assignments
+    extend ActiveSupport::Concern
+
+    included do
+      include Mapping
+    end
+
+    module ClassMethods
+      def set(identifier, opts={})
+        opts[:value] ||= identifier.to_sym
+
+        define_argument_accessor(opts[:value])
+
+        assignments_args << [identifier, opts.delete(:value), opts]
+      end
+
+      def assignments_args
+        @assignments_args ||= []
+      end
+    end
+
+    def assignments_args
+      self.class.assignments_args
+    end
+
+    def build_update_and_bindings
+      cql = ""
+      arguments = []
+      assignment_strings = []
+
+      assignments_args.each do |args|
+        a = Assignment.new(self, *args)
+        assignment_strings += Array(a.to_update_cql)
+        arguments += Array(a.argument)
+      end
+
+      cql = assignment_strings.join(', ')
+
+      [cql , arguments]
+    end
+
+    def build_insert_and_bindings
+      identifiers = []
+      terms = []
+      arguments = []
+
+      assignments_args.each do |args|
+        a = Assignment.new(self, *args)
+        identifiers += Array(a.identifier)
+        terms += Array(a.term)
+        arguments += Array(a.argument)
+      end
+
+      identifiers_cql = identifiers.join(", ")
+      terms_cql = terms.join(", ")
+
+      # (indentifier, identifier)
+      # VALUES
+      # (term, term);
+      # (identifiers_cql)
+      # VALUES
+      # (terms_cql);
+      [identifiers_cql, terms_cql , arguments]
+    end
+  end
+end

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

@@ -1,6 +1,4 @@
-require_relative 'assignment'
-
-module Cassie::Queries::Statement
+module Cassie::Statements::Statement
   module Conditions
     extend ActiveSupport::Concern
 

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

@@ -2,26 +2,34 @@ require_relative 'relations'
 require_relative 'conditions'
 require_relative 'mapping'
 
-module Cassie::Queries::Statement
+module Cassie::Statements::Statement
   module Deleting
     extend ::ActiveSupport::Concern
 
+    included do
+      include Relations
+      include Conditions
+      include Mapping
+
+      @result_class = Cassie::Statements::Results::ModificationResult
+    end
+
     module ClassMethods
       #TODO: accept block to add specific selectors and aliases
-      #      select :table do |t|
+      #      select_from :table do |t|
       #        t.id
       #        t.name as: :username
       #      end
-      def delete(table)
-        include Relations
-        include Conditions
-        include Mapping
-
+      def delete_from(table)
         self.table = table
         self.type = :delete
 
         yield(self) if block_given?
       end
+      def delete(table)
+        Cassie.logger.warn "[DEPRECATION] `Cassie::Modification#delete` has been replaced by `delete_from` and will be removed."
+        delete_from(table)
+      end
 
       # TODO rename to identifiers and extract
       def selectors
@@ -29,11 +37,6 @@ module Cassie::Queries::Statement
       end
     end
 
-    def delete(opts={})
-      execute
-      execution_successful?
-    end
-
     protected
 
     def build_delete_cql_and_bindings

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

@@ -1,25 +1,28 @@
 require_relative 'assignments'
 require_relative 'conditions'
 
-module Cassie::Queries::Statement
+module Cassie::Statements::Statement
   module Inserting
     extend ::ActiveSupport::Concern
 
-    module ClassMethods
-      def insert(table)
-        include Assignments
-        include Conditions
+    included do
+      include Assignments
+      include Conditions
 
+      @result_class = Cassie::Statements::Results::ModificationResult
+    end
+
+    module ClassMethods
+      def insert_into(table)
         self.table = table
         self.type = :insert
 
         yield(self) if block_given?
       end
-    end
-
-    def insert(opts={})
-      execute
-      execution_successful?
+      def insert(table)
+        Cassie.logger.warn "[DEPRECATION] `Cassie::Modification#insert` has been replaced by `insert_into` and will be removed."
+        insert_into(table)
+      end
     end
 
     protected

data/lib/cassie/statements/statement/limiting.rb

@@ -0,0 +1,89 @@
+module Cassie::Statements
+  def self.default_limit
+    return @default_limit if defined?(@default_limit)
+    500
+  end
+
+  def self.default_limit=(val)
+    @default_limit = val
+  end
+
+
+  module Statement::Limiting
+    extend ActiveSupport::Concern
+
+    included do
+      attr_writer :limit
+    end
+
+    module ClassMethods
+      def inherited(subclass)
+        subclass.limit = limit if defined?(@limit)
+        super
+      end
+
+      def limit=(val)
+        @limit = val
+      end
+
+      def limit(val=:get)
+        if val == :get
+          return @limit if defined?(@limit)
+          Cassie::Statements.default_limit
+        else
+          self.limit = val
+        end
+      end
+    end
+
+    def limit
+      return @limit if defined?(@limit)
+      self.class.limit
+    end
+
+    def with_limit(temp_limit)
+      raise ArgumentError, "block required for passing temporary limit" unless block_given?
+      define_limit_singleton(temp_limit)
+
+      yield
+    ensure
+      remove_limit_singleton
+    end
+
+    protected
+
+    def build_limit_str
+      return "" if limit.nil?
+
+      "LIMIT #{limit}"
+    end
+
+    private
+
+    def initialize_copy(other)
+      super
+      remove_limit_singleton
+    end
+
+    def define_limit_singleton(temp_limit)
+      assert_no_limit_singleton
+      define_singleton_method(:limit) do
+        temp_limit
+      end
+    end
+
+    def remove_limit_singleton
+      if singleton_methods.include?(:limit)
+        class << self
+          remove_method :limit
+        end
+      end
+    end
+
+    def assert_no_limit_singleton
+      if singleton_methods.include?(:limit)
+        raise NameError.new("A singleton method has already been defined for `limit`. `with_limit` can't be implemented.", :limit)
+      end
+    end
+  end
+end

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

@@ -1,37 +1,12 @@
-module Cassie::Queries::Statement
+module Cassie::Statements::Statement
   module Mapping
     extend ActiveSupport::Concern
 
-    MAPPED_METHODS = [:insert, :update, :delete].freeze
-
     included do
-      # We are mapping term values from a client object.
+      # We are mapping term values from a client provided resource.
       # store this object in `_resource` attribte
       # as they could reasonably want to name it `resource`
       attr_accessor :_resource
-
-      #TODO: consider simplifying by overriding
-      #      `execute` and aliasing via mapped methods
-      MAPPED_METHODS.each do |method|
-        # overwrite mapper methods that are defined (yuk)
-        next if !method_defined?(method)
-
-        define_method(method) do |value=nil, opts={}|
-          if value.nil?
-            # if no mapping is taking place, keep previously
-            # defined behavior/return value
-            return super(opts) if _resource.nil?
-          else
-            self._resource = value
-          end
-
-          if super(opts)
-            _resource
-          else
-            false
-          end
-        end
-      end
     end
 
     module ClassMethods
@@ -47,18 +22,22 @@ module Cassie::Queries::Statement
 
       protected
 
-      # define getter and setter
-      # methods that look up term values
+      # override definition of getter and setter
+      # methods to look up argument values
       # from resource object
-      def define_term_methods(field)
-        getter = field
-        setter = "#{field}="
+      def define_argument_accessor(name)
+        unless Symbol === name
+          raise ArgumentError, "A Symbol is required for the accessor methods for setting/getting a relation's value. #{name.class} (#{name}) given."
+        end
+
+        getter = name
+        setter = "#{name}="
 
         if method_defined?(getter) || method_defined?(setter)
-          raise "accessor or getter already defined for #{field}. Fix the collisions by using the `:value` option."
+          raise "accessor or getter already defined for #{name}. Fix the collisions by using the `:value` option."
         else
           # Order of prefrence for finding term value
-          #  1. overriden getter instance method
+          #  1. overwritten getter instance method
           #    def id
           #      "some constant"
           #    end
@@ -71,28 +50,29 @@ module Cassie::Queries::Statement
           #    query.id
           #    => 105
           define_method getter do
-            # 1 is handled by definition
+            # 1 is handled by overwritten definition
 
             # 2: prefer instance value
-            if instance_variable_defined?("@#{field}")
-              return instance_variable_get("@#{field}")
+            if instance_variable_defined?("@#{name}")
+              return instance_variable_get("@#{name}")
             end
 
             # 3: fetch from resource
-            if _resource && _resource.respond_to?(field)
-              _resource.send(field)
+            if _resource && _resource.respond_to?(name)
+              _resource.send(name)
             end
           end
 
           # query.id = 'some val'
-          # initializes underlying instance var
+          # initialize underlying instance var
           # which is preferred over resource object attribute
           #
           # Issue: if client defines value for attribute
           # they might assume later setting to nil would
           # revert to behavior of fetching from resource object attribute
           # but that is not the case since the variable is defined
-          attr_writer field
+          # and we can't know they didn't want the value of 'nil' to be used
+          attr_writer name
         end
       end
     end

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

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