cassandra_object_rails 0.0.1

data/lib/cassandra_object/inspect.rb

@@ -0,0 +1,25 @@
+module CassandraObject
+  module Inspect
+    def inspect
+      inspection = ["#{self.class.primary_key}: #{id.inspect}"]
+
+      @attributes.each do |attribute, value|
+        if value.present?
+          inspection << "#{attribute}: #{attribute_for_inspect(value)}"
+        end
+      end
+
+      "#<#{self.class} #{inspection * ', '}>"
+    end
+
+    def attribute_for_inspect(value)
+      if value.is_a?(String) && value.length > 50
+        "#{value[0..50]}...".inspect
+      elsif value.is_a?(Date) || value.is_a?(Time)
+        %("#{value.to_s(:db)}")
+      else
+        value.inspect
+      end
+    end
+  end
+end

data/lib/cassandra_object/log_subscriber.rb

@@ -0,0 +1,29 @@
+module CassandraObject
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def initialize
+      super
+      @odd_or_even = false
+    end
+
+    def cql(event)
+      payload = event.payload
+      name = '%s (%.1fms)' % [payload[:name], event.duration]
+      cql = payload[:cql].squeeze(' ')
+
+      if odd?
+        name = color(name, CYAN, true)
+        cql  = color(cql, nil, true)
+      else
+        name = color(name, MAGENTA, true)
+      end
+
+      debug "  #{name}  #{cql}"
+    end
+
+    def odd?
+      @odd_or_even = !@odd_or_even
+    end
+  end
+end
+
+CassandraObject::LogSubscriber.attach_to :cassandra_object

data/lib/cassandra_object/persistence.rb

@@ -0,0 +1,169 @@
+module CassandraObject
+  module Persistence
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :batch_statements
+    end
+
+    module ClassMethods
+      def remove(id)
+        execute_batchable_cql "DELETE FROM #{column_family}#{write_option_string} WHERE KEY = ?", id
+      end
+
+      def delete_all
+        execute_cql "TRUNCATE #{column_family}"
+      end
+
+      def create(attributes = {}, &block)
+        new(attributes, &block).tap do |object|
+          object.save
+        end
+      end
+
+      def write(id, attributes)
+        if (encoded = encode_attributes(attributes)).any?
+          insert_attributes = {'KEY' => id}.update encode_attributes(attributes)
+          statement = "INSERT INTO #{column_family} (#{quote_columns(insert_attributes.keys) * ','}) VALUES (#{Array.new(insert_attributes.size, '?') * ','})#{write_option_string}"
+          execute_batchable_cql statement, *insert_attributes.values
+        end
+
+        if (nil_attributes = attributes.select { |key, value| value.nil? }).any?
+          execute_batchable_cql "DELETE #{quote_columns(nil_attributes.keys) * ','} FROM #{column_family}#{write_option_string} WHERE KEY = ?", id
+        end
+      end
+
+      def batching?
+        !batch_statements.nil?
+      end
+
+      def batch
+        self.batch_statements = []
+        yield
+        execute_cql(batch_statement) if batch_statements.any?
+      ensure
+        self.batch_statements = nil
+      end
+
+      def instantiate(id, attributes)
+        allocate.tap do |object|
+          object.instance_variable_set("@id", id) if id
+          object.instance_variable_set("@new_record", false)
+          object.instance_variable_set("@destroyed", false)
+          object.instance_variable_set("@attributes", typecast_attributes(object, attributes))
+        end
+      end
+
+      def encode_attributes(attributes)
+        encoded = {}
+        attributes.each do |column_name, value|
+          unless value.nil?
+            encoded[column_name.to_s] = attribute_definitions[column_name.to_sym].coder.encode(value)
+          end
+        end
+        encoded
+      end
+
+      private
+
+        def quote_columns(column_names)
+          column_names.map { |name| "'#{name}'" }
+        end
+
+        def batch_statement
+          return nil unless batch_statements.any?
+
+          [
+            "BEGIN BATCH#{write_option_string(true)}",
+            batch_statements * "\n",
+            'APPLY BATCH'
+          ] * "\n"
+        end
+
+        def execute_batchable_cql(cql_string, *bind_vars)
+          if batch_statements
+            batch_statements << CassandraCQL::Statement.sanitize(cql_string, bind_vars)
+          else
+            execute_cql cql_string, *bind_vars
+          end
+        end
+
+        def typecast_attributes(object, attributes)
+          attributes = attributes.symbolize_keys
+          Hash[attribute_definitions.map { |k, attribute_definition| [k.to_s, attribute_definition.instantiate(object, attributes[k])] }]
+        end
+
+        def write_option_string(ignore_batching = false)
+          if (ignore_batching || !batching?) && base_class.default_consistency
+            " USING CONSISTENCY #{base_class.default_consistency}"
+          end
+        end
+    end
+
+    def new_record?
+      @new_record
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def persisted?
+      !(new_record? || destroyed?)
+    end
+
+    def save(*)
+      new_record? ? create : update
+    end
+
+    def destroy
+      self.class.remove(id)
+      @destroyed = true
+    end
+
+    def update_attribute(name, value)
+      name = name.to_s
+      send("#{name}=", value)
+      save(validate: false)
+    end
+
+    def update_attributes(attributes)
+      self.attributes = attributes
+      save
+    end
+
+    def update_attributes!(attributes)
+      self.attributes = attributes
+      save!
+    end
+
+    def becomes(klass)
+      became = klass.new
+      became.instance_variable_set("@attributes", @attributes)
+      became.instance_variable_set("@new_record", new_record?)
+      became.instance_variable_set("@destroyed", destroyed?)
+      became
+    end
+
+    def reload
+      clear_belongs_to_cache
+      @attributes.update(self.class.find(id).instance_variable_get('@attributes'))
+      self
+    end
+
+    private
+      def update
+        write
+      end
+
+      def create
+        @new_record = false
+        write
+      end
+
+      def write
+        changed_attributes = Hash[changed.map { |attr| [attr, read_attribute(attr)] }]
+        self.class.write(id, changed_attributes)
+      end
+  end
+end

