The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.
TypeScript aialternativeauthdatabasedenoembeddingsexamplefirebasenextjsoauth2pgvectorpostgispostgrespostgresqlpostgrestrealtimesupabasevectorswebsockets
Joshenlim/fe 4475 fdw update sql to run proper alter statements instead of (#50988)
Joshen Lim9aae037dff85
diff --git a/apps/studio/components/interfaces/Integrations/Wrappers/CreateWrapperSheet.tsx b/apps/studio/components/interfaces/Integrations/Wrappers/CreateWrapperSheet.tsxindex e655d64d9b6..fd16e97dd6d 100644--- a/apps/studio/components/interfaces/Integrations/Wrappers/CreateWrapperSheet.tsx+++ b/apps/studio/components/interfaces/Integrations/Wrappers/CreateWrapperSheet.tsx@@ -312,7 +312,12 @@ export const CreateWrapperSheet = ({{wrapperMeta.server.options.filter((option) => !option.hidden).map((option) => (- <InputField option={option} control={form.control} key={option.name} />+ <InputField+ key={option.name}+ option={option}+ control={form.control}+ placeholder={option.defaultValue}+ />))}</FormSectionContent></FormSection>diff --git a/apps/studio/components/interfaces/Integrations/Wrappers/EditWrapperSheet.tsx b/apps/studio/components/interfaces/Integrations/Wrappers/EditWrapperSheet.tsxindex ca2a703b9fd..fafb290e561 100644--- a/apps/studio/components/interfaces/Integrations/Wrappers/EditWrapperSheet.tsx+++ b/apps/studio/components/interfaces/Integrations/Wrappers/EditWrapperSheet.tsx@@ -34,6 +34,7 @@ import {} from './Wrappers.utils'import WrapperTableEditor from './WrapperTableEditor'import { DiscardChangesConfirmationDialog } from '@/components/ui-patterns/Dialogs/DiscardChangesConfirmationDialog'+import { ButtonTooltip } from '@/components/ui/ButtonTooltip'import {FormSection,FormSectionContent,@@ -70,10 +71,11 @@ export const EditWrapperSheet = ({const { mutate: updateFDW, isPending: isSaving } = useFDWUpdateMutation({onSuccess: () => {toast.success(`Successfully updated ${wrapperMeta?.label} foreign data wrapper`)-const { tables } = getValues()const hasNewSchema = (tables as Record<string, any>[]).some((table) => table.is_new_schema)if (hasNewSchema) invalidateSchemasQuery(queryClient, project?.ref)++ onClose()},})@@ -151,7 +153,11 @@ export const EditWrapperSheet = ({const wrapper_name = useWatch({ name: 'wrapper_name', control: form.control })const [isLoadingSecrets, setIsLoadingSecrets] = useState(false)+ const [secretsReady, setSecretsReady] = useState(false)+useEffect(() => {+ let isCurrent = true+const encryptedOptions = wrapperMeta.server.options.filter((option) => option.encrypted)const encryptedIdsToFetch = compact(@@ -160,7 +166,14 @@ export const EditWrapperSheet = ({return value ?? null})).filter((x) => UUID_REGEX.test(x))- // [Joshen] ^ Validate UUID to filter out already decrypted values++ if (encryptedIdsToFetch.length === 0) {+ setSecretsReady(true)+ setIsLoadingSecrets(false)+ return+ }++ setSecretsReady(false)const fetchEncryptedValues = async (ids: string[]) => {try {@@ -171,21 +184,26 @@ export const EditWrapperSheet = ({connectionString: project?.connectionString,ids: ids,})+ if (!isCurrent) returnencryptedOptions.forEach((option) => {const encryptedId = initialValues[option.name]resetField(option.name, { defaultValue: decryptedValues[encryptedId] })})+ setSecretsReady(true)} catch (error) {+ if (!isCurrent) returntoast.error('Failed to fetch encrypted values')} finally {- setIsLoadingSecrets(false)+ if (isCurrent) setIsLoadingSecrets(false)}}- if (encryptedIdsToFetch.length > 0) {- fetchEncryptedValues(encryptedIdsToFetch)+ fetchEncryptedValues(encryptedIdsToFetch)++ return () => {+ isCurrent = false}}, [initialValues, wrapperMeta, resetField, project?.ref, project?.connectionString])@@ -248,6 +266,7 @@ export const EditWrapperSheet = ({key={option.name}option={option}control={form.control}+ placeholder={option.defaultValue}loading={option.secureEntry ? isLoadingSecrets : undefined}/>))}@@ -335,16 +354,22 @@ export const EditWrapperSheet = ({<Button size="tiny" type="button" onClick={confirmOnClose} disabled={isSubmitting}>Cancel</Button>- <Button+ <ButtonTooltipsize="tiny"variant="primary"form={FORM_ID}type="submit"- disabled={isSubmitting || !isDirty}+ disabled={isSubmitting || !isDirty || !secretsReady}loading={isSubmitting}+ tooltip={{+ content: {+ side: 'top',+ text: !secretsReady ? 'Waiting for encrypted values to load' : undefined,+ },+ }}>Save wrapper- </Button>+ </ButtonTooltip></SheetFooter></form></Form>@@ -352,11 +377,11 @@ export const EditWrapperSheet = ({<ConfirmationModalvisible={isUpdateConfirmationOpen}- title="Recreate wrapper?"- size="medium"+ title="Save wrapper changes?"+ size="small"variant="warning"- confirmLabel="Recreate wrapper"- confirmLabelLoading="Recreating wrapper"+ confirmLabel="Save changes"+ confirmLabelLoading="Saving changes"loading={isSaving}onCancel={() => {setIsUpdateConfirmationOpen(false)@@ -376,9 +401,7 @@ export const EditWrapperSheet = ({}}><p className="text-sm text-foreground-light">- Saving changes will drop the existing wrapper and recreate it. Foreign servers and tables- will be recreated, and dependent objects like functions or views that reference those- tables may need to be updated manually afterwards.+ Removing a table or retyping a column may break views or functions that reference it.</p><p className="text-sm text-foreground-light mt-2">Are you sure you want to continue?</p></ConfirmationModal>diff --git a/apps/studio/components/interfaces/Integrations/Wrappers/InputField.tsx b/apps/studio/components/interfaces/Integrations/Wrappers/InputField.tsxindex c34eb91a652..d5ed4a6e7b7 100644--- a/apps/studio/components/interfaces/Integrations/Wrappers/InputField.tsx+++ b/apps/studio/components/interfaces/Integrations/Wrappers/InputField.tsx@@ -11,6 +11,7 @@ interface InputFieldProps<TFieldValues extends FieldValues = FieldValues> {option: ServerOptioncontrol: Control<TFieldValues>loading?: boolean+ placeholder?: string}const InputField = <@@ -20,6 +21,7 @@ const InputField = <control,option,loading = false,+ placeholder,}: InputFieldProps<TFieldValues>) => {return (<FormField@@ -57,7 +59,7 @@ const InputField = <) : option.secureEntry ? (<PasswordInput copy reveal {...field} />) : (- <Input {...field} />+ <Input {...field} placeholder={placeholder} />)}</FormControl></FormItemLayout>diff --git a/apps/studio/components/interfaces/Integrations/Wrappers/WrapperRow.tsx b/apps/studio/components/interfaces/Integrations/Wrappers/WrapperRow.tsxindex 2fbcbdef192..48b378edd35 100644--- a/apps/studio/components/interfaces/Integrations/Wrappers/WrapperRow.tsx+++ b/apps/studio/components/interfaces/Integrations/Wrappers/WrapperRow.tsx@@ -41,6 +41,7 @@ export const WrapperRow = ({ wrapper, isShared }: WrapperRowProps) => {const _tables = formatWrapperTables(wrapper, integration?.meta)const canEdit = canManageWrappers && !isShared+let editTooltip = 'Edit wrapper'if (!canManageWrappers) editTooltip = 'You need additional permissions to edit wrappers'else if (isShared) editTooltip = 'Shared wrappers cannot be edited in the dashboard'@@ -87,7 +88,7 @@ export const WrapperRow = ({ wrapper, isShared }: WrapperRowProps) => {><span className="text-foreground-lighter text-nowrap">{metadata.label}:</span><span className="truncate max-w-72" title={serverOptions[metadata.name]}>- {serverOptions[metadata.name]}+ {serverOptions[metadata.name] ?? metadata.defaultValue}</span></div>))}diff --git a/packages/pg-meta/src/sql/studio/database/fdw.ts b/packages/pg-meta/src/sql/studio/database/fdw.tsindex 43e621c7122..dc854a03704 100644--- a/packages/pg-meta/src/sql/studio/database/fdw.ts+++ b/packages/pg-meta/src/sql/studio/database/fdw.ts@@ -13,6 +13,209 @@ type SimplifiedWrapperMeta = {server: { options: { name: string; encrypted: boolean }[] }}+type WrapperExistingTable = {+ id: string | number+ schema: string+ name: string+ columns: { name: string; type: string }[]+ options: string[] | null+}++type WrapperFormTable = {+ schema_name: string+ table_name: string+ columns: { name: string; type: string }[]+ is_new_schema?: boolean+} & Record<string, unknown>++// Old wrappers has an implicit dependency on pgsodium. For new wrappers we use Vault directly.+const LEGACY_WRAPPER_EXTENSION_VERSIONS = [+ '0.1.0',+ '0.1.1',+ '0.1.4',+ '0.1.5',+ '0.1.6',+ '0.1.7',+ '0.1.8',+ '0.1.9',+ '0.1.10',+ '0.1.11',+ '0.1.12',+ '0.1.14',+ '0.1.15',+ '0.1.16',+ '0.1.17',+ '0.1.18',+ '0.1.19',+ '0.2.0',+ '0.3.0',+ '0.3.1',+ '0.4.0',+ '0.4.1',+ '0.4.2',+ '0.4.3',+ '0.4.4',+ '0.4.5',+]++const TABLE_META_KEYS = new Set([+ 'table_name',+ 'schema_name',+ 'schema',+ 'id',+ 'columns',+ 'index',+ 'is_new_schema',+])++const isUsingOldWrappersSql = safeSql`+ (select extversion from pg_extension where extname = 'wrappers') in (${joinSqlFragments(+ LEGACY_WRAPPER_EXTENSION_VERSIONS.map((version) => literal(version)),+ ','+ )})+`++function parseOptionsArray(options?: string[] | null): Record<string, string> {+ return Object.fromEntries(+ (options ?? []).map((entry) => {+ const index = entry.indexOf('=')+ return index === -1 ? [entry, ''] : [entry.slice(0, index), entry.slice(index + 1)]+ })+ )+}++function getTableOptionsMap(table: Record<string, unknown>): Record<string, string> {+ return Object.fromEntries(+ Object.entries(table).filter(([key, value]) => !TABLE_META_KEYS.has(key) && Boolean(value)) as [+ string,+ string,+ ][]+ )+}++function buildCreateForeignTableSql(+ table: {+ schema_name: string+ table_name: string+ columns: { name: string; type: string }[]+ } & Record<string, unknown>,+ serverName: string+): SafeSqlFragment {+ const optionsMap = getTableOptionsMap(table)++ return safeSql`+ create foreign table ${ident(table.schema_name)}.${ident(table.table_name)} (+ ${joinSqlFragments(+ table.columns.map((column) => safeSql`${ident(column.name)} ${keyword(column.type)}`),+ ','+ )}+ )+ server ${ident(serverName)}+ options (+ ${joinSqlFragments(+ Object.entries(optionsMap).map(([key, value]) => safeSql`${ident(key)} ${literal(value)}`),+ ','+ )}+ );+ `+}++function tableKey(schema: string, table: string): string {+ return `${schema}.${table}`+}++// ALTER FOREIGN TABLE doesn't support changing a column's type in place, so a+// retyped column is dropped and re-added with the new type.+function diffTableColumns(+ currentColumns: { name: string; type: string }[],+ desiredColumns: { name: string; type: string }[]+) {+ const currentByName = new Map(currentColumns.map((column) => [column.name, column.type]))+ const desiredByName = new Map(desiredColumns.map((column) => [column.name, column.type]))++ const columnsToAdd = desiredColumns.filter(+ (column) => currentByName.get(column.name) !== column.type+ )+ const columnsToDrop = currentColumns.filter(+ (column) => desiredByName.get(column.name) !== column.type+ )++ return { columnsToAdd, columnsToDrop }+}++function buildOptionsDiffClauses(+ currentOptions: Record<string, string>,+ desiredOptions: Record<string, string>+): SafeSqlFragment[] {+ const clauses: SafeSqlFragment[] = []++ for (const [key, value] of Object.entries(desiredOptions)) {+ if (!(key in currentOptions)) {+ clauses.push(safeSql`add ${ident(key)} ${literal(value)}`)+ } else if (currentOptions[key] !== value) {+ clauses.push(safeSql`set ${ident(key)} ${literal(value)}`)+ }+ }+ for (const key of Object.keys(currentOptions)) {+ if (!(key in desiredOptions)) {+ clauses.push(safeSql`drop ${ident(key)}`)+ }+ }++ return clauses+}++function buildAlterForeignTableSql(+ schema: string,+ table: string,+ current: WrapperExistingTable,+ desired: WrapperFormTable+): SafeSqlFragment {+ const { columnsToAdd, columnsToDrop } = diffTableColumns(current.columns, desired.columns)++ const dropColumnsSql =+ columnsToDrop.length > 0+ ? safeSql`+ alter foreign table ${ident(schema)}.${ident(table)}+ ${joinSqlFragments(+ columnsToDrop.map((column) => safeSql`drop column ${ident(column.name)}`),+ ', '+ )};+ `+ : safeSql``++ const addColumnsSql =+ columnsToAdd.length > 0+ ? safeSql`+ alter foreign table ${ident(schema)}.${ident(table)}+ ${joinSqlFragments(+ columnsToAdd.map(+ (column) => safeSql`add column ${ident(column.name)} ${keyword(column.type)}`+ ),+ ', '+ )};+ `+ : safeSql``++ const optionsClauses = buildOptionsDiffClauses(+ parseOptionsArray(current.options),+ getTableOptionsMap(desired)+ )+ const optionsSql =+ optionsClauses.length > 0+ ? safeSql`+ alter foreign table ${ident(schema)}.${ident(table)}+ options (${joinSqlFragments(optionsClauses, ', ')});+ `+ : safeSql``++ return safeSql`+ ${dropColumnsSql}+ ${addColumnsSql}+ ${optionsSql}+ `+}+export const getFDWsSql = (): SafeSqlFragment => {const sql = safeSql`select@@ -100,36 +303,7 @@ export function getCreateFDWSql({return safeSql`do $$begin- -- Old wrappers has an implicit dependency on pgsodium. For new wrappers- -- we use Vault directly.- if (select extversion from pg_extension where extname = 'wrappers') in (- '0.1.0',- '0.1.1',- '0.1.4',- '0.1.5',- '0.1.6',- '0.1.7',- '0.1.8',- '0.1.9',- '0.1.10',- '0.1.11',- '0.1.12',- '0.1.14',- '0.1.15',- '0.1.16',- '0.1.17',- '0.1.18',- '0.1.19',- '0.2.0',- '0.3.0',- '0.3.1',- '0.4.0',- '0.4.1',- '0.4.2',- '0.4.3',- '0.4.4',- '0.4.5'- ) then+ if ${isUsingOldWrappersSql} thencreate extension if not exists pgsodium;perform pgsodium.create_key(@@ -180,34 +354,7 @@ export function getCreateFDWSql({'\n')}begin- is_using_old_wrappers := (select extversion from pg_extension where extname = 'wrappers') in (- '0.1.0',- '0.1.1',- '0.1.4',- '0.1.5',- '0.1.6',- '0.1.7',- '0.1.8',- '0.1.9',- '0.1.10',- '0.1.11',- '0.1.12',- '0.1.14',- '0.1.15',- '0.1.16',- '0.1.17',- '0.1.18',- '0.1.19',- '0.2.0',- '0.3.0',- '0.3.1',- '0.4.0',- '0.4.1',- '0.4.2',- '0.4.3',- '0.4.4',- '0.4.5'- );+ is_using_old_wrappers := ${isUsingOldWrappersSql};${joinSqlFragments(encryptedOptions.map((option) => safeSql`@@ -237,37 +384,7 @@ export function getCreateFDWSql({`const createTablesSql = joinSqlFragments(- tables.map((newTable) => {- const columns = newTable.columns-- return safeSql`- create foreign table ${ident(newTable.schema_name)}.${ident(newTable.table_name)} (- ${joinSqlFragments(- columns.map((column) => safeSql`${ident(column.name)} ${keyword(column.type)}`),- ','- )}- )- server ${ident(formState.server_name)}- options (- ${joinSqlFragments(- Object.entries(newTable)- .filter(- ([key, value]) =>- key !== 'table_name' &&- key !== 'schema_name' &&- key !== 'schema' &&- key !== 'id' &&- key !== 'columns' &&- key !== 'index' &&- key !== 'is_new_schema' &&- Boolean(value)- )- .map(([key, value]) => safeSql`${ident(key)} ${literal(value)}`),- ','- )}- );- `- }),+ tables.map((newTable) => buildCreateForeignTableSql(newTable, formState.server_name)),'\n\n')@@ -314,36 +431,7 @@ export const getDeleteFDWSql = ({if not exists (select 1 from pg_catalog.pg_foreign_data_wrapper where fdwname = ${literal(wrapper.name)}) then- -- Old wrappers has an implicit dependency on pgsodium. For new wrappers- -- we use Vault directly.- if (select extversion from pg_extension where extname = 'wrappers') in (- '0.1.0',- '0.1.1',- '0.1.4',- '0.1.5',- '0.1.6',- '0.1.7',- '0.1.8',- '0.1.9',- '0.1.10',- '0.1.11',- '0.1.12',- '0.1.14',- '0.1.15',- '0.1.16',- '0.1.17',- '0.1.18',- '0.1.19',- '0.2.0',- '0.3.0',- '0.3.1',- '0.4.0',- '0.4.1',- '0.4.2',- '0.4.3',- '0.4.4',- '0.4.5'- ) then+ if ${isUsingOldWrappersSql} thendelete from vault.secrets where key_id = (select id from pgsodium.valid_key where name = ${literal(key)});delete from pgsodium.key where name = ${literal(key)};@@ -401,10 +489,16 @@ export const getUpdateFDWSql = ({formState,tables,}: {- wrapper: { id: number; name: string; server_name: string }+ wrapper: {+ id: number+ name: string+ server_name: string+ server_options?: string[] | null+ tables?: WrapperExistingTable[] | null+ }wrapperMeta: SimplifiedWrapperMetaformState: { [k: string]: string }- tables: any[]+ tables: WrapperFormTable[]}): SafeSqlFragment => {const ensureWrapperIsNotSharedSql = safeSql`do $$@@ -420,22 +514,176 @@ export const getUpdateFDWSql = ({end if;end $$;`- const deleteWrapperSql = getDeleteFDWSql({ wrapper, wrapperMeta })- const createWrapperSql = getCreateFDWSql({- wrapperMeta,- formState,- tables,- mode: 'tables',- sourceSchema: '',- targetSchema: '',- })- const sql = safeSql`- ${ensureWrapperIsNotSharedSql}+ const nameChanged = formState.wrapper_name !== wrapper.name+ const renameWrapperSql = nameChanged+ ? safeSql`alter foreign data wrapper ${ident(wrapper.name)} rename to ${ident(formState.wrapper_name)};`+ : safeSql``- ${deleteWrapperSql}+ // formState.server_name is never actually re-derived from wrapper_name before+ // submit (see EditWrapperSheet), so the server itself is never renamed here -+ // wrapper.server_name (the real, current name) is the only name we alter/target.+ const encryptedOptions = wrapperMeta.server.options.filter((option) => option.encrypted)+ const unencryptedOptions = wrapperMeta.server.options.filter((option) => !option.encrypted)+ const currentServerOptions = parseOptionsArray(wrapper.server_options)++ const serverOptionClauses: SafeSqlFragment[] = []+ const encryptedOptionSqlArray: SafeSqlFragment[] = []++ for (const option of unencryptedOptions) {+ const currentValue = currentServerOptions[option.name]+ const newValue = formState[option.name]++ if (newValue) {+ if (currentValue === undefined) {+ serverOptionClauses.push(safeSql`add ${ident(option.name)} ${literal(newValue)}`)+ } else if (currentValue !== newValue) {+ serverOptionClauses.push(safeSql`set ${ident(option.name)} ${literal(newValue)}`)+ }+ } else if (currentValue !== undefined) {+ serverOptionClauses.push(safeSql`drop ${ident(option.name)}`)+ }+ }- ${createWrapperSql}+ for (const option of encryptedOptions) {+ const existingSecretId = currentServerOptions[option.name]+ const newValue = formState[option.name]+ const newSecretName = `${formState.wrapper_name}_${option.name}`++ if (newValue && existingSecretId !== undefined) {+ // Secret already exists: update its value (and name, in case the wrapper+ // was renamed) in place instead of deleting and recreating it.+ encryptedOptionSqlArray.push(safeSql`+ do $$+ declare+ v_secret_id uuid;+ begin+ if ${isUsingOldWrappersSql} then+ select id into v_secret_id from vault.secrets where key_id = ${literal(existingSecretId)} limit 1;+ else+ v_secret_id := ${literal(existingSecretId)}::uuid;+ end if;++ perform vault.update_secret(+ secret_id := v_secret_id,+ new_secret := ${literal(newValue)},+ new_name := ${literal(newSecretName)}+ );+ end $$;+ `)+ } else if (newValue && existingSecretId === undefined) {+ // Option newly populated: create the secret then wire it up as a server option.+ encryptedOptionSqlArray.push(safeSql`+ do $$+ begin+ if ${isUsingOldWrappersSql} then+ create extension if not exists pgsodium;++ perform pgsodium.create_key(name := ${literal(newSecretName)});++ perform vault.create_secret(+ new_secret := ${literal(newValue)},+ new_name := ${literal(newSecretName)},+ new_key_id := (select id from pgsodium.valid_key where name = ${literal(newSecretName)})+ );+ else+ perform vault.create_secret(+ new_secret := ${literal(newValue)},+ new_name := ${literal(newSecretName)}+ );+ end if;+ end $$;++ do $$+ declare+ v_secret_ref text;+ begin+ if ${isUsingOldWrappersSql} then+ select id::text into v_secret_ref from pgsodium.valid_key where name = ${literal(newSecretName)} limit 1;+ else+ select id::text into v_secret_ref from vault.secrets where name = ${literal(newSecretName)} limit 1;+ end if;++ execute format('alter server ${ident(wrapper.server_name)} options (add ${ident(option.name)} %L)', v_secret_ref);+ end $$;+ `)+ } else if (!newValue && existingSecretId !== undefined) {+ // Option cleared: drop the server option and delete the now-orphaned secret.+ serverOptionClauses.push(safeSql`drop ${ident(option.name)}`)+ encryptedOptionSqlArray.push(safeSql`+ do $$+ begin+ if ${isUsingOldWrappersSql} then+ delete from vault.secrets where key_id = ${literal(existingSecretId)};+ delete from pgsodium.key where id = ${literal(existingSecretId)};+ else+ delete from vault.secrets where id = ${literal(existingSecretId)}::uuid;+ end if;+ end $$;+ `)+ }+ }++ const alterServerOptionsSql =+ serverOptionClauses.length > 0+ ? safeSql`+ alter server ${ident(wrapper.server_name)}+ options (${joinSqlFragments(serverOptionClauses, ', ')});+ `+ : safeSql``+ const encryptedOptionsSql = joinSqlFragments(encryptedOptionSqlArray, '\n')++ const currentTables = wrapper.tables ?? []+ const currentTableByKey = new Map(+ currentTables.map((table) => [tableKey(table.schema, table.name), table])+ )+ const desiredTableByKey = new Map(+ tables.map((table) => [tableKey(table.schema_name, table.table_name), table])+ )++ const tablesToCreate = tables.filter(+ (table) => !currentTableByKey.has(tableKey(table.schema_name, table.table_name))+ )+ const tablesToDrop = currentTables.filter(+ (table) => !desiredTableByKey.has(tableKey(table.schema, table.name))+ )++ const newSchemasSql = joinSqlFragments(+ tablesToCreate+ .filter((table) => table.is_new_schema)+ .map((table) => safeSql`create schema if not exists ${ident(table.schema_name)};`),+ '\n'+ )+ const createTablesSql = joinSqlFragments(+ tablesToCreate.map((table) => buildCreateForeignTableSql(table, wrapper.server_name)),+ '\n'+ )+ const dropTablesSql = joinSqlFragments(+ tablesToDrop.map((table) =>+ getDropForeignTableSql({ schema: table.schema, table: table.name })+ ),+ '\n'+ )+ const alterTablesSql = joinSqlFragments(+ tables+ .map((desired) => {+ const current = currentTableByKey.get(tableKey(desired.schema_name, desired.table_name))+ if (!current) return null+ return buildAlterForeignTableSql(desired.schema_name, desired.table_name, current, desired)+ })+ .filter((sql): sql is SafeSqlFragment => sql !== null),+ '\n'+ )++ const sql = safeSql`+ ${ensureWrapperIsNotSharedSql}+ ${renameWrapperSql}+ ${alterServerOptionsSql}+ ${encryptedOptionsSql}+ ${newSchemasSql}+ ${dropTablesSql}+ ${createTablesSql}+ ${alterTablesSql}`return sqldiff --git a/packages/pg-meta/test/sql/studio/fdw.test.ts b/packages/pg-meta/test/sql/studio/fdw.test.tsindex 741c6f9c3de..b850337a672 100644--- a/packages/pg-meta/test/sql/studio/fdw.test.ts+++ b/packages/pg-meta/test/sql/studio/fdw.test.ts@@ -76,20 +76,258 @@ test('deleting a wrapper row drops its server and preserves shared wrapper depenexpect(sql).toContain("where fdwname = 'bigquery_fdw'")})-test('editing a shared wrapper fails before any server is dropped', () => {+test('editing a shared wrapper fails before any other statement runs', () => {const sql = getUpdateFDWSql({- wrapper: { id: 42, name: 'bigquery_fdw', server_name: 'selected_bigquery_server' },+ wrapper: {+ id: 42,+ name: 'bigquery_fdw',+ server_name: 'selected_bigquery_server',+ server_options: ['project_id=old-project'],+ },wrapperMeta: {handlerName: 'big_query_fdw_handler',validatorName: 'big_query_fdw_validator',- server: { options: [] },+ server: { options: [{ name: 'project_id', encrypted: false }] },+ },+ formState: {+ wrapper_name: 'bigquery_fdw',+ server_name: 'selected_bigquery_server',+ project_id: 'new-project',},- formState: { wrapper_name: 'bigquery_fdw', server_name: 'selected_bigquery_server' },tables: [],})expect(sql).toContain("s.srvname <> 'selected_bigquery_server'")- expect(sql.indexOf('raise exception')).toBeLessThan(sql.indexOf('drop server'))+ expect(sql.indexOf('raise exception')).toBeLessThan(sql.indexOf('alter server'))+})++test('updating a wrapper alters the server and FDW instead of dropping and recreating them', () => {+ const sql = getUpdateFDWSql({+ wrapper: {+ id: 42,+ name: 'bigquery_fdw',+ server_name: 'bigquery_server',+ server_options: ['project_id=old-project'],+ tables: [],+ },+ wrapperMeta: {+ handlerName: 'big_query_fdw_handler',+ validatorName: 'big_query_fdw_validator',+ server: { options: [{ name: 'project_id', encrypted: false }] },+ },+ formState: {+ wrapper_name: 'bigquery_fdw',+ server_name: 'bigquery_server',+ project_id: 'new-project',+ },+ tables: [],+ })++ expect(sql).toContain(+ "alter server bigquery_server\n options (set project_id 'new-project')"+ )+ expect(sql).not.toContain('drop server')+ expect(sql).not.toContain('drop foreign data wrapper')+ expect(sql).not.toContain('create foreign data wrapper')+})++test('renaming the wrapper name only renames the FDW, not the server', () => {+ const sql = getUpdateFDWSql({+ wrapper: {+ id: 42,+ name: 'old_wrapper',+ server_name: 'old_wrapper_server',+ server_options: [],+ tables: [],+ },+ wrapperMeta: {+ handlerName: 'big_query_fdw_handler',+ validatorName: 'big_query_fdw_validator',+ server: { options: [] },+ },+ formState: {+ wrapper_name: 'new_wrapper',+ server_name: 'old_wrapper_server',+ },+ tables: [],+ })++ expect(sql).toContain('alter foreign data wrapper old_wrapper rename to new_wrapper')+ expect(sql).not.toContain('rename to new_wrapper_server')+})++test('adding a server option not previously set uses ADD, not SET', () => {+ const sql = getUpdateFDWSql({+ wrapper: {+ id: 42,+ name: 'bigquery_fdw',+ server_name: 'bigquery_server',+ server_options: [],+ tables: [],+ },+ wrapperMeta: {+ handlerName: 'big_query_fdw_handler',+ validatorName: 'big_query_fdw_validator',+ server: { options: [{ name: 'project_id', encrypted: false }] },+ },+ formState: {+ wrapper_name: 'bigquery_fdw',+ server_name: 'bigquery_server',+ project_id: 'a-project',+ },+ tables: [],+ })++ expect(sql).toContain("add project_id 'a-project'")+})++test('clearing a server option uses DROP', () => {+ const sql = getUpdateFDWSql({+ wrapper: {+ id: 42,+ name: 'bigquery_fdw',+ server_name: 'bigquery_server',+ server_options: ['project_id=a-project'],+ tables: [],+ },+ wrapperMeta: {+ handlerName: 'big_query_fdw_handler',+ validatorName: 'big_query_fdw_validator',+ server: { options: [{ name: 'project_id', encrypted: false }] },+ },+ formState: {+ wrapper_name: 'bigquery_fdw',+ server_name: 'bigquery_server',+ project_id: '',+ },+ tables: [],+ })++ expect(sql).toContain('drop project_id')+})++test('an encrypted option that already has a secret is updated in place via vault.update_secret', () => {+ const sql = getUpdateFDWSql({+ wrapper: {+ id: 42,+ name: 'bigquery_fdw',+ server_name: 'bigquery_server',+ server_options: ['sa_key_id=123e4567-e89b-12d3-a456-426614174000'],+ tables: [],+ },+ wrapperMeta: {+ handlerName: 'big_query_fdw_handler',+ validatorName: 'big_query_fdw_validator',+ server: { options: [{ name: 'sa_key_id', encrypted: true }] },+ },+ formState: {+ wrapper_name: 'bigquery_fdw',+ server_name: 'bigquery_server',+ sa_key_id: 'new-secret-value',+ },+ tables: [],+ })++ expect(sql).toContain('vault.update_secret')+ expect(sql).not.toContain('vault.create_secret')+ expect(sql).not.toContain('delete from vault.secrets')+})++test('foreign table diffing: creates new tables, drops removed tables, and skips unchanged tables', () => {+ const sql = getUpdateFDWSql({+ wrapper: {+ id: 42,+ name: 'bigquery_fdw',+ server_name: 'bigquery_server',+ server_options: [],+ tables: [+ {+ id: 1,+ schema: 'public',+ name: 'unchanged_table',+ columns: [{ name: 'id', type: 'text' }],+ options: ['table=unchanged_table'],+ },+ {+ id: 2,+ schema: 'public',+ name: 'removed_table',+ columns: [{ name: 'id', type: 'text' }],+ options: ['table=removed_table'],+ },+ ],+ },+ wrapperMeta: {+ handlerName: 'big_query_fdw_handler',+ validatorName: 'big_query_fdw_validator',+ server: { options: [] },+ },+ formState: {+ wrapper_name: 'bigquery_fdw',+ server_name: 'bigquery_server',+ },+ tables: [+ {+ schema_name: 'public',+ table_name: 'unchanged_table',+ columns: [{ name: 'id', type: 'text' }],+ is_new_schema: false,+ table: 'unchanged_table',+ },+ {+ schema_name: 'public',+ table_name: 'new_table',+ columns: [{ name: 'id', type: 'text' }],+ is_new_schema: false,+ table: 'new_table',+ },+ ],+ })++ expect(sql).toContain('create foreign table public.new_table')+ expect(sql).toContain('drop foreign table if exists public.removed_table')+ expect(sql).not.toContain('unchanged_table (')+ expect(sql).not.toContain('drop foreign table if exists public.unchanged_table')+})++test('foreign table diffing: retyping a column drops and re-adds it, since ALTER COLUMN TYPE is unsupported for foreign tables', () => {+ const sql = getUpdateFDWSql({+ wrapper: {+ id: 42,+ name: 'bigquery_fdw',+ server_name: 'bigquery_server',+ server_options: [],+ tables: [+ {+ id: 1,+ schema: 'public',+ name: 'orders',+ columns: [{ name: 'amount', type: 'integer' }],+ options: [],+ },+ ],+ },+ wrapperMeta: {+ handlerName: 'big_query_fdw_handler',+ validatorName: 'big_query_fdw_validator',+ server: { options: [] },+ },+ formState: {+ wrapper_name: 'bigquery_fdw',+ server_name: 'bigquery_server',+ },+ tables: [+ {+ schema_name: 'public',+ table_name: 'orders',+ columns: [{ name: 'amount', type: 'numeric' }],+ is_new_schema: false,+ },+ ],+ })++ expect(sql).toContain('alter foreign table public.orders\n drop column amount')+ expect(sql).toContain('alter foreign table public.orders\n add column amount numeric')})test('editing an existing foreign table excludes catalog fields from its options', () => {