cequel 1.10.0 → 2.0.0

data/lib/cequel/schema/table_updater.rb

@@ -100,7 +100,7 @@ module Cequel
       #   Altering column types is not recommended.
       #
       def change_column(name, type)
-        alter_table("ALTER #{name} TYPE #{type(type).cql_name}")
+        add_stmt %Q|ALTER TABLE "#{table_name}" ALTER "#{name}" TYPE #{type}|
       end
 
       #
@@ -111,7 +111,7 @@ module Cequel
       # @return [void]
       #
       def rename_column(old_name, new_name)
-        alter_table(%(RENAME "#{old_name}" TO "#{new_name}"))
+        add_stmt %Q|ALTER TABLE "#{table_name}" RENAME "#{old_name}" TO "#{new_name}"|
       end
 
       #
@@ -125,7 +125,7 @@ module Cequel
       def change_properties(options)
         properties = options
           .map { |name, value| TableProperty.build(name, value).to_cql }
-        alter_table("WITH #{properties.join(' AND ')}")
+        add_stmt %Q|ALTER TABLE "#{table_name}" WITH #{properties.join(' AND ')}|
       end
 
       #
@@ -136,10 +136,8 @@ module Cequel
       #   convention if nil
       # @return [void]
       #
-      def create_index(column_name, index_name = nil)
-        index_name ||= "#{table_name}_#{column_name}_idx"
-        statements <<
-          "CREATE INDEX #{index_name} ON #{table_name} (#{column_name})"
+      def create_index(column_name, index_name = "#{table_name}_#{column_name}_idx")
+        add_stmt %Q|CREATE INDEX "#{index_name}" ON "#{table_name}" ("#{column_name}")|
       end
 
       #
@@ -149,12 +147,12 @@ module Cequel
       # @return [void]
       #
       def drop_index(index_name)
-        statements << "DROP INDEX #{index_name}"
+        add_stmt %Q|DROP INDEX IF EXISTS "#{index_name}"|
       end
 
       # @!visibility protected
       def add_data_column(column)
-        add_column_statement(column)
+        add_stmt(%Q|ALTER TABLE #{table_name} ADD #{column.to_cql}|)
       end
 
       protected
@@ -163,12 +161,8 @@ module Cequel
 
       private
 
-      def alter_table(statement)
-        statements << "ALTER TABLE #{table_name} #{statement}"
-      end
-
-      def add_column_statement(column)
-        alter_table("ADD #{column.to_cql}")
+      def add_stmt(cql)
+        statements << Cequel::Metal::Statement.new(cql)
       end
 
       def type(type)

data/lib/cequel/version.rb

@@ -1,5 +1,5 @@
 # -*- encoding : utf-8 -*-
 module Cequel
   # The current version of the library
-  VERSION = '1.10.0'
+  VERSION = '2.0.0'
 end

data/spec/examples/metal/data_set_spec.rb

@@ -85,7 +85,7 @@ describe Cequel::Metal::DataSet do
     end
 
     it 'should insert row with given consistency' do
-      expect_query_with_consistency(/INSERT/, :one) do
+      expect_query_with_consistency(->(s){/INSERT/ === s.cql}, :one) do
         cequel[:posts].insert(row, consistency: :one)
       end
     end
@@ -125,7 +125,7 @@ describe Cequel::Metal::DataSet do
     end
 
     it 'should send update statement with given consistency' do
-      expect_query_with_consistency(/UPDATE/, :one) do
+      expect_query_with_consistency(->(s){/UPDATE/ === s.cql}, :one) do
         cequel[:posts].where(row_keys).update(
           {title: 'Marshmallows'}, consistency: :one)
       end
@@ -191,14 +191,21 @@ describe Cequel::Metal::DataSet do
       )
     end
 
+    # breaks in Cassandra 2.0.13+ or 2.1.3+ because reverse order bug was fixed:
+    # https://issues.apache.org/jira/browse/CASSANDRA-8733
     it 'should prepend multiple elements to list column' do
       cequel[:posts].insert(
         row_keys.merge(categories: ['Big Data', 'Cassandra']))
       cequel[:posts].where(row_keys).
         list_prepend(:categories, ['Scalability', 'Partition Tolerance'])
