activerecord-jdbc-adapter 1.3.11 → 1.3.12

data/lib/arjdbc/mysql/column.rb

@@ -10,6 +10,26 @@ module ArJdbc
     # @see ActiveRecord::ConnectionAdapters::JdbcColumn
     module Column
 
+      def initialize(name, default, sql_type = nil, null = true, collation = nil, strict = false, extra = '')
+        if name.is_a?(Hash)
+          super # first arg: config
+        else
+          @strict = strict; @collation = collation; @extra = extra
+          super(name, default, sql_type, null)
+          # base 4.1: (name, default, sql_type = nil, null = true)
+        end
+      end unless AR42
+
+      def initialize(name, default, cast_type, sql_type = nil, null = true, collation = nil, strict = false, extra = '')
+        if name.is_a?(Hash)
+          super # first arg: config
+        else
+          @strict = strict; @collation = collation; @extra = extra
+          super(name, default, cast_type, sql_type, null)
+          # base 4.2: (name, default, cast_type, sql_type = nil, null = true)
+        end
+      end if AR42
+
       attr_reader :collation, :strict, :extra
 
       def extract_default(default)

data/lib/arjdbc/mysql/connection_methods.rb

@@ -34,8 +34,13 @@ ArJdbc::ConnectionMethods.module_eval do
       properties['zeroDateTimeBehavior'] ||= 'convertToNull'
       properties['jdbcCompliantTruncation'] ||= 'false'
       properties['useUnicode'] = 'true' unless properties.key?('useUnicode') # otherwise platform default
-      encoding = config.key?(:encoding) ? config[:encoding] : 'utf8'
-      properties['characterEncoding'] = encoding if encoding
+      # NOTE: this is "better" than passing what users are used to set on MRI
+      # e.g. 'utf8mb4' will fail cause the driver will check for a Java charset
+      # ... it's smart enough to detect utf8mb4 from server variables :
+      # "character_set_client" && "character_set_connection" (thus UTF-8)
+      if encoding = config.key?(:encoding) ? config[:encoding] : 'utf8'
+        properties['characterEncoding'] = convert_mysql_encoding(encoding) || encoding
+      end
       if ! ( reconnect = config[:reconnect] ).nil?
         properties['autoReconnect'] ||= reconnect.to_s
         # properties['maxReconnects'] ||= '3'
@@ -88,4 +93,53 @@ ArJdbc::ConnectionMethods.module_eval do
     mysql_connection(config)
   end
   alias_method :jdbcmariadb_connection, :mariadb_connection
+
+  private
+
+  @@mysql_encodings = nil
+
+  def convert_mysql_encoding(encoding) # from mysql2's ruby_enc_to_mysql
+    ( @@mysql_encodings ||= {
+      "big5" => "Big5",
+      "dec8" => nil,
+      "cp850" => "CP850",
+      "hp8" => nil,
+      "koi8r" => "KOI8-R",
+      "latin1" => "ISO-8859-1",
+      "latin2" => "ISO-8859-2",
+      "swe7" => nil,
+      "ascii" => "US-ASCII",
+      #"ujis" => "eucJP-ms",
+      #"sjis" => "Shift_JIS",
+      "hebrew" => "ISO-8859-8",
+      #"tis620" => "TIS-620",
+      #"euckr" => "EUC-KR",
+      #"koi8u" => "KOI8-R",
+      #"gb2312" => "GB2312",
+      "greek" => "ISO-8859-7",
+      "cp1250" => "Windows-1250",
+      #"gbk" => "GBK",
+      "latin5" => "ISO-8859-9",
+      "armscii8" => nil,
+      "utf8" => "UTF-8",
+      "ucs2" => "UTF-16BE",
+      "cp866" => "IBM866",
+      "keybcs2" => nil,
+      #"macce" => "macCentEuro",
+      #"macroman" => "macRoman",
+      "cp852" => "CP852",
+      "latin7" => "ISO-8859-13",
+      "utf8mb4" => "UTF-8",
+      "cp1251" => "Windows-1251",
+      "utf16" => "UTF-16",
+      "cp1256" => "Windows-1256",
+      "cp1257" => "Windows-1257",
+      "utf32" => "UTF-32",
+      "binary" => "ASCII-8BIT",
+      "geostd8" => nil,
+      #"cp932" => "Windows-31J",
+      #"eucjpms" => "eucJP-ms"
+    } )[ encoding ]
+  end
+
 end

data/lib/arjdbc/oracle/adapter.rb

