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

data/lib/cassie/statements/statement/pagination/cursors.rb

@@ -0,0 +1,112 @@
+require_relative '../relations'
+require_relative '../../execution/peeking'
+
+module Cassie::Statements::Statement::Pagination
+  module Cursors
+    extend ActiveSupport::Concern
+
+    included do
+      include Cassie::Statements::Statement::Relations
+    end
+
+    module ClassMethods
+      def max_cursor(key)
+        include Cassie::Statements::Execution::Peeking
+        self.partition_linker = Cassie::Statements::Execution::PartitionLinking::CursoringPolicy
+
+        @max_cursor_key = key
+
+        where(key,:lteq,
+              value: :"max_#{key}",
+              if: :max_cursor_enabled?)
+
+        define_max_accessors(key)
+      end
+
+      def since_cursor(key)
+        include Cassie::Statements::Execution::Peeking
+
+        @max_cursor_key = key
+
+        where(key, :gt,
+              value: :"since_#{key}",
+              if: :since_cursor_enabled?)
+
+        define_since_accessors(key)
+      end
+
+      def cursor_by(key)
+        max_cursor key
+        since_cursor key
+      end
+
+      def max_cursor_key
+        @max_cursor_key.to_s
+      end
+
+      private
+
+      def define_max_accessors(key)
+        attr_accessor :max_cursor
+
+        define_method :max_cursor_enabled? do
+          !max_cursor.nil?
+        end
+
+        getter = :"max_#{key}"
+        remove_method getter if method_defined?(getter)
+        define_method getter do
+          self.max_cursor
+        end
+
+        setter = :"max_#{key}="
+        remove_method setter if method_defined?(setter)
+        define_method setter do |val|
+          self.max_cursor = val
+        end
+      end
+
+      def define_since_accessors(key)
+        attr_accessor :since_cursor
+
+        define_method :since_cursor_enabled? do
+          !since_cursor.nil?
+        end
+
+        getter = :"since_#{key}"
+        remove_method getter if method_defined?(getter)
+        define_method getter do
+          self.since_cursor
+        end
+
+        setter = :"since_#{key}="
+        remove_method setter if method_defined?(setter)
+        define_method setter do |val|
+          self.since_cursor = val
+        end
+      end
+    end
+
+    def result_class
+      if cursored?
+        Cassie::Statements::Results::CursoredResult
+      else
+        super
+      end
+    end
+
+    def result_opts
+      if cursored?
+        super.merge({max_cursor_key: self.class.max_cursor_key})
+      else
+        super
+      end
+    end
+
+    protected
+
+    def cursored?
+      respond_to?(:max_cursor)
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require_relative 'pagination/cursors'
+
+module Cassie::Statements
+  module Statement::Pagination
+    extend ActiveSupport::Concern
+
+    included do
+      include Cursors
+
+      alias :page_size :limit
+      alias :page_size= :limit=
+
+      class << self
+        alias :page_size :limit
+        alias :page_size= :limit=
+      end
+    end
+  end
+end

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

@@ -1,4 +1,4 @@
-module Cassie::Queries::Statement
+module Cassie::Statements::Statement
   module Preparation
     class Cache
       attr_reader :data

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

@@ -1,6 +1,6 @@
 require_relative 'preparation/cache'
 
-module Cassie::Queries::Statement
+module Cassie::Statements::Statement
   module Preparation
     extend ::ActiveSupport::Concern
 
@@ -24,12 +24,11 @@ module Cassie::Queries::Statement
 
     def statement
       statement = super
-
       if self.class.prepare?
-        key = statement.cql if statement.respond_to?(:cql)
-        key ||= statement.to_s
+        key = statement.respond_to?(:cql) ? statement.cql : statement.to_s
 
         unbound = statement_cache.fetch(key) do
+          statement.cql.freeze
           session.prepare(statement)
         end
         unbound.bind(statement.params)
@@ -41,7 +40,7 @@ module Cassie::Queries::Statement
     private
 
     def statement_cache
-      Cassie::Queries::Statement::Preparation.cache
+      Cassie::Statements::Statement::Preparation.cache
     end
   end
 end

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

@@ -0,0 +1,68 @@
+module Cassie::Statements::Statement
+  #
+  #
+  #    relation :username, :eq
+  #    relation :username, :eq, value: :method
+  #    relation :phone, :in
+  #    relation :user_id, :gteq, term: "minTimeuuid('2013-02-02 10:00+0000')"
+  class Relation
+    # https://cassandra.apache.org/doc/cql3/CQL.html#selectStmt
+
+    OPERATIONS = {
+                  eq: "=",
+                  lt: "<",
+                  lteq: "<=",
+                  gt: ">",
+                  gteq: ">=",
+                  in: "IN",
+                  contains: "CONTAINS",
+                  contains_key: "CONTAINS KEY",
+    }
+
+    attr_reader :source,
+                :identifier,
+                :operation,
+                :value,
+                :enabled,
+                :term
+
+
+    def initialize(source, identifier, op_type, value_method, opts={})
+      @source = source
+      @identifier = identifier
+      @operation = OPERATIONS[op_type.to_sym]
+      @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_cql
+      return nil unless enabled?
+      "#{identifier} #{operation} #{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/relations.rb

