@supabase/pg-delta 1.0.0-alpha.26 → 1.0.0-alpha.28

package/src/core/integrations/supabase.ts

@@ -125,6 +125,30 @@ export const supabase: IntegrationDSL = {
               "trigger/function_schema": [...SUPABASE_SYSTEM_SCHEMAS],
             },
           },
+          // Defensive fallback for dynamically-created pgmq queue /
+          // archive tables. `pgmq.q_<name>` and `pgmq.a_<name>` are
+          // materialized by `select pgmq.create('<name>')`, NOT by
+          // `CREATE EXTENSION pgmq`, so emitting a user trigger against
+          // them fails locally with
+          // `relation "pgmq.q_<name>" does not exist`. On a healthy
+          // install the trigger extractor's `extension_table_oids` join
+          // (packages/pg-delta/src/core/objects/trigger/trigger.model.ts)
+          // already drops these via the `pg_depend deptype='e'` row pgmq
+          // records during `pgmq.create()`; this rule covers projects
+          // where that row is missing (older pgmq, manual table
+          // rewrites, `pg_dump`/restore that loses extension deps, ...).
+          // pgmq 1.4.4 — the version Supabase Cloud currently ships —
+          // does not record the dependency at all.
+          {
+            not: {
+              and: [
+                { "trigger/schema": "pgmq" },
+                {
+                  "trigger/table_name": { op: "regex", value: "^[qa]_" },
+                },
+              ],
+            },
+          },
         ],
       },
       // Exclude system objects
@@ -185,15 +209,25 @@ export const supabase: IntegrationDSL = {
               ],
             },
             // Platform-managed foreign data wrappers — Wasm-based FDWs
