pg_online_schema_change 0.7.4 → 0.8.0

data/lib/pg_online_schema_change/orchestrate.rb

@@ -30,16 +30,23 @@ module PgOnlineSchemaChange
         # Set this early on to ensure their creation and cleanup (unexpected)
         # happens at all times. IOW, the calls from Store.get always return
         # the same value.
-        Store.set(:old_primary_table, "pgosc_op_table_#{client.table}")
-        Store.set(:audit_table, "pgosc_at_#{client.table}_#{pgosc_identifier}")
+        Store.set(:old_primary_table, "pgosc_op_table_#{client.table.downcase}")
+        Store.set(:audit_table, "pgosc_at_#{client.table.downcase}_#{pgosc_identifier}")
         Store.set(:operation_type_column, "operation_type_#{pgosc_identifier}")
         Store.set(:trigger_time_column, "trigger_time_#{pgosc_identifier}")
         Store.set(:audit_table_pk, "at_#{pgosc_identifier}_id")
         Store.set(:audit_table_pk_sequence, "#{audit_table}_#{audit_table_pk}_seq")
-        Store.set(:shadow_table, "pgosc_st_#{client.table}_#{pgosc_identifier}")
-
-        Store.set(:referential_foreign_key_statements, Query.referential_foreign_keys_to_refresh(client, client.table))
-        Store.set(:self_foreign_key_statements, Query.self_foreign_keys_to_refresh(client, client.table))
+        Store.set(:shadow_table, "pgosc_st_#{client.table.downcase}_#{pgosc_identifier}")
+
+        Store.set(
+          :referential_foreign_key_statements,
+          Query.referential_foreign_keys_to_refresh(client, client.table_name),
+        )
+        Store.set(
+          :self_foreign_key_statements,
+          Query.self_foreign_keys_to_refresh(client, client.table_name),
+        )
+        Store.set(:trigger_statements, Query.get_triggers_for(client, client.table_name))
       end
 
       def run!(options)
@@ -49,6 +56,7 @@ module PgOnlineSchemaChange
         raise Error, "Parent table has no primary key, exiting..." if primary_key.nil?
 
         setup_audit_table!
+
         setup_trigger!
         setup_shadow_table! # re-uses transaction with serializable
         disable_vacuum! # re-uses transaction with serializable
@@ -72,9 +80,7 @@ module PgOnlineSchemaChange
       def setup_signals!
         reader, writer = IO.pipe
 
-        %w[TERM QUIT INT].each do |sig|
-          trap(sig) { writer.puts sig }
-        end
+        ['TERM', 'QUIT', 'INT'].each { |sig| trap(sig) { writer.puts sig } }
 
         reader
       end
@@ -83,14 +89,14 @@ module PgOnlineSchemaChange
         reader = setup_signals!
         signal = reader.gets.chomp
 
-        while !reader.closed? && IO.select([reader]) # rubocop:disable Lint/UnreachableLoop
-          logger.info "Signal #{signal} received, cleaning up"
+        while !reader.closed? && reader.wait_readable # rubocop:disable Lint/UnreachableLoop
+          logger.info("Signal #{signal} received, cleaning up")
 
           client.connection.cancel
           drop_and_cleanup!
           reader.close
 
-          exit Signal.list[signal]
+          exit(Signal.list[signal])
         end
       end
 
@@ -98,7 +104,7 @@ module PgOnlineSchemaChange
         logger.info("Setting up audit table", { audit_table: audit_table })
 
         sql = <<~SQL
-          CREATE TABLE #{audit_table} (#{audit_table_pk} SERIAL PRIMARY KEY, #{operation_type_column} text, #{trigger_time_column} timestamp, LIKE #{client.table});
+          CREATE TABLE #{audit_table} (#{audit_table_pk} SERIAL PRIMARY KEY, #{operation_type_column} text, #{trigger_time_column} timestamp, LIKE #{client.table_name});
         SQL
 
         Query.run(client.connection, sql)
@@ -108,34 +114,34 @@ module PgOnlineSchemaChange
         # acquire access exclusive lock to ensure audit triggers
         # are setup fine. This also calls kill_backends (if opted in via flag)
         # so any competing backends will be killed to setup the trigger
