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

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

@@ -1,67 +0,0 @@
-require_relative 'assignment'
-require_relative 'mapping'
-
-module Cassie::Queries::Statement
-  module Assignments
-    extend ActiveSupport::Concern
-
-    included do
-      include Mapping
-    end
-
-    module ClassMethods
-      def set(identifier, opts={})
-        assignment = Assignment.new(identifier, opts)
-        opts[:value] ||= identifier.to_sym
-
-        if Symbol === opts[:value]
-          define_term_methods(opts[:value])
-        end
-
-        assignments[assignment] = opts
-      end
-
-      def assignments
-        @assignments ||= {}
-      end
-    end
-
-    def assignments
-      self.class.assignments
-    end
-
-    def build_update_and_bindings
-      cql = ""
-      bindings = []
-      assignment_strings = []
-
-      assignments.each do |a, opts|
-        if eval_if_opt?(opts[:if])
-          assignment_strings << a.to_update_cql
-          bindings << eval_value_opt(opts[:value])
-        end
-      end
-
-      cql = "#{assignment_strings.join(', ')}" unless bindings.empty?
-
-      [cql , bindings]
-    end
-
-    def build_insert_and_bindings
-      identifiers = []
-      bindings = []
-
-      assignments.each do |a, opts|
-        if eval_if_opt?(opts[:if])
-          identifiers << a.to_insert_cql
-          bindings << eval_value_opt(opts[:value])
-        end
-      end
-
-      identifiers_cql = "#{identifiers.join(', ')}"
-      terms_cql = Array.new(identifiers.count){"?"}.join(", ")
-
-      [identifiers_cql, terms_cql , bindings]
-    end
-  end
-end

data/lib/cassie/queries/statement/execution.rb

@@ -1,45 +0,0 @@
-require_relative 'consistency'
-
-module Cassie::Queries::Statement
-  module Execution
-    extend ActiveSupport::Concern
-
-    included do
-      attr_reader :result
-
-      include Consistency
-    end
-
-    # Executes the statment, populates result
-    # returns true or false indicating a successful execution or not
-    def execute
-      @result = session.execute(statement, execution_options)
-      execution_successful?
-    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 execution_successful?
-      #TODO: rethink this, it knows too much
-      raise "execution not complete, no results to parse" unless result
-
-      # empty select
-      return true if result.empty?
-
-      # failed upsert
-      return false if (!result.rows.first["[applied]"].nil?) && (result.rows.first["[applied]"] == false)
-
-      true
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-module Cassie::Queries::Statement
-  module Limiting
-    extend ActiveSupport::Concern
-
-    included do
-      attr_writer :limit
-    end
-
-    module ClassMethods
-      def limit=(val)
-        @limit = val
-      end
-
-      def limit(val=:get)
-        if val == :get
-          @limit if defined?(@limit)
-        else
-          self.limit = val
-        end
-      end
-    end
-
-    def limit
-      return @limit if defined?(@limit)
-      self.class.limit
-    end
-
-    protected
-
-    def build_limit_str
-      return "" if limit.nil?
-
-      "LIMIT #{limit}"
-    end
-  end
-end

data/lib/cassie/queries/statement/loading.rb

@@ -1,24 +0,0 @@
-module Cassie::Queries::Statement
-  module Loading
-    extend ActiveSupport::Concern
-
-    def fetch(args={})
-      build_resources(super(args))
-    end
-
-    protected
-
-    # Default implementation assumes
-    # 1 row per resource, clients
-    # may override if more complex
-    def build_resources(rows)
-      rows.map {|r| build_resource(r) }
-    end
-
-    # When class doesn't override
-    # simply return a struct with the row data
-    def build_resource(row)
-      Struct.new(*row.keys.map(&:to_sym)).new(*row.values)
-    end
-  end
-end

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

@@ -1,168 +0,0 @@
-require_relative '../relations'
-
-module Cassie::Queries::Pagination
-  module Cursors
-    extend ActiveSupport::Concern
-
-    included do
-      include Cassie::Queries::Statement::Relations
-    end
-
-    module ClassMethods
-      def max_cursor(key)
-        include Peeking
-
-        @max_cursor_key = key
-
-        where(key,:lteq,
-              value: :"max_#{key}",
-              if: :max_cursor_enabled?)
-
-        define_max_accessors(key)
-        define_next_max_cursor_alias(key)
-      end
-
-      def since_cursor(key)
-        include Peeking
-
-        @max_cursor_key = key
-
-        where(key, :gt,
-              value: :"since_#{key}",
-              if: :since_cursor_enabled?)
-
-        define_since_accessors(key)
-        define_next_max_cursor_alias(key)
-      end
-
-      def cursor_by(key)
-        max_cursor key
-        since_cursor key
-      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
-
-      def define_next_max_cursor_alias(key)
-        method = "next_max_#{key}"
-
-        unless method_defined?(method)
-          define_method method do
-            next_max_cursor
-          end
-        end
-      end
-    end
-
-    module Peeking
-      extend ActiveSupport::Concern
-
-      included do
-        attr_reader :next_max_cursor
-      end
-
-      module ClassMethods
-        def max_cursor_key
-          @max_cursor_key.to_s
-        end
-      end
-
-      def limit
-        super || page_size
-      end
-
-      def execute
-        # get 1 extra result to determing next page info
-        # but massage results to only have what client expects
-
-        val = peek_at_next_page do
-          super
-        end
-
-        extract_next_max_cursor
-
-        val
-      end
-
-      private
-
-      # cache query object instance page_size
-      # so we can revert _object_ back to
-      # same state and preserve value
-      # inheritance chain behavior
-      def peek_at_next_page(&block)
-        old_page_size = nil
-        was_defined = false
-
-        if defined?(@page_size)
-          old_page_size = @page_size
-          was_defined = true
-        end
-
-        @page_size = page_size + 1
-        yield
-      ensure
-        if was_defined
-          @page_size = old_page_size
-        else
-          remove_instance_variable(:@page_size)
-        end
-      end
-
-      # Extracts the next_max_cursor from the query results
-      # given then current max_cursor and since_cursor
-      # leaving the results as cursoring client expects
-      #
-      # Note: We modify cassie private attribute in place
-      #       otherwise we have to copy rows, make results private
-      #       or have a mismatch between rows in results
-      #       and resources created by query class
-      def extract_next_max_cursor
-        raw_rows = result.instance_variable_get(:@rows)
-
-        @next_max_cursor = if raw_rows.count > page_size
-          raw_rows.delete_at(-1)[self.class.max_cursor_key]
-        end
-      end
-    end
-  end
-end

