activerecord-jdbc-adapter 0.8 → 0.8.1

data/lib/jdbc_adapter/jdbc_mysql.rb

@@ -26,16 +26,16 @@ module ::JdbcSpec
     def self.adapter_selector
       [/mysql/i, lambda {|cfg,adapt| adapt.extend(::JdbcSpec::MySQL)}]
     end
-    
+
     def self.extended(adapter)
       adapter.execute("SET SQL_AUTO_IS_NULL=0")
     end
-    
+
     module Column
       TYPES_ALLOWING_EMPTY_STRING_DEFAULT = Set.new([:binary, :string, :text])
 
       def simplified_type(field_type)
-        return :boolean if field_type =~ /tinyint\(1\)|bit/i 
+        return :boolean if field_type =~ /tinyint\(1\)|bit/i
         return :string  if field_type =~ /enum/i
         super
       end
@@ -44,7 +44,7 @@ module ::JdbcSpec
         @original_default = default
         @default = nil if missing_default_forged_as_empty_string?
       end
-      
+
       # MySQL misreports NOT NULL column default when none is given.
       # We can't detect this for columns which may have a legitimate ''
       # default (string, text, binary) but we can for others (integer,
@@ -56,7 +56,7 @@ module ::JdbcSpec
         !null && @original_default == '' && !TYPES_ALLOWING_EMPTY_STRING_DEFAULT.include?(type)
       end
     end
-    
+
     def modify_types(tp)
       tp[:primary_key] = "int(11) DEFAULT NULL auto_increment PRIMARY KEY"
       tp[:decimal] = { :name => "decimal" }
@@ -64,12 +64,12 @@ module ::JdbcSpec
       tp[:datetime][:limit] = nil
       tp
     end
-    
+
     # QUOTING ==================================================
-    
+
     def quote(value, column = nil)
       return value.quoted_id if value.respond_to?(:quoted_id)
-      
+
       if column && column.type == :primary_key
         value.to_s
       elsif column && String === value && column.type == :binary && column.class.respond_to?(:string_to_binary)
@@ -81,7 +81,7 @@ module ::JdbcSpec
         super
       end
     end
-    
+
     def quote_column_name(name) #:nodoc:
         "`#{name}`"
     end
@@ -89,15 +89,15 @@ module ::JdbcSpec
     def quote_table_name(name) #:nodoc:
       quote_column_name(name).gsub('.', '`.`')
     end
-    
+
     def quoted_true
         "1"
     end
-    
+
     def quoted_false
         "0"
     end
-    
+
     def begin_db_transaction #:nodoc:
       @connection.begin
     rescue Exception
@@ -116,16 +116,25 @@ module ::JdbcSpec
       # Transactions aren't supported
     end
 
+    def disable_referential_integrity(&block) #:nodoc:
+      old = select_value("SELECT @@FOREIGN_KEY_CHECKS")
+      begin
+        update("SET FOREIGN_KEY_CHECKS = 0")
+        yield
+      ensure
+        update("SET FOREIGN_KEY_CHECKS = #{old}")
+      end
+    end
 
     # SCHEMA STATEMENTS ========================================
-    
+
     def structure_dump #:nodoc:
       if supports_views?
         sql = "SHOW FULL TABLES WHERE Table_type = 'BASE TABLE'"
       else
         sql = "SHOW TABLES"
       end
-      
+
       select_all(sql).inject("") do |structure, table|
         table.delete('Table_type')
 
@@ -135,15 +144,15 @@ module ::JdbcSpec
           structure += table + ";\n\n"
         elsif(view = hash["Create View"])
           structure += view + ";\n\n"
-        end        
+        end
       end
     end
-    
+
     def recreate_database(name) #:nodoc:
       drop_database(name)
       create_database(name)
     end
-    
+
     def create_database(name, options = {}) #:nodoc:
       if options[:collation]
         execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}` COLLATE `#{options[:collation]}`"
@@ -151,29 +160,29 @@ module ::JdbcSpec
         execute "CREATE DATABASE `#{name}` DEFAULT CHARACTER SET `#{options[:charset] || 'utf8'}`"
       end
     end