-        opened = Query.open_lock_exclusive(client, client.table)
+        opened = Query.open_lock_exclusive(client, client.table_name)
 
         raise AccessExclusiveLockNotAcquired unless opened
 
         logger.info("Setting up triggers")
 
         sql = <<~SQL
-          DROP TRIGGER IF EXISTS primary_to_audit_table_trigger ON #{client.table};
+          DROP TRIGGER IF EXISTS primary_to_audit_table_trigger ON #{client.table_name};
 
           CREATE OR REPLACE FUNCTION primary_to_audit_table_trigger()
           RETURNS TRIGGER AS
           $$
           BEGIN
             IF ( TG_OP = 'INSERT') THEN
-              INSERT INTO \"#{audit_table}\" select nextval(\'#{audit_table_pk_sequence}\'), 'INSERT', clock_timestamp(), NEW.* ;
+              INSERT INTO "#{audit_table}" select nextval('#{audit_table_pk_sequence}'), 'INSERT', clock_timestamp(), NEW.* ;
               RETURN NEW;
             ELSIF ( TG_OP = 'UPDATE') THEN
-              INSERT INTO \"#{audit_table}\" select nextval(\'#{audit_table_pk_sequence}\'), 'UPDATE', clock_timestamp(),  NEW.* ;
+              INSERT INTO "#{audit_table}" select nextval('#{audit_table_pk_sequence}'), 'UPDATE', clock_timestamp(),  NEW.* ;
               RETURN NEW;
             ELSIF ( TG_OP = 'DELETE') THEN
-              INSERT INTO \"#{audit_table}\" select nextval(\'#{audit_table_pk_sequence}\'), 'DELETE', clock_timestamp(), OLD.* ;
+              INSERT INTO "#{audit_table}" select nextval('#{audit_table_pk_sequence}'), 'DELETE', clock_timestamp(), OLD.* ;
               RETURN NEW;
             END IF;
           END;
           $$ LANGUAGE PLPGSQL SECURITY DEFINER;
 
           CREATE TRIGGER primary_to_audit_table_trigger
-          AFTER INSERT OR UPDATE OR DELETE ON #{client.table}
+          AFTER INSERT OR UPDATE OR DELETE ON #{client.table_name}
           FOR EACH ROW EXECUTE PROCEDURE primary_to_audit_table_trigger();
         SQL
 
@@ -156,20 +162,30 @@ module PgOnlineSchemaChange
         Query.run(client.connection, "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE", true)
         logger.info("Setting up shadow table", { shadow_table: shadow_table })
 
-        Query.run(client.connection, "SELECT create_table_all('#{client.table}', '#{shadow_table}');", true)
+        Query.run(
+          client.connection,
+          "SELECT create_table_all('#{client.table_name}', '#{shadow_table}');",
+          true,
+        )
 
         # update serials
-        Query.run(client.connection, "SELECT fix_serial_sequence('#{client.table}', '#{shadow_table}');", true)
+        Query.run(
+          client.connection,
+          "SELECT fix_serial_sequence('#{client.table_name}', '#{shadow_table}');",
+          true,
+        )
       end
 
       def disable_vacuum!
         # re-uses transaction with serializable
         # Disabling vacuum to avoid any issues during the process
-        result = Query.storage_parameters_for(client, client.table, true) || ""
+        result = Query.storage_parameters_for(client, client.table_name, true) || ""
         Store.set(:primary_table_storage_parameters, result)
 
-        logger.debug("Disabling vacuum on shadow and audit table",
-                     { shadow_table: shadow_table, audit_table: audit_table })
+        logger.debug(
+          "Disabling vacuum on shadow and audit table",
+          { shadow_table: shadow_table, audit_table: audit_table },
+        )
         sql = <<~SQL
           ALTER TABLE #{shadow_table} SET (
             autovacuum_enabled = false, toast.autovacuum_enabled = false
@@ -185,8 +201,10 @@ module PgOnlineSchemaChange
       def run_alter_statement!
         # re-uses transaction with serializable
         statement = Query.alter_statement_for(client, shadow_table)
