activerecord-oracle_enhanced-adapter 5.2.8 → 6.0.0.beta1

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

@@ -12,7 +12,7 @@ module ActiveRecord
           name = name.to_s
           @quoted_column_names[name] ||= begin
             # if only valid lowercase column characters in name
-            if name =~ /\A[a-z][a-z_0-9\$#]*\Z/
+            if /\A[a-z][a-z_0-9\$#]*\Z/.match?(name)
               "\"#{name.upcase}\""
             else
               # remove double quotes which cannot be used inside quoted identifier
@@ -38,18 +38,6 @@ module ActiveRecord
           end
         end
 
-        # Used only for quoting database links as the naming rules for links
-        # differ from the rules for column names. Specifically, link names may
-        # include periods.
-        def quote_database_link(name)
-          case name
-          when NONQUOTED_DATABASE_LINK
-            %Q("#{name.upcase}")
-          else
-            name
-          end
-        end
-
         # Names must be from 1 to 30 bytes long with these exceptions:
         # * Names of databases are limited to 8 bytes.
         # * Names of database links can be as long as 128 bytes.
@@ -61,12 +49,10 @@ module ActiveRecord
         #
         # Nonquoted identifiers can contain only alphanumeric characters from
         # your database character set and the underscore (_), dollar sign ($),
-        # and pound sign (#). Database links can also contain periods (.) and
-        # "at" signs (@). Oracle strongly discourages you from using $ and # in
-        # nonquoted identifiers.
-        NONQUOTED_OBJECT_NAME   = /[[:alpha:]][\w$#]{0,29}/
-        NONQUOTED_DATABASE_LINK = /[[:alpha:]][\w$#\.@]{0,127}/
-        VALID_TABLE_NAME = /\A(?:#{NONQUOTED_OBJECT_NAME}\.)?#{NONQUOTED_OBJECT_NAME}(?:@#{NONQUOTED_DATABASE_LINK})?\Z/
+        # and pound sign (#).
+        # Oracle strongly discourages you from using $ and # in nonquoted identifiers.
+        NONQUOTED_OBJECT_NAME = /[[:alpha:]][\w$#]{0,29}/
+        VALID_TABLE_NAME = /\A(?:#{NONQUOTED_OBJECT_NAME}\.)?#{NONQUOTED_OBJECT_NAME}?\Z/
 
         # unescaped table name should start with letter and
         # contain letters, digits, _, $ or #
@@ -83,8 +69,8 @@ module ActiveRecord
         end
 
         def quote_table_name(name) #:nodoc:
-          name, link = name.to_s.split("@")
-          @quoted_table_names[name] ||= [name.split(".").map { |n| quote_column_name(n) }.join("."), quote_database_link(link)].compact.join("@")
+          name, _link = name.to_s.split("@")
+          @quoted_table_names[name] ||= [name.split(".").map { |n| quote_column_name(n) }].join(".")
         end
 
         def quote_string(s) #:nodoc:
@@ -93,8 +79,10 @@ module ActiveRecord
 
         def _quote(value) #:nodoc:
           case value
+          when Type::OracleEnhanced::CharacterString::Data then
+            "'#{quote_string(value.to_s)}'"
           when Type::OracleEnhanced::NationalCharacterString::Data then
-            "N".dup << "'#{quote_string(value.to_s)}'"
+            +"N" << "'#{quote_string(value.to_s)}'"
           when ActiveModel::Type::Binary::Data then
             "empty_blob()"
           when Type::OracleEnhanced::Text::Data then
@@ -108,22 +96,22 @@ module ActiveRecord
 
         def quoted_true #:nodoc:
           return "'Y'" if emulate_booleans_from_strings
-          "1".freeze
+          "1"
         end
 
         def unquoted_true #:nodoc:
           return "Y" if emulate_booleans_from_strings
-          "1".freeze
+          "1"
         end
 
         def quoted_false #:nodoc:
           return "'N'" if emulate_booleans_from_strings
-          "0".freeze
+          "0"
         end
 
         def unquoted_false #:nodoc:
           return "N" if emulate_booleans_from_strings
-          "0".freeze
+          "0"
         end
 
         def _type_cast(value)
@@ -137,6 +125,8 @@ module ActiveRecord
             end
           when Type::OracleEnhanced::NationalCharacterString::Data
             value.to_s
+          when Type::OracleEnhanced::CharacterString::Data
+            value
           else
             super
           end
@@ -146,7 +136,7 @@ module ActiveRecord
 
           def oracle_downcase(column_name)
             return nil if column_name.nil?
-            column_name =~ /[a-z]/ ? column_name : column_name.downcase
+            /[a-z]/.match?(column_name) ? column_name : column_name.downcase
           end
       end
     end

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

@@ -17,11 +17,11 @@ module ActiveRecord
           end
 
           def visit_TableDefinition(o)
-            create_sql = "CREATE#{' GLOBAL TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} ".dup
+            create_sql = +"CREATE#{' GLOBAL TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} "
             statements = o.columns.map { |c| accept c }
             statements << accept(o.primary_keys) if o.primary_keys
 
-            if supports_foreign_keys_in_create?
+            if supports_foreign_keys?
               statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
             end
 
@@ -75,7 +75,7 @@ module ActiveRecord
 
           def action_sql(action, dependency)
             if action == "UPDATE"
-              raise ArgumentError, <<-MSG.strip_heredoc
+              raise ArgumentError, <<~MSG
               '#{action}' is not supported by Oracle
             MSG
             end
@@ -83,7 +83,7 @@ module ActiveRecord
             when :nullify then "ON #{action} SET NULL"
             when :cascade  then "ON #{action} CASCADE"
             else
-              raise ArgumentError, <<-MSG.strip_heredoc
+              raise ArgumentError, <<~MSG
               '#{dependency}' is not supported for #{action}
               Supported values are: :nullify, :cascade
             MSG

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

@@ -35,7 +35,7 @@ module ActiveRecord
         end
       end
 
-      class SynonymDefinition < Struct.new(:name, :table_owner, :table_name, :db_link) #:nodoc:
+      class SynonymDefinition < Struct.new(:name, :table_owner, :table_name) #:nodoc:
       end
 
       class IndexDefinition < ActiveRecord::ConnectionAdapters::IndexDefinition
@@ -53,10 +53,20 @@ module ActiveRecord
         include OracleEnhanced::ColumnMethods
 
         attr_accessor :tablespace, :organization
-        def initialize(name, temporary = false, options = nil, as = nil, tablespace = nil, organization = nil, comment: nil)
+        def initialize(
+          conn,
+          name,
+          temporary: false,
+          options: nil,
+          as: nil,
+          tablespace: nil,
+          organization: nil,
+          comment: nil,
+          **
+        )
           @tablespace = tablespace
           @organization = organization
-          super(name, temporary, options, as, comment: comment)
+          super(conn, name, temporary: temporary, options: options, as: as, comment: comment)
         end
 
         def new_column_definition(name, type, **options) # :nodoc:

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

@@ -13,8 +13,6 @@ module ActiveRecord #:nodoc:
               # add table prefix or suffix for schema_migrations
               next if ignored? tbl
               table(tbl, stream)
-              # add primary key trigger if table has it
-              primary_key_trigger(tbl, stream)
             end
             # following table definitions
             # add foreign keys if table has them
@@ -27,22 +25,12 @@ module ActiveRecord #:nodoc:
             synonyms(stream)
           end
 
-          def primary_key_trigger(table_name, stream)
-            if @connection.has_primary_key_trigger?(table_name)
-              pk, _pk_seq = @connection.pk_and_sequence_for(table_name)
-              stream.print "  add_primary_key_trigger #{table_name.inspect}"
-              stream.print ", primary_key: \"#{pk}\"" if pk != "id"
-              stream.print "\n\n"
-            end
-          end
-
           def synonyms(stream)
             syns = @connection.synonyms
             syns.each do |syn|
               next if ignored? syn.name
               table_name = syn.table_name
               table_name = "#{syn.table_owner}.#{table_name}" if syn.table_owner
-              table_name = "#{table_name}@#{syn.db_link}" if syn.db_link
               stream.print "  add_synonym #{syn.name.inspect}, #{table_name.inspect}, force: true"
               stream.puts
             end
@@ -179,7 +167,7 @@ module ActiveRecord #:nodoc:
             table_name = column.table_name
             @connection.select_value(<<-SQL.strip.gsub(/\s+/, " "), "Table comment", [bind_string("table_name", table_name.upcase), bind_string("column_name", column_name.upcase)]).inspect
               select data_default from all_tab_columns
-              where owner = SYS_CONTEXT('userenv', 'session_user')
+              where owner = SYS_CONTEXT('userenv', 'current_schema')
               and table_name = :table_name
               and column_name = :column_name
             SQL

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

@@ -16,6 +16,10 @@ module ActiveRecord
           FROM all_tables
           WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
           AND secondary = 'N'
+          minus
+          SELECT DECODE(mview_name, UPPER(mview_name), LOWER(mview_name), mview_name)
+          FROM all_mviews
+          WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
         SQL
         end
 
@@ -48,7 +52,7 @@ module ActiveRecord
         end
 
         def data_source_exists?(table_name)
-          (_owner, table_name, _db_link) = @connection.describe(table_name)
+          (_owner, _table_name) = @connection.describe(table_name)
           true
         rescue
           false
@@ -69,34 +73,34 @@ module ActiveRecord
         # get synonyms for schema dump
         def synonyms
           result = select_all(<<-SQL.strip.gsub(/\s+/, " "), "synonyms")
-          SELECT synonym_name, table_owner, table_name, db_link
-          FROM all_synonyms where owner = SYS_CONTEXT('userenv', 'session_user')
+          SELECT synonym_name, table_owner, table_name
+          FROM all_synonyms where owner = SYS_CONTEXT('userenv', 'current_schema')
         SQL
 
           result.collect do |row|
              OracleEnhanced::SynonymDefinition.new(oracle_downcase(row["synonym_name"]),
-             oracle_downcase(row["table_owner"]), oracle_downcase(row["table_name"]), oracle_downcase(row["db_link"]))
+             oracle_downcase(row["table_owner"]), oracle_downcase(row["table_name"]))
            end
         end
 
         def indexes(table_name) #:nodoc:
-          (owner, table_name, db_link) = @connection.describe(table_name)
+          (_owner, table_name) = @connection.describe(table_name)
           default_tablespace_name = default_tablespace
 
-          result = select_all(<<-SQL.strip.gsub(/\s+/, " "), "indexes", [bind_string("owner", owner), bind_string("owner", owner), bind_string("table_name", table_name)])
+          result = select_all(<<-SQL.strip.gsub(/\s+/, " "), "indexes", [bind_string("table_name", table_name)])
             SELECT LOWER(i.table_name) AS table_name, LOWER(i.index_name) AS index_name, i.uniqueness,
               i.index_type, i.ityp_owner, i.ityp_name, i.parameters,
               LOWER(i.tablespace_name) AS tablespace_name,
               LOWER(c.column_name) AS column_name, e.column_expression,
               atc.virtual_column
-            FROM all_indexes#{db_link} i
-              JOIN all_ind_columns#{db_link} c ON c.index_name = i.index_name AND c.index_owner = i.owner
-              LEFT OUTER JOIN all_ind_expressions#{db_link} e ON e.index_name = i.index_name AND
+            FROM all_indexes i
+              JOIN all_ind_columns c ON c.index_name = i.index_name AND c.index_owner = i.owner
+              LEFT OUTER JOIN all_ind_expressions e ON e.index_name = i.index_name AND
                 e.index_owner = i.owner AND e.column_position = c.column_position
-              LEFT OUTER JOIN all_tab_cols#{db_link} atc ON i.table_name = atc.table_name AND
+              LEFT OUTER JOIN all_tab_cols atc ON i.table_name = atc.table_name AND
                 c.column_name = atc.column_name AND i.owner = atc.owner AND atc.hidden_column = 'NO'
-            WHERE i.owner = :owner
-               AND i.table_owner = :owner
+            WHERE i.owner = SYS_CONTEXT('userenv', 'current_schema')
+               AND i.table_owner = SYS_CONTEXT('userenv', 'current_schema')
                AND i.table_name = :table_name
                AND NOT EXISTS (SELECT uc.index_name FROM all_constraints uc
                 WHERE uc.index_name = i.index_name AND uc.owner = i.owner AND uc.constraint_type = 'P')
@@ -113,10 +117,10 @@ module ActiveRecord
               statement_parameters = nil
               if row["index_type"] == "DOMAIN" && row["ityp_owner"] == "CTXSYS" && row["ityp_name"] == "CONTEXT"
                 procedure_name = default_datastore_procedure(row["index_name"])
-                source = select_values(<<-SQL.strip.gsub(/\s+/, " "), "procedure", [bind_string("owner", owner), bind_string("procedure_name", procedure_name.upcase)]).join
+                source = select_values(<<-SQL.strip.gsub(/\s+/, " "), "procedure", [bind_string("procedure_name", procedure_name.upcase)]).join
                   SELECT text
-                  FROM all_source#{db_link}
-                  WHERE owner = :owner
+                  FROM all_source
+                  WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
                     AND name = :procedure_name
                   ORDER BY line
                 SQL
@@ -192,9 +196,9 @@ module ActiveRecord
         #     t.string      :last_name, :comment => “Surname”
         #   end
 
-        def create_table(table_name, comment: nil, **options)
+        def create_table(table_name, **options)
           create_sequence = options[:id] != false
-          td = create_table_definition table_name, options[:temporary], options[:options], options[:as], options[:tablespace], options[:organization], comment: comment
+          td = create_table_definition table_name, options
 
           if options[:id] != false && !options[:as]
             pk = options.fetch(:primary_key) do
@@ -231,7 +235,9 @@ module ActiveRecord
           create_sequence_and_trigger(table_name, options) if create_sequence
 
           if supports_comments? && !supports_comments_in_create?
-            change_table_comment(table_name, comment) if comment
+            if table_comment = options[:comment].presence
+              change_table_comment(table_name, table_comment)
+            end
             td.columns.each do |column|
               change_column_comment(table_name, column.name, column.comment) if column.comment.present?
             end
@@ -242,8 +248,8 @@ module ActiveRecord
         end
 
         def rename_table(table_name, new_name) #:nodoc:
-          if new_name.to_s.length > table_name_length
-            raise ArgumentError, "New table name '#{new_name}' is too long; the limit is #{table_name_length} characters"
+          if new_name.to_s.length > DatabaseLimits::IDENTIFIER_MAX_LENGTH
+            raise ArgumentError, "New table name '#{new_name}' is too long; the limit is #{DatabaseLimits::IDENTIFIER_MAX_LENGTH} characters"
           end
           execute "RENAME #{quote_table_name(table_name)} TO #{quote_table_name(new_name)}"
           execute "RENAME #{quote_table_name("#{table_name}_seq")} TO #{default_sequence_name(new_name)}" rescue nil
@@ -265,7 +271,7 @@ module ActiveRecord
           sm_table = quote_table_name(ActiveRecord::SchemaMigration.table_name)
 
           if supports_multi_insert?
-            versions.inject("INSERT ALL\n".dup) { |sql, version|
+            versions.inject(+"INSERT ALL\n") { |sql, version|
               sql << "INTO #{sm_table} (version) VALUES (#{quote(version)})\n"
             } << "SELECT * FROM DUAL\n"
           else
@@ -285,7 +291,7 @@ module ActiveRecord
           index_name, index_type, quoted_column_names, tablespace, index_options = add_index_options(table_name, column_name, options)
           execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})#{tablespace} #{index_options}"
           if index_type == "UNIQUE"
-            unless quoted_column_names =~ /\(.*\)/
+            unless /\(.*\)/.match?(quoted_column_names)
               execute "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{quote_column_name(index_name)} #{index_type} (#{quoted_column_names})"
             end
           end
@@ -354,11 +360,11 @@ module ActiveRecord
         #
         # Will always query database and not index cache.
         def index_name_exists?(table_name, index_name)
-          (owner, table_name, db_link) = @connection.describe(table_name)
+          (_owner, table_name) = @connection.describe(table_name)
           result = select_value(<<-SQL.strip.gsub(/\s+/, " "), "index name exists")
-            SELECT 1 FROM all_indexes#{db_link} i
-            WHERE i.owner = '#{owner}'
-               AND i.table_owner = '#{owner}'
+            SELECT 1 FROM all_indexes i
+            WHERE i.owner = SYS_CONTEXT('userenv', 'current_schema')
+               AND i.table_owner = SYS_CONTEXT('userenv', 'current_schema')
                AND i.table_name = '#{table_name}'
                AND i.index_name = '#{index_name.to_s.upcase}'
           SQL
@@ -376,10 +382,10 @@ module ActiveRecord
         #
         #   add_synonym :posts, "blog.posts"
         #   add_synonym :posts_seq, "blog.posts_seq"
-        #   add_synonym :employees, "hr.employees@dblink", :force => true
+        #   add_synonym :employees, "hr.employees", :force => true
         #
         def add_synonym(name, table_name, options = {})
-          sql = "CREATE".dup
+          sql = +"CREATE"
           if options[:force] == true
             sql << " OR REPLACE"
           end
@@ -486,10 +492,10 @@ module ActiveRecord
         end
 
         def table_comment(table_name) #:nodoc:
-          (owner, table_name, db_link) = @connection.describe(table_name)
-          select_value(<<-SQL.strip.gsub(/\s+/, " "), "Table comment", [bind_string("owner", owner), bind_string("table_name", table_name)])
-            SELECT comments FROM all_tab_comments#{db_link}
-            WHERE owner = :owner
+          (_owner, table_name) = @connection.describe(table_name)
+          select_value(<<-SQL.strip.gsub(/\s+/, " "), "Table comment", [bind_string("table_name", table_name)])
+            SELECT comments FROM all_tab_comments
+            WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
               AND table_name = :table_name
           SQL
         end
@@ -502,10 +508,10 @@ module ActiveRecord
 
         def column_comment(table_name, column_name) #:nodoc:
           # TODO: it  does not exist in Abstract adapter
-          (owner, table_name, db_link) = @connection.describe(table_name)
-          select_value(<<-SQL.strip.gsub(/\s+/, " "), "Column comment", [bind_string("owner", owner), bind_string("table_name", table_name), bind_string("column_name", column_name.upcase)])
-            SELECT comments FROM all_col_comments#{db_link}
-            WHERE owner = :owner
+          (_owner, table_name) = @connection.describe(table_name)
+          select_value(<<-SQL.strip.gsub(/\s+/, " "), "Column comment", [bind_string("table_name", table_name), bind_string("column_name", column_name.upcase)])
+            SELECT comments FROM all_col_comments
+            WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
               AND table_name = :table_name
               AND column_name = :column_name
           SQL
@@ -524,23 +530,23 @@ module ActiveRecord
             SELECT tablespace_name
             FROM all_tables
             WHERE table_name='#{table_name.to_s.upcase}'
-            AND owner = SYS_CONTEXT('userenv', 'session_user')
+            AND owner = SYS_CONTEXT('userenv', 'current_schema')
           SQL
         end
 
         # get table foreign keys for schema dump
         def foreign_keys(table_name) #:nodoc:
-          (owner, desc_table_name, db_link) = @connection.describe(table_name)
+          (_owner, desc_table_name) = @connection.describe(table_name)
 
-          fk_info = select_all(<<-SQL.strip.gsub(/\s+/, " "), "Foreign Keys", [bind_string("owner", owner), bind_string("desc_table_name", desc_table_name)])
+          fk_info = select_all(<<-SQL.strip.gsub(/\s+/, " "), "Foreign Keys", [bind_string("desc_table_name", desc_table_name)])
             SELECT r.table_name to_table
                   ,rc.column_name references_column
                   ,cc.column_name
                   ,c.constraint_name name
                   ,c.delete_rule
-              FROM all_constraints#{db_link} c, all_cons_columns#{db_link} cc,
-                   all_constraints#{db_link} r, all_cons_columns#{db_link} rc
-             WHERE c.owner = :owner
+              FROM all_constraints c, all_cons_columns cc,
+                   all_constraints r, all_cons_columns rc
+             WHERE c.owner = SYS_CONTEXT('userenv', 'current_schema')
                AND c.table_name = :desc_table_name
                AND c.constraint_type = 'R'
                AND cc.owner = c.owner
@@ -579,7 +585,7 @@ module ActiveRecord
             FROM all_constraints
             WHERE constraint_type = 'R'
             AND status = 'ENABLED'
-            AND owner = SYS_CONTEXT('userenv', 'session_user')
+            AND owner = SYS_CONTEXT('userenv', 'current_schema')
           SQL
           begin
             old_constraints.each do |constraint|
@@ -594,7 +600,7 @@ module ActiveRecord
         end
 
         def create_alter_table(name)
-          OracleEnhanced::AlterTable.new create_table_definition(name, false, {})
+          OracleEnhanced::AlterTable.new create_table_definition(name)
         end
 
         def update_table_definition(table_name, base)
@@ -612,7 +618,7 @@ module ActiveRecord
           end
 
           def create_table_definition(*args)
-            OracleEnhanced::TableDefinition.new(*args)
+            OracleEnhanced::TableDefinition.new(self, *args)
           end
 
           def new_column_from_field(table_name, field)
@@ -636,7 +642,7 @@ module ActiveRecord
               field["data_default"].sub!(/^'(.*)'$/m, '\1')
               field["data_default"] = nil if field["data_default"] =~ /^(null|empty_[bc]lob\(\))$/i
               # TODO: Needs better fix to fallback "N" to false
-              field["data_default"] = false if (field["data_default"] == "N" && OracleEnhancedAdapter.emulate_booleans_from_strings)
+              field["data_default"] = false if field["data_default"] == "N" && OracleEnhancedAdapter.emulate_booleans_from_strings
             end
 
             type_metadata = fetch_type_metadata(field["sql_type"], is_virtual)
@@ -656,7 +662,7 @@ module ActiveRecord
           end
 
           def tablespace_for(obj_type, tablespace_option, table_name = nil, column_name = nil)
-            tablespace_sql = "".dup
+            tablespace_sql = +""
             if tablespace = (tablespace_option || default_tablespace_for(obj_type))
               if [:blob, :clob, :nclob].include?(obj_type.to_sym)
                 tablespace_sql << " LOB (#{quote_column_name(column_name)}) STORE AS #{column_name.to_s[0..10]}_#{table_name.to_s[0..14]}_ls (TABLESPACE #{tablespace})"
@@ -679,33 +685,11 @@ module ActiveRecord
           end
 
           def create_sequence_and_trigger(table_name, options)
+            # TODO: Needs rename since no triggers created
+            # This method will be removed since sequence will not be created separately
             seq_name = options[:sequence_name] || default_sequence_name(table_name)
             seq_start_value = options[:sequence_start_value] || default_sequence_start_value
             execute "CREATE SEQUENCE #{quote_table_name(seq_name)} START WITH #{seq_start_value}"
-
-            create_primary_key_trigger(table_name, options) if options[:primary_key_trigger]
-          end
-
-          def create_primary_key_trigger(table_name, options)
-            seq_name = options[:sequence_name] || default_sequence_name(table_name)
-            trigger_name = options[:trigger_name] || default_trigger_name(table_name)
-            primary_key = options[:primary_key] || Base.get_primary_key(table_name.to_s.singularize)
-            execute <<-SQL
-            CREATE OR REPLACE TRIGGER #{quote_table_name(trigger_name)}
-            BEFORE INSERT ON #{quote_table_name(table_name)} FOR EACH ROW
-            BEGIN
-              IF inserting THEN
-                IF :new.#{quote_column_name(primary_key)} IS NULL THEN
-                  SELECT #{quote_table_name(seq_name)}.NEXTVAL INTO :new.#{quote_column_name(primary_key)} FROM dual;
-                END IF;
-              END IF;
-            END;
-          SQL
-          end
-
-          def default_trigger_name(table_name)
-            # truncate table name if necessary to fit in max length of identifier
-            "#{table_name.to_s[0, table_name_length - 4]}_pkt"
           end
 
           def rebuild_primary_key_index_to_default_tablespace(table_name, options)