cassie-queries 0.0.1.a3 → 0.0.1.a4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cb242e7d39178042db018afd756662c8fad3c97f
-  data.tar.gz: 635694c6fa09a3c33a4344a510a168f30f7395ff
+  metadata.gz: 43d357d81ed74c4e0e24a0536842f3cb0c135681
+  data.tar.gz: 246a0d7be210bbdea3bc1c1ce3f70fdd445d7eb7
 SHA512:
-  metadata.gz: 2dcaa13edba2a7d1df4a6775efdf75671fc7782e2e8f3358748e2356acd17200098d6eeda84cb2d2b8774a4e15727d2220ea7b4397859a611713b16bc5a3af53
-  data.tar.gz: 6ee8cb5798723ecb6ca88133e07cdd7088bb6ea3558635db69b615e11644ba1c97a7a03b5d8e6f93422d198936d0d70d68d511f2ec1f2afda84ff12f29c5de4d
+  metadata.gz: 4561e775d74984005a279c954b4ad638da526830b6a1ab52a82f17def1208604180b168b2011b9baed3e993e9e0a0e5e730e88e70698604b8a439c91781541a1
+  data.tar.gz: 4922dbc93622b6cbc63bf89643e149165fd0484b91b8b617b61acde5291b02f8dc17dcff3e8916ffc57bcc9241e949f00ef8ecb0239d0603faf6101a0db8d76f

data/lib/cassie/queries/instrumentation.rb

@@ -9,7 +9,8 @@ module Cassie::Queries
     def instrument #:nodoc:
       instrumenter.instrument("cql.execute") do |payload|
         execution_val = yield # execution populates #result
-        payload[:execution_info] = result.try(:execution_info)
+
+        payload[:execution_info] = result.execution_info if result.respond_to?(:execution_info)
         execution_val
       end
     end

data/lib/cassie/queries/logging/cql_execution_event.rb

@@ -19,10 +19,14 @@ module Cassie::Queries::Logging
     end
 
     def statement
-      statement = execution_info.statement
-      str = statement.cql
-      str += " [#{statement.params}]" if statement.respond_to? :params
-      str
+      if execution_info
+        statement = execution_info.statement
+        str = statement.cql
+        str += " [#{statement.params}]" if statement.respond_to? :params
+        str
+      else
+        "CQL executed: (`execution_info` was not present?)"
+      end
     end
 
     def traced?

data/lib/cassie/queries/logging/logger.rb

@@ -10,7 +10,7 @@ module Cassie::Queries
     end
 
     def self.init_logger(target = STDOUT)
-      previous_logger = @logger
+      previous_logger = defined?(@logger) ? @logger : nil
 
       @logger = Logger.new(target)
       @logger.level = Logger::INFO

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

@@ -0,0 +1,15 @@
+module Cassie::Queries::Pagination
+  module Cursors
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def max_cursor(field, opts={})
+        relation field, :lteq, opts
+      end
+
+      def since_cursor(field, opts={})
+        relation field, :gt, opts
+      end
+    end
+  end
+end

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

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

data/lib/cassie/queries/pagination.rb

@@ -0,0 +1,37 @@
+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/assignment.rb

@@ -0,0 +1,36 @@
+module Cassie::Queries::Statement
+  #    set "username = ?", value: :username
+  #    set "favs = favs + ?" value: "{ 'movie' : 'Cassablanca' }"
+  #    set :username
+  class Assignment
+    # https://cassandra.apache.org/doc/cql3/CQL.html#updateStmt
+
+    attr_reader :identifier
+
+    def initialize(identifier, opts={})
+      if String === identifier
+        #  custom assignment is being defined:
+        #
+        #  `assign "username = ?", value: :username`
+        @cql = identifier
+        @custom = true
+      else
+        @identifier = identifier
+      end
+    end
+
+    def to_insert_cql
+      return @cql if defined?(@cql)
+      identifier
+    end
+
+    def to_update_cql
+      return @cql if defined?(@cql)
+      "#{identifier} = ?"
+    end
+
+    def custom?
+      !!@custom
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+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/deleting.rb

