@prostgles/prostgles 2.3.6-dev.1786548258

package/client/src/dashboard/SQLEditor/SQLCompletion/MatchSet.ts

@@ -0,0 +1,183 @@
+import { omitKeys } from "prostgles-types";
+import { asListObject } from "../SQLEditorSuggestions";
+import { suggestSnippets } from "./CommonMatchImports";
+import { getExpected } from "./getExpected";
+import {
+  getKind,
+  KNDS as KindMap,
+  type SQLMatcher,
+} from "./monacoSQLSetup/registerSuggestions";
+import type { KWD } from "./withKWDs";
+import { suggestKWD, withKWDs } from "./withKWDs";
+import type { SQLHandler } from "prostgles-types";
+
+export const MatchSet: SQLMatcher = {
+  match: ({ ftoken }) =>
+    ftoken?.textLC === "set" ||
+    ftoken?.textLC === "show" ||
+    ftoken?.textLC === "reset",
+  result: async (args) => {
+    const { cb, ss, setS: settingSuggestions, sql } = args;
+    const { ltoken } = cb;
+    const _suggestKWD = (vals: string[], sortText?: string) =>
+      suggestKWD(getKind, vals, sortText);
+
+    if (cb.ftoken?.textLC === "reset") {
+      return withKWDs(
+        [
+          {
+            kwd: "RESET",
+            options: [
+              {
+                label: "ALL",
+                docs: "Resets all parameters to their default values",
+              },
+              ...settingSuggestions,
+            ],
+          },
+        ],
+        { cb, ss, setS: settingSuggestions, sql },
+      ).getSuggestion();
+    }
+
+    if (cb.prevLC.startsWith("set session authorization")) {
+      return {
+        suggestions: getExpected("user", cb, ss).suggestions.concat(
+          _suggestKWD(["DEFAULT"]).suggestions,
+        ),
+      };
+    }
+
+    if (ltoken?.textLC === "to") {
+      if (cb.l1token?.textLC === "search_path") {
+        return getExpected("schema", cb, ss);
+      }
+
+      if (["timezone", "time zone"].some((v) => cb.prevLC.includes(v)) && sql) {
+        const timeZones = await getTimeZones(sql);
+        return suggestSnippets(
+          timeZones.map((t) => ({
+            label: t.name,
+            insertText: `'${t.name}'`,
+            docs: asListObject(t),
+            kind: getKind("keyword"),
+          })),
+        );
+      }
+
+      const settingInfo = settingSuggestions.find(
+        (s) => s.name === cb.identifiers.at(-1)?.text,
+      )?.settingInfo;
+      const docs = settingInfo?.description;
+      const getVal = (v = "") =>
+        settingInfo?.unit ? `'${v}${settingInfo.unit}'` : v;
+      const valueSuggestions = suggestSnippets([
+        { label: "DEFAULT", docs },
+        ...(settingInfo?.vartype === "bool" ?
+          [
+            { label: `ON`, docs },
+            { label: `OFF`, docs },
+          ]
+        : settingInfo?.vartype === "string" ?
+          [{ label: "'$setting_string_value'", docs }]
+        : settingInfo?.vartype === "integer" ?
+          [
+            {
+              label:
+                settingInfo.setting_pretty?.min_val ??
+                getVal(settingInfo.min_val),
+              kind: KindMap.Value,
+              docs: "Minimum value" + `\n\n${docs}`,
+            },
+            {
+              label:
+                settingInfo.setting_pretty?.max_val ??
+                getVal(settingInfo.max_val),
+              kind: KindMap.Value,
+              docs: "Maximum value" + `\n\n${docs}`,
+            },
+          ]
+        : settingInfo?.enumvals?.length ?
+          settingInfo.enumvals.map((label) => {
+            const isDefault = settingInfo.reset_val === label;
+            return {
+              label: { label, description: isDefault ? "DEFAULT" : undefined },
+              docs,
+            };
+          })
+        : []),
+      ]);
+
+      return valueSuggestions;
+    }
+    const extraSettings = [
+      {
+        label: "SESSION",
+        expects: "setting",
+        docs: `Specifies that the command takes effect for the current session. (This is the default if neither SESSION nor LOCAL appears.)`,
+      },
+      {
+        label: "SESSION AUTHORIZATION",
+        role: "user",
+        docs: "Set the session user identifier and the current user identifier of the current session",
+      },
+      {
+        label: "LOCAL",
+        docs: `Specifies that the command takes effect for only the current transaction. After COMMIT or ROLLBACK, the session-level setting takes effect again. Issuing this outside of a transaction block emits a warning and otherwise has no effect.`,
+      },
+      { label: "ALL" },
+      {
+        label: "SCHEMA",
+        options: (ss) =>
+          ss
+            .filter((s) => s.type === "schema")
+            .map((s) => ({ ...s, insertText: `'${s.name}'` })),
+        docs: `SET SCHEMA 'value' is an alias for SET search_path TO value. Only one schema can be specified using this syntax.`,
+      },
+      {
+        label: "SEED",
+        options: ["-1", "1"],
+        docs: `Sets the internal seed for the random number generator (the function random). Allowed values are floating-point numbers between -1 and 1 inclusive. The seed can also be set by invoking the function setseed`,
+      },
+      {
+        label: "TIME ZONE",
+        docs: `SET TIME ZONE 'value' is an alias for SET timezone TO 'value'. The syntax SET TIME ZONE allows special syntax for the time zone specification. Here are examples of valid values: 'PST8PDT', 'Europe/Rome', -7, INTERVAL '-08:00' HOUR TO MINUTE`,
+      },
+    ] as const;
+    return withKWDs(
+      [
+        { kwd: "SHOW", options: settingSuggestions },
+        {
+          kwd: "SET",
+          options: [...extraSettings, ...settingSuggestions].map((o) => ({
+            ...o,
+            kind: getKind("setting"),
+          })),
+        },
+        { kwd: "TO", dependsOn: "SET" },
+        ...extraSettings.map((d) => ({
+          kwd: d.label,
+          dependsOn: d.label,
+          ...omitKeys(d, ["label"]),
+        })),
+      ] satisfies KWD[],
+      { cb, ss, setS: settingSuggestions, sql },
+    ).getSuggestion();
+  },
+};
+
+const getTimeZones = async (sql: SQLHandler) => {
+  return (await sql(
+    `
+    SELECT *
+    FROM pg_catalog.pg_timezone_names
+  `,
+    {},
+    { returnType: "rows" },
+  )) as {
+    name: string;
+    abbrev: string;
+    utc_offset: string;
+    is_dst: boolean;
+  }[];
+};

