massive_record 0.1.0

data/lib/massive_record/wrapper/scanner.rb

@@ -0,0 +1,50 @@
+module MassiveRecord
+  module Wrapper
+    class Scanner
+      
+      attr_accessor :connection, :table_name, :column_family_names, :opened_scanner
+      attr_accessor :start_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
+        @created_at = opts[:created_at].to_s
+        @limit = opts[:limit] || 10
+      end
+      
+      def open
+        if created_at.empty?
+          self.opened_scanner = connection.scannerOpen(table_name, start_key, formatted_column_family_names)
+        else
+          self.opened_scanner = connection.scannerOpenTs(table_name, start_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{|result| populate_row(result)}
+      end
+      
+      def populate_row(result)
+        Row.populate_from_trow_result(result, connection, table_name, column_family_names)
+      end
+      
+    end
+  end
+end

data/lib/massive_record/wrapper/table.rb

@@ -0,0 +1,148 @@
+module MassiveRecord
+  module Wrapper
+    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 = 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], 
+          :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 = {})
+        scanner(opts) do |s|
+          s.fetch_rows(opts)
+        end
+      end
+      
+      def first(opts = {})
+        all(opts.merge(:limit => 1)).first
+      end
+      
+      def find(*args)
+        arg  = args[0]
+        opts = args[1] || {}
+        arg.is_a?(Array) ? arg.collect{|id| first(opts.merge(:start => id))} : first(opts.merge(:start => arg))
+      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

data/lib/massive_record/wrapper/tables_collection.rb

@@ -0,0 +1,13 @@
+module MassiveRecord
+  module Wrapper
+    class TablesCollection < Array
+    
+      attr_accessor :connection
+    
+      def load(table_name)
+        Table.new(connection, table_name)
+      end
+    
+    end
+  end
+end

