gotime-cassandra_object 4.11.6 → 4.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9fcf2ed65ff6d08d1702f76e7836b583ba931efb
-  data.tar.gz: 92826ba8e10ab9bf7c5adcbd3b91e8aa4fa1b588
+  metadata.gz: 84be31ff7407fc7ec88e53d411ddbd7ab067fb27
+  data.tar.gz: b364e2178974653ae11328b7c3b352d24d262a2a
 SHA512:
-  metadata.gz: efcb74eb7565da59f852cabf98bbff6576522711baed4e7606bc176e7ff7274b77a07613cced49800566e79492b514a25eccaf1012c878db02637a8f1a6ebd50
-  data.tar.gz: 5719eb66e60d9b435869d774e6f39fa31db7a0650233626ffbcdf4899ec5c1dbef5f8cc394c6fc5f511251b2da2983ceb0aeb45e0ddeb78574acf399b11c6e84
+  metadata.gz: 3397a56b362a21c9a6a9e9480195fdc23334e4ff081f49ef19f84638239f3e562d2e6f81ccb9f1be7c04663f8ec53a298758b8dd44f84c79491d56732922d4b3
+  data.tar.gz: 123c09faf6d4e07fdd4354619dd8e49bfd97d6f58cf7684a950ffcdf5c474a8579d2ce35fb4abdb7c43d4d072ddfc6bfacf2ba6d62b5e0d7cb447f53830a3968

data/.travis.yml

@@ -2,7 +2,10 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
+  - 2.1.0
 env: CQLSH=/usr/local/cassandra/bin/cqlsh
 before_install:
-  - echo "127.0.0.1 "hostname | sudo tee /etc/hosts
-  - sudo service cassandra start
+  - wget http://archive.apache.org/dist/cassandra/1.2.9/apache-cassandra-1.2.9-bin.tar.gz
+  - tar xfz apache-cassandra-1.2.9-bin.tar.gz
+  - sh -c "echo 'JVM_OPTS=\"\${JVM_OPTS} -Xss256k -Djava.net.preferIPv4Stack=false\"' >> apache-cassandra-1.2.9/conf/cassandra-env.sh"
+  - cd apache-cassandra-1.2.9 && sudo ./bin/cassandra 2>&1 >> cassandra.log &

data/gotime-cassandra_object.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = 'gotime-cassandra_object'
-  s.version = '4.11.6'
+  s.version = '4.12.0'
   s.description = 'Cassandra ActiveModel'
   s.summary = 'Cassandra ActiveModel'
   s.authors = ["Michael Koziarski", "gotime"]

data/lib/cassandra_object/adapters/abstract_adapter.rb

@@ -6,18 +6,20 @@ module CassandraObject
         @config = config
       end
 
-      # === Options
-      # [:select]
-      #   Only select certain fields
-      # [:limit]
-      #   Limit the results
-      def select(ids, options ={}) # abstract
+      # Read records from a instance of CassandraObject::Scope
+      def select(scope) # abstract
       end
 
-      def write(id, attributes) # abstract
+      # Insert a new row
+      def insert(table, id, attributes) # abstract
       end
 
-      def delete(ids) # abstract
+      # Update an existing row
+      def update(table, id, attributes) # abstract
+      end
+
+      # Delete rows by an array of ids
+      def delete(table, ids) # abstract
       end
 
       def execute_batch(statements) # abstract

data/lib/cassandra_object/adapters/cassandra_adapter.rb

@@ -1,28 +1,6 @@
 module CassandraObject
   module Adapters
     class CassandraAdapter < AbstractAdapter
