activerecord-jdbc-adapter 0.9.0.1 → 0.9.1

data/lib/jdbc_adapter/jdbc_postgre.rb

@@ -1,3 +1,4 @@
+
 module ::JdbcSpec
   # Don't need to load native postgres adapter
   $LOADED_FEATURES << "active_record/connection_adapters/postgresql_adapter.rb"
@@ -14,12 +15,16 @@ module ::JdbcSpec
   end
 
   module PostgreSQL
+    def self.adapter_matcher(name, *)
+      name =~ /postgre/i ? self : false
+    end
+
     def self.column_selector
       [/postgre/i, lambda {|cfg,col| col.extend(::JdbcSpec::PostgreSQL::Column)}]
     end
 
-    def self.adapter_selector
-      [/postgre/i, lambda {|cfg,adapt| adapt.extend(::JdbcSpec::PostgreSQL)}]
+    def self.jdbc_connection_class
+      ::ActiveRecord::ConnectionAdapters::PostgresJdbcConnection
     end
 
     module Column
@@ -42,6 +47,7 @@ module ::JdbcSpec
       end
 
       def cast_to_boolean(value)
+        return nil if value.nil?
         if value == true || value == false
           value
         else
@@ -49,24 +55,7 @@ module ::JdbcSpec
         end
       end
 
-      def 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 cast_to_time(value)
-        return value if value.is_a? Time
-        time_array = ParseDate.parsedate value
-        time_array[0] ||= 2000; time_array[1] ||= 1; time_array[2] ||= 1;
-        Time.send(ActiveRecord::Base.default_timezone, *time_array) rescue nil
-      end
-
-      def 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
-
+      # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
       def default_value(value)
         # Boolean types
         return "t" if value =~ /true/i
@@ -95,13 +84,62 @@ module ::JdbcSpec
       tp
     end
 
+    def postgresql_version
+      @postgresql_version ||=
+        begin
+          select('SELECT version()').to_a[0][0] =~ /PostgreSQL (\d+)\.(\d+)\.(\d+)/
+          ($1.to_i * 10000) + ($2.to_i * 100) + $3.to_i
+        rescue
+          0
+        end
+    end
+
+    # Does PostgreSQL support migrations?
+    def supports_migrations?
+      true
+    end
+
+    # Does PostgreSQL support standard conforming strings?
+    def supports_standard_conforming_strings?
+      # Temporarily set the client message level above error to prevent unintentional
+      # error messages in the logs when working on a PostgreSQL database server that
+      # does not support standard conforming strings.
+      client_min_messages_old = client_min_messages
+      self.client_min_messages = 'panic'
+
+      # postgres-pr does not raise an exception when client_min_messages is set higher
+      # than error and "SHOW standard_conforming_strings" fails, but returns an empty
+      # PGresult instead.
+      has_support = select('SHOW standard_conforming_strings').to_a[0][0] rescue false
+      self.client_min_messages = client_min_messages_old
+      has_support
+    end
+
+    def supports_insert_with_returning?
+      postgresql_version >= 80200
+    end
+
+    def supports_ddl_transactions?
+      true
+    end
+
+    def supports_savepoints?
+      true
+    end
+
+    # Returns the configured supported identifier length supported by PostgreSQL,
+    # or report the default of 63 on PostgreSQL 7.x.
+    def table_alias_length
+      @table_alias_length ||= (postgresql_version >= 80000 ? select('SHOW max_identifier_length').to_a[0][0].to_i : 63)
+    end
+
     def default_sequence_name(table_name, pk = nil)
       default_pk, default_seq = pk_and_sequence_for(table_name)
       default_seq || "#{table_name}_#{pk || default_pk || 'id'}_seq"
     end
 
     # Resets sequence to the max value of the table's pk if present.
-    def reset_pk_sequence!(table, pk = nil, sequence = nil)
+    def reset_pk_sequence!(table, pk = nil, sequence = nil) #:nodoc:
       unless pk and sequence
         default_pk, default_sequence = pk_and_sequence_for(table)
         pk ||= default_pk
@@ -109,28 +147,35 @@ module ::JdbcSpec
       end
       if pk
         if sequence
+          quoted_sequence = quote_column_name(sequence)
+
           select_value <<-end_sql, 'Reset sequence'