data/lib/cassandra_object/rails_initializer.rb

@@ -0,0 +1,19 @@
+module CassandraObject
+
+  class RailsInitializer
+
+    def self.configure!
+      self.new.configure!
+    end
+
+    def configure!
+      return if cassandra_configs.nil?
+      CassandraObject::Base.config = cassandra_configs[Rails.env || 'development']
+    end
+
+    def cassandra_configs
+      @config ||= YAML.load_file(Rails.root.join('config', 'cassandra.yml'))
+    end
+
+  end
+end

data/lib/cassandra_object/railtie.rb

@@ -0,0 +1,11 @@
+module CassandraObject
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load 'cassandra_object/tasks/cassandra.rake'
+    end
+
+    initializer 'my_railtie.configure_rails_initialization' do |app|
+      RailsInitializer.configure!
+    end
+  end
+end

data/lib/cassandra_object/savepoints.rb

@@ -0,0 +1,79 @@
+module CassandraObject
+  module Savepoints
+    class Rollback
+      attr_accessor :action, :record, :rollback_attributes
+      def initialize(action, record)
+        @action = action
+        @record = record
+        if action == :update
+          @rollback_attributes = record.changed_attributes.deep_dup
+        elsif action == :create
+          @rollback_attributes = record.attributes.deep_dup
+        end
+      end
+
+      def run!
+        case action
+        when :destroy
+          record.class.remove(record.id)
+        when :create, :update
+          record.class.write(record.id, rollback_attributes)
+        end
+      end
+    end
+
+    class Savepoint
+      attr_accessor :rollbacks
+      def initialize
+        self.rollbacks = []
+      end
+
+      def add_rollback(action, record)
+        states << Rollback.new(action, record)
+      end
+
+      def rollback!
+        rollbacks.reverse_each(&:run!)
+      end
+    end
+
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :savepoints
+      self.savepoints = []
+    end
+
+    module ClassMethods
+      def savepoint
+        self.savepoints.push Savepoint.new
+        yield
+        savepoints.pop
+      rescue => e
+        savepoints.pop.rollback!
+      end
+
+      def add_savepoint_rollback(action, record)
+        unless savepoints.empty?
+          savepoints.last.add_rollback(action, record)
+        end
+      end
+    end
+
+    def destroy
+      self.class.add_savepoint_rollback(:create, self)
+      super
+    end
+
+    private
+      def create
+        self.class.add_savepoint_rollback(:destroy, self)
+        super
+      end
+
+      def update
+        self.class.add_savepoint_rollback(:update, self)
+        super
+      end
+  end
+end