-    
+
     def drop_database(name) #:nodoc:
       execute "DROP DATABASE IF EXISTS `#{name}`"
     end
-    
+
     def current_database
       select_one("SELECT DATABASE() as db")["db"]
     end
-    
+
     def create_table(name, options = {}) #:nodoc:
       super(name, {:options => "ENGINE=InnoDB CHARACTER SET utf8 COLLATE utf8_bin"}.merge(options))
     end
-    
+
     def rename_table(name, new_name)
       execute "RENAME TABLE #{quote_table_name(name)} TO #{quote_table_name(new_name)}"
-    end  
-    
+    end
+
     def change_column_default(table_name, column_name, default) #:nodoc:
       current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'")["Type"]
 
       execute("ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_column_name(column_name)} #{quote_column_name(column_name)} #{current_type} DEFAULT #{quote(default)}")
     end
-    
+
     def change_column(table_name, column_name, type, options = {}) #:nodoc:
       unless options_include_default?(options)
         if column = columns(table_name).find { |c| c.name == column_name.to_s }
@@ -193,7 +202,7 @@ module ::JdbcSpec
       current_type = cols["Type"] || cols["COLUMN_TYPE"]
       execute "ALTER TABLE #{quote_table_name(table_name)} CHANGE #{quote_table_name(column_name)} #{quote_column_name(new_column_name)} #{current_type}"
     end
-    
+
     def add_limit_offset!(sql, options) #:nodoc:
       if limit = options[:limit]
         unless offset = options[:offset]

data/lib/jdbc_adapter/jdbc_oracle.rb

@@ -65,12 +65,7 @@ module ::JdbcSpec
         else value
         end
       end
-      
-      def type_cast_code(var_name)
-        return "JdbcSpec::Oracle::Column.cast_to_date_or_time(#{var_name})" if type == :datetime
-        super
-      end
-      
+
       private
       def simplified_type(field_type)
         case field_type
@@ -317,7 +312,12 @@ module ::JdbcSpec
           return value.to_s
         end
         case value
-        when String, ActiveSupport::Multibyte::Chars     : %Q{'#{quote_string(value)}'}
+        when String, ActiveSupport::Multibyte::Chars
+          if column.type == :datetime
+            %Q{TIMESTAMP'#{value}'}
+          else
+            %Q{'#{quote_string(value)}'}
+          end
         when NilClass   : 'null'
         when TrueClass  : '1'
         when FalseClass : '0'

data/lib/jdbc_adapter/jdbc_postgre.rb

@@ -165,7 +165,7 @@ module ::JdbcSpec
     def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
       execute(sql, name)
       table = sql.split(" ", 4)[2]
-      id_value || last_insert_id(table, sequence_name || default_sequence_name(table, pk))
+      id_value || pk && last_insert_id(table, sequence_name || default_sequence_name(table, pk))
     end
 
     def columns(table_name, name=nil)

data/lib/jdbc_adapter/jdbc_sqlite3.rb