package/client/src/dashboard/SQLEditor/SQLCompletion/MatchSubscription.ts

@@ -0,0 +1,231 @@
+import { getParentFunction } from "./MatchSelect";
+import { getExpected } from "./getExpected";
+import type { SQLMatcher } from "./monacoSQLSetup/registerSuggestions";
+import type { KWD } from "./withKWDs";
+import { withKWDs } from "./withKWDs";
+
+export const MatchSubscription: SQLMatcher = {
+  match: (cb) => cb.tokens[1]?.textLC === "subscription",
+  result: async ({ cb, ss, setS, sql }) => {
+    const command = cb.ftoken?.textLC;
+    const newSubscriptionName =
+      command === "create" &&
+      cb.tokens[1]?.textLC === "subscription" &&
+      cb.tokens[2];
+
+    const isInfunc = getParentFunction(cb);
+    if (isInfunc?.func.textLC === "with") {
+      return withKWDs(
+        Object.entries(withOptions).map(([kwd, { docs, options }]) => ({
+          kwd,
+          docs,
+          options,
+        })),
+        { cb, ss, setS, sql },
+      ).getSuggestion(",", ["(", ")"]);
+    }
+
+    if (newSubscriptionName) {
+      return withKWDs(
+        [
+          {
+            kwd: "CONNECTION",
+            docs: `The libpq connection string defining how to connect to the publisher database`,
+            options: [
+              "'host=192.168.1.50 port=5432 user=foo dbname=foodb password=mypassword'",
+            ],
+          },
+          {
+            kwd: "PUBLICATION",
+            docs: `Names of the publications on the publisher to subscribe to.`,
+            options: ["$publication_name"],
+          },
+          {
+            kwd: "WITH",
+            optional: true,
+            docs: `Optional parameters for a subscription`,
+          },
+        ] satisfies KWD[],
+        { cb, ss, setS, sql },
+      ).getSuggestion();
+    }
+
+    if (cb.prevLC.endsWith("if exists")) {
+      return getExpected("subscription", cb, ss);
+    }
+
+    return withKWDs(
+      [
+        {
+          kwd: "SUBSCRIPTION",
+          expects: command === "create" ? undefined : "subscription",
+          excludeIf: (cb) => cb.l1token?.textLC === "subscription",
+          options:
+            command === "drop" ? [{ label: "IF EXISTS" }]
+            : command === "create" ? [{ label: "$new_subscription_name" }]
+            : undefined,
+          docs: "Adds a new logical-replication subscription. The user that creates a subscription becomes the owner of the subscription. The subscription name must be distinct from the name of any existing subscription in the current database.",
+        },
+      ] satisfies KWD[],
+      { cb, ss, setS, sql },
+    ).getSuggestion();
+  },
+};
+
+const options = {
+  "FOR TABLE": {
+    docs: `Specifies a list of tables to add to the publication. If ONLY is specified before the table name, only that table is added to the publication. If ONLY is not specified, the table and all its descendant tables (if any) are added. Optionally, * can be specified after the table name to explicitly indicate that descendant tables are included. This does not apply to a partitioned table, however. The partitions of a partitioned table are always implicitly considered part of the publication, so they are never explicitly added to the publication.
+
+If the optional WHERE clause is specified, it defines a row filter expression. Rows for which the expression evaluates to false or null will not be published. Note that parentheses are required around the expression. It has no effect on TRUNCATE commands.
+
+When a column list is specified, only the named columns are replicated. If no column list is specified, all columns of the table are replicated through this publication, including any columns added later. It has no effect on TRUNCATE commands. See Section 31.4 for details about column lists.
+
+Only persistent base tables and partitioned tables can be part of a publication. Temporary tables, unlogged tables, foreign tables, materialized views, and regular views cannot be part of a publication.
+
+Specifying a column list when the publication also publishes FOR TABLES IN SCHEMA is not supported.
+
+When a partitioned table is added to a publication, all of its existing and future partitions are implicitly considered to be part of the publication. So, even operations that are performed directly on a partition are also published via publications that its ancestors are part of.`,
+    expects: "table",
+  },
+  "FOR ALL TABLES": {
+    docs: `Marks the publication as one that replicates changes for all tables in the database, including tables created in the future.`,
+    expects: undefined,
+  },
+  "FOR TABLES IN SCHEMA": {
+    docs: `Marks the publication as one that replicates changes for all tables in the specified list of schemas, including tables created in the future.
+
+Specifying a schema when the publication also publishes a table with a column list is not supported.
+
+Only persistent base tables and partitioned tables present in the schema will be included as part of the publication. Temporary tables, unlogged tables, foreign tables, materialized views, and regular views from the schema will not be part of the publication.
+
+When a partitioned table is published via schema level publication, all of its existing and future partitions are implicitly considered to be part of the publication, regardless of whether they are from the publication schema or not. So, even operations that are performed directly on a partition are also published via publications that its ancestors are part of.`,
+    expects: "schema",
+  },
+  WITH: {
+    docs: `This clause specifies optional parameters for a subscription`,
+    expects: undefined,
+  },
+} as const;
+
+const withOptions = {
+  connect: {
+    options: ["=true", "=false"],
+    docs: `(boolean) 
+Specifies whether the CREATE SUBSCRIPTION command should connect to the publisher at all. The default is true. Setting this to false will force the values of create_slot, enabled and copy_data to false. (You cannot combine setting connect to false with setting create_slot, enabled, or copy_data to true.)
+
+Since no connection is made when this option is false, no tables are subscribed. To initiate replication, you must manually create the replication slot, enable the subscription, and refresh the subscription. See Section 31.2.3 for examples. 
+`,
+  },
+  create_slot: {
+    options: ["=true", "=false"],
+    docs: ` (boolean) 
+Specifies whether the command should create the replication slot on the publisher. The default is true.
+
+If set to false, you are responsible for creating the publisher's slot in some other way. See Section 31.2.3 for examples.
+
+`,
+  },
+  enabled: {
+    options: ["=true", "=false"],
+    docs: ` (boolean) 
+Specifies whether the subscription should be actively replicating or whether it should just be set up but not started yet. The default is true.
+
+`,
+  },
+  slot_name: {
+    options: ["$slot_name"],
+    docs: ` (string) 
+Name of the publisher's replication slot to use. The default is to use the name of the subscription for the slot name.
+
+Setting slot_name to NONE means there will be no replication slot associated with the subscription. Such subscriptions must also have both enabled and create_slot set to false. Use this when you will be creating the replication slot later manually. See Section 31.2.3 for examples.
+
+The following parameters control the subscription's replication behavior after it has been created:
+
+`,
+  },
+  binary: {
+    options: ["=true", "=false"],
+    docs: ` (boolean) 
+Specifies whether the subscription will request the publisher to send the data in binary format (as opposed to text). The default is false. Any initial table synchronization copy (see copy_data) also uses the same format. Binary format can be faster than the text format, but it is less portable across machine architectures and PostgreSQL versions. Binary format is very data type specific; for example, it will not allow copying from a smallint column to an integer column, even though that would work fine in text format. Even when this option is enabled, only data types having binary send and receive functions will be transferred in binary. Note that the initial synchronization requires all data types to have binary send and receive functions, otherwise the synchronization will fail (see CREATE TYPE for more about send/receive functions).
+
+When doing cross-version replication, it could be that the publisher has a binary send function for some data type, but the subscriber lacks a binary receive function for that type. In such a case, data transfer will fail, and the binary option cannot be used.
+
+If the publisher is a PostgreSQL version before 16, then any initial table synchronization will use text format even if binary = true.
+
+`,
+  },
+  copy_data: {
+    options: ["=true", "=false"],
+    docs: ` (boolean) 
+Specifies whether to copy pre-existing data in the publications that are being subscribed to when the replication starts. The default is true.
+
+If the publications contain WHERE clauses, it will affect what data is copied. Refer to the Notes for details.
+
+See Notes for details of how copy_data = true can interact with the origin parameter.
+
+`,
+  },
+  streaming: {
+    options: ["=true", "=false"],
+    docs: ` (enum) 
+Specifies whether to enable streaming of in-progress transactions for this subscription. The default value is off, meaning all transactions are fully decoded on the publisher and only then sent to the subscriber as a whole.
+
+If set to on, the incoming changes are written to temporary files and then applied only after the transaction is committed on the publisher and received by the subscriber.
+
+If set to parallel, incoming changes are directly applied via one of the parallel apply workers, if available. If no parallel apply worker is free to handle streaming transactions then the changes are written to temporary files and applied after the transaction is committed. Note that if an error happens in a parallel apply worker, the finish LSN of the remote transaction might not be reported in the server log.
+
+`,
+  },
+  synchronous_commit: {
+    options: ["=off", "=on"],
+    docs: ` (enum) 
+The value of this parameter overrides the synchronous_commit setting within this subscription's apply worker processes. The default value is off.
+
+It is safe to use off for logical replication: If the subscriber loses transactions because of missing synchronization, the data will be sent again from the publisher.
+
+A different setting might be appropriate when doing synchronous logical replication. The logical replication workers report the positions of writes and flushes to the publisher, and when using synchronous replication, the publisher will wait for the actual flush. This means that setting synchronous_commit for the subscriber to off when the subscription is used for synchronous replication might increase the latency for COMMIT on the publisher. In this scenario, it can be advantageous to set synchronous_commit to local or higher.
+
+`,
+  },
+  two_phase: {
+    options: ["=true", "=false"],
+    docs: ` (boolean) 
+Specifies whether two-phase commit is enabled for this subscription. The default is false.
+
+When two-phase commit is enabled, prepared transactions are sent to the subscriber at the time of PREPARE TRANSACTION, and are processed as two-phase transactions on the subscriber too. Otherwise, prepared transactions are sent to the subscriber only when committed, and are then processed immediately by the subscriber.
+
+The implementation of two-phase commit requires that replication has successfully finished the initial table synchronization phase. So even when two_phase is enabled for a subscription, the internal two-phase state remains temporarily “pending” until the initialization phase completes. See column subtwophasestate of pg_subscription to know the actual two-phase state.
+
+`,
+  },
+  disable_on_error: {
+    options: ["=true", "=false"],
+    docs: ` (boolean) 
+Specifies whether the subscription should be automatically disabled if any errors are detected by subscription workers during data replication from the publisher. The default is false.
+
+`,
+  },
+  password_required: {
+    options: ["=true", "=false"],
+    docs: ` (boolean) 
+Specifies whether connections to the publisher made as a result of this subscription must use password authentication. This setting is ignored when the subscription is owned by a superuser. The default is true. Only superusers can set this value to false.
+
+`,
+  },
+  run_as_owner: {
+    options: ["=true", "=false"],
+    docs: ` (boolean) 
+If true, all replication actions are performed as the subscription owner. If false, replication workers will perform actions on each table as the owner of that table. The latter configuration is generally much more secure; for details, see Section 31.9. The default is false.
+
+`,
+  },
+  origin: {
+    options: ["=true", "=false"],
+    docs: ` (string) 
+Specifies whether the subscription will request the publisher to only send changes that don't have an origin or send changes regardless of origin. Setting origin to none means that the subscription will request the publisher to only send changes that don't have an origin. Setting origin to any means that the publisher sends changes regardless of their origin. The default is any.
+
+See Notes for details of how copy_data = true can interact with the origin parameter.
+
+`,
+  },
+} as const;