data/lib/cassandra_object/schema.rb

@@ -0,0 +1,78 @@
+require 'cassandra_object/schema/tasks'
+
+module CassandraObject
+  class Schema
+    extend Tasks
+
+    class << self
+      DEFAULT_CREATE_KEYSPACE = {
+        'strategy_class' => 'SimpleStrategy',
+        'strategy_options:replication_factor' => 1
+      }
+
+      def create_keyspace(keyspace, options = {})
+        stmt = "CREATE KEYSPACE #{keyspace}"
+
+        if options.empty?
+          options = DEFAULT_CREATE_KEYSPACE
+        end
+
+        system_execute statement_with_options(stmt, options)
+      end
+
+      def drop_keyspace(keyspace)
+        system_execute "DROP KEYSPACE #{keyspace}"
+      end
+
+      def create_column_family(column_family, options = {})
+        stmt = "CREATE COLUMNFAMILY #{column_family} " +
+               "(KEY varchar PRIMARY KEY)"
+
+        execute statement_with_options(stmt, options)
+      end
+
+      def alter_column_family(column_family, instruction, options = {})
+        stmt = "ALTER TABLE #{column_family} #{instruction}"
+        execute statement_with_options(stmt, options)
+      end
+
+      def drop_column_family(column_family)
+        stmt = "DROP TABLE #{column_family}"
+        execute stmt
+      end
+
+      def add_index(column_family, column, index_name = nil)
+        stmt = "CREATE INDEX #{index_name.nil? ? '' : index_name} ON #{column_family} (#{column})"
+        execute stmt
+      end
+
+      def drop_index(index_name)
+        # If the index was not given a name during creation, the index name is <columnfamily_name>_<column_name>_idx.
+        stmt = "DROP INDEX #{index_name}"
+        execute stmt
+      end
+
+      private
+        def statement_with_options(stmt, options)
+          if options.any?
+            with_stmt = options.map do |k,v|
+              "#{k} = #{CassandraCQL::Statement.quote(v)}"
+            end.join(' AND ')
+
+            stmt << " WITH #{with_stmt}"
+          end
+
+          stmt
+        end
+
+        def execute(cql)
+          CassandraObject::Base.execute_cql cql
+        end
+
+        def system_execute(cql)
+          @system_cql ||= CassandraCQL::Database.new(CassandraObject::Base.config.servers, keyspace: 'system')
+          @system_cql.execute cql
+        end
+    end
+  end
+end

data/lib/cassandra_object/schema/tasks.rb

@@ -0,0 +1,48 @@
+module CassandraObject
+  class Schema
+    module Tasks
+      def dump(io)
+        column_families.each do |column_family|
+          io.puts run_command("DESCRIBE COLUMNFAMILY #{column_family}")
+          io.puts
+        end
+      end
+
+      def load(io)
+        current_cql = ''
+
+        io.each_line do |line|
+          next if line.blank?
+
+          current_cql << line.rstrip
+
+          if current_cql =~ /;$/
+            CassandraObject::Base.execute_cql current_cql
+            current_cql = ''
+          end
+        end
+      end
+
+      def column_families
+        run_command('DESCRIBE COLUMNFAMILIES').split.sort
+      end
+
+      private
+        def run_command(command)
+          `echo "#{command};" | #{cqlsh} -k #{keyspace} #{server}`.sub(/^(.*)$/, '').strip
+        end
+
+        def cqlsh
+          ENV['CQLSH'] || 'cqlsh'
+        end
+
+        def keyspace
+          CassandraObject::Base.config.keyspace
+        end
+
+        def server
+          CassandraObject::Base.config.servers.first.gsub(/:.*/, '')
+        end
+    end
+  end
+end