okmodel 0.2.1 → 0.4.0

package/dist/contracts/catalog/document.d.ts

@@ -35,8 +35,12 @@ export declare function renameColumn(source: Catalog, change: {
 /**
  * Renames a table without renaming its constraints or indexes.
  *
- * Column, index, and constraint parents move to the new name. Expression text
- * that names the table is rewritten. Constraint and index names stay.
+ * Column, index, constraint, and trigger parents move to the new name, and
+ * edges that pointed at those objects move with them. Expression text that
+ * names the table is rewritten. Constraint and index names stay. A grant on
+ * the table, or on an identity sequence named `{table}_{column}_seq`, follows
+ * the name the schema will use. The planner emits the `RENAME` for a default
+ * name; a custom name is left as it is.
  *
  * @param source - Catalog document
  * @param change - Namespace, current table name, and the new name

package/dist/contracts/catalog/enum.d.ts

@@ -1,10 +1,10 @@
 /**
- * Enum catalog objects.
+ * Enum and domain catalog objects.
  *
- * Kind `type`, identity `(namespace, name)`. The definition is the ordered
- * label list and nothing else: domains are not catalog objects.
+ * Kind `type`, identity `(namespace, name)`. An enum definition is the ordered
+ * label list. A domain definition is the base type and the check.
  */
-import type { Namespace, ObjectIdentity, Owner, Provenance, TypeObject } from "./types.js";
+import type { DomainDefinition, Namespace, ObjectIdentity, Owner, Provenance, TypeDefinition, TypeObject } from "./types.js";
 /** Input for {@link enumType}. */
 export type EnumTypeInput = {
     readonly namespace: Namespace;
@@ -25,6 +25,33 @@ export type EnumTypeInput = {
  * @returns A type envelope
  */
 export declare function enumType(input: EnumTypeInput): TypeObject;
+/** Input for {@link domainType}. */
+export type DomainTypeInput = {
+    readonly namespace: Namespace;
+    readonly name: string;
+    readonly base: string;
+    readonly check: string;
+    readonly owner?: Owner;
+    readonly provenance: Provenance;
+    readonly dependencies?: readonly ObjectIdentity[];
+};
+/**
+ * Builds a domain type object.
+ *
+ * The definition is the base type and the check. An empty base or an empty
+ * check is OKM1020.
+ *
+ * @param input - Namespace, name, base type, and check
+ * @returns A type envelope
+ */
+export declare function domainType(input: DomainTypeInput): TypeObject;
+/**
+ * Reports whether a type definition is a domain.
+ *
+ * @param definition - Enum labels or a domain base and check
+ * @returns `true` when the definition has a base type
+ */
+export declare function isDomain(definition: TypeDefinition): definition is DomainDefinition;
 /**
  * Reports whether two label lists are the same text in the same order.
  *

package/dist/contracts/catalog/extension.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Extension catalog objects.
+ *
+ * The factory stores the record. It does not parse a document and it does
+ * not plan SQL. Those stay in the document chunk and in tooling.
+ */
+import type { Catalog, ExtensionObject, ObjectIdentity, Owner, Provenance } from "./types.js";
+/** Input for {@link extensionObject}. */
+export type ExtensionInput = {
+    readonly name: string;
+    readonly schema: string;
+    readonly relocatable?: boolean;
+    readonly version?: string;
+    readonly owner?: Owner;
+    readonly provenance: Provenance;
+    readonly dependencies?: readonly ObjectIdentity[];
+};
+/**
+ * Builds an extension record.
+ *
+ * @param input - Name, install schema, and optional version pin
+ * @returns The catalog object
+ */
+export declare function extensionObject(input: ExtensionInput): ExtensionObject;
+/**
+ * Reports whether a version is an exact pin (`1.6`), not a floor or an omission.
+ *
+ * @param version - Declared or installed version
+ * @returns `true` when every component is a decimal integer
+ */
+export declare function isExactVersion(version: string | undefined): version is string;
+/**
+ * Compares two exact versions. A shorter tail is zero.
+ *
+ * @param left - Exact version
+ * @param right - Exact version
+ * @returns Negative when `left` is older, positive when it is newer
+ */
+export declare function compareExtensionVersions(left: string, right: string): number;
+/**
+ * Reports whether two extension records are the same migration.
+ *
+ * An unpinned or floor declaration matches any installed version. Schema and
+ * `relocatable` still have to match.
+ *
+ * @param before - Previous record
+ * @param after - Declared record
+ * @returns `true` when no `ALTER EXTENSION` is required
+ */
+export declare function sameExtensionDefinition(before: ExtensionObject, after: ExtensionObject): boolean;
+/**
+ * Drops a version when the other side of a diff does not pin an exact one.
+ *
+ * Serialization then compares the rest of the record. Exact pins on both
+ * sides are left as written.
+ *
+ * @param source - Catalog being compared
+ * @param other - The other catalog
+ * @returns `source`, or a copy with those versions removed
+ */
+export declare function alignExtensionVersions(source: Catalog, other: Catalog): Catalog;

package/dist/contracts/catalog/privilege.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Role, grant, and default-privilege records.
+ *
+ * The factories store the envelope. SQL, introspection, and the doctor
+ * checks live in the dialect and in tooling.
+ */
+import type { DefaultPrivilegeObject, GrantObject, GrantObjectRef, Namespace, ObjectIdentity, Owner, Provenance, RoleObject } from "./types.js";
+/** Input for {@link roleObject}. */
+export type RoleInput = {
+    readonly name: string;
+    readonly login?: boolean;
+    readonly inherit?: boolean;
+    readonly owner?: Owner;
+    readonly provenance: Provenance;
+    readonly dependencies?: readonly ObjectIdentity[];
+};
+/** Input for {@link grantObject}. */
+export type GrantInput = {
+    readonly role: string;
+    readonly object: GrantObjectRef;
+    readonly privilege: string;
+    readonly owner?: Owner;
+    readonly provenance: Provenance;
+    readonly dependencies?: readonly ObjectIdentity[];
+};
+/** Input for {@link defaultPrivilegeObject}. */
+export type DefaultPrivilegeInput = {
+    readonly forRole: string;
+    readonly namespace: Namespace;
+    readonly objectKind: string;
+    readonly grantee: string;
+    readonly privilege: string;
+    readonly owner?: Owner;
+    readonly provenance: Provenance;
+    readonly dependencies?: readonly ObjectIdentity[];
+};
+/**
+ * Builds a role record.
+ *
+ * The name is an identifier. The grant key is not.
+ *
+ * @param input - Name, login, and inherit
+ * @returns The catalog object
+ */
+export declare function roleObject(input: RoleInput): RoleObject;
+/**
+ * Builds a grant record.
+ *
+ * Identity is `(role, object, privilege)`. It is not checked against the
+ * 63-byte identifier limit (D119).
+ *
+ * @param input - Grantee, object, and one privilege
+ * @returns The catalog object
+ */
+export declare function grantObject(input: GrantInput): GrantObject;
+/**
+ * Builds a default-privilege record.
+ *
+ * Identity is `(forRole, namespace, objectKind, grantee, privilege)`.
+ *
+ * @param input - Creating role, schema, object kind, grantee, and privilege
+ * @returns The catalog object
+ */
+export declare function defaultPrivilegeObject(input: DefaultPrivilegeInput): DefaultPrivilegeObject;

package/dist/contracts/catalog/routine.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Function and trigger catalog objects.
+ *
+ * The factories store the record. They do not plan SQL. DDL stays in the
+ * dialect, and `fn()` / `trigger()` stay on `okmodel/fn`.
+ */
+import type { FunctionArgument, FunctionLanguage, FunctionObject, FunctionSecurity, FunctionVolatility, Namespace, ObjectIdentity, ObjectRef, Owner, Provenance, TriggerCall, TriggerEvent, TriggerLevel, TriggerObject, TriggerTiming } from "./types.js";
+/** Input for {@link functionObject}. */
+export type FunctionInput = {
+    readonly namespace?: Namespace;
+    readonly name: string;
+    readonly arguments?: readonly FunctionArgument[];
+    readonly returns: string;
+    readonly language: FunctionLanguage;
+    readonly volatility?: FunctionVolatility;
+    readonly security?: FunctionSecurity;
+    readonly searchPath?: string;
+    readonly body: string;
+    readonly atomic?: boolean;
+    readonly owner?: Owner;
+    readonly provenance: Provenance;
+    readonly dependencies?: readonly ObjectIdentity[];
+};
+/** Input for {@link triggerObject}. */
+export type TriggerInput = {
+    readonly parent: ObjectRef;
+    readonly name: string;
+    readonly timing: TriggerTiming;
+    readonly events: readonly TriggerEvent[];
+    readonly level: TriggerLevel;
+    readonly calls: TriggerCall;
+    readonly updateOf?: readonly string[];
+    readonly when?: string;
+    readonly owner?: Owner;
+    readonly provenance: Provenance;
+    readonly dependencies?: readonly ObjectIdentity[];
+};
+/**
+ * Builds a function record.
+ *
+ * Argument types are the identity. Names live only in the definition.
+ *
+ * @param input - Signature, language, and body
+ * @returns The catalog object
+ */
+export declare function functionObject(input: FunctionInput): FunctionObject;
+/**
+ * Builds a trigger record.
+ *
+ * Dependencies are the table, the function, and each `UPDATE OF` column.
+ * Events are stored in a fixed order.
+ *
+ * @param input - Timing, events, and the function it calls
+ * @returns The catalog object
+ */
+export declare function triggerObject(input: TriggerInput): TriggerObject;

package/dist/contracts/catalog/types.d.ts

@@ -14,7 +14,7 @@ export type Owner = (typeof OWNERS)[number];
  * Object kinds from spec section 5.7.
  *
  * Built in this layer: table, column, index, constraint, sequence, and type.
- * A type object is an enum: ordered labels, and no other form.
+ * A type object is an enum (ordered labels) or a domain (base type and check).
  */
 export declare const OBJECT_KINDS: readonly ["table", "column", "index", "constraint", "sequence", "view", "materializedView", "type", "function", "trigger", "policy", "extension", "role", "grant", "defaultPrivilege"];
 /** A catalog object kind. */
@@ -100,9 +100,15 @@ export type GrantIdentity = {
     readonly object: GrantObjectRef;
     readonly privilege: string;
 };
-/** What a grant attaches to. `namespace` is the schema itself. */
+/**
+ * What a grant attaches to.
+ *
+ * `namespace` is the schema itself. A function's `name` is `name(argTypes)`
+ * so overloads stay distinct without a second field. The key is not a stored
+ * identifier (D119).
+ */
 export type GrantObjectRef = {
-    readonly kind: "table" | "sequence" | "namespace";
+    readonly kind: "table" | "view" | "materializedView" | "sequence" | "function" | "namespace";
     readonly namespace: Namespace;
     readonly name: string;
 };
@@ -130,6 +136,19 @@ export type ExtensionIdentity = {
     readonly kind: "extension";
     readonly name: string;
 };
+/**
+ * Canonical extension record.
+ *
+ * `version` is an exact pin (`1.6`) or a floor (`>=0.7`). Absent means
+ * unpinned: the installed version is information and drift ignores it.
+ */
+export type ExtensionDefinition = {
+    /** Schema the extension is installed in. */
+    readonly schema: string;
+    /** Whether `ALTER EXTENSION … SET SCHEMA` is allowed. */
+    readonly relocatable: boolean;
+    readonly version?: string;
+};
 /** Stable identity. The variant depends on the kind. */
 export type ObjectIdentity = NamespaceIdentity | AnchoredIdentity | FunctionIdentity | GrantIdentity | DefaultPrivilegeIdentity | RoleIdentity | ExtensionIdentity;
 /**
@@ -237,11 +256,22 @@ export type ConstraintDefinition = {
  * Enum definition.
  *
  * `labels` is the stored order. That order is part of the catalog hash.
- * Domains are not represented here.
  */
-export type TypeDefinition = {
+export type EnumDefinition = {
     readonly labels: readonly string[];
 };
+/**
+ * Domain definition.
+ *
+ * `base` is the Postgres type the domain is created over. `check` is the
+ * domain check, stored as written. A later base type is refused (OKM1020).
+ */
+export type DomainDefinition = {
+    readonly base: string;
+    readonly check: string;
+};
+/** A catalog type: an enum or a domain. */
+export type TypeDefinition = EnumDefinition | DomainDefinition;
 /** Sequence definition. Start and increment are decimal integers. */
 export type SequenceDefinition = {
     readonly dataType: "smallint" | "integer" | "bigint";
@@ -283,13 +313,137 @@ export type TypeObject = CatalogEnvelope<"type", NamespaceIdentity & {
     readonly kind: "type";
 }, TypeDefinition>;
 /**
- * One built catalog object.
+ * An extension.
+ *
+ * The record is identity, schema, relocatable, and version. Core stores it
+ * and does not interpret it. The extension object produces it.
+ */
+export type ExtensionObject = CatalogEnvelope<"extension", ExtensionIdentity, ExtensionDefinition>;
+/** One function language. */
+export type FunctionLanguage = "sql" | "plpgsql";
+/** One volatility. */
+export type FunctionVolatility = "volatile" | "stable" | "immutable";
+/** `SECURITY INVOKER` or `SECURITY DEFINER`. */
+export type FunctionSecurity = "invoker" | "definer";
+/** One argument. The name is not part of the identity. */
+export type FunctionArgument = {
+    readonly name: string;
+    readonly type: string;
+};
+/**
+ * Function definition.
+ *
+ * The body of a plpgsql or plain SQL function is the source Postgres stores
+ * (`prosrc`). A `LANGUAGE sql` body that starts with `BEGIN ATOMIC` is marked
+ * `atomic`: Postgres reprints that body and leaves `prosrc` empty.
+ */
+export type FunctionDefinition = {
+    readonly arguments: readonly FunctionArgument[];
+    readonly returns: string;
+    readonly language: FunctionLanguage;
+    readonly volatility: FunctionVolatility;
+    readonly security: FunctionSecurity;
+    readonly body: string;
+    readonly searchPath?: string;
+    readonly atomic?: true;
+};
+/** One trigger timing. */
+export type TriggerTiming = "before" | "after" | "instead";
+/** One trigger event. Stored order is insert, update, delete, truncate. */
+export type TriggerEvent = "insert" | "update" | "delete" | "truncate";
+/** One trigger level. */
+export type TriggerLevel = "row" | "statement";
+/** The function a trigger calls. Argument types keep an overload distinct. */
+export type TriggerCall = {
+    readonly namespace: Namespace;
+    readonly name: string;
+    readonly argTypes: readonly string[];
+};
+/**
+ * Trigger definition.
  *
- * Views, functions, triggers, extensions, roles, grants, and default
- * privileges use {@link CatalogEnvelope} when they are built. They are not
- * part of this union yet.
+ * `updateOf` lists SQL column names for `UPDATE OF`. `when` is the predicate
+ * text. The table and the function are dependency edges.
+ */
+export type TriggerDefinition = {
+    readonly timing: TriggerTiming;
+    readonly events: readonly TriggerEvent[];
+    readonly level: TriggerLevel;
+    readonly calls: TriggerCall;
+    readonly updateOf?: readonly string[];
+    readonly when?: string;
+};
+/** A function. Identity is `(schema, name, argTypes[])`. */
+export type FunctionObject = CatalogEnvelope<"function", FunctionIdentity, FunctionDefinition>;
+/** A trigger. Identity is `(table, name)`. */
+export type TriggerObject = CatalogEnvelope<"trigger", AnchoredIdentity & {
+    readonly kind: "trigger";
+}, TriggerDefinition>;
+/** One output column of a view or materialized view. */
+export type ViewColumn = {
+    readonly name: string;
+    readonly dataType: string;
+};
+/**
+ * View definition.
+ *
+ * `query` is the server reprint when one has been read (`pg_get_viewdef`),
+ * and the author's SQL until then. Column dependencies are separate edges.
+ */
+export type ViewDefinition = {
+    readonly columns: readonly ViewColumn[];
+    readonly query: string;
+};
+/**
+ * Materialized view definition.
+ *
+ * There is no replace. `refresh` is the populate mode. Postgres does not
+ * store it; introspection leaves it unset.
+ */
+export type MaterializedViewDefinition = {
+    readonly columns: readonly ViewColumn[];
+    readonly query: string;
+    readonly refresh?: "concurrently";
+};
+/** A view. Identity is `(namespace, name)`. */
+export type ViewObject = CatalogEnvelope<"view", NamespaceIdentity & {
+    readonly kind: "view";
+}, ViewDefinition>;
+/** A materialized view. Identity is `(namespace, name)`. */
+export type MaterializedViewObject = CatalogEnvelope<"materializedView", NamespaceIdentity & {
+    readonly kind: "materializedView";
+}, MaterializedViewDefinition>;
+/**
+ * Role definition.
+ *
+ * Only `login` and `inherit` are altered in place. A password is not stored.
+ */
+export type RoleDefinition = {
+    readonly login: boolean;
+    readonly inherit: boolean;
+};
+/**
+ * Grant definition.
+ *
+ * The privilege is the identity. `GRANT OPTION` is not in this version.
+ */
+export type GrantDefinition = Record<string, never>;
+/**
+ * Default-privilege definition.
+ *
+ * The key is the identity. The statement is `ALTER DEFAULT PRIVILEGES`.
+ */
+export type DefaultPrivilegeDefinition = Record<string, never>;
+/** A role. Identity is the name. Roles are never dropped (D119). */
+export type RoleObject = CatalogEnvelope<"role", RoleIdentity, RoleDefinition>;
+/** A grant. Identity is `(role, object, privilege)`. */
+export type GrantObject = CatalogEnvelope<"grant", GrantIdentity, GrantDefinition>;
+/** A default privilege. Identity is `(forRole, namespace, objectKind, grantee, privilege)`. */
+export type DefaultPrivilegeObject = CatalogEnvelope<"defaultPrivilege", DefaultPrivilegeIdentity, DefaultPrivilegeDefinition>;
+/**
+ * One built catalog object.
  */
-export type CatalogObject = TableObject | ColumnObject | IndexObject | ConstraintObject | SequenceObject | TypeObject;
+export type CatalogObject = TableObject | ColumnObject | IndexObject | ConstraintObject | SequenceObject | TypeObject | ExtensionObject | FunctionObject | TriggerObject | ViewObject | MaterializedViewObject | RoleObject | GrantObject | DefaultPrivilegeObject;
 /** Format version stored in the serialized catalog. */
 export declare const CATALOG_VERSION = 1;
 /** A catalog document. Object order is identity-key order. */

package/dist/contracts/catalog/view.d.ts

@@ -0,0 +1,73 @@
+/**
+ * View and materialized view catalog objects.
+ *
+ * The factories store the record. They do not plan SQL. DDL stays in the
+ * dialect, and `view()` / `materializedView()` stay on `okmodel/view`.
+ */
+import type { IndexObject, MaterializedViewObject, Namespace, ObjectIdentity, ObjectRef, Owner, Provenance, ViewColumn, ViewObject } from "./types.js";
+/** Input for {@link viewObject}. */
+export type ViewInput = {
+    readonly namespace?: Namespace;
+    readonly name: string;
+    readonly columns: readonly ViewColumn[];
+    readonly query: string;
+    readonly owner?: Owner;
+    readonly provenance: Provenance;
+    readonly dependencies?: readonly ObjectIdentity[];
+};
+/** Input for {@link materializedViewObject}. */
+export type MaterializedViewInput = ViewInput & {
+    readonly refresh?: "concurrently";
+};
+/** Input for {@link materializedViewIndex}. */
+export type MaterializedViewIndexInput = {
+    readonly parent: ObjectRef;
+    readonly name?: string;
+    readonly columns: readonly string[];
+    readonly unique?: boolean;
+    readonly nameKey?: string;
+    readonly expression?: string;
+    readonly predicate?: string;
+    readonly owner?: Owner;
+    readonly provenance: Provenance;
+    /** Retargeted edges. Omitted edges depend on the materialized view. */
+    readonly dependencies?: readonly ObjectIdentity[];
+};
+/**
+ * Trims a view query and drops one trailing semicolon.
+ *
+ * `pg_get_viewdef` and the author's SQL both go through this before they are
+ * stored, so two reads of the same reprint compare equal.
+ *
+ * @param query - Author SQL or a server reprint
+ * @returns The stored query text
+ */
+export declare function normaliseViewQuery(query: string): string;
+/**
+ * Builds a view record.
+ *
+ * Identity is `(namespace, name)`. Columns stay in declaration order.
+ *
+ * @param input - Columns, query, and dependency edges
+ * @returns The catalog object
+ */
+export declare function viewObject(input: ViewInput): ViewObject;
+/**
+ * Builds a materialized view record.
+ *
+ * `refresh` is stored only for `"concurrently"`. The object has no replace.
+ *
+ * @param input - Columns, query, populate mode, and dependency edges
+ * @returns The catalog object
+ */
+export declare function materializedViewObject(input: MaterializedViewInput): MaterializedViewObject;
+/**
+ * Builds an index owned by a materialized view.
+ *
+ * The edge points at the view, not at a table. View output columns are not
+ * catalog objects, so the index does not depend on column identities.
+ *
+ * @param input - Parent view, columns, and uniqueness
+ * @returns An index envelope
+ */
+export declare function materializedViewIndex(input: MaterializedViewIndexInput): IndexObject;

package/dist/dialects/pg/column.d.ts

@@ -4,7 +4,7 @@
  * Modifiers allocate a new builder when called. Importing this module does
  * not build a codec table. `.validate()` stores rules and does not run them.
  */
-import { type ReferentialAction } from "../../contracts/catalog/types.js";
+import { type CatalogObject, type Namespace, type Provenance, type ReferentialAction } from "../../contracts/catalog/types.js";
 import { type ClientFill } from "../../contracts/generator.js";
 /** Flags that decide the row, insert, and update shapes of one column. */
 export type ColumnFlags = {
@@ -221,6 +221,7 @@ export type ColumnState<TValue> = {
     readonly domain: {
         readonly base: string;
         readonly check: string;
+        readonly emit?: (namespace: Namespace, provenance: Provenance, objects: CatalogObject[]) => void;
     } | undefined;
     readonly primaryKey: boolean;
     readonly typeLabel: string | undefined;
@@ -264,6 +265,7 @@ export type OpenColumn<TValue> = {
     readonly domain?: {
         readonly base: string;
         readonly check: string;
+        readonly emit?: (namespace: Namespace, provenance: Provenance, objects: CatalogObject[]) => void;
     };
     readonly primaryKey?: boolean;
     readonly typeLabel?: string;

package/dist/dialects/pg/ddl.d.ts

@@ -4,7 +4,7 @@
  * Planning and scratch comparison both render through here, so a statement
  * has one spelling.
  */
-import type { Catalog, CatalogObject, ColumnObject, SequenceObject, TableObject } from "../../contracts/catalog/types.js";
+import type { Catalog, CatalogObject, ColumnObject, FunctionObject, MaterializedViewObject, SequenceObject, TableObject, ViewObject } from "../../contracts/catalog/types.js";
 /**
  * Quotes one identifier.
  *
@@ -23,6 +23,15 @@ export declare function quoteIdent(name: string): string;
  * @returns SQL statements
  */
 export declare function renderCatalog(source: Catalog, schema: string): readonly string[];
+/**
+ * Reports whether an index belongs to a view or a materialized view.
+ *
+ * Those indexes are created after the view, not with the tables.
+ *
+ * @param object - Catalog object
+ * @returns `true` when an index edge points at a view
+ */
+export declare function ownedByView(object: CatalogObject): boolean;
 /**
  * SQL that drops one object.
  *
@@ -42,6 +51,53 @@ export declare function dropObjectSql(object: CatalogObject, schema: string): st
  * @returns The statement
  */
 export declare function createObjectSql(object: CatalogObject, schema: string): string | undefined;
+/**
+ * `CREATE` or `CREATE OR REPLACE` for one function.
+ *
+ * A compatible signature change uses replace. The body is the stored source,
+ * or the `BEGIN ATOMIC` block when the function is atomic.
+ *
+ * @param object - Function to render
+ * @param schema - Concrete schema name
+ * @param replace - `CREATE OR REPLACE` when true
+ * @returns The statement
+ */
+export declare function functionSql(object: FunctionObject, schema: string, replace: boolean): string;
+/**
+ * `CREATE` or `CREATE OR REPLACE` for one view.
+ *
+ * Appending columns is replace. The query is the stored text.
+ *
+ * @param object - View to render
+ * @param schema - Concrete schema name
+ * @param replace - `CREATE OR REPLACE` when true
+ * @returns The statement
+ */
+export declare function viewSql(object: ViewObject, schema: string, replace: boolean): string;
+/**
+ * `CREATE MATERIALIZED VIEW ... WITH NO DATA`.
+ *
+ * Populate is a separate planned step. This statement does not read the table.
+ *
+ * @param object - Materialized view to render
+ * @param schema - Concrete schema name
+ * @returns The statement
+ */
+export declare function materializedViewSql(object: MaterializedViewObject, schema: string): string;
+/**
+ * `REFRESH MATERIALIZED VIEW`.
+ *
+ * A view created `WITH NO DATA` is empty, and Postgres rejects `CONCURRENTLY`
+ * until it has been populated once. The plan's populate step passes
+ * `populated: false`. A later refresh uses `CONCURRENTLY` when the declaration
+ * asked for it.
+ *
+ * @param object - Materialized view to refresh
+ * @param schema - Concrete schema name
+ * @param populated - `true` when the view already holds rows
+ * @returns The statement
+ */
+export declare function refreshMaterializedViewSql(object: MaterializedViewObject, schema: string, populated?: boolean): string;
 /**
  * In-place column changes: type, nullability, and default.
  *
@@ -68,3 +124,11 @@ export declare function identitySequence(sequence: SequenceObject, source: Catal
  * @returns The statement
  */
 export declare function createTableSql(tableObject: TableObject, source: Catalog, schema: string): string;
+/**
+ * Quotes a schema-qualified name.
+ *
+ * @param schema - Concrete schema name
+ * @param name - Object name
+ * @returns `"schema"."name"`
+ */
+export declare function qualify(schema: string, name: string): string;