bigrecord 0.0.11 → 0.1.0

data/Rakefile

@@ -1,9 +1,9 @@
 require 'rubygems'
 
-DATA_STORES = ["hbase"]
+DATA_STORES = ["hbase", "cassandra"]
 ROOT = File.expand_path(File.dirname(__FILE__)) + '/'
 
-load 'tasks/data_store.rake'
-load 'tasks/gem.rake'
-load 'tasks/rdoc.rake'
-load 'tasks/spec.rake'
+require ROOT + 'tasks/data_store.rb'
+require ROOT + 'tasks/gem.rb'
+require ROOT + 'tasks/rdoc.rb'
+require ROOT + 'tasks/spec.rb'

data/VERSION

@@ -1 +1 @@
-0.0.11
+0.1.0

data/lib/big_record/base.rb

@@ -1,10 +1,9 @@
 module BigRecord
 
-  class Base < AbstractBase
+  class Base < Model
 
     attr_accessor :modified_attributes
 
-
     def self.inherited(child) #:nodoc:
       @@subclasses[self] ||= []
       @@subclasses[self] << child
@@ -388,7 +387,7 @@ module BigRecord
       end
 
       def table_name
-        (superclass == BigRecord::Base) ? @table_name : superclass.table_name
+        @table_name || superclass.table_name
       end
 
       def set_table_name(name)

data/lib/big_record/connection_adapters/cassandra_adapter.rb

