extendi-cassandra_object 1.0.17 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2eb80f8a2bc136c5333d17e73df717ed4d2d33f8e28fa31ff30fdf7c8648e645
-  data.tar.gz: 57c5cb2c0939b8eca99790ac0b7f80a643e04617f31762138aea076a6e868bea
+  metadata.gz: c5523ad43210b62402fbfb637042415f14a7fe174fa3f3646556b1b1e3701df9
+  data.tar.gz: a9ed0b2512e264395a1340c2fbccbaf9259d893105c738c9724d2ee0eba2a944
 SHA512:
-  metadata.gz: ccdf0d3c0599fd1373d9dc214f5ebd3409acd43b80f27ace5951d5d31fad059bee0f8a78f719b2075fbe472e2639c1d4a7f510ad4570b49fa0e3db6f3fa2be34
-  data.tar.gz: c61f6366852d7bbff248c80dee0ae620c0b4b087ae4905b45982e255563f8c560fbfbee8d217cbf23292b9ef0c2395a392cb9470f154bb7da17820e32a703c23
+  metadata.gz: f038a28315870cef3b0bc1366e3baa46d4098b7a7c3a4733ec02a2a71281861f87a111e9dfbf1d5c9a0c167b8e1e72198662dded4c7a7b90acbd154b5131e305
+  data.tar.gz: 58ab0a6d6347d97533334ee017ef8d7f9aaf9890e770d1b2abf3629f7e1b80f0a372241985c7c38e47dc4cebd8a2efa100a5c98384ff6ca17dea6927f976ea76

data/.gitignore

@@ -4,3 +4,7 @@ Gemfile.lock
 .byebug_history
 .ruby-version
 TAGS
+.editorconfig
+.rubocop.yml
+.prettierrc.js
+.eslintrc.js

data/.travis.yml

@@ -1,20 +1,21 @@
+dist: trusty
+
 language: ruby
 rvm:
-  - 2.4.0
-  - 2.4.1
-  - 2.4.2
   - 2.5.1
+  - 2.6.5
+  - 2.7.0
 env:
-  - CASSANDRA_VERSION=2.1.2
+  - SCYLLA_VERSION=3.0.2
   - CASSANDRA_VERSION=3.0.10
   - CASSANDRA_VERSION=3.9
-  - CASSANDRA_VERSION=2.1.2 ACTIVEMODEL_VERSION='< 5'
-  - CASSANDRA_VERSION=3.0.10 ACTIVEMODEL_VERSION='< 5'
-  - CASSANDRA_VERSION=3.9 ACTIVEMODEL_VERSION='< 5'
 
 jdk:
   - oraclejdk8
 
+services:
+  - docker
+
 before_install:
   - sudo apt-get install libjna-java
   - sudo apt-get install python-support
@@ -23,7 +24,18 @@ before_install:
   - sudo pip install ccm
 
 install:
-  - ccm create -n 1 -v $CASSANDRA_VERSION -i 127.0.0. -s -b test-cluster
-  - ccm start
-  - if [ -n "$ACTIVEMODEL_VERSION" ];then bundle add activemodel --version "$ACTIVEMODEL_VERSION"; fi
-  - bundle install
+  - |
+    if [ -n "$CASSANDRA_VERSION" ];then
+      ccm create -n 1 -v $CASSANDRA_VERSION -i 127.0.0. -s -b test-cluster;
+      ccm start;
+    fi
+    if [ -n "$SCYLLA_VERSION" ];then
+      SCYLLA_IMAGE=scylladb/scylla:$SCYLLA_VERSION
+      docker pull $SCYLLA_IMAGE
+      docker run --name cassandra_test -d -p "9042:9042" -p "9160:9160" $SCYLLA_IMAGE
+      function check_scylla(){ docker exec -it cassandra_test nodetool status | grep UN; }
+      until check_scylla; do
+       echo "waiting..."
+      done
+    fi
+    bundle install

data/CHANGELOG

@@ -0,0 +1,9 @@
+# Changelog
+
+## [1.1.0] - 2020-06-18
+### Changed
+- load_balancing_policy now accept only Cassandra::LoadBalancing::Policies objects
+
+## [1.1.1] - 2020-06-18
+### Changed
+- add write_consistency on cassandra object config

data/README.md