-      def cql
-        @cql ||= CassandraCQL::Database.new(config.servers, {keyspace: config.keyspace}, config.thrift_options)
-      end
-
-      def execute(statement)
-        ActiveSupport::Notifications.instrument("cql.cassandra_object", cql: statement) do
-          cql.execute statement
-        end
-      end
-
-      def select(statement)
-        execute(statement).fetch do |cql_row|
-          attributes = cql_row.to_hash
-          key = attributes.delete(primary_key_column)
-          yield(key, attributes) unless attributes.empty?
-        end
-      end
-
-      def build_query(scope)
-        QueryBuilder.new(self, scope).to_query
-      end
-
       class QueryBuilder
         def initialize(adapter, scope)
           @adapter  = adapter
@@ -47,41 +25,13 @@ module CassandraObject
         end
 
         def where_string
-          if @scope.where_values.any?
-            wheres = []
-
-            @scope.where_values.map do |where_value|
-              wheres.concat format_where_statement(where_value)
-            end
-
-            "WHERE #{wheres * ' AND '}"
-          else
-            ''
-          end
-        end
-
-        def format_where_statement(where_value)
-          if where_value.is_a?(String)
-            [where_value]
-          elsif where_value.is_a?(Hash)
-            where_value.map do |column, value|
-              if value.is_a?(Array)
-                "#{column} IN (#{escape_where_value(value)})"
-              else
-                "#{column} = #{escape_where_value(value)}"
-              end
-            end
+          wheres = @scope.where_values.dup
+          if @scope.id_values.any?
+            wheres << @adapter.create_ids_where_clause(@scope.id_values)
           end
-        end
 
-        def escape_where_value(value)
-          if value.is_a?(Array)
-            value.map { |v| escape_where_value(v) }.join(",")
-          elsif value.is_a?(String)
-            value = value.gsub("'", "''")
-            "'#{value}'"
-          else
-            value
+          if wheres.any?
+            "WHERE #{wheres * ' AND '}"
           end
         end
 
@@ -94,6 +44,38 @@ module CassandraObject
         end
       end
 
+      def primary_key_column
+        'KEY'
+      end
+
+      def connection
+        @connection ||= CassandraCQL::Database.new(config.servers, {keyspace: config.keyspace}, config.thrift_options)
+      end
+
+      def execute(statement)
+        ActiveSupport::Notifications.instrument("cql.cassandra_object", cql: statement) do
+          connection.execute statement
+        end
+      end
+
+      def select(scope)
+        statement = QueryBuilder.new(self, scope).to_query
+
+        execute(statement).fetch do |cql_row|
+          attributes = cql_row.to_hash
+          key = attributes.delete(primary_key_column)
+          yield(key, attributes) unless attributes.empty?
+        end
+      end
+
+      def insert(table, id, attributes)
+        write(table, id, attributes)
+      end
+
+      def update(table, id, attributes)
+        write(table, id, attributes)
+      end
+
       def write(table, id, attributes)
         if (not_nil_attributes = attributes.reject { |key, value| value.nil? }).any?
           insert_attributes = {primary_key_column => id}.update(not_nil_attributes)
@@ -107,10 +89,9 @@ module CassandraObject
       end
 
       def delete(table, ids)
-        statement = "DELETE FROM #{table}#{write_option_string} WHERE "
-        statement += ids.is_a?(Array) ? "#{primary_key_column} IN (?)" : "#{primary_key_column} = ?"
+        statement = "DELETE FROM #{table}#{write_option_string} WHERE #{create_ids_where_clause(ids)}"
 
-        execute_batchable sanitize(statement, ids)
+        execute_batchable statement
       end
 
       def execute_batch(statements)
@@ -133,16 +114,18 @@ module CassandraObject
         @consistency = val
       end
 
-      def primary_key_column
-        'KEY'
-      end
-
       def write_option_string(ignore_batching = false)
         if (ignore_batching || !batching?) && consistency
           " USING CONSISTENCY #{consistency}"
         end
       end
 
+      def create_ids_where_clause(ids)
+        ids = ids.first if ids.is_a?(Array) && ids.one?
+        sql = ids.is_a?(Array) ? "#{primary_key_column} IN (?)" : "#{primary_key_column} = ?"
+        sanitize(sql, ids)
+      end
+
       private
 
         def sanitize(statement, *bind_vars)

