cmoran92-activerecord-jdbc-adapter 1.2.1

data/lib/arjdbc/derby.rb

@@ -0,0 +1,7 @@
+require 'arjdbc/jdbc'
+jdbc_require_driver 'jdbc/derby'
+require 'arjdbc/derby/connection_methods'
+require 'arjdbc/derby/adapter'
+
+
+

data/lib/arjdbc/derby/adapter.rb

@@ -0,0 +1,351 @@
+require 'arjdbc/jdbc/missing_functionality_helper'
+
+module ::ArJdbc
+  module Derby
+    def self.column_selector
+      [/derby/i, lambda {|cfg,col| col.extend(::ArJdbc::Derby::Column)}]
+    end
+
+    def self.monkey_rails
+      unless defined?(@already_monkeyd)
+        # Needed because Rails is broken wrt to quoting of
+        # some values. Most databases are nice about it,
+        # but not Derby. The real issue is that you can't
+        # compare a CHAR value to a NUMBER column.
+        ::ActiveRecord::Associations::ClassMethods.module_eval do
+          private
+
+          def select_limited_ids_list(options, join_dependency)
+            connection.select_all(
+                                  construct_finder_sql_for_association_limiting(options, join_dependency),
+                                  "#{name} Load IDs For Limited Eager Loading"
+                                  ).collect { |row| connection.quote(row[primary_key], columns_hash[primary_key]) }.join(", ")
+          end
+        end
+
+        @already_monkeyd = true
+      end
+    end
+
+    def self.extended(*args)
+      monkey_rails
+    end
+
+    def self.included(*args)
+      monkey_rails
+    end
+
+    module Column
+      def simplified_type(field_type)
+        case field_type
+        when /smallint/i  then :boolean
+        when /real/i      then :float
+        else
+          super
+        end
+      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 =~ /^'(.*)'$/
+        return nil if value == "GENERATED_BY_DEFAULT"
+        value
+      end
+    end
+
+    def adapter_name #:nodoc:
+      'Derby'
+    end
+
+    def self.arel2_visitors(config)
+      require 'arel/visitors/derby'
+      {}.tap {|v| %w(derby jdbcderby).each {|a| v[a] = ::Arel::Visitors::Derby } }
+    end
+
+    include ArJdbc::MissingFunctionalityHelper
+
+    def index_name_length
+      128
+    end
+
+    # Convert the specified column type to a SQL string.
+    # In Derby, the following cannot specify a limit:
+    # - integer
+    # - boolean (smallint)
+    # - timestamp
+    # - date
+    def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+      return super unless [:integer, :boolean, :timestamp, :date].include? type
+
+      native = native_database_types[type.to_s.downcase.to_sym]
+      native.is_a?(Hash) ? native[:name] : native
+    end
+
+    def modify_types(tp)
+      tp[:primary_key] = "int generated by default as identity NOT NULL PRIMARY KEY"
+      tp[:string][:limit] = 256
+      tp[:integer][:limit] = nil
+      tp[:boolean] = {:name => "smallint"}
+      tp[:timestamp][:limit] = nil
+      tp[:date][:limit] = nil
+      tp
+    end
+
+    # Override default -- fix case where ActiveRecord passes :default => nil, :null => true
+    def add_column_options!(sql, options)
+      options.delete(:default) if options.has_key?(:default) && options[:default].nil?
+      sql << " DEFAULT #{quote(options.delete(:default))}" if options.has_key?(:default)
+      super
+    end
+
+    def classes_for_table_name(table)
+      ActiveRecord::Base.send(:subclasses).select {|klass| klass.table_name == table}
+    end
+
+    # Set the sequence to the max value of the table's column.
+    def reset_sequence!(table, column, sequence = nil)
+      mpk = select_value("SELECT MAX(#{quote_column_name(column)}) FROM #{quote_table_name(table)}")
+      execute("ALTER TABLE #{quote_table_name(table)} ALTER COLUMN #{quote_column_name(column)} RESTART WITH #{mpk.to_i + 1}")
+    end
+
+    def reset_pk_sequence!(table, pk = nil, sequence = nil)
+      klasses = classes_for_table_name(table)
+      klass   = klasses.nil? ? nil : klasses.first
+      pk      = klass.primary_key unless klass.nil?
+      if pk && klass.columns_hash[pk].type == :integer
+        reset_sequence!(klass.table_name, pk)
+      end
+    end
+
+    def remove_index(table_name, options) #:nodoc:
+      execute "DROP INDEX #{index_name(table_name, options)}"
+    end
+
+    def rename_table(name, new_name)
+      execute "RENAME TABLE #{quote_table_name(name)} TO #{quote_table_name(new_name)}"
+    end
+
+    AUTO_INC_STMT2 = "SELECT AUTOINCREMENTSTART, AUTOINCREMENTINC, COLUMNNAME, REFERENCEID, COLUMNDEFAULT FROM SYS.SYSCOLUMNS WHERE REFERENCEID = (SELECT T.TABLEID FROM SYS.SYSTABLES T WHERE T.TABLENAME = '%s') AND COLUMNNAME = '%s'"
+
+    def add_quotes(name)
+      return name unless name
+      %Q{"#{name}"}
+    end
+
+    def strip_quotes(str)
+      return str unless str
+      return str unless /^(["']).*\1$/ =~ str
+      str[1..-2]
+    end
+
+    def expand_double_quotes(name)
+      return name unless name && name['"']
+      name.gsub(/"/,'""')
+    end
+
+    def auto_increment_stmt(tname, cname)
+      stmt = AUTO_INC_STMT2 % [tname, strip_quotes(cname)]
+      data = execute(stmt).first
+      if data
+        start = data['autoincrementstart']
+        if start
+          coldef = ""
+          coldef << " GENERATED " << (data['columndefault'].nil? ? "ALWAYS" : "BY DEFAULT ")
+          coldef << "AS IDENTITY (START WITH "
+          coldef << start
+          coldef << ", INCREMENT BY "
+          coldef << data['autoincrementinc']
+          coldef << ")"
+          return coldef
+        end
+      end
+      ""
+    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 execute(sql, name = nil, binds = [])
+      sql = extract_sql(sql)
+      if sql =~ /\A\s*(UPDATE|INSERT)/i
+        i = sql =~ /\swhere\s/im
+        if i
+          sql[i..-1] = sql[i..-1].gsub(/!=\s*NULL/, 'IS NOT NULL').gsub(/=\sNULL/i, 'IS NULL')
+        end
+      else
+        sql.gsub!(/= NULL/i, 'IS NULL')
+      end
+      super
+    end
+
+    # SELECT DISTINCT clause for a given set of columns and a given ORDER BY clause.
+    #
+    # Derby requires the ORDER BY columns in the select list for distinct queries, and
+    # requires that the ORDER BY include the distinct column.
+    #
+    #   distinct("posts.id", "posts.created_at desc")
+    #
+    # Based on distinct method for PostgreSQL Adapter
+    def distinct(columns, order_by)
+      return "DISTINCT #{columns}" if order_by.blank?
+
+      # construct a clean list of column names from the ORDER BY clause, removing
+      # any asc/desc modifiers
+      order_columns = [order_by].flatten.map{|o| o.split(',').collect { |s| s.split.first } }.flatten.reject(&:blank?)
+      order_columns = order_columns.zip((0...order_columns.size).to_a).map { |s,i| "#{s} AS alias_#{i}" }
+
+      # return a DISTINCT clause that's distinct on the columns we want but includes
+      # all the required columns for the ORDER BY to work properly
+      sql = "DISTINCT #{columns}, #{order_columns * ', '}"
+      sql
+    end
+
+    SIZEABLE = %w(VARCHAR CLOB BLOB)
+
+    def structure_dump #:nodoc:
+      definition=""
+      rs = @connection.connection.meta_data.getTables(nil,nil,nil,["TABLE"].to_java(:string))
+      while rs.next
+        tname = rs.getString(3)
+        definition << "CREATE TABLE #{tname} (\n"
+        rs2 = @connection.connection.meta_data.getColumns(nil,nil,tname,nil)
+        first_col = true
+        while rs2.next
+          col_name = add_quotes(rs2.getString(4));
+          default = ""
+          d1 = rs2.getString(13)
+          if d1 =~ /^GENERATED_/
+            default = auto_increment_stmt(tname, col_name)
+          elsif d1
+            default = " DEFAULT #{d1}"
+          end
+
+          type = rs2.getString(6)
+          col_size = rs2.getString(7)
+          nulling = (rs2.getString(18) == 'NO' ? " NOT NULL" : "")
+          create_col_string = add_quotes(expand_double_quotes(strip_quotes(col_name))) +
+            " " +
+            type +
+            (SIZEABLE.include?(type) ? "(#{col_size})" : "") +
+            nulling +
+            default
+          if !first_col
+            create_col_string = ",\n #{create_col_string}"
+          else
+            create_col_string = " #{create_col_string}"
+          end
+
+          definition << create_col_string
+
+          first_col = false
+        end
+        definition << ");\n\n"
+      end
+      definition
+    end
+
+    def remove_column(table_name, column_name)
+      execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)} RESTRICT"
+    end
+
+    # Notes about changing in Derby:
+    #    http://db.apache.org/derby/docs/10.2/ref/rrefsqlj81859.html#rrefsqlj81859__rrefsqlj37860)
+    #
+    # We support changing columns using the strategy outlined in:
+    #    https://issues.apache.org/jira/browse/DERBY-1515
+    #
+    # This feature has not made it into a formal release and is not in Java 6.  We will
+    # need to conditionally support this somehow (supposed to arrive for 10.3.0.0)
+    def change_column(table_name, column_name, type, options = {})
+      # null/not nulling is easy, handle that separately
+      if options.include?(:null)
+        # This seems to only work with 10.2 of Derby
+        if options.delete(:null) == false
+          execute "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} NOT NULL"
+        else
+          execute "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} NULL"
+        end
+      end
+
+      # anything left to do?
+      unless options.empty?
+        begin
+          execute "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} SET DATA TYPE #{type_to_sql(type, options[:limit])}"
+        rescue
+          transaction do
+            temp_new_column_name = "#{column_name}_newtype"
+            # 1) ALTER TABLE t ADD COLUMN c1_newtype NEWTYPE;
+            add_column table_name, temp_new_column_name, type, options
+            # 2) UPDATE t SET c1_newtype = c1;
+            execute "UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(temp_new_column_name)} = CAST(#{quote_column_name(column_name)} AS #{type_to_sql(type, options[:limit])})"
+            # 3) ALTER TABLE t DROP COLUMN c1;
+            remove_column table_name, column_name
+            # 4) ALTER TABLE t RENAME COLUMN c1_newtype to c1;
+            rename_column table_name, temp_new_column_name, column_name
+          end
+        end
+      end
+    end
+
+    def rename_column(table_name, column_name, new_column_name) #:nodoc:
+      execute "RENAME COLUMN #{quote_table_name(table_name)}.#{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
+    end
+
+    def primary_keys(table_name)
+      @connection.primary_keys table_name.to_s.upcase
+    end
+
+    def columns(table_name, name=nil)
+      @connection.columns_internal(table_name.to_s, name, derby_schema)
+    end
+
+    def tables
+      @connection.tables(nil, derby_schema)
+    end
+
+    def recreate_database(db_name)
+      tables.each do |t|
+        drop_table t
+      end
+    end
+
+    def quote_column_name(name) #:nodoc:
+      %Q{"#{name.to_s.upcase.gsub(/\"/, '""')}"}
+    end
+
+    def quoted_true
+      '1'
+    end
+
+    def quoted_false
+      '0'
+    end
+
+    def add_limit_offset!(sql, options) #:nodoc:
+      if options[:offset]
+        sql << " OFFSET #{options[:offset]} ROWS"
+      end
+      if options[:limit]
+        #ROWS/ROW and FIRST/NEXT mean the same
+        sql << " FETCH FIRST #{options[:limit]} ROWS ONLY"
+      end
+    end
+
+    private
+    # Derby appears to define schemas using the username
+    def derby_schema
+      if @config.has_key?(:schema)
+        config[:schema]
+      else
+        (@config[:username] && @config[:username].to_s) || ''
+      end
+    end
+  end
+end
+
+

data/lib/arjdbc/derby/connection_methods.rb

@@ -0,0 +1,19 @@
+module ActiveRecord
+  class Base
+    class << self
+      def derby_connection(config)
+        config[:url] ||= "jdbc:derby:#{config[:database]};create=true"
+        config[:driver] ||= "org.apache.derby.jdbc.EmbeddedDriver"
+        config[:adapter_spec] = ::ArJdbc::Derby
+        conn = embedded_driver(config)
+        md = conn.jdbc_connection.meta_data
+        if md.database_major_version < 10 || (md.database_major_version == 10 && md.database_minor_version < 5)
+          raise ::ActiveRecord::ConnectionFailed, "Derby adapter requires Derby 10.5 or later"
+        end
+        conn
+      end
+
+      alias_method :jdbcderby_connection, :derby_connection
+    end
+  end
+end

data/lib/arjdbc/discover.rb

@@ -0,0 +1,92 @@
+# arjdbc/discover.rb: Declare ArJdbc.extension modules in this file
+# that loads a custom module and adapter.
+
+module ::ArJdbc
+  # Adapters built-in to AR are required up-front so we can override
+  # the native ones
+  require 'arjdbc/mysql'
+  extension :MySQL do |name|
+    name =~ /mysql/i
+  end
+
+  require 'arjdbc/postgresql'
+  extension :PostgreSQL do |name|
+    name =~ /postgre/i
+  end
+
+  require 'arjdbc/sqlite3'
+  extension :SQLite3 do |name|
+    name =~ /sqlite/i
+  end
+
+  # Other adapters are lazy-loaded
+  extension :DB2 do |name, config|
+    if name =~ /(db2|as400)/i && config[:url] !~ /^jdbc:derby:net:/
+      require 'arjdbc/db2'
+      true
+    end
+  end
+
+  extension :Derby do |name|
+    if name =~ /derby/i
+      require 'arjdbc/derby'
+      true
+    end
+  end
+
+  extension :FireBird do |name|
+    if name =~ /firebird/i
+      require 'arjdbc/firebird'
+      true
+    end
+  end
+
+  extension :H2 do |name|
+    if name =~ /\.h2\./i
+      require 'arjdbc/h2'
+      true
+    end
+  end
+
+  extension :HSQLDB do |name|
+    if name =~ /hsqldb/i
+      require 'arjdbc/hsqldb'
+      true
+    end
+  end
+
+  extension :Informix do |name|
+    if name =~ /informix/i
+      require 'arjdbc/informix'
+      true
+    end
+  end
+
+  extension :Mimer do |name|
+    if name =~ /mimer/i
+      require 'arjdbc/mimer'
+      true
+    end
+  end
+
+  extension :MsSQL do |name|
+    if name =~ /sqlserver|tds|Microsoft SQL/i
+      require 'arjdbc/mssql'
+      true
+    end
+  end
+
+  extension :Oracle do |name|
+    if name =~ /oracle/i
+      require 'arjdbc/oracle'
+      true
+    end
+  end
+
+  extension :Sybase do |name|
+    if name =~ /sybase|tds/i
+      require 'arjdbc/sybase'
+      true
+    end
+  end
+end