@@ -1,7 +1,7 @@
 # Cassandra Object
 [![Build Status](https://secure.travis-ci.org/giovannelli/cassandra_object.png)](http://travis-ci.org/giovannelli/cassandra_object) [![Code Climate](https://codeclimate.com/github/giovannelli/cassandra_object/badges/gpa.svg)](https://codeclimate.com/github/giovannelli/cassandra_object)
 
-Cassandra Object uses ActiveModel to mimic much of the behavior in ActiveRecord. 
+Cassandra Object uses ActiveModel to mimic much of the behavior in ActiveRecord.
 Use cql3 provided by ruby-driver gem and uses the old thrift structure with the possible option at [this link](https://docs.datastax.com/en/cql/3.1/cql/cql_reference/create_table_r.html?hl=create%2Ctable):
 
 ```shell
@@ -11,22 +11,20 @@ CREATE TABLE keyspace.table (
     column1 text,
     value blob,
     PRIMARY KEY (key, column1)
-) WITH 
-    COMPACT STORAGE
-    AND CLUSTERING ORDER BY (column1 ASC)
-    AND bloom_filter_fp_chance = 0.001
-    AND caching = '{"keys":"ALL", "rows_per_partition":"NONE"}'
+) WITH bloom_filter_fp_chance = 0.01
+    AND caching = {'keys': 'ALL', 'rows_per_partition': 'ALL'}
     AND comment = ''
-    AND compaction = {'min_sstable_size': '52428800', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy'}
-    AND compression = {'chunk_length_kb': '64', 'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'}
-    AND dclocal_read_repair_chance = 0.0
+    AND compaction = {'class': 'SizeTieredCompactionStrategy', 'max_threshold': '32', 'min_threshold': '4'}
+    AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'}
+    AND crc_check_chance = 1.0
+    AND dclocal_read_repair_chance = 0.1
     AND default_time_to_live = 0
     AND gc_grace_seconds = 864000
     AND max_index_interval = 2048
     AND memtable_flush_period_in_ms = 0
     AND min_index_interval = 128
-    AND read_repair_chance = 1.0
-    AND speculative_retry = 'NONE';
+    AND read_repair_chance = 0.0
+    AND speculative_retry = '99.0PERCENTILE';
 ```
 
 You can also use the a custom schema structure with the possible options at [this link](https://docs.datastax.com/en/cql/3.3/cql/cql_reference/cqlCreateTable.html#tabProp):
@@ -39,20 +37,20 @@ CREATE TABLE keyspace.table (
     field2 varchar,
     field3 float,
     PRIMARY KEY (key)
-) WITH 
-    bloom_filter_fp_chance = 0.001
-    AND caching = {'keys':'ALL', 'rows_per_partition':'NONE'}'
+) WITH bloom_filter_fp_chance = 0.01
+    AND caching = {'keys': 'ALL', 'rows_per_partition': 'ALL'}
     AND comment = ''
-    AND compaction = {'min_sstable_size': '52428800', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy'}
-    AND compression = {'chunk_length_kb': '64', 'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'}
-    AND dclocal_read_repair_chance = 0.0
+    AND compaction = {'class': 'SizeTieredCompactionStrategy', 'max_threshold': '32', 'min_threshold': '4'}
+    AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'}
+    AND crc_check_chance = 1.0
+    AND dclocal_read_repair_chance = 0.1
     AND default_time_to_live = 0
     AND gc_grace_seconds = 864000
     AND max_index_interval = 2048
     AND memtable_flush_period_in_ms = 0
     AND min_index_interval = 128
-    AND read_repair_chance = 1.0
-    AND speculative_retry = 'NONE';
+    AND read_repair_chance = 0.0
+    AND speculative_retry = '99.0PERCENTILE';
 ```
 
 ## Installation
@@ -120,16 +118,16 @@ You can define a custom configuration for the cassandra connection, allowing you
 ```ruby
 class Widget < CassandraObject::BaseSchema
   string :name
-  
+
   def self.custom_config
-    #return custom cassandra configuration  
+    #return custom cassandra configuration
     { }
   end
 end
 ```
- 
+
 ## Using with Cassandra
-  
+
 Add a config/cassandra.yml:
 
 ```yaml
@@ -140,6 +138,7 @@ development:
   connect_timeout: 0.1,
   request_timeout: 0.1,
   consistency: :any/:one/:two/:three/:quorum/:all/:local_quorum/:each_quorum/:serial/:local_serial/:local_one,
+  write_consistency: :any/:one/:two/:three/:quorum/:all/:local_quorum/:each_quorum/:serial/:local_serial/:local_one,
   protocol_version: 3,
   page_size: 10000,
   trace: true/false

data/extendi-cassandra_object.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = 'extendi-cassandra_object'
-  s.version = '1.0.17'
+  s.version = '1.1.1'
   s.description = 'Cassandra ActiveModel'
   s.summary = 'Cassandra ActiveModel'
   s.authors = ['Duccio Giovannelli', 'gotime']
@@ -17,7 +17,7 @@ Gem::Specification.new do |s|
   s.test_files  = `git ls-files -- {test}/*`.split("\n")
   s.require_paths = ['lib']
 
-  s.add_runtime_dependency('activemodel', '<= 5.2')
+  s.add_runtime_dependency('activemodel', '>= 4.2.0', '< 7.0.0')
   s.add_runtime_dependency('cassandra-driver', '>= 3.2.3')
   s.add_runtime_dependency('lz4-ruby', '>= 0.3.3')
 

data/lib/cassandra_object/adapters/cassandra_adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 gem 'cassandra-driver'
 require 'cassandra'
 require 'logger'
@@ -6,7 +8,6 @@ module CassandraObject
   module Adapters
     class CassandraAdapter < AbstractAdapter
       class QueryBuilder
-
         def initialize(adapter, scope)
           @adapter = adapter
           @scope = scope
@@ -27,22 +28,27 @@ module CassandraObject
                 "SELECT #{select_string} FROM #{@scope.klass.column_family}",
                 where_string_async(nil)
             ]
-            str << "ALLOW FILTERING" if @scope.klass.allow_filtering
+            str << 'ALLOW FILTERING' if @scope.klass.allow_filtering
             return [] << str.delete_if(&:blank?) * ' '
           end
-          @scope.id_values.map do |id|
-            str = [
-                "SELECT #{select_string} FROM #{@scope.klass.column_family}",
-                where_string_async(id)
-            ]
-            str << "ALLOW FILTERING" if @scope.klass.allow_filtering
-            str.delete_if(&:blank?) * ' '
-          end
+
+          str = [
+            "SELECT #{select_string} FROM #{@scope.klass.column_family}",
+            where_string_async(@scope.id_values)
+          ]
+          str << 'ALLOW FILTERING' if @scope.klass.allow_filtering
+          [str.delete_if(&:blank?) * ' ']
         end
 
-        def where_string_async(id)
+        def where_string_async(ids)
           wheres = @scope.where_values.dup.select.each_with_index { |_, i| i.even? }
-          wheres << "#{@scope._key} = '#{id}'" if !id.nil?
+          if ids.present?
+            wheres << if ids.size > 1
+              "#{@scope._key} IN (#{ids.map { |id| "'#{id}'" }.join(',')})"
+            else
+              "#{@scope._key} = '#{ids.first}'"
+            end
+          end
           "WHERE #{wheres * ' AND '}" if wheres.any?
         end
       end
@@ -57,6 +63,7 @@ module CassandraObject
             :connections_per_local_node,
             :connections_per_remote_node,
             :consistency,
+            :write_consistency,
             :credentials,
             :futures_factory,
             :hosts,
@@ -82,14 +89,14 @@ module CassandraObject
         ])
 
         {
-            load_balancing_policy: 'Cassandra::LoadBalancing::Policies::%s',
+            # load_balancing_policy: 'Cassandra::LoadBalancing::Policies::%s',
             reconnection_policy: 'Cassandra::Reconnection::Policies::%s',
             retry_policy: 'Cassandra::Retry::Policies::%s'
         }.each do |policy_key, class_template|
           params = cluster_options[policy_key]
           if params
             if params.is_a?(Hash)
-              cluster_options[policy_key] = (class_template % [params[:policy].classify]).constantize.new(*params[:params]||[])
+              cluster_options[policy_key] = (class_template % [params[:policy].classify]).constantize.new(*params[:params] || [])
             else
               cluster_options[policy_key] = (class_template % [params.classify]).constantize.new
             end
@@ -101,7 +108,8 @@ module CassandraObject
                                 heartbeat_interval: cluster_options.keys.include?(:heartbeat_interval) ? cluster_options[:heartbeat_interval] : 30,
                                 idle_timeout: cluster_options[:idle_timeout] || 60,
                                 max_schema_agreement_wait: 1,
-                                consistency: cluster_options[:consistency] || :one,
+                                consistency: cluster_options[:consistency] || :local_one,
+                                write_consistency: cluster_options[:write_consistency] || cluster_options[:consistency] || :local_one,
                                 protocol_version: cluster_options[:protocol_version] || 3,
                                 page_size: cluster_options[:page_size] || 10000
                                })