@@ -0,0 +1,60 @@
+require_relative 'relations'
+
+module Cassie::Queries::Statement
+  module Deleting
+    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 delete(table)
+        include Relations
+
+        self.table = table
+        self.identifier = :delete
+
+        yield(self) if block_given?
+      end
+
+      # TODO rename to identifiers and extract
+      def selectors
+        @selectors ||= []
+      end
+    end
+
+    def delete(opts={})
+      execute
+      execution_successful?
+    end
+
+    protected
+
+    def build_delete_cql_and_bindings
+      where_str, bindings = build_where_and_bindings
+
+      cql = %(
+        DELETE #{build_delete_clause}
+          FROM #{table}
+          #{where_str}
+      ).squish + ";"
+
+      [cql, bindings]
+    end
+
+    # a select clause is built up of selectors
+    def selectors
+      self.class.selectors
+    end
+
+    def build_delete_clause
+      str = if selectors.empty?
+        ''
+      else
+        selectors.join(', ')
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require_relative 'relation'
+require_relative 'loading'
+
+class Cassie::Queries::RecordNotFound < StandardError; end
+
+module Cassie::Queries::Statement
+  module Fetching
+    extend ActiveSupport::Concern
+
+    included do
+      include Loading
+    end
+
+    # Returns array of rows or empty array
+    #
+    #   query.fetch(id: 1)
+    #   => [{id: 1, name: 'eprothro'}]
+    def fetch(args={})
+      args.each do |k, v|
+        setter = "#{k}="
+        send(setter, v) if respond_to? setter
+      end
+
+      execute
+      result.rows
+    end
+
+    # Returns first result or nil
+    #
+    #   query.find(id: 1)
+    #   => {id: 1, name: 'eprothro'}
+    #
+    #   query.find(id: 2)
+    #   => nil
+    def find(args={})
+      old_limit = defined?(@limit) ? @limit : nil
+      self.limit = 1
+
+      fetch.first
+    ensure
+      self.limit = old_limit
+    end
+
+    # Returns first result or raises RecordNotFound
+    #
+    #   query.find!(id: 1)
+    #   => {id: 1, name: 'eprothro'}
+    #
+    #   query.find!(id: 2)
+    #   RecordNotFound: RecordNotFound
+    def find!(args={})
+      find || raise(Cassie::Queries::RecordNotFound)
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require_relative 'assignments'
+
+module Cassie::Queries::Statement
+  module Inserting
+    extend ::ActiveSupport::Concern
+
+    module ClassMethods
+      def insert(table)
+        include Assignments
+
+        self.table = table
+        self.identifier = :insert
+
+        yield(self) if block_given?
+      end
+    end
+
+    def insert(opts={})
+      execute
+      execution_successful?
+    end
+
+    protected
+
+    def build_insert_cql_and_bindings
+      identifiers_str, terms_str, bindings = build_insert_and_bindings
+
+      cql = %(
+        INSERT INTO #{table}
+        (#{identifiers_str})
+        VALUES (#{terms_str})
+      ).squish + ";"
+
+      [cql, bindings]
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Cassie::Queries::Statement
+  module Limiting
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :limit
+
+      class << self
+        attr_accessor :limit
+      end
+    end
+
+    def limit
+      @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

@@ -0,0 +1,16 @@
+module Cassie::Queries::Statement
+  module Loading
+    extend ActiveSupport::Concern
+
+    def fetch(args={})
+      rows = super(args)
+      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).new(*row.values)
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module Cassie::Queries::Statement
+  module Mapping
+    extend ActiveSupport::Concern
+
+    MAPPED_METHODS = [:insert, :update, :delete].freeze
+
+    included do
+      MAPPED_METHODS.each do |method|
+        next unless method_defined?(method)
+
+        define_method(method) do |resource=nil, opts={}|
+          return super(opts) if _resource.nil? && resource.nil?
+
+          self._resource = resource
+
+          if super(opts)
+            _resource
+          else
+            false
+          end
+        end
+      end
+    end
+
+    module ClassMethods
+      def map_from(resource_name)
+        attr_accessor resource_name
+
+        define_method "_resource" do
+          send resource_name
+        end
+
+        define_method "_resource=" do |val|
+          send("#{resource_name}=", val)
+        end
+      end
+
+      protected
+
+      def define_term_methods(field)
+        getter = field
+        setter = "#{field}="
+
+        if method_defined?(getter) || method_defined?(setter)
+          raise "accessor or getter already defined for #{field}. Fix the collisions by using the `:value` option."
+        else
+          # Order of prefrence for finding term value
+          # 1. overriden getter instance method
+          # 2. value set by setter instance method
+          # 3. (Eventually) Mapping getter instance method
+          # 4. instance resource getter instance method
+          define_method getter do
+            if instance_variable_defined?("@#{field}")
+              return instance_variable_get("@#{field}")
+            end
+            _resource.send(field) if(_resource && _resource.respond_to?(field))
+          end
+
+          define_method setter do |val|
+            instance_variable_set("@#{field}", val)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Cassie::Queries::Statement
+  module Ordering
+    extend ActiveSupport::Concern
+
+    protected
+
+    def build_order_str
+      ""
+    end
+  end
+end

data/lib/cassie/queries/statement/preparation/cache.rb

@@ -0,0 +1,55 @@
+module Cassie::Queries::Statement
+  module Preparation
+    class Cache
+      attr_reader :data
+
+      def initialize
+        clear
+        @monitor = Monitor.new
+      end
+
+      def write(key, value)
+        synchronize do
+          @data[key] = value
+        end
+      end
+      def read(key)
+        synchronize do
+          data[key]
+        end
+      end
+      def fetch(key)
+        return read(key) if data.has_key?(key)
+        write(key, yield) if block_given?
+      end
+      def clear
+        @data = {}
+      end
+      def close
+        clear
+      end
+
+      private
+
+      def synchronize(&block)
+        @monitor.synchronize(&block)
+      end
+    end
+
+    def self.cache
+      @cache ||= init_cache
+    end
+
+    def self.init_cache
+      previous_cache = defined?(@cache) ? @cache : nil
+
+      #TODO: research why memory story is blowing up when
+      #     serializing the Cassandra prepared statement result
+      # @cache = ActiveSupport::Cache::MemoryStore.new
+      @cache = Cache.new
+
+      previous_cache.close if previous_cache
+      @cache
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require_relative 'preparation/cache'
+
+module Cassie::Queries::Statement
+  module Preparation
+    extend ::ActiveSupport::Concern
+
+    included do
+      class << self
+        attr_accessor :prepare
+      end
+      self.prepare = true
+    end
+
+    module ClassMethods
+      def inherited(subclass)
+        subclass.prepare = prepare
+        super
+      end
+
+      def prepare?
+        !!prepare
+      end
+    end
+
+    def statement
+      statement = super
+
+      if self.class.prepare?
+        key = statement.cql if statement.respond_to?(:cql)
+        key ||= statement.to_s
+
+        unbound = statement_cache.fetch(key) do
+          session.prepare(statement)
+        end
+        unbound.bind(statement.params)
+      else
+        statement
+      end
+    end
+
+    private
+
+    def statement_cache
+      Cassie::Queries::Statement::Preparation.cache
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+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: ">=",
+                  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
+        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
+
+    protected
+
+    def cql
+      # we always generate bound statements
+      @cql ||= "#{identifier} #{OPERATIONS[op_type]} ?"
+    end
+
+    def op_type
+      @op_type
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+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] ||= identifier.to_sym
+
+        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
+
+      private
+
+      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 collions 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
+
+    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

