saturnflyer-activerecord-jdbc-adapter 0.9.3

data/lib/jdbc_adapter/jdbc_firebird.rb

@@ -0,0 +1,109 @@
+module ::JdbcSpec
+  module FireBird
+    def self.adapter_matcher(name, *)
+      name =~ /firebird/i ? self : false
+    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) # :nodoc:
+      execute(sql, name)
+      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)
+      
+      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/jdbc_adapter/jdbc_hsqldb.rb

@@ -0,0 +1,210 @@
+module ::JdbcSpec
+  module ActiveRecordExtensions
+    def hsqldb_connection(config)
+      config[:url] ||= "jdbc:hsqldb:#{config[:database]}"
+      config[:driver] ||= "org.hsqldb.jdbcDriver"
+      embedded_driver(config)
+    end
+
+    def h2_connection(config)
+      config[:url] ||= "jdbc:h2:#{config[:database]}"
+      config[:driver] ||= "org.h2.Driver"
+      embedded_driver(config)
+    end
+  end
+
+  module HSQLDB
+    def self.adapter_matcher(name, *)
+      name =~ /hsqldb/i ? self : false
+    end
+
+    def self.column_selector
+      [/hsqldb|\.h2\./i, lambda {|cfg,col| col.extend(::JdbcSpec::HSQLDB::Column)}]
+    end
+
+    module Column
+      private
+      def simplified_type(field_type)
+        case field_type
+        when /longvarchar/i
+          :text
+        when /tinyint/i
+          :boolean
+        else
+          super(field_type)
+        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)
+        # jdbc returns column default strings with actual single quotes around the value.
+        return $1 if value =~ /^'(.*)'$/
+
+        value
+      end
+    end
+
+    def adapter_name #:nodoc:
+      defined?(::Jdbc::H2) ? 'h2' : '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*")}'"
+        elsif column.respond_to?(:primary) && column.primary
+          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 = {})
+      if option_not_null = options[:null] == false
+        option_not_null = options.delete(:null)
+      end
+      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)
+      if option_not_null
+        alter_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} NOT NULL"
+      end
+    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 insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
+      log(sql,name) do
+        @connection.execute_update(sql)
+      end
+      table = sql.split(" ", 4)[2]
+      id_value || last_insert_id(table, nil)
+    end
+
+    def last_insert_id(table, sequence_name)
+      Integer(select_value("CALL IDENTITY()"))
+    end
+
+    # Override normal #_execute: See Rubyforge #11567
+    def _execute(sql, name = nil)
+      if ::ActiveRecord::ConnectionAdapters::JdbcConnection::select?(sql)
+        @connection.execute_query(sql)
+      elsif ::ActiveRecord::ConnectionAdapters::JdbcConnection::insert?(sql)
+        insert(sql, name)
+      else
+        @connection.execute_update(sql)
+      end
+    end
+
+    def add_limit_offset!(sql, options) #:nodoc:
+      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
+
+    # 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
+  end
+
+  module H2
+    include HSQLDB
+
+    def self.adapter_matcher(name, *)
+      name =~ /\.h2\./i ? self : false
+    end
+
+    def h2_adapter
+      true
+    end
+  end
+end

data/lib/jdbc_adapter/jdbc_informix.rb

@@ -0,0 +1,147 @@
+module ::ActiveRecord
+  class Base
+    after_save :write_lobs
+
+  private
+    def write_lobs
+      if connection.is_a?(JdbcSpec::Informix)
+        self.class.columns.each do |c|
+          if [:text, :binary].include? c.type
+            value = self[c.name]
+            value = value.to_yaml if unserializable_attribute?(c.name, c)
+
+            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 ::JdbcSpec
+  module ActiveRecordExtensions
+    def informix_connection(config)
+      config[:port] ||= 9088
+      config[:url] ||= "jdbc:informix-sqli://#{config[:host]}:#{config[:port]}/#{config[:database]}:INFORMIXSERVER=#{config[:servername]}"
+      config[:driver] = 'com.informix.jdbc.IfxDriver'
+      jdbc_connection(config)
+    end
+  end
+
+  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.adapter_matcher(name, *)
+      name =~ /informix/i ? self : false
+    end
+
+    def self.column_selector
+      [ /informix/i,
+        lambda { |cfg, column| column.extend(::JdbcSpec::Informix::Column) } ]
+    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, name = nil)
+      # Informix does not like "= NULL", "!= NULL", or "<> NULL".
+      execute(sql.gsub(/(!=|<>)\s*null/i, "IS NOT NULL").gsub(/=\s*null/i, "IS NULL"), name)
+    end
+  end # module Informix
+end # module ::JdbcSpec