@@ -0,0 +1,349 @@
+module BigRecord
+  class Base
+    def self.cassandra_connection(config) # :nodoc:
+      begin
+        require 'cassandra'
+      rescue LoadError => e
+        puts "[BigRecord] The 'cassandra' gem is needed for CassandraAdapter. Install it with: gem install cassandra"
+        raise e
+      end
+
+      config = config.symbolize_keys
+      
+      client = Cassandra.new(config[:keyspace], config[:servers])
+      ConnectionAdapters::CassandraAdapter.new(client, logger, [], config)
+    end
+  end
+
+  module ConnectionAdapters
+    class CassandraAdapter < AbstractAdapter
+      @@emulate_booleans = true
+      cattr_accessor :emulate_booleans
+
+      LOST_CONNECTION_ERROR_MESSAGES = [
+        "Server shutdown in progress",
+        "Broken pipe",
+        "Lost connection to HBase server during query",
+        "HBase server has gone away"
+      ]
+
+      # data types
+      TYPE_NULL     = 0x00;
+      TYPE_STRING   = 0x01; # utf-8 strings
+      TYPE_BOOLEAN  = 0x04; # delegate to YAML
+      TYPE_BINARY   = 0x07; # byte[] => no conversion
+
+      # string charset
+      CHARSET = "utf-8"
+
+      # utility constants
+      NULL = "\000"
+
+      def initialize(connection, logger, connection_options, config)
+        super(connection, logger)
+        @connection_options, @config = connection_options, config
+      end
+
+      def configuration
+        @config.clone
+      end
+
+      def adapter_name #:nodoc:
+        'Cassandra'
+      end
+
+      def supports_migrations? #:nodoc:
+        false
+      end
+
+      # CONNECTION MANAGEMENT ====================================
+
+      def disconnect!
+        @connection.disconnect!
+        super
+      end
+
+      # DATABASE STATEMENTS ======================================
+
+      def update_raw(table_name, row, values, timestamp)
+        result = nil
+        log "UPDATE #{table_name} SET #{values.inspect if values} WHERE ROW=#{row};" do
+          result = @connection.insert(table_name, row, data_to_cassandra_format(values), {:consistency => Cassandra::Consistency::QUORUM})
+        end
+        result
+      end
+
+      def update(table_name, row, values, timestamp)
+        serialized_collection = {}
+        values.each do |column, value|
+          serialized_collection[column] = serialize(value)
+        end
+        update_raw(table_name, row, serialized_collection, timestamp)
+      end
+
+      def get_raw(table_name, row, column, options={})
+        result = nil
+        log "SELECT (#{column}) FROM #{table_name} WHERE ROW=#{row};" do
+          super_column, name = column.split(":")
+          result = @connection.get(table_name, row, super_column, name)
+        end
+        result
+      end
+
+      def get(table_name, row, column, options={})
+        serialized_result = get_raw(table_name, row, column, options)
+        result = nil
+        if serialized_result.is_a?(Array)
+          result = serialized_result.collect{|e| deserialize(e)}
+        else
+          result = deserialize(serialized_result)
+        end
+        result
+      end
+
+      def get_columns_raw(table_name, row, columns, options={})
+        result = {}
+        
+        log "SELECT (#{columns.join(", ")}) FROM #{table_name} WHERE ROW=#{row};" do
+          requested_columns = columns_to_cassandra_format(columns)
+          super_columns = requested_columns.keys
+
+          if super_columns.size == 1 && requested_columns[super_columns.first].size > 0
+            column_names = requested_columns[super_columns.first]
+
+            values = @connection.get_columns(table_name, row, super_columns.first, column_names)
+
+            result["id"] = row if values && values.compact.size > 0
+            column_names.each_index do |id|
+              full_key = super_columns.first + ":" + column_names[id].to_s
+              result[full_key] = values[id] unless values[id].nil?
+            end
+          else
+            values = @connection.get_columns(table_name, row, super_columns)
+            result["id"] = row if values && values.compact.size > 0
+            super_columns.each_index do |id|
+              next if values[id].nil?
+              
+              values[id].each do |column_name, value|
+                next if value.nil?
+                
+                full_key = super_columns[id] + ":" + column_name
+                result[full_key] = value
+              end
+            end
+          end
+        end
+        result
+      end
+
+      def get_columns(table_name, row, columns, options={})
+        row_cols = get_columns_raw(table_name, row, columns, options)
+        return nil unless row_cols && !row_cols.empty?
+
+        result = {}
+        row_cols.each do |key,value|
+          begin
+            result[key] =
+            if key == 'id'
+              value
+            else
+              deserialize(value)
+            end
+          rescue Exception => e
+            puts "Could not load column value #{key} for row=#{row.name}"
+          end
+        end
+        result
+      end
+
+      def get_consecutive_rows_raw(table_name, start_row, limit, columns, stop_row = nil)
+        result = []
+        log "SCAN (#{columns.join(", ")}) FROM #{table_name} WHERE START_ROW=#{start_row} AND STOP_ROW=#{stop_row} LIMIT=#{limit};" do
+          options = {}
+          options[:start] = start_row if start_row
+          options[:finish] = stop_row if stop_row
+          options[:count] = limit if limit
+
+          keys = @connection.get_range(table_name, options)
+
+          # This will be refactored. Don't make fun of me yet.
+          if !keys.empty?
+            keys.each do |key|
+              row = {}
+              row["id"] = key.key
+
+              key.columns.each do |s_col|
+                super_column = s_col.super_column
+                super_column_name = super_column.name
+
+                super_column.columns.each do |column|
+                  full_key = super_column_name + ":" + column.name
+                  row[full_key] = column.value
+                end
+              end
+
+              result << row if row.keys.size > 1
+            end
+          end
+        end
+        result
+      end
+
+      def get_consecutive_rows(table_name, start_row, limit, columns, stop_row = nil)
+        rows = get_consecutive_rows_raw(table_name, start_row, limit, columns, stop_row)
+
+        result = rows.collect do |row|
+          cols = {}
+          row.each do |key,value|
+            begin
+              cols[key] = (key == "id") ? value : deserialize(value)
+            rescue Exception => e
+              puts "Could not load column value #{key} for row=#{row.name}"
+            end
+          end
+          cols
+        end
+        result
+      end
+
+      def delete(table_name, row)
+        result = nil
+        log "DELETE FROM #{table_name} WHERE ROW=#{row};" do
+          result = @connection.remove(table_name.to_s, row, {:consistency => Cassandra::Consistency::QUORUM})
+        end
+        result
+      end
+
+      def delete_all(table_name)
+        raise NotImplementedError
+      end
+
+      # SERIALIZATION STATEMENTS =================================
+
+      # Serialize the given value
+      def serialize(value)
+        case value
+        when NilClass then NULL
+        when String then build_serialized_value(TYPE_STRING, value)
+        else value.to_yaml
+        end
+      end
+
+      # Serialize an object in a given type
+      def build_serialized_value(type, value)
+        type.chr + value
+      end
+
+      # Deserialize the given string. This method supports both the pure YAML format and
+      # the type header format.
+      def deserialize(str)
+        return unless str
+
+        #	stay compatible with the old serialization code
+        #	YAML documents start with "--- " so if we find that sequence at the beginning we
+        #	consider it as a serialized YAML value, else it's the new format with the type header
+        if str[0..3] == "--- "
+          YAML::load(str) if str
+        else
+          deserialize_with_header(str)
+        end
+      end
+
+      # Deserialize the given string assumed to be in the type header format.
+      def deserialize_with_header(data)
+        return unless data and data.size >= 2
+
+        # the type of the data is encoded in the first byte
+        type = data[0];
+
+        case type
+        when TYPE_NULL then nil
+        when TYPE_STRING then data[1..-1]
+        when TYPE_BINARY then data[1..-1]
+        else data
+        end
+      end
+      
+    protected
+
+      def data_to_cassandra_format(data = {})
+        super_columns = {}
+        
+        data.each do |name, value|
+          super_column, column = name.split(":")
+          super_columns[super_column.to_s] = {} unless super_columns.has_key?(super_column.to_s)
+          super_columns[super_column.to_s][column.to_s] = value
+        end
+
+        return super_columns
+      end
+
+      def columns_to_cassandra_format(column_names = [])
+        super_columns = {}
+
+        column_names.each do |name|
+          super_column, sub_column = name.split(":")
+          
+          super_columns[super_column.to_s] = [] unless super_columns.has_key?(super_column.to_s)
+          super_columns[super_column.to_s] << sub_column
+        end
+
+        return super_columns
+      end
+
+      def log(str, name = nil)
+        if block_given?
+          if @logger and @logger.level <= Logger::INFO
+            result = nil
+            seconds = Benchmark.realtime { result = yield }
+            @runtime += seconds
+            log_info(str, name, seconds)
+            result
+          else
+            yield
+          end
+        else
+          log_info(str, name, 0)
+          nil
+        end
+      rescue Exception => e
+        # Log message and raise exception.
+        # Set last_verfication to 0, so that connection gets verified
+        # upon reentering the request loop
+        @last_verification = 0
+        message = "#{e.class.name}: #{e.message}: #{str}"
+        log_info(message, name, 0)
+        raise e
+      end
+
+      def log_info(str, name, runtime)
+        return unless @logger
+
+        @logger.debug(
+          format_log_entry(
+            "#{name.nil? ? "CASSANDRA" : name} (#{sprintf("%f", runtime)})",
+            str.gsub(/ +/, " ")
+          )
+        )
+      end
+
+      def format_log_entry(message, dump = nil)
+        if BigRecord::Base.colorize_logging
+          if @@row_even
+            @@row_even = false
+            message_color, dump_color = "4;36;1", "0;1"
+          else
+            @@row_even = true
+            message_color, dump_color = "4;35;1", "0"
+          end
+
+          log_entry = "  \e[#{message_color}m#{message}\e[0m   "
+          log_entry << "\e[#{dump_color}m%#{String === dump ? 's' : 'p'}\e[0m" % dump if dump
+          log_entry
+        else
+          "%s  %s" % [message, dump]
+        end
+      end
+    end
+  end
+end