data/lib/cassandra_object/adapters/dynamo_adapter.rb

@@ -1,6 +1,59 @@
 module CassandraObject
-  module ConnectionAdapters
-    class Adapter < AbstractAdapter
+  module Adapters
+    class DynamoAdapter < AbstractAdapter
+      def primary_key_column
+        'id'
+      end
+
+      def connection
+        # self.namespace = spec[:namespace]
+        @connection ||= AWS::DynamoDB.new(
+          access_key_id: spec[:access_key_id],
+          secret_access_key: spec[:secret_access_key]
+        )
+      end
+
+      def select(scope)
+        dynamo_table.items[key_string].attributes.to_h
+        dynamo_table.batch_get(:all, keys.map(&:to_s))
+      end
+
+      def insert(table, id, attributes)
+        attributes = {primary_key => id}.update(attributes)
+        self.class.dynamo_table.items.create(attributes)
+      end
+
+      def update(table, id, attributes)
+        dynamo_db_item = self.class.dynamo_table.items[id]
+
+        dynamo_db_item.attributes.update do |u|
+          attributes.each do |attr, value|
+            if value.nil?
+              u.delete(attr)
+            else
+              u.set(attr => value)
+            end
+          end
+        end
+      end
+
+      def delete(table, ids)
+        ids.each do |id|
+          dynamo_table.items[id].delete
+        end
+      end
+
+      def dynamo_table_name
+        "#{namespace}.#{column_family.underscore}"
+      end
+
+      def dynamo_table
+        @dynamo_table ||= begin
+          table = connection.tables[dynamo_table_name]
+          table.hash_key = [:id, :number]
+          table
+        end
+      end
     end
   end
 end

data/lib/cassandra_object/adapters/hstore_adapter.rb

@@ -1,6 +1,147 @@
 module CassandraObject