@@ -116,6 +124,8 @@ module CassandraObject
       end
 
       def execute(statement, arguments = [])
+        consistency = config[:write_consistency] || config[:consistency]
+        # puts "cassandra adapter: #{consistency}"
         ActiveSupport::Notifications.instrument('cql.cassandra_object', cql: statement) do
           type_hints = []
           arguments.each { |a| type_hints << CassandraObject::Types::TypeHelper.guess_type(a) } unless arguments.nil?
@@ -124,6 +134,8 @@ module CassandraObject
       end
 
       def execute_async(queries, arguments = [])
+        consistency = config[:consistency]
+        # puts "execute_async adapter: #{consistency}"
         retries = 0
         futures = queries.map do |q|
           ActiveSupport::Notifications.instrument('cql.cassandra_object', cql: q) do
@@ -146,8 +158,8 @@ module CassandraObject
       def select(scope)
         queries = QueryBuilder.new(self, scope).to_query_async
         # todo paginate
-        arguments = scope.where_values.select.each_with_index{ |_, i| i.odd? }.reject{ |c| c.blank? }
-        cql_rows = execute_async(queries, arguments).map{|item| item.rows.map{|x| x}}.flatten!
+        arguments = scope.where_values.select.each_with_index { |_, i| i.odd? }.reject { |c| c.blank? }
+        cql_rows = execute_async(queries, arguments).map { |item| item.rows.map { |x| x } }.flatten!
         cql_rows.each do |cql_row|
           attributes = cql_row.to_hash
           key = attributes.delete(scope._key)
@@ -165,31 +177,31 @@ module CassandraObject
 
       def write(table, id, attributes, ttl = nil)
         statement = "INSERT INTO #{table} (#{(attributes.keys).join(',')}) VALUES (#{(['?'] * attributes.size).join(',')})"
-        statement += " USING TTL #{ttl.to_s}" if ttl.present?
+        statement += " USING TTL #{ttl}" if ttl.present?
         arguments = attributes.values
         execute(statement, arguments)
       end
 
       def write_update(table, id, attributes)
-        queries =[]
+        queries = []
         # id here is the name of the key of the model
         id_value = attributes[id]
         if (not_nil_attributes = attributes.reject { |key, value| value.nil? }).any?
           statement = "INSERT INTO #{table} (#{(not_nil_attributes.keys).join(',')}) VALUES (#{(['?'] * not_nil_attributes.size).join(',')})"
-          queries << {query: statement, arguments: not_nil_attributes.values}
+          queries << { query: statement, arguments: not_nil_attributes.values }
         end
         if (nil_attributes = attributes.select { |key, value| value.nil? }).any?
-          queries << {query: "DELETE #{nil_attributes.keys.join(',')} FROM #{table} WHERE #{id} = ?", arguments: [id_value.to_s]}
+          queries << { query: "DELETE #{nil_attributes.keys.join(',')} FROM #{table} WHERE #{id} = ?", arguments: [id_value.to_s] }
         end
         execute_batchable(queries)
       end
 
       def delete(scope, ids, attributes = {})
         ids = [ids] if !ids.is_a?(Array)
-        statement = "DELETE FROM #{scope.column_family} WHERE #{scope._key} IN (#{ids.map{|id| '?'}.join(',')})"
+        statement = "DELETE FROM #{scope.column_family} WHERE #{scope._key} IN (#{ids.map { |id| '?' }.join(',')})"
         arguments = ids
         unless attributes.blank?
-          statement += " AND #{attributes.keys.map{ |k| "#{k} = ?" }.join(' AND ')}"
+          statement += " AND #{attributes.keys.map { |k| "#{k} = ?" }.join(' AND ')}"
           arguments += attributes.values
         end
         execute(statement, arguments)
@@ -197,20 +209,23 @@ module CassandraObject
 
       def delete_single(obj)
         keys = obj.class._keys
-        wheres = keys.map{ |k| "#{k} = ?" }.join(' AND ')
-        arguments = keys.map{ |k| obj.attributes[k] }
+        wheres = keys.map { |k| "#{k} = ?" }.join(' AND ')
+        arguments = keys.map { |k| obj.attributes[k] }
         statement = "DELETE FROM #{obj.class.column_family} WHERE #{wheres}"
         execute(statement, arguments)
       end
 
       def execute_batch(statements)