data/lib/big_record/connection_adapters/column.rb

@@ -32,7 +32,7 @@ module BigRecord
     #
     # == Types and Options
     #
-    # @see BigRecord::AbstractBase.column
+    # @see BigRecord::Model.column
     #
     class Column
       module Format

data/lib/big_record/connection_adapters.rb

@@ -9,3 +9,4 @@ require dir + '/abstract/connection_specification'
 require dir + '/abstract_adapter'
 require dir + '/hbase_adapter'
 require dir + '/hbase_rest_adapter'
+require dir + '/cassandra_adapter'

data/lib/big_record/dynamic_schema.rb

@@ -44,7 +44,9 @@ module BigRecord
 
     # Returns the column object for the named attribute.
     def column_for_attribute_with_dynamic_schema(name)
-      self.columns_hash[name.to_s]
+      name_string = name.to_s
+      self.columns_hash[name_string] || self.columns_hash["#{self.class.default_column_prefix}#{name_string}"] ||
+        self.columns.select{|c|c.alias==name_string}.first
     end
 
     # Initializes the attributes array with keys matching the columns from the linked table and

data/lib/big_record/embedded.rb

@@ -123,7 +123,7 @@ module BigRecord
   # Now any subsequent access to that book object we just saved to will have
   # a WebLink record available with it.
   #
-  class Embedded < AbstractBase
+  class Embedded < Model
 
     def initialize(attrs = nil)
       super