@@ -1,10 +1,10 @@
 ArJdbc.load_java_part :Oracle
 
-require 'arjdbc/oracle/column'
-
 module ArJdbc
   module Oracle
 
+    require 'arjdbc/oracle/column'
+
     # @private
     def self.extended(adapter); initialize!; end
 
@@ -31,9 +31,7 @@ module ArJdbc
     end
 
     # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_column_class
-    def jdbc_column_class
-      ::ActiveRecord::ConnectionAdapters::OracleColumn
-    end
+    def jdbc_column_class; Column end
 
     # @private
     @@update_lob_values = true
@@ -485,24 +483,19 @@ module ArJdbc
     end
 
     # @override
-    def supports_migrations?
-      true
-    end
+    def supports_migrations?; true end
 
     # @override
-    def supports_primary_key?
-      true
-    end
+    def supports_primary_key?; true end
 
     # @override
-    def supports_savepoints?
-      true
-    end
+    def supports_savepoints?; true end
 
     # @override
-    def supports_explain?
-      true
-    end
+    def supports_explain?; true end
+
+    # @override
+    def supports_views?; true end
 
     def explain(arel, binds = [])
       sql = "EXPLAIN PLAN FOR #{to_sql(arel, binds)}"
@@ -690,3 +683,9 @@ module ActiveRecord::ConnectionAdapters
   end
 
 end
+
+module ArJdbc
+  module Oracle
+    Column = ::ActiveRecord::ConnectionAdapters::OracleColumn
+  end
+end

data/lib/arjdbc/postgresql/adapter.rb

@@ -8,6 +8,9 @@ module ArJdbc
 
     # @private
     AR4_COMPAT = ::ActiveRecord::VERSION::MAJOR > 3 unless const_defined?(:AR4_COMPAT)
+    # @private
+    AR42_COMPAT = ::ActiveRecord::VERSION::MAJOR > 4 ||
+      ( ::ActiveRecord::VERSION::MAJOR == 4 && ::ActiveRecord::VERSION::MINOR >= 2 )
 
     require 'arjdbc/postgresql/column'
     require 'arjdbc/postgresql/explain_support'
@@ -156,15 +159,12 @@ module ArJdbc
       when Array
         case column.sql_type
         when 'point'
-          column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
-          column_class.point_to_string(value)
+          Column.point_to_string(value)
         when 'json'
-          column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
-          column_class.json_to_string(value)
+          Column.json_to_string(value)
         else
           return super(value, column) unless column.array?
-          column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
-          column_class.array_to_string(value, column, self)
+          Column.array_to_string(value, column, self)
         end
       when NilClass
         if column.array? && array_member
@@ -177,21 +177,17 @@ module ArJdbc
       when Hash
         case column.sql_type
         when 'hstore'
-          column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
-          column_class.hstore_to_string(value)
+          Column.hstore_to_string(value)
         when 'json'
-          column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
-          column_class.json_to_string(value)
+          Column.json_to_string(value)
         else super(value, column)
         end
       when IPAddr
         return super unless column.sql_type == 'inet' || column.sql_type == 'cidr'
-        column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
-        column_class.cidr_to_string(value)
+        Column.cidr_to_string(value)
       when Range
         return super(value, column) unless /range$/ =~ column.sql_type
-        column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
-        column_class.range_to_string(value)
+        Column.range_to_string(value)
       else
         super(value, column)
       end
@@ -238,6 +234,11 @@ module ArJdbc
       :int8range => { :name => "int8range" },
     }) if AR4_COMPAT
 
+    NATIVE_DATABASE_TYPES.update(
+      :bit => { :name => "bit" },
+      :bit_varying => { :name => "bit varying" }
+    ) if AR42_COMPAT
+
     def native_database_types
       NATIVE_DATABASE_TYPES
     end
@@ -315,21 +316,13 @@ module ArJdbc
       postgresql_version >= 80200
     end
 
-    def supports_ddl_transactions?
-      true
-    end
+    def supports_ddl_transactions?; true end
 
-    def supports_transaction_isolation?
-      true
-    end
+    def supports_transaction_isolation?; true end
 
-    def supports_index_sort_order?
-      true
-    end
+    def supports_index_sort_order?; true end
 
-    def supports_partial_index?
-      true
-    end if AR4_COMPAT
+    def supports_partial_index?; true end if AR4_COMPAT
 
     # Range data-types weren't introduced until PostgreSQL 9.2.
     def supports_ranges?