-        raise 'No can do' if statements.empty?
+        raise 'Statements is empty!' if statements.empty?
+        consistency = config[:write_consistency] || config[:consistency]
+        # puts "cassandra adapter execute batch #{consistency}"
+
         batch = connection.batch do |b|
           statements.each do |statement|
             b.add(statement[:query], arguments: statement[:arguments])
           end
         end
-        connection.execute(batch, page_size: config[:page_size])
+        connection.execute(batch, consistency: consistency, page_size: config[:page_size])
       end
 
       # SCHEMA
@@ -239,7 +254,7 @@ module CassandraObject
       def schema_execute(cql, keyspace)
         schema_db = Cassandra.cluster cassandra_cluster_options
         connection = schema_db.connect keyspace
-        connection.execute cql, consistency: consistency
+        connection.execute cql, consistency: config[:write_consistency] || config[:consistency]
       end
 
       def cassandra_version
@@ -248,14 +263,6 @@ module CassandraObject
 
       # /SCHEMA
 
-      def consistency
-        defined?(@consistency) ? @consistency : nil
-      end
-
-      def consistency=(val)
-        @consistency = val
-      end
-
       def statement_create_with_options(stmt, options = '')
         if !options.nil?
           statement_with_options stmt, options
@@ -266,7 +273,7 @@ module CassandraObject
               AND caching = '{\"keys\":\"ALL\", \"rows_per_partition\":\"NONE\"}'
               AND comment = ''
               AND compaction = {'min_sstable_size': '52428800', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy'}
-              AND compression = {'chunk_length_kb': '64', 'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'}
+              AND compression = {'chunk_length_kb': '64', 'class': 'org.apache.cassandra.io.compress.LZ4Compressor'}
               AND dclocal_read_repair_chance = 0.0
               AND default_time_to_live = 0
               AND gc_grace_seconds = 864000
@@ -276,24 +283,24 @@ module CassandraObject
               AND read_repair_chance = 1.0
               AND speculative_retry = 'NONE';"
           else
-            "#{stmt} WITH read_repair_chance = 0.0
-              AND dclocal_read_repair_chance = 0.1
-              AND gc_grace_seconds = 864000
-              AND bloom_filter_fp_chance = 0.01
-              AND caching = { 'keys' : 'ALL', 'rows_per_partition' : 'NONE' }
+            "#{stmt} WITH bloom_filter_fp_chance = 0.01
+              AND caching = {'keys': 'ALL', 'rows_per_partition': 'ALL'}
               AND comment = ''
-              AND compaction = { 'class' : 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold' : 32, 'min_threshold' : 4 }
-              AND compression = { 'chunk_length_in_kb' : 64, 'class' : 'org.apache.cassandra.io.compress.LZ4Compressor' }
+              AND compaction = {'class': 'SizeTieredCompactionStrategy', 'max_threshold': '32', 'min_threshold': '4'}
+              AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'}
+              AND crc_check_chance = 1.0
+              AND dclocal_read_repair_chance = 0.1
               AND default_time_to_live = 0
-              AND speculative_retry = '99PERCENTILE'
-              AND min_index_interval = 128
+              AND gc_grace_seconds = 864000
               AND max_index_interval = 2048
-              AND crc_check_chance = 1.0;
+              AND memtable_flush_period_in_ms = 0
+              AND min_index_interval = 128
+              AND read_repair_chance = 0.0
+              AND speculative_retry = '99.0PERCENTILE';
             "
           end
         end
       end
-
     end
   end
 end

data/lib/cassandra_object/adapters/cassandra_schemaless_adapter.rb

@@ -26,34 +26,39 @@ module CassandraObject
 
           if @scope.id_values.empty?
             str = [
-                "SELECT #{select_string} FROM #{@scope.klass.column_family}",
-                where_string_async(nil)
+              "SELECT #{select_string} FROM #{@scope.klass.column_family}",
+              where_string_async(nil)
             ]
             str << 'ALLOW FILTERING' if @scope.klass.allow_filtering
             return [] << str.delete_if(&:blank?) * ' '
           end
-          @scope.id_values.map do |id|
-            str = [
-                "SELECT #{select_string} FROM #{@scope.klass.column_family}",
-                where_string_async(id)
-            ]
-            str << 'ALLOW FILTERING' if @scope.klass.allow_filtering
-            str.delete_if(&:blank?) * ' '
-          end
+          str = [
+            "SELECT #{select_string} FROM #{@scope.klass.column_family}",
+            where_string_async(@scope.id_values)
+          ]
+          str << 'ALLOW FILTERING' if @scope.klass.allow_filtering
+          [str.delete_if(&:blank?) * ' ']
         end
 
-        def where_string_async(id)
+        def where_string_async(ids)
           conditions = []
-          conditions << "#{@adapter.primary_key_column} = '#{id}'" if !id.nil?
+
+          if ids.present?
+            conditions << if ids.size > 1
+              "#{@adapter.primary_key_column} IN (#{ids.map { |id| "'#{id}'" }.join(',')})"
+            else
+              "#{@adapter.primary_key_column} = '#{ids.first}'"
+            end
+          end
+
           select_values = @scope.select_values.select { |sv| sv != :column1 }
           if select_values.size > 0
             select_str = select_values.size > 1 ? "column1 IN (#{select_values.map { |sv| '?' }.join(',')})" : 'column1 = ?'
             conditions << select_str
           end
           conditions += @scope.where_values.select.each_with_index { |_, i| i.even? }
-          return conditions.any? ? "WHERE #{conditions.join(' AND ')}" : nil
+          conditions.any? ? "WHERE #{conditions.join(' AND ')}" : nil
         end
-
       end
 
       def primary_key_column
@@ -70,6 +75,7 @@ module CassandraObject
             :connections_per_local_node,
             :connections_per_remote_node,
             :consistency,
+            :write_consistency,
             :credentials,
             :futures_factory,
             :hosts,
@@ -95,26 +101,27 @@ module CassandraObject
         ])
 
         {
-            load_balancing_policy: 'Cassandra::LoadBalancing::Policies::%s',
+            # load_balancing_policy: 'Cassandra::LoadBalancing::Policies::%s',
             reconnection_policy: 'Cassandra::Reconnection::Policies::%s',
             retry_policy: 'Cassandra::Retry::Policies::%s'
         }.each do |policy_key, class_template|
           params = cluster_options[policy_key]
           if params
             if params.is_a?(Hash)
