massive_record 0.1.0

data/lib/massive_record/orm/finders.rb

@@ -0,0 +1,125 @@
+module MassiveRecord
+  module ORM
+    module Finders
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        #
+        # Interface for retrieving objects based on key.
+        # Has some convenience behaviour like find :first, :last, :all.
+        #
+        def find(*args)
+          options = args.extract_options!.to_options
+          raise ArgumentError.new("At least one argument required!") if args.empty?
+          raise RecordNotFound.new("Can't find a #{model_name.human} without an ID.") if args.first.nil?
+          raise ArgumentError.new("Sorry, conditions are not supported!") if options.has_key? :conditions
+          args << options
+
+          type = args.shift if args.first.is_a? Symbol
+          find_many = type == :all
+          expected_result_size = nil
+
+          return (find_many ? [] : nil) unless table.exists?
+          
+          result_from_table = if type
+                                table.send(type, *args) # first() / all()
+                              else
+                                options = args.extract_options!
+                                what_to_find = args.first
+                                expected_result_size = 1
+
+                                if args.first.kind_of?(Array)
+                                  find_many = true
+                                elsif args.length > 1
+                                  find_many = true
+                                  what_to_find = args
+                                end
+
+                                expected_result_size = what_to_find.length if what_to_find.is_a? Array
+                                table.find(what_to_find, options)
+                              end
+
+          # Filter out unexpected IDs (unless type is set (all/first), in that case
+          # we have no expectations on the returned rows' ids)
+          unless type || result_from_table.blank?
+            if find_many
+              result_from_table.select! { |result| what_to_find.include? result.id }
+            else 
+              if result_from_table.id != what_to_find
+                result_from_table = nil
+              end
+            end
+          end
+
+          raise RecordNotFound.new("Could not find #{model_name} with id=#{what_to_find}") if result_from_table.blank? && type.nil?
+          
+          if find_many && expected_result_size && expected_result_size != result_from_table.length
+            raise RecordNotFound.new("Expected to find #{expected_result_size} records, but found only #{result_from_table.length}")
+          end
+          
+          records = [result_from_table].compact.flatten.collect do |row|
+            instantiate(transpose_hbase_columns_to_record_attributes(row))
+          end
+
+          find_many ? records : records.first
+        end
+
+        def first(*args)
+          find(:first, *args)
+        end
+
+        def last(*args)
+          raise "Sorry, not implemented!"
+        end
+
+        def all(*args)
+          find(:all, *args)
+        end
+        
+        def find_in_batches(*args)
+          table.find_in_batches(*args) do |rows|
+            records = rows.collect do |row|
+              instantiate(transpose_hbase_columns_to_record_attributes(row))
+            end    
+            yield records
+          end
+        end
+        
+        def find_each(*args)
+          find_in_batches(*args) do |rows|
+            rows.each do |row|
+              yield row
+            end
+          end
+        end
+
+
+        def exists?(id)
+          !!find(id) rescue false
+        end
+
+
+        private
+
+        def transpose_hbase_columns_to_record_attributes(row)
+          attributes = {:id => row.id}
+          
+          autoload_column_families_and_fields_with(row.columns.keys)
+
+          # Parse the schema to populate the instance attributes
+          attributes_schema.each do |key, field|
+            cell = row.columns[field.unique_name]
+            attributes[field.name] = cell.nil? ? nil : cell.deserialize_value
+          end
+          attributes
+        end
+
+        def instantiate(record)
+          allocate.tap do |model|
+            model.init_with('attributes' => record)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/id_factory.rb