@@ -0,0 +1,63 @@
+require_relative 'relations'
+require_relative 'limiting'
+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 Limiting
+        include Ordering
+        include Fetching
+
+        self.table = table
+        self.identifier = :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

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

@@ -0,0 +1,39 @@
+require_relative 'assignments'
+
+module Cassie::Queries::Statement
+  module Updating
+    extend ::ActiveSupport::Concern
+
+    module ClassMethods
+      def update(table)
+        include Relations
+        include Assignments
+
+        self.table = table
+        self.identifier = :update
+
+        yield(self) if block_given?
+      end
+    end
+
+    def update(opts={})
+      execute
+      execution_successful?
+    end
+
+    protected
+
+    def build_update_cql_and_bindings
+      assignment_str, update_bindings = build_update_and_bindings
+      where_str, where_bindings = build_where_and_bindings
+
+      cql = %(
+        UPDATE #{table}
+        SET #{assignment_str}
+        #{where_str}
+      ).squish + ";"
+
+      [cql, update_bindings + where_bindings]
+    end
+  end
+end

data/lib/cassie/queries/statement.rb

@@ -1,48 +1,60 @@
 require 'active_support/core_ext/string/filters'
+require_relative 'statement/preparation'
+require_relative 'statement/selection'
+require_relative 'statement/deleting'
+require_relative 'statement/updating'
+require_relative 'statement/inserting'
+
 
 module Cassie::Queries
   module Statement