@@ -340,12 +333,13 @@ module ArJdbc
       true
     end
 
+    # @override
+    def supports_views?; true end
+
     # NOTE: handled by JdbcAdapter we override only to have save-point in logs :
 
     # @override
-    def supports_savepoints?
-      true
-    end
+    def supports_savepoints?; true end
 
     # @override
     def create_savepoint(name = current_savepoint_name(true))
@@ -832,43 +826,51 @@ module ArJdbc
         sql_type && sql_type[0, 3] == 'bit' ? quote_bit(value) : super
       when Array
         if AR4_COMPAT && column.array? # will be always falsy in AR < 4.0
-          column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
-          "'#{column_class.array_to_string(value, column, self).gsub(/'/, "''")}'"
+          "'#{Column.array_to_string(value, column, self).gsub(/'/, "''")}'"
         elsif column.type == :json # only in AR-4.0
-          column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
-          super(column_class.json_to_string(value), column)
+          super(Column.json_to_string(value), column)
         elsif column.type == :point # only in AR-4.0
-          column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
-          super(column_class.point_to_string(value), column)
+          super(Column.point_to_string(value), column)
         else super
         end
       when Hash
         if column.type == :hstore # only in AR-4.0
-          column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
-          super(column_class.hstore_to_string(value), column)
+          super(Column.hstore_to_string(value), column)
         elsif column.type == :json # only in AR-4.0
-          column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
-          super(column_class.json_to_string(value), column)
+          super(Column.json_to_string(value), column)
         else super
         end
       when Range
         sql_type = column.respond_to?(:sql_type) && column.sql_type
         if sql_type && sql_type[-5, 5] == 'range' && AR4_COMPAT
-          column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
-          escaped = quote_string(column_class.range_to_string(value))
+          escaped = quote_string(Column.range_to_string(value))
           "'#{escaped}'::#{sql_type}"
         else super
         end
       when IPAddr
         if column.type == :inet || column.type == :cidr # only in AR-4.0
-          column_class = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
-          super(column_class.cidr_to_string(value), column)
+          super(Column.cidr_to_string(value), column)
         else super
         end
       else
         super
       end
-    end
+    end unless AR42_COMPAT
+
+    def quote(value, column = nil)
+      return super unless column
+
+      case value
+      when Float
+        if value.infinite? || value.nan?
+          "'#{value.to_s}'"
+        else
+          super
+        end
+      else
+        super
+      end
+    end if AR42_COMPAT
 
     # Quotes a string, escaping any ' (single quote) and \ (backslash) chars.
     # @return [String]
@@ -897,7 +899,7 @@ module ArJdbc
 
     def quote_bit(value)
       "B'#{value}'"
-    end if PostgreSQL::AR4_COMPAT
+    end if AR4_COMPAT
 
     def escape_bytea(string)
       return unless string
@@ -1002,7 +1004,7 @@ module ArJdbc
 
       change_column_default(table_name, column_name, default) if options_include_default?(options)
       change_column_null(table_name, column_name, false, default) if notnull
-    end if ActiveRecord::VERSION::MAJOR < 4
+    end if ::ActiveRecord::VERSION::MAJOR < 4
 
     # Changes the column of a table.
     def change_column(table_name, column_name, type, options = {})
@@ -1077,7 +1079,7 @@ module ArJdbc
 
     # Returns the list of all column definitions for a table.
     def columns(table_name, name = nil)
-      klass = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
+      pass_cast_type = respond_to?(:lookup_cast_type)
       column_definitions(table_name).map do |row|
         # name, type, default, notnull, oid, fmod
         name = row[0]; type = row[1]; default = row[2]
@@ -1091,7 +1093,12 @@ module ArJdbc
         elsif default =~ /^\(([-+]?[\d\.]+)\)$/ # e.g. "(-1)" for a negative default
           default = $1
         end
-        klass.new(name, default, oid, type, ! notnull, fmod, self)
+        if pass_cast_type
+          cast_type = lookup_cast_type(type)
+          Column.new(name, default, cast_type, type, ! notnull, fmod, self)
+        else
+          Column.new(name, default, oid, type, ! notnull, fmod, self)
+        end
       end
     end
 
@@ -1121,44 +1128,55 @@ module ArJdbc
     end
     private :column_definitions
 
+    # @private
+    TABLES_SQL = 'SELECT tablename FROM pg_tables WHERE schemaname = ANY (current_schemas(false))'
+
     def tables(name = nil)