-        logger.info("Running alter statement on shadow table",
-                    { shadow_table: shadow_table, parent_table: client.table })
+        logger.info(
+          "Running alter statement on shadow table",
+          { shadow_table: shadow_table, parent_table: client.table_name },
+        )
         Query.run(client.connection, statement, true)
 
         Store.set(:dropped_columns_list, Query.dropped_columns(client))
@@ -198,10 +216,16 @@ module PgOnlineSchemaChange
         # Begin the process to copy data into copy table
         # depending on the size of the table, this can be a time
         # taking operation.
-        logger.info("Clearing contents of audit table before copy..", { shadow_table: shadow_table, parent_table: client.table })
+        logger.info(
+          "Clearing contents of audit table before copy..",
+          { shadow_table: shadow_table, parent_table: client.table_name },
+        )
         Query.run(client.connection, "DELETE FROM #{audit_table}", true)
 
-        logger.info("Copying contents..", { shadow_table: shadow_table, parent_table: client.table })
+        logger.info(
+          "Copying contents..",
+          { shadow_table: shadow_table, parent_table: client.table_name },
+        )
         if client.copy_statement
           query = format(client.copy_statement, shadow_table: shadow_table)
           return Query.run(client.connection, query, true)
@@ -223,31 +247,34 @@ module PgOnlineSchemaChange
 
       def swap!
         logger.info("Performing swap!")
-
-        storage_params_reset = primary_table_storage_parameters.empty? ? "" : "ALTER TABLE #{client.table} SET (#{primary_table_storage_parameters});"
-
         # From here on, all statements are carried out in a single
         # transaction with access exclusive lock
 
-        opened = Query.open_lock_exclusive(client, client.table)
+        opened = Query.open_lock_exclusive(client, client.table_name)
 
         raise AccessExclusiveLockNotAcquired unless opened
 
-        Query.run(client.connection, "SET statement_timeout to '#{SWAP_STATEMENT_TIMEOUT}';", opened)
+        Query.run(
+          client.connection,
+          "SET statement_timeout to '#{SWAP_STATEMENT_TIMEOUT}';",
+          opened,
+        )
 
         rows = Replay.rows_to_play(opened)
         Replay.play!(rows, opened)
 
-        query_for_primary_key_refresh = Query.query_for_primary_key_refresh(shadow_table, primary_key, client.table, opened)
+        query_for_primary_key_refresh =
+          Query.query_for_primary_key_refresh(shadow_table, primary_key, client.table_name, opened)
 
         sql = <<~SQL
           #{query_for_primary_key_refresh};
-          ALTER TABLE #{client.table} RENAME to #{old_primary_table};
-          ALTER TABLE #{shadow_table} RENAME to #{client.table};
+          ALTER TABLE #{client.table_name} RENAME to #{old_primary_table};
+          ALTER TABLE #{shadow_table} RENAME to #{client.table_name};
           #{referential_foreign_key_statements}
           #{self_foreign_key_statements}
+          #{trigger_statements}
           #{storage_params_reset}
-          DROP TRIGGER IF EXISTS primary_to_audit_table_trigger ON #{client.table};
+          DROP TRIGGER IF EXISTS primary_to_audit_table_trigger ON #{client.table_name};
         SQL
 
         Query.run(client.connection, sql, opened)
@@ -259,13 +286,13 @@ module PgOnlineSchemaChange
       def run_analyze!
         logger.info("Performing ANALYZE!")
 
-        Query.run(client.connection, "ANALYZE VERBOSE #{client.table};")
+        Query.run(client.connection, "ANALYZE VERBOSE #{client.table_name};")
       end
 
       def validate_constraints!
         logger.info("Validating constraints!")
 
-        validate_statements = Query.get_foreign_keys_to_validate(client, client.table)
+        validate_statements = Query.get_foreign_keys_to_validate(client, client.table_name)
 
         Query.run(client.connection, validate_statements)
       end
@@ -276,7 +303,7 @@ module PgOnlineSchemaChange
         shadow_table_drop = shadow_table ? "DROP TABLE IF EXISTS #{shadow_table}" : ""
 
         sql = <<~SQL
-          DROP TRIGGER IF EXISTS primary_to_audit_table_trigger ON #{client.table};
+          DROP TRIGGER IF EXISTS primary_to_audit_table_trigger ON #{client.table_name};
           #{audit_table_drop};
           #{shadow_table_drop};
           #{primary_drop}