@@ -0,0 +1,188 @@
+module ::JdbcSpec
+  module ActiveRecordExtensions
+    def sqlite3_connection(config)
+      config[:url] ||= "jdbc:sqlite:#{config[:database]}"
+      config[:driver] ||= "org.sqlite.JDBC"
+      jdbc_connection(config)
+    end
+  end
+
+  module SQLite3
+    def self.column_selector
+      [/sqlite/i, lambda {|cfg,col| col.extend(::JdbcSpec::SQLite3::Column)}]
+    end
+
+    def self.adapter_selector
+      [/sqlite/i, lambda {|cfg,adapt| adapt.extend(::JdbcSpec::SQLite3)}]
+    end
+
+    module Column
+
+      private
+      def simplified_type(field_type)
+        case field_type
+        when /^integer\(1\)$/i                  then :boolean
+        when /text/i                           then :string
+        when /int/i                            then :integer
+        when /real/i                   then @scale == 0 ? :integer : :decimal
+        when /date|time/i                      then :datetime
+        when /blob/i                           then :binary
+        end
+      end
+
+      def self.cast_to_date_or_time(value)
+        return value if value.is_a? Date
+        return nil if value.blank?
+        guess_date_or_time((value.is_a? Time) ? value : cast_to_time(value))
+      end
+
+      def self.cast_to_time(value)
+        return value if value.is_a? Time
+        Time.at(value) rescue nil
+      end
+
+      def self.guess_date_or_time(value)
+        (value.hour == 0 and value.min == 0 and value.sec == 0) ?
+        Date.new(value.year, value.month, value.day) : value
+      end
+    end
+
+    def type_cast(value)
+      return nil if value.nil?
+      case type
+      when :string   then value
+      when :integer  then defined?(value.to_i) ? value.to_i : (value ? 1 : 0)
+      when :primary_key then defined?(value.to_i) ? value.to_i : (value ? 1 : 0)
+      when :float    then value.to_f
+      when :datetime then JdbcSpec::SQLite3::Column.cast_to_date_or_time(value)
+      when :time     then JdbcSpec::SQLite3::Column.cast_to_time(value)
+      when :decimal   then self.class.value_to_decimal(value)
+      when :boolean   then self.class.value_to_boolean(value)
+      else value
+      end
+    end
+
+    def modify_types(tp)
+      tp[:primary_key] = "INTEGER PRIMARY KEY AUTOINCREMENT"
+      tp[:float] = { :name => "REAL" }
+      tp[:decimal] = { :name => "REAL" }
+      tp[:datetime] = { :name => "INTEGER" }
+      tp[:timestamp] = { :name => "INTEGER" }
+      tp[:time] = { :name => "INTEGER" }
+      tp[:date] = { :name => "INTEGER" }
+      tp[:boolean] = { :name => "INTEGER", :limit => 1}
+      tp
+    end
+
+    def quote(value, column = nil) # :nodoc:
+      return value.quoted_id if value.respond_to?(:quoted_id)
+
+      case value
+      when String
+        if column && column.type == :binary
+          "'#{quote_string(value).unpack("C*").collect {|v| v.to_s(16)}.join}'"
+        else
+          "'#{quote_string(value)}'"
+        end
+      else super
+      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 remove_column(table_name, column_name) #:nodoc:
+      cols = columns(table_name).collect {|col| col.name}
+      cols.delete(column_name)
+      cols = cols.join(', ')
+      table_backup = table_name + "_backup"
+
+      @connection.begin
+
+      execute "CREATE TEMPORARY TABLE #{table_backup}(#{cols})"
+      insert "INSERT INTO #{table_backup} SELECT #{cols} FROM #{table_name}"
+      execute "DROP TABLE #{table_name}"
+      execute "CREATE TABLE #{table_name}(#{cols})"
+      insert "INSERT INTO #{table_name} SELECT #{cols} FROM #{table_backup}"
+      execute "DROP TABLE #{table_backup}"
+
+      @connection.commit
+    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
+
+    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("SELECT SEQ FROM SQLITE_SEQUENCE WHERE NAME = '#{table}'"))
+    end
+
+    def add_limit_offset!(sql, options) #:nodoc:
+      if options[:limit]
+        sql << " LIMIT #{options[:limit]}"
+        sql << " OFFSET #{options[:offset]}" if options[:offset]
+      end
+    end
+
+    def tables
+      @connection.tables.select {|row| row.to_s !~ /^sqlite_/i }
+    end
+
+    def remove_index(table_name, options = {})
+      execute "DROP INDEX #{quote_column_name(index_name(table_name, options))}"
+    end
+
+    def indexes(table_name, name = nil)
+      result = select_rows("SELECT name, sql FROM sqlite_master WHERE tbl_name = '#{table_name}' AND type = 'index'", name)
+
+      result.collect do |row|
+        name = row[0]
+        index_sql = row[1]
+        unique = (index_sql =~ /unique/i)
+        cols = index_sql.match(/\((.*)\)/)[1].gsub(/,/,' ').split
+        ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, name, unique, cols)
+      end
+    end
+  end
+end

data/lib/jdbc_adapter/jdbc_sybase.rb