-      select_values(<<-SQL, 'SCHEMA')
-        SELECT tablename
-        FROM pg_tables
-        WHERE schemaname = ANY (current_schemas(false))
-      SQL
+      select_values(TABLES_SQL, 'SCHEMA')
     end
 
+    # @private
+    TABLE_EXISTS_SQL_PREFIX =  'SELECT COUNT(*) as table_count FROM pg_class c'
+    TABLE_EXISTS_SQL_PREFIX << ' LEFT JOIN pg_namespace n ON n.oid = c.relnamespace'
+    if AR42_COMPAT # -- (r)elation/table, (v)iew, (m)aterialized view
+    TABLE_EXISTS_SQL_PREFIX << " WHERE c.relkind IN ('r','v','m')"
+    else
+    TABLE_EXISTS_SQL_PREFIX << " WHERE c.relkind IN ('r','v')"
+    end
+    TABLE_EXISTS_SQL_PREFIX << " AND c.relname = ?"
+
+    # Returns true if table exists.
+    # If the schema is not specified as part of +name+ then it will only find tables within
+    # the current schema search path (regardless of permissions to access tables in other schemas)
     def table_exists?(name)
       schema, table = extract_schema_and_table(name.to_s)
-      return false unless table # abstract classes - nil table name
-
-      binds = [[ nil, table.gsub(/(^"|"$)/,'') ]]
-      binds << [ nil, schema ] if schema
-      sql = <<-SQL
-        SELECT COUNT(*) as table_count
-        FROM pg_tables
-        WHERE tablename = ?
-        AND schemaname = #{schema ? "?" : "ANY (current_schemas(false))"}
-      SQL
+      return false unless table
+
+      binds = [[nil, table]]
+      binds << [nil, schema] if schema
+
+      sql = "#{TABLE_EXISTS_SQL_PREFIX} AND n.nspname = #{schema ? "?" : 'ANY (current_schemas(false))'}"
 
       log(sql, 'SCHEMA', binds) do
-        @connection.execute_query_raw(sql, binds).first["table_count"] > 0
+        @connection.execute_query_raw(sql, binds).first['table_count'] > 0
       end
     end
 
+    def index_name_exists?(table_name, index_name, default)
+      exec_query(<<-SQL, 'SCHEMA').rows.first[0].to_i > 0
+        SELECT COUNT(*)
+        FROM pg_class t
+        INNER JOIN pg_index d ON t.oid = d.indrelid
+        INNER JOIN pg_class i ON d.indexrelid = i.oid
+        WHERE i.relkind = 'i'
+          AND i.relname = '#{index_name}'
+          AND t.relname = '#{table_name}'
+          AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)) )
+      SQL
+    end if AR42_COMPAT
+
     # @private
     IndexDefinition = ::ActiveRecord::ConnectionAdapters::IndexDefinition
-    if ActiveRecord::VERSION::MAJOR < 3 ||
-        ( ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR <= 1 )
-      # NOTE: make sure we accept 6 arguments (>= 3.2) as well as 5 (<= 3.1) :
-      # allow 6 on 3.1 : Struct.new(:table, :name, :unique, :columns, :lengths)
-      IndexDefinition.class_eval do
-        def initialize(table, name, unique = nil, columns = nil, lengths = nil, orders = nil)
-          super(table, name, unique, columns, lengths) # @see {#indexes}
-        end
-      end
-    end
 
     # Returns an array of indexes for the given table.
     def indexes(table_name, name = nil)
@@ -1169,9 +1187,9 @@ module ArJdbc
         INNER JOIN pg_index d ON t.oid = d.indrelid
         INNER JOIN pg_class i ON d.indexrelid = i.oid
         WHERE i.relkind = 'i'
-        AND d.indisprimary = 'f'
-        AND t.relname = '#{table_name}'
-        AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)) )
+          AND d.indisprimary = 'f'
+          AND t.relname = '#{table_name}'
+          AND i.relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname = ANY (current_schemas(false)) )
         ORDER BY i.relname
       SQL
 
@@ -1198,13 +1216,13 @@ module ArJdbc
           desc_order_columns = inddef.scan(/(\w+) DESC/).flatten
           orders = desc_order_columns.any? ? Hash[ desc_order_columns.map { |column| [column, :desc] } ] : {}
 
-          if ActiveRecord::VERSION::MAJOR > 3 # AR4 supports `where` and `using` index options
+          if ::ActiveRecord::VERSION::MAJOR > 3 # AR4 supports `where` and `using` index options
             where = inddef.scan(/WHERE (.+)$/).flatten[0]
             using = inddef.scan(/USING (.+?) /).flatten[0].to_sym
 
             IndexDefinition.new(table_name, index_name, unique, column_names, [], orders, where, nil, using)
           else
-            IndexDefinition.new(table_name, index_name, unique, column_names, [], orders)
+            new_index_definition(table_name, index_name, unique, column_names, [], orders)
           end
         end
       end
@@ -1212,6 +1230,16 @@ module ArJdbc
       result
     end
 
+    # @private
+    def column_name_for_operation(operation, node)
+      case operation
+      when 'maximum' then 'max'
+      when 'minimum' then 'min'
+      when 'average' then 'avg'
+      else operation.downcase
+      end
+    end if AR42_COMPAT
+
     private
 
     def translate_exception(exception, message)
@@ -1225,20 +1253,12 @@ module ArJdbc
       end
     end
 
-    # Extracts the table and schema name from +name+
+    # @private `Utils.extract_schema_and_table` from AR
     def extract_schema_and_table(name)
-      schema, table = name.split('.', 2)
-
-      unless table # A table was provided without a schema
-        table  = schema
-        schema = nil
-      end
-
-      if name =~ /^"/ # Handle quoted table names
-        table  = name
-        schema = nil
-      end
-      [schema, table]
+      result = name.scan(/[^".\s]+|"[^"]*"/)[0, 2]
+      result.each { |m| m.gsub!(/(^"|"$)/, '') }
+      result.unshift(nil) if result.size == 1 # schema == nil
+      result # [schema, table]
     end
 
     def extract_pg_identifier_from_name(name)
@@ -1321,8 +1341,8 @@ module ActiveRecord::ConnectionAdapters
 
       @table_alias_length = nil
 
-      @use_insert_returning = config.key?(:insert_returning) ?
-        self.class.type_cast_config_to_boolean(config[:insert_returning]) : nil
+      @use_insert_returning = @config.key?(:insert_returning) ?
+        self.class.type_cast_config_to_boolean(@config[:insert_returning]) : nil
     end
 
     class ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
@@ -1392,6 +1412,18 @@ module ActiveRecord::ConnectionAdapters
       def json(name, options = {})
         column(name, 'json', options)
       end
+
+      def jsonb(name, options = {})
+        column(name, :jsonb, options)
+      end
+
+      def bit(name, options)
+        column(name, 'bit', options)
+      end
+
+      def bit_varying(name, options)
+        column(name, 'bit varying', options)
+      end
     end
 
     class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
@@ -1402,7 +1434,7 @@ module ActiveRecord::ConnectionAdapters
         options[:default] = options.fetch(:default, 'uuid_generate_v4()')
         options[:primary_key] = true
         column name, type, options
-      end if ActiveRecord::VERSION::MAJOR > 3 # 3.2 super expects (name)
+      end if ::ActiveRecord::VERSION::MAJOR > 3 # 3.2 super expects (name)
 
       def column(name, type = nil, options = {})
         super
@@ -1416,7 +1448,7 @@ module ActiveRecord::ConnectionAdapters
 
       private
 
-      if ActiveRecord::VERSION::MAJOR > 3
+      if ::ActiveRecord::VERSION::MAJOR > 3
 
         def create_column_definition(name, type)
           ColumnDefinition.new name, type
@@ -1445,7 +1477,7 @@ module ActiveRecord::ConnectionAdapters
 
     def update_table_definition(table_name, base)
       Table.new(table_name, base)
-    end if ActiveRecord::VERSION::MAJOR > 3
+    end if ::ActiveRecord::VERSION::MAJOR > 3
 
     def jdbc_connection_class(spec)
       ::ArJdbc::PostgreSQL.jdbc_connection_class
@@ -1456,10 +1488,16 @@ module ActiveRecord::ConnectionAdapters
       ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
     end
 
-    if ActiveRecord::VERSION::MAJOR < 4 # Rails 3.x compatibility
+    if ::ActiveRecord::VERSION::MAJOR < 4 # Rails 3.x compatibility
       PostgreSQLJdbcConnection.raw_array_type = true if PostgreSQLJdbcConnection.raw_array_type? == nil
       PostgreSQLJdbcConnection.raw_hstore_type = true if PostgreSQLJdbcConnection.raw_hstore_type? == nil
     end
 
   end
 end
+
+module ArJdbc
+  module PostgreSQL
+    Column = ::ActiveRecord::ConnectionAdapters::PostgreSQLColumn
+  end
+end