bigrecord 0.0.5

data/lib/big_record/connection_adapters/abstract/connection_specification.rb

@@ -0,0 +1,279 @@
+require 'set'
+
+module BigRecord
+  class Base
+    class ConnectionSpecification #:nodoc:
+      attr_reader :config, :adapter_method
+      def initialize (config, adapter_method)
+        @config, @adapter_method = config, adapter_method
+      end
+    end
+
+    # Check for activity after at least +verification_timeout+ seconds.
+    # Defaults to 0 (always check.)
+    cattr_accessor :verification_timeout, :instance_writer => false
+    @@verification_timeout = 0
+
+    # The class -> [adapter_method, config] map
+    @@defined_connections = {}
+
+    # The class -> thread id -> adapter cache. (class -> adapter if not allow_concurrency)
+    @@active_connections = {}
+
+    class << self
+      # Retrieve the connection cache.
+      def thread_safe_active_connections #:nodoc:
+        @@active_connections[Thread.current.object_id] ||= {}
+      end
+
+      def single_threaded_active_connections #:nodoc:
+        @@active_connections
+      end
+
+      # pick up the right active_connection method from @@allow_concurrency
+      if @@allow_concurrency
+        alias_method :active_connections, :thread_safe_active_connections
+      else
+        alias_method :active_connections, :single_threaded_active_connections
+      end
+
+      # set concurrency support flag (not thread safe, like most of the methods in this file)
+      def allow_concurrency=(threaded) #:nodoc:
+        logger.debug "allow_concurrency=#{threaded}" if logger
+        return if @@allow_concurrency == threaded
+        clear_all_cached_connections!
+        @@allow_concurrency = threaded
+        method_prefix = threaded ? "thread_safe" : "single_threaded"
+        sing = (class << self; self; end)
+        [:active_connections, :scoped_methods].each do |method|
+          sing.send(:alias_method, method, "#{method_prefix}_#{method}")
+        end
+        log_connections if logger
+      end
+
+      def active_connection_name #:nodoc:
+        @active_connection_name ||=
+           if active_connections[name] || @@defined_connections[name]
+             name
+           elsif self == BigRecord::Base
+             nil
+           else
+             superclass.active_connection_name
+           end
+      end
+
+      def clear_active_connection_name #:nodoc:
+        @active_connection_name = nil
+        subclasses.each { |klass| klass.clear_active_connection_name }
+      end
+
+      # Returns the connection currently associated with the class. This can
+      # also be used to "borrow" the connection to do database work unrelated
+      # to any of the specific Active Records.
+      def connection
+        if @active_connection_name && (conn = active_connections[@active_connection_name])
+          conn
+        else
+          # retrieve_connection sets the cache key.
+          conn = retrieve_connection
+          active_connections[@active_connection_name] = conn
+        end
+      end
+
+      # Clears the cache which maps classes to connections.
+      def clear_active_connections!
+        clear_cache!(@@active_connections) do |name, conn|
+          conn.disconnect!
+        end
+      end
+
+      # Clears the cache which maps classes
+      def clear_reloadable_connections!
+        @@active_connections.each do |name, conn|
+          if conn.requires_reloading?
+            conn.disconnect!
+            @@active_connections.delete(name)
+          end
+        end
+      end
+
+      # Verify active connections.
+      def verify_active_connections! #:nodoc:
+        if @@allow_concurrency
+          remove_stale_cached_threads!(@@active_connections) do |name, conn|
+            conn.disconnect!
+          end
+        end
+
+        active_connections.each_value do |connection|
+          connection.verify!(@@verification_timeout)
+        end
+      end
+
+      private
+        def clear_cache!(cache, thread_id = nil, &block)
+          if cache
+            if @@allow_concurrency
+              thread_id ||= Thread.current.object_id
+              thread_cache, cache = cache, cache[thread_id]
+              return unless cache
+            end
+
+            cache.each(&block) if block_given?
+            cache.clear
+          end
+        ensure
+          if thread_cache && @@allow_concurrency
+            thread_cache.delete(thread_id)
+          end
+        end
+
+        # Remove stale threads from the cache.
+        def remove_stale_cached_threads!(cache, &block)
+          stale = Set.new(cache.keys)
+
+          Thread.list.each do |thread|
+            stale.delete(thread.object_id) if thread.alive?
+          end
+
+          stale.each do |thread_id|
+            clear_cache!(cache, thread_id, &block)
+          end
+        end
+
+        def clear_all_cached_connections!
+          if @@allow_concurrency
+            @@active_connections.each_value do |connection_hash_for_thread|
+              connection_hash_for_thread.each_value {|conn| conn.disconnect! }
+              connection_hash_for_thread.clear
+            end
+          else
+            @@active_connections.each_value {|conn| conn.disconnect! }
+          end
+          @@active_connections.clear
+        end
+    end
+
+    # Returns the connection currently associated with the class. This can
+    # also be used to "borrow" the connection to do database work that isn't
+    # easily done without going straight to SQL.
+    def connection
+      self.class.connection
+    end
+
+    # Establishes the connection to the database. Accepts a hash as input where
+    # the :adapter key must be specified with the name of a database adapter (in lower-case)
+    # example for regular databases (MySQL, Postgresql, etc):
+    #
+    #   ActiveRecord::Base.establish_connection(
+    #     :adapter  => "mysql",
+    #     :host     => "localhost",
+    #     :username => "myuser",
+    #     :password => "mypass",
+    #     :database => "somedatabase"
+    #   )
+    #
+    # Example for SQLite database:
+    #
+    #   ActiveRecord::Base.establish_connection(
+    #     :adapter => "sqlite",
+    #     :database  => "path/to/dbfile"
+    #   )
+    #
+    # Also accepts keys as strings (for parsing from yaml for example):
+    #   ActiveRecord::Base.establish_connection(
+    #     "adapter" => "sqlite",
+    #     "database"  => "path/to/dbfile"
+    #   )
+    #
+    # The exceptions AdapterNotSpecified, AdapterNotFound and ArgumentError
+    # may be returned on an error.
+    def self.establish_connection(spec = nil)
+      case spec
+        when nil
+          raise AdapterNotSpecified unless defined? RAILS_ENV
+          establish_connection(RAILS_ENV)
+        when ConnectionSpecification
+          clear_active_connection_name
+          @active_connection_name = name
+          @@defined_connections[name] = spec
+        when Symbol, String
+          if configuration = configurations[spec.to_s]
+            establish_connection(configuration)
+          else
+            raise AdapterNotSpecified, "#{spec} database is not configured"
+          end
+        else
+          spec = spec.symbolize_keys
+          unless spec.key?(:adapter) then raise AdapterNotSpecified, "database configuration does not specify adapter" end
+          adapter_method = "#{spec[:adapter]}_connection"
+          unless respond_to?(adapter_method) then raise AdapterNotFound, "database configuration specifies nonexistent #{spec[:adapter]} adapter" end
+          remove_connection
+          establish_connection(ConnectionSpecification.new(spec, adapter_method))
+      end
+    end
+
+    # Locate the connection of the nearest super class. This can be an
+    # active or defined connections: if it is the latter, it will be
+    # opened and set as the active connection for the class it was defined
+    # for (not necessarily the current class).
+    def self.retrieve_connection #:nodoc:
+      # Name is nil if establish_connection hasn't been called for
+      # some class along the inheritance chain up to AR::Base yet.
+      if name = active_connection_name
+        if conn = active_connections[name]
+          # Verify the connection.
+          conn.verify!(@@verification_timeout)
+        elsif spec = @@defined_connections[name]
+          # Activate this connection specification.
+          klass = name.constantize
+          klass.connection = spec
+          conn = active_connections[name]
+        end
+      end
+
+      conn or raise ConnectionNotEstablished
+    end
+
+    # Returns true if a connection that's accessible to this class have already been opened.
+    def self.connected?
+      active_connections[active_connection_name] ? true : false
+    end
+
+    # Remove the connection for this class. This will close the active
+    # connection and the defined connection (if they exist). The result
+    # can be used as argument for establish_connection, for easy
+    # re-establishing of the connection.
+    def self.remove_connection(klass=self)
+      spec = @@defined_connections[klass.name]
+      konn = active_connections[klass.name]
+      @@defined_connections.delete_if { |key, value| value == spec }
+      active_connections.delete_if { |key, value| value == konn }
+      konn.disconnect! if konn
+      spec.config if spec
+    end
+
+    # Set the connection for the class.
+    def self.connection=(spec) #:nodoc:
+      if spec.kind_of?(BigRecord::ConnectionAdapters::AbstractAdapter)
+        active_connections[name] = spec
+      elsif spec.kind_of?(ConnectionSpecification)
+        config = spec.config.reverse_merge(:allow_concurrency => @@allow_concurrency)
+        self.connection = self.send(spec.adapter_method, config)
+      elsif spec.nil?
+        raise ConnectionNotEstablished
+      else
+        establish_connection spec
+      end
+    end
+
+    # connection state logging
+    def self.log_connections #:nodoc:
+      if logger
+        logger.info "Defined connections: #{@@defined_connections.inspect}"
+        logger.info "Active connections: #{active_connections.inspect}"
+        logger.info "Active connection name: #{@active_connection_name}"
+      end
+    end
+  end
+end