-              cluster_options[policy_key] = (class_template % [params[:policy].classify]).constantize.new(*params[:params]||[])
+              cluster_options[policy_key] = (class_template % [params[:policy].classify]).constantize.new(*params[:params] || [])
             else
               cluster_options[policy_key] = (class_template % [params.classify]).constantize.new
             end
           end
         end
-        
+
         # Setting defaults
         cluster_options.merge!({
                                 heartbeat_interval: cluster_options.keys.include?(:heartbeat_interval) ? cluster_options[:heartbeat_interval] : 30,
                                 idle_timeout: cluster_options[:idle_timeout] || 60,
                                 max_schema_agreement_wait: 1,
-                                consistency: cluster_options[:consistency] || :one,
+                                consistency: cluster_options[:consistency] || :local_one,
+                                write_consistency: cluster_options[:write_consistency] || cluster_options[:consistency] || :local_one,
                                 protocol_version: cluster_options[:protocol_version] || 3,
                                 page_size: cluster_options[:page_size] || 10000
                                })
@@ -129,12 +136,17 @@ module CassandraObject
       end
 
       def execute(statement, arguments = [])
+        consistency = config[:write_consistency] || config[:consistency]
+        # puts "schemaless adapter: #{consistency}"
         ActiveSupport::Notifications.instrument('cql.cassandra_object', cql: statement) do
           connection.execute statement, arguments: arguments, consistency: consistency, page_size: config[:page_size]
         end
       end
 
       def execute_async(queries, arguments = [], per_page = nil, next_cursor = nil)
