cequel 0.0.0 → 0.4.0

data/lib/cequel/model/scoped.rb

@@ -0,0 +1,50 @@
+module Cequel
+
+  module Model
+
+    module Scoped
+
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        delegate :consistency, :count, :first, :limit, :select, :where,
+          :find_in_batches, :find_each, :find_rows_in_batches, :find_each_row,
+          :to => :all
+
+        def default_scope(scope)
+          @_cequel.default_scope = scope
+        end
+
+        def all
+          @_cequel.current_scope || @_cequel.default_scope || empty_scope
+        end
+
+        def select(*rows)
+          all.select(*rows)
+        end
+
+        def with_scope(scope)
+          @_cequel.synchronize do
+            old_scope = @_cequel.current_scope
+            begin
+              @_cequel.current_scope = scope
+              yield
+            ensure
+              @_cequel.current_scope = old_scope
+            end
+          end
+        end
+
+        private
+
+        def empty_scope
+          Scope.new(self, [column_family])
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/model/subclass_internals.rb

@@ -0,0 +1,45 @@
+module Cequel
+
+  module Model
+
+    class SubclassInternals < ClassInternals
+
+      def initialize(clazz, super_internals)
+        super(clazz)
+        @super = super_internals
+        @columns = {}
+      end
+
+      def index_preference
+        @super.index_preference + @index_preference
+      end
+
+      def key
+        @super.key
+      end
+
+      def columns
+        @super.columns.merge(@columns)
+      end
+
+      def type_column
+        @super.type_column
+      end
+
+      def column_family_name
+        @super.column_family_name
+      end
+
+      def base_class
+        @super.base_class
+      end
+
+      def associations
+        @super.associations.merge(super)
+      end
+
+    end
+    
+  end
+
+end

data/lib/cequel/model/timestamps.rb

@@ -0,0 +1,52 @@
+module Cequel
+  
+  module Model
+
+    module Timestamps
+
+      extend ActiveSupport::Concern
+
+      included do
+        include CreatedAt
+        include UpdatedAt
+      end
+
+      module CreatedAt
+
+        extend ActiveSupport::Concern
+
+        included do
+          column :created_at, :timestamp
+          before_create :_set_created_at
+        end
+
+        private
+
+        def _set_created_at
+          self.created_at = Time.now
+        end
+
+      end
+
+      module UpdatedAt
+
+        extend ActiveSupport::Concern
+
+        included do
+          column :updated_at, :timestamp
+          before_save :_set_updated_at
+        end
+
+        private
+
+        def _set_updated_at
+          self.updated_at = Time.now if transient? || changed?
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/model/translation.rb

@@ -0,0 +1,17 @@
+module Cequel
+
+  module Model
+
+    module Translation
+
+      extend ActiveModel::Translation
+
+      def i18n_scope
+        'cequel'
+      end
+
+    end
+    
+  end
+
+end

data/lib/cequel/model/validations.rb

@@ -0,0 +1,50 @@
+module Cequel
+  
+  module Model
+
+    module Validations
+
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveModel::Validations
+        alias_method_chain :valid?, :callbacks # XXX is there no better way?
+      end
+
+      module ClassMethods
+
+        def create!(attributes = {}, &block)
+          instance = new(attributes, &block)
+          instance.save!
+        end
+
+      end
+
+      def save(*args)
+        if valid?
+          super
+          true
+        else
+          false
+        end
+      end
+
+      def save!(*args)
+        raise RecordInvalid, errors.full_messages.join("; ") unless save
+        self
+      end
+
+      def update_attributes!(*args)
+        raise RecordInvalid, errors.full_messages.join("; ") unless update_attributes(*args)
+        self
+      end
+
+      def valid_with_callbacks?
+        run_callbacks(:validation) { valid_without_callbacks? }
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/new_relic_instrumentation.rb

