cassandra_model 0.9.3.2

data/lib/cassandra_model/connection_cache.rb

@@ -0,0 +1,24 @@
+module CassandraModel
+  class ConnectionCache
+    MUTEX = Mutex.new
+
+    class << self
+      def build_cache
+        Hash.new do |hash, key|
+          MUTEX.synchronize { hash[key] = RawConnection.new(key) }
+        end
+      end
+
+      def [](key)
+        @@cache[key]
+      end
+
+      def clear
+        @@cache.values.map(&:shutdown)
+        @@cache.clear
+      end
+    end
+
+    @@cache = build_cache
+  end
+end

data/lib/cassandra_model/counter_record.rb

@@ -0,0 +1,58 @@
+module CassandraModel
+  class CounterRecord < Record
+
+    def increment_async!(options)
+      counter_clause = counter_clause(options)
+      row_key = internal_primary_key.values
+      statement = increment_statement(counter_clause)
+
+      future = if batch_reactor
+                 execute_async_in_batch(statement, options.values + row_key)
+               else
+                 session.execute_async(statement, *options.values, *row_key, write_query_options)
+               end
+      future.on_success { execute_callback(:record_saved) }
+      future.on_failure do |error|
+        Logging.logger.error("Error incrementing #{self.class}: #{error}")
+        execute_callback(:save_record_failed, error)
+      end.then { self }
+    end
+
+    def increment!(options)
+      increment_async!(options).get
+    end
+
+    def save_async
+      raise NotImplementedError
+    end
+
+    private
+
+    def internal_primary_key
+      internal_attributes.slice(*self.class.internal_primary_key)
+    end
+
+    def increment_statement(counter_clause)
+      query = "UPDATE #{self.class.table_name} SET #{counter_clause} WHERE #{update_restriction}"
+      statement(query)
+    end
+
+    def counter_clause(options)
+      options.keys.map { |column| "#{column} = #{column} + ?" }.join(', ')
+    end
+
+    def update_restriction
+      self.class.internal_primary_key.map { |key| "#{key} = ?" }.join(' AND ')
+    end
+
+    class << self
+      def counter_columns
+        table_data.counter_columns ||= columns - (partition_key + clustering_columns)
+      end
+
+      def save_in_batch
+        table_config.batch_type = :counter
+      end
+    end
+  end
+end

data/lib/cassandra_model/data_inquirer.rb

@@ -0,0 +1,105 @@
+module CassandraModel
+  class DataInquirer
+    include TypeGuessing
+
+    attr_reader :partition_key, :column_defaults, :is_sharding
+
+    def initialize
+      @partition_key = Hash.new { |hash, key| hash[key] = :text }
+      @column_defaults = Hash.new { |hash, key| hash[key] = '' }
+      @known_keys = []
+    end
+
+    def knows_about(*columns)
+      columns.each do |column|
+        partition_key[column]
+        guess_data_type(column) if @guess_data_types
+        column_defaults[column]
+      end
+      @known_keys << columns
+      self
+    end
+
+    def shards_queries
+      @is_sharding = true
+    end
+
+    def composite_rows
+      @known_keys.map do |row|
+        partition_key.keys - row
+      end.reject(&:empty?)
+    end
+
+    def defaults(column)
+      raise "Cannot default unknown column #{column}" unless partition_key.include?(column)
+      ColumnDefault.new(column, self)
+    end
+
+    def change_type_of(column)
+      raise "Cannot retype unknown column #{column}" unless partition_key.include?(column)
+      ColumnType.new(column, self)
+    end
+
+    private
+
+    ColumnDefault = Struct.new(:column, :inquirer) do
+      def to(value)
+        default_to(value)
+
+        case value
+          when Integer then
+            retype_to(:int)
+          when Float then
+            retype_to(:double)
+          when Time then
+            retype_to(:timestamp)
+          when Cassandra::Uuid then
+            retype_to(:uuid)
+        end
+      end
+
+      def default_to(value)
+        inquirer.column_defaults[column] = value
+      end
+
+      private
+
+      def retype_to(type)
+        ColumnType.new(column, inquirer).retype_to(type)
+      end
+    end
+
+    ColumnType = Struct.new(:column, :inquirer) do
+      def to(type)
+        retype_to(type)
+
+        case type
+          when :int then
+            default_to(0)
+          when :double then
+            default_to(0.0)
+          when :timestamp then
+            default_to(Time.at(0))
+          when :uuid then
+            default_to(Cassandra::Uuid.new(0))
+        end
+      end
+
+      def retype_to(type)
+        inquirer.partition_key[column] = type
+      end
+
+      private
+
+      def default_to(value)
+        ColumnDefault.new(column, inquirer).default_to(value)
+      end
+    end
+
+    def guess_data_type(column)
+      type = guessed_data_type(column, :int)
+      change_type_of(column).to(type)
+    end
+
+  end
+end

data/lib/cassandra_model/data_modelling.rb

