activerecord-jdbc-adapter-onsite 1.2.2

data/lib/arjdbc/firebird.rb

@@ -0,0 +1,2 @@
+require 'arjdbc/jdbc'
+require 'arjdbc/firebird/adapter'

data/lib/arjdbc/firebird/adapter.rb

@@ -0,0 +1,140 @@
+module ::ArJdbc
+  module FireBird
+
+    def self.extended(mod)
+      unless @lob_callback_added
+        ActiveRecord::Base.class_eval do
+          def after_save_with_firebird_blob
+            self.class.columns.select { |c| c.sql_type =~ /blob/i }.each do |c|
+              value = self[c.name]
+              if respond_to?(:unserializable_attribute?)
+                value = value.to_yaml if unserializable_attribute?(c.name, c)
+              else
+                value = value.to_yaml if value.is_a?(Hash)
+              end
+              next if value.nil?
+              connection.write_large_object(c.type == :binary, c.name, self.class.table_name, self.class.primary_key, quote_value(id), value)
+            end
+          end
+        end
+
+        ActiveRecord::Base.after_save :after_save_with_firebird_blob
+        @lob_callback_added = true
+      end
+    end
+
+    def adapter_name
+      'Firebird'
+    end
+
+    def self.arel2_visitors(config)
+      require 'arel/visitors/firebird'
+      {}.tap {|v| %w(firebird firebirdsql).each {|a| v[a] = ::Arel::Visitors::Firebird } }
+    end
+
+    def modify_types(tp)
+      tp[:primary_key] = 'INTEGER NOT NULL PRIMARY KEY'
+      tp[:string][:limit] = 252
+      tp[:integer][:limit] = nil
+      tp
+    end
+
+    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = []) # :nodoc:
+      execute(sql, name, binds)
+      id_value
+    end
+
+    def add_limit_offset!(sql, options) # :nodoc:
+      if options[:limit]
+        limit_string = "FIRST #{options[:limit]}"
+        limit_string << " SKIP #{options[:offset]}" if options[:offset]
+        sql.sub!(/\A(\s*SELECT\s)/i, '\&' + limit_string + ' ')
+      end
+    end
+
+    def prefetch_primary_key?(table_name = nil)
+      true
+    end
+
+    def default_sequence_name(table_name, primary_key) # :nodoc:
+      "#{table_name}_seq"
+    end
+
+    def next_sequence_value(sequence_name)
+      select_one("SELECT GEN_ID(#{sequence_name}, 1 ) FROM RDB$DATABASE;")["gen_id"]
+    end
+
+    def create_table(name, options = {}) #:nodoc:
+      super(name, options)
+      execute "CREATE GENERATOR #{name}_seq"
+    end
+
+    def rename_table(name, new_name) #:nodoc:
+      execute "RENAME #{name} TO #{new_name}"
+      execute "UPDATE RDB$GENERATORS SET RDB$GENERATOR_NAME='#{new_name}_seq' WHERE RDB$GENERATOR_NAME='#{name}_seq'" rescue nil
+    end
+
+    def drop_table(name, options = {}) #:nodoc:
+      super(name)
+      execute "DROP GENERATOR #{name}_seq" rescue nil
+    end
+
+    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+      execute "ALTER TABLE #{table_name} ALTER  #{column_name} TYPE #{type_to_sql(type, options[:limit])}"
+    end
+
+    def rename_column(table_name, column_name, new_column_name)
+      execute "ALTER TABLE #{table_name} ALTER  #{column_name} TO #{new_column_name}"
+    end
+
+    def remove_index(table_name, options) #:nodoc:
+      execute "DROP INDEX #{index_name(table_name, options)}"
+    end
+
+    def quote(value, column = nil) # :nodoc:
+      return value.quoted_id if value.respond_to?(:quoted_id)
+
+      # BLOBs are updated separately by an after_save trigger.
+      return value.nil? ? "NULL" : "'#{quote_string(value[0..1])}'" if column && [:binary, :text].include?(column.type)
+
+      if [Time, DateTime].include?(value.class)
+        "CAST('#{value.strftime("%Y-%m-%d %H:%M:%S")}' AS TIMESTAMP)"
+      else
+        if column && column.type == :primary_key
+          return value.to_s
+        end
+        super
+      end
+    end
+
+    def quote_string(string) # :nodoc:
+      string.gsub(/'/, "''")
+    end
+
+    def quote_column_name(column_name) # :nodoc:
+      %Q("#{ar_to_fb_case(column_name)}")
+    end
+
+    def quoted_true # :nodoc:
+      quote(1)
+    end
+
+    def quoted_false # :nodoc:
+      quote(0)
+    end
+
+    private
+
+    # Maps uppercase Firebird column names to lowercase for ActiveRecord;
+    # mixed-case columns retain their original case.
+    def fb_to_ar_case(column_name)
+      column_name =~ /[[:lower:]]/ ? column_name : column_name.to_s.downcase
+    end
+
+    # Maps lowercase ActiveRecord column names to uppercase for Fierbird;
+    # mixed-case columns retain their original case.
+    def ar_to_fb_case(column_name)
+      column_name =~ /[[:upper:]]/ ? column_name : column_name.to_s.upcase
+    end
+  end
+end

data/lib/arjdbc/h2.rb

@@ -0,0 +1,4 @@
+require 'arjdbc/jdbc'
+jdbc_require_driver 'jdbc/h2'
+require 'arjdbc/h2/connection_methods'
+require 'arjdbc/h2/adapter'

data/lib/arjdbc/h2/adapter.rb

@@ -0,0 +1,54 @@
+require 'arjdbc/hsqldb/adapter'
+
+module ArJdbc
+  module H2
+    include HSQLDB
+
+    def self.jdbc_connection_class
+      ::ActiveRecord::ConnectionAdapters::H2JdbcConnection
+    end
+
+    def adapter_name #:nodoc:
+      'H2'
+    end
+
+    def self.arel2_visitors(config)
+      v = HSQLDB.arel2_visitors(config)
+      v.merge({}.tap {|v| %w(h2 jdbch2).each {|a| v[a] = ::Arel::Visitors::HSQLDB } })
+    end
+
+    def h2_adapter
+      true
+    end
+
+    def tables
+      @connection.tables(nil, h2_schema)
+    end
+
+    def columns(table_name, name=nil)
+      @connection.columns_internal(table_name.to_s, name, h2_schema)
+    end
+
+    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+      execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} #{type_to_sql(type, options[:limit])}"
+      change_column_default(table_name, column_name, options[:default]) if options_include_default?(options)
+      change_column_null(table_name, column_name, options[:null], options[:default]) if options.key?(:null)
+    end
+
+    private
+    def change_column_null(table_name, column_name, null, default = nil)
+      if !null && !default.nil?
+        execute("UPDATE #{table_name} SET #{column_name}=#{quote(default)} WHERE #{column_name} IS NULL")
+      end
+      if null
+        execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET NULL"
+      else
+        execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET NOT NULL"
+      end
+    end
+
+    def h2_schema
+      @config[:schema] || ''
+    end
+  end
+end

