massive_record 0.1.1 → 0.2.0.beta

data/lib/massive_record/adapters/thrift/scanner.rb

@@ -0,0 +1,59 @@
+module MassiveRecord
+  module Adapters
+    module Thrift
+      class Scanner
+      
+        attr_accessor :connection, :table_name, :column_family_names, :opened_scanner
+        attr_accessor :start_key, :offset_key, :created_at, :limit
+        attr_accessor :formatted_column_family_names, :column_family_names
+      
+        def initialize(connection, table_name, column_family_names, opts = {})
+          @connection = connection
+          @table_name = table_name
+          @column_family_names = column_family_names.collect{|n| n.split(":").first}
+          @column_family_names = opts[:columns] unless opts[:columns].nil?
+          @formatted_column_family_names = @column_family_names.collect{|n| "#{n.split(":").first}:"}
+          @start_key = opts[:start_key].to_s
+          @offset_key = opts[:offset_key].to_s
+          @created_at = opts[:created_at].to_s
+          @limit = opts[:limit] || 10
+        end
+      
+        def key
+          offset_key.empty? ? start_key : offset_key
+        end
+      
+        def open
+          if created_at.empty?
+            self.opened_scanner = connection.scannerOpen(table_name, key, formatted_column_family_names)
+          else
+            self.opened_scanner = connection.scannerOpenTs(table_name, key, formatted_column_family_names, created_at)
+          end
+        end
+      
+        def close
+          connection.scannerClose(opened_scanner)
+        end
+      
+        def fetch_trows(opts = {})
+          connection.scannerGetList(opened_scanner, limit)
+        end
+      
+        def fetch_rows(opts = {})
+          populate_rows(fetch_trows(opts))
+        end
+      
+        def populate_rows(results)
+          results.collect do |result|
+            populate_row(result) unless result.row.match(/^#{start_key.gsub("|", "\\|")}/).nil?
+          end.select{|r| !r.nil?}
+        end
+      
+        def populate_row(result)
+          Row.populate_from_trow_result(result, connection, table_name, column_family_names)
+        end
+      
+      end
+    end
+  end
+end

data/lib/massive_record/adapters/thrift/table.rb

@@ -0,0 +1,169 @@
+module MassiveRecord
+  module Adapters
+    module Thrift
+      class Table
+        
+        attr_accessor :connection, :name, :column_families
+    
+        def initialize(connection, table_name)
+          @connection = connection
+          @name = table_name.to_s
+          init_column_families
+        end
+    
+        def init_column_families      
+          @column_families = MassiveRecord::Wrapper::ColumnFamiliesCollection.new
+          @column_families.table = self
+        end
+    
+        def self.create(connection, table_name, column_families = [])
+          table = self.new(connection, table_name)
+          table.column_families = column_families
+          table.save
+        end
+    
+        def save
+          begin
+            client.createTable(name, @column_families.collect{|cf| cf.descriptor}).nil?
+          rescue Apache::Hadoop::Hbase::Thrift::AlreadyExists => ex
+            "The table already exists."
+          rescue => ex
+            raise ex
+          end
+        end
+    
+        def client
+          connection
+        end    
+    
+        def disable
+          client.disableTable(name).nil?
+        end
+    
+        def destroy
+          disable
+          client.deleteTable(name).nil?
+        end
+    
+        def create_column_families(column_family_names)
+          column_family_names.each{|name| @column_families.push(ColumnFamily.new(name))}
+        end
+    
+        def fetch_column_families
+          @column_families.clear
+          client.getColumnDescriptors(name).each do |column_name, description| 
+            @column_families.push(ColumnFamily.new(column_name.split(":").first))
+          end
+          @column_families
+        end
+    
+        def column_family_names
+          @column_families.collect{|column_family| column_family.name.to_s}
+        end
+    
+        def fetch_column_family_names
+          fetch_column_families
+          column_family_names
+        end
+      
+        def column_names
+          first.column_names
+        end
+    
+        def scanner(opts = {})
+          scanner = Scanner.new(connection, name, column_family_names, format_options_for_scanner(opts))
+        
+          if block_given?
+            begin
+              scanner.open
+              yield scanner
+            ensure
+              scanner.close
+            end
+          else
+            scanner
+          end
+        end
+      
+        def format_options_for_scanner(opts = {})
+          {
+            :start_key  => opts[:start],
+            :offset_key => opts[:offset],
+            :created_at => opts[:created_at],
+            :columns    => opts[:select], # list of column families to fetch from hbase
+            :limit      => opts[:limit] || opts[:batch_size]
+          }
+        end
+      
+        def all(opts = {})
+          rows = []
+          
+          find_in_batches(opts) do |batch|
+            rows |= batch
+          end
+          
+          rows
+        end
+      
+        def first(opts = {})
+          all(opts.merge(:limit => 1)).first
+        end
+        
+        #
+        # Fast way of fetching the value of the cell
+        # table.get("my_id", :info, :name) # => "Bob"
+        #
+        def get(id, column_family_name, column_name)
+          MassiveRecord::Wrapper::Cell.new(:value => connection.get(name, id, "#{column_family_name.to_s}:#{column_name.to_s}").first.value).value
+        end
+        
+        def find(*args)
+          arg  = args[0]
+          opts = args[1] || {}
+          if arg.is_a?(Array)
+            arg.collect{|id| first(opts.merge(:start => id))}
+          else
+            # need to replace by connection.getRowWithColumns("companies_development", "NO0000000812676342", ["info:name", "info:org_num"]).first
+            first(opts.merge(:start => arg))
+          end
+        end
+    
+        def find_in_batches(opts = {})        
+          results_limit = opts.delete(:limit)
+          results_found = 0
+          
+          scanner(opts) do |s|
+            while (true) do
+              s.limit = results_limit - results_found if !results_limit.nil? && results_limit <= results_found + s.limit
+              
+              rows = s.fetch_rows
+              if rows.empty?
+                break
+              else
+                results_found += rows.size
+                yield rows
+              end
+            end
+          end
+        end
+    
+        def exists?
+          connection.tables.include?(name)
+        end
+    
+        def regions
+          connection.getTableRegions(name).collect do |r|
+            {
+              :start_key => r.startKey,
+              :end_key => r.endKey,
+              :id => r.id,
+              :name => r.name,
+              :version => r.version
+            }
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/massive_record/orm/attribute_methods/read.rb

@@ -9,7 +9,8 @@ module MassiveRecord
         end
         
         def read_attribute(attr_name)
-          attributes_schema[attr_name].nil? ? @attributes[attr_name.to_s] : attributes_schema[attr_name].decode(@attributes[attr_name.to_s])
+          attr_name = attr_name.to_s
+          attributes_schema[attr_name].nil? ? @attributes[attr_name] : attributes_schema[attr_name].decode(@attributes[attr_name])
         end
 
         private

data/lib/massive_record/orm/base.rb

@@ -7,23 +7,31 @@ require 'active_support/core_ext/string'
 require 'active_support/memoizable'
 
 require 'massive_record/orm/schema'
+require 'massive_record/orm/coders'
 require 'massive_record/orm/errors'
 require 'massive_record/orm/config'
+require 'massive_record/orm/relations'
 require 'massive_record/orm/finders'
+require 'massive_record/orm/finders/scope'
 require 'massive_record/orm/attribute_methods'
 require 'massive_record/orm/attribute_methods/write'
 require 'massive_record/orm/attribute_methods/read'
 require 'massive_record/orm/attribute_methods/dirty'
+require 'massive_record/orm/single_table_inheritance'
 require 'massive_record/orm/validations'
 require 'massive_record/orm/callbacks'
 require 'massive_record/orm/timestamps'
 require 'massive_record/orm/persistence'
 
+
 module MassiveRecord
   module ORM
     class Base
       include ActiveModel::Conversion
       
+      class_attribute :coder, :instance_writer => false
+      self.coder = Coders::JSON.new
+
       # Accepts a logger conforming to the interface of Log4r or the default Ruby 1.8+ Logger class,
       cattr_accessor :logger, :instance_writer => false
 
@@ -42,7 +50,11 @@ module MassiveRecord
      
       class << self
         def table_name
-          @table_name ||= table_name_prefix + (table_name_overriden.blank? ? self.to_s.demodulize.underscore.pluralize : table_name_overriden) + table_name_suffix
+          @table_name ||= table_name_prefix + table_name_without_pre_and_suffix + table_name_suffix
+        end
+
+        def table_name_without_pre_and_suffix
+          (table_name_overriden.blank? ? base_class.to_s.demodulize.underscore.pluralize : table_name_overriden)
         end
 
         def table_name=(name)
@@ -54,6 +66,36 @@ module MassiveRecord
           @table_name = self.table_name_overriden = nil
           self.table_name_prefix = self.table_name_suffix = ""
         end
+
+        def base_class
+          class_of_descendant(self)
+        end
+
+
+        def inheritance_attribute
+          @inheritance_attribute ||= "type"
+        end
+
+        def set_inheritance_attribute(value = nil, &block)
+          define_attr_method :inheritance_attribute, value, &block
+        end
+        alias :inheritance_attribute= :set_inheritance_attribute
+
+
+        def ===(other)
+          other.is_a? self
+        end
+
+        
+        private
+        
+        def class_of_descendant(klass)
+          if klass.superclass.superclass == Base
+            klass
+          else
+            class_of_descendant(klass.superclass)
+          end
+        end
       end
 
       #
@@ -64,10 +106,14 @@ module MassiveRecord
       # for describing column families and fields are in place
       #
       def initialize(attributes = {})
-        self.attributes_raw = attributes_from_field_definition.merge(attributes)
-        self.attributes = attributes
         @new_record = true
         @destroyed = @readonly = false
+        @relation_proxy_cache = {}
+
+        attributes = {} if attributes.nil?
+
+        self.attributes_raw = attributes_from_field_definition.merge(attributes)
+        self.attributes = attributes
 
         _run_initialize_callbacks
       end
@@ -88,11 +134,14 @@ module MassiveRecord
       def init_with(coder)
         @new_record = false
         @destroyed = @readonly = false
+        @relation_proxy_cache = {}
 
         self.attributes_raw = coder['attributes']
 
         _run_find_callbacks
         _run_initialize_callbacks
+
+        self
       end
 
 
@@ -139,6 +188,13 @@ module MassiveRecord
       end
 
 
+      def clone
+        object = self.class.new
+        object.init_with('attributes' => attributes.select{|k| !['id', 'created_at', 'updated_at'].include?(k)})
+        object
+      end
+      
+
       private
 
       #
@@ -173,6 +229,7 @@ module MassiveRecord
 
     Base.class_eval do
       include Config
+      include Relations::Interface
       include Persistence
       include Finders
       include ActiveModel::Translation
@@ -182,6 +239,7 @@ module MassiveRecord
       include Validations
       include Callbacks
       include Timestamps
+      include SingleTableInheritance
 
 
       alias [] read_attribute

data/lib/massive_record/orm/coders/chained.rb

@@ -0,0 +1,71 @@
+module MassiveRecord
+  module ORM
+    module Coders
+      CoderError = ::StandardError
+      ParseError = CoderError
+      EncodeError = CoderError
+
+      #
+      # If you ever need support for multiple coders, this class can help you out.
+      # Lets say you have YAML serialized data in your attributes, but what to migrate
+      # over to JSON, you can:
+      #   
+      #   MassiveRecord::ORM::Coders::Chained.new(
+      #     MassiveRecord::ORM::Coders::JSON.new,
+      #     MassiveRecord::ORM::Coders::YAML.new
+      #   )
+      #
+      #   or
+      #
+      #   MassiveRecord::ORM::Base.coder = MassiveRecord::ORM::Coders::Chained.new({
+      #     :load_with => [MassiveRecord::ORM::Coders::JSON.new, MassiveRecord::ORM::Coders::JSON.new],
+      #     :dump_with => MassiveRecord::ORM::Coders::JSON.new
+      #   })
+      #
+      # With this set we'll first try the JSON coder, and if it fails with an
+      # encoding error we'll try the next one in the chain.
+      #
+      class Chained
+        attr_reader :loaders, :dumpers
+
+        def initialize(*args)
+          coders = args.extract_options!
+
+          @loaders = args.flatten
+          @dumpers = args.flatten
+
+          @loaders = [coders[:load_with]].flatten if coders[:load_with]
+          @dumpers = [coders[:dump_with]].flatten if coders[:dump_with]
+        end
+
+
+        def dump(object)
+          raise "We have no coders to dump with" if dumpers.empty?
+
+          dumpers.each do |coder|
+            begin
+              return coder.dump(object)
+            rescue
+            end
+          end
+
+          raise "Unable to encode #{object}. Tried encode it with: #{dumpers.collect(&:class).to_sentence}"
+        end
+
+
+        def load(data)
+          raise "We have no coders to load with" if loaders.empty?
+
+          loaders.each do |coder|
+            begin
+              return coder.load(data)
+            rescue
+            end
+          end
+
+          raise "Unable to parse #{data}. Tried loading it with: #{loaders.collect(&:class).to_sentence}"
+        end
+      end
+    end
+  end
+end