+    # https://cassandra.apache.org/doc/cql3/CQL.html#selectStmt
     extend ::ActiveSupport::Concern
 
     included do
+      include Preparation
+      include Selection
+      include Deleting
+      include Updating
+      include Inserting
+
       attr_reader :result
-    end
 
-    module ClassMethods
-      def cql(statement)
-        if self.const_defined?(:STATEMENT)
-          raise "a cql statement has already been defined and cannot be changed"
-        else
-          self.const_set(:STATEMENT, statement.squish)
-        end
+      class << self
+        attr_accessor :table
+        attr_accessor :identifier
       end
+    end
 
-      def statement
-        self.const_get(:STATEMENT)
-      rescue NameError
-      end
+    def table
+      self.class.table
     end
 
     # Executes the statment, populates result
     # returns true or false indicating a successful execution or not
     def execute
-      @result = session.execute(statement, arguments: bindings)
+      @result = session.execute(statement)
       execution_successful?
     end
 
+    # returns a CQL string, or a Cassandra::Statement
+    # that is ready for execution
     def statement
-      self.class.statement
+      Cassandra::Statements::Simple.new(*build_cql_and_bindings)
     end
 
     protected
 
-    def bindings
-      []
+    def build_cql_and_bindings
+      if identifier
+        send "build_#{identifier}_cql_and_bindings"
+      else
+        [cql, bindings]
+      end
     end
 
-    private
-
     def execution_successful?
+      #TODO: rethink this, it knows too much
       raise "execution not complete, no results to parse" unless result
 
       # empty select
@@ -53,5 +65,35 @@ module Cassie::Queries
 
       true
     end
+
+    private
+
+    def identifier
+      self.class.identifier
+    end
+
+    def eval_if_opt?(value)
+      case value
+      when nil
+        true # if is true by default
+      when Symbol
+        !!send(value)
+      when String
+        !!eval(value)
+      else
+        !!value
+      end
+    end
+
+    def eval_value_opt(value)
+      case value
+      when Symbol
+        send(value)
+      when String
+        eval(value)
+      else
+        value
+      end
+    end
   end
 end

data/lib/cassie/query.rb

@@ -2,15 +2,24 @@ module Cassie
   require 'cassandra'
   require_relative 'queries/session'
   require_relative 'queries/statement'
