andyjeffries-rubyrep 1.2.1

data/lib/rubyrep/connection_extenders/connection_extenders.rb

@@ -0,0 +1,165 @@
+class ActiveRecord::ConnectionAdapters::AbstractAdapter
+  # The current log subscriber
+  attr_accessor :log_subscriber
+end
+
+class ActiveRecord::ConnectionAdapters::Column
+  # Bug in ActiveRecord parsing of PostgreSQL timestamps with microseconds:
+  # Certain values are incorrectly rounded, thus ending up with timestamps
+  # that are off by one microsecond.
+  # This monkey patch fixes the problem.
+  def self.fast_string_to_time(string)
+    if string =~ Format::ISO_DATETIME
+      microsec = ($7.to_f * 1_000_000).round # used to be #to_i instead
+      new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
+    end
+  end
+end
+
+module RR
+  
+  # Connection extenders provide additional database specific functionality
+  # not coming in the ActiveRecord library.
+  # This module itself only provides functionality to register and retrieve
+  # such connection extenders.
+  module ConnectionExtenders
+    # Returns a Hash of currently registered connection extenders.
+    # (Empty Hash if no connection extenders were defined.)
+    def self.extenders
+      @extenders ||= {}
+      @extenders
+    end
+  
+    # Registers one or multiple connection extender.
+    # extender is a Hash with 
+    #   key::   The adapter symbol as used by ActiveRecord::Connection Adapters, e. g. :postgresql
+    #   value:: Name of the module implementing the connection extender
+    def self.register(extender)
+      @extenders ||= {}
+      @extenders.merge! extender
+    end
+
+    # Dummy ActiveRecord descendant only used to create database connections.
+    class DummyActiveRecord < ActiveRecord::Base
+    end
+    
+    # Creates an ActiveRecord database connection according to the provided +config+ connection hash.
+    # Possible values of this parameter are described in ActiveRecord::Base#establish_connection.
+    # The database connection is extended with the correct ConnectionExtenders module.
+    # 
+    # ActiveRecord only allows one database connection per class.
+    # (It disconnects the existing database connection if a new connection is established.)
+    # To go around this, we delete ActiveRecord's memory of the existing database connection
+    # as soon as it is created.
+    def self.db_connect_without_cache(config)
+      if RUBY_PLATFORM =~ /java/
+        adapter = config[:adapter]
+        
+        # As recommended in the activerecord-jdbc-adapter use the jdbc versions
+        # of the Adapters. E. g. instead of "postgresql", "jdbcpostgresql".
+        adapter = 'jdbc' + adapter unless adapter =~ /^jdbc/
+
+        DummyActiveRecord.establish_connection(config.merge(:adapter => adapter))
+      else
+        DummyActiveRecord.establish_connection(config)
+      end
+      connection = DummyActiveRecord.connection
+      
+      # Delete the database connection from ActiveRecords's 'memory'
+      ActiveRecord::Base.connection_handler.connection_pools.delete DummyActiveRecord.name
+      
+      extender = ""
+      if RUBY_PLATFORM =~ /java/
+        extender = :jdbc
+      elsif ConnectionExtenders.extenders.include? config[:adapter].to_sym
+        extender = config[:adapter].to_sym
+      else
+        raise "No ConnectionExtender available for :#{config[:adapter]}"
+      end
+      connection.extend ConnectionExtenders.extenders[extender]
+      
+      # Hack to get Postgres schema support under JRuby to par with the standard
+      # ruby version
+      if RUBY_PLATFORM =~ /java/ and config[:adapter].to_sym == :postgresql
+        connection.extend RR::ConnectionExtenders::PostgreSQLExtender
+        connection.initialize_search_path
+      end
+
+      replication_module = ReplicationExtenders.extenders[config[:adapter].to_sym]
+      connection.extend replication_module if replication_module
+      
+      connection
+    end
+    
+    @@use_cache = true
+    
+    # Returns the current cache status (+true+ if caching is used; +false+ otherwise).
+    def self.use_cache?; @@use_cache; end
+    
+    # Returns the connection cache hash.
+    def self.connection_cache; @@connection_cache; end
+    
+    # Sets a new connection cache
+    def self.connection_cache=(cache)
+      @@connection_cache = cache
+    end
+
+    # Installs the configured logger (if any) into the database connection.
+    # * +db_connection+: database connection (as produced by #db_connect)
+    # * +config+: database configuration (as provided to #db_connect)
+    def self.install_logger(db_connection, config)
+      if config[:logger]
+        if config[:logger].respond_to?(:debug)
+          logger = config[:logger]
+        else
+          logger = ActiveSupport::BufferedLogger.new(config[:logger])
+        end
+        db_connection.instance_variable_set :@logger, logger
+        if ActiveSupport.const_defined?(:Notifications)
+          connection_object_id = db_connection.object_id
+          db_connection.log_subscriber = ActiveSupport::Notifications.subscribe("sql.active_record") do |name, start, finish, id, payload|
+            if payload[:connection_id] == connection_object_id and logger.debug?
+              logger.debug payload[:sql].squeeze(" ")
+            end
+          end
+        end
+      end
+    end
+    
+    # Creates database connections by calling #db_connect_without_cache with the 
+    # provided +config+ configuration hash.
+    # A new database connection is created only if no according cached connection
+    # is available.
+    def self.db_connect(config)
+      if not use_cache?
+        db_connection = db_connect_without_cache config
+      else
+        config_dump = Marshal.dump config.reject {|key, | [:proxy_host, :proxy_port, :logger].include? key}
+        config_checksum = Digest::SHA1.hexdigest(config_dump)
+        @@connection_cache ||= {}
+
+        db_connection = connection_cache[config_checksum]
+        unless db_connection and db_connection.active?
+          db_connection = db_connect_without_cache config
+          connection_cache[config_checksum] = db_connection
+        end
+      end
+
+      install_logger db_connection, config
+
+      db_connection
+    end
+
+    # If status == true: enable the cache. If status == false: don' use cache
+    # Returns the old connection caching status
+    def self.use_db_connection_cache(status)
+      old_status, @@use_cache = @@use_cache, status
+      old_status
+    end
+    
+    # Free up all cached connections
+    def self.clear_db_connection_cache
+      @@connection_cache = {}
+    end
+  end
+end