@@ -0,0 +1,22 @@
+begin
+  require 'new_relic/agent/method_tracer'
+rescue LoadError => e
+  raise LoadError, "Can't use NewRelic instrumentation without NewRelic gem"
+end
+
+module Cequel
+
+  module NewRelicInstrumentation
+
+    extend ActiveSupport::Concern
+
+    included do
+      include NewRelic::Agent::MethodTracer
+      add_method_tracer :execute, 'Database/Cassandra/#{args[0][/^[A-Z ]*[A-Z]/].sub(/ FROM$/, \'\')}'
+    end
+
+  end
+
+end
+
+Cequel::Keyspace.module_eval { include Cequel::NewRelicInstrumentation }

data/lib/cequel/row_specification.rb

@@ -0,0 +1,63 @@
+module Cequel
+
+  #
+  # @private
+  #
+  class RowSpecification
+
+    def self.build(column_values)
+      column_values.map { |column, value| new(column, value) }
+    end
+
+    attr_reader :column, :value
+
+    def initialize(column, value)
+      @column, @value = column, value
+    end
+
+    def cql
+      case @value
+      when DataSet
+        subquery_cql
+      when Array
+        if @value.length == 1
+          ["? = ?", @column, @value.first]
+        else
+          [
+            "? IN (?)",
+            @column, @value
+          ]
+        end
+      else
+        ["? = ?", @column, @value]
+      end
+    end
+
+    private
+
+    def subquery_cql
+      values = values_from_subquery
+      case values.length
+      when 0
+        raise EmptySubquery,
+          "Unable to generate CQL row specification: subquery (#{@value.cql}) returned no results."
+      when 1
+        RowSpecification.new(@column, values.first).cql
+      else
+        RowSpecification.new(@column, values).cql
+      end
+    end
+
+    def values_from_subquery
+      results = @value.map do |row|
+        if row.length > 1
+          raise ArgumentError,
+            "Subqueries must return a single row per column"
+        end
+        row.values.first
+      end
+    end
+
+  end
+
+end

data/lib/cequel/statement.rb

@@ -0,0 +1,23 @@
+module Cequel
+  class Statement
+    attr_reader :bind_vars
+
+    def initialize
+      @cql, @bind_vars = StringIO.new, []
+    end
+
+    def cql
+      @cql.string
+    end
+
+    def append(cql, *bind_vars)
+      @cql << cql
+      @bind_vars.concat(bind_vars)
+      self
+    end
+
+    def args
+      [cql, *bind_vars]
+    end
+  end
+end

data/lib/cequel/version.rb

@@ -0,0 +1,3 @@
+module Cequel
+  VERSION = '0.4.0'
+end

data/spec/environment.rb

@@ -0,0 +1,3 @@
+require 'bundler'
+
+Bundler.require(:default, :test)

data/spec/examples/data_set_spec.rb

