cequel 1.7.0 → 1.8.0

data/lib/cequel/metal/keyspace.rb

@@ -187,23 +187,13 @@ module Cequel
         execute_with_consistency(statement, bind_vars, default_consistency)
       end
 
-      #
-      # Execute a CQL query in this keyspace with the given consistency
-      #
-      # @param statement [String] CQL string
-      # @param bind_vars [Array] array of values for bind variables
-      # @param consistency [Symbol] consistency at which to execute query
-      # @return [Enumerable] the results of the query
-      #
-      # @since 1.1.0
-      #
-      def execute_with_consistency(statement, bind_vars, consistency)
-        retries = max_retries
+      def execute_with_options(statement, bind_vars, options={})
+        options[:consistency] ||= default_consistency
 
+        retries = max_retries
         log('CQL', statement, *bind_vars) do
           begin
-            client.execute(sanitize(statement, bind_vars),
-                           consistency: consistency || default_consistency)
+            client.execute(sanitize(statement, bind_vars), options)
           rescue Cassandra::Errors::NoHostsAvailable,
                  Ione::Io::ConnectionError => e
             clear_active_connections!
@@ -213,6 +203,20 @@ module Cequel
             retry
           end
         end
+
+      end
+      #
+      # Execute a CQL query in this keyspace with the given consistency
+      #
+      # @param statement [String] CQL string
+      # @param bind_vars [Array] array of values for bind variables
+      # @param consistency [Symbol] consistency at which to execute query
+      # @return [Enumerable] the results of the query
+      #
+      # @since 1.1.0
+      #
+      def execute_with_consistency(statement, bind_vars, consistency)
+        execute_with_options(statement, bind_vars, {consistency: consistency || default_consistency})
       end
 
       #

data/lib/cequel/metal/request_logger.rb

@@ -51,9 +51,16 @@ module Cequel
       private
 
       def format_for_log(label, timing, statement, bind_vars)
+        bind_vars = bind_vars.map{|it| String === it ? limit_length(it) : it }
         format('%s (%s) %s', label, timing, sanitize(statement, bind_vars))
       end
 
+      def limit_length(str)
+        return str if str.length < 100
+
+        str[0..25] + "..." + str[-25..-1]
+      end
+
       def_delegator 'Cequel::Metal::Keyspace', :sanitize
       private :sanitize
     end

data/lib/cequel/record/data_set_builder.rb

@@ -40,6 +40,8 @@ module Cequel
         add_bounds
         add_order
         set_consistency
+        set_page_size
+        set_paging_state
         data_set
       end
 
@@ -51,7 +53,7 @@ module Cequel
                      :scoped_key_names, :scoped_key_values,
                      :scoped_indexed_column, :lower_bound,
                      :upper_bound, :reversed?, :order_by_column,
-                     :query_consistency, :ascends_by?
+                     :query_consistency, :query_page_size, :query_paging_state, :ascends_by?
 
       private
 
@@ -97,6 +99,18 @@ module Cequel
         end
       end
 
+      def set_page_size
+        if query_page_size
+          self.data_set = data_set.page_size(query_page_size)
+        end
+      end
+
+      def set_paging_state
+        if query_paging_state
+          self.data_set = data_set.paging_state(query_paging_state)
+        end
+      end
+
       def sort_direction
         ascends_by?(order_by_column) ? :asc : :desc
       end

data/lib/cequel/record/properties.rb

@@ -343,6 +343,8 @@ module Cequel
         unless self.class.reflect_on_column(name)
           fail UnknownAttributeError, "unknown attribute: #{name}"
         end
+
+        send("#{name}_will_change!") unless value === read_attribute(name)
         @attributes[name] = value
       end
 

data/lib/cequel/record/record_set.rb

@@ -464,6 +464,30 @@ module Cequel
         scoped(query_consistency: consistency)
       end
 
