pgslice 0.7.0 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 325b5cd0c6ec6dfa7a98db88a06bb47ed4f8ee327c6c21dddfd897ec13f54533
-  data.tar.gz: aabbfee0e2bced3b7e93f4d9f0db218db060779a3b75b14ac7056867901bae26
+  metadata.gz: 80b19b5f7b8bc83c0e75061952d6b26b1dc6ddba6eec34c1ca6a25ec53050201
+  data.tar.gz: b59c9d219b0bc539b5e45c078ff7bdd9bf3df9a3856574f811a19a33052c58bb
 SHA512:
-  metadata.gz: ba7310102950041d8247779282b6b252d40d7c824bd03b07d08ed7e400534cbf44eb31161595004ff782ccdaa9eacd0d6698797068ea06109ef974eebab8439b
-  data.tar.gz: 50faa245fb1ac68b6b685af8529277f23a46146477fd37e9ec52a6984222daa3392ca49e9d5276f03177f755ccec5c94989d4f6f25e182f3013ed9b24a8a7250
+  metadata.gz: db38bae9e3a120383329c1a9dbb2dc031700774bc57b0e5153a49c5f1683018d3752d363ea35976ca09f3da36ffa249f2bd9cdef74797461af60302089facef9
+  data.tar.gz: f4d51f9a864901a7305224b720c3e261a95a35584dc42d2559ca15068d5c2bea87755c4321c57aa76d60413c742b3cf5b767b731e759c83b2ce8c69502ecd4a0

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.7.2 (2026-01-05)
+
+- Added support for Ruby 4.0
+
+## 0.7.1 (2025-07-27)
+
+- Fixed `analyze` analyzing partitions twice with declarative partitioning
+- Removed unnecessary query for `unprep` with declarative partitioning
+
 ## 0.7.0 (2025-05-26)
 
 - Dropped support for Ruby < 3

data/README.md

@@ -14,7 +14,9 @@ pgslice is a command line tool. To install, run:
 gem install pgslice
 ```
 
-This will give you the `pgslice` command. You can also install it with [Homebrew](#homebrew) or [Docker](#docker). If installation fails, you may need to install [dependencies](#dependencies).
+This will give you the `pgslice` command. If installation fails, you may need to install [dependencies](#dependencies).
+
+You can also install it with [Homebrew](#homebrew) or [Docker](#docker).
 
 ## Steps
 
@@ -108,17 +110,17 @@ pgslice add_partitions visits --intermediate --past 1 --future 1
 ```sql
 BEGIN;
 
-CREATE TABLE "public"."visits_202408" PARTITION OF "public"."visits_intermediate" FOR VALUES FROM ('2024-08-01') TO ('2024-09-01');
+CREATE TABLE "public"."visits_202508" PARTITION OF "public"."visits_intermediate" FOR VALUES FROM ('2025-08-01') TO ('2025-09-01');
 
-ALTER TABLE "public"."visits_202408" ADD PRIMARY KEY ("id");
+ALTER TABLE "public"."visits_202508" ADD PRIMARY KEY ("id");
 
-CREATE TABLE "public"."visits_202409" PARTITION OF "public"."visits_intermediate" FOR VALUES FROM ('2024-09-01') TO ('2024-10-01');
+CREATE TABLE "public"."visits_202509" PARTITION OF "public"."visits_intermediate" FOR VALUES FROM ('2025-09-01') TO ('2025-10-01');
 
-ALTER TABLE "public"."visits_202409" ADD PRIMARY KEY ("id");
+ALTER TABLE "public"."visits_202509" ADD PRIMARY KEY ("id");
 
-CREATE TABLE "public"."visits_202410" PARTITION OF "public"."visits_intermediate" FOR VALUES FROM ('2024-10-01') TO ('2024-11-01');
+CREATE TABLE "public"."visits_202510" PARTITION OF "public"."visits_intermediate" FOR VALUES FROM ('2025-10-01') TO ('2025-11-01');
 