data/lib/cassie/queries/statement/pagination/page_size.rb

@@ -1,7 +0,0 @@
-module Cassie::Queries::Pagination
-  module PageSize
-    def self.default
-      100
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-require_relative 'pagination/cursors'
-require_relative 'pagination/page_size'
-
-module Cassie::Queries
-  module Pagination
-    extend ActiveSupport::Concern
-
-    included do
-      include Cursors
-    end
-
-    module ClassMethods
-      def inherited(subclass)
-        subclass.page_size = page_size
-        super
-      end
-
-      def page_size
-        return @page_size if defined?(@page_size)
-        Cassie::Queries::Pagination::PageSize.default
-      end
-
-      def page_size=(val)
-        @page_size = val
-      end
-    end
-
-    def page_size
-      return @page_size if defined?(@page_size)
-      self.class.page_size
-    end
-
-    def page_size=(val)
-      @page_size = val
-    end
-  end
-end

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

@@ -1,74 +0,0 @@
-# for pluralization
-require 'active_support/core_ext/string'
-
-module Cassie::Queries::Statement
-  #
-  #
-  #    relation "username = ?", value: :username
-  #    relation :username, :eq
-  #    relation :username, :eq, value: :method
-  #    relation :phone, :in
-  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 :identifier,
-                :op_type
-
-    def initialize(identifier, op_type, opts={})
-      if Hash === op_type
-        #  custom relation is being defined:
-        #  `relation "username = ?", value: :username`
-
-        # swap the 2nd arg that sucked in options hash
-        # to keep consistent feeling interface
-        opts.merge!(op_type)
-
-        @cql = identifier
-        @custom = true
-      else
-        @identifier = identifier
-        @op_type = op_type.to_sym
-      end
-    end
-
-    def custom?
-      !!@custom
-    end
-
-    def to_cql
-      cql
-    end
-
-    def multiple_term?
-      op_type == :in
-    end
-
-    def implied_value_method
-      method = if multiple_term?
-        identifier.to_s.pluralize
-      else
-        identifier
-      end
-
-      method.to_sym
-    end
-
-    protected
-
-    def cql
-      # we always generate bound statements
-      @cql ||= "#{identifier} #{OPERATIONS[op_type]} ?"
-    end
-  end
-end

data/lib/cassie/queries/statement/relations.rb

@@ -1,66 +0,0 @@
-require_relative 'relation'
-
-module Cassie::Queries::Statement
-  module Relations
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      #    where :username, :eq, value: :method
-      #    where :phone, :in
-      #    were "username = ?", value: :username
-      def where(identifier, op, opts={})
-        relation = Relation.new(identifier, op, opts)
-
-        opts[:value] ||= relation.implied_value_method
-
-        if Symbol === opts[:value]
-          define_term_methods(opts[:value])
-        end
-
-        relations[relation] = opts
-      end
-
-      # a where clause is built up of multiple 'relations'
-      def relations
-        @relations ||= {}
-      end
-
-      protected
-
-      def define_term_methods(name)
-        #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
-    end
-
-    # a where clause is built up of multiple 'relations'
-    def relations
-      self.class.relations
-    end
-
-    protected
-
-    def build_where_and_bindings
-      cql = ""
-      bindings = []
-      relation_strings = []
-
-      relations.each do |r, opts|
-        if eval_if_opt?(opts[:if])
-          relation_strings << r.to_cql
-          bindings << eval_value_opt(opts[:value])
-        end
-      end
-
-      cql = "WHERE #{relation_strings.join(' AND ')}" unless bindings.empty?
-
-      [cql , bindings]
-    end
-  end
-end

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

@@ -1,63 +0,0 @@
-require_relative 'relations'
-require_relative 'limiting'
-require_relative 'pagination'
-require_relative 'ordering'
-require_relative 'fetching'
-
-module Cassie::Queries::Statement
-  module Selection
-    extend ::ActiveSupport::Concern
-
-    module ClassMethods
-      #TODO: accept block to add specific selectors and aliases
-      #      select :table do |t|
-      #        t.id
-      #        t.name as: :username
-      #      end
-      def select(table)
-        include Relations
-        include Ordering
-        include Fetching
-
-        self.table = table
-        self.type = :select
-
-        yield(self) if block_given?
-      end
-
-      # a select clause is built up of selectors
-      def selectors
-        @selectors ||= []
-      end
-    end
-
-    protected
-
-    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
-      str = if selectors.empty?
-        '*'
-      else
-        selectors.join(', ')
-      end
-    end
-  end
-end