diff --git a/apps/desktop/src/App.vue b/apps/desktop/src/App.vue
index 02764afa64..528c99f0bc 100644
--- a/apps/desktop/src/App.vue
+++ b/apps/desktop/src/App.vue
@@ -264,6 +264,9 @@ const {
   sqlParameterNames,
   sqlParameterDatabaseType,
   sqlParameterEnabledSyntaxes,
+  sqlParameterReplaceInsideQuotes,
+  sqlParameterAnsiQuotes,
+  sqlParameterNoBackslashEscapes,
   onSqlParametersConfirm,
   explainMode,
 } = useSqlExecution({
@@ -2202,6 +2205,9 @@ onUnmounted(() => {
           :sql-parameter-names="sqlParameterNames"
           :sql-parameter-database-type="sqlParameterDatabaseType"
           :sql-parameter-enabled-syntaxes="sqlParameterEnabledSyntaxes"
+          :sql-parameter-replace-inside-quotes="sqlParameterReplaceInsideQuotes"
+          :sql-parameter-ansi-quotes="sqlParameterAnsiQuotes"
+          :sql-parameter-no-backslash-escapes="sqlParameterNoBackslashEscapes"
           @update:show-connection-dialog="setConnectionDialogOpen"
           @update:show-danger-dialog="showDangerDialog = $event"
           @update:suppress-danger-confirm="suppressDangerConfirm = $event"
diff --git a/apps/desktop/src/components/editor/EditorSettingsDialog.vue b/apps/desktop/src/components/editor/EditorSettingsDialog.vue
index df5ccd4b3e..ca02024c03 100644
--- a/apps/desktop/src/components/editor/EditorSettingsDialog.vue
+++ b/apps/desktop/src/components/editor/EditorSettingsDialog.vue
@@ -94,7 +94,16 @@ import { validateConfigName, generateId, type AiConfigItem, type ConfigNameValid
 import { currentExecutableStatementRange, type SqlTextRange } from "@/lib/sql/sqlStatementRanges";
 import { executableStatementRangeCacheForDoc, executableStatementRangeStartingAt, type ExecutableStatementRangeCache } from "@/lib/sql/executableStatementRangeCache";
 import { EMPTY_TABLE_COLUMN_TEMPLATE_DATA_TYPE, parseTableColumnTemplateFields, TABLE_COLUMN_TEMPLATE_DATABASE_TYPES } from "@/lib/table/tableColumnTemplates";
-import { DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES, normalizeSqlVariableSyntaxOverrides, SQL_VARIABLE_SYNTAX_DATABASE_TYPES, SQL_VARIABLE_SYNTAX_KEYS, SQL_VARIABLE_SYNTAX_TOKENS, type SqlVariableSyntaxOverrides, type SqlVariableSyntaxToggles } from "@/lib/sql/sqlVariableSyntax";
+import {
+  DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES,
+  normalizeSqlVariableSyntaxOverrides,
+  SQL_VARIABLE_SYNTAX_DATABASE_TYPES,
+  SQL_VARIABLE_SYNTAX_KEYS,
+  SQL_VARIABLE_SYNTAX_TOKENS,
+  sqlVariableSyntaxKeysForDatabase,
+  type SqlVariableSyntaxOverrides,
+  type SqlVariableSyntaxToggles,
+} from "@/lib/sql/sqlVariableSyntax";
 import { buildMcpCodexConfig, buildMcpJsonConfig, buildMcpOpenCodeConfig, buildMcpVsCodeConfig, type McpEnvEntry, type McpLaunchConfig } from "@/lib/mcp/mcpConfigTemplates";
 import { isMacOS } from "@/lib/backend/platform";
 import { combineDataTypeForDatabase, dataTypeLengthInputValue, getDataTypeOptions, getDefaultLengthForType, isDataTypeLengthDisabled, splitDataType } from "@/lib/table/tableStructureEditorState";
@@ -302,9 +311,10 @@ const editTableColumnTemplateRows = ref<TableColumnTemplateGridRow[]>(tableColum
 const editTableColumnTemplateDatabaseType = ref<DatabaseType>(TABLE_COLUMN_TEMPLATE_DATABASE_TYPES[0] ?? "mysql");
 const editSqlVariableSyntaxOverrides = ref<SqlVariableSyntaxOverrides>(normalizeSqlVariableSyntaxOverrides(settingsStore.editorSettings.sqlVariableSyntaxOverrides));
 const editSqlVariableSyntaxDatabaseType = ref<DatabaseType>(SQL_VARIABLE_SYNTAX_DATABASE_TYPES[0] ?? "mysql");
+const visibleSqlVariableSyntaxKeys = computed(() => sqlVariableSyntaxKeysForDatabase(editSqlVariableSyntaxDatabaseType.value));
 
 function sqlVariableSyntaxToggle(key: keyof SqlVariableSyntaxToggles): boolean {
-  return editSqlVariableSyntaxOverrides.value[editSqlVariableSyntaxDatabaseType.value]?.[key] ?? true;
+  return editSqlVariableSyntaxOverrides.value[editSqlVariableSyntaxDatabaseType.value]?.[key] ?? DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES[key];
 }
 
 function setSqlVariableSyntaxToggle(key: keyof SqlVariableSyntaxToggles, value: boolean) {
@@ -315,13 +325,13 @@ function setSqlVariableSyntaxToggle(key: keyof SqlVariableSyntaxToggles, value:
     [key]: value,
   };
   const next: SqlVariableSyntaxOverrides = { ...editSqlVariableSyntaxOverrides.value };
-  // Keep storage sparse: an all-enabled type has no entry; otherwise persist only the disabled syntaxes.
-  if (SQL_VARIABLE_SYNTAX_KEYS.every((toggleKey) => merged[toggleKey])) {
+  // Keep storage sparse while preserving the opt-in setting whose default is false.
+  if (SQL_VARIABLE_SYNTAX_KEYS.every((toggleKey) => merged[toggleKey] === DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES[toggleKey])) {
     delete next[dbType];
   } else {
     const partial: Partial<SqlVariableSyntaxToggles> = {};
     for (const toggleKey of SQL_VARIABLE_SYNTAX_KEYS) {
-      if (!merged[toggleKey]) partial[toggleKey] = false;
+      if (merged[toggleKey] !== DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES[toggleKey]) partial[toggleKey] = merged[toggleKey];
     }
     next[dbType] = partial;
   }
@@ -3107,7 +3117,7 @@ onUnmounted(cleanupPreviewEditor);
                   </Select>
                 </div>
                 <div class="grid gap-3 md:grid-cols-2">
-                  <div v-for="key in SQL_VARIABLE_SYNTAX_KEYS" :key="key" class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
+                  <div v-for="key in visibleSqlVariableSyntaxKeys" :key="key" class="flex items-center justify-between gap-4 rounded-md border bg-muted/20 px-3 py-2">
                     <div class="min-w-0 space-y-1">
                       <Label :for="`sql-var-syntax-${key}`" class="flex items-center gap-1.5">
                         <span class="font-mono text-xs text-primary">{{ SQL_VARIABLE_SYNTAX_TOKENS[key] }}</span>
diff --git a/apps/desktop/src/components/editor/SqlParameterDialog.vue b/apps/desktop/src/components/editor/SqlParameterDialog.vue
index 310796f841..77778cd994 100644
--- a/apps/desktop/src/components/editor/SqlParameterDialog.vue
+++ b/apps/desktop/src/components/editor/SqlParameterDialog.vue
@@ -26,6 +26,9 @@ const props = defineProps<{
   parameters: SqlParameterDescriptor[];
   databaseType?: DatabaseType;
   enabledSyntaxes?: SqlParameterSyntax[];
+  replaceInsideQuotes?: boolean;
+  ansiQuotes?: boolean;
+  noBackslashEscapes?: boolean;
 }>();
 
 const emit = defineEmits<{
@@ -47,7 +50,15 @@ const syntaxLabels: Record<SqlParameterSyntax, string> = {
   sqlserver: "@name",
 };
 
-const resolvedSql = computed(() => substituteSqlParameters(props.sql, values.value, { databaseType: props.databaseType, enabledSyntaxes: props.enabledSyntaxes }));
+const resolvedSql = computed(() =>
+  substituteSqlParameters(props.sql, values.value, {
+    databaseType: props.databaseType,
+    enabledSyntaxes: props.enabledSyntaxes,
+    replaceInsideQuotes: props.replaceInsideQuotes,
+    ansiQuotes: props.ansiQuotes,
+    noBackslashEscapes: props.noBackslashEscapes,
+  }),
+);
 const highlightedSql = computed(() => highlight(resolvedSql.value));
 
 watch(
diff --git a/apps/desktop/src/components/layout/AppDialogs.vue b/apps/desktop/src/components/layout/AppDialogs.vue
index a050483823..d4762c12e8 100644
--- a/apps/desktop/src/components/layout/AppDialogs.vue
+++ b/apps/desktop/src/components/layout/AppDialogs.vue
@@ -38,6 +38,9 @@ const props = defineProps<{
   sqlParameterNames: SqlParameterDescriptor[];
   sqlParameterDatabaseType?: DatabaseType;
   sqlParameterEnabledSyntaxes?: SqlParameterSyntax[];
+  sqlParameterReplaceInsideQuotes?: boolean;
+  sqlParameterAnsiQuotes?: boolean;
+  sqlParameterNoBackslashEscapes?: boolean;
 }>();
 
 const emit = defineEmits<{
@@ -169,6 +172,9 @@ watch(
     :parameters="sqlParameterNames"
     :database-type="sqlParameterDatabaseType"
     :enabled-syntaxes="sqlParameterEnabledSyntaxes"
+    :replace-inside-quotes="sqlParameterReplaceInsideQuotes"
+    :ansi-quotes="sqlParameterAnsiQuotes"
+    :no-backslash-escapes="sqlParameterNoBackslashEscapes"
     @update:open="emit('update:showSqlParameterDialog', $event)"
     @execute="emit('sqlParametersConfirm', $event)"
   />
diff --git a/apps/desktop/src/composables/__tests__/useSqlExecution.spec.ts b/apps/desktop/src/composables/__tests__/useSqlExecution.spec.ts
index 28a39b698b..734a223f0b 100644
--- a/apps/desktop/src/composables/__tests__/useSqlExecution.spec.ts
+++ b/apps/desktop/src/composables/__tests__/useSqlExecution.spec.ts
@@ -179,6 +179,58 @@ describe("useSqlExecution", () => {
     expect(executedSql).toContain("where fp.create_at < @date_start");
   });
 
+  it("keeps quoted braced placeholders unchanged when interpolation is not configured", async () => {
+    const sql = "select 'C:\\', '${date_end}'";
+    const activeTab = ref<QueryTab | undefined>(queryTab("app"));
+    const activeConnection = ref<ConnectionConfig | undefined>(connection("mysql"));
+    const activeOutputView = ref<"result" | "summary" | "explain" | "chart">("result");
+    const queryStore = useQueryStore();
+    const executeCurrentSql = vi.spyOn(queryStore, "executeCurrentSql").mockImplementation(async () => {
+      if (activeTab.value) activeTab.value.result = { columns: ["value"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 };
+    });
+    vi.spyOn(useHistoryStore(), "add").mockResolvedValue(undefined);
+    useSettingsStore().editorSettings.sqlVariableSyntaxOverrides = { mysql: { noBackslashEscapes: true } };
+
+    const execution = useSqlExecution({
+      activeTab: computed(() => activeTab.value),
+      activeConnection: computed(() => activeConnection.value),
+      executableSql: computed(() => sql),
+      activeOutputView,
+    });
+
+    await execution.tryExecute();
+
+    expect(execution.showSqlParameterDialog.value).toBe(false);
+    expect(executeCurrentSql).toHaveBeenCalledWith(sql, {});
+  });
+
+  it("opens the parameter dialog for quoted braced placeholders after per-database opt-in", async () => {
+    const sql = "select '${date_end}', '#{status}'";
+    const activeTab = ref<QueryTab | undefined>(queryTab("app"));
+    const activeConnection = ref<ConnectionConfig | undefined>(connection("mysql"));
+    const activeOutputView = ref<"result" | "summary" | "explain" | "chart">("result");
+    const queryStore = useQueryStore();
+    const executeCurrentSql = vi.spyOn(queryStore, "executeCurrentSql").mockResolvedValue(undefined);
+    vi.spyOn(useHistoryStore(), "add").mockResolvedValue(undefined);
+    useSettingsStore().editorSettings.sqlVariableSyntaxOverrides = { mysql: { replaceInsideQuotes: true, ansiQuotes: true, noBackslashEscapes: true } };
+
+    const execution = useSqlExecution({
+      activeTab: computed(() => activeTab.value),
+      activeConnection: computed(() => activeConnection.value),
+      executableSql: computed(() => sql),
+      activeOutputView,
+    });
+
+    await execution.tryExecute();
+
+    expect(execution.showSqlParameterDialog.value).toBe(true);
+    expect(execution.sqlParameterNames.value.map((parameter) => parameter.name)).toEqual(["date_end", "status"]);
+    expect(execution.sqlParameterReplaceInsideQuotes.value).toBe(true);
+    expect(execution.sqlParameterAnsiQuotes.value).toBe(true);
+    expect(execution.sqlParameterNoBackslashEscapes.value).toBe(true);
+    expect(executeCurrentSql).not.toHaveBeenCalled();
+  });
+
   it("sends Doris STRUCT DDL unchanged without opening the parameter dialog", async () => {
     const sql = `
       create table \`events\` (
diff --git a/apps/desktop/src/composables/useSqlExecution.ts b/apps/desktop/src/composables/useSqlExecution.ts
index 42de97b4da..bc5c47c78c 100644
--- a/apps/desktop/src/composables/useSqlExecution.ts
+++ b/apps/desktop/src/composables/useSqlExecution.ts
@@ -96,6 +96,9 @@ export function useSqlExecution(deps: {
   const sqlParameterNames = ref<SqlParameterDescriptor[]>([]);
   const sqlParameterDatabaseType = ref<DatabaseType | undefined>();
   const sqlParameterEnabledSyntaxes = ref<SqlParameterSyntax[]>([]);
+  const sqlParameterReplaceInsideQuotes = ref(false);
+  const sqlParameterAnsiQuotes = ref(false);
+  const sqlParameterNoBackslashEscapes = ref(false);
   const pendingSourceOffset = ref<number | undefined>();
 
   async function resolvedExecutableSql(source?: SqlExecutionOverride): Promise<{ sql: string; sourceOffset?: number }> {
@@ -166,12 +169,21 @@ export function useSqlExecution(deps: {
     const databaseType = deps.activeConnection.value?.db_type;
     const toggles = resolveSqlVariableSyntaxToggles(settingsStore.editorSettings.sqlVariableSyntaxOverrides, databaseType);
     const enabledSyntaxes = enabledSqlParameterSyntaxes(toggles);
-    const parameters = extractSqlParameterDescriptors(sql, { databaseType, enabledSyntaxes });
+    const parameters = extractSqlParameterDescriptors(sql, {
+      databaseType,
+      enabledSyntaxes,
+      replaceInsideQuotes: toggles.replaceInsideQuotes,
+      ansiQuotes: toggles.ansiQuotes,
+      noBackslashEscapes: toggles.noBackslashEscapes,
+    });
     if (!parameters.length) return false;
     sqlParameterSourceSql.value = sql;
     sqlParameterNames.value = parameters;
     sqlParameterDatabaseType.value = databaseType;
     sqlParameterEnabledSyntaxes.value = enabledSyntaxes;
+    sqlParameterReplaceInsideQuotes.value = toggles.replaceInsideQuotes;
+    sqlParameterAnsiQuotes.value = toggles.ansiQuotes;
+    sqlParameterNoBackslashEscapes.value = toggles.noBackslashEscapes;
     pendingSourceOffset.value = sourceOffset;
     showSqlParameterDialog.value = true;
     return true;
@@ -272,6 +284,9 @@ export function useSqlExecution(deps: {
     sqlParameterNames.value = [];
     sqlParameterDatabaseType.value = undefined;
     sqlParameterEnabledSyntaxes.value = [];
+    sqlParameterReplaceInsideQuotes.value = false;
+    sqlParameterAnsiQuotes.value = false;
+    sqlParameterNoBackslashEscapes.value = false;
     const sourceOffset = pendingSourceOffset.value;
     pendingSourceOffset.value = undefined;
     await continueExecute(sql, sourceOffset);
@@ -283,6 +298,9 @@ export function useSqlExecution(deps: {
     sqlParameterNames.value = [];
     sqlParameterDatabaseType.value = undefined;
     sqlParameterEnabledSyntaxes.value = [];
+    sqlParameterReplaceInsideQuotes.value = false;
+    sqlParameterAnsiQuotes.value = false;
+    sqlParameterNoBackslashEscapes.value = false;
     pendingSourceOffset.value = undefined;
   });
 
@@ -301,6 +319,9 @@ export function useSqlExecution(deps: {
     sqlParameterNames,
     sqlParameterDatabaseType,
     sqlParameterEnabledSyntaxes,
+    sqlParameterReplaceInsideQuotes,
+    sqlParameterAnsiQuotes,
+    sqlParameterNoBackslashEscapes,
     onSqlParametersConfirm,
     explainMode,
   };
diff --git a/apps/desktop/src/i18n/locales/en.ts b/apps/desktop/src/i18n/locales/en.ts
index 9367196c62..9d43c93e63 100644
--- a/apps/desktop/src/i18n/locales/en.ts
+++ b/apps/desktop/src/i18n/locales/en.ts
@@ -3663,7 +3663,7 @@ export default {
     prefillNewQueryWithSelect: "Prefill new query with SELECT *",
     prefillNewQueryWithSelectDescription: "When creating a new query, prefill the editor with SELECT * FROM <table> based on the active table tab or the table selected in the sidebar.",
     sqlVariableSyntax: "SQL variable & placeholder substitution",
-    sqlVariableSyntaxDescription: "Choose which variable and placeholder syntaxes DBX substitutes before running SQL, per database type. All are enabled by default.",
+    sqlVariableSyntaxDescription: "Choose how DBX substitutes variables and placeholders before running SQL, per database type. Placeholder syntaxes are enabled by default; quoted interpolation is opt-in.",
     sqlVariableSyntax_positional: "Positional placeholder",
     sqlVariableSyntax_positionalDescription: "Prompt for a value to substitute each positional placeholder in order.",
     sqlVariableSyntax_named: "Named placeholder",
@@ -3676,6 +3676,12 @@ export default {
     sqlVariableSyntax_sqlserverDescription: "Prompt for a value to substitute SQL Server-style placeholders (may collide with session variables).",
     sqlVariableSyntax_atSet: "Inline variable expansion",
     sqlVariableSyntax_atSetDescription: "Expand inline variable declarations and substitute their values before running.",
+    sqlVariableSyntax_replaceInsideQuotes: "Replace braced placeholders inside quotes",
+    sqlVariableSyntax_replaceInsideQuotesDescription: "Also detect ${name} and #{name} inside quoted strings and identifiers. Values are inserted as escaped text; disabled by default.",
+    sqlVariableSyntax_ansiQuotes: "ANSI_QUOTES mode",
+    sqlVariableSyntax_ansiQuotesDescription: "Enable when this MySQL, Doris, or StarRocks session uses ANSI_QUOTES so double-quoted placeholders are treated as identifiers instead of strings.",
+    sqlVariableSyntax_noBackslashEscapes: "NO_BACKSLASH_ESCAPES mode",
+    sqlVariableSyntax_noBackslashEscapesDescription: "Enable when this MySQL, Doris, or StarRocks session uses NO_BACKSLASH_ESCAPES so DBX keeps backslashes literal instead of doubling them.",
     autoAliasTables: "Automatically add table aliases",
     autoAliasTablesDescription: "When selecting a table completion in FROM or JOIN, insert a generated alias such as order_items AS oi.",
     redisScanPageSize: "Redis scan count",
diff --git a/apps/desktop/src/i18n/locales/es.ts b/apps/desktop/src/i18n/locales/es.ts
index be7578e315..44115a86be 100644
--- a/apps/desktop/src/i18n/locales/es.ts
+++ b/apps/desktop/src/i18n/locales/es.ts
@@ -3423,7 +3423,7 @@ export default withEnglishFallback({
     prefillNewQueryWithSelect: "Rellenar nueva consulta con SELECT *",
     prefillNewQueryWithSelectDescription: "Al crear una nueva consulta, rellena el editor con SELECT * FROM <tabla> según la pestaña de tabla activa o la tabla seleccionada en la barra lateral.",
     sqlVariableSyntax: "Sustitución de variables y marcadores SQL",
-    sqlVariableSyntaxDescription: "Elige qué sintaxis de variables y marcadores sustituye DBX antes de ejecutar SQL, por tipo de base de datos. Todas están habilitadas de forma predeterminada.",
+    sqlVariableSyntaxDescription: "Elige cómo sustituye DBX las variables y los marcadores antes de ejecutar SQL, por tipo de base de datos. Las sintaxis están activadas por defecto; la interpolación entre comillas es opcional.",
     sqlVariableSyntax_positional: "Marcador posicional",
     sqlVariableSyntax_positionalDescription: "Solicita un valor para sustituir cada marcador posicional en orden.",
     sqlVariableSyntax_named: "Marcador con nombre",
@@ -3436,6 +3436,12 @@ export default withEnglishFallback({
     sqlVariableSyntax_sqlserverDescription: "Solicita un valor para sustituir los marcadores de estilo SQL Server (pueden entrar en conflicto con variables de sesión).",
     sqlVariableSyntax_atSet: "Expansión de variables en línea",
     sqlVariableSyntax_atSetDescription: "Expande las declaraciones de variables en línea y sustituye sus valores antes de ejecutar.",
+    sqlVariableSyntax_replaceInsideQuotes: "Sustituir marcadores entre comillas",
+    sqlVariableSyntax_replaceInsideQuotesDescription: "También detecta ${name} y #{name} dentro de cadenas e identificadores entre comillas. Los valores se insertan como texto escapado; desactivado de forma predeterminada.",
+    sqlVariableSyntax_ansiQuotes: "Modo ANSI_QUOTES",
+    sqlVariableSyntax_ansiQuotesDescription: "Actívalo cuando la sesión de MySQL, Doris o StarRocks use ANSI_QUOTES para tratar los marcadores entre comillas dobles como identificadores en lugar de cadenas.",
+    sqlVariableSyntax_noBackslashEscapes: "Modo NO_BACKSLASH_ESCAPES",
+    sqlVariableSyntax_noBackslashEscapesDescription: "Actívalo cuando la sesión de MySQL, Doris o StarRocks use NO_BACKSLASH_ESCAPES para conservar las barras invertidas literales en lugar de duplicarlas.",
     autoAliasTables: "Agregar alias de tabla automáticamente",
     autoAliasTablesDescription: "Al seleccionar una tabla en FROM o JOIN, inserta un alias generado como order_items AS oi.",
     redisScanPageSize: "Cantidad de escaneo Redis",
diff --git a/apps/desktop/src/i18n/locales/it.ts b/apps/desktop/src/i18n/locales/it.ts
index 98fe931d3b..b0d8952e43 100644
--- a/apps/desktop/src/i18n/locales/it.ts
+++ b/apps/desktop/src/i18n/locales/it.ts
@@ -3421,7 +3421,7 @@ export default withEnglishFallback({
     prefillNewQueryWithSelect: "Precompila nuova query con SELECT *",
     prefillNewQueryWithSelectDescription: "Alla creazione di una nuova query, precompila l'editor con SELECT * FROM <tabella> in base alla scheda tabella attiva o alla tabella selezionata nella barra laterale.",
     sqlVariableSyntax: "Sostituzione di variabili e segnaposto SQL",
-    sqlVariableSyntaxDescription: "Scegli quali sintassi di variabili e segnaposto DBX sostituisce prima di eseguire SQL, per tipo di database. Tutte abilitate per impostazione predefinita.",
+    sqlVariableSyntaxDescription: "Scegli come DBX sostituisce variabili e segnaposto prima di eseguire SQL, per tipo di database. Le sintassi sono attive per impostazione predefinita; l'interpolazione tra virgolette è facoltativa.",
     sqlVariableSyntax_positional: "Segnaposto posizionale",
     sqlVariableSyntax_positionalDescription: "Richiede un valore per sostituire ogni segnaposto posizionale in ordine.",
     sqlVariableSyntax_named: "Segnaposto con nome",
@@ -3434,6 +3434,12 @@ export default withEnglishFallback({
     sqlVariableSyntax_sqlserverDescription: "Richiede un valore per sostituire i segnaposto in stile SQL Server (possono entrare in conflitto con le variabili di sessione).",
     sqlVariableSyntax_atSet: "Espansione di variabili inline",
     sqlVariableSyntax_atSetDescription: "Espande le dichiarazioni di variabili inline e ne sostituisce i valori prima dell'esecuzione.",
+    sqlVariableSyntax_replaceInsideQuotes: "Sostituisci segnaposto tra virgolette",
+    sqlVariableSyntax_replaceInsideQuotesDescription: "Rileva anche ${name} e #{name} nelle stringhe e negli identificatori tra virgolette. I valori vengono inseriti come testo con escape; disattivato per impostazione predefinita.",
+    sqlVariableSyntax_ansiQuotes: "Modalità ANSI_QUOTES",
+    sqlVariableSyntax_ansiQuotesDescription: "Attiva quando la sessione MySQL, Doris o StarRocks usa ANSI_QUOTES, così i segnaposto tra virgolette doppie vengono trattati come identificatori anziché come stringhe.",
+    sqlVariableSyntax_noBackslashEscapes: "Modalità NO_BACKSLASH_ESCAPES",
+    sqlVariableSyntax_noBackslashEscapesDescription: "Attiva quando la sessione MySQL, Doris o StarRocks usa NO_BACKSLASH_ESCAPES, così DBX mantiene letterali le barre inverse invece di raddoppiarle.",
     autoAliasTables: "Aggiungi alias tabella automaticamente",
     autoAliasTablesDescription: "Quando scegli una tabella in FROM o JOIN, inserisce un alias generato come order_items AS oi.",
     redisScanPageSize: "Conteggio scansione Redis",
diff --git a/apps/desktop/src/i18n/locales/ja.ts b/apps/desktop/src/i18n/locales/ja.ts
index 7851868f38..359bb0cab9 100644
--- a/apps/desktop/src/i18n/locales/ja.ts
+++ b/apps/desktop/src/i18n/locales/ja.ts
@@ -3411,7 +3411,7 @@ export default withEnglishFallback({
     prefillNewQueryWithSelect: "新規クエリに SELECT を自動入力",
     prefillNewQueryWithSelectDescription: "新規クエリ作成時、アクティブなテーブルタブまたはサイドバーで選択したテーブルに基づき、エディタに SELECT * FROM <テーブル名> を自動入力します。",
     sqlVariableSyntax: "SQL 変数・プレースホルダー置換",
-    sqlVariableSyntaxDescription: "SQL 実行前に置換する変数・プレースホルダー構文をデータベース種別ごとに選択します。既定ではすべて有効です。",
+    sqlVariableSyntaxDescription: "SQL 実行前の変数・プレースホルダー置換方法をデータベース種別ごとに選択します。構文は既定で有効ですが、引用符内の置換はオプトインです。",
     sqlVariableSyntax_positional: "位置プレースホルダー",
     sqlVariableSyntax_positionalDescription: "各位置プレースホルダーを順番に置き換える値の入力を求めます。",
     sqlVariableSyntax_named: "名前付きプレースホルダー",
@@ -3424,6 +3424,12 @@ export default withEnglishFallback({
     sqlVariableSyntax_sqlserverDescription: "SQL Server 形式プレースホルダーを置き換える値の入力を求めます（セッション変数と競合する場合があります）。",
     sqlVariableSyntax_atSet: "インライン変数展開",
     sqlVariableSyntax_atSetDescription: "実行前にインライン変数宣言を展開し、その値をインライン化します。",
+    sqlVariableSyntax_replaceInsideQuotes: "引用符内の波括弧プレースホルダーを置換",
+    sqlVariableSyntax_replaceInsideQuotesDescription: "引用符付き文字列や識別子内の ${name} と #{name} も検出します。値はエスケープ済みテキストとして挿入され、既定では無効です。",
+    sqlVariableSyntax_ansiQuotes: "ANSI_QUOTES モード",
+    sqlVariableSyntax_ansiQuotesDescription: "MySQL、Doris、または StarRocks セッションで ANSI_QUOTES を使用する場合に有効にし、二重引用符内のプレースホルダーを文字列ではなく識別子として扱います。",
+    sqlVariableSyntax_noBackslashEscapes: "NO_BACKSLASH_ESCAPES モード",
+    sqlVariableSyntax_noBackslashEscapesDescription: "MySQL、Doris、または StarRocks セッションで NO_BACKSLASH_ESCAPES を使用する場合に有効にし、バックスラッシュを二重化せず文字どおりに保持します。",
     autoAliasTables: "テーブル別名を自動追加",
     autoAliasTablesDescription: "FROM または JOIN でテーブル補完を選択すると、order_items AS oi のような生成済み別名を挿入します。",
     redisScanPageSize: "Redisスキャンカウント",
diff --git a/apps/desktop/src/i18n/locales/pt-BR.ts b/apps/desktop/src/i18n/locales/pt-BR.ts
index 145dd8aae7..dd750fb59b 100644
--- a/apps/desktop/src/i18n/locales/pt-BR.ts
+++ b/apps/desktop/src/i18n/locales/pt-BR.ts
@@ -3423,7 +3423,7 @@ export default withEnglishFallback({
     prefillNewQueryWithSelect: "Preencher nova consulta com SELECT *",
     prefillNewQueryWithSelectDescription: "Ao criar uma nova consulta, preenche o editor com SELECT * FROM <tabela> com base na aba de tabela ativa ou na tabela selecionada na barra lateral.",
     sqlVariableSyntax: "Substituição de variáveis e espaços reservados SQL",
-    sqlVariableSyntaxDescription: "Escolha quais sintaxes de variáveis e espaços reservados o DBX substitui antes de executar SQL, por tipo de banco de dados. Todas ativadas por padrão.",
+    sqlVariableSyntaxDescription: "Escolha como o DBX substitui variáveis e espaços reservados antes de executar SQL, por tipo de banco de dados. As sintaxes ficam ativas por padrão; a interpolação entre aspas é opcional.",
     sqlVariableSyntax_positional: "Espaço reservado posicional",
     sqlVariableSyntax_positionalDescription: "Solicita um valor para substituir cada espaço reservado posicional em ordem.",
     sqlVariableSyntax_named: "Espaço reservado nomeado",
@@ -3436,6 +3436,12 @@ export default withEnglishFallback({
     sqlVariableSyntax_sqlserverDescription: "Solicita um valor para substituir os espaços reservados de estilo SQL Server (podem colidir com variáveis de sessão).",
     sqlVariableSyntax_atSet: "Expansão de variáveis inline",
     sqlVariableSyntax_atSetDescription: "Expande as declarações de variáveis inline e substitui seus valores antes de executar.",
+    sqlVariableSyntax_replaceInsideQuotes: "Substituir espaços reservados entre aspas",
+    sqlVariableSyntax_replaceInsideQuotesDescription: "Também detecta ${name} e #{name} dentro de strings e identificadores entre aspas. Os valores são inseridos como texto escapado; desativado por padrão.",
+    sqlVariableSyntax_ansiQuotes: "Modo ANSI_QUOTES",
+    sqlVariableSyntax_ansiQuotesDescription: "Ative quando a sessão MySQL, Doris ou StarRocks usar ANSI_QUOTES para tratar espaços reservados entre aspas duplas como identificadores em vez de strings.",
+    sqlVariableSyntax_noBackslashEscapes: "Modo NO_BACKSLASH_ESCAPES",
+    sqlVariableSyntax_noBackslashEscapesDescription: "Ative quando a sessão MySQL, Doris ou StarRocks usar NO_BACKSLASH_ESCAPES para manter as barras invertidas literais em vez de duplicá-las.",
     autoAliasTables: "Adicionar alias de tabela automaticamente",
     autoAliasTablesDescription: "Ao escolher uma tabela em FROM ou JOIN, insere um alias gerado como order_items AS oi.",
     redisScanPageSize: "Contagem de scan do Redis",
diff --git a/apps/desktop/src/i18n/locales/zh-CN.ts b/apps/desktop/src/i18n/locales/zh-CN.ts
index 2af3a3490e..44a0a8912c 100644
--- a/apps/desktop/src/i18n/locales/zh-CN.ts
+++ b/apps/desktop/src/i18n/locales/zh-CN.ts
@@ -3633,7 +3633,7 @@ export default withEnglishFallback({
     prefillNewQueryWithSelect: "新建查询时预填充 SELECT 语句",
     prefillNewQueryWithSelectDescription: "新建查询时，根据当前激活的数据表标签页或侧边栏选中的表，自动在编辑器中填充 SELECT * FROM <表名>。",
     sqlVariableSyntax: "SQL 变量与占位符替换",
-    sqlVariableSyntaxDescription: "按数据库类型选择执行 SQL 前替换哪些变量与占位符语法，默认全部开启。",
+    sqlVariableSyntaxDescription: "按数据库类型选择执行 SQL 前如何替换变量与占位符。占位符语法默认开启，引号内替换需主动开启。",
     sqlVariableSyntax_positional: "位置占位符",
     sqlVariableSyntax_positionalDescription: "按顺序为每个位置占位符提示输入替换值。",
     sqlVariableSyntax_named: "命名占位符",
@@ -3646,6 +3646,12 @@ export default withEnglishFallback({
     sqlVariableSyntax_sqlserverDescription: "为 SQL Server 风格占位符提示输入替换值（可能与会话变量冲突）。",
     sqlVariableSyntax_atSet: "内联变量展开",
     sqlVariableSyntax_atSetDescription: "执行前展开内联变量声明并就地代入其值。",
+    sqlVariableSyntax_replaceInsideQuotes: "替换引号内的花括号占位符",
+    sqlVariableSyntax_replaceInsideQuotesDescription: "同时识别字符串与带引号标识符内的 ${name} 和 #{name}。值会作为转义文本插入；默认关闭。",
+    sqlVariableSyntax_ansiQuotes: "ANSI_QUOTES 模式",
+    sqlVariableSyntax_ansiQuotesDescription: "当 MySQL、Doris 或 StarRocks 会话启用 ANSI_QUOTES 时开启，使双引号内的占位符按标识符而非字符串处理。",
+    sqlVariableSyntax_noBackslashEscapes: "NO_BACKSLASH_ESCAPES 模式",
+    sqlVariableSyntax_noBackslashEscapesDescription: "当 MySQL、Doris 或 StarRocks 会话启用 NO_BACKSLASH_ESCAPES 时开启，使 DBX 保留原始反斜杠而不是将其加倍。",
     autoAliasTables: "自动添加表别名",
     autoAliasTablesDescription: "在 FROM 或 JOIN 中选择表名补全时，自动插入类似 order_items AS oi 的表别名。",
     redisScanPageSize: "Redis 扫描数量",
diff --git a/apps/desktop/src/i18n/locales/zh-TW.ts b/apps/desktop/src/i18n/locales/zh-TW.ts
index 0a5288039c..0d91fc9807 100644
--- a/apps/desktop/src/i18n/locales/zh-TW.ts
+++ b/apps/desktop/src/i18n/locales/zh-TW.ts
@@ -3234,7 +3234,7 @@ export default withEnglishFallback({
     prefillNewQueryWithSelect: "新建查詢時預填 SELECT 語句",
     prefillNewQueryWithSelectDescription: "新建查詢時，根據目前啟用的資料表分頁或側邊欄選取的資料表，自動在編輯器中填入 SELECT * FROM <資料表名稱>。",
     sqlVariableSyntax: "SQL 變數與佔位符替換",
-    sqlVariableSyntaxDescription: "依資料庫類型選擇執行 SQL 前替換哪些變數與佔位符語法，預設全部開啟。",
+    sqlVariableSyntaxDescription: "依資料庫類型選擇執行 SQL 前如何替換變數與佔位符。佔位符語法預設開啟，引號內替換需主動開啟。",
     sqlVariableSyntax_positional: "位置佔位符",
     sqlVariableSyntax_positionalDescription: "依序為每個位置佔位符提示輸入替換值。",
     sqlVariableSyntax_named: "具名佔位符",
@@ -3247,6 +3247,12 @@ export default withEnglishFallback({
     sqlVariableSyntax_sqlserverDescription: "為 SQL Server 風格佔位符提示輸入替換值（可能與工作階段變數衝突）。",
     sqlVariableSyntax_atSet: "內聯變數展開",
     sqlVariableSyntax_atSetDescription: "執行前展開內聯變數宣告並就地代入其值。",
+    sqlVariableSyntax_replaceInsideQuotes: "替換引號內的花括號佔位符",
+    sqlVariableSyntax_replaceInsideQuotesDescription: "同時識別字串與帶引號識別碼內的 ${name} 和 #{name}。值會以跳脫文字插入；預設關閉。",
+    sqlVariableSyntax_ansiQuotes: "ANSI_QUOTES 模式",
+    sqlVariableSyntax_ansiQuotesDescription: "當 MySQL、Doris 或 StarRocks 工作階段啟用 ANSI_QUOTES 時開啟，使雙引號內的佔位符按識別碼而非字串處理。",
+    sqlVariableSyntax_noBackslashEscapes: "NO_BACKSLASH_ESCAPES 模式",
+    sqlVariableSyntax_noBackslashEscapesDescription: "當 MySQL、Doris 或 StarRocks 工作階段啟用 NO_BACKSLASH_ESCAPES 時開啟，使 DBX 保留原始反斜線而不是將其加倍。",
     autoAliasTables: "自動加入資料表別名",
     autoAliasTablesDescription: "在 FROM 或 JOIN 中選擇資料表補全時，自動插入類似 order_items AS oi 的資料表別名。",
     redisScanPageSize: "Redis 掃描數量",
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlParameters.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlParameters.spec.ts
index 9ce3cadc35..f324e6fb13 100644
--- a/apps/desktop/src/lib/__tests__/sql/sqlParameters.spec.ts
+++ b/apps/desktop/src/lib/__tests__/sql/sqlParameters.spec.ts
@@ -21,6 +21,48 @@ describe("extractSqlParameters", () => {
     expect(extractSqlParameters(sql)).toEqual(["id"]);
   });
 
+  it("detects braced placeholders inside quoted text only when explicitly enabled", () => {
+    const sql = "select '${date_end}', \"${schema_name}\", `${table_name}`, [${column_name}], '#{mybatis_name}', ':named', '@sqlserver', '?'";
+
+    expect(extractSqlParameters(sql)).toEqual([]);
+    expect(extractSqlParameters(sql, { replaceInsideQuotes: true })).toEqual(["date_end", "schema_name", "table_name", "column_name", "mybatis_name"]);
+  });
+
+  it("uses NO_BACKSLASH_ESCAPES while scanning quoted boundaries", () => {
+    const sql = "select 'C:\\', '${value}'";
+
+    expect(extractSqlParameters(sql, { databaseType: "mysql", noBackslashEscapes: true })).toEqual([]);
+    expect(extractSqlParameters(sql, { databaseType: "mysql", replaceInsideQuotes: true, noBackslashEscapes: true })).toEqual(["value"]);
+  });
+
+  it("keeps escaped double quotes inside MySQL strings and honors ANSI_QUOTES identifiers", () => {
+    const stringSql = 'select "prefix \\" ${first}", "${second}"';
+    const identifierSql = 'select "C:\\", "${identifier}"';
+
+    expect(extractSqlParameters(stringSql, { databaseType: "mysql", replaceInsideQuotes: true })).toEqual(["first", "second"]);
+    expect(extractSqlParameters(identifierSql, { databaseType: "mysql", ansiQuotes: true })).toEqual([]);
+    expect(extractSqlParameters(identifierSql, { databaseType: "mysql", replaceInsideQuotes: true, ansiQuotes: true })).toEqual(["identifier"]);
+  });
+
+  it("keeps quoted placeholders in comments and dollar-quoted code ignored", () => {
+    const sql = ["select '${visible}', $$ '${body}' $$, $tag$ \"#{tag_body}\" $tag$", "-- '${line_comment}'", "/* '#{block_comment}' */"].join("\n");
+
+    expect(extractSqlParameters(sql, { replaceInsideQuotes: true })).toEqual(["visible"]);
+  });
+
+  it("honors syntax toggles when detecting placeholders inside quotes", () => {
+    const sql = "select '${shell_name}', '#{mybatis_name}'";
+
+    expect(extractSqlParameters(sql, { enabledSyntaxes: ["shell"], replaceInsideQuotes: true })).toEqual(["shell_name"]);
+    expect(extractSqlParameters(sql, { enabledSyntaxes: ["mybatis"], replaceInsideQuotes: true })).toEqual(["mybatis_name"]);
+  });
+
+  it("skips malformed quoted placeholders and continues scanning valid ones", () => {
+    const sql = "select '${bad-name} ${valid_name}', '${unfinished'";
+
+    expect(extractSqlParameters(sql, { replaceInsideQuotes: true })).toEqual(["valid_name"]);
+  });
+
   it("ignores placeholders inside Postgres dollar-quoted strings", () => {
     const sql = "select $$ ${body_param} $$, $tag$ ${tag_param} $tag$, ${real_param}";
     expect(extractSqlParameters(sql)).toEqual(["real_param"]);
@@ -293,6 +335,104 @@ describe("substituteSqlParameters", () => {
     ).toBe("select 'O''Reilly', NULL, current_date");
   });
 
+  it("inserts escaped text inside existing quote delimiters", () => {
+    const sql = "select '${single_value}', \"${double_value}\", `${backtick_value}`, [${bracket_value}]";
+    expect(
+      substituteSqlParameters(
+        sql,
+        {
+          single_value: { kind: "string", value: "O'Reilly" },
+          double_value: { kind: "string", value: 'a"b' },
+          backtick_value: { kind: "string", value: "a`b" },
+          bracket_value: { kind: "string", value: "a]b" },
+        },
+        { replaceInsideQuotes: true },
+      ),
+    ).toBe("select 'O''Reilly', \"a\"\"b\", `a``b`, [a]]b]");
+  });
+
+  it.each(["mysql", "doris", "starrocks"] as const)("preserves backslash sequences inside %s single-quoted strings", (databaseType) => {
+    const sql = "select '${path}', '${newline}', '${nul}', '${quote_and_path}'";
+    const values = {
+      path: { kind: "string" as const, value: String.raw`C:\new` },
+      newline: { kind: "string" as const, value: String.raw`\n` },
+      nul: { kind: "string" as const, value: String.raw`\0` },
+      quote_and_path: { kind: "string" as const, value: String.raw`O'Reilly\path` },
+    };
+
+    expect(substituteSqlParameters(sql, values, { databaseType, replaceInsideQuotes: true })).toBe(String.raw`select 'C:\\new', '\\n', '\\0', 'O''Reilly\\path'`);
+  });
+
+  it.each(["mysql", "doris", "starrocks"] as const)("classifies %s double quotes from the active SQL mode", (databaseType) => {
+    const sql = 'select "${path}", "${newline}"';
+    const values = {
+      path: { kind: "string" as const, value: String.raw`C:\new` },
+      newline: { kind: "string" as const, value: String.raw`\n` },
+    };
+
+    expect(substituteSqlParameters(sql, values, { databaseType, replaceInsideQuotes: true })).toBe(String.raw`select "C:\\new", "\\n"`);
+    expect(substituteSqlParameters(sql, values, { databaseType, replaceInsideQuotes: true, noBackslashEscapes: true })).toBe(String.raw`select "C:\new", "\n"`);
+    expect(substituteSqlParameters(sql, values, { databaseType, replaceInsideQuotes: true, ansiQuotes: true })).toBe(String.raw`select "C:\new", "\n"`);
+  });
+
+  it("keeps backslashes literal for MySQL-family NO_BACKSLASH_ESCAPES sessions", () => {
+    const sql = "select '${path}', '${newline}', '${nul}', '${quote_and_path}'";
+    const values = {
+      path: { kind: "string" as const, value: String.raw`C:\new` },
+      newline: { kind: "string" as const, value: String.raw`\n` },
+      nul: { kind: "string" as const, value: String.raw`\0` },
+      quote_and_path: { kind: "string" as const, value: String.raw`O'Reilly\path` },
+    };
+
+    expect(substituteSqlParameters(sql, values, { databaseType: "mysql", replaceInsideQuotes: true, noBackslashEscapes: true })).toBe(String.raw`select 'C:\new', '\n', '\0', 'O''Reilly\path'`);
+  });
+
+  it("preserves a preceding string ending in backslash under NO_BACKSLASH_ESCAPES", () => {
+    const sql = "select 'C:\\', '${value}'";
+
+    expect(substituteSqlParameters(sql, { value: { kind: "string", value: String.raw`C:\new` } }, { databaseType: "mysql", replaceInsideQuotes: true, noBackslashEscapes: true })).toBe("select 'C:\\', 'C:\\new'");
+  });
+
+  it("does not double backslashes in quoted identifiers", () => {
+    const sql = 'select "${double_name}", `${backtick_name}`, [${bracket_name}]';
+    const values = {
+      double_name: { kind: "string" as const, value: String.raw`a\b` },
+      backtick_name: { kind: "string" as const, value: String.raw`c\d` },
+      bracket_name: { kind: "string" as const, value: String.raw`e\f` },
+    };
+
+    expect(substituteSqlParameters(sql, values, { databaseType: "mysql", replaceInsideQuotes: true, ansiQuotes: true })).toBe(String.raw`select "a\b", ` + "`c\\d`" + String.raw`, [e\f]`);
+  });
+
+  it("preserves doubled quote escapes surrounding a quoted placeholder", () => {
+    const sql = "select 'prefix ''${name}'' suffix'";
+
+    expect(substituteSqlParameters(sql, { name: { kind: "string", value: "O'Reilly" } }, { replaceInsideQuotes: true })).toBe("select 'prefix ''O''Reilly'' suffix'");
+  });
+
+  it("uses typed literals outside quotes and textual values inside quotes", () => {
+    const sql = "select ${date_end}, '${date_end}', '${nullable}', '#{enabled}'";
+    expect(
+      substituteSqlParameters(
+        sql,
+        {
+          date_end: { kind: "string", value: "2026-07-16" },
+          nullable: { kind: "null", value: "" },
+          enabled: { kind: "boolean", value: "yes" },
+        },
+        { replaceInsideQuotes: true },
+      ),
+    ).toBe("select '2026-07-16', '2026-07-16', 'NULL', 'yes'");
+  });
+
+  it("replaces repeated quoted placeholders without changing the default-off path", () => {
+    const sql = "select '${date_end}', '${date_end}'";
+    const values = { date_end: { kind: "string" as const, value: "2026-07-16" } };
+
+    expect(substituteSqlParameters(sql, values)).toBe(sql);
+    expect(substituteSqlParameters(sql, values, { replaceInsideQuotes: true })).toBe("select '2026-07-16', '2026-07-16'");
+  });
+
   it("replaces all supported placeholder syntaxes with SQL literals", () => {
     const sql = "select ? as a, :named as b, ${shell_name} as c, #{mybatis_name} as d, @sql_server_name as e";
     expect(
diff --git a/apps/desktop/src/lib/__tests__/sql/sqlVariableSyntax.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlVariableSyntax.spec.ts
index 4e25f881cf..54846b7b61 100644
--- a/apps/desktop/src/lib/__tests__/sql/sqlVariableSyntax.spec.ts
+++ b/apps/desktop/src/lib/__tests__/sql/sqlVariableSyntax.spec.ts
@@ -1,18 +1,18 @@
 import { describe, expect, it } from "vitest";
 import { reactive } from "vue";
-import { DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES, enabledSqlParameterSyntaxes, normalizeSqlVariableSyntaxOverrides, resolveSqlVariableSyntaxToggles } from "@/lib/sql/sqlVariableSyntax";
+import { DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES, enabledSqlParameterSyntaxes, normalizeSqlVariableSyntaxOverrides, resolveSqlVariableSyntaxToggles, sqlVariableSyntaxKeysForDatabase } from "@/lib/sql/sqlVariableSyntax";
 
 describe("resolveSqlVariableSyntaxToggles", () => {
-  it("enables every syntax when there are no overrides", () => {
+  it("uses the backward-compatible defaults when there are no overrides", () => {
     expect(resolveSqlVariableSyntaxToggles(undefined, "mysql")).toEqual(DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES);
     expect(resolveSqlVariableSyntaxToggles({}, "mysql")).toEqual(DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES);
   });
 
-  it("enables every syntax for a database type without an entry", () => {
+  it("uses the defaults for a database type without an entry", () => {
     expect(resolveSqlVariableSyntaxToggles({ mysql: { shell: false } }, "postgres")).toEqual(DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES);
   });
 
-  it("enables every syntax when the database type is unknown", () => {
+  it("uses the defaults when the database type is unknown", () => {
     expect(resolveSqlVariableSyntaxToggles({ mysql: { shell: false } }, undefined)).toEqual(DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES);
   });
 
@@ -24,8 +24,41 @@ describe("resolveSqlVariableSyntaxToggles", () => {
       mybatis: true,
       sqlserver: false,
       atSet: false,
+      replaceInsideQuotes: false,
+      ansiQuotes: false,
+      noBackslashEscapes: false,
     });
   });
+
+  it("enables quoted interpolation only for an explicit per-database opt-in", () => {
+    expect(resolveSqlVariableSyntaxToggles({ mysql: { replaceInsideQuotes: true } }, "mysql").replaceInsideQuotes).toBe(true);
+    expect(resolveSqlVariableSyntaxToggles({ mysql: { replaceInsideQuotes: true } }, "postgres").replaceInsideQuotes).toBe(false);
+  });
+
+  it("applies NO_BACKSLASH_ESCAPES only to compatible database types", () => {
+    expect(resolveSqlVariableSyntaxToggles({ mysql: { noBackslashEscapes: true } }, "mysql").noBackslashEscapes).toBe(true);
+    expect(resolveSqlVariableSyntaxToggles({ doris: { noBackslashEscapes: true } }, "doris").noBackslashEscapes).toBe(true);
+    expect(resolveSqlVariableSyntaxToggles({ starrocks: { noBackslashEscapes: true } }, "starrocks").noBackslashEscapes).toBe(true);
+    expect(resolveSqlVariableSyntaxToggles({ postgres: { noBackslashEscapes: true } }, "postgres").noBackslashEscapes).toBe(false);
+  });
+
+  it("applies ANSI_QUOTES only to compatible database types", () => {
+    expect(resolveSqlVariableSyntaxToggles({ mysql: { ansiQuotes: true } }, "mysql").ansiQuotes).toBe(true);
+    expect(resolveSqlVariableSyntaxToggles({ doris: { ansiQuotes: true } }, "doris").ansiQuotes).toBe(true);
+    expect(resolveSqlVariableSyntaxToggles({ starrocks: { ansiQuotes: true } }, "starrocks").ansiQuotes).toBe(true);
+    expect(resolveSqlVariableSyntaxToggles({ postgres: { ansiQuotes: true } }, "postgres").ansiQuotes).toBe(false);
+  });
+
+  it("shows the SQL mode compatibility setting only for supported database types", () => {
+    expect(sqlVariableSyntaxKeysForDatabase("mysql")).toContain("ansiQuotes");
+    expect(sqlVariableSyntaxKeysForDatabase("mysql")).toContain("noBackslashEscapes");
+    expect(sqlVariableSyntaxKeysForDatabase("doris")).toContain("ansiQuotes");
+    expect(sqlVariableSyntaxKeysForDatabase("doris")).toContain("noBackslashEscapes");
+    expect(sqlVariableSyntaxKeysForDatabase("starrocks")).toContain("ansiQuotes");
+    expect(sqlVariableSyntaxKeysForDatabase("starrocks")).toContain("noBackslashEscapes");
+    expect(sqlVariableSyntaxKeysForDatabase("postgres")).not.toContain("ansiQuotes");
+    expect(sqlVariableSyntaxKeysForDatabase("postgres")).not.toContain("noBackslashEscapes");
+  });
 });
 
 describe("enabledSqlParameterSyntaxes", () => {
@@ -34,12 +67,12 @@ describe("enabledSqlParameterSyntaxes", () => {
   });
 
   it("filters out disabled placeholder syntaxes", () => {
-    expect(enabledSqlParameterSyntaxes({ positional: false, named: true, shell: false, mybatis: true, sqlserver: false, atSet: true })).toEqual(["named", "mybatis"]);
+    expect(enabledSqlParameterSyntaxes({ positional: false, named: true, shell: false, mybatis: true, sqlserver: false, atSet: true, replaceInsideQuotes: true, ansiQuotes: true, noBackslashEscapes: true })).toEqual(["named", "mybatis"]);
   });
 
   it("ignores the atSet toggle entirely", () => {
-    expect(enabledSqlParameterSyntaxes({ positional: true, named: true, shell: true, mybatis: true, sqlserver: true, atSet: false })).toEqual(["positional", "named", "shell", "mybatis", "sqlserver"]);
-    expect(enabledSqlParameterSyntaxes({ positional: false, named: false, shell: false, mybatis: false, sqlserver: false, atSet: true })).toEqual([]);
+    expect(enabledSqlParameterSyntaxes({ positional: true, named: true, shell: true, mybatis: true, sqlserver: true, atSet: false, replaceInsideQuotes: true, ansiQuotes: true, noBackslashEscapes: true })).toEqual(["positional", "named", "shell", "mybatis", "sqlserver"]);
+    expect(enabledSqlParameterSyntaxes({ positional: false, named: false, shell: false, mybatis: false, sqlserver: false, atSet: true, replaceInsideQuotes: false, ansiQuotes: false, noBackslashEscapes: false })).toEqual([]);
   });
 });
 
@@ -51,12 +84,28 @@ describe("normalizeSqlVariableSyntaxOverrides", () => {
     expect(normalizeSqlVariableSyntaxOverrides("mysql")).toEqual({});
   });
 
-  it("keeps only syntaxes explicitly set to false", () => {
-    expect(normalizeSqlVariableSyntaxOverrides({ mysql: { positional: true, shell: false, atSet: false } })).toEqual({ mysql: { shell: false, atSet: false } });
+  it("keeps only values that differ from their defaults", () => {
+    expect(normalizeSqlVariableSyntaxOverrides({ mysql: { positional: true, shell: false, atSet: false, replaceInsideQuotes: true, ansiQuotes: true } })).toEqual({
+      mysql: { shell: false, atSet: false, replaceInsideQuotes: true, ansiQuotes: true },
+    });
+  });
+
+  it("drops entries containing only default values", () => {
+    expect(normalizeSqlVariableSyntaxOverrides({ mysql: { positional: true, replaceInsideQuotes: false }, postgres: {} })).toEqual({});
   });
 
-  it("drops entries with no disabled syntaxes", () => {
-    expect(normalizeSqlVariableSyntaxOverrides({ mysql: { positional: true }, postgres: {} })).toEqual({});
+  it("keeps NO_BACKSLASH_ESCAPES only for compatible database types", () => {
+    expect(normalizeSqlVariableSyntaxOverrides({ mysql: { noBackslashEscapes: true }, doris: { noBackslashEscapes: true }, postgres: { noBackslashEscapes: true } })).toEqual({
+      mysql: { noBackslashEscapes: true },
+      doris: { noBackslashEscapes: true },
+    });
+  });
+
+  it("keeps ANSI_QUOTES only for compatible database types", () => {
+    expect(normalizeSqlVariableSyntaxOverrides({ mysql: { ansiQuotes: true }, starrocks: { ansiQuotes: true }, postgres: { ansiQuotes: true } })).toEqual({
+      mysql: { ansiQuotes: true },
+      starrocks: { ansiQuotes: true },
+    });
   });
 
   it("ignores non-boolean values and unknown keys", () => {
@@ -68,7 +117,7 @@ describe("normalizeSqlVariableSyntaxOverrides", () => {
   });
 
   it("is stable across a round-trip", () => {
-    const normalized = normalizeSqlVariableSyntaxOverrides({ mysql: { shell: false }, oracle: { atSet: false, named: false } });
+    const normalized = normalizeSqlVariableSyntaxOverrides({ mysql: { shell: false, replaceInsideQuotes: true }, oracle: { atSet: false, named: false } });
     expect(normalizeSqlVariableSyntaxOverrides(normalized)).toEqual(normalized);
   });
 
diff --git a/apps/desktop/src/lib/sql/sqlParameters.ts b/apps/desktop/src/lib/sql/sqlParameters.ts
index cf94fc0830..87009ec663 100644
--- a/apps/desktop/src/lib/sql/sqlParameters.ts
+++ b/apps/desktop/src/lib/sql/sqlParameters.ts
@@ -19,6 +19,8 @@ export interface SqlParameterDescriptor {
 interface ParameterOccurrence extends SqlParameterDescriptor {
   start: number;
   end: number;
+  quotedBy?: "'" | '"' | "`" | "]";
+  quotedBackslashEscapes?: boolean;
 }
 
 type ComplexTypeDeclarationKind = "struct" | "variant";
@@ -27,12 +29,27 @@ export interface SqlParameterOptions {
   databaseType?: DatabaseType;
   // Which placeholder syntaxes are recognized. Undefined enables all of them.
   enabledSyntaxes?: readonly SqlParameterSyntax[];
+  // Opt in to scheduler-style ${name}/#{name} interpolation inside quoted SQL text.
+  replaceInsideQuotes?: boolean;
+  // Match MySQL-family ANSI_QUOTES when classifying double-quoted regions.
+  ansiQuotes?: boolean;
+  // Match MySQL-family NO_BACKSLASH_ESCAPES when scanning and interpolating strings.
+  noBackslashEscapes?: boolean;
 }
 
 const PARAMETER_NAME_RE = /^[\p{L}_][\p{L}\p{N}_]*$/u;
 const PARAMETER_NAME_START_RE = /[\p{L}_]/u;
 const PARAMETER_NAME_CHAR_RE = /[\p{L}\p{N}_]/u;
 const SQL_SERVER_TEMP_TABLE_CONTEXT_KEYWORDS = new Set(["table", "from", "join", "into", "update", "truncate"]);
+const MYSQL_FAMILY_SQL_MODE_DATABASE_TYPES: ReadonlySet<DatabaseType> = new Set(["mysql", "doris", "starrocks"]);
+
+export function supportsNoBackslashEscapesMode(databaseType: DatabaseType | undefined): boolean {
+  return !!databaseType && MYSQL_FAMILY_SQL_MODE_DATABASE_TYPES.has(databaseType);
+}
+
+export function supportsAnsiQuotesMode(databaseType: DatabaseType | undefined): boolean {
+  return !!databaseType && MYSQL_FAMILY_SQL_MODE_DATABASE_TYPES.has(databaseType);
+}
 
 export function extractSqlParameters(sql: string, options?: SqlParameterOptions): string[] {
   return extractSqlParameterDescriptors(sql, options).map((descriptor) => descriptor.key);
@@ -62,7 +79,8 @@ export function substituteSqlParameters(sql: string, values: Record<string, SqlP
   let cursor = 0;
   for (const occurrence of occurrences) {
     result += sql.slice(cursor, occurrence.start);
-    result += sqlParameterLiteral(values[occurrence.key] ?? { kind: "string", value: "" });
+    const input = values[occurrence.key] ?? { kind: "string", value: "" };
+    result += occurrence.quotedBy ? sqlParameterTextInsideQuote(input, occurrence.quotedBy, occurrence.quotedBackslashEscapes ?? false) : sqlParameterLiteral(input);
     cursor = occurrence.end;
   }
   result += sql.slice(cursor);
@@ -80,11 +98,11 @@ export function sqlParameterLiteral(input: SqlParameterInput): string {
 
 function findSqlParameterOccurrences(sql: string, options?: SqlParameterOptions): ParameterOccurrence[] {
   const occurrences: ParameterOccurrence[] = [];
-  const nativeSqlServerParameters = collectNativeSqlServerParameters(sql);
+  const nativeSqlServerParameters = collectNativeSqlServerParameters(sql, options);
   const supportsNamedParameters = options?.databaseType !== "saphana";
   const enabledSyntaxes = options?.enabledSyntaxes ? new Set(options.enabledSyntaxes) : null;
   const isSyntaxEnabled = (syntax: SqlParameterSyntax) => !enabledSyntaxes || enabledSyntaxes.has(syntax);
-  const complexTypeFieldSeparators = supportsNamedParameters && isSyntaxEnabled("named") ? collectComplexTypeFieldSeparators(sql) : new Set<number>();
+  const complexTypeFieldSeparators = supportsNamedParameters && isSyntaxEnabled("named") ? collectComplexTypeFieldSeparators(sql, options) : new Set<number>();
   let i = 0;
   let dollarQuoteEnd = "";
   let positionalIndex = 0;
@@ -102,11 +120,16 @@ function findSqlParameterOccurrences(sql: string, options?: SqlParameterOptions)
     const next = sql[i + 1];
 
     if (ch === "'" || ch === '"' || ch === "`") {
-      i = skipQuoted(sql, i, ch);
+      const quotedBackslashEscapes = sqlQuoteEscapesInsertedBackslashes(ch, options);
+      const quoteEnd = skipQuoted(sql, i, ch, options);
+      if (options?.replaceInsideQuotes) collectQuotedBracedParameterOccurrences(sql, i, quoteEnd, ch, quotedBackslashEscapes, occurrences, isSyntaxEnabled);
+      i = quoteEnd;
       continue;
     }
     if (ch === "[") {
-      i = skipBracketIdentifier(sql, i);
+      const quoteEnd = skipBracketIdentifier(sql, i);
+      if (options?.replaceInsideQuotes) collectQuotedBracedParameterOccurrences(sql, i, quoteEnd, "]", false, occurrences, isSyntaxEnabled);
+      i = quoteEnd;
       continue;
     }
     if (ch === "-" && next === "-") {
@@ -194,8 +217,35 @@ function findSqlParameterOccurrences(sql: string, options?: SqlParameterOptions)
   return occurrences;
 }
 
+function collectQuotedBracedParameterOccurrences(sql: string, quoteStart: number, quoteEnd: number, quotedBy: NonNullable<ParameterOccurrence["quotedBy"]>, quotedBackslashEscapes: boolean, occurrences: ParameterOccurrence[], isSyntaxEnabled: (syntax: SqlParameterSyntax) => boolean) {
+  const contentEnd = sql[quoteEnd - 1] === quotedBy ? quoteEnd - 1 : quoteEnd;
+  let i = quoteStart + 1;
+
+  while (i < contentEnd) {
+    const ch = sql[i];
+    const syntax: SqlParameterSyntax | undefined = ch === "$" && sql[i + 1] === "{" ? "shell" : ch === "#" && sql[i + 1] === "{" ? "mybatis" : undefined;
+    if (!syntax || !isSyntaxEnabled(syntax)) {
+      i += 1;
+      continue;
+    }
+
+    const end = sql.indexOf("}", i + 2);
+    if (end === -1 || end >= contentEnd) {
+      // No later braced placeholder can close within this quoted range either.
+      break;
+    }
+    const name = sql.slice(i + 2, end).trim();
+    if (!PARAMETER_NAME_RE.test(name)) {
+      i = end + 1;
+      continue;
+    }
+    occurrences.push({ key: name, name, syntax, token: sql.slice(i, end + 1), start: i, end: end + 1, quotedBy, quotedBackslashEscapes });
+    i = end + 1;
+  }
+}
+
 // Doris-style complex types use colons between field names and types; those are not bind parameters.
-function collectComplexTypeFieldSeparators(sql: string): Set<number> {
+function collectComplexTypeFieldSeparators(sql: string, options?: SqlParameterOptions): Set<number> {
   const separators = new Set<number>();
   let i = 0;
   let dollarQuoteEnd = "";
@@ -212,7 +262,7 @@ function collectComplexTypeFieldSeparators(sql: string): Set<number> {
     const ch = sql[i];
     const next = sql[i + 1];
     if (ch === "'" || ch === '"' || ch === "`") {
-      i = skipQuoted(sql, i, ch);
+      i = skipQuoted(sql, i, ch, options);
       continue;
     }
     if (ch === "[") {
@@ -241,7 +291,7 @@ function collectComplexTypeFieldSeparators(sql: string): Set<number> {
     }
     const declaration = readComplexTypeDeclaration(sql, i);
     if (declaration) {
-      i = collectComplexTypeFieldSeparatorsInDeclaration(sql, declaration.openingBracket + 1, declaration.kind, separators) + 1;
+      i = collectComplexTypeFieldSeparatorsInDeclaration(sql, declaration.openingBracket + 1, declaration.kind, separators, options) + 1;
       continue;
     }
     i += 1;
@@ -250,7 +300,7 @@ function collectComplexTypeFieldSeparators(sql: string): Set<number> {
   return separators;
 }
 
-function collectComplexTypeFieldSeparatorsInDeclaration(sql: string, start: number, kind: ComplexTypeDeclarationKind, separators: Set<number>): number {
+function collectComplexTypeFieldSeparatorsInDeclaration(sql: string, start: number, kind: ComplexTypeDeclarationKind, separators: Set<number>, options?: SqlParameterOptions): number {
   let i = start;
   let genericDepth = 0;
   let parenthesisDepth = 0;
@@ -264,7 +314,7 @@ function collectComplexTypeFieldSeparatorsInDeclaration(sql: string, start: numb
         continue;
       }
       if (isLineStatementStart(sql, i) && isSqlStatementKeyword(sql, i)) return i;
-      const fieldNameEnd = readComplexTypeFieldNameEnd(sql, i, kind);
+      const fieldNameEnd = readComplexTypeFieldNameEnd(sql, i, kind, options);
       if (fieldNameEnd > i) {
         const separator = skipSqlWhitespaceAndComments(sql, fieldNameEnd);
         if (sql[separator] === ":") {
@@ -282,7 +332,7 @@ function collectComplexTypeFieldSeparatorsInDeclaration(sql: string, start: numb
     const ch = sql[i];
     const next = sql[i + 1];
     if (ch === "'" || ch === '"' || ch === "`") {
-      i = skipQuoted(sql, i, ch);
+      i = skipQuoted(sql, i, ch, options);
       continue;
     }
     if (ch === "[") {
@@ -303,7 +353,7 @@ function collectComplexTypeFieldSeparatorsInDeclaration(sql: string, start: numb
     }
     const declaration = readComplexTypeDeclaration(sql, i);
     if (declaration) {
-      i = collectComplexTypeFieldSeparatorsInDeclaration(sql, declaration.openingBracket + 1, declaration.kind, separators) + 1;
+      i = collectComplexTypeFieldSeparatorsInDeclaration(sql, declaration.openingBracket + 1, declaration.kind, separators, options) + 1;
       continue;
     }
     if (ch === ";" && genericDepth === 0 && parenthesisDepth === 0) return i;
@@ -345,11 +395,11 @@ function readComplexTypeDeclaration(sql: string, start: number): { kind: Complex
   return sql[openingBracket] === "<" ? { kind, openingBracket } : null;
 }
 
-function readComplexTypeFieldNameEnd(sql: string, start: number, kind: ComplexTypeDeclarationKind): number {
-  if (kind === "variant") return readVariantFieldNameEnd(sql, start);
+function readComplexTypeFieldNameEnd(sql: string, start: number, kind: ComplexTypeDeclarationKind, options?: SqlParameterOptions): number {
+  if (kind === "variant") return readVariantFieldNameEnd(sql, start, options);
 
   const ch = sql[start];
-  if (ch === '"' || ch === "`") return skipQuoted(sql, start, ch);
+  if (ch === '"' || ch === "`") return skipQuoted(sql, start, ch, options);
   if (ch === "[") return skipBracketIdentifier(sql, start);
   if (!PARAMETER_NAME_START_RE.test(ch ?? "")) return start;
 
@@ -358,11 +408,11 @@ function readComplexTypeFieldNameEnd(sql: string, start: number, kind: ComplexTy
   return i;
 }
 
-function readVariantFieldNameEnd(sql: string, start: number): number {
+function readVariantFieldNameEnd(sql: string, start: number, options?: SqlParameterOptions): number {
   let i = start;
   const modifier = matchesWord(sql, i, "match_name") ? "match_name" : matchesWord(sql, i, "match_name_glob") ? "match_name_glob" : "";
   if (modifier) i = skipSqlWhitespaceAndComments(sql, i + modifier.length);
-  return sql[i] === "'" ? skipQuoted(sql, i, "'") : start;
+  return sql[i] === "'" ? skipQuoted(sql, i, "'", options) : start;
 }
 
 function skipSqlWhitespaceAndComments(sql: string, start: number): number {
@@ -386,7 +436,7 @@ function skipSqlWhitespaceAndComments(sql: string, start: number): number {
   return i;
 }
 
-function collectNativeSqlServerParameters(sql: string): { declared: Set<string>; ignoredStarts: Set<number> } {
+function collectNativeSqlServerParameters(sql: string, options?: SqlParameterOptions): { declared: Set<string>; ignoredStarts: Set<number> } {
   const declared = new Set<string>();
   const ignoredStarts = new Set<number>();
   let i = 0;
@@ -404,7 +454,7 @@ function collectNativeSqlServerParameters(sql: string): { declared: Set<string>;
     const ch = sql[i];
     const next = sql[i + 1];
     if (ch === "'" || ch === '"' || ch === "`") {
-      i = skipQuoted(sql, i, ch);
+      i = skipQuoted(sql, i, ch, options);
       continue;
     }
     if (ch === "[") {
@@ -432,23 +482,23 @@ function collectNativeSqlServerParameters(sql: string): { declared: Set<string>;
       continue;
     }
     if (matchesWord(sql, i, "declare")) {
-      i = collectDeclareStatementVariables(sql, i + "declare".length, declared);
+      i = collectDeclareStatementVariables(sql, i + "declare".length, declared, options);
       continue;
     }
     if (matchesWord(sql, i, "set")) {
-      i = collectSetStatementVariables(sql, i + "set".length, declared);
+      i = collectSetStatementVariables(sql, i + "set".length, declared, options);
       continue;
     }
     if (matchesWord(sql, i, "select")) {
-      i = collectSelectAssignmentVariables(sql, i + "select".length, declared);
+      i = collectSelectAssignmentVariables(sql, i + "select".length, declared, options);
       continue;
     }
     if ((matchesWord(sql, i, "create") || matchesWord(sql, i, "alter")) && isRoutineDefinitionStart(sql, i)) {
-      i = collectRoutineDefinitionVariables(sql, i, declared);
+      i = collectRoutineDefinitionVariables(sql, i, declared, options);
       continue;
     }
     if (matchesWord(sql, i, "exec") || matchesWord(sql, i, "execute")) {
-      i = collectExecNamedArgumentStarts(sql, i + (matchesWord(sql, i, "exec") ? "exec".length : "execute".length), ignoredStarts);
+      i = collectExecNamedArgumentStarts(sql, i + (matchesWord(sql, i, "exec") ? "exec".length : "execute".length), ignoredStarts, options);
       continue;
     }
     i += 1;
@@ -457,7 +507,7 @@ function collectNativeSqlServerParameters(sql: string): { declared: Set<string>;
   return { declared, ignoredStarts };
 }
 
-function collectDeclareStatementVariables(sql: string, start: number, declared: Set<string>): number {
+function collectDeclareStatementVariables(sql: string, start: number, declared: Set<string>, options?: SqlParameterOptions): number {
   let i = start;
   while (i < sql.length) {
     const ch = sql[i];
@@ -465,7 +515,7 @@ function collectDeclareStatementVariables(sql: string, start: number, declared:
     if (ch === ";") return i + 1;
     if (isLineStatementStart(sql, i) && isSqlStatementKeyword(sql, i)) return i;
     if (ch === "'" || ch === '"' || ch === "`") {
-      i = skipQuoted(sql, i, ch);
+      i = skipQuoted(sql, i, ch, options);
       continue;
     }
     if (ch === "[") {
@@ -497,7 +547,7 @@ function collectDeclareStatementVariables(sql: string, start: number, declared:
   return i;
 }
 
-function collectSetStatementVariables(sql: string, start: number, declared: Set<string>): number {
+function collectSetStatementVariables(sql: string, start: number, declared: Set<string>, options?: SqlParameterOptions): number {
   let i = start;
   while (i < sql.length) {
     const ch = sql[i];
@@ -505,7 +555,7 @@ function collectSetStatementVariables(sql: string, start: number, declared: Set<
     if (ch === ";") return i + 1;
     if (isLineStatementStart(sql, i) && isSqlStatementKeyword(sql, i)) return i;
     if (ch === "'" || ch === '"' || ch === "`") {
-      i = skipQuoted(sql, i, ch);
+      i = skipQuoted(sql, i, ch, options);
       continue;
     }
     if (ch === "[") {
@@ -537,7 +587,7 @@ function collectSetStatementVariables(sql: string, start: number, declared: Set<
   return i;
 }
 
-function collectSelectAssignmentVariables(sql: string, start: number, declared: Set<string>): number {
+function collectSelectAssignmentVariables(sql: string, start: number, declared: Set<string>, options?: SqlParameterOptions): number {
   let i = start;
   while (i < sql.length) {
     const ch = sql[i];
@@ -546,7 +596,7 @@ function collectSelectAssignmentVariables(sql: string, start: number, declared:
     if (isLineStatementStart(sql, i) && isSqlStatementKeyword(sql, i)) return i;
     if (matchesWord(sql, i, "from")) return i;
     if (ch === "'" || ch === '"' || ch === "`") {
-      i = skipQuoted(sql, i, ch);
+      i = skipQuoted(sql, i, ch, options);
       continue;
     }
     if (ch === "[") {
@@ -578,7 +628,7 @@ function collectSelectAssignmentVariables(sql: string, start: number, declared:
   return i;
 }
 
-function collectRoutineDefinitionVariables(sql: string, start: number, declared: Set<string>): number {
+function collectRoutineDefinitionVariables(sql: string, start: number, declared: Set<string>, options?: SqlParameterOptions): number {
   let i = start;
   while (i < sql.length) {
     const ch = sql[i];
@@ -586,7 +636,7 @@ function collectRoutineDefinitionVariables(sql: string, start: number, declared:
     if (ch === ";") return i + 1;
     if (matchesWord(sql, i, "as") || matchesWord(sql, i, "returns")) return i;
     if (ch === "'" || ch === '"' || ch === "`") {
-      i = skipQuoted(sql, i, ch);
+      i = skipQuoted(sql, i, ch, options);
       continue;
     }
     if (ch === "[") {
@@ -618,7 +668,7 @@ function collectRoutineDefinitionVariables(sql: string, start: number, declared:
   return i;
 }
 
-function collectExecNamedArgumentStarts(sql: string, start: number, ignoredStarts: Set<number>): number {
+function collectExecNamedArgumentStarts(sql: string, start: number, ignoredStarts: Set<number>, options?: SqlParameterOptions): number {
   let i = start;
   while (i < sql.length) {
     const ch = sql[i];
@@ -626,7 +676,7 @@ function collectExecNamedArgumentStarts(sql: string, start: number, ignoredStart
     if (ch === ";") return i + 1;
     if (isLineStatementStart(sql, i) && isSqlStatementKeyword(sql, i)) return i;
     if (ch === "'" || ch === '"' || ch === "`") {
-      i = skipQuoted(sql, i, ch);
+      i = skipQuoted(sql, i, ch, options);
       continue;
     }
     if (ch === "[") {
@@ -722,10 +772,23 @@ function readParameterName(sql: string, start: number): string {
   return sql.slice(start, i);
 }
 
-function skipQuoted(sql: string, start: number, quote: string): number {
+function sqlQuoteEscapesInsertedBackslashes(quote: string, options?: SqlParameterOptions): boolean {
+  if (!supportsNoBackslashEscapesMode(options?.databaseType) || options?.noBackslashEscapes) return false;
+  return quote === "'" || (quote === '"' && !options?.ansiQuotes);
+}
+
+function sqlQuoteUsesBackslashEscapes(quote: string, options?: SqlParameterOptions): boolean {
+  if (supportsNoBackslashEscapesMode(options?.databaseType)) return sqlQuoteEscapesInsertedBackslashes(quote, options);
+  // Preserve the existing conservative scanner for other/unknown dialects;
+  // interpolation escaping remains limited to confirmed MySQL-family semantics.
+  return quote === "'";
+}
+
+function skipQuoted(sql: string, start: number, quote: string, options?: SqlParameterOptions): number {
+  const backslashEscapes = sqlQuoteUsesBackslashEscapes(quote, options);
   let i = start + 1;
   while (i < sql.length) {
-    if (sql[i] === "\\" && quote === "'" && i + 1 < sql.length) {
+    if (sql[i] === "\\" && backslashEscapes && i + 1 < sql.length) {
       i += 2;
       continue;
     }
@@ -800,6 +863,14 @@ function quoteSqlString(value: string): string {
   return `'${value.replace(/'/g, "''")}'`;
 }
 
+function sqlParameterTextInsideQuote(input: SqlParameterInput, quotedBy: NonNullable<ParameterOccurrence["quotedBy"]>, backslashEscapes: boolean): string {
+  const value = input.kind === "null" ? "NULL" : input.value;
+  // Use the same quote-mode decision as the scanner so substitution cannot
+  // reinterpret a delimiter or backslash differently from occurrence discovery.
+  const backslashEscaped = backslashEscapes ? value.replaceAll("\\", "\\\\") : value;
+  return backslashEscaped.replaceAll(quotedBy, quotedBy + quotedBy);
+}
+
 function normalizeBooleanLiteral(value: string): string {
   const normalized = value.trim().toLowerCase();
   if (normalized === "true" || normalized === "t" || normalized === "yes" || normalized === "y" || normalized === "1") return "TRUE";
diff --git a/apps/desktop/src/lib/sql/sqlVariableSyntax.ts b/apps/desktop/src/lib/sql/sqlVariableSyntax.ts
index 4e83d3d387..55d86dff29 100644
--- a/apps/desktop/src/lib/sql/sqlVariableSyntax.ts
+++ b/apps/desktop/src/lib/sql/sqlVariableSyntax.ts
@@ -3,14 +3,14 @@
 // DBX runs two client-side substitution systems before sending SQL to a backend:
 // the placeholder parameter dialog (`sqlParameters.ts`, five syntaxes) and the
 // `@set name = value;` expansion (`sqlVariables.ts`). This module lets users opt
-// out of individual syntaxes per database type. Every toggle defaults to `true`,
-// so an empty/absent config reproduces the historical "always substitute" behaviour.
+// out of individual syntaxes per database type and opt into quoted interpolation.
+// An empty/absent config reproduces the historical behaviour.
 //
-// Storage is sparse: only syntaxes explicitly turned off (`false`) are persisted,
-// keyed by database type. Anything not stored resolves to enabled.
+// Storage is sparse: only values different from their defaults are persisted,
+// keyed by database type.
 
 import type { DatabaseType } from "@/types/database";
-import type { SqlParameterSyntax } from "@/lib/sql/sqlParameters";
+import { supportsAnsiQuotesMode, supportsNoBackslashEscapesMode, type SqlParameterSyntax } from "@/lib/sql/sqlParameters";
 import { manifestDatabaseTypes } from "@/lib/database/databaseDriverManifest";
 
 export interface SqlVariableSyntaxToggles {
@@ -20,6 +20,9 @@ export interface SqlVariableSyntaxToggles {
   mybatis: boolean; // #{name}
   sqlserver: boolean; // @name
   atSet: boolean; // @set name = value;  (expandSqlVariables)
+  replaceInsideQuotes: boolean; // '${name}', "${name}", `${name}`, [${name}]
+  ansiQuotes: boolean; // MySQL-family ANSI_QUOTES session mode
+  noBackslashEscapes: boolean; // MySQL-family NO_BACKSLASH_ESCAPES session mode
 }
 
 export const DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES: SqlVariableSyntaxToggles = {
@@ -29,10 +32,13 @@ export const DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES: SqlVariableSyntaxToggles = {
   mybatis: true,
   sqlserver: true,
   atSet: true,
+  replaceInsideQuotes: false,
+  ansiQuotes: false,
+  noBackslashEscapes: false,
 };
 
 // Fixed order for iterating the toggles in the settings UI.
-export const SQL_VARIABLE_SYNTAX_KEYS = ["positional", "named", "shell", "mybatis", "sqlserver", "atSet"] as const satisfies readonly (keyof SqlVariableSyntaxToggles)[];
+export const SQL_VARIABLE_SYNTAX_KEYS = ["positional", "named", "shell", "mybatis", "sqlserver", "atSet", "replaceInsideQuotes", "ansiQuotes", "noBackslashEscapes"] as const satisfies readonly (keyof SqlVariableSyntaxToggles)[];
 
 // Display tokens (code symbols, not translated) shown next to each toggle.
 export const SQL_VARIABLE_SYNTAX_TOKENS: Record<keyof SqlVariableSyntaxToggles, string> = {
@@ -42,6 +48,9 @@ export const SQL_VARIABLE_SYNTAX_TOKENS: Record<keyof SqlVariableSyntaxToggles,
   mybatis: "#{name}",
   sqlserver: "@name",
   atSet: "@set …;",
+  replaceInsideQuotes: "'${name}'",
+  ansiQuotes: "ANSI_QUOTES",
+  noBackslashEscapes: "NO_BACKSLASH_ESCAPES",
 };
 
 // The first five toggles map one-to-one onto placeholder parameter syntaxes.
@@ -66,9 +75,17 @@ export function resolveSqlVariableSyntaxToggles(overrides: SqlVariableSyntaxOver
     mybatis: partial?.mybatis ?? true,
     sqlserver: partial?.sqlserver ?? true,
     atSet: partial?.atSet ?? true,
+    replaceInsideQuotes: partial?.replaceInsideQuotes ?? false,
+    ansiQuotes: supportsAnsiQuotesMode(dbType) ? (partial?.ansiQuotes ?? false) : false,
+    // Ignore stale or hand-written mode overrides for dialects without this mode.
+    noBackslashEscapes: supportsNoBackslashEscapesMode(dbType) ? (partial?.noBackslashEscapes ?? false) : false,
   };
 }
 
+export function sqlVariableSyntaxKeysForDatabase(dbType: DatabaseType | undefined): readonly (keyof SqlVariableSyntaxToggles)[] {
+  return SQL_VARIABLE_SYNTAX_KEYS.filter((key) => (key !== "ansiQuotes" || supportsAnsiQuotesMode(dbType)) && (key !== "noBackslashEscapes" || supportsNoBackslashEscapesMode(dbType)));
+}
+
 /** Derive the enabled placeholder parameter syntaxes (excludes `atSet`). */
 export function enabledSqlParameterSyntaxes(toggles: SqlVariableSyntaxToggles): SqlParameterSyntax[] {
   return PARAMETER_SYNTAX_KEYS.filter((key) => toggles[key]);
@@ -76,7 +93,7 @@ export function enabledSqlParameterSyntaxes(toggles: SqlVariableSyntaxToggles):
 
 /**
  * Normalize persisted overrides into a sparse structure: drop non-object entries
- * and only keep syntaxes explicitly set to `false`. Absence resolves to enabled.
+ * and only keep boolean values that differ from their defaults.
  */
 export function normalizeSqlVariableSyntaxOverrides(value: unknown): SqlVariableSyntaxOverrides {
   if (!value || typeof value !== "object" || Array.isArray(value)) return {};
@@ -85,7 +102,10 @@ export function normalizeSqlVariableSyntaxOverrides(value: unknown): SqlVariable
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) continue;
     const partial: Partial<SqlVariableSyntaxToggles> = {};
     for (const key of SQL_VARIABLE_SYNTAX_KEYS) {
-      if ((raw as Record<string, unknown>)[key] === false) partial[key] = false;
+      if (key === "ansiQuotes" && !supportsAnsiQuotesMode(dbType as DatabaseType)) continue;
+      if (key === "noBackslashEscapes" && !supportsNoBackslashEscapesMode(dbType as DatabaseType)) continue;
+      const rawValue = (raw as Record<string, unknown>)[key];
+      if (typeof rawValue === "boolean" && rawValue !== DEFAULT_SQL_VARIABLE_SYNTAX_TOGGLES[key]) partial[key] = rawValue;
     }
     if (Object.keys(partial).length > 0) result[dbType as DatabaseType] = partial;
   }
diff --git a/packages/app-tests/settingsStore.test.ts b/packages/app-tests/settingsStore.test.ts
index e63886e496..6cdc9f9fb8 100644
--- a/packages/app-tests/settingsStore.test.ts
+++ b/packages/app-tests/settingsStore.test.ts
@@ -482,6 +482,14 @@ test("defaults SQL formatter settings", () => {
   assert.deepEqual(normalizeEditorSettings({}).sqlFormatter, DEFAULT_EDITOR_SETTINGS.sqlFormatter);
 });
 
+test("normalizes quoted SQL placeholder interpolation as a sparse opt-in", () => {
+  assert.deepEqual(DEFAULT_EDITOR_SETTINGS.sqlVariableSyntaxOverrides, {});
+  assert.deepEqual(normalizeEditorSettings({ sqlVariableSyntaxOverrides: { mysql: { shell: false } } } as any).sqlVariableSyntaxOverrides, { mysql: { shell: false } });
+  assert.deepEqual(normalizeEditorSettings({ sqlVariableSyntaxOverrides: { mysql: { replaceInsideQuotes: true, ansiQuotes: true, noBackslashEscapes: true }, postgres: { replaceInsideQuotes: false, ansiQuotes: true, noBackslashEscapes: true } } } as any).sqlVariableSyntaxOverrides, {
+    mysql: { replaceInsideQuotes: true, ansiQuotes: true, noBackslashEscapes: true },
+  });
+});
+
 test("normalizes saved SQL formatter settings", () => {
   assert.deepEqual(
     normalizeEditorSettings({