@@ -0,0 +1,382 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Cequel::DataSet do
+  describe '#insert' do
+    it 'should insert a row' do
+      connection.should_receive(:execute).
+        with "INSERT INTO posts (?) VALUES (?)", [:id, :title], [1, 'Fun times']
+
+      cequel[:posts].insert(:id => 1, :title => 'Fun times')
+    end
+
+    it 'should include consistency argument' do
+      connection.should_receive(:execute).
+        with "INSERT INTO posts (?) VALUES (?) USING CONSISTENCY QUORUM", [:id, :title], [1, 'Fun times']
+
+      cequel[:posts].insert(
+        {:id => 1, :title => 'Fun times'},
+        :consistency => :quorum
+      )
+    end
+
+    it 'should include ttl argument' do
+      connection.should_receive(:execute).
+        with "INSERT INTO posts (?) VALUES (?) USING TTL 600", [:id, :title], [1, 'Fun times']
+
+      cequel[:posts].insert(
+        {:id => 1, :title => 'Fun times'},
+        :ttl => 10.minutes
+      )
+    end
+
+    it 'should include timestamp argument' do
+      time = Time.now - 10.minutes
+      connection.should_receive(:execute).
+        with "INSERT INTO posts (?) VALUES (?) USING TIMESTAMP #{time.to_i}", [:id, :title], [1, 'Fun times']
+
+      cequel[:posts].insert(
+        {:id => 1, :title => 'Fun times'},
+        :timestamp => time
+      )
+    end
+
+    it 'should include multiple arguments joined by AND' do
+      time = Time.now - 10.minutes
+      connection.should_receive(:execute).
+        with "INSERT INTO posts (?) VALUES (?) USING CONSISTENCY QUORUM AND TTL 600 AND TIMESTAMP #{time.to_i}",
+        [:id, :title], [1, 'Fun times']
+
+      cequel[:posts].insert(
+        {:id => 1, :title => 'Fun times'},
+        :consistency => :quorum,
+        :ttl => 600,
+        :timestamp => time
+      )
+    end
+  end
+
+  describe '#update' do
+    it 'should send basic update statement' do
+      connection.should_receive(:execute).
+        with "UPDATE posts SET ? = ?, ? = ?", :title, 'Fun times', :body, 'Fun'
+
+      cequel[:posts].update(:title => 'Fun times', :body => 'Fun')
+    end
+
+    it 'should send update statement with options' do
+      time = Time.now - 10.minutes
+
+      connection.should_receive(:execute).
+        with "UPDATE posts USING CONSISTENCY QUORUM AND TTL 600 AND TIMESTAMP #{time.to_i} SET ? = ?, ? = ?", :title, 'Fun times', :body, 'Fun'
+
+      cequel[:posts].update(
+        {:title => 'Fun times', :body => 'Fun'},
+        :consistency => :quorum, :ttl => 600, :timestamp => time
+      )
+    end
+
+    it 'should send update statement scoped to current row specifications' do
+      connection.should_receive(:execute).
+        with "UPDATE posts SET ? = ? WHERE ? = ?", :title, 'Fun', :id, 4
+
+      cequel[:posts].where(:id => 4).update(:title => 'Fun')
+    end
+
+    it 'should do nothing if row specification contains empty subquery' do
+      connection.stub(:execute).with("SELECT ? FROM posts", [:blog_id]).
+        and_return result_stub
+
+      expect do
+        cequel[:blogs].where(:id => cequel[:posts].select(:blog_id)).
+          update(:title => 'Fun')
+      end.to_not raise_error
+    end
+  end
+
+  describe '#delete' do
+    it 'should send basic delete statement' do
+      connection.should_receive(:execute).
+        with 'DELETE FROM posts'
+
+      cequel[:posts].delete
+    end
+
+    it 'should send delete statement for specified columns' do
+      connection.should_receive(:execute).
+        with 'DELETE ? FROM posts', [:title, :body]
+
+      cequel[:posts].delete(:title, :body)
+    end
+
+    it 'should send delete statement with persistence options' do
+      time = Time.now - 10.minutes
+
+      connection.should_receive(:execute).
+        with "DELETE ? FROM posts USING CONSISTENCY QUORUM AND TIMESTAMP #{time.to_i}", [:title, :body]
+
+      cequel[:posts].delete(
+        :title, :body,
+        :consistency => :quorum, :timestamp => time
+      )
+    end
+
+    it 'should send delete statement with scoped row specifications' do
+      connection.should_receive(:execute).
+        with "DELETE FROM posts WHERE ? = ?", :id, 4
+
+      cequel[:posts].where(:id => 4).delete
+    end
+
+    it 'should not do anything if scoped to empty subquery' do
+      connection.stub(:execute).with("SELECT ? FROM posts", [:blog_id]).
+        and_return result_stub
+
+      expect do
+        cequel[:blogs].where(:id => cequel[:posts].select(:blog_id)).
+          delete
+      end.to_not raise_error
+    end
+  end
+
+  describe '#truncate' do
+    it 'should send a TRUNCATE statement' do
+      connection.should_receive(:execute).with("TRUNCATE posts")
+
+      cequel[:posts].truncate
+    end
+  end
+
+  describe '#cql' do
+    it 'should generate select statement with all columns' do
+      cequel[:posts].cql.should == ['SELECT * FROM posts']
+    end
+  end
+
+  describe '#select' do
+    it 'should generate select statement with given columns' do
+      cequel[:posts].select(:id, :title).cql.
+        should == ['SELECT ? FROM posts', [:id, :title]]
+    end
+
+    it 'should accept array argument' do
+      cequel[:posts].select([:id, :title]).cql.
+        should == ['SELECT ? FROM posts', [:id, :title]]
+    end
+
+    it 'should combine multiple selects' do
+      cequel[:posts].select(:id).select(:title).cql.
+        should == ['SELECT ? FROM posts', [:id, :title]]
+    end
+
+    it 'should accept :first option' do
+      cequel[:posts].select(:first => 100).cql.
+        should == ['SELECT FIRST 100 * FROM posts']
+    end
+
+    it 'should accept :last option' do
+      cequel[:posts].select(:last => 100).cql.
+        should == ['SELECT FIRST 100 REVERSED * FROM posts']
+    end
+
+    it 'should accept column range' do
+      cequel[:posts].select(1..10).cql.
+        should == ['SELECT ?..? FROM posts', 1, 10]
+    end
+
+    it 'should accept :from option' do
+      cequel[:posts].select(:from => 10).cql.
+        should == ['SELECT ?..? FROM posts', 10, '']
+    end
+
+    it 'should combine range and column limit options' do
+      cequel[:posts].select(:first => 100, :from => 10).cql.
+        should == ['SELECT FIRST 100 ?..? FROM posts', 10, '']
+    end
+
+    it 'should chain select options' do
+      cequel[:posts].select(:first => 100).select(:from => 10).cql.
+        should == ['SELECT FIRST 100 ?..? FROM posts', 10, '']
+    end
+  end
+
+  describe '#select!' do
+    it 'should generate select statement with given columns' do
+      cequel[:posts].select(:id, :title).select!(:published).cql.
+        should == ['SELECT ? FROM posts', [:published]]
+    end
+  end
+
+  describe '#where' do
+    it 'should build WHERE statement from hash' do
+      cequel[:posts].where(:title => 'Hey').cql.
+        should == ["SELECT * FROM posts WHERE ? = ?", :title, 'Hey']
+    end
+
+    it 'should build WHERE statement from multi-element hash' do
+      cequel[:posts].where(:title => 'Hey', :body => 'Guy').cql.
+        should == ["SELECT * FROM posts WHERE ? = ? AND ? = ?", :title, 'Hey', :body, 'Guy']
+    end
+
+    it 'should build WHERE statement with IN' do
+      cequel[:posts].where(:id => [1, 2, 3, 4]).cql.
+        should == ['SELECT * FROM posts WHERE ? IN (?)', :id, [1, 2, 3, 4]]
+    end
+
+    it 'should use = if provided one-element array' do
+      cequel[:posts].where(:id => [1]).cql.
+        should == ['SELECT * FROM posts WHERE ? = ?', :id, 1]
+    end
+
+    it 'should build WHERE statement from CQL string' do
+      cequel[:posts].where("title = ?", 'Hey').cql.
+        should == ["SELECT * FROM posts WHERE title = ?", 'Hey']
+    end
+
+    it 'should build WHERE statement from CQL string with bind variables' do
+      cequel[:posts].where("title = ?", 'Hey').cql.
+        should == ["SELECT * FROM posts WHERE title = ?", 'Hey']
+    end
+
+    it 'should aggregate multiple WHERE statements' do
+      cequel[:posts].where(:title => 'Hey').where('body = ?', 'Sup').cql.
+        should == ["SELECT * FROM posts WHERE ? = ? AND body = ?", :title, 'Hey', 'Sup']
+    end
+
+    it 'should take a data set as a condition and perform an IN statement' do
+      connection.stub(:execute).
+        with("SELECT ? FROM posts WHERE ? = ?", [:blog_id], :title, 'Blog').
+        and_return result_stub(
+          {:blog_id => 1},
+          {:blog_id => 3}
+        )
+
+      cequel[:blogs].where(
+        :id => cequel[:posts].select(:blog_id).where(:title => 'Blog')
+      ).cql.
+        should == ['SELECT * FROM blogs WHERE ? IN (?)', :id, [1, 3]]
+    end
+
+    it 'should raise EmptySubquery if inner data set has no results' do
+      connection.stub(:execute).
+        with("SELECT ? FROM posts WHERE ? = ?", [:blog_id], :title, 'Blog').
+        and_return result_stub
+
+      expect do
+        cequel[:blogs].where(
+          :id => cequel[:posts].select(:blog_id).where(:title => 'Blog')
+        ).cql
+      end.to raise_error(Cequel::EmptySubquery)
+    end
+
+  end
+
+  describe '#where!' do
+    it 'should override chained conditions' do
+      cequel[:posts].where(:title => 'Hey').where!(:title => 'Cequel').cql.
+        should == ["SELECT * FROM posts WHERE ? = ?", :title, 'Cequel']
+    end
+  end
+
+  describe '#consistency' do
+    it 'should add USING CONSISTENCY to select' do
+      cequel[:posts].consistency(:quorum).cql.
+        should == ["SELECT * FROM posts USING CONSISTENCY QUORUM"]
+    end
+  end
+
+  describe '#limit' do
+    it 'should add LIMIT' do
+      cequel[:posts].limit(2).cql.
+        should == ['SELECT * FROM posts LIMIT 2']
+    end
+  end
+
+  describe 'chaining scopes' do
+    it 'should aggregate all scope options' do
+      cequel[:posts].
+        select(:id, :title).
+        consistency(:quorum).
+        where(:title => 'Hey').
+        limit(3).cql.
+        should == ["SELECT ? FROM posts USING CONSISTENCY QUORUM WHERE ? = ? LIMIT 3", [:id, :title], :title, 'Hey']
+    end
+  end
+
+  describe 'result enumeration' do
+    it 'should enumerate over results' do
+      connection.stub(:execute).with("SELECT * FROM posts").
+        and_return result_stub('id' => 1, 'title' => 'Hey')
+
+      cequel[:posts].to_a.should == [{'id' => 1, 'title' => 'Hey'}]
+    end
+
+    it 'should provide results with indifferent access' do
+      connection.stub(:execute).with("SELECT * FROM posts").
+        and_return result_stub('id' => 1, 'title' => 'Hey')
+
+      cequel[:posts].to_a.first[:id].should == 1
+    end
+
+    it 'should not run query if no block given to #each' do
+      expect { cequel[:posts].each }.to_not raise_error
+    end
+
+    it 'should return Enumerator if no block given to #each' do
+      connection.stub(:execute).with("SELECT * FROM posts").
+        and_return result_stub('id' => 1, 'title' => 'Hey')
+
+      cequel[:posts].each.each_with_index.map { |row, i| [row[:id], i] }.
+        should == [[1, 0]]
+    end
+
+    it 'should return no results if subquery is empty' do
+      connection.stub(:execute).with("SELECT ? FROM posts", [:blog_id]).
+        and_return result_stub
+
+      cequel[:blogs].where(:id => cequel[:posts].select(:blog_id)).to_a.
+        should == []
+    end
+  end
+
+  describe '#first' do
+    it 'should run a query with LIMIT 1 and return first row' do
+      connection.stub(:execute).with("SELECT * FROM posts LIMIT 1").
+        and_return result_stub('id' => 1, 'title' => 'Hey')
+
+      cequel[:posts].first.should == {'id' => 1, 'title' => 'Hey'}
+    end
+
+    it 'should return nil if subquery returns empty results' do
+      connection.stub(:execute).with("SELECT ? FROM posts", [:blog_id]).
+        and_return result_stub
+
+      cequel[:blogs].where(:id => cequel[:posts].select(:blog_id)).first.
+        should be_nil
+    end
+  end
+
+  describe '#count' do
+    it 'should run a count query and return count' do
+      connection.stub(:execute).with("SELECT COUNT(*) FROM posts").
+        and_return result_stub('count' => 4)
+
+      cequel[:posts].count.should == 4
+    end
+
+    it 'should return 0 if subquery returns no results' do
+      connection.stub(:execute).with("SELECT ? FROM posts", [:blog_id]).
+        and_return result_stub
+
+      cequel[:blogs].where(:id => cequel[:posts].select(:blog_id)).count.
+        should == 0
+    end
+
+    it 'should use limit if specified' do
+      connection.stub(:execute).with("SELECT COUNT(*) FROM posts LIMIT 100000").
+        and_return result_stub('count' => 4)
+
+      cequel[:posts].limit(100_000).count.should == 4
+    end
+  end
+
+end