+        consistency = config[:consistency]
+        # puts "schemaless adapter async: #{consistency}"
+
         retries = 0
         per_page ||= config[:page_size]
         futures = queries.map { |q|
@@ -164,7 +176,7 @@ module CassandraObject
           item.rows.each { |x| ids << x[primary_key_column] }
           new_next_cursor = item.paging_state unless item.last_page?
         end
-        return {ids: ids, new_next_cursor: new_next_cursor}
+        { ids: ids, new_next_cursor: new_next_cursor }
       end
 
       def select(scope)
@@ -172,19 +184,19 @@ module CassandraObject
         queries.compact! if queries.present?
         raise CassandraObject::RecordNotFound if !queries.present?
 
-        arguments = scope.select_values.select{ |sv| sv != :column1 }.map(&:to_s)
-        arguments += scope.where_values.select.each_with_index{ |_, i| i.odd? }.reject{ |c| c.empty? }.map(&:to_s)
+        arguments = scope.select_values.select { |sv| sv != :column1 }.map(&:to_s)
+        arguments += scope.where_values.select.each_with_index { |_, i| i.odd? }.reject { |c| c.empty? }.map(&:to_s)
         records = execute_async(queries, arguments).map do |item|
           # pagination
           elems = []
           loop do
-            item.rows.each{ |x| elems << x }
+            item.rows.each { |x| elems << x }
             break if item.last_page?
             item = item.next_page
           end
           elems
         end
-        {results: records.flatten!}
+        { results: records.flatten! }
       end
 
       def select_paginated(scope)
@@ -192,15 +204,15 @@ module CassandraObject
         queries.compact! if queries.present?
         raise CassandraObject::RecordNotFound if !queries.present?
 
-        arguments = scope.select_values.select{ |sv| sv != :column1 }.map(&:to_s)
-        arguments += scope.where_values.select.each_with_index{ |_, i| i.odd? }.reject{ |c| c.empty? }.map(&:to_s)
+        arguments = scope.select_values.select { |sv| sv != :column1 }.map(&:to_s)
+        arguments += scope.where_values.select.each_with_index { |_, i| i.odd? }.reject { |c| c.empty? }.map(&:to_s)
         new_next_cursor = nil
         records = []
         execute_async(queries, arguments, scope.limit_value, scope.next_cursor).each do |item|
           new_next_cursor = item.paging_state unless item.last_page?
-          item.rows.each{ |x| records << x }
+          item.rows.each { |x| records << x }
         end
-        {results: records, new_next_cursor: new_next_cursor}
+        { results: records, new_next_cursor: new_next_cursor }
       end
 
       def insert(table, id, attributes, ttl = nil)
@@ -213,16 +225,15 @@ module CassandraObject
 
       def write(table, id, attributes, ttl)
         queries = []
-        # puts attributes
         attributes.each do |column, value|
           if !value.nil?
             query = "INSERT INTO #{table} (#{primary_key_column},column1,value) VALUES (?,?,?)"
-            query += " USING TTL #{ttl.to_s}" if !ttl.nil?
+            query += " USING TTL #{ttl}" if !ttl.nil?
             args = [id.to_s, column.to_s, value.to_s]
 
-            queries << {query: query, arguments: args}
+            queries << { query: query, arguments: args }
           else
-            queries << {query: "DELETE FROM #{table} WHERE #{primary_key_column} = ? AND column1= ?", arguments: [id.to_s, column.to_s]}
+            queries << { query: "DELETE FROM #{table} WHERE #{primary_key_column} = ? AND column1= ?", arguments: [id.to_s, column.to_s] }
           end
         end
         execute_batchable(queries)
@@ -232,18 +243,20 @@ module CassandraObject
         ids = [ids] if !ids.is_a?(Array)
         arguments = nil
         arguments = ids if ids.size == 1
-        statement = "DELETE FROM #{table} WHERE #{create_ids_where_clause(ids)}" #.gsub('?', ids.map { |id| "'#{id}'" }.join(','))
+        statement = "DELETE FROM #{table} WHERE #{create_ids_where_clause(ids)}" # .gsub('?', ids.map { |id| "'#{id}'" }.join(','))
         execute(statement, arguments)
       end
 
       def execute_batch(statements)
-        raise 'No can do' if statements.empty?
+        consistency = config[:write_consistency] || config[:consistency]
+        # puts "schemaless execute batch #{consistency}"
+        raise 'Statements is empty!' if statements.empty?
         batch = connection.batch do |b|
           statements.each do |statement|
             b.add(statement[:query], arguments: statement[:arguments])
           end
         end
-        connection.execute(batch, page_size: config[:page_size])
+        connection.execute(batch, consistency: consistency, page_size: config[:page_size])
       end
 
       # SCHEMA
@@ -270,7 +283,7 @@ module CassandraObject
       def schema_execute(cql, keyspace)
         schema_db = Cassandra.cluster cassandra_cluster_options
         connection = schema_db.connect keyspace
-        connection.execute cql, consistency: consistency
+        connection.execute cql, consistency: config[:write_consistency] || config[:consistency]
       end
 
       def cassandra_version
@@ -279,14 +292,6 @@ module CassandraObject
 
       # /SCHEMA
 
-      def consistency
-        defined?(@consistency) ? @consistency : nil
-      end
-
-      def consistency=(val)
-        @consistency = val
-      end
-
       def statement_create_with_options(stmt, options)
         if !options.nil?
           statement_with_options stmt, options
@@ -299,7 +304,7 @@ module CassandraObject
               AND caching = '{\"keys\":\"ALL\", \"rows_per_partition\":\"NONE\"}'
               AND comment = ''
               AND compaction = {'min_sstable_size': '52428800', 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy'}
-              AND compression = {'chunk_length_kb': '64', 'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'}
+              AND compression = {'chunk_length_kb': '64', 'class': 'org.apache.cassandra.io.compress.LZ4Compressor'}
               AND dclocal_read_repair_chance = 0.0
               AND default_time_to_live = 0
               AND gc_grace_seconds = 864000
@@ -309,19 +314,20 @@ module CassandraObject
               AND read_repair_chance = 1.0
               AND speculative_retry = 'NONE';"
           else
-            "#{stmt} WITH read_repair_chance = 0.0
-              AND dclocal_read_repair_chance = 0.1
-              AND gc_grace_seconds = 864000
-              AND bloom_filter_fp_chance = 0.01
-              AND caching = { 'keys' : 'ALL', 'rows_per_partition' : 'NONE' }
+            "#{stmt} WITH bloom_filter_fp_chance = 0.01
+              AND caching = {'keys': 'ALL', 'rows_per_partition': 'ALL'}
               AND comment = ''
-              AND compaction = { 'class' : 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'max_threshold' : 32, 'min_threshold' : 4 }
-              AND compression = { 'chunk_length_in_kb' : 64, 'class' : 'org.apache.cassandra.io.compress.LZ4Compressor' }
+              AND compaction = {'class': 'SizeTieredCompactionStrategy', 'max_threshold': '32', 'min_threshold': '4'}
+              AND compression = {'sstable_compression': 'org.apache.cassandra.io.compress.LZ4Compressor'}
+              AND crc_check_chance = 1.0
+              AND dclocal_read_repair_chance = 0.1
               AND default_time_to_live = 0
-              AND speculative_retry = '99PERCENTILE'
-              AND min_index_interval = 128
+              AND gc_grace_seconds = 864000
               AND max_index_interval = 2048
-              AND crc_check_chance = 1.0;
+              AND memtable_flush_period_in_ms = 0
+              AND min_index_interval = 128
+              AND read_repair_chance = 0.0
+              AND speculative_retry = '99.0PERCENTILE';
             "
 
           end
@@ -332,9 +338,8 @@ module CassandraObject
         return ids if ids.empty?
         ids = ids.first if ids.is_a?(Array) && ids.one?
         sql = ids.is_a?(Array) ? "#{primary_key_column} IN (#{ids.map { |id| "'#{id}'" }.join(',')})" : "#{primary_key_column} = ?"
-        return sql
+        sql
       end
-
     end
   end
 end

data/lib/cassandra_object/attribute_methods.rb

@@ -5,9 +5,9 @@ module CassandraObject
 
     included do
       if ActiveModel::VERSION::STRING < '3.2'
-        attribute_method_suffix("", "=")
+        attribute_method_suffix('', '=')
       else
-        attribute_method_suffix("=")
+        attribute_method_suffix('=')
       end
 
       # (Alias for the protected read_attribute method).

data/lib/cassandra_object/persistence.rb

@@ -4,10 +4,10 @@ module CassandraObject
 
     included do
       class_attribute :batch_statements
+      attr_accessor :store_updated_at
     end
 
     module ClassMethods
-
       def ttl=(value)
         @ttl = value
       end

data/lib/cassandra_object/scope/finder_methods.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CassandraObject
   class Scope
     module FinderMethods
@@ -16,50 +18,60 @@ module CassandraObject
       end
 
       def find_in_batches(id, next_cursor = nil)
-        obj = self.clone
+        obj = clone
         obj.is_all = true
         obj.next_cursor = next_cursor
         obj.where_ids(id).execute_paged
       end
 
       def find_all_in_batches(next_cursor = nil)
-        obj = self.clone
+        obj = clone
         obj.is_all = true
         obj.next_cursor = next_cursor
         obj.execute
       end
 
       def first
-        return limit(1).find_all_in_batches[:results].first if self.schema_type == :dynamic_attributes || self.schema_type == :schemaless
+        return limit(1).find_all_in_batches[:results].first if schema_type == :dynamic_attributes || schema_type == :schemaless
         limit(1).execute.first
       end
 
       private
 
-      def find_one(id)
-        if id.blank?
-          not_found(id)
-        elsif self.schema_type == :dynamic_attributes
-          record = where_ids(id).execute
-          not_found(id) if record.empty?
-          record
-        elsif record = where_ids(id)[0]
-          record
-        else
-          not_found(id)
+        def find_one(id)
+          if id.blank?
+            not_found(id)
+          elsif schema_type == :dynamic_attributes
+            record = where_ids(id).execute
+            not_found(id) if record.empty?
+            record
+          elsif record = where_ids(id)[0]
+            record
+          else
+            not_found(id)
+          end
         end
-      end
 
-      def find_some(ids)
-        ids = ids.flatten
-        return [] if ids.empty?
-        ids = ids.compact.map(&:to_s).uniq
-        where_ids(ids).execute
-      end
+        def find_some(pids)
+          ids = pids.flatten.compact.uniq.map(&:to_s)
+          return [] if ids.empty?
 
-      def not_found(id)
-        raise CassandraObject::RecordNotFound, "Couldn't find #{self.name} with key #{id.inspect}"
-      end
+          qr = where_ids(ids).execute
+          is_dymnamic = qr.is_a?(Hash)
+
+          results = qr.sort_by do |r|
+            id = r.keys.first if r.is_a?(Hash)
+            id = r[0] if r.is_a?(Array)
+            id = r.id if id.nil?
+            ids.index(id)
+          end
+
+          is_dymnamic ? Hash[results] : results
+        end
+
+        def not_found(id)
+          raise CassandraObject::RecordNotFound, "Couldn't find #{name} with key #{id.inspect}"
+        end
     end
   end
 end

data/lib/cassandra_object/scoping.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module CassandraObject
   module Scoping
     extend ActiveSupport::Concern

data/lib/cassandra_object/timestamps.rb

@@ -15,7 +15,11 @@ module CassandraObject
 
       before_update if: :changed? do
         if self.class.timestamps
-          self.updated_at = Time.current
+          if store_updated_at.present?
+            self.updated_at = store_updated_at
+          else
+            self.updated_at = Time.current
+          end
         end
       end
     end

data/test/support/cassandra.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 Bundler.require :cassandra
 
 CassandraObject::Base.config = {
@@ -13,7 +15,7 @@ CassandraObject::Base.config = {
   connections_per_local_node: 4,
   schema_refresh_delay: 0.1,
   schema_refresh_timeout: 0.1,
-  load_balancing_policy: 'RoundRobin',
+  load_balancing_policy: Cassandra::LoadBalancing::Policies::RoundRobin.new,
   reconnection_policy: { policy: 'Constant', params: [5] },
   retry_policy: 'Default',
   # connections_per_remote_node: nil,
@@ -30,15 +32,12 @@ end
 sleep 1
 CassandraObject::Schema.create_keyspace 'cassandra_object_test'
 CassandraObject::Schemaless.create_column_family 'Issues'
-CassandraObject::Schema.create_column_family 'IssueSchemas', {attributes: 'id text, title text, description text, field float, intero int, created_at timestamp, updated_at timestamp, PRIMARY KEY (id)', options: {}}
-CassandraObject::Schema.create_column_family 'IssueSchemaCks', {attributes: 'id text, type text, date timestamp, value float, PRIMARY KEY (id, type, date)', options: {}}
+CassandraObject::Schema.create_column_family 'IssueSchemas', { attributes: 'id text, title text, description text, field float, intero int, created_at timestamp, updated_at timestamp, PRIMARY KEY (id)', options: {} }
+CassandraObject::Schema.create_column_family 'IssueSchemaCks', { attributes: 'id text, type text, date timestamp, value float, PRIMARY KEY (id, type, date)', options: {} }
 CassandraObject::Schemaless.create_column_family 'IssueDynamics'
 CassandraObject::Schemaless.create_column_family 'IssuesCustomConfig'
-CassandraObject::Schema.create_column_family 'IssueSchemaFathers', {attributes: 'id text, title text, field float, created_at timestamp, updated_at timestamp, PRIMARY KEY (id)', options: {}}
-CassandraObject::Schema.create_column_family 'IssueSchemaChildren', {attributes: 'id text, title text, description text, field float, created_at timestamp, updated_at timestamp, issue_schema_father_id text, PRIMARY KEY (id)', options: {}}
-CassandraObject::BaseSchemaless.adapter.consistency = :quorum
-CassandraObject::BaseSchemalessDynamic.adapter.consistency = :quorum
-CassandraObject::BaseSchema.adapter.consistency = :quorum
+CassandraObject::Schema.create_column_family 'IssueSchemaFathers', { attributes: 'id text, title text, field float, created_at timestamp, updated_at timestamp, PRIMARY KEY (id)', options: {} }
+CassandraObject::Schema.create_column_family 'IssueSchemaChildren', { attributes: 'id text, title text, description text, field float, created_at timestamp, updated_at timestamp, issue_schema_father_id text, PRIMARY KEY (id)', options: {} }
 
 CassandraObject::Base.class_eval do
   class_attribute :created_records
@@ -60,7 +59,6 @@ end
 
 module ActiveSupport
   class TestCase
-
     self.test_order = :random
 
     def after_setup

data/test/unit/connections/connections_test.rb

@@ -16,8 +16,6 @@ class CassandraObject::ConnectionsTest < CassandraObject::TestCase
     threads = []
 
     (0..10).collect do |i|
-
-      # puts "spawn thread #{i}"
       thr = Thread.new do
         begin
           IssueSchema.find(ids)

data/test/unit/persistence_schema_ck_test.rb

@@ -4,7 +4,6 @@
 require 'test_helper'
 
 class CassandraObject::PersistenceSchemaCkTest < CassandraObject::TestCase
-
   test 'composite key' do
     time1 = Time.now
     time2 = time1 + 1.second
@@ -25,19 +24,17 @@ class CassandraObject::PersistenceSchemaCkTest < CassandraObject::TestCase
     item = res[1]
     assert_equal '1', item.id
     assert_equal time2.to_i, item.date.to_i
-
   end
 
   test 'delete' do
     IssueSchemaCk.create(id: '1', type: 'first', date: Time.now, value: 1.to_f)
     IssueSchemaCk.create(id: '1', type: 'second', date: Time.now, value: 1.to_f)
-
     IssueSchemaCk.delete('1')
     assert_equal 0, IssueSchemaCk.find_by_id([1]).size
   end
 
   test 'delete with attributes' do
-    time = Time.now
+    time = Time.now - 10.days
     IssueSchemaCk.create(id: '1', type: 'first', date: time, value: 1.to_f)
     IssueSchemaCk.create(id: '1', type: 'first', date: Time.now, value: 1.to_f)
     IssueSchemaCk.create(id: '2', type: 'first', date: time, value: 1.to_f)
@@ -65,5 +62,4 @@ class CassandraObject::PersistenceSchemaCkTest < CassandraObject::TestCase
     IssueSchemaCk.find_by_id(['1']).first.destroy
     assert_equal 1, IssueSchemaCk.find_by_id([1]).size
   end
-
 end

data/test/unit/scope/finder_methods_test.rb

@@ -26,6 +26,38 @@ class CassandraObject::FinderMethodsTest < CassandraObject::TestCase
     assert_equal [first_issue, second_issue].to_set, Issue.find([first_issue.id, second_issue.id]).to_set
   end
 
+  test 'IssueDynamic: find with ids sorted' do
+    ids = (0..999).to_a.map(&:to_s)
+    ids.each do |i|
+      IssueDynamic.create(key: i, title: "foo_title_#{i}")
+    end
+    ids_to_find = ids.sample(10)
+    assert_equal ids_to_find, IssueDynamic.find(ids_to_find).keys
+    IssueDynamic.delete_all
+  end
+
+  test 'Issue: find with ids sorted' do
+    ids = (0..999).to_a.map(&:to_s)
+    ids.each do |i|
+      Issue.create(id: i, title: "foo_title_#{i}")
+    end
+    ids_to_find = ids.sample(10)
+    assert_equal ids_to_find, Issue.find(ids_to_find).map(&:id)
+    Issue.delete_all
+  end
+
+  test 'IssueSchemaCk: find with ids sorted' do
+    ids = (0..999).to_a.map(&:to_s)
+    ids.each do |i|
+      IssueSchemaCk.create(id: i, type: 'first', date: Date.yesterday.to_time, value: 1.0)
+      IssueSchemaCk.create(id: i, type: 'first', date: Date.today.to_time, value: 2.0)
+    end
+    ids_to_find = ids.sample(10)
+    assert_equal ids_to_find.size * 2, IssueSchemaCk.find(ids_to_find).size
+    assert_equal ids_to_find, IssueSchemaCk.find(ids_to_find).map(&:id).uniq
+    IssueSchemaCk.delete_all
+  end
+
   test 'find_by_id' do
     Issue.create.tap do |issue|
       assert_equal issue, Issue.find_by_id(issue.id)
@@ -64,9 +96,7 @@ class CassandraObject::FinderMethodsTest < CassandraObject::TestCase
     IssueDynamic.delete(['1', '2'])
   end
 
-
   test 'find all in batches dynamic paged' do
-
     issues = []
     100.times.each do |i|
       issues << IssueDynamic.create(key: i, title: 'tit', dynamic_field1: 'one', dynamic_field2: 'two')
@@ -135,5 +165,4 @@ class CassandraObject::FinderMethodsTest < CassandraObject::TestCase
   #   first_issue = IssueDynamic.create(key: '1', title: 'tit', dynamic_field1: 'one', dynamic_field2: 'two')
   #   f = IssueDynamic.first
   # end
-
 end

data/test/unit/scope/query_methods_test.rb

@@ -37,5 +37,4 @@ class CassandraObject::Scope::QueryMethodsTest < CassandraObject::TestCase
     foo_issue_columns =  Issue.columns.first
     assert_equal ['created_at', 'description', 'title', 'updated_at'], foo_issue_columns[foo_issue_columns.keys.first]
   end
-
 end

data/test/unit/timestamps_test.rb

@@ -21,7 +21,30 @@ class CassandraObject::TimestampsTest < CassandraObject::TestCase
   test 'created_at sets only if nil' do
     time = 5.days.ago
     issue = Issue.create created_at: time
-
     assert_equal time, issue.created_at
   end
+
+  test 'set updated_at to now when not passed as an attribute' do
+    udate = 1.year.ago
+    issue = Issue.create(description: 'foo', updated_at: udate)
+    assert_equal udate, issue.updated_at
+    issue.update_attributes(description: 'test')
+    assert_not_equal udate, issue.updated_at
+  end
+
+  test 'set updated_at to passed value' do
+    issue = Issue.create(description: 'foo')
+    updated_at = issue.updated_at
+    new_updated_at = updated_at + 5.days
+    issue.update_attributes(description: 'bar', store_updated_at: new_updated_at)
+    assert_equal new_updated_at, issue.updated_at
+  end
+
+  test 'set updated_at to passed value even if is equal to the stored value' do
+    udate = 1.year.ago
+    issue = Issue.create(description: 'foo', updated_at: udate)
+    assert_equal udate, issue.updated_at
+    issue.update_attributes(description: 'bar', store_updated_at: issue.updated_at)
+    assert_equal udate, issue.updated_at
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: extendi-cassandra_object
 version: !ruby/object:Gem::Version
-  version: 1.0.17
+  version: 1.1.1
 platform: ruby
 authors:
 - Duccio Giovannelli
@@ -9,22 +9,28 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-27 00:00:00.000000000 Z
+date: 2020-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "<="
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: 7.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "<="
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '5.2'
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: cassandra-driver
   requirement: !ruby/object:Gem::Requirement
@@ -198,8 +204,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.5
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Cassandra ActiveModel