extendi-cassandra_object 1.0.0

data/lib/cassandra_object/railtie.rb

@@ -0,0 +1,33 @@
+module CassandraObject
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      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'],
+              hosts: config['hosts'],
+            }
+          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"
+      ActiveSupport.on_load(:action_controller) do
+        include CassandraObject::Railties::ControllerRuntime
+      end
+    end
+  end
+end

data/lib/cassandra_object/railties/controller_runtime.rb

@@ -0,0 +1,45 @@
+require 'active_support/core_ext/module/attr_internal'
+require 'cassandra_object/log_subscriber'
+
+module CassandraObject
+  module Railties # :nodoc:
+    module ControllerRuntime #:nodoc:
+      extend ActiveSupport::Concern
+
+      module ClassMethods # :nodoc:
+        def log_process_action(payload)
+          messages, cassandra_object_runtime = super, payload[:cassandra_object_runtime]
+          if cassandra_object_runtime.to_i > 0
+            messages << ("CassandraObject: %.1fms" % cassandra_object_runtime.to_f)
+          end
+          messages
+        end
+      end
+
+      #private
+
+        attr_internal :cassandra_object_runtime
+
+        def process_action(action, *args)
+          # We also need to reset the runtime before each action
+          # because of queries in middleware or in cases we are streaming
+          # and it won't be cleaned up by the method below.
+          CassandraObject::LogSubscriber.reset_runtime
+          super
+        end
+
+        def cleanup_view_runtime
+          runtime_before_render = CassandraObject::LogSubscriber.reset_runtime
+          runtime = super
+          runtime_after_render = CassandraObject::LogSubscriber.reset_runtime
+          self.cassandra_object_runtime = runtime_before_render + runtime_after_render
+          runtime - runtime_after_render
+        end
+
+        def append_info_to_payload(payload)
+          super
+          payload[:cassandra_object_runtime] = (cassandra_object_runtime || 0) + CassandraObject::LogSubscriber.reset_runtime
+        end
+    end
+  end
+end

data/lib/cassandra_object/schema.rb

@@ -0,0 +1,83 @@
+require 'cassandra'
+
+module CassandraObject
+  class Schema
+
+    class << self
+      DEFAULT_CREATE_KEYSPACE = {
+        'strategy_class' => 'SimpleStrategy',
+        'strategy_options' => 'replication_factor:1'
+      }
+
+      def create_keyspace(keyspace, options = nil)
+        stmt = "CREATE KEYSPACE #{keyspace} WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };"
+
+        options ||= {} #DEFAULT_CREATE_KEYSPACE
+
+        system_execute stmt #adapter.statement_with_options(stmt, options)
+      end
+
+      def drop_keyspace(keyspace, confirm = false)
+        if adapter.cassandra_version < 3
+          count = (system_execute "SELECT count(*) FROM schema_columnfamilies where keyspace_name = '#{keyspace}' ALLOW FILTERING;").rows.first['count']
+        else
+          count = (system_schema_execute "SELECT count(*) FROM tables where keyspace_name = '#{keyspace}';").rows.first['count']
+        end
+        if confirm || count == 0
+          system_execute "DROP KEYSPACE #{keyspace}"
+        else
+          raise "Cannot drop keyspace #{keyspace}. You must delete all tables before"
+        end
+      end
+
+      def create_column_family(column_family, options = {})
+        create_table column_family, options
+      end
+
+      def create_table(table_name, options = {})
+        adapter.create_table table_name, options
+      end
+
+      def alter_column_family(column_family, instruction, options = {})
+        stmt = "ALTER TABLE #{column_family} #{instruction}"
+        keyspace_execute adapter.statement_with_options(stmt, options)
+      end
+
+      def drop_column_family(column_family)
+        drop_table column_family
+      end
+
+      def drop_table(table_name, confirm = false)
+        adapter.drop_table table_name, confirm
+      end
+
+      def add_index(column_family, column, index_name = nil)
+        stmt = "CREATE INDEX #{index_name.nil? ? '' : index_name} ON #{column_family} (#{column})"
+        keyspace_execute stmt
+      end
+
+      # If the index was not given a name during creation, the index name is <columnfamily_name>_<column_name>_idx.
+      def drop_index(index_name)
+        keyspace_execute "DROP INDEX #{index_name}"
+      end
+
+      private
+
+        def adapter
+          @adapter ||= CassandraObject::Adapters::CassandraAdapter.new(CassandraObject::Base.config)
+        end
+
+        def keyspace_execute(cql)
+          adapter.schema_execute cql, CassandraObject::Base.config[:keyspace]
+        end
+
+        def system_schema_execute(cql)
+          adapter.schema_execute cql, 'system_schema'
+        end
+
+        def system_execute(cql)
+          adapter.schema_execute cql, 'system'
+        end
+    end
+  end
+end

