Ignore PostgreSQL-specific SET commands that DuckDB doesn't support

Fivetran and other PostgreSQL clients send SET commands for parameters
like ssl_renegotiation_limit, statement_timeout, work_mem, etc. that
DuckDB doesn't recognize. These now return SET success without executing.

Added 70+ PostgreSQL-specific SET parameters to the ignore list including:
- SSL/connection settings (ssl_renegotiation_limit)
- Timeout settings (statement_timeout, lock_timeout)
- Memory settings (work_mem, maintenance_work_mem)
- Planner settings (enable_seqscan, enable_hashjoin, etc.)
- Cost settings (seq_page_cost, random_page_cost, etc.)
- Transaction settings (synchronous_commit, etc.)
- JIT settings
- And many more

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: EDsCODE

server/catalog.go

@@ -359,8 +359,140 @@ var (
 	setApplicationNameToRegex = regexp.MustCompile(`(?i)^SET\s+application_name\s+TO\s+`)
 	// SHOW application_name -> SELECT getvariable('application_name') AS application_name
 	showApplicationNameRegex = regexp.MustCompile(`(?i)^SHOW\s+application_name\s*;?\s*$`)
+	// Regex to extract SET parameter name
+	setParameterRegex = regexp.MustCompile(`(?i)^SET\s+(?:SESSION\s+|LOCAL\s+)?(\w+)`)
 )
 
