cassie 1.0.0.alpha.3 → 1.0.0.alpha.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 970ee1be69be9f6ac3b0827c0b03d5dadbd704ee
-  data.tar.gz: a1d420963e62bc82535a30959b3ff6e15ff7bf86
+  metadata.gz: b525f6072394101c053af5d655136f44cfda52a1
+  data.tar.gz: b70d7576dfd3b36ee4958f5e75dbfee6ce9c16ed
 SHA512:
-  metadata.gz: 21d680ba347b41154d12d3cdc5afd6fe4d0a7df8abce59cf550c83f9a589407750574119b738f3208418604fc4ddfb6e6d515ad0b87b6259a2651355ac48ec48
-  data.tar.gz: d753f55aa66ebc96c6d14b01300ec5efd66fca989378227f5c16a1cf92351076793211c4f1961203ee898c7bf9bb4a7bbb494feb0eb1167f484254dbce77b730
+  metadata.gz: 3b345d2bb1febc085c96b5deca61fcd61862242d8ea02e17c8ce7ddc2015c8cfa95af8d51ccb52b7714ed9b1ac200f678194d7b2c1a9200ba056992b0126c88a
+  data.tar.gz: d12cda51a8148b416963326eaebad65b67df3e096fc95e887ec6ff15802a36f052b42d0147e49f53515e9934ba2d842add0720521230ef704ce4b059dcc8c4eb

data/lib/cassie/queries/instrumentation.rb

@@ -0,0 +1,24 @@
+module Cassie::Queries
+  module Instrumentation
+    extend ::ActiveSupport::Concern
+
+    def execute
+      instrument { super }
+    end
+
+    def instrument #:nodoc:
+      instrumenter.instrument("cql.execute") do |payload|
+        execution_val = yield # execution populates #result
+
+        payload[:execution_info] = result.execution_info if result.respond_to?(:execution_info)
+        execution_val
+      end
+    end
+
+    protected
+
+    def instrumenter
+      ActiveSupport::Notifications
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Cassie::Queries::Logging
+  class CqlExecutionEvent < ActiveSupport::Notifications::Event
+
+    def duration # in milliseconds
+      return super unless traced?
+
+      # trace duration is in microseconds
+      trace.duration / 1000.0
+    end
+
+    def message
+      color "(#{duration.round(1)}ms) #{statement}"
+    end
+
+    protected
+
+    def execution_info
+      payload[:execution_info]
+    end
+
+    def statement
+      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?
+      execution_info && !!trace
+    end
+
+    def trace
+      execution_info.trace
+    end
+
+    def color(message)
+      "\e[1m\e[37m#{message}\e[0m\e[22m"
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Cassie::Queries
+  module Logging
+
+    def self.logger
+      @logger ||= init_logger
+    end
+
+    def self.logger=(new_logger)
+      @logger = new_logger || Logger.new('/dev/null')
+    end
+
+    def self.init_logger(target = STDOUT)
+      previous_logger = defined?(@logger) ? @logger : nil
+
+      @logger = Logger.new(target)
+      @logger.level = Logger::INFO
+      @logger.formatter = log_formatter
+
+      previous_logger.close if previous_logger
+      @logger
+    end
+
+    def self.log_formatter
+      ActiveSupport::Logger::SimpleFormatter.new
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require_relative 'cql_execution_event'
+
+module Cassie::Queries::Logging
+  module Subscription
+    extend ::ActiveSupport::Concern
+
+    included do
+      ActiveSupport::Notifications.subscribe('cql.execute') do |*args|
+        # args:
+        # name    # => String, name of the event (such as 'render' from above)
+        # start   # => Time, when the instrumented block started execution
+        # finish  # => Time, when the instrumented block ended execution
+        # id      # => String, unique ID for this notification
+        # payload # => Hash, the payload
+        #             [:exception] => if raised during event
+        unless args.last[:exception]
+          logger.debug(CqlExecutionEvent.new(*args).message)
+        end
+      end
+    end
+  end
+end

data/lib/cassie/queries/logging.rb

@@ -0,0 +1,22 @@
+require_relative 'logging/logger'
+require_relative 'logging/subscription'
+
+module Cassie::Queries
+  module Logging
+    extend ::ActiveSupport::Concern
+
+    included do
+      include Subscription
+    end
+
+    module ClassMethods
+      def logger
+        Cassie::Queries::Logging.logger
+      end
+    end
+
+    def logger
+      self.class.logger
+    end
+  end
+end

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/session.rb

@@ -0,0 +1,22 @@
+module Cassie::Queries
+  module Session
+    extend ::ActiveSupport::Concern
+
+    module ClassMethods
+      def session
+        # until cassie-configuration exists,
+        # we're relying on the client to
+        # supply the session
+        if defined?(super)
+          super
+        else
+          raise "Oops! Cassie::Queries doesn't manage a Cassandra session for you, yet. You must provide a .session class method that returns a valid session."
+        end
+      end
+    end
+
+    def session
+      self.class.session
+    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

@@ -0,0 +1,99 @@
+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
+
+      class << self
+        attr_accessor :table
+        attr_accessor :identifier
+      end
+    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)
+      execution_successful?
+    end
+
+    # returns a CQL string, or a Cassandra::Statement
+    # that is ready for execution
+    def statement
+      Cassandra::Statements::Simple.new(*build_cql_and_bindings)
+    end
+
+    protected
+
+    def build_cql_and_bindings
+      if identifier
+        send "build_#{identifier}_cql_and_bindings"
+      else
+        [cql, bindings]
+      end
+    end
+
+    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
+
+    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

@@ -0,0 +1,36 @@
+module Cassie
+  # Active Support used for
+  #  * include convenience via ActiveSupport::Concern
+  #  * string extensions
+  #  * notification pub/sub
+  #  * log formatting
+  #
+  # We require/autoload extensions only as needed,
+  # this base require has almost no overhead
+  #
+  # http://guides.rubyonrails.org/active_support_core_extensions.html
+  require 'active_support'
+  require 'cassandra'
+  require_relative 'queries/session'
+  require_relative 'queries/statement'
+  require_relative 'queries/pagination'
+  require_relative 'queries/instrumentation'
+  require_relative 'queries/logging'
+
+  class Query
+    include Queries::Session
+    include Queries::Statement
+    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

data/lib/cassie.rb

@@ -1,8 +1 @@
-# components are included via
-# separate gems for simpler
-# extensibility and the help
-# promote loose coupling
-
-# require 'cassie-configuration'
-# require 'cassie-migrations'
-require 'cassie-queries'
+require_relative 'cassie/query'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cassie
 version: !ruby/object:Gem::Version
-  version: 1.0.0.alpha.3
+  version: 1.0.0.alpha.4
 platform: ruby
 authors:
 - Evan Prothro
@@ -11,19 +11,33 @@ cert_chain: []
 date: 2016-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: cassie-queries
+  name: cassandra-driver
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0.alpha
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0.alpha
+        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
@@ -76,6 +90,32 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/cassie.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/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
 homepage: https://github.com/eprothro/cassie
 licenses:
 - MIT