-  module ConnectionAdapters
-    class Adapter < AbstractAdapter
+  module Adapters
+    class HstoreAdapter < AbstractAdapter
+      class QueryBuilder
+        def initialize(adapter, scope)
+          @adapter  = adapter
+          @scope    = scope
+        end
+
+        def to_query
+          [
+            "SELECT #{select_string} FROM #{@scope.klass.column_family}",
+            where_string,
+            order_string,
+            limit_string,
+          ].delete_if(&:blank?) * ' '
+        end
+
+        def select_string
+          if @scope.select_values.any?
+            "id, slice(attribute_store, #{@adapter.fields_to_postgres_array(@scope.select_values)}) as attribute_store"
+          else
+            '*'
+          end
+        end
+
+        def where_string
+          wheres = @scope.where_values.dup
+          if @scope.id_values.any?
+            wheres << @adapter.create_ids_where_clause(@scope.id_values)
+          end
+
+          if wheres.any?
+            "WHERE #{wheres * ' AND '}"
+          end
+        end
+
+        def order_string
+          if @scope.id_values.many?
+            id_orders = @scope.id_values.map { |id| "ID=#{@adapter.quote(id)} DESC" }.join(',')
+            "ORDER BY #{id_orders}"
+          end
+        end
+
+        def limit_string
+          if @scope.limit_value
+            "LIMIT #{@scope.limit_value}"
+          end
+        end
+      end
+
+      def primary_key_column
+        'id'
+      end
+
+      def connection
+        conf = {:adapter=>"postgresql", :encoding=>"unicode", :database=>"axle_place_test", :pool=>5, :username=>"postgres"}
+        @connection ||= ActiveRecord::Base.postgresql_connection(conf)
+        # @connection ||= ActiveRecord::Base.postgresql_connection(config)
+      end
+
+      def execute(statement)
+        ActiveSupport::Notifications.instrument("cql.cassandra_object", cql: statement) do
+          connection.exec_query statement
+        end
+      end
+
+      def select(scope)
+        statement = QueryBuilder.new(self, scope).to_query
+
+        connection.execute(statement).each do |attributes|
+          yield attributes[primary_key_column], hstore_to_attributes(attributes['attribute_store'])
+        end
+      end
+
+      def insert(table, id, attributes)
+        not_nil_attributes = attributes.reject { |key, value| value.nil? }
+        statement = "INSERT INTO #{table} (#{primary_key_column}, attribute_store) VALUES (#{quote(id)}, #{attributes_to_hstore(not_nil_attributes)})"
+        execute_batchable statement
+      end
+
+      def update(table, id, attributes)
+        return if attributes.empty?
+
+        not_nil_attributes = attributes.reject { |key, value| value.nil? }
+        nil_attributes = attributes.select { |key, value| value.nil? }
+
+        if not_nil_attributes.any? && nil_attributes.any?
+          value_update = "(attribute_store - #{fields_to_postgres_array(nil_attributes.keys)}) || #{attributes_to_hstore(not_nil_attributes)}"
+        elsif not_nil_attributes.any?
+          value_update = "attribute_store || #{attributes_to_hstore(not_nil_attributes)}"
+        elsif nil_attributes.any?
+          value_update = "attribute_store - #{fields_to_postgres_array(nil_attributes.keys)}"
+        end
+
+        statement = "UPDATE #{table} SET attribute_store = #{value_update} WHERE #{primary_key_column} = #{quote(id)}"
+        execute_batchable statement
+      end
+
+      def delete(table, ids)
+        statement = "DELETE FROM #{table} WHERE #{create_ids_where_clause(ids)}"
+
+        execute_batchable statement
+      end
+
+      def execute_batch(statements)
+        stmt = [
+          "BEGIN",
+          statements * ";\n",
+          'COMMIT'
+        ] * ";\n"
+
+        execute stmt
+      end
+
+      def create_ids_where_clause(ids)
+        ids = ids.first if ids.is_a?(Array) && ids.one?
+
+        if ids.is_a?(Array)
+          id_list = ids.map { |id| quote(id) }.join(',')
+          "#{primary_key_column} IN (#{id_list})"
+        else
+          "#{primary_key_column} = #{quote(ids)}"
+        end
+      end
+
+      def quote(value)
+        connection.quote(value)
+      end
+
+      def fields_to_postgres_array(fields)
+        quoted_fields = fields.map { |field| "'#{field}'" }.join(',')
+        "ARRAY[#{quoted_fields}]"
+      end
+
+      private
+
+        def attributes_to_hstore(attributes)
+          quote ActiveRecord::ConnectionAdapters::PostgreSQLColumn.hstore_to_string(attributes)
+        end
+
+        def hstore_to_attributes(string)
+          ActiveRecord::ConnectionAdapters::PostgreSQLColumn.string_to_hstore(string)
+        end
     end
   end
 end

data/lib/cassandra_object/callbacks.rb

@@ -14,7 +14,7 @@ module CassandraObject
     end
 
     private
-      def write #:nodoc:
+      def write(*args) #:nodoc:
         run_callbacks(:save) { super }
       end
 

data/lib/cassandra_object/connection.rb

@@ -20,20 +20,9 @@ module CassandraObject
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def cql
-        @@cql ||= CassandraCQL::Database.new(config.servers, {keyspace: config.keyspace}, config.thrift_options)
-      end
-
       def adapter
         @@adapter ||= CassandraObject::Adapters::CassandraAdapter.new(config)
-      end
-
-      def execute_cql(cql_string, *bind_vars)
-        statement = CassandraCQL::Statement.sanitize(cql_string, bind_vars).force_encoding(Encoding::UTF_8)
-
-        ActiveSupport::Notifications.instrument("cql.cassandra_object", cql: statement) do
-          cql.execute statement
-        end
+        # @@adapter ||= CassandraObject::Adapters::HstoreAdapter.new(config)
       end
     end
   end