data/lib/big_record/connection_adapters/abstract/database_statements.rb

@@ -0,0 +1,175 @@
+module BigRecord
+  module ConnectionAdapters # :nodoc:
+    module DatabaseStatements
+#      # Returns an array of record hashes with the column names as keys and
+#      # column values as values.
+#      def select_all(sql, name = nil)
+#        select(sql, name)
+#      end
+#
+#      # Returns a record hash with the column names as keys and column values
+#      # as values.
+#      def select_one(sql, name = nil)
+#        result = select_all(sql, name)
+#        result.first if result
+#      end
+#
+#      # Returns a single value from a record
+#      def select_value(sql, name = nil)
+#        if result = select_one(sql, name)
+#          result.values.first
+#        end
+#      end
+#
+#      # Returns an array of the values of the first column in a select:
+#      #   select_values("SELECT id FROM companies LIMIT 3") => [1,2,3]
+#      def select_values(sql, name = nil)
+#        result = select_rows(sql, name)
+#        result.map { |v| v[0] }
+#      end
+#
+#      # Returns an array of arrays containing the field values.
+#      # Order is the same as that returned by #columns.
+#      def select_rows(sql, name = nil)
+#        raise NotImplementedError, "select_rows is an abstract method"
+#      end
+#
+#      # Executes the SQL statement in the context of this connection.
+#      def execute(sql, name = nil)
+#        raise NotImplementedError, "execute is an abstract method"
+#      end
+#
+#      # Returns the last auto-generated ID from the affected table.
+#      def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+#        insert_sql(sql, name, pk, id_value, sequence_name)
+#      end
+#
+#      # Executes the update statement and returns the number of rows affected.
+#      def update(sql, name = nil)
+#        update_sql(sql, name)
+#      end
+#
+#      # Executes the delete statement and returns the number of rows affected.
+#      def delete(sql, name = nil)
+#        delete_sql(sql, name)
+#      end
+#
+#      # Wrap a block in a transaction.  Returns result of block.
+#      def transaction(start_db_transaction = true)
+#        transaction_open = false
+#        begin
+#          if block_given?
+#            if start_db_transaction
+#              begin_db_transaction
+#              transaction_open = true
+#            end
+#            yield
+#          end
+#        rescue Exception => database_transaction_rollback
+#          if transaction_open
+#            transaction_open = false
+#            rollback_db_transaction
+#          end
+#          raise unless database_transaction_rollback.is_a? ActiveRecord::Rollback
+#        end
+#      ensure
+#        if transaction_open
+#          begin
+#            commit_db_transaction
+#          rescue Exception => database_transaction_rollback
+#            rollback_db_transaction
+#            raise
+#          end
+#        end
+#      end
+#
+#      # Begins the transaction (and turns off auto-committing).
+#      def begin_db_transaction()    end
+#
+#      # Commits the transaction (and turns on auto-committing).
+#      def commit_db_transaction()   end
+#
+#      # Rolls back the transaction (and turns on auto-committing). Must be
+#      # done if the transaction block raises an exception or returns false.
+#      def rollback_db_transaction() end
+#
+#      # Alias for #add_limit_offset!.
+#      def add_limit!(sql, options)
+#        add_limit_offset!(sql, options) if options
+#      end
+#
+#      # Appends +LIMIT+ and +OFFSET+ options to an SQL statement.
+#      # This method *modifies* the +sql+ parameter.
+#      # ===== Examples
+#      #  add_limit_offset!('SELECT * FROM suppliers', {:limit => 10, :offset => 50})
+#      # generates
+#      #  SELECT * FROM suppliers LIMIT 10 OFFSET 50
+#      def add_limit_offset!(sql, options)
+#        if limit = options[:limit]
+#          sql << " LIMIT #{limit}"
+#          if offset = options[:offset]
+#            sql << " OFFSET #{offset}"
+#          end
+#        end
+#      end
+#
+#      # Appends a locking clause to an SQL statement.
+#      # This method *modifies* the +sql+ parameter.
+#      #   # SELECT * FROM suppliers FOR UPDATE
+#      #   add_lock! 'SELECT * FROM suppliers', :lock => true
+#      #   add_lock! 'SELECT * FROM suppliers', :lock => ' FOR UPDATE'
+#      def add_lock!(sql, options)
+#        case lock = options[:lock]
+#          when true;   sql << ' FOR UPDATE'
+#          when String; sql << " #{lock}"
+#        end
+#      end
+#
+#      def default_sequence_name(table, column)
+#        nil
+#      end
+#
+#      # Set the sequence to the max value of the table's column.
+#      def reset_sequence!(table, column, sequence = nil)
+#        # Do nothing by default.  Implement for PostgreSQL, Oracle, ...
+#      end
+
+      # Inserts the given fixture into the table. Overridden in adapters that require
+      # something beyond a simple insert (eg. Oracle).
+      def insert_fixture(fixture, table_name)
+#        execute "INSERT INTO #{quote_table_name(table_name)} (#{fixture.key_list}) VALUES (#{fixture.value_list})", 'Fixture Insert'
+        attributes = fixture.to_hash.dup
+        id = attributes.delete("id")
+        raise ArgumentError, "the id is missing" unless id
+        update(table_name, id, attributes, Time.now.to_bigrecord_timestamp)
+      end
+
+#      def empty_insert_statement(table_name)
+#        "INSERT INTO #{quote_table_name(table_name)} VALUES(DEFAULT)"
+#      end
+#
+#      protected
+#        # Returns an array of record hashes with the column names as keys and
+#        # column values as values.
+#        def select(sql, name = nil)
+#          raise NotImplementedError, "select is an abstract method"
+#        end
+#
+#        # Returns the last auto-generated ID from the affected table.
+#        def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+#          execute(sql, name)
+#          id_value
+#        end
+#
+#        # Executes the update statement and returns the number of rows affected.
+#        def update_sql(sql, name = nil)
+#          execute(sql, name)
+#        end
+#
+#        # Executes the delete statement and returns the number of rows affected.
+#        def delete_sql(sql, name = nil)
+#          update_sql(sql, name)
+#        end
+    end
+  end
+end

