refatored vault

src-tauri/src/crdt/transformer.rs

@@ -0,0 +1,787 @@
+use crate::crdt::trigger::{HLC_TIMESTAMP_COLUMN, TOMBSTONE_COLUMN};
+use crate::database::error::DatabaseError;
+use crate::table_names::{TABLE_CRDT_CONFIGS, TABLE_CRDT_LOGS};
+use sqlparser::ast::{
+    Assignment, AssignmentTarget, BinaryOperator, ColumnDef, DataType, Expr, Ident, Insert,
+    ObjectName, ObjectNamePart, SelectItem, SetExpr, Statement, TableFactor, TableObject, Value,
+};
+use std::borrow::Cow;
+use std::collections::HashSet;
+use uhlc::Timestamp;
+
+/// Konfiguration für CRDT-Spalten
+#[derive(Clone)]
+struct CrdtColumns {
+    tombstone: &'static str,
+    hlc_timestamp: &'static str,
+}
+
+impl CrdtColumns {
+    const DEFAULT: Self = Self {
+        tombstone: TOMBSTONE_COLUMN,
+        hlc_timestamp: HLC_TIMESTAMP_COLUMN,
+    };
+
+    /// Erstellt einen Tombstone-Filter für eine Tabelle
+    fn create_tombstone_filter(&self, table_alias: Option<&str>) -> Expr {
+        let column_expr = match table_alias {
+            Some(alias) => {
+                // Qualifizierte Referenz: alias.tombstone
+                Expr::CompoundIdentifier(vec![Ident::new(alias), Ident::new(self.tombstone)])
+            }
+            None => {
+                // Einfache Referenz: tombstone
+                Expr::Identifier(Ident::new(self.tombstone))
+            }
+        };
+
+        Expr::BinaryOp {
+            left: Box::new(column_expr),
+            op: BinaryOperator::NotEq,
+            right: Box::new(Expr::Value(Value::Number("1".to_string(), false).into())),
+        }
+    }
+
+    /// Erstellt eine Tombstone-Zuweisung für UPDATE/DELETE
+    fn create_tombstone_assignment(&self) -> Assignment {
+        Assignment {
+            target: AssignmentTarget::ColumnName(ObjectName(vec![ObjectNamePart::Identifier(
+                Ident::new(self.tombstone),
+            )])),
+            value: Expr::Value(Value::Number("1".to_string(), false).into()),
+        }
+    }
+
+    /// Erstellt eine HLC-Zuweisung für UPDATE/DELETE
+    fn create_hlc_assignment(&self, timestamp: &Timestamp) -> Assignment {
+        Assignment {
+            target: AssignmentTarget::ColumnName(ObjectName(vec![ObjectNamePart::Identifier(
+                Ident::new(self.hlc_timestamp),
+            )])),
+            value: Expr::Value(Value::SingleQuotedString(timestamp.to_string()).into()),
+        }
+    }
+
+    /// Fügt CRDT-Spalten zu einer Tabellendefinition hinzu
+    fn add_to_table_definition(&self, columns: &mut Vec<ColumnDef>) {
+        if !columns.iter().any(|c| c.name.value == self.tombstone) {
+            columns.push(ColumnDef {
+                name: Ident::new(self.tombstone),
+                data_type: DataType::Integer(None),
+                options: vec![],
+            });
+        }
+        if !columns.iter().any(|c| c.name.value == self.hlc_timestamp) {
+            columns.push(ColumnDef {
+                name: Ident::new(self.hlc_timestamp),
+                data_type: DataType::String(None),
+                options: vec![],
+            });
+        }
+    }
+}
+
+pub struct CrdtTransformer {
+    columns: CrdtColumns,
+    excluded_tables: HashSet<&'static str>,
+}
+
+impl CrdtTransformer {
+    pub fn new() -> Self {
+        let mut excluded_tables = HashSet::new();
+        excluded_tables.insert(TABLE_CRDT_CONFIGS);
+        excluded_tables.insert(TABLE_CRDT_LOGS);
+
+        Self {
+            columns: CrdtColumns::DEFAULT,
+            excluded_tables,
+        }
+    }
+
+    /// Prüft, ob eine Tabelle CRDT-Synchronisation unterstützen soll
+    fn is_crdt_sync_table(&self, name: &ObjectName) -> bool {
+        let table_name = self.normalize_table_name(name);
+        !self.excluded_tables.contains(table_name.as_ref())
+    }
+
+    /// Normalisiert Tabellennamen (entfernt Anführungszeichen)
+    fn normalize_table_name(&self, name: &ObjectName) -> Cow<str> {
+        let name_str = name.to_string().to_lowercase();
+        Cow::Owned(name_str.trim_matches('`').trim_matches('"').to_string())
+    }
+
+    pub fn transform_select_statement(&self, stmt: &mut Statement) -> Result<(), DatabaseError> {
+        match stmt {
+            Statement::Query(query) => self.transform_query_recursive(query),
+            // Fange alle anderen Fälle ab und gib einen Fehler zurück
+            _ => Err(DatabaseError::UnsupportedStatement {
+                statement_type: format!("{:?}", stmt)
+                    .split('(')
+                    .next()
+                    .unwrap_or("")
+                    .to_string(),
+                description: "This operation only accepts SELECT statements.".to_string(),
+            }),
+        }
+    }
+
+    pub fn transform_execute_statement(
+        &self,
+        stmt: &mut Statement,
+        hlc_timestamp: &Timestamp,
+    ) -> Result<Option<String>, DatabaseError> {
+        match stmt {
+            Statement::CreateTable(create_table) => {
+                if self.is_crdt_sync_table(&create_table.name) {
+                    self.columns
+                        .add_to_table_definition(&mut create_table.columns);
+                    Ok(Some(
+                        self.normalize_table_name(&create_table.name).into_owned(),
+                    ))
+                } else {
+                    Ok(None)
+                }
+            }
+            Statement::Insert(insert_stmt) => {
+                if let TableObject::TableName(name) = &insert_stmt.table {
+                    if self.is_crdt_sync_table(name) {
+                        self.transform_insert(insert_stmt, hlc_timestamp)?;
+                    }
+                }
+                Ok(None)
+            }
+            Statement::Update {
+                table, assignments, ..
+            } => {
+                if let TableFactor::Table { name, .. } = &table.relation {
+                    if self.is_crdt_sync_table(name) {
+                        assignments.push(self.columns.create_hlc_assignment(hlc_timestamp));
+                    }
+                }
+                Ok(None)
+            }
+            Statement::Delete(del_stmt) => {
+                if let Some(table_name) = self.extract_table_name_from_delete(del_stmt) {
+                    if self.is_crdt_sync_table(&table_name) {
+                        self.transform_delete_to_update(stmt, hlc_timestamp)?;
+                    }
+                    Ok(None)
+                } else {
+                    Err(DatabaseError::UnsupportedStatement {
+                        statement_type: "DELETE".to_string(),
+                        description: "DELETE from non-table source or multiple tables".to_string(),
+                    })
+                }
+            }
+            Statement::AlterTable { name, .. } => {
+                if self.is_crdt_sync_table(name) {
+                    Ok(Some(self.normalize_table_name(name).into_owned()))
+                } else {
+                    Ok(None)
+                }
+            }
+            _ => Ok(None),
+        }
+    }
+
+    /// Transformiert Query-Statements (fügt Tombstone-Filter hinzu)
+    fn transform_query_recursive(
+        &self,
+        query: &mut sqlparser::ast::Query,
+    ) -> Result<(), DatabaseError> {
+        self.add_tombstone_filters_recursive(&mut query.body)
+    }
+
+    /// Rekursive Behandlung aller SetExpr-Typen mit vollständiger Subquery-Unterstützung
+    fn add_tombstone_filters_recursive(&self, set_expr: &mut SetExpr) -> Result<(), DatabaseError> {
+        match set_expr {
+            SetExpr::Select(select) => {
+                self.add_tombstone_filters_to_select(select)?;
+
+                // Transformiere auch Subqueries in Projektionen
+                for projection in &mut select.projection {
+                    match projection {
+                        SelectItem::UnnamedExpr(expr) | SelectItem::ExprWithAlias { expr, .. } => {
+                            self.transform_expression_subqueries(expr)?;
+                        }
+                        _ => {} // Wildcard projections ignorieren
+                    }
+                }
+
+                // Transformiere Subqueries in WHERE
+                if let Some(where_clause) = &mut select.selection {
+                    self.transform_expression_subqueries(where_clause)?;
+                }
+
+                // Transformiere Subqueries in GROUP BY
+                match &mut select.group_by {
+                    sqlparser::ast::GroupByExpr::All(_) => {
+                        // GROUP BY ALL - keine Expressions zu transformieren
+                    }
+                    sqlparser::ast::GroupByExpr::Expressions(exprs, _) => {
+                        for group_expr in exprs {
+                            self.transform_expression_subqueries(group_expr)?;
+                        }
+                    }
+                }
+
+                // Transformiere Subqueries in HAVING
+                if let Some(having) = &mut select.having {
+                    self.transform_expression_subqueries(having)?;
+                }
+            }
+            SetExpr::SetOperation { left, right, .. } => {
+                self.add_tombstone_filters_recursive(left)?;
+                self.add_tombstone_filters_recursive(right)?;
+            }
+            SetExpr::Query(query) => {
+                self.add_tombstone_filters_recursive(&mut query.body)?;
+            }
+            SetExpr::Values(values) => {
+                // Transformiere auch Subqueries in Values-Listen
+                for row in &mut values.rows {
+                    for expr in row {
+                        self.transform_expression_subqueries(expr)?;
+                    }
+                }
+            }
+            _ => {} // Andere Fälle
+        }
+        Ok(())
+    }
+
+    /// Transformiert Subqueries innerhalb von Expressions
+    fn transform_expression_subqueries(&self, expr: &mut Expr) -> Result<(), DatabaseError> {
+        match expr {
+            // Einfache Subqueries
+            Expr::Subquery(query) => {
+                self.add_tombstone_filters_recursive(&mut query.body)?;
+            }
+            // EXISTS Subqueries
+            Expr::Exists { subquery, .. } => {
+                self.add_tombstone_filters_recursive(&mut subquery.body)?;
+            }
+            // IN Subqueries
+            Expr::InSubquery {
+                expr: left_expr,
+                subquery,
+                ..
+            } => {
+                self.transform_expression_subqueries(left_expr)?;
+                self.add_tombstone_filters_recursive(&mut subquery.body)?;
+            }
+            // ANY/ALL Subqueries
+            Expr::AnyOp { left, right, .. } | Expr::AllOp { left, right, .. } => {
+                self.transform_expression_subqueries(left)?;
+                self.transform_expression_subqueries(right)?;
+            }
+            // Binäre Operationen
+            Expr::BinaryOp { left, right, .. } => {
+                self.transform_expression_subqueries(left)?;
+                self.transform_expression_subqueries(right)?;
+            }
+            // Unäre Operationen
+            Expr::UnaryOp {
+                expr: inner_expr, ..
+            } => {
+                self.transform_expression_subqueries(inner_expr)?;
+            }
+            // Verschachtelte Ausdrücke
+            Expr::Nested(nested) => {
+                self.transform_expression_subqueries(nested)?;
+            }
+            // CASE-Ausdrücke
+            Expr::Case {
+                operand,
+                conditions,
+                else_result,
+                ..
+            } => {
+                if let Some(op) = operand {
+                    self.transform_expression_subqueries(op)?;
+                }
+                for case_when in conditions {
+                    self.transform_expression_subqueries(&mut case_when.condition)?;
+                    self.transform_expression_subqueries(&mut case_when.result)?;
+                }
+                if let Some(else_res) = else_result {
+                    self.transform_expression_subqueries(else_res)?;
+                }
+            }
+            // Funktionsaufrufe
+            Expr::Function(func) => match &mut func.args {
+                sqlparser::ast::FunctionArguments::List(sqlparser::ast::FunctionArgumentList {
+                    args,
+                    ..
+                }) => {
+                    for arg in args {
+                        if let sqlparser::ast::FunctionArg::Unnamed(
+                            sqlparser::ast::FunctionArgExpr::Expr(expr),
+                        ) = arg
+                        {
+                            self.transform_expression_subqueries(expr)?;
+                        }
+                    }
+                }
+                _ => {}
+            },
+            // BETWEEN
+            Expr::Between {
+                expr: main_expr,
+                low,
+                high,
+                ..
+            } => {
+                self.transform_expression_subqueries(main_expr)?;
+                self.transform_expression_subqueries(low)?;
+                self.transform_expression_subqueries(high)?;
+            }
+            // IN Liste
+            Expr::InList {
+                expr: main_expr,
+                list,
+                ..
+            } => {
+                self.transform_expression_subqueries(main_expr)?;
+                for list_expr in list {
+                    self.transform_expression_subqueries(list_expr)?;
+                }
+            }
+            // IS NULL/IS NOT NULL
+            Expr::IsNull(inner) | Expr::IsNotNull(inner) => {
+                self.transform_expression_subqueries(inner)?;
+            }
+            // Andere Expression-Typen benötigen keine Transformation
+            _ => {}
+        }
+        Ok(())
+    }
+
+    /// Fügt Tombstone-Filter zu SELECT-Statements hinzu (nur wenn nicht explizit in WHERE gesetzt)
+    fn add_tombstone_filters_to_select(
+        &self,
+        select: &mut sqlparser::ast::Select,
+    ) -> Result<(), DatabaseError> {
+        // Sammle alle CRDT-Tabellen mit ihren Aliasen
+        let mut crdt_tables = Vec::new();
+        for twj in &select.from {
+            if let TableFactor::Table { name, alias, .. } = &twj.relation {
+                if self.is_crdt_sync_table(name) {
+                    let table_alias = alias.as_ref().map(|a| a.name.value.as_str());
+                    crdt_tables.push((name.clone(), table_alias));
+                }
+            }
+        }
+
+        if crdt_tables.is_empty() {
+            return Ok(());
+        }
+
+        // Prüfe, welche Tombstone-Spalten bereits in der WHERE-Klausel referenziert werden
+        let explicitly_filtered_tables = if let Some(where_clause) = &select.selection {
+            self.find_explicitly_filtered_tombstone_tables(where_clause, &crdt_tables)
+        } else {
+            HashSet::new()
+        };
+
+        // Erstelle Filter nur für Tabellen, die noch nicht explizit gefiltert werden
+        let mut tombstone_filters = Vec::new();
+        for (table_name, table_alias) in crdt_tables {
+            let table_name_string = table_name.to_string();
+            let table_key = table_alias.unwrap_or(&table_name_string);
+            if !explicitly_filtered_tables.contains(table_key) {
+                tombstone_filters.push(self.columns.create_tombstone_filter(table_alias));
+            }
+        }
+
+        // Füge die automatischen Filter hinzu
+        if !tombstone_filters.is_empty() {
+            let combined_filter = tombstone_filters
+                .into_iter()
+                .reduce(|acc, expr| Expr::BinaryOp {
+                    left: Box::new(acc),
+                    op: BinaryOperator::And,
+                    right: Box::new(expr),
+                })
+                .unwrap();
+
+            match &mut select.selection {
+                Some(existing) => {
+                    *existing = Expr::BinaryOp {
+                        left: Box::new(existing.clone()),
+                        op: BinaryOperator::And,
+                        right: Box::new(combined_filter),
+                    };
+                }
+                None => {
+                    select.selection = Some(combined_filter);
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Findet alle Tabellen, die bereits explizit Tombstone-Filter in der WHERE-Klausel haben
+    fn find_explicitly_filtered_tombstone_tables(
+        &self,
+        where_expr: &Expr,
+        crdt_tables: &[(ObjectName, Option<&str>)],
+    ) -> HashSet<String> {
+        let mut filtered_tables = HashSet::new();
+        self.scan_expression_for_tombstone_references(
+            where_expr,
+            crdt_tables,
+            &mut filtered_tables,
+        );
+        filtered_tables
+    }
+
+    /// Rekursiv durchsucht einen Expression-Baum nach Tombstone-Spalten-Referenzen
+    fn scan_expression_for_tombstone_references(
+        &self,
+        expr: &Expr,
+        crdt_tables: &[(ObjectName, Option<&str>)],
+        filtered_tables: &mut HashSet<String>,
+    ) {
+        match expr {
+            // Einfache Spaltenreferenz: tombstone = ?
+            Expr::Identifier(ident) => {
+                if ident.value == self.columns.tombstone {
+                    // Wenn keine Tabelle spezifiziert ist und es nur eine CRDT-Tabelle gibt
+                    if crdt_tables.len() == 1 {
+                        let table_name_str = crdt_tables[0].0.to_string();
+                        let table_key = crdt_tables[0].1.unwrap_or(&table_name_str);
+                        filtered_tables.insert(table_key.to_string());
+                    }
+                }
+            }
+            // Qualifizierte Spaltenreferenz: table.tombstone = ? oder alias.tombstone = ?
+            Expr::CompoundIdentifier(idents) => {
+                if idents.len() == 2 && idents[1].value == self.columns.tombstone {
+                    let table_ref = &idents[0].value;
+
+                    // Prüfe, ob es eine unserer CRDT-Tabellen ist (nach Name oder Alias)
+                    for (table_name, alias) in crdt_tables {
+                        let table_name_str = table_name.to_string();
+                        if table_ref == &table_name_str || alias.map_or(false, |a| a == table_ref) {
+                            filtered_tables.insert(table_ref.clone());
+                            break;
+                        }
+                    }
+                }
+            }
+            // Binäre Operationen: AND, OR, etc.
+            Expr::BinaryOp { left, right, .. } => {
+                self.scan_expression_for_tombstone_references(left, crdt_tables, filtered_tables);
+                self.scan_expression_for_tombstone_references(right, crdt_tables, filtered_tables);
+            }
+            // Unäre Operationen: NOT, etc.
+            Expr::UnaryOp { expr, .. } => {
+                self.scan_expression_for_tombstone_references(expr, crdt_tables, filtered_tables);
+            }
+            // Verschachtelte Ausdrücke
+            Expr::Nested(nested) => {
+                self.scan_expression_for_tombstone_references(nested, crdt_tables, filtered_tables);
+            }
+            // IN-Klauseln
+            Expr::InList { expr, .. } => {
+                self.scan_expression_for_tombstone_references(expr, crdt_tables, filtered_tables);
+            }
+            // BETWEEN-Klauseln
+            Expr::Between { expr, .. } => {
+                self.scan_expression_for_tombstone_references(expr, crdt_tables, filtered_tables);
+            }
+            // IS NULL/IS NOT NULL
+            Expr::IsNull(expr) | Expr::IsNotNull(expr) => {
+                self.scan_expression_for_tombstone_references(expr, crdt_tables, filtered_tables);
+            }
+            // Funktionsaufrufe - KORRIGIERT
+            Expr::Function(func) => {
+                match &func.args {
+                    sqlparser::ast::FunctionArguments::List(
+                        sqlparser::ast::FunctionArgumentList { args, .. },
+                    ) => {
+                        for arg in args {
+                            if let sqlparser::ast::FunctionArg::Unnamed(
+                                sqlparser::ast::FunctionArgExpr::Expr(expr),
+                            ) = arg
+                            {
+                                self.scan_expression_for_tombstone_references(
+                                    expr,
+                                    crdt_tables,
+                                    filtered_tables,
+                                );
+                            }
+                        }
+                    }
+                    _ => {} // Andere FunctionArguments-Varianten ignorieren
+                }
+            }
+            // CASE-Ausdrücke - KORRIGIERT
+            Expr::Case {
+                operand,
+                conditions,
+                else_result,
+                ..
+            } => {
+                if let Some(op) = operand {
+                    self.scan_expression_for_tombstone_references(op, crdt_tables, filtered_tables);
+                }
+                for case_when in conditions {
+                    self.scan_expression_for_tombstone_references(
+                        &case_when.condition,
+                        crdt_tables,
+                        filtered_tables,
+                    );
+                    self.scan_expression_for_tombstone_references(
+                        &case_when.result,
+                        crdt_tables,
+                        filtered_tables,
+                    );
+                }
+                if let Some(else_res) = else_result {
+                    self.scan_expression_for_tombstone_references(
+                        else_res,
+                        crdt_tables,
+                        filtered_tables,
+                    );
+                }
+            }
+            // Subqueries mit vollständiger Unterstützung
+            Expr::Subquery(query) => {
+                self.transform_query_recursive_for_tombstone_analysis(
+                    query,
+                    crdt_tables,
+                    filtered_tables,
+                )
+                .ok();
+            }
+            // EXISTS/NOT EXISTS Subqueries
+            Expr::Exists { subquery, .. } => {
+                self.transform_query_recursive_for_tombstone_analysis(
+                    subquery,
+                    crdt_tables,
+                    filtered_tables,
+                )
+                .ok();
+            }
+            // IN/NOT IN Subqueries
+            Expr::InSubquery { expr, subquery, .. } => {
+                self.scan_expression_for_tombstone_references(expr, crdt_tables, filtered_tables);
+                self.transform_query_recursive_for_tombstone_analysis(
+                    subquery,
+                    crdt_tables,
+                    filtered_tables,
+                )
+                .ok();
+            }
+            // ANY/ALL Subqueries
+            Expr::AnyOp { left, right, .. } | Expr::AllOp { left, right, .. } => {
+                self.scan_expression_for_tombstone_references(left, crdt_tables, filtered_tables);
+                self.scan_expression_for_tombstone_references(right, crdt_tables, filtered_tables);
+            }
+            // Andere Expression-Typen ignorieren wir für jetzt
+            _ => {}
+        }
+    }
+
+    /// Analysiert eine Subquery und sammelt Tombstone-Referenzen
+    fn transform_query_recursive_for_tombstone_analysis(
+        &self,
+        query: &sqlparser::ast::Query,
+        crdt_tables: &[(ObjectName, Option<&str>)],
+        filtered_tables: &mut HashSet<String>,
+    ) -> Result<(), DatabaseError> {
+        self.analyze_set_expr_for_tombstone_references(&query.body, crdt_tables, filtered_tables)
+    }
+
+    /// Rekursiv analysiert SetExpr für Tombstone-Referenzen
+    fn analyze_set_expr_for_tombstone_references(
+        &self,
+        set_expr: &SetExpr,
+        crdt_tables: &[(ObjectName, Option<&str>)],
+        filtered_tables: &mut HashSet<String>,
+    ) -> Result<(), DatabaseError> {
+        match set_expr {
+            SetExpr::Select(select) => {
+                // Analysiere WHERE-Klausel
+                if let Some(where_clause) = &select.selection {
+                    self.scan_expression_for_tombstone_references(
+                        where_clause,
+                        crdt_tables,
+                        filtered_tables,
+                    );
+                }
+
+                // Analysiere alle Projektionen (können auch Subqueries enthalten)
+                for projection in &select.projection {
+                    match projection {
+                        SelectItem::UnnamedExpr(expr) | SelectItem::ExprWithAlias { expr, .. } => {
+                            self.scan_expression_for_tombstone_references(
+                                expr,
+                                crdt_tables,
+                                filtered_tables,
+                            );
+                        }
+                        _ => {} // Wildcard projections ignorieren
+                    }
+                }
+
+                // Analysiere GROUP BY
+                match &select.group_by {
+                    sqlparser::ast::GroupByExpr::All(_) => {
+                        // GROUP BY ALL - keine Expressions zu analysieren
+                    }
+                    sqlparser::ast::GroupByExpr::Expressions(exprs, _) => {
+                        for group_expr in exprs {
+                            self.scan_expression_for_tombstone_references(
+                                group_expr,
+                                crdt_tables,
+                                filtered_tables,
+                            );
+                        }
+                    }
+                }
+
+                // Analysiere HAVING
+                if let Some(having) = &select.having {
+                    self.scan_expression_for_tombstone_references(
+                        having,
+                        crdt_tables,
+                        filtered_tables,
+                    );
+                }
+            }
+            SetExpr::SetOperation { left, right, .. } => {
+                self.analyze_set_expr_for_tombstone_references(left, crdt_tables, filtered_tables)?;
+                self.analyze_set_expr_for_tombstone_references(
+                    right,
+                    crdt_tables,
+                    filtered_tables,
+                )?;
+            }
+            SetExpr::Query(query) => {
+                self.analyze_set_expr_for_tombstone_references(
+                    &query.body,
+                    crdt_tables,
+                    filtered_tables,
+                )?;
+            }
+            SetExpr::Values(values) => {
+                // Analysiere Values-Listen
+                for row in &values.rows {
+                    for expr in row {
+                        self.scan_expression_for_tombstone_references(
+                            expr,
+                            crdt_tables,
+                            filtered_tables,
+                        );
+                    }
+                }
+            }
+            _ => {} // Andere Varianten
+        }
+        Ok(())
+    }
+
+    /// Transformiert INSERT-Statements (fügt HLC-Timestamp hinzu)
+    fn transform_insert(
+        &self,
+        insert_stmt: &mut Insert,
+        timestamp: &Timestamp,
+    ) -> Result<(), DatabaseError> {
+        insert_stmt
+            .columns
+            .push(Ident::new(self.columns.hlc_timestamp));
+
+        match insert_stmt.source.as_mut() {
+            Some(query) => match &mut *query.body {
+                SetExpr::Values(values) => {
+                    for row in &mut values.rows {
+                        row.push(Expr::Value(
+                            Value::SingleQuotedString(timestamp.to_string()).into(),
+                        ));
+                    }
+                }
+                SetExpr::Select(select) => {
+                    let hlc_expr =
+                        Expr::Value(Value::SingleQuotedString(timestamp.to_string()).into());
+                    select.projection.push(SelectItem::UnnamedExpr(hlc_expr));
+                }
+                _ => {
+                    return Err(DatabaseError::UnsupportedStatement {
+                        statement_type: "INSERT".to_string(),
+                        description: "INSERT with unsupported source type".to_string(),
+                    });
+                }
+            },
+            None => {
+                return Err(DatabaseError::UnsupportedStatement {
+                    statement_type: "INSERT".to_string(),
+                    description: "INSERT statement has no source".to_string(),
+                });
+            }
+        }
+        Ok(())
+    }
+
+    /// Transformiert DELETE zu UPDATE (soft delete)
+    fn transform_delete_to_update(
+        &self,
+        stmt: &mut Statement,
+        timestamp: &Timestamp,
+    ) -> Result<(), DatabaseError> {
+        if let Statement::Delete(del_stmt) = stmt {
+            let table_to_update = match &del_stmt.from {
+                sqlparser::ast::FromTable::WithFromKeyword(from)
+                | sqlparser::ast::FromTable::WithoutKeyword(from) => {
+                    if from.len() == 1 {
+                        from[0].clone()
+                    } else {
+                        return Err(DatabaseError::UnsupportedStatement {
+                            statement_type: "DELETE".to_string(),
+                            description: "DELETE with multiple tables not supported".to_string(),
+                        });
+                    }
+                }
+            };
+
+            let assignments = vec![
+                self.columns.create_tombstone_assignment(),
+                self.columns.create_hlc_assignment(timestamp),
+            ];
+
+            *stmt = Statement::Update {
+                table: table_to_update,
+                assignments,
+                from: None,
+                selection: del_stmt.selection.clone(),
+                returning: None,
+                or: None,
+            };
+        }
+        Ok(())
+    }
+
+    /// Extrahiert Tabellennamen aus DELETE-Statement
+    fn extract_table_name_from_delete(
+        &self,
+        del_stmt: &sqlparser::ast::Delete,
+    ) -> Option<ObjectName> {
+        let tables = match &del_stmt.from {
+            sqlparser::ast::FromTable::WithFromKeyword(from)
+            | sqlparser::ast::FromTable::WithoutKeyword(from) => from,
+        };
+
+        if tables.len() == 1 {
+            if let TableFactor::Table { name, .. } = &tables[0].relation {
+                Some(name.clone())
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }
+}