@@ -0,0 +1,45 @@
+module CassandraModel
+  module DataModelling
+
+    def self.extended(base)
+      base.send(:include, CompositeRecord)
+    end
+
+    def model_data
+      inquirer = DataInquirer.new
+      data_set = DataSet.new
+      yield inquirer, data_set
+
+      self.table = if table_sliced?(data_set)
+                     rotating_table(data_set, inquirer)
+                   else
+                     meta_table(table_prefix, inquirer, data_set)
+                   end
+
+      generate_composite_defaults_from_inquirer(inquirer)
+    end
+
+    private
+
+    def table_sliced?(data_set)
+      data_set.data_rotation[:slices]
+    end
+
+    def rotating_table(data_set, inquirer)
+      table_list = data_set.data_rotation[:slices].times.map do |index|
+        meta_table("#{table_prefix}_#{index}", inquirer, data_set)
+      end
+      CassandraModel::RotatingTable.new(table_list, data_set.data_rotation[:frequency])
+    end
+
+    def table_prefix
+      table_config.table_name || generate_table_name
+    end
+
+    def meta_table(table_name, inquirer, data_set)
+      table_definition = CassandraModel::TableDefinition.from_data_model(table_name, inquirer, data_set)
+      CassandraModel::MetaTable.new(table_config.connection_name, table_definition)
+    end
+
+  end
+end

data/lib/cassandra_model/data_set.rb

@@ -0,0 +1,84 @@
+module CassandraModel
+  class DataSet
+    include TypeGuessing
+
+    attr_reader :columns, :clustering_columns, :data_rotation
+
+    def initialize
+      @columns = Hash.new { |hash, key| hash[key] = :text }
+      @data_rotation = {}
+      @clustering_columns = []
+    end
+
+    def knows_about(*columns)
+      columns.each do |column|
+        if @guess_data_types
+          guess_data_type(column)
+        else
+          self.columns[column]
+        end
+      end
+    end
+
+    def counts(*columns)
+      if columns.empty?
+        count_column(:count)
+      else
+        columns.map { |column| count_column(column) }
+      end
+    end
+
+    def rotates_storage_across(slices)
+      TableRotation.new(slices, self)
+    end
+
+    def is_defined_by(*columns)
+      knows_about(*columns)
+      @clustering_columns = columns
+    end
+
+    def change_type_of(column)
+      raise "Cannot retype unknown column #{column}" unless columns.include?(column)
+      ColumnType.new(column, self)
+    end
+
+    private
+
+    def count_column(column)
+      @columns[column] = :counter
+    end
+
+    ColumnType = Struct.new(:column, :data_set) do
+      def to(type)
+        data_set.columns[column] = type
+      end
+    end
+
+    TableRotation = Struct.new(:slices, :data_set) do
+      def tables
+        define_table_slicing
+        define_rotation_frequency(1.week)
+      end
+
+      def tables_every(interval)
+        define_table_slicing
+        define_rotation_frequency(interval)
+      end
+
+      private
+
+      def define_rotation_frequency(frequency)
+        data_set.data_rotation[:frequency] = frequency
+      end
+
+      def define_table_slicing
+        data_set.data_rotation[:slices] = slices
+      end
+    end
+
+    def guess_data_type(column)
+      columns[column] = guessed_data_type(column, :counter)
+    end
+
+  end
+end

data/lib/cassandra_model/displayable_attributes.rb

@@ -0,0 +1,44 @@
+module CassandraModel
+  module DisplayableAttributesStatic
+    def display_attributes(*columns)
+      map = (columns.first if columns.first.is_a?(Hash))
+      table_config.display_attributes = map ? map : columns
+    end
+
+    def displayable_attributes
+      table_config.display_attributes
+    end
+  end
+
+  module DisplayableAttributes
+    def self.included(base)
+      base.extend(DisplayableAttributesStatic)
+    end
+
+    def as_json(*_)
+      if displayable_attributes
+        displayable_attributes.is_a?(Hash) ? mapped_as_json : sliced_displayable_attributes
+      else
+        attributes
+      end
+    end
+
+    private
+
+    def mapped_as_json
+      sliced_displayable_attributes.inject({}) { |memo, (key, value)| memo.merge!(displayable_attributes[key] => value) }
+    end
+
+    def sliced_displayable_attributes
+      attributes.slice(*displayable_attributes_slice)
+    end
+
+    def displayable_attributes_slice
+      displayable_attributes.is_a?(Hash) ? displayable_attributes.keys : displayable_attributes
+    end
+
+    def displayable_attributes
+      self.class.displayable_attributes
+    end
+  end
+end

data/lib/cassandra_model/global_callbacks.rb

@@ -0,0 +1,39 @@
+module CassandraModel
+  class GlobalCallbacks
+
+    class << self
+      def add_listener(listener)
+        listeners << listener
+      end
+
+      def call(callback, *params)
+        listeners.each do |listener|
+          callback_name = callback_name(callback)
+          listener.public_send(callback_name, *params) if listener.respond_to?(callback_name)
+        end
+      end
+
+      def method_missing(method, *args, &block)
+        if method =~ /^on_/
+          listener = Object.new.tap do |callback|
+            callback.define_singleton_method(method) { |*callback_args| block.call(*callback_args) }
+          end
+          add_listener listener
+        else
+          super(method, *args, &block)
+        end
+      end
+
+      private
+
+      def callback_name(callback)
+        "on_#{callback}"
+      end
+
+      def listeners
+        @listeners ||= []
+      end
+    end
+
+  end
+end

