Merge pull request #56 from PostHog/fix/strip-on-conflict-ducklake

Strip ON CONFLICT clause in DuckLake mode

Author: EDsCODE

transpiler/transform/onconflict.go

@@ -13,10 +13,21 @@ import (
 // Note: DuckDB's ON CONFLICT support has evolved. As of DuckDB 0.9+,
 // it supports ON CONFLICT DO NOTHING and ON CONFLICT DO UPDATE.
 // This transform handles cases where the syntax might differ.
-type OnConflictTransform struct{}
+//
+// In DuckLake mode, PRIMARY KEY and UNIQUE constraints are stripped,
+// so ON CONFLICT clauses will fail with "columns not referenced by constraint".
+// We strip ON CONFLICT entirely in DuckLake mode since there are no constraints
+// to conflict with.
+type OnConflictTransform struct {
+	DuckLakeMode bool
+}
 
 func NewOnConflictTransform() *OnConflictTransform {
-	return &OnConflictTransform{}
+	return &OnConflictTransform{DuckLakeMode: false}
+}
+
+func NewOnConflictTransformWithConfig(duckLakeMode bool) *OnConflictTransform {
+	return &OnConflictTransform{DuckLakeMode: duckLakeMode}
 }
 
 func (t *OnConflictTransform) Name() string {
@@ -46,6 +57,15 @@ func (t *OnConflictTransform) transformInsert(insert *pg_query.InsertStmt) bool
 		return false
 	}
 
+	// In DuckLake mode, we strip PRIMARY KEY and UNIQUE constraints,
+	// so ON CONFLICT clauses will fail with "columns not referenced by constraint".
+	// Strip the ON CONFLICT clause entirely since there are no constraints to conflict with.
+	// The data will be inserted normally. Fivetran's DELETE + INSERT pattern handles updates.
+	if t.DuckLakeMode {
+		insert.OnConflictClause = nil
+		return true
+	}
+
 	// DuckDB now supports ON CONFLICT syntax similar to PostgreSQL
 	// However, there are some differences:
 	//

transpiler/transpiler.go

@@ -48,8 +48,8 @@ func New(cfg Config) *Transpiler {
 	// 8. SET/SHOW command handling
 	t.transforms = append(t.transforms, transform.NewSetShowTransform())
 
-	// 9. ON CONFLICT handling
-	t.transforms = append(t.transforms, transform.NewOnConflictTransform())
+	// 9. ON CONFLICT handling (strips ON CONFLICT in DuckLake mode since constraints don't exist)
+	t.transforms = append(t.transforms, transform.NewOnConflictTransformWithConfig(cfg.DuckLakeMode))
 
 	// DDL transforms only when DuckLake mode is enabled
 	if cfg.DuckLakeMode {

transpiler/transpiler_test.go

@@ -740,6 +740,42 @@ func TestTranspile_OnConflict(t *testing.T) {
 	}
 }
 
+func TestTranspile_OnConflict_DuckLakeMode(t *testing.T) {
+	// In DuckLake mode, ON CONFLICT is stripped because PRIMARY KEY/UNIQUE constraints don't exist
+	tests := []struct {
+		name  string
+		input string
+	}{
+		{
+			name:  "ON CONFLICT DO NOTHING stripped",
+			input: "INSERT INTO users (id, name) VALUES (1, 'test') ON CONFLICT (id) DO NOTHING",
+		},
+		{
+			name:  "ON CONFLICT DO UPDATE stripped",
+			input: "INSERT INTO users (id, name) VALUES (1, 'test') ON CONFLICT (id) DO UPDATE SET name = EXCLUDED.name",
+		},
+	}
+
+	tr := New(Config{DuckLakeMode: true})
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := tr.Transpile(tt.input)
+			if err != nil {
+				t.Fatalf("Transpile(%q) error: %v", tt.input, err)
+			}
+			// ON CONFLICT should be stripped in DuckLake mode
+			if strings.Contains(strings.ToUpper(result.SQL), "ON CONFLICT") {
+				t.Errorf("Transpile(%q) = %q, should NOT contain ON CONFLICT in DuckLake mode", tt.input, result.SQL)
+			}
+			// But the INSERT should still work
+			if !strings.Contains(strings.ToUpper(result.SQL), "INSERT INTO") {
+				t.Errorf("Transpile(%q) = %q, should still contain INSERT INTO", tt.input, result.SQL)
+			}
+		})
+	}
+}
+
 func TestTranspile_JSONOperators(t *testing.T) {
 	// DuckDB supports -> and ->> operators
 	tests := []struct {