Skip to content

The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.

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.tsx
index 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.tsx
index 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) return
encryptedOptions.forEach((option) => {
const encryptedId = initialValues[option.name]
resetField(option.name, { defaultValue: decryptedValues[encryptedId] })
})
+ setSecretsReady(true)
} catch (error) {
+ if (!isCurrent) return
toast.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
+ <ButtonTooltip
size="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 = ({
<ConfirmationModal
visible={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.tsx
index 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: ServerOption
control: 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.tsx
index 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.ts
index 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} then
create 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} then
delete 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: SimplifiedWrapperMeta
formState: { [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 sql
diff --git a/packages/pg-meta/test/sql/studio/fdw.test.ts b/packages/pg-meta/test/sql/studio/fdw.test.ts
index 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 depen
expect(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', () => {