cassandra_object_rails 0.0.1

data/lib/cassandra_object/scope.rb

@@ -0,0 +1,48 @@
+require 'cassandra_object/scope/batches'
+require 'cassandra_object/scope/finder_methods'
+require 'cassandra_object/scope/query_methods'
+
+module CassandraObject
+  class Scope
+    include Batches, FinderMethods, QueryMethods
+
+    attr_accessor :klass
+    attr_accessor :limit_value, :select_values, :where_values
+
+    def initialize(klass)
+      @klass = klass
+
+      @limit_value = nil
+      @select_values = []
+      @where_values = []
+    end
+
+    private
+      def method_missing(method_name, *args, &block)
+        if klass.respond_to?(method_name)
+          klass.send(method_name, *args, &block)
+        elsif Array.method_defined?(method_name)
+          to_a.send(method_name, *args, &block)
+        else
+          super
+        end
+      end
+
+      def instantiate_from_cql(cql_string, *args)
+        results = []
+        klass.execute_cql(cql_string, *args).fetch do |cql_row|
+          results << instantiate_cql_row(cql_row)
+        end
+        results.compact!
+        results
+      end
+
+      def instantiate_cql_row(cql_row)
+        attributes = cql_row.to_hash
+        key = attributes.delete('KEY')
+        if attributes.any?
+          klass.instantiate(key, attributes)
+        end
+      end
+  end
+end

data/lib/cassandra_object/scope/batches.rb

@@ -0,0 +1,32 @@
+module CassandraObject
+  class Scope
+    module Batches
+      def find_each(options = {})
+        find_in_batches(options) do |records|
+          records.each { |record| yield record }
+        end
+      end
+
+      def find_in_batches(options = {})
+        batch_size = options.delete(:batch_size) || 1000
+        start_key = nil
+
+        scope = limit(batch_size + 1)
+        records = scope.to_a
+
+        while records.any?
+          if records.size > batch_size
+            next_record = records.pop
+          else
+             next_record = nil
+          end
+
+          yield records
+          break if next_record.nil?
+
+          records = scope.where("KEY >= '#{next_record.id}'").to_a
+        end
+      end
+    end
+  end
+end

data/lib/cassandra_object/scope/finder_methods.rb

@@ -0,0 +1,47 @@
+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 all
+        to_a
+      end
+
+      def first
+        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 record = where('KEY' => id).first
+            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("KEY" => ids).to_a
+        end
+    end
+  end
+end

data/lib/cassandra_object/scope/query_methods.rb

@@ -0,0 +1,111 @@
+module CassandraObject
+  class Scope
+    module QueryMethods
+      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)
+        self.where_values += values.flatten
+        self
+      end
+
+      def where(*values)
+        clone.where! values
+      end
+
+      def limit!(value)
+        self.limit_value = value
+        self
+      end
+
+      def limit(value)
+        clone.limit! value
+      end
+
+      def to_cql
+        [
+            "SELECT #{select_string} FROM #{klass.column_family}",
+            consistency_string,
+            where_string,
+            limit_string
+        ].delete_if(&:blank?) * ' '
+      end
+
+      def to_a
+        instantiate_from_cql(to_cql)
+      end
+
+      private
+        def select_string
+          if select_values.any?
+            (['KEY'] | select_values) * ','
+          else
+            '*'
+          end
+        end
+
+        def where_string
+          if where_values.any?
+            wheres = []
+
+            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
+          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
+          end
+        end
+
+        def limit_string
+          if limit_value
+            "LIMIT #{limit_value}"
+          else
+            ""
+          end
+        end
+
+        def consistency_string
+          if klass.default_consistency
+            "USING CONSISTENCY #{klass.default_consistency}"
+          end
+        end
+    end
+  end
+end

data/lib/cassandra_object/scoping.rb

@@ -0,0 +1,19 @@
+module CassandraObject
+  module Scoping
+    extend ActiveSupport::Concern
+
+    included do
+      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
+      end
+    end
+
+    module ClassMethods
+      def scope
+        Scope.new(self)
+      end
+    end
+  end
+end

data/lib/cassandra_object/serialization.rb

@@ -0,0 +1,6 @@
+module CassandraObject
+  module Serialization
+    extend ActiveSupport::Concern
+    include ActiveModel::Serializers::JSON
+  end
+end

data/lib/cassandra_object/tasks/cassandra.rake