-ALTER TABLE "public"."visits_202410" ADD PRIMARY KEY ("id");
+ALTER TABLE "public"."visits_202510" ADD PRIMARY KEY ("id");
 
 COMMIT;
 ```
@@ -131,17 +133,17 @@ pgslice fill visits
 /* 1 of 3 */
 INSERT INTO "public"."visits_intermediate" ("id", "user_id", "ip", "created_at")
     SELECT "id", "user_id", "ip", "created_at" FROM "public"."visits"
-    WHERE "id" > 0 AND "id" <= 10000 AND "created_at" >= '2024-08-01'::date AND "created_at" < '2024-11-01'::date
+    WHERE "id" > 0 AND "id" <= 10000 AND "created_at" >= '2025-08-01'::date AND "created_at" < '2025-11-01'::date
 
 /* 2 of 3 */
 INSERT INTO "public"."visits_intermediate" ("id", "user_id", "ip", "created_at")
     SELECT "id", "user_id", "ip", "created_at" FROM "public"."visits"
-    WHERE "id" > 10000 AND "id" <= 20000 AND "created_at" >= '2024-08-01'::date AND "created_at" < '2024-11-01'::date
+    WHERE "id" > 10000 AND "id" <= 20000 AND "created_at" >= '2025-08-01'::date AND "created_at" < '2025-11-01'::date
 
 /* 3 of 3 */
 INSERT INTO "public"."visits_intermediate" ("id", "user_id", "ip", "created_at")
     SELECT "id", "user_id", "ip", "created_at" FROM "public"."visits"
-    WHERE "id" > 20000 AND "id" <= 30000 AND "created_at" >= '2024-08-01'::date AND "created_at" < '2024-11-01'::date
+    WHERE "id" > 20000 AND "id" <= 30000 AND "created_at" >= '2025-08-01'::date AND "created_at" < '2025-11-01'::date
 ```
 
 ```sh
@@ -149,11 +151,11 @@ pgslice analyze visits
 ```
 
 ```sql
-ANALYZE VERBOSE "public"."visits_202408";
+ANALYZE VERBOSE "public"."visits_202508";
 
-ANALYZE VERBOSE "public"."visits_202409";
+ANALYZE VERBOSE "public"."visits_202509";
 
-ANALYZE VERBOSE "public"."visits_202410";
+ANALYZE VERBOSE "public"."visits_202510";
 
 ANALYZE VERBOSE "public"."visits_intermediate";
 ```