data/lib/cassandra_model/logging.rb

@@ -0,0 +1,8 @@
+module CassandraModel
+  class Logging
+    #noinspection RubyClassVariableUsageInspection
+    @@logger = Logger.new(STDOUT).tap { |logger| logger.level = Logger::WARN }
+
+    cattr_accessor :logger
+  end
+end

data/lib/cassandra_model/meta_columns.rb

@@ -0,0 +1,162 @@
+module CassandraModel
+  module MetaColumns
+
+    def self.included(base)
+      base.extend MetaColumnsStatic
+    end
+
+    private
+
+    def deferred_columns
+      self.class.deferred_columns
+    end
+
+    def after_initialize
+      self.class.after_initialize(self)
+      deferred_columns.each do |column|
+        column_value = @attributes.delete(column)
+        send("#{column}=", column_value) if column_value
+      end
+    end
+
+    def deferred_getset(name, on_load)
+      if instance_variable_defined?(defered_column_name(name))
+        deferred_get(name)
+      else
+        deferred_set_with_callback(name, on_load)
+      end
+    end
+
+    def deferred_get(name)
+      instance_variable_get(defered_column_name(name))
+    end
+
+    def async_deferred_set(name)
+      future = @deferred_futures[name]
+      result = (future.get if future)
+      deferred_set(name, result)
+    end
+
+    def deferred_set_with_callback(name, on_load)
+      result = on_load.call(@attributes)
+      deferred_set(name, result)
+    end
+
+    def deferred_set(name, value)
+      instance_variable_set(defered_column_name(name), value)
+    end
+
+    def defered_column_name(name)
+      "@deferred_#{name}"
+    end
+  end
+
+  module MetaColumnsStatic
+    extend Forwardable
+
+    #attr_reader :deferred_column_writers, :async_deferred_column_writers
+    def_delegators :table_config, :deferred_column_writers, :async_deferred_column_writers
+
+    def deferred_column(name, options)
+      name = name.to_sym
+      deferred_columns << name
+
+      create_attr_accessor(name, options)
+      create_save_method(name, options)
+    end
+
+    def async_deferred_column(name, options)
+      name = name.to_sym
+      deferred_columns << name
+
+      async_create_attr_accessor(name, options)
+      async_create_save_method(name, options)
+    end
+
+    def after_initialize(record)
+      futures = if table_config.async_deferred_column_readers
+                  table_config.async_deferred_column_readers.inject({}) do |memo, (column, callback)|
+                    memo.merge!(column => callback.call(record.attributes))
+                  end
+                end
+      record.instance_variable_set(:@deferred_futures, futures)
+    end
+
+    def save_deferred_columns(record)
+      do_save_deferred_columns(record) if table_config.deferred_column_writers
+    end
+
+    def save_async_deferred_columns(record)
+      do_save_async_deferred_columns(record) if table_config.async_deferred_column_writers
+    end
+
+    def deferred_columns
+      table_config.deferred_columns ||= []
+    end
+
+    private
+
+    def do_save_deferred_columns(record)
+      table_config.deferred_column_writers.each { |column, callback| callback.call(record.attributes, record.send(column)) }
+    end
+
+    def do_save_async_deferred_columns(record)
+      table_config.async_deferred_column_writers.map { |column, callback| callback.call(record.attributes, record.send(column)) }
+    end
+
+    def create_save_method(name, options)
+      on_save = options[:on_save]
+      if on_save
+        table_config.deferred_column_writers ||= {}
+        table_config.deferred_column_writers[name] = on_save
+
+        define_method(:"save_#{name}") { on_save.call(@attributes, send(name)) }
+      end
+    end
+
+    def async_create_save_method(name, options)
+      on_save = options[:on_save]
+      if on_save
+        table_config.async_deferred_column_writers ||= {}
+        table_config.async_deferred_column_writers[name] = on_save
+
+        define_method(:"save_#{name}") { on_save.call(@attributes, send(name)) }
+      end
+    end
+
+    def create_attr_accessor(name, options)
+      create_attr_reader(name, options)
+      create_attr_writer(name)
+    end
+
+    def async_create_attr_accessor(name, options)
+      async_create_attr_reader(name, options)
+      create_attr_writer(name)
+    end
+
+    def create_attr_writer(name)
+      define_method(:"#{name}=") do |value|
+        deferred_set(name, value)
+      end
+    end
+
+    def create_attr_reader(name, options)
+      on_load = options[:on_load]
+      raise 'No on_load method provided' unless on_load
+
+      define_method(name) { deferred_getset(name, on_load) }
+    end
+
+    def async_create_attr_reader(name, options)
+      on_load = options[:on_load]
+      raise 'No on_load method provided' unless on_load
+
+      table_config.async_deferred_column_readers ||= {}
+      table_config.async_deferred_column_readers[name] = on_load
+
+      define_method(name) do
+        deferred_get(name) || async_deferred_set(name)
+      end
+    end
+  end
+end