@@ -293,6 +320,17 @@ module PgOnlineSchemaChange
       def pgosc_identifier
         @pgosc_identifier ||= SecureRandom.hex(3)
       end
+
+      def storage_params_reset
+        "ALTER TABLE #{client.table_name} RESET (autovacuum_enabled, toast.autovacuum_enabled);" +
+          (
+            if primary_table_storage_parameters.empty?
+              ""
+            else
+              "ALTER TABLE #{client.table_name} SET (#{primary_table_storage_parameters});"
+            end
+          )
+      end
     end
   end
 end

data/lib/pg_online_schema_change/query.rb

@@ -14,21 +14,31 @@ module PgOnlineSchemaChange
 
     class << self
       def alter_statement?(query)
-        PgQuery.parse(query).tree.stmts.all? do |statement|
-          statement.stmt.alter_table_stmt.instance_of?(PgQuery::AlterTableStmt) || statement.stmt.rename_stmt.instance_of?(PgQuery::RenameStmt)
-        end
+        PgQuery
+          .parse(query)
+          .tree
+          .stmts
+          .all? do |statement|
+            statement.stmt.alter_table_stmt.instance_of?(PgQuery::AlterTableStmt) ||
+              statement.stmt.rename_stmt.instance_of?(PgQuery::RenameStmt)
+          end
       rescue PgQuery::ParseError
         false
       end
 
       def same_table?(query)
-        tables = PgQuery.parse(query).tree.stmts.filter_map do |statement|
-          if statement.stmt.alter_table_stmt.instance_of?(PgQuery::AlterTableStmt)
-            statement.stmt.alter_table_stmt.relation.relname
-          elsif statement.stmt.rename_stmt.instance_of?(PgQuery::RenameStmt)
-            statement.stmt.rename_stmt.relation.relname
-          end
-        end
+        tables =
+          PgQuery
+            .parse(query)
+            .tree
+            .stmts
+            .filter_map do |statement|
+              if statement.stmt.alter_table_stmt.instance_of?(PgQuery::AlterTableStmt)
+                statement.stmt.alter_table_stmt.relation.relname
+              elsif statement.stmt.rename_stmt.instance_of?(PgQuery::RenameStmt)
+                statement.stmt.rename_stmt.relation.relname
+              end
+            end
 
         tables.uniq.count == 1
       rescue PgQuery::ParseError
@@ -36,14 +46,30 @@ module PgOnlineSchemaChange
       end
 
       def table(query)
-        from_rename_statement = PgQuery.parse(query).tree.stmts.filter_map do |statement|
-          statement.stmt.rename_stmt&.relation&.relname
-        end[0]
+        from_rename_statement =
+          PgQuery
+            .parse(query)
+            .tree
+            .stmts
+            .filter_map { |statement| statement.stmt.rename_stmt&.relation&.relname }[
+            0
+          ]
         PgQuery.parse(query).tables[0] || from_rename_statement
       end
 
+      def table_name(query, table)
+        table_name = "\"#{table}\""
+        if table =~ /[A-Z]/ && query.include?(table_name) && table[0] != '"'
+          table_name
+        else
+          table
+        end
+      end
+
       def run(connection, query, reuse_trasaction = false, &block)
-        connection.cancel if [PG::PQTRANS_INERROR, PG::PQTRANS_UNKNOWN].include?(connection.transaction_status)
+        if [PG::PQTRANS_INERROR, PG::PQTRANS_UNKNOWN].include?(connection.transaction_status)
+          connection.cancel
+        end
 
         logger.debug("Running query", { query: query })
 
@@ -65,18 +91,19 @@ module PgOnlineSchemaChange
       def table_columns(client, table = nil, reuse_trasaction = false)
         sql = <<~SQL
           SELECT attname as column_name, format_type(atttypid, atttypmod) as type, attnum as column_position FROM   pg_attribute
-          WHERE  attrelid = \'#{table || client.table}\'::regclass AND attnum > 0 AND NOT attisdropped
+          WHERE  attrelid = '#{table || client.table_name}'::regclass AND attnum > 0 AND NOT attisdropped
           ORDER  BY attnum;
         SQL
         mapped_columns = []
 
         run(client.connection, sql, reuse_trasaction) do |result|