@@ -0,0 +1,53 @@
+namespace :cassandra do
+
+  desc 'Creates the keyspace in config/cassandra.yml for the current environment'
+  task create: :environment do
+    begin
+      CassandraObject::Schema.create_keyspace cassandra_config.keyspace, cassandra_config.keyspace_options
+    rescue Exception => e
+      if e.message =~ /conflicts/
+        p "Keyspace #{cassandra_config.keyspace} already exists"
+      else
+        raise e
+      end
+    end
+  end
+
+  desc 'Drops the keyspace in config/cassandra.yml for the current environment'
+  task drop: :environment do
+    begin
+      CassandraObject::Schema.drop_keyspace cassandra_config.keyspace
+    rescue Exception => e
+      if e.message =~ /non existing keyspace/
+        p "Keyspace #{cassandra_config.keyspace} does not exist"
+      else
+        raise e
+      end
+    end
+  end
+
+  task reset: [:drop, :setup]
+  task setup: [:create, :load]
+
+  task dump: :environment do
+    filename = ENV['SCHEMA'] || "#{Rails.root}/db/cassandra/structure.cql"
+    File.open(filename, "w:utf-8") do |file|
+      CassandraObject::Schema.dump(file)
+    end
+  end
+
+  task load: :environment do
+    filename = ENV['SCHEMA'] || "#{Rails.root}/db/cassandra/structure.cql"
+    File.open(filename) do |file|
+      CassandraObject::Schema.load(file)
+    end
+  end
+
+  private
+    def cassandra_config
+      @cassandra_config ||= begin
+        cassandra_configs = YAML.load_file(Rails.root.join('config', 'cassandra.yml'))
+        CassandraObject::Config.new cassandra_configs[Rails.env || 'development']
+      end
+    end
+end

data/lib/cassandra_object/timestamps.rb

@@ -0,0 +1,19 @@
+module CassandraObject
+  module Timestamps
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :created_at, type: :time
+      attribute :updated_at, type: :time
+
+      before_create do
+        self.created_at ||= Time.current
+        self.updated_at ||= Time.current
+      end
+
+      before_update if: :changed? do
+        self.updated_at = Time.current
+      end
+    end
+  end
+end

data/lib/cassandra_object/type.rb

@@ -0,0 +1,16 @@
+module CassandraObject
+  class Type
+    cattr_accessor :attribute_types
+    self.attribute_types = {}.with_indifferent_access
+
+    class << self
+      def register(name, coder)
+        attribute_types[name] = coder
+      end
+
+      def get_coder(name)
+        attribute_types[name]
+      end
+    end
+  end
+end

data/lib/cassandra_object/types.rb

@@ -0,0 +1,8 @@
+CassandraObject::Type.register(:array,          CassandraObject::Types::ArrayType)
+CassandraObject::Type.register(:boolean,        CassandraObject::Types::BooleanType)
+CassandraObject::Type.register(:date,           CassandraObject::Types::DateType)
+CassandraObject::Type.register(:float,          CassandraObject::Types::FloatType)
+CassandraObject::Type.register(:integer,        CassandraObject::Types::IntegerType)
+CassandraObject::Type.register(:json,           CassandraObject::Types::JsonType)
+CassandraObject::Type.register(:time,           CassandraObject::Types::TimeType)
+CassandraObject::Type.register(:string,         CassandraObject::Types::StringType)

data/lib/cassandra_object/types/array_type.rb

@@ -0,0 +1,76 @@
+module CassandraObject
+  module Types
+    class ArrayType < BaseType
+      class DirtyArray < Array
+        attr_accessor :record, :name, :options
+        def initialize(record, name, array, options)
+          @record   = record
+          @name     = name.to_s
+          @options  = options
+
+          super(array)
+          setify!
+        end
+
+        def <<(obj)
+          modifying do
+            super
+            setify!
+          end
+        end
+
+        def delete(obj)
+          modifying do
+            super
+          end
+        end
+
+        private
+          def setify!
+            if options[:unique]
+              reject!(&:blank?)
+              uniq!
+              begin sort! rescue ArgumentError end
+            end
+          end
+
+          def modifying
+            unless record.changed_attributes.include?(name)
+              original = dup
+            end
+
+            result = yield
+
+            if !record.changed_attributes.key?(name) && original != self
+              record.changed_attributes[name] = original
+            end
+
+            record.send("#{name}=", self)
+
+            result
+          end
+      end
+
+      def default
+        []
+      end
+
+      def encode(array)
+        raise ArgumentError.new("#{array.inspect} is not an Array") unless array.kind_of?(Array)
+        array.to_a.to_json
+      end
+
+      def decode(str)
+        return [] if str.blank?
+
+        ActiveSupport::JSON.decode(str).tap do |array|
+          array.uniq! if options[:unique]
+        end
+      end
+
+      def wrap(record, name, value)
+        DirtyArray.new(record, name, Array(value), options)
+      end
+    end
+  end
+end