data/lib/arjdbc/h2/connection_methods.rb

@@ -0,0 +1,13 @@
+module ActiveRecord
+  class Base
+    class << self
+      def h2_connection(config)
+        config[:url] ||= "jdbc:h2:#{config[:database]}"
+        config[:driver] ||= "org.h2.Driver"
+        config[:adapter_spec] = ::ArJdbc::H2
+        embedded_driver(config)
+      end
+      alias_method :jdbch2_connection, :h2_connection
+    end
+  end
+end

data/lib/arjdbc/hsqldb.rb

@@ -0,0 +1,4 @@
+require 'arjdbc/jdbc'
+jdbc_require_driver 'jdbc/hsqldb'
+require 'arjdbc/hsqldb/connection_methods'
+require 'arjdbc/hsqldb/adapter'

data/lib/arjdbc/hsqldb/adapter.rb

@@ -0,0 +1,184 @@
+module ::ArJdbc
+  module HSQLDB
+    def self.column_selector
+      [/hsqldb|\.h2\./i, lambda {|cfg,col| col.extend(::ArJdbc::HSQLDB::Column)}]
+    end
+
+    module Column
+      private
+      def simplified_type(field_type)
+        case field_type
+        when /longvarchar/i then :text
+        when /tinyint/i  then :boolean
+        when /real/i     then :float
+        else
+          super
+        end
+      end
+
+      # Override of ActiveRecord::ConnectionAdapters::Column
+      def extract_limit(sql_type)
+        # HSQLDB appears to return "LONGVARCHAR(0)" for :text columns, which
+        # for AR purposes should be interpreted as "no limit"
+        return nil if sql_type =~ /\(0\)/
+        super
+      end
+
+      # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
+      def default_value(value)
+        # H2 auto-generated key default value
+        return nil if value =~ /^\(NEXT VALUE FOR/i
+
+        # jdbc returns column default strings with actual single quotes around the value.
+        return $1 if value =~ /^'(.*)'$/
+
+        value
+      end
+    end
+
+    def adapter_name #:nodoc:
+      'Hsqldb'
+    end
+
+    def self.arel2_visitors(config)
+      require 'arel/visitors/hsqldb'
+      {}.tap {|v| %w(hsqldb jdbchsqldb).each {|a| v[a] = ::Arel::Visitors::HSQLDB } }
+    end
+
+    def modify_types(tp)
+      tp[:primary_key] = "INTEGER GENERATED BY DEFAULT AS IDENTITY(START WITH 0) PRIMARY KEY"
+      tp[:integer][:limit] = nil
+      tp[:boolean][:limit] = nil
+      # set text and float limits so we don't see odd scales tacked on
+      # in migrations
+      tp[:boolean] = { :name => "tinyint" }
+      tp[:text][:limit] = nil
+      tp[:float][:limit] = 17 if defined?(::Jdbc::H2)
+      tp[:string][:limit] = 255
+      tp[:datetime] = { :name => "DATETIME" }
+      tp[:timestamp] = { :name => "DATETIME" }
+      tp[:time] = { :name => "TIME" }
+      tp[:date] = { :name => "DATE" }
+      tp
+    end
+
+    def quote(value, column = nil) # :nodoc:
+      return value.quoted_id if value.respond_to?(:quoted_id)
+
+      case value
+      when String
+        if respond_to?(:h2_adapter) && value.empty?
+          "''"
+        elsif column && column.type == :binary
+          "'#{value.unpack("H*")[0]}'"
+        elsif column && (column.type == :integer ||
+                         column.respond_to?(:primary) && column.primary && column.klass != String)
+          value.to_i.to_s
+        else
+          "'#{quote_string(value)}'"
+        end
+      else
+        super
+      end
+    end
+
+    def quote_column_name(name) #:nodoc:
+      name = name.to_s
+      if name =~ /[-]/
+        %Q{"#{name.upcase}"}
+      else
+        name
+      end
+    end
+
+    def quote_string(str)
+      str.gsub(/'/, "''")
+    end
+
+    def quoted_true
+      '1'
+    end
+
+    def quoted_false
+      '0'
+    end
+
+    def add_column(table_name, column_name, type, options = {})
+      add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+      add_column_options!(add_column_sql, options)
+      execute(add_column_sql)
+    end
+
+    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+      execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} #{type_to_sql(type, options[:limit])}"
+    end
+
+    def change_column_default(table_name, column_name, default) #:nodoc:
+      execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET DEFAULT #{quote(default)}"
+    end
+
+    def rename_column(table_name, column_name, new_column_name) #:nodoc:
+      execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} RENAME TO #{new_column_name}"
+    end
+
+    # Maps logical Rails types to MySQL-specific data types.
+    def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+      return super if defined?(::Jdbc::H2) || type.to_s != 'integer' || limit == nil
+
+      type
+    end
+
+    def rename_table(name, new_name)
+      execute "ALTER TABLE #{name} RENAME TO #{new_name}"
+    end
+
+    def last_insert_id
+      Integer(select_value("CALL IDENTITY()"))
+    end
+
+    def _execute(sql, name = nil)
+      result = super
+      ActiveRecord::ConnectionAdapters::JdbcConnection::insert?(sql) ? last_insert_id : result
+    end
+
+    def add_limit_offset!(sql, options) #:nodoc:
+      if sql =~ /^select/i
+        offset = options[:offset] || 0
+        bef = sql[7..-1]
+        if limit = options[:limit]
+          sql.replace "SELECT LIMIT #{offset} #{limit} #{bef}"
+        elsif offset > 0
+          sql.replace "SELECT LIMIT #{offset} 0 #{bef}"
+        end
+      end
+    end
+
+    # override to filter out system tables that otherwise end
+    # up in db/schema.rb during migrations.  JdbcConnection#tables
+    # now takes an optional block filter so we can screen out
+    # rows corresponding to system tables.  HSQLDB names its
+    # system tables SYSTEM.*, but H2 seems to name them without
+    # any kind of convention
+    def tables
+      @connection.tables.select {|row| row.to_s !~ /^system_/i }
+    end
+
+    def remove_index(table_name, options = {})
+      execute "DROP INDEX #{quote_column_name(index_name(table_name, options))}"
+    end
+
+    def recreate_database(name)
+      drop_database(name)
+    end
+    
+    # do nothing since database gets created upon connection. However
+    # this method gets called by rails db rake tasks so now we're
+    # avoiding method_missing error
+    def create_database(name)
+    end
+
+    def drop_database(name)
+      execute("DROP ALL OBJECTS")
+    end    
+  end
+end