data/lib/cassandra_object/schemaless.rb

@@ -0,0 +1,83 @@
+require 'cassandra'
+
+module CassandraObject
+  class Schemaless
+
+    class << self
+      DEFAULT_CREATE_KEYSPACE = {
+        'strategy_class' => 'SimpleStrategy',
+        'strategy_options' => 'replication_factor:1'
+      }
+
+      def create_keyspace(keyspace, options = nil)
+        stmt = "CREATE KEYSPACE #{keyspace} WITH REPLICATION = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 };"
+
+        options ||= {} #DEFAULT_CREATE_KEYSPACE
+
+        system_execute stmt #adapter.statement_with_options(stmt, options)
+      end
+
+      def drop_keyspace(keyspace, confirm = false)
+        if adapter.cassandra_version < 3
+          count = (system_execute "SELECT count(*) FROM schema_columnfamilies where keyspace_name = '#{keyspace}' ALLOW FILTERING;").rows.first['count']
+        else
+          count = (system_schema_execute "SELECT count(*) FROM tables where keyspace_name = '#{keyspace}';").rows.first['count']
+        end
+        if confirm || count == 0
+          system_execute "DROP KEYSPACE #{keyspace}"
+        else
+          raise "Cannot drop keyspace #{keyspace}. You must delete all tables before"
+        end
+      end
+
+      def create_column_family(column_family, options = {})
+        create_table column_family, options
+      end
+
+      def create_table(table_name, options = {})
+        adapter.create_table table_name, options
+      end
+
+      def alter_column_family(column_family, instruction, options = {})
+        stmt = "ALTER TABLE #{column_family} #{instruction}"
+        keyspace_execute adapter.statement_with_options(stmt, options)
+      end
+
+      def drop_column_family(column_family)
+        drop_table column_family
+      end
+
+      def drop_table(table_name, confirm = false)
+        adapter.drop_table table_name, confirm
+      end
+
+      def add_index(column_family, column, index_name = nil)
+        stmt = "CREATE INDEX #{index_name.nil? ? '' : index_name} ON #{column_family} (#{column})"
+        keyspace_execute stmt
+      end
+
+      # If the index was not given a name during creation, the index name is <columnfamily_name>_<column_name>_idx.
+      def drop_index(index_name)
+        keyspace_execute "DROP INDEX #{index_name}"
+      end
+
+      private
+
+        def adapter
+          @adapter ||= CassandraObject::Adapters::CassandraSchemalessAdapter.new(CassandraObject::Base.config)
+        end
+
+        def keyspace_execute(cql)
+          adapter.schema_execute cql, CassandraObject::Base.config[:keyspace]
+        end
+
+        def system_schema_execute(cql)
+          adapter.schema_execute cql, 'system_schema'
+        end
+
+        def system_execute(cql)
+          adapter.schema_execute cql, 'system'
+        end
+    end
+  end
+end

data/lib/cassandra_object/scope.rb

