hyper_record 0.2.8

data/lib/hypertable/thrift_client.rb

@@ -0,0 +1,94 @@
+# include path hack
+$:.push(File.dirname(__FILE__) + '/gen-rb')
+
+require 'thrift'
+require 'thrift/protocol/binary_protocol_accelerated'
+require 'hql_service'
+require File.dirname(__FILE__) + '/thrift_transport_monkey_patch'
+
+module Hypertable
+  class ThriftClient < ThriftGen::HqlService::Client
+    def initialize(host, port = 38080, timeout_ms = 20000, do_open = true)
+      socket = Thrift::Socket.new(host, port, timeout_ms)
+      @transport = Thrift::FramedTransport.new(socket)
+      protocol = Thrift::BinaryProtocolAccelerated.new(@transport)
+      super(protocol)
+      open() if do_open
+    end
+
+    def open()
+      @transport.open()
+      @do_close = true
+    end
+
+    def close()
+      @transport.close() if @do_close
+    end
+
+    # more convenience methods
+
+    def with_scanner(table, scan_spec)
+      scanner = open_scanner(table, scan_spec, true)
+      begin
+        yield scanner
+      ensure
+        close_scanner(scanner)
+      end
+    end
+
+    def with_mutator(table, flags=0, flush_interval=0)
+      mutator = open_mutator(table, flags, flush_interval);
+      begin
+        yield mutator
+      ensure
+        close_mutator(mutator, 0)
+      end
+    end
+
+    # scanner iterator
+    def each_cell(scanner)
+      cells = next_cells(scanner);
+
+      while (cells.size > 0)
+        cells.each {|cell| yield cell}
+        cells = next_cells(scanner);
+      end
+    end
+
+    def each_cell_as_arrays(scanner)
+      cells = next_cells_as_arrays(scanner);
+
+      while (cells.size > 0)
+        cells.each {|cell| yield cell}
+        cells = next_cells_as_arrays(scanner);
+      end
+    end
+
+    def each_row(scanner)
+      row = next_row(scanner);
+
+      while (row && row.size > 0)
+        yield row
+        row = next_row(scanner);
+      end
+    end
+
+    def each_row_as_arrays(scanner)
+      row = next_row_as_arrays(scanner);
+
+      while (row && row.size > 0)
+        yield row
+        row = next_row_as_arrays(scanner);
+      end
+    end
+  end
+
+  def self.with_thrift_client(host, port, timeout_ms = 20000)
+    client = ThriftClient.new(host, port, timeout_ms)
+    begin
+      yield client
+    ensure
+      client.close()
+    end
+  end
+end

data/lib/hypertable/thrift_transport_monkey_patch.rb

@@ -0,0 +1,29 @@
+# Monkey patch for Thrift::FramedTransport typically found in:
+# /usr/local/lib/ruby/site_ruby/1.8/thrift/transport/framed_transport.rb
+#
+# Rev 765279 (current recommended Thrift rev for Hypertable) does not
+# reset buffer state when the connection is reopened.  This patch will
+# be submitted to Thrift once it has been tested for a few weeks in 
+# production.
+
+module Thrift
+  class FramedTransport < BaseTransport
+    def initialize(transport, read=true, write=true)
+      reset_state
+      @transport = transport
+      @read = read
+      @write = write
+    end
+
+    def reset_state
+      @rbuf = ''
+      @wbuf = ''
+      @index = 0
+    end
+
+    def open
+      reset_state
+      @transport.open
+    end
+  end
+end

data/spec/fixtures/pages.yml

@@ -0,0 +1,8 @@
+page_1:
+  ROW: page_1
+  name: LOLcats and more
+  url: http://www.icanhascheezburger.com
+page_2:
+  ROW: page_2
+  name: ESPN
+  url: http://espn.go.com

data/spec/fixtures/qualified_pages.yml

@@ -0,0 +1 @@
+# intentionally left blank

data/spec/lib/associations_spec.rb