-      expect(cequel[:posts].where(row_keys).first[:categories]).to eq(
+
+      expected = if cequel.bug8733_version?
         ['Partition Tolerance', 'Scalability', 'Big Data', 'Cassandra']
-      )
+      else
+        ['Scalability', 'Partition Tolerance', 'Big Data', 'Cassandra']
+      end
+
+      expect(cequel[:posts].where(row_keys).first[:categories]).to eq(expected)
     end
   end
 
@@ -268,9 +275,9 @@ describe Cequel::Metal::DataSet do
     end
 
     it 'should add multiple elements to set' do
-      cequel[:posts].insert(
-        row_keys.merge(tags: Set['big-data', 'nosql']))
+      cequel[:posts].insert(row_keys.merge(tags: Set['big-data', 'nosql']))
       cequel[:posts].where(row_keys).set_add(:tags, 'cassandra')
+
       expect(cequel[:posts].where(row_keys).first[:tags]).
         to eq(Set['big-data', 'nosql', 'cassandra'])
     end
@@ -379,7 +386,7 @@ describe Cequel::Metal::DataSet do
     end
 
     it 'should send delete with specified consistency' do
-      expect_query_with_consistency(/DELETE/, :one) do
+      expect_query_with_consistency(->(s){/DELETE/ === s.cql}, :one) do
         cequel[:posts].where(row_keys).delete(:body, :consistency => :one)
       end
     end
@@ -429,7 +436,7 @@ describe Cequel::Metal::DataSet do
 
   describe '#cql' do
     it 'should generate select statement with all columns' do
-      expect(cequel[:posts].cql).to eq(['SELECT * FROM posts'])
+      expect(cequel[:posts].cql.to_s).to eq('SELECT * FROM posts')
     end
   end
 
@@ -504,8 +511,7 @@ describe Cequel::Metal::DataSet do
         title: 'Bogus Post',
       ))
       expect(cequel[:posts].where(
-        :blog_subdomain => %w(cassandra big-data-weekly),
-        :permalink => 'big-data'
+        :blog_subdomain => %w(cassandra big-data-weekly)
       ).map { |row| row[:title] }).to match_array(['Big Data', 'Cassandra'])
     end
 
@@ -584,33 +590,29 @@ describe Cequel::Metal::DataSet do
     let(:data_set) { cequel[:posts].consistency(:one) }
 
     it 'should issue SELECT with scoped consistency' do
-      expect_query_with_consistency(/SELECT/, :one) { data_set.to_a }
-    end
-
-    it 'should issue COUNT with scoped consistency' do
-      expect_query_with_consistency(/SELECT.*COUNT/, :one) { data_set.count }
+      expect_query_with_consistency(anything, :one) { data_set.to_a }
     end
 
     it 'should issue INSERT with scoped consistency' do
-      expect_query_with_consistency(/INSERT/, :one) do
+      expect_query_with_consistency(anything, :one) do
         data_set.insert(row_keys)
       end
     end
 
     it 'should issue UPDATE with scoped consistency' do
-      expect_query_with_consistency(/UPDATE/, :one) do
+      expect_query_with_consistency(anything, :one) do
         data_set.where(row_keys).update(title: 'Marshmallows')
       end
     end
 
     it 'should issue DELETE with scoped consistency' do
-      expect_query_with_consistency(/DELETE/, :one) do
+      expect_query_with_consistency(anything, :one) do
         data_set.where(row_keys).delete
       end
     end
 
     it 'should issue DELETE column with scoped consistency' do
-      expect_query_with_consistency(/DELETE/, :one) do
+      expect_query_with_consistency(anything, :one) do
         data_set.where(row_keys).delete(:title)
       end
     end
@@ -622,33 +624,29 @@ describe Cequel::Metal::DataSet do
     let(:data_set) { cequel[:posts] }
 
     it 'should issue SELECT with default consistency' do
-      expect_query_with_consistency(/SELECT/, :all) { data_set.to_a }
-    end
-
-    it 'should issue COUNT with default consistency' do
-      expect_query_with_consistency(/SELECT.*COUNT/, :all) { data_set.count }
+      expect_query_with_consistency(anything, :all) { data_set.to_a }
     end
 
     it 'should issue INSERT with default consistency' do
-      expect_query_with_consistency(/INSERT/, :all) do
+      expect_query_with_consistency(anything, :all) do
         data_set.insert(row_keys)
       end
     end
 
     it 'should issue UPDATE with default consistency' do