@@ -0,0 +1,86 @@
+require 'cassandra_object/scope/finder_methods'
+require 'cassandra_object/scope/query_methods'
+
+module CassandraObject
+  class Scope
+    include FinderMethods, QueryMethods
+
+    attr_accessor :klass
+    attr_accessor :is_all, :limit_value, :select_values, :where_values, :id_values, :raw_response, :next_cursor
+
+    def initialize(klass)
+      @klass = klass
+
+      @is_all = false
+      @limit_value = nil
+      @raw_response = nil
+      @select_values = []
+      @id_values = []
+      @where_values = []
+      @next_cursor = nil
+    end
+
+    private
+
+    def scoping
+      previous, klass.current_scope = klass.current_scope, self
+      yield
+    ensure
+      klass.current_scope = previous
+    end
+
+
+    def method_missing(method_name, *args, &block)
+      if klass.respond_to?(method_name)
+        scoping { klass.send(method_name, *args, &block) }
+      elsif Array.method_defined?(method_name)
+        to_a.send(method_name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def select_records
+      results = []
+      records = {}
+      new_next_cursor = nil
+
+      if self.schema_type == :standard
+        klass.adapter.select(self) do |key, attributes|
+          records[key] = attributes
+        end
+      else
+        if @is_all
+          pre = klass.adapter.pre_select(self, @limit_value, @next_cursor)
+          new_next_cursor = pre[:new_next_cursor]
+          return {results: [], next_cursor: new_next_cursor} if pre[:ids].empty? # fix last query all if ids is empty
+          self.id_values = pre[:ids]
+        end
+
+        resp = klass.adapter.select(self)
+        primary_key_column = klass.adapter.primary_key_column
+        resp.each do |cql_row|
+          key = cql_row[primary_key_column]
+          records[key] ||= {}
+          records[key][cql_row.values[1]] = cql_row.values[2]
+        end
+
+      end
+      # limit
+      records = records.first(@limit_value) if @limit_value.present?
+      records.each do |key, attributes|
+        if self.raw_response || self.schema_type == :dynamic_attributes
+          results << {key => attributes.values.compact.empty? ? attributes.keys : attributes}
+        else
+          results << klass.instantiate(key, attributes)
+        end
+      end
+      results = results.reduce({}, :merge) if self.schema_type == :dynamic_attributes
+      if @is_all
+        return {results: results, next_cursor: new_next_cursor}
+      end
+      return results
+    end
+
+  end
+end

data/lib/cassandra_object/scope/finder_methods.rb

@@ -0,0 +1,54 @@
+module CassandraObject
+  class Scope
+    module FinderMethods
+      def find(ids)
+        if ids.is_a?(Array)
+          find_some(ids)
+        else
+          find_one(ids)
+        end
+      end
+
+      def find_by_id(ids)
+        find(ids)
+      rescue CassandraObject::RecordNotFound
+        nil
+      end
+
+      def find_all_in_batches(next_cursor = nil)
+        obj = self.clone
+        obj.is_all = true
+        obj.next_cursor = next_cursor
+        obj.to_a
+      end
+
+      def first
+        return limit(1).find_all_in_batches[:results].first if self.schema_type == :dynamic_attributes || self.schema_type == :schemaless
+        limit(1).to_a.first
+      end
+
+      private
+
+      def find_one(id)
+        if id.blank?
+          raise CassandraObject::RecordNotFound, "Couldn't find #{self.name} with key #{id.inspect}"
+        elsif self.schema_type == :dynamic_attributes
+          record = where_ids(id).to_a
+          raise CassandraObject::RecordNotFound if record.empty?
+          record
+        elsif record = where_ids(id)[0]
+          record
+        else
+          raise CassandraObject::RecordNotFound
+        end
+      end
+
+      def find_some(ids)
+        ids = ids.flatten
+        return [] if ids.empty?
+        ids = ids.compact.map(&:to_s).uniq
+        where_ids(ids).to_a
+      end
+    end
+  end
+end

data/lib/cassandra_object/scope/query_methods.rb

@@ -0,0 +1,69 @@
+module CassandraObject
+  class Scope
+    module QueryMethods
+
+      def cql_response
+        cloned = self.clone
+        cloned.raw_response = true
+        cloned
+      end
+
+      def columns
+        cloned = self.clone
+        cloned.select_values = [:column1]
+        cloned.cql_response
+      end
+
+      def select!(*values)
+        self.select_values += values.flatten
+        self
+      end
+
+      def select(*values, &block)
+        if block_given?
+          to_a.select(&block)
+        else
+          clone.select!(*values)
+        end
+      end
+
+      def where!(*values)
+        if values.flatten.size == 1
+          self.where_values += values.flatten
+          self.where_values << ''
+        else
+          self.where_values += values.flatten
+        end
+        self
+      end
+
+      def where(*values)
+        clone.where! values
+      end
+
+      def where_ids!(*ids)
+        self.id_values += ids.flatten
+        self.id_values.compact if self.id_values.present?
+        self
+      end
+
+      def where_ids(*ids)
+        clone.where_ids! ids
+      end
+
+      def limit!(value)
+        self.limit_value = value
+        self
+      end
+
+      def limit(value)
+        clone.limit! value
+      end
+
+      def to_a
+        select_records
+      end
+
+    end
+  end
+end