@@ -0,0 +1,235 @@
+require File.join(File.dirname(__FILE__), '../spec_helper.rb')
+
+class Book < ActiveRecord::HyperBase
+  has_many :chapters
+  has_and_belongs_to_many :authors
+  qualified_column :author_id, :qualifiers => ['.*']
+  qualified_column :chapter_id, :qualifiers => ['.*']
+
+  def self.create_table
+    hql = "CREATE TABLE #{table_name} (
+      'title',
+      'author_id',
+      'chapter_id'
+    )"
+    connection.execute(hql)
+  end
+end
+
+class Chapter < ActiveRecord::HyperBase
+  belongs_to :book
+
+  def self.create_table
+    hql = "CREATE TABLE #{table_name} (
+      'title',
+      'book_id' MAX_VERSIONS=1
+    )"
+    connection.execute(hql)
+  end
+end
+
+class Author < ActiveRecord::HyperBase
+  has_and_belongs_to_many :books
+  qualified_column :book_id, :qualifiers => ['.*']
+
+  def self.create_table
+    hql = "CREATE TABLE #{table_name} (
+      'name',
+      'book_id'
+    )"
+    connection.execute(hql)
+  end
+end
+
+module ActiveRecord
+  module HyperRecord
+    describe HyperBase, '.has_and_belongs_to_many' do
+      before(:each) do
+        Book.drop_table
+        Author.drop_table
+        Book.create_table
+        Author.create_table
+
+        @b = Book.new({:title => "Curious George and the Electric Fence"})
+        @b.ROW = 'curious_george'
+        @b.save!
+
+        @a1 = Author.new({:name => 'Irvine Welsh', :ROW => 'irvine_welsh'})
+        @a1.save!
+        @a2 = Author.new({:name => 'Douglas Adams', :ROW => 'douglas_adams'})
+        @a2.save!
+      end
+
+      it "should support addition of association elements using <<" do
+        @b.authors.should be_empty
+        @b.authors << @a1
+        @b.authors.should == [@a1]
+        @b.reload
+        @b.authors.should == [@a1]
+        @a1.books.should == [@b]
+      end
+
+      it "should allow multiple objects to be associated through HABTM" do
+        @b.authors.should be_empty
+        @b.authors << @a1
+        @b.authors << @a2
+        @b.authors.map{|x| x.ROW}.sort.should == [@a1, @a2].map{|x| x.ROW}.sort
+        @b.reload
+        @b.authors.map{|x| x.ROW}.sort.should == [@a1, @a2].map{|x| x.ROW}.sort
+        @a1.books.map{|x| x.ROW}.sort.should == [@b].map{|x| x.ROW}.sort
+        @a2.books.map{|x| x.ROW}.sort.should == [@b].map{|x| x.ROW}.sort
+      end
+
+      it "should allow removal of association elements using clear" do
+        @b.authors.should be_empty
+        @b.authors << @a1
+        @b.authors.should == [@a1]
+        @b.authors.clear
+        @b.reload
+        @b.authors.should be_empty
+      end
+
+      it "should allow an object to be created through the association" do
+        a = @b.authors.create({:name => 'Harper Lee', :ROW => 'harper_lee'})
+        a.new_record?.should be_false
+        a.reload
+        a.books.should == [@b]
+      end
+
+      it "should allow an object to be newed through the association" do
+        @b.authors.should be_empty
+        a = @b.authors.new({:name => 'Harper Lee', :ROW => 'harper_lee'})
+        a.new_record?.should be_true
+        a.save!
+        a.reload
+        a.books.should be_empty
+      end
+
+      it "should allow removal of association elements using delete" do
+        @b.authors.should be_empty
+        @b.authors << @a1
+        @b.authors << @a2
+        @b.authors.delete(@a2)
+        @b.reload
+        @b.authors.should == [@a1]
+      end
+
+      it "should clean up association cells when an object is destroyed" do
+        @b.authors.should be_empty
+        @b.authors << @a1
+        @b.author_id.should == {@a1.ROW => 1}
+        @a1.destroy
+        @b.reload
+        @b.authors.should be_empty
+        @b.author_id.should == {}
+      end
+    end
+
+    describe HyperBase, '.belongs_to_and_has_many' do
+      before(:each) do
+        Book.drop_table
+        Chapter.drop_table
+        Book.create_table
+        Chapter.create_table
+
+        @b = Book.new({:title => "Curious George and the Electric Fence"})
+        @b.ROW = 'curious_george'
+        @b.save!
+
+        @c1 = Chapter.new({:title => 'Ch 1', :ROW => 'c1'})
+        @c1.save!
+        @b.chapters << @c1
+        @c2 = Chapter.new({:title => 'Ch 2', :ROW => 'c2'})
+        @c2.save!
+      end
+
+      it "should allow belongs_to assocs between two hyperrecord objects" do
+        @c1.book.should == @b
+        @c2.book.should == nil
+        @b.chapters.to_a.should == [@c1]
+        @b.chapters << @c2
+        @b.reload
+        @b.chapters.to_a.should == [@c1, @c2]
+        @c2.book_id.should == @b.ROW
+      end
+
+      it "should clear has_many associations when requested" do
+        @b.chapters.to_a.should == [@c1]
+        @b.chapters.clear
+        @b.reload
+        @b.chapters.to_a.should be_empty
+        @b.chapter_id.should == {}
+      end
+
+      it "should allow new records through has_many but note that the association cells are not written, so this method is to be avoided" do
+        @b.chapters.to_a.should == [@c1]
+        c = @b.chapters.new({:ROW => 'c3', :title => 'Ch 3'})
+        c.new_record?.should be_true
+        c.save!
+        @b.reload
+        @b.chapters.length.should == 1
+        @b.chapters.should == [@c1]
+        @b.chapter_id.should == {@c1.ROW => "1"}
+        @b.chapters << c
+        @b.reload
+        @b.chapters.should == [@c1, c]
+        @b.chapter_id.should == {@c1.ROW => "1", c.ROW => "1"}
+      end
+
+      it "should allow create records through has_many" do
+        @b.chapters.to_a.should == [@c1]
+        c = @b.chapters.create({:ROW => 'c3', :title => 'Ch 3'})
+        c.new_record?.should be_false
+        @b.reload
+        @b.chapters.length.should == 2
+        @b.chapters.should == [@c1, c]
+      end
+
+      it "should allow new records using << has_many" do
+        @b.chapters.to_a.should == [@c1]
+        c = Chapter.new({:ROW => 'c3', :title => 'Ch 3'})
+        c.new_record?.should be_true
+        @b.chapters << c
+        @b.reload
+        @b.chapters.length.should == 2
+        @b.chapters.should == [@c1, c]
+        c.reload
+        c.book.should == @b
+      end
+
+      it "should support remove of has_many records through delete" do
+        @b.chapters.to_a.should == [@c1]
+        c = @b.chapters.create({:ROW => 'c3', :title => 'Ch 3'})
+        @b.reload
+        @b.chapters.should == [@c1, c]
+        @b.chapter_id.should == {@c1.ROW => "1", c.ROW => "1"}
+        @b.chapters.delete(@c1)
+        @b.reload
+        @b.chapters.should == [c]
+        @b.chapter_id.should == {c.ROW => "1"}
+      end
+
+      it "should update belongs_to id value on assignment" do
+        @c2.book_id.should be_blank
+        @c2.book = @b
+        @c2.save!
+        @c2.reload
+        @c2.book_id.should == @b.id
+      end
+
+      it "should silently ignore eager loading of belongs_to associations" do
+        c1 = Chapter.find(@c1.ROW, :include => [:book])
+        # note: no exception, loaded? is marked as true and assoc still works
+        c1.book.loaded?.should be_true
+        c1.book.should == @b
+      end
+
+      it "should silently ignore eager loading of has_many associations" do
+        b = Book.find(@b.ROW, :include => [:chapters])
+        # note: no exception, loaded? is marked as false and assoc still works
+        b.chapters.loaded?.should be_false
+        b.chapters.to_a.should == [@c1]
+      end
+    end
+  end
+end