@@ -0,0 +1,93 @@
+# for pluralization
+require 'active_support/core_ext/string'
+require_relative 'relation'
+
+module Cassie::Statements::Statement
+  # Provides support for a set of CQL relations
+  # and building the where clause and argument list
+  # for a cql statement
+  #
+  # CQL Relation terminology:
+  #
+  #   "SELECT * FROM table WHERE id = ?", [1]
+  #
+  # relation:   'WHERE'
+  # identifier: 'id'
+  # operation:  '='
+  # term:       '?'
+  # argument:   '1'
+  module Relations
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      #    where :username, :eq, value: :method
+      #    where :phone, :in
+      #    relation :user_id, :gteq, term: "minTimeuuid('2013-02-02 10:00+0000')"
+      def where(identifier, op, opts={})
+        opts[:value] ||= implied_argument_method(identifier, op)
+
+        define_argument_accessor(opts[:value])
+
+        relations_args << [identifier, op, opts.delete(:value), opts]
+      end
+
+      def relations_args
+        @relations_args ||= []
+      end
+
+      protected
+
+      #TODO: extract argument accessor creation for
+      #      more DRY and clear usage. See mapping module.
+      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
+        #TODO: this should probably only raise
+        #      if value option was nil and we
+        #      are implicilty creating getter/setters.
+        if method_defined?(name) || method_defined?("#{name}=")
+          raise "accessor or getter already defined for #{name}. Fix the collisions by using the `:value` option."
+        else
+          attr_accessor name
+        end
+      end
+
+      private
+
+      def implied_argument_method(identifier, op)
+        method = if op == :in
+          identifier.to_s.pluralize
+        else
+          identifier
+        end
+
+        method.to_sym
+      end
+    end
+
+    # a where clause is built up of multiple 'relations'
+    def relations_args
+      self.class.relations_args
+    end
+
+    protected
+
+    def build_where_and_bindings
+      cql = ""
+      relation_strings = []
+      arguments = []
+
+      relations_args.each do |args|
+        r = Relation.new(self, *args)
+        relation_strings += Array(r.to_cql)
+        arguments += Array(r.argument)
+      end
+
+      cql = "WHERE #{relation_strings.join(' AND ')}" unless relation_strings.empty?
+
+      # where identifier inequality term AND identifier inequality term;
+      [cql , arguments]
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+require_relative 'limiting'
+require_relative 'pagination'
+require_relative 'relations'
+require_relative 'ordering'
+
+module Cassie::Statements::Statement
+  module Selection
+    extend ::ActiveSupport::Concern
+
+    included do
+      include Relations
+      include Ordering
+      include Limiting
+      include Pagination
+
+      @result_class = Cassie::Statements::Results::QueryResult
+    end
+
+    module ClassMethods
+      def select_from(table)
+        self.table = table
+        self.type = :select
+
+        yield(self) if block_given?
+      end
+
+      def select(selector, opts={})
+        selector = selector.to_s
+        selector += " AS #{opts[:as]}" if opts[:as]
+        selectors << selector
+      end
+
+      # a select clause is built up of selectors
+      def selectors
+        @selectors ||= []
+      end
+
+      def write_time(selector)
+        "WRITETIME(#{selector})"
+      end
+      alias writetime write_time
+
+      def ttl(selector)
+        "TTL(#{selector})"
+      end
+
+      def count(selector='*')
+        "COUNT(#{selector})"
+      end
+    end
+
+    protected
+
+    def result_opts
+      opts = {}
+      opts[:each_deserializer] = method(:build_result) if respond_to?(:build_result, true)
+      opts[:deserializer] = method(:build_results) if respond_to?(:build_results, true)
+      super.merge(opts)
+    end
+
+    def build_select_cql_and_bindings
+      where_str, bindings = build_where_and_bindings
+
+      cql = %(
+        SELECT #{build_select_clause}
+          FROM #{table}
+          #{where_str}
+          #{build_order_str}
+          #{build_limit_str}
+      ).squish + ";"
+
+      [cql, bindings]
+    end
+
+    # a select clause is built up of selectors
+    def selectors
+      self.class.selectors
+    end
+
+    def build_select_clause
+      return '*' if selectors.empty?
+
+      selectors.join(', ')
+    end
+  end
+end

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