-      expect_query_with_consistency(/UPDATE/, :all) do
+      expect_query_with_consistency(anything, :all) do
         data_set.where(row_keys).update(title: 'Marshmallows')
       end
     end
 
     it 'should issue DELETE with default consistency' do
-      expect_query_with_consistency(/DELETE/, :all) do
+      expect_query_with_consistency(anything, :all) do
         data_set.where(row_keys).delete
       end
     end
 
     it 'should issue DELETE column with default consistency' do
-      expect_query_with_consistency(/DELETE/, :all) do
+      expect_query_with_consistency(anything, :all) do
         data_set.where(row_keys).delete(:title)
       end
     end
@@ -658,11 +656,7 @@ describe Cequel::Metal::DataSet do
     let(:data_set) { cequel[:posts].page_size(1) }
 
     it 'should issue SELECT with scoped page size' do
-      expect_query_with_options(/SELECT/, :page_size => 1) { data_set.to_a }
-    end
-
-    it 'should issue COUNT with scoped page size' do
-      expect_query_with_options(/SELECT.*COUNT/, :page_size => 1) { data_set.count }
+      expect_query_with_options(->(s){/SELECT/ === s.cql}, :page_size => 1) { data_set.to_a }
     end
   end
 
@@ -670,11 +664,7 @@ describe Cequel::Metal::DataSet do
     let(:data_set) { cequel[:posts].paging_state(nil) }
 
     it 'should issue SELECT with scoped paging state' do
-      expect_query_with_options(/SELECT/, :paging_state => nil) { data_set.to_a }
-    end
-
-    it 'should issue COUNT with scoped paging state' do
-      expect_query_with_options(/SELECT.*COUNT/, :paging_state => nil) { data_set.count }
+      expect_query_with_options(->(s){/SELECT/ === s.cql}, :paging_state => nil) { data_set.to_a }
     end
   end
 
@@ -728,18 +718,16 @@ describe Cequel::Metal::DataSet do
       end
     end
 
-    it 'should run a count query and return count' do
-      expect(cequel[:posts].count).to eq(4)
+    it 'should raise DangerousQueryError when attempting to count' do
+      expect{ cequel[:posts].count }.to raise_error(Cequel::Record::DangerousQueryError)
     end
 
-    it 'should use where clause if specified' do
-      expect(cequel[:posts].where(row_keys.merge(permalink: 'post-1')).
-        count).to eq(1)
+    it 'should raise DangerousQueryError when attempting to access size' do
+      expect{ cequel[:posts].size }.to raise_error(Cequel::Record::DangerousQueryError)
     end
 
-    it 'should use limit if specified' do
-      expect(cequel[:posts].limit(2).count).to eq(2)
+    it 'should raise DangerousQueryError when attempting to access length' do
+      expect{ cequel[:posts].length }.to raise_error(Cequel::Record::DangerousQueryError)
     end
   end
-
 end

data/spec/examples/metal/keyspace_spec.rb

@@ -35,9 +35,9 @@ describe Cequel::Metal::Keyspace do
     it 'should auto-apply if option given' do
       cequel.batch(auto_apply: 2) do
         cequel[:posts].insert(id: 1, title: 'One')
-        expect(cequel[:posts].count).to be_zero
+        expect(cequel[:posts].to_a.count).to be_zero
         cequel[:posts].insert(id: 2, title: 'Two')
-        expect(cequel[:posts].count).to be(2)
+        expect(cequel[:posts].to_a.count).to be(2)
       end
     end
 
@@ -46,7 +46,7 @@ describe Cequel::Metal::Keyspace do
     end
 
     it 'should execute unlogged batch if specified' do
-      expect_query_with_consistency(/BEGIN UNLOGGED BATCH/, anything) do
+      expect_query_with_consistency(instance_of(Cassandra::Statements::Batch::Unlogged), anything) do
         cequel.batch(unlogged: true) do
           cequel[:posts].insert(id: 1, title: 'One')
           cequel[:posts].insert(id: 2, title: 'Two')
@@ -55,7 +55,7 @@ describe Cequel::Metal::Keyspace do
     end
 
     it 'should execute batch with given consistency' do