data/lib/cassandra_object/counter_base.rb

@@ -30,6 +30,18 @@ module CassandraObject
         execute_cql "UPDATE #{column_family} SET #{counter_updates(counter, count)} WHERE KEY = '#{group}'"
       end
 
+      def cql
+        @@cql ||= CassandraCQL::Database.new(config.servers, {keyspace: config.keyspace}, config.thrift_options)
+      end
+
+      def execute_cql(cql_string, *bind_vars)
+        statement = CassandraCQL::Statement.sanitize(cql_string, bind_vars).force_encoding(Encoding::UTF_8)
+
+        ActiveSupport::Notifications.instrument("cql.cassandra_object", cql: statement) do
+          cql.execute statement
+        end
+      end
+
       private
 
       def counter_updates(counter, count=nil)
@@ -68,6 +80,5 @@ module CassandraObject
     include Identity
     include Inspect
     extend  Model
-
   end
 end

data/lib/cassandra_object/persistence.rb

@@ -21,8 +21,12 @@ module CassandraObject
         end
       end
 
-      def write(id, attributes)
-        adapter.write column_family, id, encode_attributes(attributes)
+      def insert_record(id, attributes)
+        adapter.insert column_family, id, encode_attributes(attributes)
+      end
+
+      def update_record(id, attributes)
+        adapter.update column_family, id, encode_attributes(attributes)
       end
 
       def batching?
@@ -131,18 +135,19 @@ module CassandraObject
     end
 
     private
-      def update
-        write
-      end
 
       def create
         @new_record = false
-        write
+        write :insert_record
+      end
+
+      def update
+        write :update_record
       end
 
-      def write
+      def write(method)
         changed_attributes = Hash[changed.map { |attr| [attr, read_attribute(attr)] }]
-        self.class.write(id, changed_attributes)
+        self.class.send(method, id, changed_attributes)
       end
   end
 end

data/lib/cassandra_object/railtie.rb

@@ -4,6 +4,25 @@ module CassandraObject
       load 'cassandra_object/tasks/ks.rake'
     end
 
+    initializer "cassandra_object.log_runtime" do |app|
+      ActiveSupport.on_load :cassandra_object do
+        pathname = Rails.root.join('config', 'cassandra.yml')
+        if pathname.exist?
+          config = YAML.load(pathname.read)
+
+          if config = config[Rails.env]
+            self.config = {
+              keyspace: config['keyspace'],
+              servers: config['servers'],
+              thrift: config['thrift']
+            }
+          else
+            raise "Missing environment #{Rails.env} in cassandra.yml"
+          end
+        end
+      end
+    end
+
     # Expose database runtime to controller for logging.
     initializer "cassandra_object.log_runtime" do |app|
       require "cassandra_object/railties/controller_runtime"

data/lib/cassandra_object/schema/tasks.rb

@@ -17,7 +17,7 @@ module CassandraObject
           current_cql << line.rstrip
 
           if current_cql =~ /;$/
-            CassandraObject::Base.execute_cql current_cql
+            keyspace_execute current_cql
             current_cql = ''
           end
         end

data/lib/cassandra_object/scope.rb

@@ -7,14 +7,15 @@ module CassandraObject
     include Batches, FinderMethods, QueryMethods
 
     attr_accessor :klass
-    attr_accessor :limit_value, :select_values, :where_values
+    attr_accessor :limit_value, :select_values, :where_values, :id_values
 
     def initialize(klass)
       @klass = klass
 
-      @limit_value = nil
-      @select_values = []
-      @where_values = []
+      @limit_value    = nil
+      @select_values  = []
+      @where_values   = []
+      @id_values      = []
     end
 
     private
@@ -36,9 +37,9 @@ module CassandraObject
         end
       end
 