-            SELECT setval('#{sequence}', (SELECT COALESCE(MAX(#{pk})+(SELECT increment_by FROM #{sequence}), (SELECT min_value FROM #{sequence})) FROM #{table}), false)
-          end_sql
+              SELECT setval('#{quoted_sequence}', (SELECT COALESCE(MAX(#{quote_column_name pk})+(SELECT increment_by FROM #{quoted_sequence}), (SELECT min_value FROM #{quoted_sequence})) FROM #{quote_table_name(table)}), false)
+            end_sql
         else
           @logger.warn "#{table} has primary key #{pk} with no default sequence" if @logger
         end
       end
     end
 
+    def quote_regclass(table_name)
+      table_name.to_s.split('.').map do |part| 
+        part =~ /".*"/i ? part : quote_table_name(part)
+      end.join('.')  
+    end
+
     # Find a table's primary key and sequence.
-    def pk_and_sequence_for(table)
+    def pk_and_sequence_for(table) #:nodoc:
       # First try looking for a sequence with a dependency on the
       # given table's primary key.
-        result = select(<<-end_sql, 'PK and serial sequence')[0]
-          SELECT attr.attname AS nm, name.nspname AS nsp, seq.relname AS rel
+      result = select(<<-end_sql, 'PK and serial sequence')[0]
+          SELECT attr.attname, seq.relname
           FROM pg_class      seq,
                pg_attribute  attr,
                pg_depend     dep,
                pg_namespace  name,
                pg_constraint cons
           WHERE seq.oid           = dep.objid
-            AND seq.relnamespace  = name.oid
             AND seq.relkind       = 'S'
             AND attr.attrelid     = dep.refobjid
             AND attr.attnum       = dep.refobjsubid
@@ -140,15 +185,19 @@ module ::JdbcSpec
             AND dep.refobjid      = '#{table}'::regclass
         end_sql
 
-        if result.nil? or result.empty?
-          # If that fails, try parsing the primary key's default value.
-          # Support the 7.x and 8.0 nextval('foo'::text) as well as
-          # the 8.1+ nextval('foo'::regclass).
-          # TODO: assumes sequence is in same schema as table.
-          result = select(<<-end_sql, 'PK and custom sequence')[0]
-            SELECT attr.attname AS nm, name.nspname AS nsp, split_part(def.adsrc, '\\\'', 2) AS rel
+      if result.nil? or result.empty?
+        # If that fails, try parsing the primary key's default value.
+        # Support the 7.x and 8.0 nextval('foo'::text) as well as
+        # the 8.1+ nextval('foo'::regclass).
+        result = query(<<-end_sql, 'PK and custom sequence')[0]
+            SELECT attr.attname,
+              CASE
+                WHEN split_part(def.adsrc, '''', 2) ~ '.' THEN
+                  substr(split_part(def.adsrc, '''', 2),
+                         strpos(split_part(def.adsrc, '''', 2), '.')+1)
+                ELSE split_part(def.adsrc, '''', 2)
+              END as relname
             FROM pg_class       t
-            JOIN pg_namespace   name ON (t.relnamespace = name.oid)
             JOIN pg_attribute   attr ON (t.oid = attrelid)
             JOIN pg_attrdef     def  ON (adrelid = attrelid AND adnum = attnum)
             JOIN pg_constraint  cons ON (conrelid = adrelid AND adnum = conkey[1])
@@ -156,17 +205,40 @@ module ::JdbcSpec
               AND cons.contype = 'p'
               AND def.adsrc ~* 'nextval'
           end_sql
+      end
+
+      [result["attname"], result["relname"]]
+    rescue
+      nil
+    end
+
+    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+      # Extract the table from the insert sql. Yuck.
+      table = sql.split(" ", 4)[2].gsub('"', '')
+
+      # Try an insert with 'returning id' if available (PG >= 8.2)
+      if supports_insert_with_returning?
+        pk, sequence_name = *pk_and_sequence_for(table) unless pk
+        if pk
+          id = select_value("#{sql} RETURNING #{quote_column_name(pk)}")
+          clear_query_cache
+          return id
         end
-        # check for existence of . in sequence name as in public.foo_sequence.  if it does not exist, join the current namespace
-        result['rel']['.'] ? [result['nm'], result['rel']] : [result['nm'], "#{result['nsp']}.#{result['rel']}"]
-      rescue
-        nil
       end
 
-    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
+      # Otherwise, insert then grab last_insert_id.
       execute(sql, name)
-      table = sql.split(" ", 4)[2]
-      id_value || pk && last_insert_id(table, sequence_name || default_sequence_name(table, pk))
+
+      # If neither pk nor sequence name is given, look them up.
+      unless pk || sequence_name
+        pk, sequence_name = *pk_and_sequence_for(table)
+      end
+
+      # If a pk is given, fallback to default sequence name.
+      # Don't fetch last insert id for a table without a pk.
+      if pk && sequence_name ||= default_sequence_name(table, pk)
+        last_insert_id(table, sequence_name)
+      end
     end
 
     def columns(table_name, name=nil)
@@ -248,18 +320,11 @@ module ::JdbcSpec
 
       @connection.connection.close
       begin
-        file = "db/#{RAILS_ENV}_structure.sql"
-        `pg_dump -i -U "#{@config[:username]}" -s -x -O -f #{file} #{search_path} #{database}`
+        definition = `pg_dump -i -U "#{@config[:username]}" -s -x -O #{search_path} #{database}`
         raise "Error dumping database" if $?.exitstatus == 1
 
         # need to patch away any references to SQL_ASCII as it breaks the JDBC driver
-        lines = File.readlines(file)
-        File.open(file, "w") do |io|
-          lines.each do |line|
-            line.gsub!(/SQL_ASCII/, 'UNICODE')
-            io.write(line)
-          end
-        end
+        definition.gsub(/SQL_ASCII/, 'UNICODE')
       ensure
         reconnect!
       end
@@ -333,8 +398,12 @@ module ::JdbcSpec
       %("#{name}")
     end
 
-    def quoted_date(value)
-      value.strftime("%Y-%m-%d %H:%M:%S")
+    def quoted_date(value) #:nodoc:
+      if value.acts_like?(:time) && value.respond_to?(:usec)
+        "#{super}.#{sprintf("%06d", value.usec)}"
+      else
+        super
+      end
     end
 
     def disable_referential_integrity(&block) #:nodoc:
@@ -349,17 +418,17 @@ module ::JdbcSpec
     end
 
     def add_column(table_name, column_name, type, options = {})
-      execute("ALTER TABLE #{table_name} ADD #{column_name} #{type_to_sql(type, options[:limit])}")
+      execute("ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit])}")
       change_column_default(table_name, column_name, options[:default]) unless options[:default].nil?
       if options[:null] == false
-        execute("UPDATE #{table_name} SET #{column_name} = '#{options[:default]}'") if options[:default]
-        execute("ALTER TABLE #{table_name} ALTER #{column_name} SET NOT NULL")
+        execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)} = '#{options[:default]}'") if options[:default]
+        execute("ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} SET NOT NULL")
       end
     end
 
     def change_column(table_name, column_name, type, options = {}) #:nodoc:
       begin
-        execute "ALTER TABLE #{table_name} ALTER  #{column_name} TYPE #{type_to_sql(type, options[:limit])}"
+        execute "ALTER TABLE #{quote_table_name(table_name)} ALTER #{quote_column_name(column_name)} TYPE #{type_to_sql(type, options[:limit])}"
       rescue ActiveRecord::StatementInvalid
         # This is PG7, so we use a more arcane way of doing it.
         begin_db_transaction
@@ -373,11 +442,11 @@ module ::JdbcSpec
     end
 
     def change_column_default(table_name, column_name, default) #:nodoc:
-      execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET DEFAULT '#{default}'"
+      execute "ALTER TABLE #{quote_table_name(table_name)} ALTER COLUMN #{quote_column_name(column_name)} SET DEFAULT '#{default}'"
     end
 
     def rename_column(table_name, column_name, new_column_name) #:nodoc:
-      execute "ALTER TABLE #{table_name} RENAME COLUMN #{column_name} TO #{new_column_name}"
+      execute "ALTER TABLE #{quote_table_name(table_name)} RENAME COLUMN #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
     end
 
     def remove_index(table_name, options) #:nodoc:
@@ -401,3 +470,4 @@ module ::JdbcSpec
     end
   end
 end
+

data/lib/jdbc_adapter/jdbc_sqlite3.rb

@@ -1,35 +1,94 @@
 module ::JdbcSpec
   module ActiveRecordExtensions
     def sqlite3_connection(config)
+      parse_sqlite3_config!(config)
+
       config[:url] ||= "jdbc:sqlite:#{config[:database]}"
       config[:driver] ||= "org.sqlite.JDBC"
       jdbc_connection(config)
     end
+
+    def parse_sqlite3_config!(config)
+      config[:database] ||= config[:dbfile]
+
+      # Allow database path relative to RAILS_ROOT, but only if
+      # the database path is not the special path that tells
+      # Sqlite to build a database only in memory.
+      if Object.const_defined?(:RAILS_ROOT) && ':memory:' != config[:database]
+        config[:database] = File.expand_path(config[:database], RAILS_ROOT)
+      end
+    end
   end
 
   module SQLite3
+    def self.adapter_matcher(name, *)
+      name =~ /sqlite/i ? self : false
+    end
+
     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)}]
+    def self.jdbc_connection_class
+      ::ActiveRecord::ConnectionAdapters::Sqlite3JdbcConnection
     end
 
     module Column
 
+      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 :date 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
+
       private
       def simplified_type(field_type)
         case field_type
-        when /^integer\(1\)$/i                  then :boolean
+        when /boolean/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 /float/i                          then :float
+        when /real/i                           then @scale == 0 ? :integer : :decimal
+        when /datetime/i                       then :datetime
+        when /date/i                           then :date
+        when /time/i                           then :time
         when /blob/i                           then :binary
         end
       end
 
+      def extract_precision(sql_type)
+        case sql_type
+          when /^(real)\((\d+)(,\d+)?\)/i then $2.to_i 
+          else super
+        end 
+      end
+      
+      def extract_scale(sql_type)
+        case sql_type
+          when /^(real)\((\d+)\)/i then 0
+          when /^(real)\((\d+)(,(\d+))\)/i then $4.to_i
+          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 =~ /^'(.*)'$/
+
+        value
+      end
+
       def self.cast_to_date_or_time(value)
         return value if value.is_a? Date
         return nil if value.blank?
@@ -38,7 +97,9 @@ module ::JdbcSpec
 
       def self.cast_to_time(value)
         return value if value.is_a? Time
-        Time.at(value) rescue nil
+        time_array = ParseDate.parsedate value
+        time_array[0] ||= 2000; time_array[1] ||= 1; time_array[2] ||= 1;
+        Time.send(ActiveRecord::Base.default_timezone, *time_array) rescue nil
       end
 
       def self.guess_date_or_time(value)
@@ -47,40 +108,40 @@ module ::JdbcSpec
       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
+    def adapter_name #:nodoc:
+      'SQLite'
+    end
+
+    def supports_count_distinct? #:nodoc:
+      sqlite_version >= '3.2.6'
+    end
+
+    def supports_autoincrement? #:nodoc:
+      sqlite_version >= '3.1.0'
+    end
+
+    def sqlite_version
+      @sqlite_version ||= select_value('select sqlite_version(*)')
     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[:datetime] = { :name => "DATETIME" }
+      tp[:timestamp] = { :name => "DATETIME" }
+      tp[:time] = { :name => "TIME" }
+      tp[:date] = { :name => "DATE" }
+      tp[:boolean] = { :name => "BOOLEAN" }
       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}'"
+          "'#{quote_string(column.class.string_to_binary(value))}'"
         else
           "'#{quote_string(value)}'"
         end
@@ -88,16 +149,27 @@ module ::JdbcSpec
       end
     end
 
+    def quote_column_name(name) #:nodoc:
+      name = name.to_s
+      # Did not find reference on values needing quoting, but these
+      # happen in AR unit tests
+      if name == "references" || name =~ /-/
+        %Q("#{name}") 
+      else
+        name
+      end
+    end
+
     def quote_string(str)
       str.gsub(/'/, "''")
     end
 
     def quoted_true
-      '1'
+      %Q{'t'}
     end
 
     def quoted_false
-      '0'
+      %Q{'f'}
     end
 
     def add_column(table_name, column_name, type, options = {})
@@ -184,5 +256,54 @@ module ::JdbcSpec
         ::ActiveRecord::ConnectionAdapters::IndexDefinition.new(table_name, name, unique, cols)
       end
     end
+
+    def recreate_database(name)
+      tables.each{ |table| drop_table(table) }
+    end
+
+    def _execute(sql, name = nil)
+      if ActiveRecord::ConnectionAdapters::JdbcConnection::select?(sql)
+        @connection.execute_query(sql)
+      else
+        affected_rows = @connection.execute_update(sql)
+        ActiveRecord::ConnectionAdapters::JdbcConnection::insert?(sql) ? last_insert_id(sql.split(" ", 4)[2], nil) : affected_rows
+      end
+    end
+
+    def table_structure(table_name)
+      returning structure = @connection.execute_query("PRAGMA table_info(#{quote_table_name(table_name)})") do
+        raise(ActiveRecord::StatementInvalid, "Could not find table '#{table_name}'") if structure.empty?
+      end
+    end
+    
+    def columns(table_name, name = nil) #:nodoc:        
+      table_structure(table_name).map do |field|
+        ::ActiveRecord::ConnectionAdapters::JdbcColumn.new(@config, field['name'], field['dflt_value'], field['type'], field['notnull'] == "0")
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    class JdbcColumn < Column
+      def self.string_to_binary(value)
+        value.gsub(/\0|%/n) do |b|
+          case b
+            when "\0" then "%00"
+            when "\%"  then "%25"
+          end
+        end
+      end
+
+      def self.binary_to_string(value)
+        value.gsub(/%00|%25/n) do |b|
+          case b
+            when "%00" then "\0"
+            when "%25" then "%"
+          end
+        end
+      end
+    end
   end
 end