-            // (e.g. `clerk`, `clerk_oauth`) whose handler/validator live in
-            // the `extensions` schema. `CREATE FOREIGN DATA WRAPPER`
-            // requires superuser, and Supabase Cloud provisions these via
-            // `supabase_admin` at project creation; replaying the DDL
-            // against a local image fails because the local environment
-            // has no equivalent pre-step. We can't rely on the FDW owner
-            // alone — after a dump/restore the owner is often rewritten
-            // away from `supabase_admin` — so match on the function
-            // reference instead.
+            // (e.g. `clerk`, `clerk_oauth`) provisioned via the `wrappers`
+            // extension. Supabase Cloud creates these as
+            // `CREATE FOREIGN DATA WRAPPER clerk_oauth HANDLER
+            // extensions.wasm_fdw_handler VALIDATOR
+            // extensions.wasm_fdw_validator` at project creation; replaying
+            // the DDL against a local image fails because the local
+            // environment has no equivalent pre-step. We can't rely on the
+            // FDW owner alone — after a dump/restore the owner is often
+            // rewritten away from `supabase_admin` — so match on the shared
+            // Wasm handler/validator (`extensions.wasm_fdw_handler` /
+            // `extensions.wasm_fdw_validator`) instead.
+            //
+            // Matching the bare `extensions.*` namespace would be too broad:
+            // contrib FDWs like `postgres_fdw` also install their
+            // handler/validator into `extensions` on Supabase, and those ARE
+            // available in the local image, so a user-created `postgres_fdw`
+            // wrapper (and its servers/foreign tables/user mappings) must
+            // still roundtrip. Keying on the `wasm_fdw_*` function names
+            // targets only the platform Wasm wrappers.
             {
               and: [
                 { objectType: "foreign_data_wrapper" },
@@ -202,13 +236,70 @@ export const supabase: IntegrationDSL = {
                     {
                       "foreign_data_wrapper/handler": {
                         op: "regex",
-                        value: "^extensions\\.",
+                        value: "^extensions\\.wasm_fdw_handler$",
                       },
                     },
                     {
                       "foreign_data_wrapper/validator": {
                         op: "regex",
-                        value: "^extensions\\.",
+                        value: "^extensions\\.wasm_fdw_validator$",
+                      },
+                    },
+                  ],
+                },
+              ],
+            },
+            // Platform-managed Wasm FDW dependents (CLI-1470 follow-up).
+            // Suppressing the wrapper DDL alone leaves `CREATE SERVER` /
+            // `CREATE FOREIGN TABLE` / `CREATE USER MAPPING` that reference
+            // a wrapper local Docker never provisions (`clerk_oauth`, etc.).
+            // Match on the parent wrapper's Wasm handler/validator
+            // (`extensions.wasm_fdw_handler` / `extensions.wasm_fdw_validator`,
+            // joined at extract time) — the same discriminator used for the
+            // wrapper itself above. A bare `extensions.*` match would also
+            // drop user-created `postgres_fdw` servers/foreign tables/user
+            // mappings (whose handler installs into `extensions` but which
+            // the local image CAN provision), so keep it scoped to the Wasm
+            // function names. Server _privilege_ scope is excluded here —
+            // `GRANT/REVOKE ON SERVER` does not require superuser and remains
+            // user-declarative state (see CLI-1469 companion test).
+            {
+              and: [
+                { objectType: "server" },
+                { not: { scope: "privilege" } },
+                {
+                  or: [
+                    {
+                      "{server,foreign_table,user_mapping}/wrapper_handler": {
+                        op: "regex",
+                        value: "^extensions\\.wasm_fdw_handler$",
+                      },
+                    },
+                    {
+                      "{server,foreign_table,user_mapping}/wrapper_validator": {
+                        op: "regex",
+                        value: "^extensions\\.wasm_fdw_validator$",
+                      },
+                    },
+                  ],
+                },
+              ],
+            },
+            {
+              and: [
+                { objectType: ["foreign_table", "user_mapping"] },
+                {
+                  or: [
+                    {
+                      "{server,foreign_table,user_mapping}/wrapper_handler": {
+                        op: "regex",
+                        value: "^extensions\\.wasm_fdw_handler$",
+                      },
+                    },
+                    {
+                      "{server,foreign_table,user_mapping}/wrapper_validator": {
+                        op: "regex",
+                        value: "^extensions\\.wasm_fdw_validator$",
                       },
                     },
                   ],

package/src/core/objects/base.change.ts

@@ -51,6 +51,21 @@ export abstract class BaseChange {
     return [];
   }
 
+  /**
+   * Stable identifiers this change invalidates in place.
+   *
+   * Unlike `drops`, the object keeps its identity. This is an ordering-only
+   * signal for mutations that rewrite an existing object in a way that requires
+   * dependents bound to the old definition to be dropped before the mutation
+   * and rebuilt afterward.
+   *
+   * Defaults to an empty array. Override in subclasses that invalidate
+   * dependents without dropping the object.
+   */
+  get invalidates(): string[] {
+    return [];
+  }
+
   /**
    * Stable identifiers this change requires to exist beforehand.
    *

package/src/core/objects/foreign-data-wrapper/foreign-table/foreign-table.model.ts

@@ -36,6 +36,9 @@ const foreignTablePropsSchema = z.object({
   columns: z.array(columnPropsSchema),
   privileges: z.array(privilegePropsSchema),
   security_labels: z.array(securityLabelPropsSchema).default([]).optional(),
+  // Parent FDW handler/validator — filter metadata only, not in dataFields.
+  wrapper_handler: z.string().nullable().optional(),
+  wrapper_validator: z.string().nullable().optional(),
 });
 
 type ForeignTablePrivilegeProps = PrivilegeProps;
@@ -51,6 +54,8 @@ export class ForeignTable extends BasePgModel implements TableLikeObject {
   public readonly columns: ForeignTableProps["columns"];
   public readonly privileges: ForeignTablePrivilegeProps[];
   public readonly security_labels: SecurityLabelProps[];
+  public readonly wrapper_handler: ForeignTableProps["wrapper_handler"];
+  public readonly wrapper_validator: ForeignTableProps["wrapper_validator"];
 
   constructor(props: ForeignTableProps) {
     super();
@@ -67,6 +72,8 @@ export class ForeignTable extends BasePgModel implements TableLikeObject {
     this.columns = props.columns;
     this.privileges = props.privileges;
     this.security_labels = props.security_labels ?? [];
+    this.wrapper_handler = props.wrapper_handler ?? null;
+    this.wrapper_validator = props.wrapper_validator ?? null;
   }
 
   get stableId(): `foreignTable:${string}` {
@@ -146,12 +153,22 @@ export async function extractForeignTables(
           c.relowner::regrole::text as owner,
           quote_ident(srv.srvname) as server,
           coalesce(ft.ftoptions, array[]::text[]) as options,
-          c.oid as oid
+          c.oid as oid,
+          case
+            when fdw.fdwhandler = 0 then null
+            else p_handler.pronamespace::regnamespace::text || '.' || quote_ident(p_handler.proname)
+          end as wrapper_handler,
+          case
+            when fdw.fdwvalidator = 0 then null
+            else p_validator.pronamespace::regnamespace::text || '.' || quote_ident(p_validator.proname)
+          end as wrapper_validator
         from
           pg_class c
           inner join pg_foreign_table ft on ft.ftrelid = c.oid
           inner join pg_foreign_server srv on srv.oid = ft.ftserver
           inner join pg_foreign_data_wrapper fdw on fdw.oid = srv.srvfdw
+          left join pg_catalog.pg_proc p_handler on p_handler.oid = fdw.fdwhandler
+          left join pg_catalog.pg_proc p_validator on p_validator.oid = fdw.fdwvalidator
           left outer join extension_oids e1 on c.oid = e1.objid
         where
           c.relkind = 'f'
@@ -165,6 +182,8 @@ export async function extractForeignTables(
         ft.owner,
         ft.server,
         ft.options,
+        ft.wrapper_handler,
+        ft.wrapper_validator,
         obj_description(ft.oid, 'pg_class') as comment,
         coalesce(json_agg(
           case when a.attname is not null then
@@ -250,7 +269,14 @@ export async function extractForeignTables(
         left join pg_attrdef ad on a.attrelid = ad.adrelid and a.attnum = ad.adnum
         left join pg_type ty on ty.oid = a.atttypid
       group by
-        ft.oid, ft.schema, ft.name, ft.owner, ft.server, ft.options
+        ft.oid,
+        ft.schema,
+        ft.name,
+        ft.owner,
+        ft.server,
+        ft.options,
+        ft.wrapper_handler,
+        ft.wrapper_validator
       order by
         ft.schema, ft.name
   `);

package/src/core/objects/foreign-data-wrapper/server/server.model.ts

@@ -26,6 +26,9 @@ const serverPropsSchema = z.object({
   options: z.array(z.string()).nullable(),
   comment: z.string().nullable(),
   privileges: z.array(privilegePropsSchema),
+  // Parent FDW handler/validator — filter metadata only, not in dataFields.
+  wrapper_handler: z.string().nullable().optional(),
+  wrapper_validator: z.string().nullable().optional(),
 });
 
 type ServerPrivilegeProps = PrivilegeProps;
@@ -40,6 +43,8 @@ export class Server extends BasePgModel {
   public readonly options: ServerProps["options"];
   public readonly comment: ServerProps["comment"];
   public readonly privileges: ServerPrivilegeProps[];
+  public readonly wrapper_handler: ServerProps["wrapper_handler"];
+  public readonly wrapper_validator: ServerProps["wrapper_validator"];
 
   constructor(props: ServerProps) {
     super();
@@ -55,6 +60,8 @@ export class Server extends BasePgModel {
     this.options = props.options;
     this.comment = props.comment;
     this.privileges = props.privileges;
+    this.wrapper_handler = props.wrapper_handler ?? null;
+    this.wrapper_validator = props.wrapper_validator ?? null;
   }
 
   get stableId(): `server:${string}` {
@@ -112,10 +119,20 @@ export async function extractServers(pool: Pool): Promise<Server[]> {
             )
             from lateral aclexplode(srv.srvacl) as x(grantor, grantee, privilege_type, is_grantable)
           ), '[]'
-        ) as privileges
+        ) as privileges,
+        case
+          when fdw.fdwhandler = 0 then null
+          else p_handler.pronamespace::regnamespace::text || '.' || quote_ident(p_handler.proname)
+        end as wrapper_handler,
+        case
+          when fdw.fdwvalidator = 0 then null
+          else p_validator.pronamespace::regnamespace::text || '.' || quote_ident(p_validator.proname)
+        end as wrapper_validator
       from
         pg_catalog.pg_foreign_server srv
         inner join pg_catalog.pg_foreign_data_wrapper fdw on fdw.oid = srv.srvfdw
+        left join pg_catalog.pg_proc p_handler on p_handler.oid = fdw.fdwhandler
+        left join pg_catalog.pg_proc p_validator on p_validator.oid = fdw.fdwvalidator
       where
         not fdw.fdwname like any(array['pg\\_%'])
       order by

package/src/core/objects/foreign-data-wrapper/user-mapping/user-mapping.model.ts

@@ -18,6 +18,9 @@ const userMappingPropsSchema = z.object({
   user: z.string(),
   server: z.string(),
   options: z.array(z.string()).nullable(),
+  // Parent FDW handler/validator — filter metadata only, not in dataFields.
+  wrapper_handler: z.string().nullable().optional(),
+  wrapper_validator: z.string().nullable().optional(),
 });
 
 export type UserMappingProps = z.infer<typeof userMappingPropsSchema>;
@@ -26,6 +29,8 @@ export class UserMapping extends BasePgModel {
   public readonly user: UserMappingProps["user"];
   public readonly server: UserMappingProps["server"];
   public readonly options: UserMappingProps["options"];
+  public readonly wrapper_handler: UserMappingProps["wrapper_handler"];
+  public readonly wrapper_validator: UserMappingProps["wrapper_validator"];
 
   constructor(props: UserMappingProps) {
     super();
@@ -36,6 +41,8 @@ export class UserMapping extends BasePgModel {
 
     // Data fields
     this.options = props.options;
+    this.wrapper_handler = props.wrapper_handler ?? null;
+    this.wrapper_validator = props.wrapper_validator ?? null;
   }
 
   get stableId(): `userMapping:${string}:${string}` {
@@ -74,11 +81,21 @@ export async function extractUserMappings(pool: Pool): Promise<UserMapping[]> {
           else um.umuser::regrole::text
         end as user,
         quote_ident(srv.srvname) as server,
-        coalesce(um.umoptions, array[]::text[]) as options
+        coalesce(um.umoptions, array[]::text[]) as options,
+        case
+          when fdw.fdwhandler = 0 then null
+          else p_handler.pronamespace::regnamespace::text || '.' || quote_ident(p_handler.proname)
+        end as wrapper_handler,
+        case
+          when fdw.fdwvalidator = 0 then null
+          else p_validator.pronamespace::regnamespace::text || '.' || quote_ident(p_validator.proname)
+        end as wrapper_validator
       from
         pg_catalog.pg_user_mapping um
         inner join pg_catalog.pg_foreign_server srv on srv.oid = um.umserver
         inner join pg_catalog.pg_foreign_data_wrapper fdw on fdw.oid = srv.srvfdw
+        left join pg_catalog.pg_proc p_handler on p_handler.oid = fdw.fdwhandler
+        left join pg_catalog.pg_proc p_validator on p_validator.oid = fdw.fdwvalidator
       where
         not fdw.fdwname like any(array['pg\\_%'])
       order by

package/src/core/objects/materialized-view/materialized-view.diff.test.ts

@@ -106,7 +106,7 @@ describe.concurrent("materialized-view.diff", () => {
     expect(changes[0]).toBeInstanceOf(AlterMaterializedViewChangeOwner);
   });
 
-  test("drop + create on non-alterable change", () => {
+  test("drop + create with metadata on non-alterable change", () => {
     const main = new MaterializedView(base);
     const branch = new MaterializedView({ ...base, definition: "select 2" });
     const changes = diffMaterializedViews(
@@ -114,9 +114,10 @@ describe.concurrent("materialized-view.diff", () => {
       { [main.stableId]: main },
       { [branch.stableId]: branch },
     );
-    expect(changes).toHaveLength(2);
+    expect(changes).toHaveLength(3);
     expect(changes[0]).toBeInstanceOf(DropMaterializedView);
     expect(changes[1]).toBeInstanceOf(CreateMaterializedView);
+    expect(changes[2]).toBeInstanceOf(AlterMaterializedViewChangeOwner);
   });
 
   test("alter storage parameters: set and reset", () => {

package/src/core/objects/materialized-view/materialized-view.diff.ts

@@ -30,117 +30,126 @@ import {
 import type { MaterializedViewChange } from "./changes/materialized-view.types.ts";
 import type { MaterializedView } from "./materialized-view.model.ts";
 
-/**
- * Diff two sets of materialized views from main and branch catalogs.
- *
- * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
- * @param main - The materialized views in the main catalog.
- * @param branch - The materialized views in the branch catalog.
- * @returns A list of changes to apply to main to make it match branch.
- */
-export function diffMaterializedViews(
+export function buildCreateMaterializedViewChanges(
   ctx: Pick<
     ObjectDiffContext,
     "version" | "currentUser" | "defaultPrivilegeState"
   >,
-  main: Record<string, MaterializedView>,
-  branch: Record<string, MaterializedView>,
+  mv: MaterializedView,
 ): MaterializedViewChange[] {
-  const { created, dropped, altered } = diffObjects(main, branch);
-
-  const changes: MaterializedViewChange[] = [];
+  const changes: MaterializedViewChange[] = [
+    new CreateMaterializedView({
+      materializedView: mv,
+    }),
+  ];
 
-  for (const materializedViewId of created) {
-    const mv = branch[materializedViewId];
+  // OWNER: If the materialized view should be owned by someone other than the current user,
+  // emit ALTER MATERIALIZED VIEW ... OWNER TO after creation
+  if (mv.owner !== ctx.currentUser) {
     changes.push(
-      new CreateMaterializedView({
+      new AlterMaterializedViewChangeOwner({
         materializedView: mv,
+        owner: mv.owner,
       }),
     );
+  }
 
-    // OWNER: If the materialized view should be owned by someone other than the current user,
-    // emit ALTER MATERIALIZED VIEW ... OWNER TO after creation
-    if (mv.owner !== ctx.currentUser) {
+  // Materialized view comment on creation
+  if (mv.comment !== null) {
+    changes.push(
+      new CreateCommentOnMaterializedView({
+        materializedView: mv,
+      }),
+    );
+  }
+  // Column comments on creation
+  for (const col of mv.columns) {
+    if (col.comment !== null) {
       changes.push(
-        new AlterMaterializedViewChangeOwner({
+        new CreateCommentOnMaterializedViewColumn({
           materializedView: mv,
-          owner: mv.owner,
+          column: col,
         }),
       );
     }
+  }
 
-    // Note: RLS (row_security, force_row_security) is a non-alterable property for materialized views.
-    // If RLS needs to be enabled, the materialized view must be dropped and recreated, which is
-    // handled in the "altered" section when non-alterable properties change.
+  // Security labels on the matview itself (columns of matviews are not
+  // supported targets of SECURITY LABEL, so we only label the relation).
+  for (const label of mv.security_labels) {
+    changes.push(
+      new CreateSecurityLabelOnMaterializedView({
+        materializedView: mv,
+        securityLabel: label,
+      }),
+    );
+  }
 
-    // Materialized view comment on creation
-    if (mv.comment !== null) {
-      changes.push(
-        new CreateCommentOnMaterializedView({
-          materializedView: mv,
-        }),
-      );
-    }
-    // Column comments on creation
-    for (const col of mv.columns) {
-      if (col.comment !== null) {
-        changes.push(
-          new CreateCommentOnMaterializedViewColumn({
-            materializedView: mv,
-            column: col,
-          }),
-        );
-      }
-    }
+  // PRIVILEGES: For created objects, compare against default privileges state
+  // The migration script will run ALTER DEFAULT PRIVILEGES before CREATE (via constraint spec),
+  // so objects are created with the default privileges state in effect.
+  // We compare default privileges against desired privileges to generate REVOKE/GRANT statements
+  // needed to reach the final desired state.
+  const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(
+    ctx.currentUser,
+    "materialized_view",
+    mv.schema ?? "",
+  );
+  const creatorFilteredDefaults =
+    mv.owner !== ctx.currentUser
+      ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
+      : effectiveDefaults;
+  const desiredPrivileges = mv.privileges;
+  // Filter out owner privileges - owner always has ALL privileges implicitly
+  // and shouldn't be compared. Use the materialized view owner as the reference.
+  const privilegeResults = diffPrivileges(
+    creatorFilteredDefaults,
+    desiredPrivileges,
+    mv.owner,
+  );
 
-    // Security labels on the matview itself (columns of matviews are not
-    // supported targets of SECURITY LABEL, so we only label the relation).
-    for (const label of mv.security_labels) {
-      changes.push(
-        new CreateSecurityLabelOnMaterializedView({
-          materializedView: mv,
-          securityLabel: label,
-        }),
-      );
-    }
+  changes.push(
+    ...(emitColumnPrivilegeChanges(
+      privilegeResults,
+      mv,
+      mv,
+      "materializedView",
+      {
+        Grant: GrantMaterializedViewPrivileges,
+        Revoke: RevokeMaterializedViewPrivileges,
+        RevokeGrantOption: RevokeGrantOptionMaterializedViewPrivileges,
+      },
+      effectiveDefaults,
+      ctx.version,
+    ) as MaterializedViewChange[]),
+  );
 
-    // PRIVILEGES: For created objects, compare against default privileges state
-    // The migration script will run ALTER DEFAULT PRIVILEGES before CREATE (via constraint spec),
-    // so objects are created with the default privileges state in effect.
-    // We compare default privileges against desired privileges to generate REVOKE/GRANT statements
-    // needed to reach the final desired state.
-    const effectiveDefaults = ctx.defaultPrivilegeState.getEffectiveDefaults(
-      ctx.currentUser,
-      "materialized_view",
-      mv.schema ?? "",
-    );
-    const creatorFilteredDefaults =
-      mv.owner !== ctx.currentUser
-        ? effectiveDefaults.filter((p) => p.grantee !== ctx.currentUser)
-        : effectiveDefaults;
-    const desiredPrivileges = mv.privileges;
-    // Filter out owner privileges - owner always has ALL privileges implicitly
-    // and shouldn't be compared. Use the materialized view owner as the reference.
-    const privilegeResults = diffPrivileges(
-      creatorFilteredDefaults,
-      desiredPrivileges,
-      mv.owner,
-    );
+  return changes;
+}
+
+/**
+ * Diff two sets of materialized views from main and branch catalogs.
+ *
+ * @param ctx - Context containing version, currentUser, and defaultPrivilegeState
+ * @param main - The materialized views in the main catalog.
+ * @param branch - The materialized views in the branch catalog.
+ * @returns A list of changes to apply to main to make it match branch.
+ */
+export function diffMaterializedViews(
+  ctx: Pick<
+    ObjectDiffContext,
+    "version" | "currentUser" | "defaultPrivilegeState"
+  >,
+  main: Record<string, MaterializedView>,
+  branch: Record<string, MaterializedView>,
+): MaterializedViewChange[] {
+  const { created, dropped, altered } = diffObjects(main, branch);
 
+  const changes: MaterializedViewChange[] = [];
+
+  for (const materializedViewId of created) {
     changes.push(
-      ...(emitColumnPrivilegeChanges(
-        privilegeResults,
-        mv,
-        mv,
-        "materializedView",
-        {
-          Grant: GrantMaterializedViewPrivileges,
-          Revoke: RevokeMaterializedViewPrivileges,
-          RevokeGrantOption: RevokeGrantOptionMaterializedViewPrivileges,
-        },
-        effectiveDefaults,
-        ctx.version,
-      ) as MaterializedViewChange[]),
+      ...buildCreateMaterializedViewChanges(ctx, branch[materializedViewId]),
     );
   }
 
@@ -180,9 +189,7 @@ export function diffMaterializedViews(
       // Replace the entire materialized view (drop + create)
       changes.push(
         new DropMaterializedView({ materializedView: mainMaterializedView }),
-        new CreateMaterializedView({
-          materializedView: branchMaterializedView,
-        }),
+        ...buildCreateMaterializedViewChanges(ctx, branchMaterializedView),
       );
     } else {
       // Only alterable properties changed - check each one

package/src/core/objects/table/changes/table.alter.ts

@@ -651,6 +651,15 @@ export class AlterTableAlterColumnType extends AlterTableChange {
     ];
   }
 
+  get invalidates() {
+    // ALTER COLUMN ... TYPE rewrites the column in place. The column keeps its
+    // identity, but anything bound to its old type (views, rules, etc.) must be
+    // dropped before the rewrite and rebuilt after, so report it as invalidated.
+    return [
+      stableId.column(this.table.schema, this.table.name, this.column.name),
+    ];
+  }
+
   serialize(_options?: SerializeOptions): string {
     // previousColumn is optional so direct serializer tests/fixtures can keep
     // emitting canonical ALTER TYPE SQL without forcing a USING expression.