-      def instantiate_from_cql(cql_string)
+      def select_records
         results = []
-        klass.adapter.select(cql_string) do |key, attributes|
+        klass.adapter.select(self) do |key, attributes|
           results << klass.instantiate(key, attributes)
         end
         results.compact!

data/lib/cassandra_object/scope/finder_methods.rb

@@ -28,7 +28,7 @@ module CassandraObject
         def find_one(id)
           if id.blank?
             raise CassandraObject::RecordNotFound, "Couldn't find #{self.name} with key #{id.inspect}"
-          elsif record = where(adapter.primary_key_column => id).first
+          elsif record = where_ids(id).first
             record
           else
             raise CassandraObject::RecordNotFound
@@ -41,7 +41,7 @@ module CassandraObject
 
           ids = ids.compact.map(&:to_s).uniq
 
-          where(adapter.primary_key_column => ids).to_a
+          where_ids(ids).to_a
         end
     end
   end

data/lib/cassandra_object/scope/query_methods.rb

@@ -23,6 +23,15 @@ module CassandraObject
         clone.where! values
       end
 
+      def where_ids!(*ids)
+        self.id_values += ids.flatten
+        self
+      end
+
+      def where_ids(*ids)
+        clone.where_ids! ids
+      end
+
       def limit!(value)
         self.limit_value = value
         self
@@ -32,12 +41,8 @@ module CassandraObject
         clone.limit! value
       end
 
-      def to_cql
-        adapter.build_query(self)
-      end
-
       def to_a
-        instantiate_from_cql(adapter.build_query(self))
+        select_records
       end
     end
   end

data/lib/cassandra_object/scoping.rb

@@ -6,7 +6,7 @@ module CassandraObject
       singleton_class.class_eval do
         delegate :find, :find_by_id, :first, :all, to: :scope
         delegate :find_each, :find_in_batches, to: :scope
-        delegate :select, :where, to: :scope
+        delegate :select, :where, :where_ids, to: :scope
       end
     end
 

data/test/support/issue.rb

@@ -4,6 +4,6 @@ class Issue < CassandraObject::Base
   before_create { self.description ||= 'funny' }
 
   def self.for_key key
-    where('KEY' => key)
+    where_ids(key)
   end
 end

data/test/unit/log_subscriber_test.rb

@@ -12,7 +12,7 @@ class CassandraObject::LogSubscriberTest < CassandraObject::TestCase
   end
 
   def test_cql_notification
-    Issue.execute_cql "SELECT * FROM Issues"
+    Issue.adapter.execute "SELECT * FROM Issues"
 
     wait
 

data/test/unit/schema/tasks_test.rb

@@ -15,8 +15,8 @@ class CassandraObject::Schema::TasksTest < CassandraObject::TestCase
   end
 
   test "load" do
-    CassandraObject::Base.expects(:execute_cql).with("DO STUFF;")
-    CassandraObject::Base.expects(:execute_cql).with("AND MORE;")
+    CassandraObject::Schema.expects(:keyspace_execute).with("DO STUFF;")
+    CassandraObject::Schema.expects(:keyspace_execute).with("AND MORE;")
 
     CassandraObject::Schema.load StringIO.new(
       "DO\n" +

data/test/unit/scope/query_methods_test.rb

@@ -27,6 +27,7 @@ class CassandraObject::Scope::QueryMethodsTest < CassandraObject::TestCase
   test "chaining where with scope" do
     issue = Issue.create title: 'abc', description: 'def'
     query = Issue.select(:title).for_key(issue.id)
-    assert_match /^SELECT KEY,title/, query.to_cql
+
+    assert_equal [:title], query.select_values
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gotime-cassandra_object
 version: !ruby/object:Gem::Version
-  version: 4.11.6
+  version: 4.12.0
 platform: ruby
 authors:
 - Michael Koziarski
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-06 00:00:00.000000000 Z
+date: 2014-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel