activerecord-oracle_enhanced-adapter 5.2.8 → 6.0.0.beta1

data/lib/active_record/connection_adapters/oracle_enhanced/structure_dump.rb

@@ -11,7 +11,7 @@ module ActiveRecord #:nodoc:
           sequences = select(<<-SQL.strip.gsub(/\s+/, " "), "sequences to dump at structure dump")
             SELECT sequence_name, min_value, max_value, increment_by, order_flag, cycle_flag
             FROM all_sequences
-            where sequence_owner = SYS_CONTEXT('userenv', 'session_user') ORDER BY 1
+            where sequence_owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY 1
           SQL
 
           structure = sequences.map do |result|
@@ -28,13 +28,13 @@ module ActiveRecord #:nodoc:
           SQL
           tables.each do |table_name|
             virtual_columns = virtual_columns_for(table_name) if supports_virtual_columns?
-            ddl = "CREATE#{ ' GLOBAL TEMPORARY' if temporary_table?(table_name)} TABLE \"#{table_name}\" (\n".dup
+            ddl = +"CREATE#{ ' GLOBAL TEMPORARY' if temporary_table?(table_name)} TABLE \"#{table_name}\" (\n"
             columns = select_all(<<-SQL.strip.gsub(/\s+/, " "), "columns at structure dump")
               SELECT column_name, data_type, data_length, char_used, char_length,
               data_precision, data_scale, data_default, nullable
               FROM all_tab_columns
               WHERE table_name = '#{table_name}'
-              AND owner = SYS_CONTEXT('userenv', 'session_user')
+              AND owner = SYS_CONTEXT('userenv', 'current_schema')
               ORDER BY column_id
             SQL
             cols = columns.map do |row|
@@ -55,10 +55,11 @@ module ActiveRecord #:nodoc:
           end
 
           join_with_statement_token(structure) << structure_dump_fk_constraints
+          join_with_statement_token(structure) << structure_dump_views
         end
 
         def structure_dump_column(column) #:nodoc:
-          col = "\"#{column['column_name']}\" #{column['data_type']}".dup
+          col = +"\"#{column['column_name']}\" #{column['data_type']}"
           if (column["data_type"] == "NUMBER") && !column["data_precision"].nil?
             col << "(#{column['data_precision'].to_i}"
             col << ",#{column['data_scale'].to_i}" if !column["data_scale"].nil?
@@ -74,7 +75,7 @@ module ActiveRecord #:nodoc:
 
         def structure_dump_virtual_column(column, data_default) #:nodoc:
           data_default = data_default.gsub(/"/, "")
-          col = "\"#{column['column_name']}\" #{column['data_type']}".dup
+          col = +"\"#{column['column_name']}\" #{column['data_type']}"
           if (column["data_type"] == "NUMBER") && !column["data_precision"].nil?
             col << "(#{column['data_precision'].to_i}"
             col << ",#{column['data_scale'].to_i}" if !column["data_scale"].nil?
@@ -150,7 +151,7 @@ module ActiveRecord #:nodoc:
           fks = foreign_keys.map do |table|
             if respond_to?(:foreign_keys) && (foreign_keys = foreign_keys(table["table_name"])).any?
               foreign_keys.map do |fk|
-                sql = "ALTER TABLE #{quote_table_name(fk.from_table)} ADD CONSTRAINT #{quote_column_name(fk.options[:name])} ".dup
+                sql = +"ALTER TABLE #{quote_table_name(fk.from_table)} ADD CONSTRAINT #{quote_column_name(fk.options[:name])} "
                 sql << "#{foreign_key_definition(fk.to_table, fk.options)}"
               end
             end
@@ -202,7 +203,7 @@ module ActiveRecord #:nodoc:
           sql
         end
 
-        # Extract all stored procedures, packages, synonyms and views.
+        # Extract all stored procedures, packages, synonyms.
         def structure_dump_db_stored_code #:nodoc:
           structure = []
           all_source = select_all(<<-SQL.strip.gsub(/\s+/, " "), "stored program at structure dump")
@@ -213,7 +214,7 @@ module ActiveRecord #:nodoc:
             AND owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY type
           SQL
           all_source.each do |source|
-            ddl = "CREATE OR REPLACE   \n".dup
+            ddl = +"CREATE OR REPLACE   \n"
             texts = select_all(<<-SQL.strip.gsub(/\s+/, " "), "all source at structure dump")
               SELECT text
               FROM all_source
@@ -229,16 +230,26 @@ module ActiveRecord #:nodoc:
             structure << ddl
           end
 
-          # export views
+          # export synonyms
+          structure << structure_dump_synonyms
+
+          join_with_statement_token(structure)
+        end
+
+        def structure_dump_views #:nodoc:
+          structure = []
           views = select_all(<<-SQL.strip.gsub(/\s+/, " "), "views at structure dump")
             SELECT view_name, text FROM all_views
-            WHERE owner = SYS_CONTEXT('userenv', 'session_user') ORDER BY view_name ASC
+            WHERE owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY view_name ASC
           SQL
           views.each do |view|
             structure << "CREATE OR REPLACE FORCE VIEW #{view['view_name']} AS\n #{view['text']}"
           end
+          join_with_statement_token(structure)
+        end
 
-          # export synonyms
+        def structure_dump_synonyms #:nodoc:
+          structure = []
           synonyms = select_all(<<-SQL.strip.gsub(/\s+/, " "), "synonyms at structure dump")
             SELECT owner, synonym_name, table_name, table_owner
             FROM all_synonyms
@@ -246,15 +257,14 @@ module ActiveRecord #:nodoc:
           SQL
           synonyms.each do |synonym|
             structure << "CREATE OR REPLACE #{synonym['owner'] == 'PUBLIC' ? 'PUBLIC' : '' } SYNONYM #{synonym['synonym_name']}
-  			FOR #{synonym['table_owner']}.#{synonym['table_name']}"
+            FOR #{synonym['table_owner']}.#{synonym['table_name']}"
           end
-
           join_with_statement_token(structure)
         end
 
         def structure_drop #:nodoc:
           sequences = select_values(<<-SQL.strip.gsub(/\s+/, " "), "sequences to drop at structure dump")
-            SELECT sequence_name FROM all_sequences where sequence_owner = SYS_CONTEXT('userenv', 'session_user') ORDER BY 1
+            SELECT sequence_name FROM all_sequences where sequence_owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY 1
           SQL
           statements = sequences.map do |seq|
             "DROP SEQUENCE \"#{seq}\""
@@ -314,7 +324,7 @@ module ActiveRecord #:nodoc:
             SELECT column_name, data_default
             FROM all_tab_cols
             WHERE virtual_column = 'YES'
-            AND owner = SYS_CONTEXT('userenv', 'session_user')
+            AND owner = SYS_CONTEXT('userenv', 'current_schema')
             AND table_name = '#{table.upcase}'
           SQL
         end
@@ -323,7 +333,7 @@ module ActiveRecord #:nodoc:
           short_type = type == "materialized view" ? "mview" : type
           features = select_values(<<-SQL.strip.gsub(/\s+/, " "), "features to drop")
             SELECT #{short_type}_name FROM all_#{short_type.tableize}
-            where owner = SYS_CONTEXT('userenv', 'session_user')
+            where owner = SYS_CONTEXT('userenv', 'current_schema')
           SQL
           statements = features.map do |name|
             "DROP #{type.upcase} \"#{name}\""
@@ -334,7 +344,7 @@ module ActiveRecord #:nodoc:
         def drop_sql_for_object(type)
           objects = select_values(<<-SQL.strip.gsub(/\s+/, " "), "objects to drop")
             SELECT object_name FROM all_objects
-            WHERE object_type = '#{type.upcase}' and owner = SYS_CONTEXT('userenv', 'session_user')
+            WHERE object_type = '#{type.upcase}' and owner = SYS_CONTEXT('userenv', 'current_schema')
           SQL
           statements = objects.map do |name|
             "DROP #{type.upcase} \"#{name}\""

data/lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -38,7 +38,6 @@ require "active_record/connection_adapters/oracle_enhanced/schema_creation"
 require "active_record/connection_adapters/oracle_enhanced/schema_definitions"
 require "active_record/connection_adapters/oracle_enhanced/schema_dumper"
 require "active_record/connection_adapters/oracle_enhanced/schema_statements"
-require "active_record/connection_adapters/oracle_enhanced/schema_statements_ext"
 require "active_record/connection_adapters/oracle_enhanced/context_index"
 require "active_record/connection_adapters/oracle_enhanced/column"
 require "active_record/connection_adapters/oracle_enhanced/quoting"
@@ -58,6 +57,7 @@ require "active_record/type/oracle_enhanced/boolean"
 require "active_record/type/oracle_enhanced/json"
 require "active_record/type/oracle_enhanced/timestamptz"
 require "active_record/type/oracle_enhanced/timestampltz"
+require "active_record/type/oracle_enhanced/character_string"
 
 module ActiveRecord
   module ConnectionHandling #:nodoc:
@@ -115,16 +115,12 @@ module ActiveRecord
     # * <tt>:time_zone</tt> - database session time zone
     #   (it is recommended to set it using ENV['TZ'] which will be then also used for database session time zone)
     # * <tt>:schema</tt> - database schema which holds schema objects.
-    # * <tt>:tcp_keepalive</tt> - TCP keepalive is enabled for OCI client, defaults to true
-    # * <tt>:tcp_keepalive_time</tt> - TCP keepalive time for OCI client, defaults to 600
     #
     # Optionals NLS parameters:
     #
     # * <tt>:nls_calendar</tt>
     # * <tt>:nls_comp</tt>
     # * <tt>:nls_currency</tt>
-    # * <tt>:nls_date_format</tt> - format for :date columns, defaults to <tt>YYYY-MM-DD HH24:MI:SS</tt>
-    #   (changing `nls_date_format` parameter value is not supported. Use the default value.)
     # * <tt>:nls_date_language</tt>
     # * <tt>:nls_dual_currency</tt>
     # * <tt>:nls_iso_currency</tt>
@@ -135,16 +131,18 @@ module ActiveRecord
     # * <tt>:nls_numeric_characters</tt>
     # * <tt>:nls_sort</tt>
     # * <tt>:nls_territory</tt>
-    # * <tt>:nls_timestamp_format</tt> - format for :timestamp columns, defaults to <tt>YYYY-MM-DD HH24:MI:SS:FF6</tt>
-    #   (changing `nls_timestamp_format` parameter value is not supported. Use the default value.)
     # * <tt>:nls_timestamp_tz_format</tt>
     # * <tt>:nls_time_format</tt>
     # * <tt>:nls_time_tz_format</tt>
     #
+    # Fixed NLS values (not overridable):
+    #
+    # * <tt>:nls_date_format</tt> - format for :date columns is <tt>YYYY-MM-DD HH24:MI:SS</tt>
+    # * <tt>:nls_timestamp_format</tt> - format for :timestamp columns is <tt>YYYY-MM-DD HH24:MI:SS:FF6</tt>
+    #
     class OracleEnhancedAdapter < AbstractAdapter
       include OracleEnhanced::DatabaseStatements
       include OracleEnhanced::SchemaStatements
-      include OracleEnhanced::SchemaStatementsExt
       include OracleEnhanced::ContextIndex
       include OracleEnhanced::Quoting
       include OracleEnhanced::DatabaseLimits
@@ -196,11 +194,26 @@ module ActiveRecord
 
       ##
       # :singleton-method:
-      # Specify default sequence start with value (by default 10000 if not explicitly set), e.g.:
+      # Specify default sequence start with value (by default 1 if not explicitly set), e.g.:
       #
-      #   ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_sequence_start_value = 1
+      #   ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_sequence_start_value = 10000
       cattr_accessor :default_sequence_start_value
-      self.default_sequence_start_value = 10000
+      self.default_sequence_start_value = 1
+
+      ##
+      # :singleton-method:
+      # By default, OracleEnhanced adapter will use longer 128 bytes identifier
+      # if database version is Oracle 12.2 or higher.
+      # If you wish to use shorter 30 byte identifier with Oracle Database supporting longer identifier
+      # you can add the following line to your initializer file:
+      #
+      #   ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.use_shorter_identifier = true
+      cattr_accessor :use_shorter_identifier
+      self.use_shorter_identifier = false
+
+      ##
+      # :singleton-method:
+      # Specify default sequence start with value (by default 1 if not explicitly set), e.g.:
 
       class StatementPool < ConnectionAdapters::StatementPool
         private
@@ -212,13 +225,12 @@ module ActiveRecord
 
       def initialize(connection, logger = nil, config = {}) # :nodoc:
         super(connection, logger, config)
-        @statements = StatementPool.new(self.class.type_cast_config_to_integer(config[:statement_limit]))
         @enable_dbms_output = false
         @do_not_prefetch_primary_key = {}
         @columns_cache = {}
       end
 
-      ADAPTER_NAME = "OracleEnhanced".freeze
+      ADAPTER_NAME = "OracleEnhanced"
 
       def adapter_name #:nodoc:
         ADAPTER_NAME
@@ -232,6 +244,10 @@ module ActiveRecord
         end
       end
 
+      def build_statement_pool
+        StatementPool.new(self.class.type_cast_config_to_integer(@config[:statement_limit]))
+      end
+
       def supports_savepoints? #:nodoc:
         true
       end
@@ -244,8 +260,8 @@ module ActiveRecord
         true
       end
 
-      def supports_foreign_keys_in_create?
-        supports_foreign_keys?
+      def supports_optimizer_hints?
+        true
       end
 
       def supports_views?
@@ -307,12 +323,19 @@ module ActiveRecord
         false
       end
 
+      def supports_longer_identifier?
+        if !use_shorter_identifier && @connection.database_version.to_s >= [12, 2].to_s
+          true
+        else
+          false
+        end
+      end
+
       #:stopdoc:
       DEFAULT_NLS_PARAMETERS = {
         nls_calendar: nil,
         nls_comp: nil,
         nls_currency: nil,
-        nls_date_format: "YYYY-MM-DD HH24:MI:SS",
         nls_date_language: nil,
         nls_dual_currency: nil,
         nls_iso_currency: nil,
@@ -322,12 +345,17 @@ module ActiveRecord
         nls_numeric_characters: nil,
         nls_sort: nil,
         nls_territory: nil,
-        nls_timestamp_format: "YYYY-MM-DD HH24:MI:SS:FF6",
         nls_timestamp_tz_format: nil,
         nls_time_format: nil,
         nls_time_tz_format: nil
       }
 
+      #:stopdoc:
+      FIXED_NLS_PARAMETERS = {
+        nls_date_format: "YYYY-MM-DD HH24:MI:SS",
+        nls_timestamp_format: "YYYY-MM-DD HH24:MI:SS:FF6"
+      }
+
       #:stopdoc:
       NATIVE_DATABASE_TYPES = {
         primary_key: "NUMBER(38) NOT NULL PRIMARY KEY",
@@ -336,7 +364,7 @@ module ActiveRecord
         ntext: { name: "NCLOB" },
         integer: { name: "NUMBER", limit: 38 },
         float: { name: "BINARY_FLOAT" },
-        decimal: { name: "DECIMAL" },
+        decimal: { name: "NUMBER" },
         datetime: { name: "TIMESTAMP" },
         timestamp: { name: "TIMESTAMP" },
         timestamptz: { name: "TIMESTAMP WITH TIME ZONE" },
@@ -412,14 +440,14 @@ module ActiveRecord
       end
 
       # use in set_sequence_name to avoid fetching primary key value from sequence
-      AUTOGENERATED_SEQUENCE_NAME = "autogenerated".freeze
+      AUTOGENERATED_SEQUENCE_NAME = "autogenerated"
 
       # Returns the next sequence value from a sequence generator. Not generally
       # called directly; used by ActiveRecord to get the next primary key value
       # when inserting a new database record (see #prefetch_primary_key?).
       def next_sequence_value(sequence_name)
         # if sequence_name is set to :autogenerated then it means that primary key will be populated by trigger
-        return nil if sequence_name == AUTOGENERATED_SEQUENCE_NAME
+        raise ArgumentError "Trigger based primary key is not supported" if sequence_name == AUTOGENERATED_SEQUENCE_NAME
         # call directly connection method to avoid prepared statement which causes fetching of next sequence value twice
         select_value(<<-SQL.strip.gsub(/\s+/, " "), "next sequence value")
           SELECT #{quote_table_name(sequence_name)}.NEXTVAL FROM dual
@@ -433,8 +461,8 @@ module ActiveRecord
         table_name = table_name.to_s
         do_not_prefetch = @do_not_prefetch_primary_key[table_name]
         if do_not_prefetch.nil?
-          owner, desc_table_name, db_link = @connection.describe(table_name)
-          @do_not_prefetch_primary_key [table_name] = do_not_prefetch = !has_primary_key?(table_name, owner, desc_table_name, db_link) || has_primary_key_trigger?(table_name, owner, desc_table_name, db_link)
+          owner, desc_table_name = @connection.describe(table_name)
+          @do_not_prefetch_primary_key [table_name] = do_not_prefetch = !has_primary_key?(table_name, owner, desc_table_name)
         end
         !do_not_prefetch
       end
@@ -501,25 +529,8 @@ module ActiveRecord
         SQL
       end
 
-      # check if table has primary key trigger with _pkt suffix
-      def has_primary_key_trigger?(table_name, owner = nil, desc_table_name = nil, db_link = nil)
-        (owner, desc_table_name, db_link) = @connection.describe(table_name) unless owner
-
-        trigger_name = default_trigger_name(table_name).upcase
-
-        !!select_value(<<-SQL.strip.gsub(/\s+/, " "), "Primary Key Trigger", [bind_string("owner", owner), bind_string("trigger_name", trigger_name), bind_string("owner", owner), bind_string("table_name", desc_table_name)])
-          SELECT trigger_name
-          FROM all_triggers#{db_link}
-          WHERE owner = :owner
-            AND trigger_name = :trigger_name
-            AND table_owner = :owner
-            AND table_name = :table_name
-            AND status = 'ENABLED'
-        SQL
-      end
-
       def column_definitions(table_name)
-        (owner, desc_table_name, db_link) = @connection.describe(table_name)
+        (owner, desc_table_name) = @connection.describe(table_name)
 
         select_all(<<-SQL.strip.gsub(/\s+/, " "), "Column definitions")
           SELECT cols.column_name AS name, cols.data_type AS sql_type,
@@ -533,7 +544,7 @@ module ActiveRecord
                                     NULL) AS limit,
                  DECODE(data_type, 'NUMBER', data_scale, NULL) AS scale,
                  comments.comments as column_comment
-            FROM all_tab_cols#{db_link} cols, all_col_comments#{db_link} comments
+            FROM all_tab_cols cols, all_col_comments comments
            WHERE cols.owner      = '#{owner}'
              AND cols.table_name = #{quote(desc_table_name)}
              AND cols.hidden_column = 'NO'
@@ -550,12 +561,12 @@ module ActiveRecord
 
       # Find a table's primary key and sequence.
       # *Note*: Only primary key is implemented - sequence will be nil.
-      def pk_and_sequence_for(table_name, owner = nil, desc_table_name = nil, db_link = nil) #:nodoc:
-        (owner, desc_table_name, db_link) = @connection.describe(table_name) unless owner
+      def pk_and_sequence_for(table_name, owner = nil, desc_table_name = nil) #:nodoc:
+        (owner, desc_table_name) = @connection.describe(table_name)
 
         seqs = select_values(<<-SQL.strip.gsub(/\s+/, " "), "Sequence")
           select us.sequence_name
-          from all_sequences#{db_link} us
+          from all_sequences us
           where us.sequence_owner = '#{owner}'
           and us.sequence_name = upper(#{quote(default_sequence_name(desc_table_name))})
         SQL
@@ -563,7 +574,7 @@ module ActiveRecord
         # changed back from user_constraints to all_constraints for consistency
         pks = select_values(<<-SQL.strip.gsub(/\s+/, " "), "Primary Key")
           SELECT cc.column_name
-            FROM all_constraints#{db_link} c, all_cons_columns#{db_link} cc
+            FROM all_constraints c, all_cons_columns cc
            WHERE c.owner = '#{owner}'
              AND c.table_name = #{quote(desc_table_name)}
              AND c.constraint_type = 'P'
@@ -571,7 +582,7 @@ module ActiveRecord
              AND cc.constraint_name = c.constraint_name
         SQL
 
-        warn <<-WARNING.strip_heredoc if pks.count > 1
+        warn <<~WARNING if pks.count > 1
           WARNING: Active Record does not support composite primary key.
 
           #{table_name} has composite primary key. Composite primary key is ignored.
@@ -588,17 +599,17 @@ module ActiveRecord
         pk_and_sequence && pk_and_sequence.first
       end
 
-      def has_primary_key?(table_name, owner = nil, desc_table_name = nil, db_link = nil) #:nodoc:
-        !pk_and_sequence_for(table_name, owner, desc_table_name, db_link).nil?
+      def has_primary_key?(table_name, owner = nil, desc_table_name = nil) #:nodoc:
+        !pk_and_sequence_for(table_name, owner, desc_table_name).nil?
       end
 
       def primary_keys(table_name) # :nodoc:
-        (owner, desc_table_name, db_link) = @connection.describe(table_name) unless owner
+        (_owner, desc_table_name) = @connection.describe(table_name)
 
-        pks = select_values(<<-SQL.strip.gsub(/\s+/, " "), "Primary Keys", [bind_string("owner", owner), bind_string("table_name", desc_table_name)])
+        pks = select_values(<<-SQL.strip.gsub(/\s+/, " "), "Primary Keys", [bind_string("table_name", desc_table_name)])
           SELECT cc.column_name
-            FROM all_constraints#{db_link} c, all_cons_columns#{db_link} cc
-           WHERE c.owner = :owner
+            FROM all_constraints c, all_cons_columns cc
+           WHERE c.owner = SYS_CONTEXT('userenv', 'current_schema')
              AND c.table_name = :table_name
              AND c.constraint_type = 'P'
              AND cc.owner = c.owner
@@ -626,11 +637,24 @@ module ActiveRecord
 
       def temporary_table?(table_name) #:nodoc:
         select_value(<<-SQL.strip.gsub(/\s+/, " "), "temporary table", [bind_string("table_name", table_name.upcase)]) == "Y"
-          SELECT temporary FROM all_tables WHERE table_name = :table_name and owner = SYS_CONTEXT('userenv', 'session_user')
+          SELECT temporary FROM all_tables WHERE table_name = :table_name and owner = SYS_CONTEXT('userenv', 'current_schema')
         SQL
       end
 
+      def max_identifier_length
+        supports_longer_identifier? ? 128 : 30
+      end
+      alias table_alias_length max_identifier_length
+      alias index_name_length max_identifier_length
+
       private
+        def check_version
+          database_version = @connection.database_version.join(".").to_f
+
+          if database_version < 10
+            raise "Your version of Oracle (#{database_version}) is too old. Active Record Oracle enhanced adapter supports Oracle >= 10g."
+          end
+        end
 
         def initialize_type_map(m = type_map)
           super
@@ -638,7 +662,9 @@ module ActiveRecord
           register_class_with_precision m, %r(WITH TIME ZONE)i,       Type::OracleEnhanced::TimestampTz
           register_class_with_precision m, %r(WITH LOCAL TIME ZONE)i, Type::OracleEnhanced::TimestampLtz
           register_class_with_limit m, %r(raw)i,            Type::OracleEnhanced::Raw
-          register_class_with_limit m, %r(char)i,           Type::OracleEnhanced::String
+          register_class_with_limit m, %r{^(char)}i,        Type::OracleEnhanced::CharacterString
+          register_class_with_limit m, %r{^(nchar)}i,       Type::OracleEnhanced::String
+          register_class_with_limit m, %r(varchar)i,        Type::OracleEnhanced::String
           register_class_with_limit m, %r(clob)i,           Type::OracleEnhanced::Text
           register_class_with_limit m, %r(nclob)i,           Type::OracleEnhanced::NationalCharacterText
 
@@ -679,20 +705,20 @@ module ActiveRecord
           end
         end
 
-        def translate_exception(exception, message) #:nodoc:
+        def translate_exception(exception, message:, sql:, binds:) #:nodoc:
           case @connection.error_code(exception)
           when 1
-            RecordNotUnique.new(message)
+            RecordNotUnique.new(message, sql: sql, binds: binds)
           when 60
             Deadlocked.new(message)
           when 900, 904, 942, 955, 1418, 2289, 2449, 17008
-            ActiveRecord::StatementInvalid.new(message)
+            ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds)
           when 1400
-            ActiveRecord::NotNullViolation.new(message)
-          when 2291
-            InvalidForeignKey.new(message)
+            ActiveRecord::NotNullViolation.new(message, sql: sql, binds: binds)
+          when 2291, 2292
+            InvalidForeignKey.new(message, sql: sql, binds: binds)
           when 12899
-            ValueTooLong.new(message)
+            ValueTooLong.new(message, sql: sql, binds: binds)
           else
             super
           end