+// PostgreSQL-specific SET parameters that DuckDB doesn't support.
+// These will be silently ignored (return SET success without executing).
+var ignoredSetParameters = map[string]bool{
+	// SSL/Connection settings
+	"ssl_renegotiation_limit": true,
+
+	// Statement/Lock timeouts
+	"statement_timeout":                    true,
+	"lock_timeout":                         true,
+	"idle_in_transaction_session_timeout":  true,
+	"idle_session_timeout":                 true,
+
+	// Client connection settings
+	"client_min_messages":          true,
+	"log_min_messages":             true,
+	"log_min_duration_statement":   true,
+	"log_statement":                true,
+
+	// Transaction settings (DuckDB handles these differently)
+	"default_transaction_isolation":  true,
+	"default_transaction_read_only":  true,
+	"default_transaction_deferrable": true,
+	"transaction_isolation":          true,
+	"transaction_read_only":          true,
+	"transaction_deferrable":         true,
+
+	// Encoding (DuckDB is always UTF-8)
+	"client_encoding": true,
+
+	// PostgreSQL-specific features
+	"row_security":                  true,
+	"check_function_bodies":         true,
+	"default_tablespace":            true,
+	"temp_tablespaces":              true,
+	"session_replication_role":      true,
+	"vacuum_freeze_min_age":         true,
+	"vacuum_freeze_table_age":       true,
+	"bytea_output":                  true,
+	"xmlbinary":                     true,
+	"xmloption":                     true,
+	"gin_pending_list_limit":        true,
+	"gin_fuzzy_search_limit":        true,
+
+	// Locale settings
+	"lc_messages": true,
+	"lc_monetary": true,
+	"lc_numeric":  true,
+	"lc_time":     true,
+
+	// Constraint settings
+	"constraint_exclusion":       true,
+	"cursor_tuple_fraction":      true,
+	"from_collapse_limit":        true,
+	"join_collapse_limit":        true,
+	"geqo":                       true,
+	"geqo_threshold":             true,
+
+	// Parallel query settings
+	"max_parallel_workers_per_gather": true,
+	"max_parallel_workers":            true,
+	"parallel_leader_participation":   true,
+	"parallel_tuple_cost":             true,
+	"parallel_setup_cost":             true,
+	"min_parallel_table_scan_size":    true,
+	"min_parallel_index_scan_size":    true,
+
+	// Planner settings
+	"enable_bitmapscan":         true,
+	"enable_hashagg":            true,
+	"enable_hashjoin":           true,
+	"enable_indexscan":          true,
+	"enable_indexonlyscan":      true,
+	"enable_material":           true,
+	"enable_mergejoin":          true,
+	"enable_nestloop":           true,
+	"enable_parallel_append":    true,
+	"enable_parallel_hash":      true,
+	"enable_partition_pruning":  true,
+	"enable_partitionwise_join": true,
+	"enable_partitionwise_aggregate": true,
+	"enable_seqscan":            true,
+	"enable_sort":               true,
+	"enable_tidscan":            true,
+	"enable_gathermerge":        true,
+
+	// Cost settings
+	"seq_page_cost":             true,
+	"random_page_cost":          true,
+	"cpu_tuple_cost":            true,
+	"cpu_index_tuple_cost":      true,
+	"cpu_operator_cost":         true,
+	"effective_cache_size":      true,
+
+	// Memory settings
+	"work_mem":                  true,
+	"maintenance_work_mem":      true,
+	"logical_decoding_work_mem": true,
+	"temp_buffers":              true,
+
+	// Misc settings that don't apply
+	"synchronous_commit":   true,
+	"commit_delay":         true,
+	"commit_siblings":      true,
+	"huge_pages":           true,
+	"force_parallel_mode":  true,
+	"jit":                  true,
+	"jit_above_cost":       true,
+	"jit_inline_above_cost": true,
+	"jit_optimize_above_cost": true,
+
+	// Replication settings
+	"synchronous_standby_names": true,
+	"wal_sender_timeout":        true,
+	"wal_receiver_timeout":      true,
+
+	// Search path is handled separately but good to have here as fallback
+	// "search_path": true,  // This one we might want to handle specially later
+}
+
+// isIgnoredSetParameter checks if a SET command targets a PostgreSQL-specific
+// parameter that should be silently ignored in DuckDB.
+func isIgnoredSetParameter(query string) bool {
+	matches := setParameterRegex.FindStringSubmatch(query)
+	if len(matches) < 2 {
+		return false
+	}
+	paramName := strings.ToLower(matches[1])
+	return ignoredSetParameters[paramName]
+}
+
 // rewritePgCatalogQuery rewrites PostgreSQL-specific syntax for DuckDB compatibility
 func rewritePgCatalogQuery(query string) string {
 	// Replace pg_catalog.func_name( with func_name(

server/conn.go

@@ -280,6 +280,15 @@ func (c *clientConn) handleQuery(body []byte) error {
 
 	log.Printf("[%s] Query: %s", c.username, query)
 
+	// Check if this is a PostgreSQL-specific SET command that should be ignored
+	if isIgnoredSetParameter(query) {
+		log.Printf("[%s] Ignoring PostgreSQL-specific SET: %s", c.username, query)
+		writeCommandComplete(c.writer, "SET")
+		writeReadyForQuery(c.writer, c.txStatus)
+		c.writer.Flush()
+		return nil
+	}
+
 	// Rewrite pg_catalog function calls for compatibility
 	query = rewritePgCatalogQuery(query)
 
@@ -1305,6 +1314,13 @@ func (c *clientConn) handleExecute(body []byte) {
 
 	log.Printf("[%s] Execute %q with %d params: %s", c.username, portalName, len(args), p.stmt.query)
 
+	// Check if this is a PostgreSQL-specific SET command that should be ignored
+	if isIgnoredSetParameter(p.stmt.query) {
+		log.Printf("[%s] Ignoring PostgreSQL-specific SET: %s", c.username, p.stmt.query)
+		writeCommandComplete(c.writer, "SET")
+		return
+	}
+
 	if !returnsResults {
 		// Handle nested BEGIN: PostgreSQL issues a warning but continues,
 		// while DuckDB throws an error. Match PostgreSQL behavior.

server/conn_test.go

@@ -562,3 +562,44 @@ func TestQueryReturnsResultsWithComments(t *testing.T) {
 		})
 	}
 }
+
+func TestIsIgnoredSetParameter(t *testing.T) {
+	tests := []struct {
+		name     string
+		query    string
+		expected bool
+	}{
+		// PostgreSQL-specific SET commands that should be ignored
+		{"ssl_renegotiation_limit", "SET ssl_renegotiation_limit = 0", true},
+		{"ssl_renegotiation_limit TO", "SET ssl_renegotiation_limit TO 0", true},
+		{"statement_timeout", "SET statement_timeout = '30s'", true},
+		{"lock_timeout", "SET lock_timeout = 1000", true},
+		{"client_encoding", "SET client_encoding = 'UTF8'", true},
+		{"client_min_messages", "SET client_min_messages = warning", true},
+		{"row_security", "SET row_security = on", true},
+		{"work_mem", "SET work_mem = '64MB'", true},
+		{"enable_seqscan", "SET enable_seqscan = off", true},
+		{"jit", "SET jit = off", true},
+		{"synchronous_commit", "SET synchronous_commit = off", true},
+		{"SESSION prefix", "SET SESSION statement_timeout = 0", true},
+		{"LOCAL prefix", "SET LOCAL lock_timeout = 5000", true},
+		{"case insensitive", "set SSL_RENEGOTIATION_LIMIT = 0", true},
+
+		// SET commands that should NOT be ignored (pass through to DuckDB)
+		{"application_name", "SET application_name = 'myapp'", false},
+		{"timezone", "SET timezone = 'UTC'", false},
+		{"search_path", "SET search_path = public", false},
+		{"random DuckDB setting", "SET threads = 4", false},
+		{"not a SET command", "SELECT 1", false},
+		{"SET in string", "SELECT 'SET ssl_renegotiation_limit = 0'", false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := isIgnoredSetParameter(tt.query)
+			if result != tt.expected {
+				t.Errorf("isIgnoredSetParameter(%q) = %v, want %v", tt.query, result, tt.expected)
+			}
+		})
+	}
+}