-      expect_query_with_consistency(/BEGIN BATCH/, :one) do
+      expect_query_with_consistency(instance_of(Cassandra::Statements::Batch::Logged), :one) do
         cequel.batch(consistency: :one) do
           cequel[:posts].insert(id: 1, title: 'One')
           cequel[:posts].insert(id: 2, title: 'Two')
@@ -127,8 +127,10 @@ describe Cequel::Metal::Keyspace do
 
     context "with a connection error" do
       it "reconnects to cassandra with a new client after first failed connection" do
-        allow(cequel.client).to receive(:execute)
-          .with(statement, :consistency => cequel.default_consistency)
+        allow(cequel.client)
+          .to receive(:execute)
+               .with(->(s){ s.cql == statement},
+                     hash_including(:consistency => cequel.default_consistency))
           .and_raise(Ione::Io::ConnectionError)
           .once
 

data/spec/examples/record/associations_spec.rb

@@ -297,26 +297,16 @@ describe Cequel::Record::Associations do
       expect(blog.posts.first.title).to eq('Post 0')
     end
 
-    it 'should always query the database for #count' do
-      blog.posts.entries
-      posts.first.destroy
-      expect(blog.posts.count).to eq(2)
+    it 'should raise DangerousQueryError for #count' do
+      expect{ blog.posts.count }.to raise_error(Cequel::Record::DangerousQueryError)
     end
 
-    it 'should always load the records for #length' do
-      expect(blog.posts.length).to eq(3)
-      expect(blog.posts).to be_loaded
+    it 'should raise DangerousQueryError for #length' do
+      expect{ blog.posts.length }.to raise_error(Cequel::Record::DangerousQueryError)
     end
 
-    it 'should count from database for #size if unloaded' do
-      expect(blog.posts.size).to eq(3)
-      expect(blog.posts).not_to be_loaded
-    end
-
-    it 'should count records in memory for #size if loaded' do
-      blog.posts.entries
-      disallow_queries!
-      expect(blog.posts.size).to eq(3)
+    it 'should raise DangerousQueryError for #size' do
+      expect{ blog.posts.size }.to raise_error(Cequel::Record::DangerousQueryError)
     end
 
     it "does not allow invalid :dependent options" do
@@ -350,7 +340,7 @@ describe Cequel::Record::Associations do
       it "deletes all children when destroying the parent" do
         expect {
           post_with_comments.destroy
-        }.to change { Comment.count }.by(-2)
+        }.to change { Comment.all.to_a.count }.by(-2)
       end
 
       it "executes :destroy callbacks on the children" do
@@ -375,7 +365,7 @@ describe Cequel::Record::Associations do
       it "deletes all children when destroying the parent" do
         expect {
           post_with_attachments.destroy
-        }.to change { Attachment.count }.by(-2)
+        }.to change { Attachment.all.to_a.count }.by(-2)
       end
 
       it "does not execute :destroy callbacks on the children" do

data/spec/examples/record/persistence_spec.rb

@@ -50,7 +50,7 @@ describe Cequel::Record::Persistence do
         end
 
         it 'should save with specified consistency' do
-          expect_query_with_consistency(/INSERT/, :one) do
+          expect_query_with_consistency(anything, :one) do
             Blog.new do |blog|
               blog.subdomain = 'cequel'
               blog.name = 'Cequel'
@@ -119,7 +119,7 @@ describe Cequel::Record::Persistence do
         end
 
         it 'should save with specified consistency' do
-          expect_query_with_consistency(/UPDATE/, :one) do
+          expect_query_with_consistency(anything, :one) do
             blog.name = 'Cequel'
             blog.save(consistency: :one)
           end
@@ -148,7 +148,7 @@ describe Cequel::Record::Persistence do
 
         it 'should not mark itself as clean if save failed at Cassandra level' do
           blog.name = 'Pizza'
-          with_client_error(Cassandra::Errors::InvalidError.new(1, 'error')) do
+          with_client_error(Cassandra::Errors::InvalidError.new(nil, nil, nil, nil, nil, nil, nil, nil, nil)) do
             begin
               blog.save
             rescue Cassandra::Errors::InvalidError
@@ -243,14 +243,14 @@ describe Cequel::Record::Persistence do
 
       it 'should destroy with specified consistency' do
         blog = Blog.create(:subdomain => 'big-data', :name => 'Big Data')