@@ -0,0 +1,133 @@
+require 'singleton'
+
+module MassiveRecord
+  module ORM
+
+    #
+    # A factory class for unique IDs for any given tables.
+    #
+    # Usage:
+    #   IdFactory.next_for(:cars) # => 1
+    #   IdFactory.next_for(:cars) # => 2
+    #   IdFactory.next_for(AClassRespondingToTableName)         # => 1
+    #   IdFactory.next_for("a_class_responding_to_table_names") # => 2
+    #
+    #
+    # Storage:
+    #   Stored in id_factories table, under column family named tables.
+    #   Field name equals to tables it has generated ids for, and it's
+    #   values is integers (if the adapter supports it).
+    #
+    class IdFactory < Table
+      include Singleton
+
+      COLUMN_FAMILY_FOR_TABLES = :tables
+      ID = "id_factory"
+
+      column_family COLUMN_FAMILY_FOR_TABLES do
+        autoload_fields
+      end
+
+      #
+      # Returns the factory, singleton class.
+      # It will be a reloaded version each time instance
+      # is retrieved, or else it will fetch self from the
+      # database, or if all other fails return a new of self.
+      #
+      def self.instance
+        if table_exists?
+          begin
+            if @instance
+              @instance.reload
+            else
+              @instance = find(ID)
+            end
+          rescue RecordNotFound
+            @instance = nil
+          end
+        end
+
+        @instance = new unless @instance
+        @instance
+      end
+
+      #
+      # Delegates to the instance, just a shout cut.
+      #
+      def self.next_for(table)
+        instance.next_for(table)
+      end
+
+
+
+      #
+      # Returns a new and unique id for a given table name
+      # Table can a symbol, string or an object responding to table_name
+      #
+      def next_for(table)
+        table = table.respond_to?(:table_name) ? table.table_name : table.to_s
+        next_id :table => table
+      end
+
+
+
+      def id
+        ID
+      end
+
+      private
+
+      #
+      # Method which actually does the increment work for
+      # a given table name as string
+      #
+      def next_id(options = {}) 
+        options.assert_valid_keys(:table)
+        table_name = options.delete :table
+
+        create_field_or_ensure_type_integer_for(table_name)
+        atomic_increment!(table_name)
+      end
+
+
+
+
+      def create_field_or_ensure_type_integer_for(table_name)
+        if has_field_for? table_name
+          ensure_type_integer_for(table_name)
+        else
+          create_field_for(table_name)
+        end
+      end
+
+
+      #
+      # Creates a field for a table name which is new
+      # Feels a bit hackish, hooking in and doing some of what the
+      # autoload-functionality of column_family block above does too.
+      # But at least, we can "dynamicly" assign new attributes to this object.
+      #
+      def create_field_for(table_name)
+        add_field_to_column_family COLUMN_FAMILY_FOR_TABLES, table_name, :integer, :default => 0
+      end
+      
+      #
+      # Just makes sure that definition of a field is set to integer.
+      # This is needed as the autoload functionlaity sets all types to strings.
+      #
+      def ensure_type_integer_for(table_name)
+        column_family_for_tables.field_by_name(table_name).type = :integer
+        self[table_name] = 0 if self[table_name].blank?
+      end
+
+
+      def has_field_for?(table_name)
+        respond_to? table_name
+      end
+
+      def column_family_for_tables
+        @column_family_for_tables ||= column_families.family_by_name(COLUMN_FAMILY_FOR_TABLES)
+      end
+    end
+  end
+end

data/lib/massive_record/orm/persistence.rb

