Engine: duplicate INSERT on unique identity returns success as no-op

lucidprogrammer · lucidprogrammer · commit 134cce1e45c9 · 2026-04-12T23:01:46.000Z
diff --git a/crates/contextdb-engine/src/database.rs b/crates/contextdb-engine/src/database.rs
@@ -82,6 +82,16 @@ pub struct Database {
     closed: AtomicBool,
 }
 
+pub(crate) enum InsertRowResult {
+    Inserted(RowId),
+    NoOp,
+}
+
+enum RowConstraintCheck {
+    Valid,
+    DuplicateUniqueNoOp,
+}
+
 impl std::fmt::Debug for Database {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("Database")
@@ -768,6 +778,21 @@ impl Database {
         self.relational.insert(tx, table, values)
     }
 
+    pub(crate) fn insert_row_with_unique_noop(
+        &self,
+        tx: TxId,
+        table: &str,
+        values: HashMap<ColName, Value>,
+    ) -> Result<InsertRowResult> {
+        match self.check_row_constraints(tx, table, &values, None, true)? {
+            RowConstraintCheck::Valid => self
+                .relational
+                .insert(tx, table, values)
+                .map(InsertRowResult::Inserted),
+            RowConstraintCheck::DuplicateUniqueNoOp => Ok(InsertRowResult::NoOp),
+        }
+    }
+
     pub fn upsert_row(
         &self,
         tx: TxId,
@@ -816,6 +841,22 @@ impl Database {
         values: &HashMap<ColName, Value>,
         skip_row_id: Option<RowId>,
     ) -> Result<()> {
+        match self.check_row_constraints(tx, table, values, skip_row_id, false)? {
+            RowConstraintCheck::Valid => Ok(()),
+            RowConstraintCheck::DuplicateUniqueNoOp => {
+                unreachable!("strict constraint validation cannot return no-op")
+            }
+        }
+    }
+
+    fn check_row_constraints(
+        &self,
+        tx: TxId,
+        table: &str,
+        values: &HashMap<ColName, Value>,
+        skip_row_id: Option<RowId>,
+        allow_duplicate_unique_noop: bool,
+    ) -> Result<RowConstraintCheck> {
         let meta = self
             .table_meta(table)
             .ok_or_else(|| Error::TableNotFound(table.to_string()))?;
@@ -827,11 +868,7 @@ impl Database {
                     skip_row_id.is_none_or(|row_id| row.row_id != row_id)
                 })?;
 
-        for column in meta
-            .columns
-            .iter()
-            .filter(|column| column.unique && !column.primary_key)
-        {
+        for column in meta.columns.iter().filter(|column| column.primary_key) {
             let Some(value) = values.get(&column.name) else {
                 continue;
             };
@@ -849,6 +886,33 @@ impl Database {
             }
         }
 
+        let mut duplicate_unique_row_id = None;
+
+        for column in meta
+            .columns
+            .iter()
+            .filter(|column| column.unique && !column.primary_key)
+        {
+            let Some(value) = values.get(&column.name) else {
+                continue;
+            };
+            if *value == Value::Null {
+                continue;
+            }
+            let matching_row_ids: Vec<RowId> = visible_rows
+                .iter()
+                .filter(|existing| existing.values.get(&column.name) == Some(value))
+                .map(|existing| existing.row_id)
+                .collect();
+            self.merge_unique_conflict(
+                table,
+                &column.name,
+                &matching_row_ids,
+                allow_duplicate_unique_noop,
+                &mut duplicate_unique_row_id,
+            )?;
+        }
+
         for unique_constraint in &meta.unique_constraints {
             let mut candidate_values = Vec::with_capacity(unique_constraint.len());
             let mut has_null = false;
@@ -867,17 +931,60 @@ impl Database {
                 continue;
             }
 
-            if visible_rows.iter().any(|existing| {
-                unique_constraint
-                    .iter()
-                    .zip(candidate_values.iter())
-                    .all(|(column_name, value)| existing.values.get(column_name) == Some(*value))
-            }) {
+            let matching_row_ids: Vec<RowId> = visible_rows
+                .iter()
+                .filter(|existing| {
+                    unique_constraint.iter().zip(candidate_values.iter()).all(
+                        |(column_name, value)| existing.values.get(column_name) == Some(*value),
+                    )
+                })
+                .map(|existing| existing.row_id)
+                .collect();
+            self.merge_unique_conflict(
+                table,
+                &unique_constraint.join(","),
+                &matching_row_ids,
+                allow_duplicate_unique_noop,
+                &mut duplicate_unique_row_id,
+            )?;
+        }
+
+        if duplicate_unique_row_id.is_some() {
+            Ok(RowConstraintCheck::DuplicateUniqueNoOp)
+        } else {
+            Ok(RowConstraintCheck::Valid)
+        }
+    }
+
+    fn merge_unique_conflict(
+        &self,
+        table: &str,
+        column: &str,
+        matching_row_ids: &[RowId],
+        allow_duplicate_unique_noop: bool,
+        duplicate_unique_row_id: &mut Option<RowId>,
+    ) -> Result<()> {
+        if matching_row_ids.is_empty() {
+            return Ok(());
+        }
+
+        if !allow_duplicate_unique_noop || matching_row_ids.len() != 1 {
+            return Err(Error::UniqueViolation {
+                table: table.to_string(),
+                column: column.to_string(),
+            });
+        }
+
+        let matched_row_id = matching_row_ids[0];
+        if let Some(existing_row_id) = duplicate_unique_row_id {
+            if *existing_row_id != matched_row_id {
                 return Err(Error::UniqueViolation {
                     table: table.to_string(),
-                    column: unique_constraint.join(","),
+                    column: column.to_string(),
                 });
             }
+        } else {
+            *duplicate_unique_row_id = Some(matched_row_id);
         }
 
         Ok(())
diff --git a/crates/contextdb-engine/src/executor.rs b/crates/contextdb-engine/src/executor.rs
@@ -1,4 +1,4 @@
-use crate::database::{Database, QueryResult};
+use crate::database::{Database, InsertRowResult, QueryResult};
 use crate::sync_types::ConflictPolicy;
 use contextdb_core::*;
 use contextdb_parser::ast::{
@@ -986,8 +986,12 @@ fn exec_insert(
                 }
             }
         } else {
-            match db.insert_row(txid, &p.table, values.clone()) {
-                Ok(row_id) => row_id,
+            match db.insert_row_with_unique_noop(txid, &p.table, values.clone()) {
+                Ok(InsertRowResult::Inserted(row_id)) => row_id,
+                Ok(InsertRowResult::NoOp) => {
+                    db.accountant().release(row_bytes);
+                    continue;
+                }
                 Err(err) => {
                     db.accountant().release(row_bytes);
                     return Err(err);
diff --git a/crates/contextdb-engine/src/schema_enforcer.rs b/crates/contextdb-engine/src/schema_enforcer.rs
@@ -93,40 +93,6 @@ pub fn validate_dml(
                 }
             }
 
-            let unique_columns: Vec<_> = table_meta
-                .columns
-                .iter()
-                .filter(|column| column.unique && !column.primary_key)
-                .collect();
-            if !unique_columns.is_empty() {
-                let existing_rows = db.scan(&p.table, db.snapshot())?;
-                for row in &p.values {
-                    for column in &unique_columns {
-                        let Some(index) = columns.iter().position(|name| name == &column.name)
-                        else {
-                            continue;
-                        };
-                        let value = row
-                            .get(index)
-                            .ok_or_else(|| {
-                                Error::PlanError("column/value count mismatch".to_string())
-                            })
-                            .and_then(|expr| resolve_expr(expr, params))?;
-                        if value == Value::Null {
-                            continue;
-                        }
-                        if existing_rows
-                            .iter()
-                            .any(|existing| existing.values.get(&column.name) == Some(&value))
-                        {
-                            return Err(Error::UniqueViolation {
-                                table: p.table.clone(),
-                                column: column.name.clone(),
-                            });
-                        }
-                    }
-                }
-            }
             Ok(())
         }
         _ => Ok(()),
diff --git a/crates/contextdb-engine/tests/sql_surface_tests.rs b/crates/contextdb-engine/tests/sql_surface_tests.rs
@@ -1848,7 +1848,7 @@ fn con_01_not_null_rejects_null() {
 }
 
 #[test]
-fn con_02_unique_rejects_duplicate() {
+fn con_02_unique_duplicate_is_noop() {
     let db = Database::open_memory();
     db.execute(
         "CREATE TABLE uniq (id UUID PRIMARY KEY, email TEXT UNIQUE)",
@@ -1864,14 +1864,17 @@ fn con_02_unique_rejects_duplicate() {
     )
     .unwrap();
 
-    let result = db.execute(
+    db.execute(
         "INSERT INTO uniq (id, email) VALUES ($id, $email)",
         &params(vec![
             ("id", Value::Uuid(Uuid::new_v4())),
             ("email", Value::Text("alice@example.com".into())),
         ]),
-    );
-    assert!(result.is_err(), "UNIQUE column must reject duplicate value");
+    )
+    .unwrap();
+
+    let rows = db.scan("uniq", db.snapshot()).unwrap();
+    assert_eq!(rows.len(), 1, "duplicate UNIQUE insert must be a no-op");
 }
 
 #[test]
@@ -1901,7 +1904,7 @@ fn con_03_backward_compat_column_def_serde() {
 }
 
 #[test]
-fn con_04_composite_unique_rejects_duplicate_tuple() {
+fn con_04_composite_unique_duplicate_is_noop() {
     let db = Database::open_memory();
     db.execute(
         "CREATE TABLE memberships (id UUID PRIMARY KEY, org_id UUID NOT NULL, email TEXT NOT NULL, UNIQUE (org_id, email))",
@@ -1919,18 +1922,18 @@ fn con_04_composite_unique_rejects_duplicate_tuple() {
     )
     .unwrap();
 
-    let result = db.execute(
+    db.execute(
         "INSERT INTO memberships (id, org_id, email) VALUES ($id, $org_id, $email)",
         &params(vec![
             ("id", Value::Uuid(Uuid::new_v4())),
             ("org_id", Value::Uuid(Uuid::from_u128(1))),
             ("email", Value::Text("alice@example.com".into())),
         ]),
-    );
-    assert!(
-        result.is_err(),
-        "duplicate composite tuple must be rejected"
-    );
+    )
+    .unwrap();
+
+    let rows = db.scan("memberships", db.snapshot()).unwrap();
+    assert_eq!(rows.len(), 1, "duplicate composite tuple must be a no-op");
 }
 
 #[test]
@@ -3617,16 +3620,16 @@ fn integrity_10_failed_insert_does_not_leak_memory() {
     let baseline = accountant.usage().used;
 
     for _ in 0..20 {
-        let result = db.execute(
+        db.execute(
             "INSERT INTO items (id, name) VALUES ($id, 'dup')",
             &params(vec![("id", Value::Uuid(Uuid::new_v4()))]),
-        );
-        assert!(result.is_err(), "duplicate UNIQUE insert must fail");
+        )
+        .unwrap();
     }
 
     let used = accountant.usage().used;
     assert!(
         used <= baseline + 256,
-        "failed inserts must not leak memory: baseline={baseline}, used={used}"
+        "duplicate no-op inserts must not leak memory: baseline={baseline}, used={used}"
     );
 }
diff --git a/tests/acceptance/query_surface.rs b/tests/acceptance/query_surface.rs