data/lib/big_record/connection_adapters/abstract/quoting.rb

@@ -0,0 +1,58 @@
+module BigRecord
+  module ConnectionAdapters # :nodoc:
+    module Quoting
+      # Quotes the column value to help prevent
+      # {SQL injection attacks}[http://en.wikipedia.org/wiki/SQL_injection].
+      def quote(value, column = nil)
+        # records are quoted as their primary key
+        return value.quoted_id if value.respond_to?(:quoted_id)
+
+        case value
+          when String, ActiveSupport::Multibyte::Chars
+            value = value.to_s
+            if column && column.type == :binary && column.class.respond_to?(:string_to_binary)
+              "'#{quote_string(column.class.string_to_binary(value))}'" # ' (for ruby-mode)
+            elsif column && [:integer, :float].include?(column.type)
+              value = column.type == :integer ? value.to_i : value.to_f
+              value.to_s
+            else
+              "'#{quote_string(value)}'" # ' (for ruby-mode)
+            end
+          when NilClass                 then "NULL"
+          when TrueClass                then (column && column.type == :integer ? '1' : quoted_true)
+          when FalseClass               then (column && column.type == :integer ? '0' : quoted_false)
+          when Float, Fixnum, Bignum    then value.to_s
+          # BigDecimals need to be output in a non-normalized form and quoted.
+          when BigDecimal               then value.to_s('F')
+          when Date                     then "'#{value.to_s}'"
+          when Time, DateTime           then "'#{quoted_date(value)}'"
+          else                          "'#{quote_string(value.to_yaml)}'"
+        end
+      end
+
+      # Quotes a string, escaping any ' (single quote) and \ (backslash)
+      # characters.
+      def quote_string(s)
+        s.gsub(/\\/, '\&\&').gsub(/'/, "''") # ' (for ruby-mode)
+      end
+
+      # Returns a quoted form of the column name.  This is highly adapter
+      # specific.
+      def quote_column_name(name)
+        name
+      end
+
+      def quoted_true
+        "'t'"
+      end
+
+      def quoted_false
+        "'f'"
+      end
+
+      def quoted_date(value)
+        value.strftime("%Y-%m-%d %H:%M:%S")
+      end
+    end
+  end
+end

data/lib/big_record/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,190 @@
+require 'benchmark'
+require 'date'
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+module BigRecord
+  module ConnectionAdapters # :nodoc:
+    # All the concrete database adapters follow the interface laid down in this class.
+    # You can use this interface directly by borrowing the database connection from the Base with
+    # Base.connection.
+    #
+    # Most of the methods in the adapter are useful during migrations.  Most
+    # notably, SchemaStatements#create_table, SchemaStatements#drop_table,
+    # SchemaStatements#add_index, SchemaStatements#remove_index,
+    # SchemaStatements#add_column, SchemaStatements#change_column and
+    # SchemaStatements#remove_column are very useful.
+    class AbstractAdapter
+      include Quoting, DatabaseStatements#, SchemaStatements
+      @@row_even = true
+
+      def initialize(connection, logger = nil) #:nodoc:
+        @connection, @logger = connection, logger
+        @runtime = 0
+        @last_verification = 0
+      end
+
+      # Returns the human-readable name of the adapter.  Use mixed case - one
+      # can always use downcase if needed.
+      def adapter_name
+        'Abstract'
+      end
+
+      # Does this adapter support migrations?  Backend specific, as the
+      # abstract adapter always returns +false+.
+      def supports_migrations?
+        false
+      end
+
+      # Does this adapter support using DISTINCT within COUNT?  This is +true+
+      # for all adapters except sqlite.
+      def supports_count_distinct?
+        false
+      end
+
+      def supports_ddl_transactions?
+        false
+      end
+
+      # Should primary key values be selected from their corresponding
+      # sequence before the insert statement?  If true, next_sequence_value
+      # is called before each insert to set the record's primary key.
+      # This is false for all adapters but Firebird.
+      def prefetch_primary_key?(table_name = nil)
+        false
+      end
+
+      def reset_runtime #:nodoc:
+        rt, @runtime = @runtime, 0
+        rt
+      end
+
+      # QUOTING ==================================================
+
+      # Override to return the quoted table name if the database needs it
+      def quote_table_name(name)
+        name
+      end
+
+      # REFERENTIAL INTEGRITY ====================================
+
+      # Override to turn off referential integrity while executing +&block+
+      def disable_referential_integrity(&block)
+        yield
+      end
+
+      # CONNECTION MANAGEMENT ====================================
+
+      # Is this connection active and ready to perform queries?
+      def active?
+        @active != false
+      end
+
+      # Close this connection and open a new one in its place.
+      def reconnect!
+        @active = true
+      end
+
+      # Close this connection
+      def disconnect!
+        @active = false
+      end
+
+      # Returns true if its safe to reload the connection between requests for development mode.
+      # This is not the case for Ruby/MySQL and it's not necessary for any adapters except SQLite.
+      def requires_reloading?
+        false
+      end
+
+      # Lazily verify this connection, calling +active?+ only if it hasn't
+      # been called for +timeout+ seconds.
+      def verify!(timeout)
+        now = Time.now.to_i
+        if (now - @last_verification) > timeout
+          reconnect! unless active?
+          @last_verification = now
+        end
+      end
+
+      # Provides access to the underlying database connection. Useful for
+      # when you need to call a proprietary method such as postgresql's lo_*
+      # methods
+      def raw_connection
+        @connection
+      end
+
+      # DATABASE STATEMENTS ======================================
+
+      def update_raw(table_name, row, values, timestamp)
+        raise NotImplementedError
+      end
+
+      def update(table_name, row, values, timestamp)
+        raise NotImplementedError
+      end
+
+      def get_raw(table_name, row, column, options={})
+        raise NotImplementedError
+      end
+
+      def get(table_name, row, column, options={})
+        raise NotImplementedError
+      end
+
+      def get_columns_raw(table_name, row, columns, options={})
+        raise NotImplementedError
+      end
+
+      def get_columns(table_name, row, columns, options={})
+        raise NotImplementedError
+      end
+
+      def get_consecutive_rows_raw(table_name, start_row, limit, columns, stop_row = nil)
+        raise NotImplementedError
+      end
+
+      def get_consecutive_rows(table_name, start_row, limit, columns, stop_row = nil)
+        raise NotImplementedError
+      end
+
+      def delete(table_name, row)
+        raise NotImplementedError
+      end
+
+      def delete_all(table_name)
+        raise NotImplementedError
+      end
+
+      # SCHEMA STATEMENTS ========================================
+
+      def table_exists?(table_name)
+        raise NotImplementedError
+      end
+
+      def create_table(table_name, column_families)
+        raise NotImplementedError
+      end
+
+      def drop_table(table_name)
+        raise NotImplementedError
+      end
+
+    end # class AbstractAdapter
+  end # module ConnectionAdapters
+end # module BigRecord
+
+
+# Open the time class to add logic for the hbase timestamp
+class Time
+  # Return this time is the hbase timestamp format, i.e. a 'long'. The 4 high bytes contain
+  # the number of seconds since epoch and the 4 low bytes contain the microseconds. That
+  # format is an arbitrary one and could have been something else.
+  def to_bigrecord_timestamp
+    (self.to_i << 32) + self.usec
+  end
+
+  def self.from_bigrecord_timestamp(timestamp)
+    Time.at(timestamp >> 32, timestamp & 0xFFFFFFFF)
+  end
+
+end