@@ -0,0 +1,199 @@
+module MassiveRecord
+  module ORM
+    module Persistence
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def create(attributes = {})
+          new(attributes).tap do |record|
+            record.save
+          end
+        end
+
+        def destroy_all
+          all.each { |record| record.destroy }
+        end
+      end
+
+
+      def new_record?
+        @new_record
+      end
+
+      def persisted?
+        !(new_record? || destroyed?)
+      end
+
+      def destroyed?
+        @destroyed
+      end
+
+
+      def reload
+        self.attributes_raw = self.class.find(id).attributes
+        self
+      end
+      
+      def save(*)
+        create_or_update
+      end
+
+      def save!(*)
+        create_or_update or raise RecordNotSaved
+      end
+
+      def update_attribute(attr_name, value)
+        send("#{attr_name}=", value)
+        save(:validate => false)
+      end
+
+      def update_attributes(attributes)
+        self.attributes = attributes
+        save
+      end
+
+      def update_attributes!(attributes)
+        self.attributes = attributes
+        save!
+      end
+
+      # TODO  This actually does nothing atm, but it's here and callbacks on it
+      #       is working.
+      def touch
+        true
+      end
+
+      def destroy
+        @destroyed = row_for_record.destroy and freeze
+      end
+      alias_method :delete, :destroy
+
+
+
+
+      def increment(attr_name, by = 1)
+        raise NotNumericalFieldError unless attributes_schema[attr_name.to_s].type == :integer
+        self[attr_name] ||= 0
+        self[attr_name] += by
+        self
+      end
+
+      def increment!(attr_name, by = 1)
+        increment(attr_name, by).update_attribute(attr_name, self[attr_name])
+      end
+
+      # Atomic increment of an attribute. Please note that it's the
+      # adapter (or the wrapper) which needs to guarantee that the update
+      # is atomic, and as of writing this the Thrift adapter / wrapper does
+      # not do this anatomic.
+      def atomic_increment!(attr_name, by = 1)
+        ensure_that_we_have_table_and_column_families!
+        attr_name = attr_name.to_s
+
+        row = row_for_record
+        row.values = attributes_to_row_values_hash([attr_name])
+        self[attr_name] = row.atomic_increment(attributes_schema[attr_name].unique_name, by).to_i
+      end
+
+      def decrement(attr_name, by = 1)
+        raise NotNumericalFieldError unless attributes_schema[attr_name.to_s].type == :integer
+        self[attr_name] ||= 0
+        self[attr_name] -= by
+        self
+      end
+
+      def decrement!(attr_name, by = 1)
+        decrement(attr_name, by).update_attribute(attr_name, self[attr_name])
+      end
+      
+
+      private
+
+
+      def create_or_update
+        !!(new_record? ? create : update)
+      end
+
+      def create
+        ensure_that_we_have_table_and_column_families!
+
+        if saved = store_record_to_database
+          @new_record = false
+        end
+        saved
+      end
+
+      def update(attribute_names_to_update = attributes.keys)
+        ensure_that_we_have_table_and_column_families!
+
+        store_record_to_database(attribute_names_to_update)
+      end
+
+
+
+
+      #
+      # Takes care of the actual storing of the record to the database
+      # Both update and create is using this
+      #
+      def store_record_to_database(attribute_names_to_update = [])
+        row = row_for_record
+        row.values = attributes_to_row_values_hash(attribute_names_to_update)
+        row.save
+      end
+
+
+      #
+      # Iterates over tables and column families and ensure that we
+      # have what we need
+      #
+      def ensure_that_we_have_table_and_column_families!
+        if !self.class.connection.tables.include? self.class.table_name
+          missing_family_names = calculate_missing_family_names
+          self.class.table.create_column_families(missing_family_names) unless missing_family_names.empty?
+          self.class.table.save
+        end
+
+        raise ColumnFamiliesMissingError.new(calculate_missing_family_names) if !calculate_missing_family_names.empty?
+      end
+      
+      #
+      # Calculate which column families are missing in the database in
+      # context of what the schema instructs.
+      #
+      def calculate_missing_family_names
+        existing_family_names = self.class.table.fetch_column_families.collect(&:name) rescue []
+        expected_family_names = column_families ? column_families.collect(&:name) : []
+
+        expected_family_names.collect(&:to_s) - existing_family_names.collect(&:to_s)
+      end
+
+      #
+      # Returns a Wrapper::Row class which we can manipulate this
+      # record in the database with
+      #
+      def row_for_record
+        raise IdMissing.new("You must set an ID before save.") if id.blank?
+
+        MassiveRecord::Wrapper::Row.new({
+          :id => id,
+          :table => self.class.table
+        })
+      end
+
+      #
+      # Returns attributes on a form which Wrapper::Row expects
+      #
+      def attributes_to_row_values_hash(only_attr_names = [])
+        values = Hash.new { |hash, key| hash[key] = Hash.new }
+
+        attributes_schema.each do |attr_name, orm_field|
+          next unless only_attr_names.empty? || only_attr_names.include?(attr_name)
+          values[orm_field.column_family.name][orm_field.column] = send(attr_name)
+        end
+
+        values
+      end
+    end
+  end
+end