-          mapped_columns = result.map do |row|
-            row["column_name_regular"] = row["column_name"]
-            row["column_name"] = client.connection.quote_ident(row["column_name"])
-            row["column_position"] = row["column_position"].to_i
-            row
-          end
+          mapped_columns =
+            result.map do |row|
+              row["column_name_regular"] = row["column_name"]
+              row["column_name"] = client.connection.quote_ident(row["column_name"])
+              row["column_position"] = row["column_position"].to_i
+              row
+            end
         end
 
         mapped_columns
@@ -86,7 +113,9 @@ module PgOnlineSchemaChange
         parsed_query = PgQuery.parse(client.alter_statement)
 
         parsed_query.tree.stmts.each do |statement|
-          statement.stmt.alter_table_stmt.relation.relname = shadow_table if statement.stmt.alter_table_stmt
+          if statement.stmt.alter_table_stmt
+            statement.stmt.alter_table_stmt.relation.relname = shadow_table
+          end
 
           statement.stmt.rename_stmt.relation.relname = shadow_table if statement.stmt.rename_stmt
         end
@@ -97,17 +126,27 @@ module PgOnlineSchemaChange
         query = <<~SQL
           SELECT indexdef, schemaname
           FROM pg_indexes
-          WHERE schemaname = \'#{client.schema}\' AND tablename = \'#{table}\'
+          WHERE schemaname = '#{client.schema}' AND tablename = '#{table}'
         SQL
 
         indexes = []
-        run(client.connection, query) do |result|
-          indexes = result.map { |row| row["indexdef"] }
-        end
+        run(client.connection, query) { |result| indexes = result.map { |row| row["indexdef"] } }
 
         indexes
       end
 
+      def get_triggers_for(client, table)
+        query = <<~SQL
+          SELECT pg_get_triggerdef(oid) as tdef FROM pg_trigger
+          WHERE  tgrelid = '#{client.schema}.#{table}'::regclass AND tgisinternal = FALSE;
+        SQL
+
+        triggers = []
+        run(client.connection, query) { |result| triggers = result.map { |row| "#{row["tdef"]};" } }
+
+        triggers.join(";")
+      end
+
       def get_all_constraints_for(client)
         query = <<~SQL
           SELECT  conrelid::regclass AS table_on,
@@ -121,9 +160,7 @@ module PgOnlineSchemaChange
         SQL
 
         constraints = []
-        run(client.connection, query) do |result|
-          constraints = result.map { |row| row }
-        end
+        run(client.connection, query) { |result| constraints = result.map { |row| row } }
 
         constraints
       end
@@ -141,72 +178,93 @@ module PgOnlineSchemaChange
       end
 
       def referential_foreign_keys_to_refresh(client, table)
-        references = get_all_constraints_for(client).select do |row|
-          row["table_from"] == table && row["constraint_type"] == "f"
-        end
+        references =
+          get_all_constraints_for(client).select do |row|
+            row["table_from"] == table && row["constraint_type"] == "f"
+          end
 
-        references.map do |row|
-          add_statement = if row["definition"].end_with?("NOT VALID")
-                            "ALTER TABLE #{row["table_on"]} ADD CONSTRAINT #{row["constraint_name"]} #{row["definition"]};"
-                          else
-                            "ALTER TABLE #{row["table_on"]} ADD CONSTRAINT #{row["constraint_name"]} #{row["definition"]} NOT VALID;"
-                          end
+        references
+          .map do |row|
+            add_statement =
+              if row["definition"].end_with?("NOT VALID")
+                "ALTER TABLE #{row["table_on"]} ADD CONSTRAINT #{row["constraint_name"]} #{row["definition"]};"
+              else
+                "ALTER TABLE #{row["table_on"]} ADD CONSTRAINT #{row["constraint_name"]} #{row["definition"]} NOT VALID;"
+              end
 
-          drop_statement = "ALTER TABLE #{row["table_on"]} DROP CONSTRAINT #{row["constraint_name"]};"
+            drop_statement =
+              "ALTER TABLE #{row["table_on"]} DROP CONSTRAINT #{row["constraint_name"]};"
 