+      #
+      # Set the page_size at which to read records into the record set.
+      #
+      # @param page_size [Integer] page_size for reads
+      # @return [RecordSet] record set tuned to given page_size
+      #
+      def page_size(page_size)
+        scoped(query_page_size: page_size)
+      end
+
+      #
+      # Set the paging_state at which to read records into the record set.
+      #
+      # @param paging_state [String] paging_state for reads
+      # @return [RecordSet] record set tuned to given paging_state
+      #
+      def paging_state(paging_state)
+        scoped(query_paging_state: paging_state)
+      end
+
+      def next_paging_state
+        data_set.next_paging_state
+      end
+
       #
       # @overload first
       #   @return [Record] the first record in this record set
@@ -667,9 +691,11 @@ module Cequel
       attr_reader :attributes
       hattr_reader :attributes, :select_columns, :scoped_key_values,
                    :row_limit, :lower_bound, :upper_bound,
-                   :scoped_indexed_column, :query_consistency
+                   :scoped_indexed_column, :query_consistency,
+                   :query_page_size, :query_paging_state
       protected :select_columns, :scoped_key_values, :row_limit, :lower_bound,
-                :upper_bound, :scoped_indexed_column, :query_consistency
+                :upper_bound, :scoped_indexed_column, :query_consistency,
+                :query_page_size, :query_paging_state
       hattr_inquirer :attributes, :reversed
       protected :reversed?
 

data/lib/cequel/schema/table_reader.rb

@@ -75,7 +75,7 @@ module Cequel
       def read_partition_keys
         validators = table_data['key_validator']
         types = parse_composite_types(validators) || [validators]
-        columns = partition_columns.sort { |c| c['component_index'] }
+        columns = partition_columns.sort_by { |c| c['component_index'] }
           .map { |c| c['column_name'] }
 
         columns.zip(types) do |name, type|

data/lib/cequel/version.rb

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

data/spec/examples/metal/data_set_spec.rb

@@ -654,6 +654,30 @@ describe Cequel::Metal::DataSet do
     end
   end
 
+  describe '#page_size' 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 }
+    end
+  end
+
+  describe '#paging_state' 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 }
+    end
+  end
+
   describe 'result enumeration' do
     let(:row) { row_keys.merge(:title => 'Big Data') }
 

data/spec/examples/record/dirty_spec.rb

@@ -59,12 +59,4 @@ describe Cequel::Record::Dirty do
     end
   end
 
-  context 'unloaded model' do
-    let(:post) { Post['cequel'] }
-
-    it 'should not track changes' do
-      post.title = 'Cequel'
-      expect(post.changes).to be_empty
-    end
-  end
 end

data/spec/examples/record/persistence_spec.rb

@@ -128,8 +128,8 @@ describe Cequel::Record::Persistence do
         it 'should save with specified TTL' do
           blog.name = 'Cequel 1.4'
           blog.save(ttl: 10)
-          expect(cequel[Blog.table_name].select_ttl(:name).first.ttl(:name)).
-            to be_within(0.1).of(9.9)
+          expect(cequel[Blog.table_name].select_ttl(:name).first.ttl(:name))
+            .to be_between(9,10).inclusive
         end
 
         it 'should save with specified timestamp' do

data/spec/examples/record/properties_spec.rb

@@ -53,6 +53,11 @@ describe Cequel::Record::Properties do
         title).to eq('Big Data')
     end
 
+    it 'should mark the attribute as dirty when setting attributes' do
+      expect(Post.new { |post| post.title = 'Big Data' }.changed).to eq(['title'])
+      expect(Post.new { |post| post.title = 'Big Data' }.changes).to eq({'title' => [nil,'Big Data']})
+    end
+
     it 'should get attributes with indifferent access' do
       post = Post.new.tap { |post| post.attributes = {:downcased_title => 'big data' }}
       expect(post.attributes[:title]).to eq 'Big Data'

data/spec/examples/record/record_set_spec.rb

@@ -811,6 +811,41 @@ describe Cequel::Record::RecordSet do
     end
   end
 