data/lib/rubyrep/connection_extenders/jdbc_extender.rb

@@ -0,0 +1,65 @@
+require 'java'
+
+module RR
+  module ConnectionExtenders
+
+    # Provides various JDBC specific functionality required by Rubyrep.
+    module JdbcSQLExtender
+      RR::ConnectionExtenders.register :jdbc => self
+      
+      # Monkey patch for activerecord-jdbc-adapter-0.7.2 as it doesn't set the 
+      # +@active+ flag to false, thus ActiveRecord#active? incorrectly confirms
+      # the connection to still be active.
+      def disconnect!
+        super
+        @active = false
+      end
+
+      # Returns an ordered list of primary key column names of the given table
+      def primary_key_names(table)
+        if tables.grep(/^#{table}$/i).empty?
+          # Note: Cannot use tables.include? as returned tables are made lowercase under JRuby MySQL
+          raise "table '#{table}' does not exist"
+        end
+        columns = []
+        result_set = @connection.connection.getMetaData.getPrimaryKeys(nil, nil, table);
+        while result_set.next
+          column_name = result_set.getString("COLUMN_NAME")
+          key_seq = result_set.getShort("KEY_SEQ")
+          columns << {:column_name => column_name, :key_seq => key_seq}
+        end
+        columns.sort! {|a, b| a[:key_seq] <=> b[:key_seq]}
+        key_names = columns.map {|column| column[:column_name]}
+        key_names
+      end
+
+      # Returns for each given table, which other tables it references via
+      # foreign key constraints.
+      # * tables: an array of table names
+      # * returns: a hash with
+      #   * key: name of the referencing table
+      #   * value: an array of names of referenced tables
+      def referenced_tables(tables)
+        result = {}
+        tables.each do |table|
+          references_of_this_table = []
+          result_set = @connection.connection.getMetaData.getImportedKeys(nil, nil, table)
+          while result_set.next
+            referenced_table = result_set.getString("PKTABLE_NAME")
+            unless references_of_this_table.include? referenced_table
+              references_of_this_table << referenced_table
+            end
+          end
+          result[table] = references_of_this_table
+        end
+        result
+      end
+    end
+  end
+end
+
+require 'activerecord-jdbc-adapter'
+if ArJdbc.const_defined?(:PostgreSQL)
+  ArJdbc::PostgreSQL::RecordNotUnique = ActiveRecord::RecordNotUnique unless ArJdbc::PostgreSQL.const_defined?(:RecordNotUnique)
+  ArJdbc::PostgreSQL::InvalidForeignKey = ActiveRecord::InvalidForeignKey  unless ArJdbc::PostgreSQL.const_defined?(:InvalidForeignKey)
+end

data/lib/rubyrep/connection_extenders/mysql_extender.rb

@@ -0,0 +1,59 @@
+module RR
+
+  module ConnectionExtenders
+
+    # Provides various MySQL specific functionality required by Rubyrep.
+    module MysqlExtender
+      RR::ConnectionExtenders.register :mysql2 => self
+
+      # Returns an ordered list of primary key column names of the given table
+      def primary_key_names(table)
+        row = self.select_one(<<-end_sql)
+          select table_name from information_schema.tables 
+          where table_schema = database() and table_name = '#{table}'
+        end_sql
+        if row.nil?
+          raise "table '#{table}' does not exist"
+        end
+        
+        rows = self.select_all(<<-end_sql)
+          select column_name from information_schema.key_column_usage
+          where table_schema = database() and table_name = '#{table}' 
+          and constraint_name = 'PRIMARY'
+          order by ordinal_position
+        end_sql
+
+        columns = rows.map {|_row| _row['column_name']}
+        columns
+      end
+
+      # Returns for each given table, which other tables it references via
+      # foreign key constraints.
+      # * tables: an array of table names
+      # Returns: a hash with
+      # * key: name of the referencing table
+      # * value: an array of names of referenced tables
+      def referenced_tables(tables)
+        rows = self.select_all(<<-end_sql)
+          select distinct table_name as referencing_table, referenced_table_name as referenced_table
+          from information_schema.key_column_usage
+          where table_schema = database()
+          and table_name in ('#{tables.join("', '")}')
+        end_sql
+        result = {}
+        rows.each do |row|
+          unless result.include? row['referencing_table']
+            result[row['referencing_table']] = []
+          end
+          if row['referenced_table'] != nil
+            result[row['referencing_table']] << row['referenced_table']
+          end
+        end
+        tables.each do |table|
+          result[table] = [] unless result.include? table
+        end
+        result
+      end
+    end
+  end
+end

data/lib/rubyrep/connection_extenders/postgresql_extender.rb

@@ -0,0 +1,277 @@
+require 'time'
+
+# Hack:
+# For some reasons these methods were removed in Rails 2.2.2, thus breaking
+# the binary and multi-lingual data loading.
+# So here they are again.
+module ActiveRecord
+  module ConnectionAdapters
+    # PostgreSQL-specific extensions to column definitions in a table.
+    class PostgreSQLColumn < Column #:nodoc:
+
+      # Escapes binary strings for bytea input to the database.
+      def self.string_to_binary(value)
+        if PGconn.respond_to?(:escape_bytea)
+          self.class.module_eval do
+            define_method(:string_to_binary) do |value|
+              PGconn.escape_bytea(value) if value
+            end
+          end
+        else
+          self.class.module_eval do
+            define_method(:string_to_binary) do |value|
+              if value
+                result = ''
+                value.each_byte { |c| result << sprintf('\\\\%03o', c) }
+                result
+              end
+            end
+          end
+        end
+        self.class.string_to_binary(value)
+      end
+
+      # Unescapes bytea output from a database to the binary string it represents.
+      def self.binary_to_string(value)
+        # In each case, check if the value actually is escaped PostgreSQL bytea output
+        # or an unescaped Active Record attribute that was just written.
+        if PGconn.respond_to?(:unescape_bytea)
+          self.class.module_eval do
+            define_method(:binary_to_string) do |value|
+              if value =~ /\\\d{3}/
+                PGconn.unescape_bytea(value)
+              else
+                value
+              end
+            end
+          end
+        else
+          self.class.module_eval do
+            define_method(:binary_to_string) do |value|
+              if value =~ /\\\d{3}/
+                result = ''
+                i, max = 0, value.size
+                while i < max
+                  char = value[i]
+                  if char == ?\\
+                    if value[i+1] == ?\\
+                      char = ?\\
+                      i += 1
+                    else
+                      char = value[i+1..i+3].oct
+                      i += 3
+                    end
+                  end
+                  result << char
+                  i += 1
+                end
+                result
+              else
+                value
+              end
+            end
+          end
+        end
+        self.class.binary_to_string(value)
+      end
+    end
+  end
+end
+
+module RR
+  module ConnectionExtenders
+
+    # Provides various PostgreSQL specific functionality required by Rubyrep.
+    module PostgreSQLExtender
+      RR::ConnectionExtenders.register :postgresql => self
+      
+      # Returns an array of schemas in the current search path.
+      def schemas
+        unless @schemas
+          search_path = select_one("show search_path")['search_path']
+          @schemas = search_path.split(/,/).map { |p| quote(p.strip) }.join(',')
+        end
+        @schemas
+      end
+
+      # *** Monkey patch***
+      # Returns the list of all tables in the schema search path or a specified schema.
+      # This overwrites the according ActiveRecord::PostgreSQLAdapter method
+      # to make sure that also search paths with spaces work
+      # (E. g. 'public, rr' instead of only 'public,rr')
+      def tables(name = nil)
+        select_all(<<-SQL, name).map { |row| row['tablename'] }
+          SELECT tablename
+            FROM pg_tables
+           WHERE schemaname IN (#{schemas})
+        SQL
+      end
+
+      # Disables schema extraction from table names by overwriting the according
+      # ActiveRecord method.
+      # Necessary to support table names containing dots (".").
+      # (This is possible as rubyrep exclusively uses the search_path setting to
+      # support PostgreSQL schemas.)
+      def extract_pg_identifier_from_name(name)
+        return name, nil
+      end
+
+      # Returns an ordered list of primary key column names of the given table
+      def primary_key_names(table)
+        row = self.select_one(<<-end_sql)
+          SELECT relname
+          FROM pg_class
+          WHERE relname = '#{table}' and relnamespace IN
+            (SELECT oid FROM pg_namespace WHERE nspname in (#{schemas}))
+        end_sql
+        raise "table '#{table}' does not exist" if row.nil?
+        
+        row = self.select_one(<<-end_sql)
+          SELECT cons.conkey 
+          FROM pg_class           rel
+          JOIN pg_constraint      cons ON (rel.oid = cons.conrelid)
+          WHERE cons.contype = 'p' AND rel.relname = '#{table}' AND rel.relnamespace IN
+            (SELECT oid FROM pg_namespace WHERE nspname in (#{schemas}))
+        end_sql
+        return [] if row.nil?
+        column_parray = row['conkey']
+        
+        # Change a Postgres Array of attribute numbers
+        # (returned in String form, e. g.: "{1,2}") into an array of Integers
+        column_ids = column_parray.sub(/^\{(.*)\}$/,'\1').split(',').map {|a| a.to_i}
+
+        columns = {}
+        rows = self.select_all(<<-end_sql)
+          SELECT attnum, attname
+          FROM pg_class           rel
+          JOIN pg_constraint      cons ON (rel.oid = cons.conrelid)
+          JOIN pg_attribute       attr ON (rel.oid = attr.attrelid and attr.attnum = any (cons.conkey))
+          WHERE cons.contype = 'p' AND rel.relname = '#{table}' AND rel.relnamespace IN
+            (SELECT oid FROM pg_namespace WHERE nspname in (#{schemas}))
+        end_sql
+        sorted_columns = []
+        if not rows.nil?
+          rows.each() {|r| columns[r['attnum'].to_i] = r['attname']}
+          sorted_columns = column_ids.map {|column_id| columns[column_id]}
+        end
+        sorted_columns
+      end
+
+      # Returns for each given table, which other tables it references via
+      # foreign key constraints.
+      # * tables: an array of table names
+      # Returns: a hash with
+      # * key: name of the referencing table
+      # * value: an array of names of referenced tables
+      def referenced_tables(tables)
+        rows = self.select_all(<<-end_sql)
+          select distinct referencing.relname as referencing_table, referenced.relname as referenced_table
+          from pg_class referencing
+          left join pg_constraint on referencing.oid = pg_constraint.conrelid
+          left join pg_class referenced on pg_constraint.confrelid = referenced.oid
+          where referencing.relkind='r'
+          and referencing.relname in ('#{tables.join("', '")}')
+          and referencing.relnamespace IN
+            (SELECT oid FROM pg_namespace WHERE nspname in (#{schemas}))
+        end_sql
+        result = {}
+        rows.each do |row|
+          unless result.include? row['referencing_table']
+            result[row['referencing_table']] = []
+          end
+          if row['referenced_table'] != nil
+            result[row['referencing_table']] << row['referenced_table']
+          end
+        end
+        result
+      end
+
+      # Sets the schema search path as per configuration parameters
+      def initialize_search_path
+        execute "SET search_path TO #{config[:schema_search_path] || 'public'}"
+      end
+
+      # *** Moneky patch***
+      # Returns the column objects for the named table.
+      # Fixes JRuby schema support
+      def columns(table_name, name = nil)
+        jdbc_connection = @connection.connection # the actual JDBC DatabaseConnection
+        @unquoted_schema ||= select_one("show search_path")['search_path']
+
+        # check if table exists
+        table_results = jdbc_connection.meta_data.get_tables(
+          jdbc_connection.catalog,
+          @unquoted_schema,
+          table_name,
+          ["TABLE","VIEW","SYNONYM"].to_java(:string)
+        )
+        table_exists = table_results.next
+        table_results.close
+        raise "table '#{table_name}' not found" unless table_exists
+
+        # get ResultSet for columns of table
+        column_results = jdbc_connection.meta_data.get_columns(
+          jdbc_connection.catalog,
+          @unquoted_schema,
+          table_name,
+          nil
+        )
+        
+        # create the Column objects
+        columns = []
+        while column_results.next
+          
+          # generate type clause
+          type_clause = column_results.get_string('TYPE_NAME')
+          precision = column_results.get_int('COLUMN_SIZE')
+          scale = column_results.get_int('DECIMAL_DIGITS')
+          if precision > 0
+            type_clause += "(#{precision}#{scale > 0 ? ",#{scale}" : ""})"
+          end
+
+          # create column
+          columns << ::ActiveRecord::ConnectionAdapters::JdbcColumn.new(
+            @config,
+            column_results.get_string('COLUMN_NAME'),
+            column_results.get_string('COLUMN_DEF'),
+            type_clause,
+            column_results.get_string('IS_NULLABLE').strip == "NO"
+          )
+        end
+        column_results.close
+        
+        columns
+      end if RUBY_PLATFORM =~ /java/
+
+      # *** Monkey patch***
+      # Returns the list of a table's column names, data types, and default values.
+      # This overwrites the according ActiveRecord::PostgreSQLAdapter method
+      # to
+      # * work with tables containing a dot (".") and
+      # * only look for tables in the current schema search path.
+      def column_definitions(table_name) #:nodoc:
+        rows = self.select_all <<-end_sql
+          SELECT
+            a.attname as name,
+            format_type(a.atttypid, a.atttypmod) as type,
+            d.adsrc as source,
+            a.attnotnull as notnull
+          FROM pg_attribute a LEFT JOIN pg_attrdef d
+            ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+          WHERE a.attrelid = (
+            SELECT oid FROM pg_class
+            WHERE relname = '#{table_name}' AND relnamespace IN
+              (SELECT oid FROM pg_namespace WHERE nspname in (#{schemas}))
+            LIMIT 1
+            )
+            AND a.attnum > 0 AND NOT a.attisdropped
+          ORDER BY a.attnum
+        end_sql
+    
+        rows.map {|row| [row['name'], row['type'], row['source'], row['notnull']]}
+      end
+
+    end
+  end
+end
+