-          "#{drop_statement} #{add_statement}"
-        end.join
+            "#{drop_statement} #{add_statement}"
+          end
+          .join
       end
 
       def self_foreign_keys_to_refresh(client, table)
-        references = get_all_constraints_for(client).select do |row|
-          row["table_on"] == table && row["constraint_type"] == "f"
-        end
+        references =
+          get_all_constraints_for(client).select do |row|
+            row["table_on"] == table && row["constraint_type"] == "f"
+          end
 
-        references.map do |row|
-          add_statement = if row["definition"].end_with?("NOT VALID")
-                            "ALTER TABLE #{row["table_on"]} ADD CONSTRAINT #{row["constraint_name"]} #{row["definition"]};"
-                          else
-                            "ALTER TABLE #{row["table_on"]} ADD CONSTRAINT #{row["constraint_name"]} #{row["definition"]} NOT VALID;"
-                          end
-          add_statement
-        end.join
+        references
+          .map do |row|
+            add_statement =
+              if row["definition"].end_with?("NOT VALID")
+                "ALTER TABLE #{row["table_on"]} ADD CONSTRAINT #{row["constraint_name"]} #{row["definition"]};"
+              else
+                "ALTER TABLE #{row["table_on"]} ADD CONSTRAINT #{row["constraint_name"]} #{row["definition"]} NOT VALID;"
+              end
+            add_statement
+          end
+          .join
       end
 
       def get_foreign_keys_to_validate(client, table)
         constraints = get_all_constraints_for(client)
-        referential_foreign_keys = constraints.select do |row|
-          row["table_from"] == table && row["constraint_type"] == "f"
-        end
+        referential_foreign_keys =
+          constraints.select { |row| row["table_from"] == table && row["constraint_type"] == "f" }
 
-        self_foreign_keys = constraints.select do |row|
-          row["table_on"] == table && row["constraint_type"] == "f"
-        end
+        self_foreign_keys =
+          constraints.select { |row| row["table_on"] == table && row["constraint_type"] == "f" }
 
-        [referential_foreign_keys, self_foreign_keys].flatten.map do |row|
-          "ALTER TABLE #{row["table_on"]} VALIDATE CONSTRAINT #{row["constraint_name"]};"
-        end.join
+        [referential_foreign_keys, self_foreign_keys].flatten
+          .map do |row|
+            "ALTER TABLE #{row["table_on"]} VALIDATE CONSTRAINT #{row["constraint_name"]};"
+          end
+          .join
       end
 
       def dropped_columns(client)
-        PgQuery.parse(client.alter_statement).tree.stmts.map do |statement|
-          next if statement.stmt.alter_table_stmt.nil?
-
-          statement.stmt.alter_table_stmt.cmds.map do |cmd|
-            cmd.alter_table_cmd.name if cmd.alter_table_cmd.subtype == DROPPED_COLUMN_TYPE
+        PgQuery
+          .parse(client.alter_statement)
+          .tree
+          .stmts
+          .map do |statement|
+            next if statement.stmt.alter_table_stmt.nil?
+
+            statement.stmt.alter_table_stmt.cmds.map do |cmd|
+              cmd.alter_table_cmd.name if cmd.alter_table_cmd.subtype == DROPPED_COLUMN_TYPE
+            end
           end
-        end.flatten.compact
+          .flatten
+          .compact
       end
 
       def renamed_columns(client)
-        PgQuery.parse(client.alter_statement).tree.stmts.map do |statement|
-          next if statement.stmt.rename_stmt.nil?
-
-          {
-            old_name: statement.stmt.rename_stmt.subname,
-            new_name: statement.stmt.rename_stmt.newname,
-          }
-        end.flatten.compact
+        PgQuery
+          .parse(client.alter_statement)
+          .tree
+          .stmts
+          .map do |statement|
+            next if statement.stmt.rename_stmt.nil?
+
+            {
+              old_name: statement.stmt.rename_stmt.subname,
+              new_name: statement.stmt.rename_stmt.newname,
+            }
+          end
+          .flatten
+          .compact
       end
 
       def primary_key_for(client, table)
@@ -215,9 +273,9 @@ module PgOnlineSchemaChange
             pg_attribute.attname as column_name
           FROM pg_index, pg_class, pg_attribute, pg_namespace
           WHERE