+  describe '#page_size' do
+    it 'should return the number of records specified by page_size' do
+      expect(Post.page_size(2).to_a.length).to be(2)
+    end
+  end
+
+  describe '#next_paging_state' do
+    it 'should return the paging state of the result' do
+      expect(Post.page_size(1).next_paging_state).not_to eq(nil)
+    end
+  end
+
+  describe '#paging_state' do
+    let(:page_one) { Post.page_size(1) }
+    let(:page_two) { Post.page_size(1).paging_state(page_one.next_paging_state) }
+    let(:page_size) { 3 }
+
+    it 'should page through all records' do
+      all_pages = []
+      next_paging_state = nil
+
+      loop do
+        a_page = Post.page_size(page_size).paging_state(next_paging_state)
+        next_paging_state = a_page.next_paging_state
+
+        # There may be less than page size records on final page
+        expect(a_page.to_a.length).to be <= page_size
+        all_pages.concat(a_page.to_a)
+        break if next_paging_state.nil?
+      end
+
+      expect(all_pages).to eq(posts.to_a)
+    end
+  end
+
   describe '#count' do
     let(:records) { blogs }
 

data/spec/examples/record/schema_spec.rb

@@ -73,6 +73,48 @@ describe Cequel::Record::Schema do
     end
   end
 
+  context 'CQL3 table with non-dictionary-ordered partition columns' do
+    let(:table_name) { 'accesses_' + SecureRandom.hex(4) }
+
+    let(:model) do
+      model_table_name = table_name
+      Class.new do
+        include Cequel::Record
+        self.table_name = model_table_name
+
+        key :serial, :text, partition: true
+        key :username, :text, partition: true
+        key :date, :text, partition: true
+        key :access_time, :timeuuid
+        column :url, :text
+      end
+    end
+
+    let(:model_modified) do
+      model_table_name = table_name
+      Class.new do
+        include Cequel::Record
+        self.table_name = model_table_name
+
+        key :serial, :text, partition: true
+        key :username, :text, partition: true
+        key :date, :text, partition: true
+        key :access_time, :timeuuid
+        column :url, :text
+        column :user_agent, :text
+      end
+    end
+
+    before { model.synchronize_schema }
+    after { cequel.schema.drop_table(table_name) }
+
+    it 'should be able to synchronize schema again' do
+      expect {
+        model_modified.synchronize_schema
+      }.not_to raise_error
+    end
+  end
+
   context 'wide-row legacy table' do
     let(:table_name) { 'legacy_posts_' + SecureRandom.hex(4) }
 

data/spec/examples/schema/table_reader_spec.rb

@@ -2,16 +2,17 @@
 require File.expand_path('../../spec_helper', __FILE__)
 
 describe Cequel::Schema::TableReader do
+  let(:table_name) { :"posts_#{SecureRandom.hex(4)}" }
 
   after do
-    cequel.schema.drop_table(:posts)
+    cequel.schema.drop_table(table_name)
   end
 
-  let(:table) { cequel.schema.read_table(:posts) }
+  let(:table) { cequel.schema.read_table(table_name) }
 
   describe 'reading simple key' do
     before do
-      cequel.execute("CREATE TABLE posts (permalink text PRIMARY KEY)")
+      cequel.execute("CREATE TABLE #{table_name} (permalink text PRIMARY KEY)")
     end
 
     it 'should read name correctly' do
@@ -30,7 +31,7 @@ describe Cequel::Schema::TableReader do
   describe 'reading single non-partition key' do
     before do
       cequel.execute <<-CQL
