@lix-js/sdk 0.6.0-preview.4 → 0.6.0-preview.5

package/dist-engine-src/src/sql2/bind/table.rs

@@ -0,0 +1,273 @@
+use datafusion::sql::sqlparser::ast::ObjectName;
+
+use crate::LixError;
+
+use super::super::catalog::{PublicCatalog, PublicSurfaceContract};
+use super::expr::BoundColumnRef;
+use super::write::BoundWriteOp;
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct BoundTable {
+    pub(crate) name: String,
+    pub(crate) surface: PublicSurfaceContract,
+}
+
+pub(crate) fn bind_exact_table_name(name: &ObjectName) -> Result<String, LixError> {
+    if name.0.len() != 1 {
+        return Err(super::error::unsupported(
+            "qualified SQL table names are not supported",
+        ));
+    }
+    name.0
+        .first()
+        .and_then(|part| part.as_ident())
+        .map(|ident| {
+            if ident.quote_style.is_some() {
+                ident.value.clone()
+            } else {
+                ident.value.to_ascii_lowercase()
+            }
+        })
+        .ok_or_else(|| super::error::unsupported("unsupported SQL table name"))
+}
+
+pub(crate) fn bind_public_table(
+    catalog: &PublicCatalog,
+    name: &ObjectName,
+) -> Result<BoundTable, LixError> {
+    let table_name = bind_exact_table_name(name)?;
+    let surface = catalog.require_surface(&table_name)?.clone();
+    Ok(BoundTable {
+        name: table_name,
+        surface,
+    })
+}
+
+pub(crate) fn require_public_column<'a>(
+    table: &'a BoundTable,
+    column_name: &str,
+) -> Result<&'a super::super::catalog::PublicColumn, LixError> {
+    if table.surface.public_column(column_name).is_some() {
+        return Ok(table
+            .surface
+            .public_column(column_name)
+            .expect("checked public column"));
+    }
+    if table.surface.column(column_name).is_some() {
+        return Err(LixError::new(
+            LixError::CODE_COLUMN_NOT_FOUND,
+            format!(
+                "column '{column_name}' is not part of public SQL surface '{}'",
+                table.name
+            ),
+        ));
+    }
+    Err(LixError::new(
+        LixError::CODE_COLUMN_NOT_FOUND,
+        format!(
+            "column '{column_name}' does not exist on SQL table '{}'",
+            table.name
+        ),
+    ))
+}
+
+pub(crate) fn require_writable_column(
+    table: &BoundTable,
+    column_name: &str,
+    op: BoundWriteOp,
+) -> Result<BoundColumnRef, LixError> {
+    let column = require_public_column(table, column_name)?;
+    let allowed = match op {
+        BoundWriteOp::Insert => column.is_insertable(),
+        BoundWriteOp::Update => column.is_updatable(),
+        BoundWriteOp::Delete => false,
+    };
+    if !allowed {
+        if table.name == "lix_branch" && column_name == "id" && op == BoundWriteOp::Update {
+            return Err(super::error::unsupported(
+                "UPDATE lix_branch cannot change immutable column 'id'",
+            ));
+        }
+        return Err(super::error::unsupported(format!(
+            "column '{column_name}' is not writable on SQL table '{}'",
+            table.name
+        )));
+    }
+    Ok(BoundColumnRef {
+        table: table.name.clone(),
+        column_id: column.id,
+        name: column.name.clone(),
+    })
+}
+
+pub(crate) fn bind_public_column_ref(
+    table: &BoundTable,
+    column_name: &str,
+) -> Result<BoundColumnRef, LixError> {
+    let column = require_public_column(table, column_name)?;
+    Ok(BoundColumnRef {
+        table: table.name.clone(),
+        column_id: column.id,
+        name: column.name.clone(),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use datafusion::sql::sqlparser::ast::{SetExpr, Statement, TableFactor};
+    use datafusion::sql::sqlparser::dialect::GenericDialect;
+    use datafusion::sql::sqlparser::parser::Parser;
+    use serde_json::json;
+
+    use super::*;
+    use crate::sql2::catalog::PublicSurfaceKind;
+
+    #[test]
+    fn rejects_qualified_table_name_even_when_leaf_exists() {
+        let catalog = catalog();
+        let error = bind_public_table(&catalog, &table_name("SELECT * FROM foo.lix_state"))
+            .expect_err("qualified table should be rejected");
+
+        assert_eq!(error.code, LixError::CODE_UNSUPPORTED_SQL);
+    }
+
+    #[test]
+    fn rejects_unknown_table_name() {
+        let catalog = catalog();
+        let error = bind_public_table(&catalog, &table_name("SELECT * FROM missing"))
+            .expect_err("unknown table should be rejected");
+
+        assert_eq!(error.code, LixError::CODE_UNSUPPORTED_SQL);
+        assert!(error.message.contains("unknown SQL table 'missing'"));
+    }
+
+    #[test]
+    fn base_entity_table_does_not_expose_branch_column() {
+        let catalog = catalog();
+        let table = bind_public_table(&catalog, &table_name("SELECT * FROM test_state_schema"))
+            .expect("base entity table should bind");
+
+        assert!(matches!(
+            table.surface.kind,
+            PublicSurfaceKind::EntityBase { .. }
+        ));
+        assert!(require_public_column(&table, "name").is_ok());
+        let error = require_public_column(&table, "lixcol_branch_id")
+            .expect_err("base entity surface should not expose branch column");
+        assert!(error.message.contains("does not exist"));
+    }
+
+    #[test]
+    fn by_branch_entity_exposes_lixcol_branch_id_without_branch_id_alias() {
+        let catalog = catalog();
+        let table = bind_public_table(
+            &catalog,
+            &table_name("SELECT * FROM test_state_schema_by_branch"),
+        )
+        .expect("by-branch entity table should bind");
+
+        assert!(matches!(
+            table.surface.kind,
+            PublicSurfaceKind::EntityByBranch { .. }
+        ));
+        assert!(require_public_column(&table, "lixcol_branch_id").is_ok());
+        let error = require_public_column(&table, "branch_id")
+            .expect_err("by-branch entity surface should not alias branch_id");
+        assert!(error.message.contains("does not exist"));
+    }
+
+    #[test]
+    fn quoted_table_names_are_case_sensitive() {
+        let catalog = catalog();
+
+        bind_public_table(&catalog, &table_name("SELECT * FROM \"lix_state\""))
+            .expect("quoted exact case should bind");
+        let error = bind_public_table(&catalog, &table_name("SELECT * FROM \"LIX_STATE\""))
+            .expect_err("quoted mixed case should not be folded");
+
+        assert!(error.message.contains("unknown SQL table 'LIX_STATE'"));
+    }
+
+    #[test]
+    fn hidden_columns_cannot_bind_as_public_columns() {
+        let catalog = catalog();
+        let table = bind_public_table(&catalog, &table_name("SELECT * FROM lix_file"))
+            .expect("lix_file should bind");
+
+        let error = require_public_column(&table, "lixcol_schema_key")
+            .expect_err("hidden column should not bind");
+        assert!(error.message.contains("not part of public SQL surface"));
+    }
+
+    #[test]
+    fn catalog_rejects_duplicate_public_surface_names() {
+        let error = PublicCatalog::from_visible_schemas(&[json!({
+            "x-lix-key": "lix_file",
+            "properties": {
+                "id": { "type": "string" }
+            }
+        })])
+        .expect_err("system table collisions should be rejected");
+
+        assert_eq!(error.code, LixError::CODE_SCHEMA_DEFINITION);
+        assert!(error
+            .message
+            .contains("duplicate public SQL surface 'lix_file'"));
+    }
+
+    #[test]
+    fn catalog_uses_validated_entity_surface_derivation() {
+        let catalog = PublicCatalog::from_visible_schemas(&[json!({
+            "x-lix-key": "bad_entity",
+            "properties": {
+                "value": { "type": "null" }
+            }
+        })])
+        .expect("invalid entity schemas should match provider behavior and be skipped");
+
+        assert!(catalog.surface("bad_entity").is_none());
+    }
+
+    #[test]
+    fn dynamic_entity_history_surface_uses_provider_history_column_names() {
+        let catalog = catalog();
+        let table = bind_public_table(
+            &catalog,
+            &table_name("SELECT * FROM test_state_schema_history"),
+        )
+        .expect("entity history surface should bind");
+
+        assert!(matches!(
+            table.surface.kind,
+            PublicSurfaceKind::EntityHistory { .. }
+        ));
+        assert!(require_public_column(&table, "lixcol_entity_pk").is_ok());
+        assert!(require_public_column(&table, "lixcol_snapshot_content").is_ok());
+    }
+
+    fn catalog() -> PublicCatalog {
+        PublicCatalog::from_visible_schemas(&[json!({
+            "x-lix-key": "test_state_schema",
+            "properties": {
+                "id": { "type": "string" },
+                "name": { "type": "string" },
+                "lixcol_internal": { "type": "string" }
+            }
+        })])
+        .expect("test catalog")
+    }
+
+    fn table_name(sql: &str) -> ObjectName {
+        let mut statements = Parser::parse_sql(&GenericDialect {}, sql).expect("parse SQL");
+        let Some(Statement::Query(query)) = statements.pop() else {
+            panic!("expected query");
+        };
+        let SetExpr::Select(select) = query.body.as_ref() else {
+            panic!("expected select");
+        };
+        let TableFactor::Table { name, .. } = &select.from[0].relation else {
+            panic!("expected table factor");
+        };
+        name.clone()
+    }
+}

package/dist-engine-src/src/sql2/bind/write.rs

@@ -0,0 +1,86 @@
+use super::expr::{BoundColumnRef, BoundExpr, BoundParamRef};
+use super::read::BoundRead;
+use crate::sql2::plan::branch_scope::BranchScope;
+use crate::sql2::plan::predicate::BoundPredicate;
+use std::collections::BTreeMap;
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct BoundWrite {
+    pub(crate) target: BoundWriteTarget,
+    pub(crate) op: BoundWriteOp,
+    pub(crate) input: BoundWriteInput,
+    pub(crate) predicate: BoundPredicate,
+    pub(crate) assignments: Vec<BoundAssignment>,
+    pub(crate) params: BoundParamMap,
+    pub(crate) branch_scope: BranchScope,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) enum BoundWriteTarget {
+    LixState,
+    LixStateByBranch,
+    Entity(EntityWriteSurface),
+    File(FileWriteSurface),
+    Directory(DirectoryWriteSurface),
+    Branch,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) enum EntityWriteSurface {
+    Base { schema_key: String },
+    ByBranch { schema_key: String },
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) enum FileWriteSurface {
+    Base,
+    ByBranch,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) enum DirectoryWriteSurface {
+    Base,
+    ByBranch,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) enum BoundWriteOp {
+    Insert,
+    Update,
+    Delete,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) enum BoundWriteInput {
+    Values(BoundInsertValues),
+    Query {
+        query: Box<BoundRead>,
+        columns: Vec<BoundColumnRef>,
+    },
+    None,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct BoundInsertValues {
+    pub(crate) columns: Vec<BoundColumnRef>,
+    pub(crate) rows: Vec<Vec<BoundExpr>>,
+}
+
+impl BoundInsertValues {
+    pub(crate) fn column_index(&self, column_name: &str) -> Option<usize> {
+        self.columns
+            .iter()
+            .position(|column| column.name == column_name)
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct BoundAssignment {
+    pub(crate) column: BoundColumnRef,
+    pub(crate) value: BoundExpr,
+}
+
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub(crate) struct BoundParamMap {
+    pub(crate) params: BTreeMap<usize, BoundParamRef>,
+}