-        expect_query_with_consistency(/DELETE/, :one) do
+        expect_query_with_consistency(anything, :one) do
           blog.destroy(consistency: :one)
         end
       end
 
-      it 'should destroy with specified timestamp' do
+      it 'should not destroy records without specified timestamp' do
         blog = Blog.create(subdomain: 'big-data', name: 'Big Data')
-        blog.destroy(timestamp: 1.minute.ago)
+        blog.destroy(timestamp: 1.hour.ago)
         expect(cequel[Blog.table_name].where(subdomain: 'big-data').first).to be
       end
     end

data/spec/examples/record/record_set_spec.rb

@@ -674,7 +674,11 @@ describe Cequel::Record::RecordSet do
     let(:records) { blogs }
 
     it 'should return the number of records requested' do
-      expect(Blog.limit(2).length).to be(2)
+      expect(Blog.limit(2).to_a.length).to be(2)
+    end
+
+    it 'should return the minimum of the requested limit and the actual record count' do
+      expect(Blog.limit(5).to_a.length).to be(3)
     end
   end
 
@@ -805,7 +809,7 @@ describe Cequel::Record::RecordSet do
 
   describe '#consistency' do
     it 'should perform query with specified consistency' do
-      expect_query_with_consistency(/SELECT/, :one) do
+      expect_query_with_consistency(anything, :one) do
         Post.consistency(:one).to_a
       end
     end
@@ -847,10 +851,34 @@ describe Cequel::Record::RecordSet do
   end
 
   describe '#count' do
-    let(:records) { blogs }
+    let(:records) { posts }
 
-    it 'should count records' do
-      expect(Blog.count).to eq(3)
+    context 'without scoping' do
+      it 'should raise DangerousQueryError when attempting to count' do
+        expect{ Post.count }.to raise_error(Cequel::Record::DangerousQueryError)
+      end
+
+      it 'should raise DangerousQueryError when attempting to access size' do
+        expect{ Post.size }.to raise_error(Cequel::Record::DangerousQueryError)
+      end
+
+      it 'should raise DangerousQueryError when attempting to access length' do
+        expect{ Post.length }.to raise_error(Cequel::Record::DangerousQueryError)
+      end
+    end
+
+    context 'with scoping' do
+      it 'should raise DangerousQueryError when attempting to count' do
+        expect{ Post['postgres'].count }.to raise_error(Cequel::Record::DangerousQueryError)
+      end
+
+      it 'should raise DangerousQueryError when attempting to access size' do
+        expect{ Post['postgres'].size }.to raise_error(Cequel::Record::DangerousQueryError)
+      end
+
+      it 'should raise DangerousQueryError when attempting to access length' do
+        expect{ Post['postgres'].length }.to raise_error(Cequel::Record::DangerousQueryError)
+      end
     end
   end
 
@@ -895,13 +923,13 @@ describe Cequel::Record::RecordSet do
 
     it 'should be able to delete with no scoping' do
       Post.delete_all
-      expect(Post.count).to be_zero
+      expect(Post.first).to be_nil
     end
 
     it 'should be able to delete with scoping' do
       Post['postgres'].delete_all
-      expect(Post['postgres'].count).to be_zero
-      expect(Post['cassandra'].count).to eq(cassandra_posts.length)
+      expect(Post['postgres'].first).to be_nil
+      expect(Post['cassandra'].to_a.count).to eq(cassandra_posts.length)
     end
 
     it 'should be able to delete fully specified collection' do
@@ -916,13 +944,13 @@ describe Cequel::Record::RecordSet do
 
     it 'should be able to delete with no scoping' do
       Post.destroy_all
-      expect(Post.count).to be_zero
+      expect(Post.first).to be_nil
     end
 
     it 'should be able to delete with scoping' do
       Post['postgres'].destroy_all
-      expect(Post['postgres'].count).to be_zero
-      expect(Post['cassandra'].count).to eq(cassandra_posts.length)
+      expect(Post['postgres'].first).to be_nil
+      expect(Post['cassandra'].to_a.count).to eq(cassandra_posts.length)
     end
 
     it 'should be able to delete fully specified collection' do
@@ -974,5 +1002,4 @@ describe Cequel::Record::RecordSet do
         .to yield_successive_args *blog_1_views
     end
   end
-
 end