@@ -0,0 +1,39 @@
+module JdbcSpec
+  module Sybase
+    def self.adapter_selector
+      [/sybase/i, lambda{|cfg,adapt| adapt.extend(JdbcSpec::Sybase)}]
+    end
+
+      def add_limit_offset!(sql, options) # :nodoc:
+        @limit = options[:limit]
+        @offset = options[:offset]
+        if use_temp_table?
+          # Use temp table to hack offset with Sybase
+          sql.sub!(/ FROM /i, ' INTO #artemp FROM ')
+        elsif zero_limit?
+          # "SET ROWCOUNT 0" turns off limits, so we havesy
+          # to use a cheap trick.
+          if sql =~ /WHERE/i
+            sql.sub!(/WHERE/i, 'WHERE 1 = 2 AND ')
+          elsif sql =~ /ORDER\s+BY/i
+            sql.sub!(/ORDER\s+BY/i, 'WHERE 1 = 2 ORDER BY')
+          else
+            sql << 'WHERE 1 = 2'
+          end
+        end
+      end
+
+      # If limit is not set at all, we can ignore offset;
+      # if limit *is* set but offset is zero, use normal select
+      # with simple SET ROWCOUNT.  Thus, only use the temp table
+      # if limit is set and offset > 0.
+      def use_temp_table?
+        !@limit.nil? && !@offset.nil? && @offset > 0
+      end
+
+      def zero_limit?
+        !@limit.nil? && @limit == 0
+      end
+
+  end
+end

data/lib/jdbc_adapter/tsql_helper.rb

@@ -0,0 +1,59 @@
+# Common methods for handling TSQL databases.
+module TSqlMethods
+
+  def modify_types(tp) #:nodoc:
+    tp[:primary_key] = "int NOT NULL IDENTITY(1, 1) PRIMARY KEY"
+    tp[:integer][:limit] = nil
+    tp[:boolean] = {:name => "bit"}
+    tp[:binary] = { :name => "image"}
+    tp
+  end
+
+  def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+    return super unless type.to_s == 'integer'
+    
+    if limit.nil? || limit == 4
+      'int'
+    elsif limit == 2
+      'smallint'
+    elsif limit == 1
+      'tinyint'
+    else
+      'bigint'
+    end
+  end
+
+  def add_limit_offset!(sql, options)
+    if options[:limit] and options[:offset]
+      total_rows = select_all("SELECT count(*) as TotalRows from (#{sql.gsub(/\bSELECT(\s+DISTINCT)?\b/i, "SELECT\\1 TOP 1000000000")}) tally")[0]["TotalRows"].to_i
+      if (options[:limit] + options[:offset]) >= total_rows
+        options[:limit] = (total_rows - options[:offset] >= 0) ? (total_rows - options[:offset]) : 0
+      end
+      sql.sub!(/^\s*SELECT(\s+DISTINCT)?/i, "SELECT * FROM (SELECT TOP #{options[:limit]} * FROM (SELECT\\1 TOP #{options[:limit] + options[:offset]} ")
+      sql << ") AS tmp1"
+      if options[:order]
+        options[:order] = options[:order].split(',').map do |field|
+          parts = field.split(" ")
+          tc = parts[0]
+          if sql =~ /\.\[/ and tc =~ /\./ # if column quoting used in query
+            tc.gsub!(/\./, '\\.\\[')
+            tc << '\\]'
+          end
+          if sql =~ /#{tc} AS (t\d_r\d\d?)/
+              parts[0] = $1
+          elsif parts[0] =~ /\w+\.(\w+)/
+            parts[0] = $1
+          end
+          parts.join(' ')
+        end.join(', ')
+        sql << " ORDER BY #{change_order_direction(options[:order])}) AS tmp2 ORDER BY #{options[:order]}"
+      else
+        sql << " ) AS tmp2"
+      end
+    elsif sql !~ /^\s*SELECT (@@|COUNT\()/i
+      sql.sub!(/^\s*SELECT(\s+DISTINCT)?/i) do
+        "SELECT#{$1} TOP #{options[:limit]}"
+      end unless options[:limit].nil?
+    end
+  end
+end