package/client/src/dashboard/SQLEditor/SQLCompletion/MatchUpdate.ts

@@ -0,0 +1,79 @@
+import { suggestSnippets } from "./CommonMatchImports";
+import { getExpected } from "./getExpected";
+import type { SQLMatcher } from "./monacoSQLSetup/registerSuggestions";
+import { suggestColumnLike } from "./suggestColumnLike";
+import { suggestCondition } from "./suggestCondition";
+import { type KWD, withKWDs, suggestKWD } from "./withKWDs";
+
+const KWDs = [
+  { kwd: "UPDATE", expects: "table" },
+  { kwd: "SET", expects: "column", justAfter: ["UPDATE"] },
+  { kwd: ",", expects: "column", canRepeat: true },
+  { kwd: "FROM", optional: true, expects: "table" },
+  { kwd: "WHERE", expects: "condition" },
+  { kwd: "RETURNING", expects: "column" },
+] as const satisfies KWD[];
+
+export const MatchUpdate: SQLMatcher = {
+  match: ({ prevTopKWDs }) => {
+    return prevTopKWDs.slice(0, 2).some((t) => ["UPDATE"].includes(t.text));
+  },
+  result: async (args) => {
+    const { cb, ss } = args;
+    const { prevTokens, ltoken } = cb;
+    const kwds = withKWDs(KWDs, args);
+
+    const isSettingColumns =
+      !cb.currNestingId && cb.prevTopKWDs[0]?.textLC === "set";
+    if (
+      isSettingColumns &&
+      cb.ltoken?.type.startsWith("identifier") &&
+      [",", "set"].includes(cb.l1token?.textLC ?? "")
+    ) {
+      return suggestSnippets([
+        {
+          label: "=",
+        },
+      ]);
+    }
+
+    if (
+      isSettingColumns &&
+      !cb.thisLinePrevTokens.length &&
+      ![",", "set"].includes(cb.ltoken?.textLC ?? "")
+    ) {
+      return withKWDs(KWDs.slice(3), args).getSuggestion();
+    }
+
+    if (prevTokens.length === 1) {
+      return {
+        suggestions: getExpected("table", cb, ss).suggestions.map((s) => ({
+          ...s,
+          label: `${s.name}...`,
+          insertText: s.insertText + `\nSET`,
+        })),
+      };
+    }
+
+    if (ltoken?.text === ",") {
+      const cols = getExpected("column", cb, ss);
+      return {
+        // space added after = to prevent bad suggestions (next kwd) showing up
+        suggestions: cols.suggestions.map((c) => ({
+          ...c,
+          insertText: `${c.insertText} = `,
+        })),
+      };
+    }
+    if (ltoken?.text === "=" || kwds.prevKWD?.expects === "column") {
+      return suggestColumnLike(args);
+    }
+
+    if (kwds.prevKWD?.expects === "condition") {
+      const cond = await suggestCondition(args, true);
+      if (cond) return cond;
+    }
+
+    return kwds.getSuggestion();
+  },
+};