@@ -1,16 +1,20 @@
 require_relative 'assignments'
 require_relative 'conditions'
 
-module Cassie::Queries::Statement
+module Cassie::Statements::Statement
   module Updating
     extend ::ActiveSupport::Concern
 
+    included do
+      include Relations
+      include Assignments
+      include Conditions
+
+      @result_class = Cassie::Statements::Results::ModificationResult
+    end
+
     module ClassMethods
       def update(table)
-        include Relations
-        include Assignments
-        include Conditions
-
         self.table = table
         self.type = :update
 
@@ -18,11 +22,6 @@ module Cassie::Queries::Statement
       end
     end
 
-    def update(opts={})
-      execute
-      execution_successful?
-    end
-
     protected
 
     def build_update_cql_and_bindings

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

@@ -1,33 +1,23 @@
 require 'active_support/core_ext/string/filters'
 require 'active_support/hash_with_indifferent_access'
-require_relative 'statement/execution'
-require_relative 'statement/preparation'
-require_relative 'statement/callbacks'
-require_relative 'statement/limiting'
-require_relative 'statement/pagination'
-require_relative 'statement/selection'
-require_relative 'statement/deleting'
-require_relative 'statement/updating'
-require_relative 'statement/inserting'
 
-
-module Cassie::Queries
+module Cassie::Statements
+  # Include Statement to provide support for a
+  # `statement` method returning a `Cassandra::Statements::Simple`
+  # statement with positional arguments.
+  #
+  # `type` and `table` attributes are also added,
+  # providing an extension interface for building
+  # cql and bindings for different statement types.
   module Statement
+    require_relative 'statement/preparation'
+
     class Invalid < StandardError; end
 
-    # https://cassandra.apache.org/doc/cql3/CQL.html#selectStmt
     extend ::ActiveSupport::Concern
 
     included do
-      include Execution
       include Preparation
-      include Callbacks
-      include Limiting
-      include Pagination
-      include Selection
-      include Deleting
-      include Updating
-      include Inserting
 
       class << self
         attr_accessor :table

data/lib/cassie/statements.rb

@@ -0,0 +1,9 @@
+module Cassie
+  module Statements
+    require_relative 'statements/core'
+    require_relative 'statements/query'
+    require_relative 'statements/modification'
+    require_relative 'statements/instrumenting'
+    require_relative 'statements/logging'
+  end
+end

data/lib/cassie/testing/fake/definition.rb

@@ -0,0 +1,11 @@
+require_relative 'session_methods'
+
+module Cassie
+  module Testing::Fake::Definition
+  end
+
+  class FakeDefinition < Cassie::Definition
+    include Cassie::Testing::Fake::SessionMethods
+
+  end
+end

data/lib/cassie/testing/fake/modification.rb

@@ -0,0 +1,11 @@
+require_relative 'session_methods'
+
+module Cassie
+  module Testing::Fake::Modification
+  end
+
+  class FakeModification < Cassie::Modification
+    include Cassie::Testing::Fake::SessionMethods
+
+  end
+end

data/lib/cassie/testing/fake/result.rb

@@ -2,6 +2,7 @@ require_relative 'execution_info'
 
 module Cassie::Testing::Fake
   class Result
+    include Enumerable
     attr_reader :rows, :statement, :opts
 
     def initialize(statement, execution_opts={})
@@ -14,18 +15,29 @@ module Cassie::Testing::Fake
       ExecutionInfo.new(statement)
     end
 
-    def rows
-      if paging_enabled?
+    def each
+      _rows = if paging_enabled?
         index = current_page - 1
         offset = index * page_size
         @data.slice(offset, page_size) || []
       else
         @data
       end
+
+      if block_given?
+        _rows.each(&block)
+        self
+      else
+        _rows.each
+      end
     end
+    alias rows each
+    alias each_row each
 
     def empty?
-      rows.empty?
+      !!rows.peek
+    rescue StopIteration
+      true
     end
 
     def paging_enabled?

data/lib/cassie/testing.rb

@@ -1,6 +1,8 @@
 module Cassie
   module Testing
+    require_relative 'testing/fake/definition'
     require_relative 'testing/fake/query'
+    require_relative 'testing/fake/modification'
 
   end
 end

data/lib/cassie.rb

@@ -17,7 +17,9 @@ module Cassie
   require_relative 'cassie/configuration'
   require_relative 'cassie/connection_handler'
   require_relative 'cassie/connection'
+  require_relative 'cassie/definition'
   require_relative 'cassie/query'
+  require_relative 'cassie/modification'
 
   extend Configuration::Core
   extend ConnectionHandler