@@ -217,14 +219,14 @@ WHERE
 Back up and drop older partitions each day, month, or year.
 
 ```sh
-pg_dump -c -Fc -t <table>_202409 $PGSLICE_URL > <table>_202409.dump
-psql -c "DROP TABLE <table>_202409" $PGSLICE_URL
+pg_dump -c -Fc -t <table>_202509 $PGSLICE_URL > <table>_202509.dump
+psql -c "DROP TABLE <table>_202509" $PGSLICE_URL
 ```
 
 If you use [Amazon S3](https://aws.amazon.com/s3/) for backups, [s3cmd](https://github.com/s3tools/s3cmd) is a nice tool.
 
 ```sh
-s3cmd put <table>_202409.dump s3://<s3-bucket>/<table>_202409.dump
+s3cmd put <table>_202509.dump s3://<s3-bucket>/<table>_202509.dump
 ```
 
 ## Schema Updates
@@ -267,7 +269,7 @@ SELECT * FROM
 WHERE
     user_id = 123 AND
     -- for performance
-    created_at >= '2024-09-01' AND created_at < '2024-09-02'
+    created_at >= '2025-09-01' AND created_at < '2025-09-02'
 ```
 
 For this to be effective, ensure `constraint_exclusion` is set to `partition` (the default value) or `on`.
@@ -299,12 +301,14 @@ You can also use pgslice to reduce the size of a table without partitioning by c
 ```sh
 pgslice prep <table> --no-partition
 pgslice fill <table> --where "id > 1000" # use any conditions
+pgslice analyze <table>
 pgslice swap <table>
+pgslice fill <table> --where "id > 1000" --swapped
 ```
 
 ## Triggers
 
-Triggers aren’t copied from the original table. You can set up triggers on the intermediate table if needed. Note that Postgres doesn’t support `BEFORE / FOR EACH ROW` triggers on partitioned tables.
+Triggers aren’t copied from the original table. You can set up triggers on the intermediate table if needed.
 
 ## Data Protection
 
@@ -317,7 +321,7 @@ Always make sure your [connection is secure](https://ankane.org/postgres-sslmode
 With Homebrew, you can use:
 
 ```sh
-brew install ankane/brew/pgslice
+brew install pgslice
 ```
 
 ### Docker

data/lib/pgslice/cli/add_partitions.rb

@@ -13,7 +13,11 @@ module PgSlice
       assert_table(table)
 
       future = options[:future]
+      # TODO uncomment in 0.8.0
+      # abort "--future cannot be negative" if future < 0
       past = options[:past]
+      # TODO uncomment in 0.8.0
+      # abort "--past cannot be negative" if past < 0
       tablespace = options[:tablespace]
       range = (-1 * past)..future
 
@@ -27,7 +31,7 @@ module PgSlice
       queries = []
 
       if needs_comment
-        queries << "COMMENT ON TRIGGER #{quote_ident(trigger_name)} ON #{quote_table(table)} IS 'column:#{field},period:#{period},cast:#{cast}';"
+        queries << "COMMENT ON TRIGGER #{quote_ident(trigger_name)} ON #{quote_table(table)} IS #{quote("column:#{field},period:#{period},cast:#{cast}")};"
       end
 
       # today = utc date
@@ -63,14 +67,14 @@ module PgSlice
         added_partitions << partition
 
         if declarative
-          queries << <<-SQL
-CREATE TABLE #{quote_table(partition)} PARTITION OF #{quote_table(table)} FOR VALUES FROM (#{sql_date(day, cast, false)}) TO (#{sql_date(advance_date(day, period, 1), cast, false)})#{tablespace_str};
+          queries << <<~SQL
+            CREATE TABLE #{quote_table(partition)} PARTITION OF #{quote_table(table)} FOR VALUES FROM (#{sql_date(day, cast, false)}) TO (#{sql_date(advance_date(day, period, 1), cast, false)})#{tablespace_str};
           SQL
         else
-          queries << <<-SQL
-CREATE TABLE #{quote_table(partition)}
-    (CHECK (#{quote_ident(field)} >= #{sql_date(day, cast)} AND #{quote_ident(field)} < #{sql_date(advance_date(day, period, 1), cast)}))
-    INHERITS (#{quote_table(table)})#{tablespace_str};
+          queries << <<~SQL
+            CREATE TABLE #{quote_table(partition)}
+                (CHECK (#{quote_ident(field)} >= #{sql_date(day, cast)} AND #{quote_ident(field)} < #{sql_date(advance_date(day, period, 1), cast)}))
+                INHERITS (#{quote_table(table)})#{tablespace_str};
           SQL
         end
 
@@ -115,17 +119,17 @@ CREATE TABLE #{quote_table(partition)}
         trigger_defs = current_defs + future_defs + past_defs.reverse
 
         if trigger_defs.any?
-          queries << <<-SQL
-CREATE OR REPLACE FUNCTION #{quote_ident(trigger_name)}()
-    RETURNS trigger AS $$
-    BEGIN
-        IF #{trigger_defs.join("\n        ELSIF ")}
-        ELSE
-            RAISE EXCEPTION 'Date out of range. Ensure partitions are created.';
-        END IF;
-        RETURN NULL;
-    END;
-    $$ LANGUAGE plpgsql;
+          queries << <<~SQL
+            CREATE OR REPLACE FUNCTION #{quote_ident(trigger_name)}()
+                RETURNS trigger AS $$
+                BEGIN
+                    IF #{trigger_defs.join("\n        ELSIF ")}
+                    ELSE
+                        RAISE EXCEPTION 'Date out of range. Ensure partitions are created.';
+                    END IF;
+                    RETURN NULL;
+                END;
+                $$ LANGUAGE plpgsql;
           SQL
         end
       end

data/lib/pgslice/cli/analyze.rb

@@ -5,8 +5,10 @@ module PgSlice
     def analyze(table)
       table = create_table(table)
       parent_table = options[:swapped] ? table : table.intermediate_table
+      assert_table(parent_table)
 
-      analyze_list = parent_table.partitions + [parent_table]
+      _, _, _, _, declarative, _ = parent_table.fetch_settings(table.trigger_name)
+      analyze_list = declarative ? [parent_table] : (parent_table.partitions + [parent_table])
       run_queries_without_transaction(analyze_list.map { |t| "ANALYZE VERBOSE #{quote_table(t)};" })
     end
   end

data/lib/pgslice/cli/fill.rb

@@ -74,7 +74,7 @@ module PgSlice
       end
 
       while starting_id < max_source_id
-        where = "#{quote_ident(primary_key)} > #{starting_id} AND #{quote_ident(primary_key)} <= #{starting_id + batch_size}"
+        where = "#{quote_ident(primary_key)} > #{quote(starting_id)} AND #{quote_ident(primary_key)} <= #{quote(starting_id + batch_size)}"
         if starting_time
           where << " AND #{quote_ident(field)} >= #{sql_date(starting_time, cast)} AND #{quote_ident(field)} < #{sql_date(ending_time, cast)}"
         end
@@ -82,11 +82,11 @@ module PgSlice
           where << " AND #{options[:where]}"
         end
 
-        query = <<-SQL
-/* #{i} of #{batch_count} */
-INSERT INTO #{quote_table(dest_table)} (#{fields})
-    SELECT #{fields} FROM #{quote_table(source_table)}
-    WHERE #{where}
+        query = <<~SQL
+          /* #{i} of #{batch_count} */
+          INSERT INTO #{quote_table(dest_table)} (#{fields})
+              SELECT #{fields} FROM #{quote_table(source_table)}
+              WHERE #{where}
         SQL
 
         run_query(query)

data/lib/pgslice/cli/prep.rb

@@ -33,15 +33,12 @@ module PgSlice
       declarative = version > 1
 
       if declarative && options[:partition]
-        including = ["DEFAULTS", "CONSTRAINTS", "STORAGE", "COMMENTS", "STATISTICS"]
-        if server_version_num >= 120000
-          including << "GENERATED"
-        end
+        including = ["DEFAULTS", "CONSTRAINTS", "STORAGE", "COMMENTS", "STATISTICS", "GENERATED"]
         if server_version_num >= 140000
           including << "COMPRESSION"
         end
-        queries << <<-SQL
-CREATE TABLE #{quote_table(intermediate_table)} (LIKE #{quote_table(table)} #{including.map { |v| "INCLUDING #{v}" }.join(" ")}) PARTITION BY RANGE (#{quote_ident(column)});
+        queries << <<~SQL
+          CREATE TABLE #{quote_table(intermediate_table)} (LIKE #{quote_table(table)} #{including.map { |v| "INCLUDING #{v}" }.join(" ")}) PARTITION BY RANGE (#{quote_ident(column)});
         SQL
 
         if version == 3
@@ -57,12 +54,12 @@ CREATE TABLE #{quote_table(intermediate_table)} (LIKE #{quote_table(table)} #{in
 
         # add comment
         cast = table.column_cast(column)
-        queries << <<-SQL
-COMMENT ON TABLE #{quote_table(intermediate_table)} IS 'column:#{column},period:#{period},cast:#{cast},version:#{version}';
+        queries << <<~SQL
+          COMMENT ON TABLE #{quote_table(intermediate_table)} IS #{quote("column:#{column},period:#{period},cast:#{cast},version:#{version}")};
         SQL
       else
-        queries << <<-SQL
-CREATE TABLE #{quote_table(intermediate_table)} (LIKE #{quote_table(table)} INCLUDING ALL);
+        queries << <<~SQL
+          CREATE TABLE #{quote_table(intermediate_table)} (LIKE #{quote_table(table)} INCLUDING ALL);
         SQL
 
         table.foreign_keys.each do |fk_def|
@@ -71,24 +68,24 @@ CREATE TABLE #{quote_table(intermediate_table)} (LIKE #{quote_table(table)} INCL
       end
 
       if options[:partition] && !declarative
-        queries << <<-SQL
-CREATE FUNCTION #{quote_ident(trigger_name)}()
-    RETURNS trigger AS $$
-    BEGIN
-        RAISE EXCEPTION 'Create partitions first.';
-    END;
-    $$ LANGUAGE plpgsql;
+        queries << <<~SQL
+          CREATE FUNCTION #{quote_ident(trigger_name)}()
+              RETURNS trigger AS $$
+              BEGIN
+                  RAISE EXCEPTION 'Create partitions first.';
+              END;
+              $$ LANGUAGE plpgsql;
         SQL
 
-        queries << <<-SQL
-CREATE TRIGGER #{quote_ident(trigger_name)}
-    BEFORE INSERT ON #{quote_table(intermediate_table)}
-    FOR EACH ROW EXECUTE PROCEDURE #{quote_ident(trigger_name)}();
+        queries << <<~SQL
+          CREATE TRIGGER #{quote_ident(trigger_name)}
+              BEFORE INSERT ON #{quote_table(intermediate_table)}
+              FOR EACH ROW EXECUTE PROCEDURE #{quote_ident(trigger_name)}();
         SQL
 
         cast = table.column_cast(column)
-        queries << <<-SQL
-COMMENT ON TRIGGER #{quote_ident(trigger_name)} ON #{quote_table(intermediate_table)} IS 'column:#{column},period:#{period},cast:#{cast}';
+        queries << <<~SQL
+          COMMENT ON TRIGGER #{quote_ident(trigger_name)} ON #{quote_table(intermediate_table)} IS #{quote("column:#{column},period:#{period},cast:#{cast}")};
         SQL
       end
 

data/lib/pgslice/cli/swap.rb

@@ -20,7 +20,7 @@ module PgSlice
         queries << "ALTER SEQUENCE #{quote_ident(sequence["sequence_schema"])}.#{quote_ident(sequence["sequence_name"])} OWNED BY #{quote_table(table)}.#{quote_ident(sequence["related_column"])};"
       end
 
-      queries.unshift("SET LOCAL lock_timeout = #{escape_literal(options[:lock_timeout])};")
+      queries.unshift("SET LOCAL lock_timeout = #{quote(options[:lock_timeout])};")
 
       run_queries(queries)
     end

data/lib/pgslice/cli/unprep.rb

@@ -9,9 +9,14 @@ module PgSlice
       assert_table(intermediate_table)
 
       queries = [
-        "DROP TABLE #{quote_table(intermediate_table)} CASCADE;",
-        "DROP FUNCTION IF EXISTS #{quote_ident(trigger_name)}();"
+        "DROP TABLE #{quote_table(intermediate_table)} CASCADE;"
       ]
+
+      _, _, _, _, declarative, _ = intermediate_table.fetch_settings(table.trigger_name)
+      unless declarative
+        queries << "DROP FUNCTION IF EXISTS #{quote_ident(trigger_name)}();"
+      end
+
       run_queries(queries)
     end
   end

data/lib/pgslice/cli.rb

@@ -1,8 +1,10 @@
 module PgSlice
   class CLI < Thor
     class << self
-      attr_accessor :instance
+      attr_accessor :instance, :exit_on_failure
+      alias_method :exit_on_failure?, :exit_on_failure
     end
+    self.exit_on_failure = true
 
     include Helpers
 
@@ -13,10 +15,6 @@ module PgSlice
 
     map %w[--version -v] => :version
 
-    def self.exit_on_failure?
-      ENV["PGSLICE_ENV"] != "test"
-    end
-
     def initialize(*args)
       PgSlice::CLI.instance = self
       $stdout.sync = true

data/lib/pgslice/helpers.rb

@@ -77,7 +77,7 @@ module PgSlice
         begin
           execute(query)
         rescue PG::ServerError => e
-          abort("#{e.class.name}: #{e.message}")
+          abort "#{e.class.name}: #{e.message}"
         end
       end
       log_sql
@@ -102,8 +102,17 @@ module PgSlice
       else
         fmt = "%Y-%m-%d"
       end
-      str = escape_literal(time.strftime(fmt))
-      add_cast ? "#{str}::#{cast}" : str
+      str = quote(time.strftime(fmt))
+      if add_cast
+        case cast
+        when "date", "timestamptz"
+          "#{str}::#{cast}"
+        else
+          abort "Invalid cast"
+        end
+      else
+        str
+      end
     end
 
     def name_format(period)
@@ -157,8 +166,12 @@ module PgSlice
       PG::Connection.quote_ident(value)
     end
 
-    def escape_literal(value)
-      connection.escape_literal(value)
+    def quote(value)
+      if value.is_a?(Numeric)
+        value
+      else
+        connection.escape_literal(value)
+      end
     end
 
     def quote_table(table)

data/lib/pgslice/table.rb

@@ -12,16 +12,24 @@ module PgSlice
     end
 
     def exists?
-      execute("SELECT COUNT(*) FROM pg_catalog.pg_tables WHERE schemaname = $1 AND tablename = $2", [schema, name]).first["count"].to_i > 0
+      query = <<~SQL
+        SELECT COUNT(*) FROM pg_catalog.pg_tables
+        WHERE schemaname = $1 AND tablename = $2
+      SQL
+      execute(query, [schema, name]).first["count"].to_i > 0
     end
 
     def columns
-      execute("SELECT column_name FROM information_schema.columns WHERE table_schema = $1 AND table_name = $2 AND is_generated = 'NEVER'", [schema, name]).map { |r| r["column_name"] }
+      query = <<~SQL
+        SELECT column_name FROM information_schema.columns
+        WHERE table_schema = $1 AND table_name = $2 AND is_generated = 'NEVER'
+      SQL
+      execute(query, [schema, name]).map { |r| r["column_name"] }
     end
 
     # http://www.dbforums.com/showthread.php?1667561-How-to-list-sequences-and-the-columns-by-SQL
     def sequences
-      query = <<-SQL
+      query = <<~SQL
         SELECT
           a.attname AS related_column,
           n.nspname AS sequence_schema,
@@ -41,13 +49,17 @@ module PgSlice
     end
 
     def foreign_keys
-      execute("SELECT pg_get_constraintdef(oid) FROM pg_constraint WHERE conrelid = #{regclass} AND contype ='f'").map { |r| r["pg_get_constraintdef"] }
+      query = <<~SQL
+        SELECT pg_get_constraintdef(oid) FROM pg_constraint
+        WHERE conrelid = $1::regclass AND contype ='f'
+      SQL
+      execute(query, [quote_table]).map { |r| r["pg_get_constraintdef"] }
     end
 
     # https://stackoverflow.com/a/20537829
     # TODO can simplify with array_position in Postgres 9.5+
     def primary_key
-      query = <<-SQL
+      query = <<~SQL
         SELECT
           pg_attribute.attname,
           format_type(pg_attribute.atttypid, pg_attribute.atttypmod),
@@ -69,7 +81,11 @@ module PgSlice
     end
 
     def index_defs
-      execute("SELECT pg_get_indexdef(indexrelid) FROM pg_index WHERE indrelid = #{regclass} AND indisprimary = 'f'").map { |r| r["pg_get_indexdef"] }
+      query = <<~SQL
+        SELECT pg_get_indexdef(indexrelid) FROM pg_index
+        WHERE indrelid = $1::regclass AND indisprimary = 'f'
+      SQL
+      execute(query, [quote_table]).map { |r| r["pg_get_indexdef"] }
     end
 
     def quote_table
@@ -89,17 +105,25 @@ module PgSlice
     end
 
     def column_cast(column)
-      data_type = execute("SELECT data_type FROM information_schema.columns WHERE table_schema = $1 AND table_name = $2 AND column_name = $3", [schema, name, column])[0]["data_type"]
+      query = <<~SQL
+        SELECT data_type FROM information_schema.columns
+        WHERE table_schema = $1 AND table_name = $2 AND column_name = $3
+      SQL
+      data_type = execute(query, [schema, name, column])[0]["data_type"]
       data_type == "timestamp with time zone" ? "timestamptz" : "date"
     end
 
     def max_id(primary_key, below: nil, where: nil)
       query = "SELECT MAX(#{quote_ident(primary_key)}) FROM #{quote_table}"
       conditions = []
-      conditions << "#{quote_ident(primary_key)} <= #{below}" if below
+      params = []
+      if below
+        conditions << "#{quote_ident(primary_key)} <= $1"
+        params << below
+      end
       conditions << where if where
       query << " WHERE #{conditions.join(" AND ")}" if conditions.any?
-      execute(query)[0]["max"].to_i
+      execute(query, params)[0]["max"].to_i
     end
 
     def min_id(primary_key, column, cast, starting_time, where)
@@ -113,15 +137,15 @@ module PgSlice
 
     # ensure this returns partitions in the correct order
     def partitions
-      query = <<-SQL
+      query = <<~SQL
         SELECT
-          nmsp_child.nspname  AS schema,
-          child.relname       AS name
+          nmsp_child.nspname AS schema,
+          child.relname AS name
         FROM pg_inherits
-          JOIN pg_class parent            ON pg_inherits.inhparent = parent.oid
-          JOIN pg_class child             ON pg_inherits.inhrelid   = child.oid
-          JOIN pg_namespace nmsp_parent   ON nmsp_parent.oid  = parent.relnamespace
-          JOIN pg_namespace nmsp_child    ON nmsp_child.oid   = child.relnamespace
+          JOIN pg_class parent ON pg_inherits.inhparent = parent.oid
+          JOIN pg_class child ON pg_inherits.inhrelid = child.oid
+          JOIN pg_namespace nmsp_parent ON nmsp_parent.oid = parent.relnamespace
+          JOIN pg_namespace nmsp_child ON nmsp_child.oid = child.relnamespace
         WHERE
           nmsp_parent.nspname = $1 AND
           parent.relname = $2
@@ -131,14 +155,17 @@ module PgSlice
     end
 
     def fetch_comment
-      execute("SELECT obj_description(#{regclass}) AS comment")[0]
+      execute("SELECT obj_description($1::regclass) AS comment", [quote_table])[0]
     end
 
     def fetch_trigger(trigger_name)
-      execute("SELECT obj_description(oid, 'pg_trigger') AS comment FROM pg_trigger WHERE tgname = $1 AND tgrelid = #{regclass}", [trigger_name])[0]
+      query = <<~SQL
+        SELECT obj_description(oid, 'pg_trigger') AS comment FROM pg_trigger
+        WHERE tgname = $1 AND tgrelid = $2::regclass
+      SQL
+      execute(query, [trigger_name, quote_table])[0]
     end
 
-    # legacy
     def fetch_settings(trigger_name)
       needs_comment = false
       trigger_comment = fetch_trigger(trigger_name)
@@ -166,6 +193,10 @@ module PgSlice
         needs_comment = true
       end
 
+      unless ["date", "timestamptz"].include?(cast)
+        abort "Invalid cast"
+      end
+
       version ||= trigger_comment ? 1 : 2
       declarative = version > 1
 
@@ -174,30 +205,24 @@ module PgSlice
 
     protected
 
+    def abort(message)
+      PgSlice::CLI.instance.send(:abort, message)
+    end
+
     def execute(*args)
       PgSlice::CLI.instance.send(:execute, *args)
     end
 
-    def escape_literal(value)
-      PgSlice::CLI.instance.send(:escape_literal, value)
+    def quote(value)
+      PgSlice::CLI.instance.send(:quote, value)
     end
 
     def quote_ident(value)
-      PG::Connection.quote_ident(value)
+      PgSlice::CLI.instance.send(:quote_ident, value)
     end
 
-    def regclass
-      "#{escape_literal(quote_table)}::regclass"
-    end
-
-    def sql_date(time, cast, add_cast = true)
-      if cast == "timestamptz"
-        fmt = "%Y-%m-%d %H:%M:%S UTC"
-      else
-        fmt = "%Y-%m-%d"
-      end
-      str = escape_literal(time.strftime(fmt))
-      add_cast ? "#{str}::#{cast}" : str
+    def sql_date(*args)
+      PgSlice::CLI.instance.send(:sql_date, *args)
     end
   end
 end

data/lib/pgslice/version.rb

@@ -1,3 +1,3 @@
 module PgSlice
-  VERSION = "0.7.0"
+  VERSION = "0.7.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pgslice
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.2
 platform: ruby
 authors:
 - Andrew Kane
@@ -9,6 +9,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: cgi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -77,7 +91,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Postgres partitioning as easy as pie
 test_files: []