data/lib/arjdbc/hsqldb/connection_methods.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  class Base
+    class << self
+      def hsqldb_connection(config)
+        require "arjdbc/hsqldb"
+        config[:url] ||= "jdbc:hsqldb:#{config[:database]}"
+        config[:driver] ||= "org.hsqldb.jdbcDriver"
+        config[:adapter_spec] = ::ArJdbc::HSQLDB
+        embedded_driver(config)
+      end
+
+      alias_method :jdbchsqldb_connection, :hsqldb_connection
+    end
+  end
+end

data/lib/arjdbc/informix.rb

@@ -0,0 +1,3 @@
+require 'arjdbc/jdbc'
+require 'arjdbc/informix/connection_methods'
+require 'arjdbc/informix/adapter'

data/lib/arjdbc/informix/adapter.rb

@@ -0,0 +1,142 @@
+module ::ActiveRecord
+  class Base
+    after_save :write_lobs
+
+  private
+    def write_lobs
+      if connection.is_a?(ArJdbc::Informix)
+        self.class.columns.each do |c|
+          if [:text, :binary].include? c.type
+            value = self[c.name]
+            if respond_to?(:unserializable_attribute?)
+              value = value.to_yaml if unserializable_attribute?(c.name, c)
+            else
+              value = value.to_yaml if value.is_a?(Hash)
+            end
+
+            unless value.nil? || (value == '')
+              connection.write_large_object(c.type == :binary,
+                                            c.name,
+                                            self.class.table_name,
+                                            self.class.primary_key,
+                                            quote_value(id),
+                                            value)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+module ::ArJdbc
+  module Informix
+    def self.extended(base)
+      @@db_major_version = base.select_one("SELECT dbinfo('version', 'major') version FROM systables WHERE tabid = 1")['version'].to_i
+    end
+
+    def self.column_selector
+      [ /informix/i,
+        lambda { |cfg, column| column.extend(::ArJdbc::Informix::Column) } ]
+    end
+
+    def self.jdbc_connection_class
+      ::ActiveRecord::ConnectionAdapters::InformixJdbcConnection
+    end
+
+    module Column
+    private
+      # TODO: Test all Informix column types.
+      def simplified_type(field_type)
+        if field_type =~ /serial/i
+          :primary_key
+        else
+          super
+        end
+      end
+    end
+
+    def modify_types(tp)
+      tp[:primary_key] = "SERIAL PRIMARY KEY"
+      tp[:string]      = { :name => "VARCHAR", :limit => 255 }
+      tp[:integer]     = { :name => "INTEGER" }
+      tp[:float]       = { :name => "FLOAT" }
+      tp[:decimal]     = { :name => "DECIMAL" }
+      tp[:datetime]    = { :name => "DATETIME YEAR TO FRACTION(5)" }
+      tp[:timestamp]   = { :name => "DATETIME YEAR TO FRACTION(5)" }
+      tp[:time]        = { :name => "DATETIME HOUR TO FRACTION(5)" }
+      tp[:date]        = { :name => "DATE" }
+      tp[:binary]      = { :name => "BYTE" }
+      tp[:boolean]     = { :name => "BOOLEAN" }
+      tp
+    end
+
+    def prefetch_primary_key?(table_name = nil)
+      true
+    end
+
+    def supports_migrations?
+      true
+    end
+
+    def default_sequence_name(table, column)
+      "#{table}_seq"
+    end
+
+    def add_limit_offset!(sql, options)
+      if options[:limit]
+        limit = "FIRST #{options[:limit]}"
+        # SKIP available only in IDS >= 10
+        offset = (@@db_major_version >= 10 && options[:offset]?
+                  "SKIP #{options[:offset]}" : "")
+        sql.sub!(/^select /i, "SELECT #{offset} #{limit} ")
+      end
+      sql
+    end
+
+    def next_sequence_value(sequence_name)
+      select_one("SELECT #{sequence_name}.nextval id FROM systables WHERE tabid=1")['id']
+    end
+
+    # TODO: Add some smart quoting for newlines in string and text fields.
+    def quote_string(string)
+      string.gsub(/\'/, "''")
+    end
+
+    def quote(value, column = nil)
+      if column && [:binary, :text].include?(column.type)
+        # LOBs are updated separately by an after_save trigger.
+        "NULL"
+      elsif column && column.type == :date
+        "'#{value.mon}/#{value.day}/#{value.year}'"
+      else
+        super
+      end
+    end
+
+    def create_table(name, options = {})
+      super(name, options)
+      execute("CREATE SEQUENCE #{name}_seq")
+    end
+
+    def rename_table(name, new_name)
+      execute("RENAME TABLE #{name} TO #{new_name}")
+      execute("RENAME SEQUENCE #{name}_seq TO #{new_name}_seq")
+    end
+
+    def drop_table(name)
+      super(name)
+      execute("DROP SEQUENCE #{name}_seq")
+    end
+
+    def remove_index(table_name, options = {})
+      @connection.execute_update("DROP INDEX #{index_name(table_name, options)}")
+    end
+
+  private
+    def select(sql, *rest)
+      # Informix does not like "= NULL", "!= NULL", or "<> NULL".
+      execute(sql.gsub(/(!=|<>)\s*null/i, "IS NOT NULL").gsub(/=\s*null/i, "IS NULL"), *rest)
+    end
+  end # module Informix
+end # module ::ArJdbc