package/client/src/dashboard/SQLEditor/SQLCompletion/MatchVacuum.ts

@@ -0,0 +1,86 @@
+import { getParentFunction } from "./MatchSelect";
+import { getExpected } from "./getExpected";
+import type { SQLMatcher } from "./monacoSQLSetup/registerSuggestions";
+import { getKind } from "./monacoSQLSetup/registerSuggestions";
+import type { KWD } from "./withKWDs";
+import { withKWDs } from "./withKWDs";
+import { pickKeys } from "prostgles-types";
+
+export const MatchVacuumOrAnalyze: SQLMatcher = {
+  match: (cb) => ["vacuum", "analyze"].includes(cb.ftoken?.textLC ?? ""),
+  result: async ({ cb, ss, setS, sql }) => {
+    const command = cb.ftoken?.textLC ?? "vacuum";
+    const func = getParentFunction(cb);
+    if (func?.func.textLC === command) {
+      return withKWDs(
+        Object.entries(options).map(([kwd, docs]) => ({ kwd, docs })),
+        { cb, ss, setS, sql, opts: { notOrdered: true } },
+      ).getSuggestion(",", ["(", ")"]);
+    }
+
+    if (cb.ltoken?.textLC === ")") {
+      return getExpected("table", cb, ss);
+    }
+
+    return withKWDs(
+      command === "analyze" ?
+        [
+          {
+            kwd: "ANALYZE",
+            expects: ["table"],
+            options: [
+              {
+                label: "(options...)",
+                insertText: "($0)",
+                docs: Object.keys(
+                  pickKeys(options, [
+                    "VERBOSE",
+                    "SKIP_LOCKED",
+                    "BUFFER_USAGE_LIMIT",
+                  ]),
+                ).join("\n\n"),
+                kind: getKind("snippet"),
+              },
+            ],
+          },
+        ]
+      : ([
+          {
+            kwd: "VACUUM",
+            expects: ["table"],
+            options: [
+              {
+                label: "(options...)",
+                insertText: "($0)",
+                docs: Object.keys(options).join("\n\n"),
+                kind: getKind("snippet"),
+              },
+            ],
+          },
+          {
+            kwd: "VACUUM FULL",
+            expects: ["table"],
+            excludeIf: ["VACUUM"],
+          },
+        ] satisfies KWD[]),
+      { cb, ss, setS, sql },
+    ).getSuggestion();
+  },
+};
+
+const options = {
+  FULL: `Selects “full” vacuum, which can reclaim more space, but takes much longer and exclusively locks the table. This method also requires extra disk space, since it writes a new copy of the table and doesn't release the old copy until the operation is complete. Usually this should only be used when a significant amount of space needs to be reclaimed from within the table.`,
+  FREEZE: `Selects aggressive “freezing” of tuples. Specifying FREEZE is equivalent to performing VACUUM with the vacuum_freeze_min_age and vacuum_freeze_table_age parameters set to zero. Aggressive freezing is always performed when the table is rewritten, so this option is redundant when FULL is specified.`,
+  VERBOSE: `Prints a detailed vacuum activity report for each table.`,
+  ANALYZE: `Updates statistics used by the planner to determine the most efficient way to execute a query.`,
+  DISABLE_PAGE_SKIPPING: `Normally, VACUUM will skip pages based on the visibility map. Pages where all tuples are known to be frozen can always be skipped, and those where all tuples are known to be visible to all transactions may be skipped except when performing an aggressive vacuum. Furthermore, except when performing an aggressive vacuum, some pages may be skipped in order to avoid waiting for other sessions to finish using them. This option disables all page-skipping behavior, and is intended to be used only when the contents of the visibility map are suspect, which should happen only if there is a hardware or software issue causing database corruption.`,
+  SKIP_LOCKED: `Specifies that VACUUM should not wait for any conflicting locks to be released when beginning work on a relation: if a relation cannot be locked immediately without waiting, the relation is skipped. Note that even with this option, VACUUM may still block when opening the relation's indexes. Additionally, VACUUM ANALYZE may still block when acquiring sample rows from partitions, table inheritance children, and some types of foreign tables. Also, while VACUUM ordinarily processes all partitions of specified partitioned tables, this option will cause VACUUM to skip all partitions if there is a conflicting lock on the partitioned table.`,
+  INDEX_CLEANUP: `Normally, VACUUM will skip index vacuuming when there are very few dead tuples in the table. The cost of processing all of the table's indexes is expected to greatly exceed the benefit of removing dead index tuples when this happens. This option can be used to force VACUUM to process indexes when there are more than zero dead tuples. The default is AUTO, which allows VACUUM to skip index vacuuming when appropriate. If INDEX_CLEANUP is set to ON, VACUUM will conservatively remove all dead tuples from indexes. This may be useful for backwards compatibility with earlier releases of PostgreSQL where this was the standard behavior.\nINDEX_CLEANUP can also be set to OFF to force VACUUM to always skip index vacuuming, even when there are many dead tuples in the table. This may be useful when it is necessary to make VACUUM run as quickly as possible to avoid imminent transaction ID wraparound (see Section 25.1.5). However, the wraparound failsafe mechanism controlled by vacuum_failsafe_age will generally trigger automatically to avoid transaction ID wraparound failure, and should be preferred. If index cleanup is not performed regularly, performance may suffer, because as the table is modified indexes will accumulate dead tuples and the table itself will accumulate dead line pointers that cannot be removed until index cleanup is completed.\nThis option has no effect for tables that have no index and is ignored if the FULL option is used. It also has no effect on the transaction ID wraparound failsafe mechanism. When triggered it will skip index vacuuming, even when INDEX_CLEANUP is set to ON.`,
+  PROCESS_MAIN: `Specifies that VACUUM should attempt to process the main relation. This is usually the desired behavior and is the default. Setting this option to false may be useful when it is only necessary to vacuum a relation's corresponding TOAST table.`,
+  PROCESS_TOAST: `Specifies that VACUUM should attempt to process the corresponding TOAST table for each relation, if one exists. This is usually the desired behavior and is the default. Setting this option to false may be useful when it is only necessary to vacuum the main relation. This option is required when the FULL option is used.`,
+  TRUNCATE: `Specifies that VACUUM should attempt to truncate off any empty pages at the end of the table and allow the disk space for the truncated pages to be returned to the operating system. This is normally the desired behavior and is the default unless the vacuum_truncate option has been set to false for the table to be vacuumed. Setting this option to false may be useful to avoid ACCESS EXCLUSIVE lock on the table that the truncation requires. This option is ignored if the FULL option is used.`,
+  PARALLEL: `Perform index vacuum and index cleanup phases of VACUUM in parallel using integer background workers (for the details of each vacuum phase, please refer to Table 28.45). The number of workers used to perform the operation is equal to the number of indexes on the relation that support parallel vacuum which is limited by the number of workers specified with PARALLEL option if any which is further limited by max_parallel_maintenance_workers. An index can participate in parallel vacuum if and only if the size of the index is more than min_parallel_index_scan_size. Please note that it is not guaranteed that the number of parallel workers specified in integer will be used during execution. It is possible for a vacuum to run with fewer workers than specified, or even with no workers at all. Only one worker can be used per index. So parallel workers are launched only when there are at least 2 indexes in the table. Workers for vacuum are launched before the start of each phase and exit at the end of the phase. These behaviors might change in a future release. This option can't be used with the FULL option.`,
+  SKIP_DATABASE_STATS: `Specifies that VACUUM should skip updating the database-wide statistics about oldest unfrozen XIDs. Normally VACUUM will update these statistics once at the end of the command. However, this can take awhile in a database with a very large number of tables, and it will accomplish nothing unless the table that had contained the oldest unfrozen XID was among those vacuumed. Moreover, if multiple VACUUM commands are issued in parallel, only one of them can update the database-wide statistics at a time. Therefore, if an application intends to issue a series of many VACUUM commands, it can be helpful to set this option in all but the last such command; or set it in all the commands and separately issue VACUUM (ONLY_DATABASE_STATS) afterwards.`,
+  ONLY_DATABASE_STATS: `Specifies that VACUUM should do nothing except update the database-wide statistics about oldest unfrozen XIDs. When this option is specified, the table_and_columns list must be empty, and no other option may be enabled except VERBOSE.`,
+  BUFFER_USAGE_LIMIT: `Specifies the Buffer Access Strategy ring buffer size for VACUUM. This size is used to calculate the number of shared buffers which will be reused as part of this strategy. 0 disables use of a Buffer Access Strategy. If ANALYZE is also specified, the BUFFER_USAGE_LIMIT value is used for both the vacuum and analyze stages. This option can't be used with the FULL option except if ANALYZE is also specified. When this option is not specified, VACUUM uses the value from vacuum_buffer_usage_limit. Higher settings can allow VACUUM to run more quickly, but having too large a setting may cause too many other useful pages to be evicted from shared buffers. The minimum value is 128 kB and the maximum value is 16 GB.`,
+};