data/lib/big_record/family_span_columns.rb

@@ -64,7 +64,7 @@ module BigRecord
       # ignore methods '=' and '?' (e.g. 'normalized_srf_ief:231=')
       return if name =~ /=|\?$/
 
-      column = self.columns_hash[name]
+      column = column_for_attribute_without_family_span_columns(name)
       unless column
         family = BigRecord::ConnectionAdapters::Column.extract_family(name)
         column = self.columns_hash[family] if family

data/lib/big_record/{abstract_base.rb → model.rb}

@@ -52,7 +52,7 @@ module BigRecord
     end
   end
 
-  class AbstractBase
+  class Model
     require 'rubygems'
     require 'uuidtools'
 
@@ -1069,7 +1069,7 @@ private
       end
 
       def default_columns
-        raise NotImplemented
+        {}
       end
 
       def default_views

data/lib/big_record.rb

@@ -36,7 +36,7 @@ rescue LoadError
 end
 
 require dir + '/routing_ext'
-require dir + '/abstract_base'
+require dir + '/model'
 require dir + '/base'
 require dir + '/embedded'
 require dir + '/validations'

data/spec/connections/bigrecord.yml

@@ -1,7 +1,7 @@
-hbase:
+hbase_rest:
   adapter: hbase_rest
   api_address: http://localhost:8080
-hbase_brd:
+hbase:
   adapter: hbase
   zookeeper_quorum: localhost
   zookeeper_client_port: 2181
@@ -9,7 +9,7 @@ hbase_brd:
   drb_port: 50001
 cassandra:
   adapter: cassandra
-  address: localhost
-  port: 9160
-  drb_host: localhost
-  drb_port: 50002
+  keyspace: Bigrecord
+  servers:
+    - localhost:9160
+    - 127.0.0.1:9160

data/spec/unit/adapters/hbase_adapter_spec.rb

@@ -5,8 +5,6 @@ describe BigRecord::ConnectionAdapters::HbaseAdapter do
 
   before do
     # Make sure the connection is defined in spec/connections/bigrecord.yml
-    BigRecord::Base.establish_connection 'hbase'
-
     @adapter = BigRecord::Base.connection
   end
 

data/spec/unit/attributes_spec.rb

@@ -1,5 +1,5 @@
 # Defined as a shared spec because embedded_spec uses it as well
-describe BigRecord::AbstractBase, :shared => true do
+describe BigRecord::Model, :shared => true do
 
   before(:all) do
     Book.delete_all
@@ -174,7 +174,7 @@ describe BigRecord::AbstractBase, :shared => true do
     end
 
     it 'should be handled properly' do
-      pending "this still needs to be implemented in BigRecord::AbstractBase"
+      pending "this still needs to be implemented in BigRecord::Model"
 
       # readonly is the readonly attribute here
       @company = Company.new(:name => "The Company", :address => "Unknown", :readonly => "secret")

data/spec/unit/columns_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 require File.expand_path(File.join(File.dirname(__FILE__), 'attributes_spec'))
 
 describe BigRecord::Base do
-  it_should_behave_like "BigRecord::AbstractBase"
+  it_should_behave_like "BigRecord::Model"
 
   describe 'column functionality' do
 

data/spec/unit/deletion_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe BigRecord::Base do
+
+  class FlaggedDeletionBook < Book
+    column :deleted, :boolean
+  end
+
+  before(:all) do
+    FlaggedDeletionBook.delete_all
+    @book = FlaggedDeletionBook.create(:title => "I Am Legend", :author => "Richard Matheson")
+    @book.destroy
+  end
+
+  after(:all) do
+    FlaggedDeletionBook.delete_all
+  end
+
+  describe "flagged deletion functionality" do
+
+    it "should not be found by normal finders" do
+      lambda {
+        FlaggedDeletionBook.find(@book)
+      }.should raise_error BigRecord::RecordNotFound
+    end
+
+    it "should be found using the :include_deleted option" do
+      lambda {
+        FlaggedDeletionBook.find(@book, :include_deleted => true)
+      }.should_not raise_error
+    end
+
+  end
+
+end

data/spec/unit/embedded_spec.rb

@@ -12,7 +12,7 @@ describe BigRecord::Embedded do
     Zoo.delete_all
   end
 