-            pg_class.oid = \'#{table}\'::regclass AND
+            pg_class.oid = '#{table}'::regclass AND
             indrelid = pg_class.oid AND
-            nspname = \'#{client.schema}\' AND
+            nspname = '#{client.schema}' AND
             pg_class.relnamespace = pg_namespace.oid AND
             pg_attribute.attrelid = pg_class.oid AND
             pg_attribute.attnum = any(pg_index.indkey)
@@ -225,16 +283,14 @@ module PgOnlineSchemaChange
         SQL
 
         columns = []
-        run(client.connection, query) do |result|
-          columns = result.map { |row| row["column_name"] }
-        end
+        run(client.connection, query) { |result| columns = result.map { |row| row["column_name"] } }
 
         columns.first
       end
 
       def storage_parameters_for(client, table, reuse_trasaction = false)
         query = <<~SQL
-          SELECT array_to_string(reloptions, ',') as params FROM pg_class WHERE relname=\'#{table}\';
+          SELECT array_to_string(reloptions, ',') as params FROM pg_class WHERE relname='#{table}';
         SQL
 
         columns = []
@@ -255,7 +311,7 @@ module PgOnlineSchemaChange
 
         query = <<~SQL
           SET lock_timeout = '#{client.wait_time_for_lock}s';
-          LOCK TABLE #{client.table} IN ACCESS EXCLUSIVE MODE;
+          LOCK TABLE #{client.table_name} IN ACCESS EXCLUSIVE MODE;
         SQL
         run(client.connection, query, true)
 
@@ -282,16 +338,17 @@ module PgOnlineSchemaChange
         logger.info("Terminating other backends")
 
         query = <<~SQL
-          SELECT pg_terminate_backend(pid) FROM pg_locks WHERE locktype = 'relation' AND relation = \'#{table}\'::regclass::oid AND pid <> pg_backend_pid()
+          SELECT pg_terminate_backend(pid) FROM pg_locks WHERE locktype = 'relation' AND relation = '#{table}'::regclass::oid AND pid <> pg_backend_pid()
         SQL
 
         run(client.connection, query, true)
       end
 
       def copy_data_statement(client, shadow_table, reuse_trasaction = false)
-        select_columns = table_columns(client, client.table, reuse_trasaction).map do |entry|
-          entry["column_name_regular"]
-        end
+        select_columns =
+          table_columns(client, client.table_name, reuse_trasaction).map do |entry|
+            entry["column_name_regular"]
+          end
 
         select_columns -= dropped_columns_list if dropped_columns_list.any?
 
@@ -309,27 +366,23 @@ module PgOnlineSchemaChange
           client.connection.quote_ident(insert_into_column)
         end
 
-        select_columns.map! do |select_column|
-          client.connection.quote_ident(select_column)
-        end
+        select_columns.map! { |select_column| client.connection.quote_ident(select_column) }
 
         <<~SQL
           INSERT INTO #{shadow_table}(#{insert_into_columns.join(", ")})
           SELECT #{select_columns.join(", ")}
-          FROM ONLY #{client.table}
+          FROM ONLY #{client.table_name}
         SQL
       end
 
       def primary_key_sequence(shadow_table, primary_key, opened)
         query = <<~SQL
-          SELECT pg_get_serial_sequence(\'#{shadow_table}\', \'#{primary_key}\') as sequence_name
+          SELECT pg_get_serial_sequence('#{shadow_table}', '#{primary_key}') as sequence_name
         SQL
 
         result = run(client.connection, query, opened)
 
-        result.map do |row|
-          row["sequence_name"]
-        end&.first
+        result.map { |row| row["sequence_name"] }&.first
       end
 
       def query_for_primary_key_refresh(shadow_table, primary_key, table, opened)
@@ -338,7 +391,7 @@ module PgOnlineSchemaChange
         return "" if sequence_name.nil?
 
         <<~SQL
-          SELECT setval((select pg_get_serial_sequence(\'#{shadow_table}\', \'#{primary_key}\')), (SELECT max(#{primary_key}) FROM #{table}));
+          SELECT setval((select pg_get_serial_sequence('#{shadow_table}', '#{primary_key}')), (SELECT max(#{primary_key}) FROM #{table}));
         SQL
       end
     end