-        CREATE TABLE posts (
+        CREATE TABLE #{table_name} (
           blog_subdomain text,
           permalink ascii,
           PRIMARY KEY (blog_subdomain, permalink)
@@ -63,7 +64,7 @@ describe Cequel::Schema::TableReader do
   describe 'reading reverse-ordered non-partition key' do
     before do
       cequel.execute <<-CQL
-        CREATE TABLE posts (
+        CREATE TABLE #{table_name} (
           blog_subdomain text,
           permalink ascii,
           PRIMARY KEY (blog_subdomain, permalink)
@@ -89,7 +90,7 @@ describe Cequel::Schema::TableReader do
   describe 'reading compound non-partition key' do
     before do
       cequel.execute <<-CQL
-        CREATE TABLE posts (
+        CREATE TABLE #{table_name} (
           blog_subdomain text,
           permalink ascii,
           author_id uuid,
@@ -116,7 +117,7 @@ describe Cequel::Schema::TableReader do
   describe 'reading compound partition key' do
     before do
       cequel.execute <<-CQL
-        CREATE TABLE posts (
+        CREATE TABLE #{table_name} (
           blog_subdomain text,
           permalink ascii,
           PRIMARY KEY ((blog_subdomain, permalink))
@@ -142,7 +143,7 @@ describe Cequel::Schema::TableReader do
   describe 'reading compound partition and non-partition keys' do
     before do
       cequel.execute <<-CQL
-        CREATE TABLE posts (
+        CREATE TABLE #{table_name} (
           blog_subdomain text,
           permalink ascii,
           author_id uuid,
@@ -183,7 +184,7 @@ describe Cequel::Schema::TableReader do
 
     before do
       cequel.execute <<-CQL
-        CREATE TABLE posts (
+        CREATE TABLE #{table_name} (
           blog_subdomain text,
           permalink ascii,
           title text,
@@ -194,7 +195,7 @@ describe Cequel::Schema::TableReader do
           PRIMARY KEY (blog_subdomain, permalink)
         )
       CQL
-      cequel.execute('CREATE INDEX posts_author_id_idx ON posts (author_id)')
+      cequel.execute("CREATE INDEX posts_author_id_idx ON #{table_name} (author_id)")
     end
 
     it 'should read types of scalar data columns' do
@@ -255,7 +256,7 @@ describe Cequel::Schema::TableReader do
 
     before do
       cequel.execute <<-CQL
-        CREATE TABLE posts (permalink text PRIMARY KEY)
+        CREATE TABLE #{table_name} (permalink text PRIMARY KEY)
         WITH bloom_filter_fp_chance = 0.02
         AND comment = 'Posts table'
         AND compaction = {
@@ -315,7 +316,7 @@ describe Cequel::Schema::TableReader do
   describe 'skinny-row compact storage' do
     before do
       cequel.execute <<-CQL
-        CREATE TABLE posts (permalink text PRIMARY KEY, title text, body text)
+        CREATE TABLE #{table_name} (permalink text PRIMARY KEY, title text, body text)
         WITH COMPACT STORAGE
       CQL
     end
@@ -333,7 +334,7 @@ describe Cequel::Schema::TableReader do
   describe 'wide-row compact storage' do
     before do
       cequel.execute <<-CQL
-        CREATE TABLE posts (
+        CREATE TABLE #{table_name} (
           blog_subdomain text,
           id uuid,
           data text,
@@ -356,7 +357,7 @@ describe Cequel::Schema::TableReader do
   describe 'skinny-row legacy table', thrift: true do
     before do
       legacy_connection.execute <<-CQL
-        CREATE TABLE posts (permalink text PRIMARY KEY, title text, body text)
+        CREATE TABLE #{table_name} (permalink text PRIMARY KEY, title text, body text)
       CQL
     end
     subject { table }
@@ -375,7 +376,7 @@ describe Cequel::Schema::TableReader do
   describe 'wide-row legacy table', thrift: true do
     before do
       legacy_connection.execute(<<-CQL2)
-        CREATE COLUMNFAMILY posts (blog_subdomain text PRIMARY KEY)
+        CREATE COLUMNFAMILY #{table_name} (blog_subdomain text PRIMARY KEY)
         WITH comparator=uuid AND default_validation=text
       CQL2
     end