-  it_should_behave_like "BigRecord::AbstractBase"
+  it_should_behave_like "BigRecord::Model"
 
   describe "embedded within a BigRecord::Base model" do
 
@@ -40,4 +40,14 @@ describe BigRecord::Embedded do
 
   end
 
+  describe "standalone behavior" do
+
+    it "should generate the id in the constructor" do
+      link = Embedded::WebLink.new
+      link.attributes['id'].should_not be_nil
+      link.id.should_not be_nil
+    end
+
+  end
+
 end

data/tasks/{gem.rake → gem.rb}

@@ -6,7 +6,7 @@ begin
     gemspec.authors = ["openplaces.org"]
     gemspec.email = "bigrecord@openplaces.org"
     gemspec.homepage = "http://www.bigrecord.org"
-    gemspec.summary = "Object mapper for supporting column-oriented data stores (supports #{DATA_STORES.join(" ")}) in Ruby on Rails."
+    gemspec.summary = "Object mapper for supporting column-oriented data stores (supports #{DATA_STORES.join(", ")}) in Ruby on Rails."
     gemspec.description = "BigRecord is built from ActiveRecord, and intended to seamlessly integrate into your Ruby on Rails applications."
     gemspec.files = FileList["{examples,guides,generators,lib,rails,spec,tasks}/**/*","init.rb","install.rb","Rakefile","VERSION"].to_a
     gemspec.extra_rdoc_files = FileList["guides/**/*","LICENSE","README.rdoc"].to_a

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: bigrecord
 version: !ruby/object:Gem::Version 
-  version: 0.0.11
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
 platform: ruby
 authors: 
 - openplaces.org
@@ -9,49 +14,59 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-12 00:00:00 -05:00
+date: 2010-04-27 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :development
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: uuidtools
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 0
         version: 2.0.0
-    version: 
+  type: :runtime
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: activesupport
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: activerecord
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 0
         version: "0"
-    version: 
+  type: :runtime
+  version_requirements: *id004
 description: BigRecord is built from ActiveRecord, and intended to seamlessly integrate into your Ruby on Rails applications.
 email: bigrecord@openplaces.org
 executables: []
@@ -82,7 +97,6 @@ files:
 - init.rb
 - install.rb
 - lib/big_record.rb
-- lib/big_record/abstract_base.rb
 - lib/big_record/action_view_extensions.rb
 - lib/big_record/ar_associations.rb
 - lib/big_record/ar_associations/association_collection.rb
@@ -111,6 +125,7 @@ files:
 - lib/big_record/connection_adapters/abstract/database_statements.rb
 - lib/big_record/connection_adapters/abstract/quoting.rb
 - lib/big_record/connection_adapters/abstract_adapter.rb
+- lib/big_record/connection_adapters/cassandra_adapter.rb
 - lib/big_record/connection_adapters/column.rb
 - lib/big_record/connection_adapters/hbase_adapter.rb
 - lib/big_record/connection_adapters/hbase_rest_adapter.rb
@@ -122,6 +137,7 @@ files:
 - lib/big_record/family_span_columns.rb
 - lib/big_record/fixtures.rb
 - lib/big_record/migration.rb
+- lib/big_record/model.rb
 - lib/big_record/routing_ext.rb
 - lib/big_record/timestamp.rb
 - lib/big_record/validations.rb
@@ -158,6 +174,7 @@ files:
 - spec/unit/attributes_spec.rb
 - spec/unit/br_associations_spec.rb
 - spec/unit/columns_spec.rb
+- spec/unit/deletion_spec.rb
 - spec/unit/embedded_spec.rb
 - spec/unit/find_spec.rb
 - spec/unit/hash_helper_spec.rb
@@ -166,10 +183,10 @@ files:
 - spec/unit/scanner_spec.rb
 - spec/unit/validations_spec.rb
 - tasks/bigrecord_tasks.rake
-- tasks/data_store.rake
-- tasks/gem.rake
-- tasks/rdoc.rake
-- tasks/spec.rake
+- tasks/data_store.rb
+- tasks/gem.rb
+- tasks/rdoc.rb
+- tasks/spec.rb
 - LICENSE
 - README.rdoc
 has_rdoc: true
@@ -185,20 +202,22 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: Object mapper for supporting column-oriented data stores (supports hbase) in Ruby on Rails.
+summary: Object mapper for supporting column-oriented data stores (supports hbase, cassandra) in Ruby on Rails.
 test_files: []