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 nameChanged = formState.wrapper_name !== wrapper.name
+  const renameWrapperSql = nameChanged
+    ? safeSql`alter foreign data wrapper ${ident(wrapper.name)} rename to ${ident(formState.wrapper_name)};`
+    : safeSql``
+
+  // 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)}`)
+    }
+  }
+
+  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}
-
-    ${deleteWrapperSql}
-
-    ${createWrapperSql}
+    ${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: [{ name: 'project_id', encrypted: false }] },
+    },
+    formState: {
+      wrapper_name: 'bigquery_fdw',
+      server_name: 'selected_bigquery_server',
+      project_id: 'new-project',
+    },
+    tables: [],
+  })
+
+  expect(sql).toContain("s.srvname <> 'selected_bigquery_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: 'bigquery_fdw', server_name: 'selected_bigquery_server' },
+    formState: {
+      wrapper_name: 'new_wrapper',
+      server_name: 'old_wrapper_server',
+    },
     tables: [],
   })
 
-  expect(sql).toContain("s.srvname <> 'selected_bigquery_server'")
-  expect(sql.indexOf('raise exception')).toBeLessThan(sql.indexOf('drop server'))
+  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', () => {