-  require_relative 'queries/prepared_statement'
+  require_relative 'queries/pagination'
   require_relative 'queries/instrumentation'
   require_relative 'queries/logging'
 
   class Query
     include Queries::Session
     include Queries::Statement
-    include Queries::PreparedStatement
+    include Queries::Pagination
     include Queries::Instrumentation
     include Queries::Logging
+
+    def initialize(*args)
+      value = super(*args)
+      after_initialize(*args)
+      value
+    end
+
+    def after_initialize(*args)
+    end
   end
 end

metadata

@@ -1,88 +1,119 @@
 --- !ruby/object:Gem::Specification
 name: cassie-queries
 version: !ruby/object:Gem::Version
-  version: 0.0.1.a3
+  version: 0.0.1.a4
 platform: ruby
 authors:
 - Evan Prothro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-11 00:00:00.000000000 Z
+date: 2015-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cassandra-driver
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.2'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: '`cassie-queries` is a lightweight interface adapter allowing easy use
-  of the functionality provided by the `cassandra-driver`.'
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "`cassie-queries` is a lightweight interface adapter allowing easy use
+  of the functionality provided by the `cassandra-driver`."
 email: evan.prothro@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/cassie-queries.rb
 - lib/cassie/queries/instrumentation.rb
+- lib/cassie/queries/logging.rb
 - lib/cassie/queries/logging/cql_execution_event.rb
 - lib/cassie/queries/logging/logger.rb
 - lib/cassie/queries/logging/subscription.rb
-- lib/cassie/queries/logging.rb
-- lib/cassie/queries/prepared_statement.rb
+- lib/cassie/queries/pagination.rb
+- lib/cassie/queries/pagination/cursors.rb
+- lib/cassie/queries/pagination/page_size.rb
 - lib/cassie/queries/session.rb
 - lib/cassie/queries/statement.rb
+- lib/cassie/queries/statement/assignment.rb
+- lib/cassie/queries/statement/assignments.rb
+- lib/cassie/queries/statement/deleting.rb
+- lib/cassie/queries/statement/fetching.rb
+- lib/cassie/queries/statement/inserting.rb
+- lib/cassie/queries/statement/limiting.rb
+- lib/cassie/queries/statement/loading.rb
+- lib/cassie/queries/statement/mapping.rb
+- lib/cassie/queries/statement/ordering.rb
+- lib/cassie/queries/statement/preparation.rb
+- lib/cassie/queries/statement/preparation/cache.rb
+- lib/cassie/queries/statement/relation.rb
+- lib/cassie/queries/statement/relations.rb
+- lib/cassie/queries/statement/selection.rb
+- lib/cassie/queries/statement/updating.rb
 - lib/cassie/query.rb
-- lib/cassie-queries.rb
 homepage: https://github.com/eprothro/cassie-queries
 licenses:
 - MIT
@@ -93,17 +124,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>'
+  - - ">"
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: Apache Cassandra query management

data/lib/cassie/queries/prepared_statement.rb

@@ -1,40 +0,0 @@
-module Cassie::Queries
-  module PreparedStatement
-    extend ::ActiveSupport::Concern
-
-    included do
-      class << self
-        attr_accessor :prepare
-      end
-      self.prepare = true
-    end
-
-    module ClassMethods
-      def inherited(subclass)
-        subclass.prepare = prepare
-      end
-
-      def prepare?
-        !!prepare
-      end
-
-      def prepared_statement
-        # use class instance variable to esnure only 1
-        # statement is prepared per process
-        # no mutex required in MRI because of GIL
-        #
-        # note: cassandra-driver handles the case
-        #       of executing a prepared statement
-        #       on a host where it has not been prepared
-        #       yet, by re-preparing.
-        @prepared_statement ||= begin
-          session.prepare(statement)
-        end
-      end
-    end
-
-    def statement
-      self.class.prepare? ? self.class.prepared_statement : super
-    end
-  end
-end