data/massive_record.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "massive_record/version"
+
+Gem::Specification.new do |s|
+  s.name              = "massive_record"
+  s.version           = MassiveRecord::VERSION
+  s.platform          = Gem::Platform::RUBY
+  s.authors           = ["Companybook"]
+  s.email             = %q{geeks@companybook.no}
+  s.homepage          = %q{http://github.com/CompanyBook/massive_record}
+  s.summary           = %q{HBase Ruby client API}
+  s.description       = %q{HBase Ruby client API}
+  s.rubyforge_project = "massive_record"
+
+
+  s.add_dependency "thrift", ">= 0.5.0"
+  s.add_dependency "activesupport"
+  s.add_dependency "activemodel"
+
+  s.add_development_dependency "rspec", ">= 2.1.0"
+
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/config.yml.example

@@ -0,0 +1,4 @@
+# Please copy the content of this file to ./config.yml to be able to run all the tests
+host: somewhere.compute.amazonaws.com
+port: 9090
+table: massive_record_people_test

data/spec/orm/cases/attribute_methods_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+require 'orm/models/person'
+
+describe "attribute methods" do
+  before do
+    @model = Person.new :id => 5, :name => "John", :age => 15
+  end
+
+  it "should define reader method" do
+    @model.name.should == "John"
+  end
+
+  it "should define writer method" do
+    @model.name = "Bar"
+    @model.name.should == "Bar"
+  end
+
+  it "should be possible to write attributes" do
+    @model.write_attribute :name, "baaaaar"
+    @model.name.should == "baaaaar"
+  end
+
+  it "should be possible to read attributes" do
+    @model.read_attribute(:name).should == "John"
+  end
+  
+  it "should contains the id in the attributes getter" do
+    @model.attributes.should include("id")
+  end
+
+  describe "#attributes=" do
+    it "should simply return if incomming value is not a hash" do
+      @model.attributes = "FOO BAR"
+      @model.attributes.keys.should include("name")
+    end
+
+    it "should mass assign attributes" do
+      @model.attributes = {:name => "Foo", :age => 20}
+      @model.name.should == "Foo"
+      @model.age.should == 20
+    end
+
+    it "should raise an error if we encounter an unkown attribute" do
+      lambda { @model.attributes = {:unkown => "foo"} }.should raise_error MassiveRecord::ORM::UnkownAttributeError
+    end
+  end
+end

data/spec/orm/cases/auto_generate_id_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'orm/models/person'
+
+describe "auto setting of ids" do
+  include MockMassiveRecordConnection
+
+  before do
+    @person = Person.new :name => "thorbjorn", :age => 29
+  end
+
+  it "should return nil as default if no default_id is defined" do
+    @person.id.should be_nil
+  end
+
+  it "should have id based on whatever default_id defines" do
+    Person.class_eval do
+      def default_id
+        [name, age].join("-")
+      end
+    end
+
+    @person.id.should == "thorbjorn-29"
+
+    Person.class_eval { undef_method :default_id }
+  end
+
+  it "should have id based on whatever default_id defines, even if it is private method" do
+    Person.class_eval do
+      private
+      def default_id
+        [name, age].join("-")
+      end
+    end
+
+    @person.id.should == "thorbjorn-29"
+
+    Person.class_eval { undef_method :default_id }
+  end
+
+  describe "#next_id" do
+    it "should ask IdFactory for a next id for self" do
+      Person.class_eval do
+        def default_id
+          next_id
+        end
+      end
+
+      MassiveRecord::ORM::IdFactory.should_receive(:next_for).with(Person).and_return(1)
+      @person.id.should == "1"
+
+      Person.class_eval { undef_method :default_id }
+    end
+  end
+end

data/spec/orm/cases/base_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper'
+require 'orm/models/test_class'
+
+describe MassiveRecord::ORM::Base do
+  include MockMassiveRecordConnection
+
+  describe "table name" do
+    before do
+      TestClass.reset_table_name_configuration!
+    end
+
+    it "should have a table name" do
+      TestClass.table_name.should == "test_classes"
+    end
+    
+    it "should have a table name with prefix" do
+      TestClass.table_name_prefix = "prefix_"
+      TestClass.table_name.should == "prefix_test_classes"
+    end
+    
+    it "should have a table name with suffix" do
+      TestClass.table_name_suffix = "_suffix"
+      TestClass.table_name.should == "test_classes_suffix"
+    end
+    
+    describe "set explicitly" do
+      it "should be able to set it" do
+        TestClass.table_name = "foo"
+        TestClass.table_name.should == "foo"
+      end
+
+      it "should have a table name with prefix" do
+        TestClass.table_name = "foo"
+        TestClass.table_name_prefix = "prefix_"
+        TestClass.table_name.should == "prefix_foo"
+      end
+      
+      it "should have a table name with suffix" do
+        TestClass.table_name = "foo"
+        TestClass.table_name_suffix = "_suffix"
+        TestClass.table_name.should == "foo_suffix"
+      end
+
+      it "should be possible to call set_table_name" do
+        TestClass.set_table_name("foo")
+        TestClass.table_name.should == "foo"
+      end
+    end
+  end
+
+  it "should have a model name" do
+    TestClass.model_name.should == "TestClass"
+  end
+
+  describe "#initialize" do
+    it "should take a set of attributes and make them readable" do
+      model = TestClass.new :foo => :bar
+      model.foo.should == :bar
+    end
+
+    it "should initialize an object via init_with()" do
+      model = TestClass.allocate
+      model.init_with 'attributes' => {:foo => :bar}
+      model.foo.should == :bar
+    end
+
+    it "should stringify keys set on attributes" do
+      model = TestClass.allocate
+      model.init_with 'attributes' => {:foo => :bar}
+      model.attributes.keys.should include("foo")
+    end
+
+    it "should return nil as id by default" do
+      TestClass.new.id.should be_nil
+    end
+  end
+
+  describe "equality" do
+    it "should evaluate one object the same as equal" do
+      person = Person.find(1)
+      person.should == person
+    end
+
+    it "should evaluate two objects of same class and id as ==" do
+      Person.find(1).should == Person.find(1)
+    end
+
+    it "should evaluate two objects of same class and id as eql?" do
+      Person.find(1).eql?(Person.find(1)).should be_true
+    end
+
+    it "should not be equal if ids are different" do
+      Person.find(1).should_not == Person.find(2)
+    end
+
+    it "should not be equal if class are different" do
+      TestClass.find(1).should_not == Person.find(2)
+    end
+  end
+
+  describe "#to_param" do
+    it "should return nil if new record" do
+      TestClass.new.to_param.should be_nil
+    end
+
+    it "should return the id if persisted" do
+      TestClass.create!(:id => 1).to_param.should == "1"
+    end
+  end
+
+  describe "#to_key" do
+    it "should return nil if new record" do
+      TestClass.new.to_key.should be_nil
+    end
+
+    it "should return id in an array persisted" do
+      TestClass.create!(:id => "1").to_key.should == ["1"]
+    end
+  end
+
+  it "should be able to freeze objects" do
+    test_object = TestClass.new
+    test_object.freeze
+    test_object.should be_frozen
+  end
+
+
+  describe "#inspect" do
+    before do
+      @person = Person.new({
+        :name => "Bob",
+        :age => 3,
+        :date_of_birth => Date.today
+      })
+    end
+
+    it "should wrap inspection string inside of #< >" do
+      @person.inspect.should match(/^#<.*?>$/);
+    end
+
+    it "should contain it's class name" do
+      @person.inspect.should include("Person")
+    end
+
+    it "should start with the record's id if it has any" do
+      @person.id = 3
+      @person.inspect.should include "#<Person id: 3,"
+    end
+
+    it "should start with the record's id if it has any" do
+      @person.id = nil
+      @person.inspect.should include "#<Person id: nil,"
+    end
+
+    it "should contain a nice list of it's attributes" do
+      i = @person.inspect
+      i.should include(%q{name: "Bob"})
+      i.should include(%q{age: 3})
+    end
+  end
+
+  describe "attribute read / write alias" do
+    before do
+      @test_object = TestClass.new :foo => 'bar'
+    end
+
+    it "should read attributes by object[attr]" do
+      @test_object[:foo].should == 'bar'
+    end
+
+    it "should write attributes by object[attr] = new_value" do
+      @test_object["foo"] = "new_value"
+      @test_object.foo.should == "new_value"
+    end
+  end
+end