sqlrite 0.2.0__tar.gz → 0.3.0__tar.gz

{sqlrite-0.2.0 → sqlrite-0.3.0}/.github/workflows/release.yml

@@ -152,7 +152,14 @@ jobs:
   # click Approve before this job actually runs).
   publish-crate:
     name: Publish sqlrite crate to crates.io
-    needs: [detect, tag-all]
+    # Engine depends on sqlrite-ask (post-v0.1.19 dep-direction flip), so
+    # publish-ask must complete first — otherwise crates.io rejects the
+    # engine publish with "failed to select a version for the requirement
+    # `sqlrite-ask = "^X.Y"`". This was masked through 0.1.x because old
+    # sqlrite-ask versions were already on crates.io and the engine's
+    # version requirement (`^0.1`) matched them; the v0.2.0 cut surfaced
+    # the latent bug.
+    needs: [detect, tag-all, publish-ask]
     if: needs.detect.outputs.should_release == 'true'
     runs-on: ubuntu-latest
     environment: release
@@ -203,9 +210,11 @@ jobs:
 
   # ---------------------------------------------------------------------------
   # Step 3a': publish the `sqlrite-ask` crate (Phase 7g.1) — natural-
-  # language → SQL adapter built on top of the engine. Same shape as
-  # `publish-crate` above; separate job so a registry hiccup on one
-  # doesn't block the other and re-runs are surgical.
+  # language → SQL adapter. Since the v0.1.19 dep-direction flip,
+  # sqlrite-ask is dep-free of sqlrite-engine — it's a pure-string-in /
+  # string-out adapter. The engine depends on IT, not the other way
+  # around. So this job runs FIRST in the publish chain; publish-crate
+  # waits on it.
   #
   # Crate name on crates.io: `sqlrite-ask`. Library name (the `use`
   # path): `sqlrite_ask`. No alias-renaming this time — the short
@@ -213,7 +222,7 @@ jobs:
   # for why the engine had to rename).
   publish-ask:
     name: Publish sqlrite-ask crate to crates.io
-    needs: [detect, tag-all, publish-crate]
+    needs: [detect, tag-all]
     if: needs.detect.outputs.should_release == 'true'
     runs-on: ubuntu-latest
     environment: release
@@ -230,13 +239,9 @@ jobs:
         env:
           CARGO_REGISTRY_TOKEN: ${{ secrets.CRATES_IO_TOKEN }}
         # `--no-verify` mirrors `publish-crate` — Release-PR CI
-        # already validated this commit.
-        #
-        # `needs: [..., publish-crate]` is load-bearing: sqlrite-ask
-        # depends on sqlrite-engine, and crates.io rejects publishes
-        # whose path-deps haven't yet resolved to a published version
-        # at the same number. Sequencing makes the dep visible by the
-        # time we publish.
+        # already validated this commit. sqlrite-ask has no
+        # SQLRite-internal path-deps after the v0.1.19 dep-direction
+        # flip, so this job is unblocked the moment `tag-all` lands.
         run: cargo publish -p sqlrite-ask --no-verify
 
       - name: GitHub Release

{sqlrite-0.2.0 → sqlrite-0.3.0}/Cargo.lock

@@ -3817,7 +3817,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-ask"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "serde",
  "serde_json",
@@ -3828,7 +3828,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-desktop"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "serde",
  "serde_json",
@@ -3840,7 +3840,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-engine"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "clap",
  "env_logger",
@@ -3857,7 +3857,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-ffi"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "cbindgen",
  "serde",
@@ -3867,7 +3867,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-mcp"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "clap",
  "libc",
@@ -3878,7 +3878,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-nodejs"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "napi",
  "napi-build",
@@ -3888,7 +3888,7 @@ dependencies = [
 
 [[package]]
 name = "sqlrite-python"
-version = "0.2.0"
+version = "0.3.0"
 dependencies = [
  "pyo3",
  "sqlrite-engine",

{sqlrite-0.2.0 → sqlrite-0.3.0}/Cargo.toml

@@ -27,7 +27,7 @@ resolver = "3"
 # `package =` key so the import name stays `sqlrite` internally:
 #     sqlrite = { package = "sqlrite-engine", path = "…" }
 name = "sqlrite-engine"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["Joao Henrique Machado Silva <joaoh82@gmail.com>"]
 edition = "2024"
 rust-version = "1.85"
@@ -138,4 +138,4 @@ fs2 = { version = "0.4", optional = true }
 # crate publishes to crates.io, and a path-only dep without a
 # version field fails the manifest verification step. See PR #58
 # retrospective in docs/roadmap.md.
-sqlrite-ask = { version = "0.2", path = "sqlrite-ask", optional = true }
+sqlrite-ask = { version = "0.3", path = "sqlrite-ask", optional = true }

{sqlrite-0.2.0 → sqlrite-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlrite
-Version: 0.2.0
+Version: 0.3.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{sqlrite-0.2.0 → sqlrite-0.3.0}/desktop/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sqlrite-desktop-frontend",
   "private": true,
-  "version": "0.2.0",
+  "version": "0.3.0",
   "type": "module",
   "scripts": {
     "dev": "vite",

{sqlrite-0.2.0 → sqlrite-0.3.0}/docs/supported-sql.md

@@ -8,12 +8,14 @@ If you're looking for _how_ to use SQLRite (REPL flow, meta-commands, history, e
 
 | Statement | Supported today |
 |---|---|
-| [`CREATE TABLE`](#create-table) | Columns with `PRIMARY KEY` / `UNIQUE` / `NOT NULL`; typed columns; auto-indexes on constrained columns |
+| [`CREATE TABLE`](#create-table) | Columns with `PRIMARY KEY` / `UNIQUE` / `NOT NULL` / `DEFAULT <literal>`; typed columns; auto-indexes on constrained columns |
 | [`CREATE [UNIQUE] INDEX`](#create-index) | Single-column named indexes, `IF NOT EXISTS`, persisted as cell-based B-Trees |
-| [`INSERT INTO`](#insert-into) | Auto-ROWID, UNIQUE/PK enforcement, clean type errors, NULL padding |
+| [`INSERT INTO`](#insert-into) | Auto-ROWID, UNIQUE/PK enforcement, clean type errors, NULL/DEFAULT padding |
 | [`SELECT`](#select) | `*` or column list, `WHERE`, single-column `ORDER BY`, `LIMIT`; index probing on `col = literal` |
 | [`UPDATE`](#update) | Multi-column `SET`, `WHERE`, arithmetic RHS, type + UNIQUE enforcement |
 | [`DELETE`](#delete) | `WHERE` predicate or whole-table |
+| [`ALTER TABLE`](#alter-table) | `RENAME TO`, `RENAME COLUMN`, `ADD COLUMN`, `DROP COLUMN` (one operation per statement) |
+| [`DROP TABLE`](#drop-table) / [`DROP INDEX`](#drop-index) | `IF EXISTS`; single target; auto-indexes refused for `DROP INDEX` |
 | [`BEGIN`](#transactions) / [`COMMIT`](#transactions) / [`ROLLBACK`](#transactions) | Snapshot-based; single-level; WAL-backed commit; auto-rollback on COMMIT disk failure |
 
 Statements the parser accepts (because sqlparser understands them in the SQLite dialect) but SQLRite doesn't execute yet return `SQL Statement not supported yet`. The [Not yet supported](#not-yet-supported) section below enumerates the common ones.
@@ -41,12 +43,12 @@ CREATE TABLE <name> (<col> <type> [column_constraint]* [, ...]);
 
 - `PRIMARY KEY` — one column per table; the column **must** be `INTEGER` and gets auto-ROWID behavior (omitted on INSERT → auto-assigned). Auto-creates an index named `sqlrite_autoindex_<table>_<column>`.
 - `UNIQUE` — enforced at INSERT/UPDATE time. Auto-creates an index with the same naming scheme.
-- `NOT NULL` — rejects NULL at INSERT/UPDATE. Omitted columns on INSERT are NULL by default, so a `NOT NULL` without an INSERT-time value is an error.
+- `NOT NULL` — rejects NULL at INSERT/UPDATE. Omitted columns on INSERT are NULL by default (or pick up the column's `DEFAULT`, if any), so a `NOT NULL` without an INSERT-time value or DEFAULT is an error.
+- `DEFAULT <literal>` — value substituted when the column is omitted from an INSERT. Accepts integer / real / text / boolean / NULL literals (and unary `+` / `-` on numerics). Function-call defaults like `CURRENT_TIMESTAMP` and other non-literal expressions are rejected at CREATE TABLE time. Explicit `INSERT ... VALUES (..., NULL, ...)` is preserved as NULL — the default only fires for omitted columns (matches SQLite).
 
 ### What's **not** enforced at CREATE TABLE time
 
 - **Table-level constraints** (`PRIMARY KEY (col1, col2)`, `FOREIGN KEY`, `CHECK`, `UNIQUE (col1, col2)`) are parsed but ignored.
-- **`DEFAULT` values** are parsed but ignored.
 - **Multi-column `PRIMARY KEY`** — only single-column PKs work; a composite PK is accepted by the parser but treated as no PK.
 
 ### Errors returned
@@ -208,6 +210,72 @@ DELETE FROM <table> [WHERE <expr>];
 
 ---
 
+## `ALTER TABLE`
+
+```sql
+ALTER TABLE [IF EXISTS] <table> RENAME TO <new_table>;
+ALTER TABLE [IF EXISTS] <table> RENAME COLUMN <old_col> TO <new_col>;
+ALTER TABLE [IF EXISTS] <table> ADD COLUMN <col_def>;
+ALTER TABLE [IF EXISTS] <table> DROP COLUMN <col>;
+```
+
+One operation per statement (SQLite-style). `ALTER TABLE foo RENAME TO bar, ADD COLUMN x ...` is rejected — issue separate statements instead.
+
+### `RENAME TO`
+
+- Reserved-name rejection: cannot rename to `sqlrite_master`.
+- Errors if the target name is already a table.
+- Auto-indexes whose names embed the old table name (`sqlrite_autoindex_<old>_<col>`) are renamed in lockstep so the schema catalog stays consistent. Explicit indexes carry their user-given name unchanged.
+
+### `RENAME COLUMN`
+
+- Errors if the old column doesn't exist or the new name already exists in the table.
+- Re-keys the row storage and updates every dependent index (auto + explicit, secondary / HNSW / FTS) — including auto-index name regeneration.
+- Renaming the PRIMARY KEY column is allowed; the table's `primary_key` pointer follows the new name.
+
+### `ADD COLUMN`
+
+- The column definition reuses the same parser that handles CREATE TABLE columns: same types, same `NOT NULL` / `DEFAULT` semantics.
+- **Rejected:** `PRIMARY KEY` and `UNIQUE` constraints on the added column. Both would require backfilling the column under uniqueness constraints against existing rows; that path will land alongside multi-column UNIQUE.
+- **`NOT NULL` on a non-empty table requires `DEFAULT`.** Without one there's no value to backfill existing rowids with. Same rule SQLite applies.
+- With a `DEFAULT`, every existing rowid is backfilled with the default value at ADD COLUMN time. Without a `DEFAULT`, existing rowids read as NULL for the new column.
+
+### `DROP COLUMN`
+
+- **Rejected:** dropping the PRIMARY KEY column.
+- **Rejected:** dropping the only remaining column (degenerate table).
+- Cascades to every dependent index (auto + explicit, secondary / HNSW / FTS) on the dropped column.
+- `CASCADE` / `RESTRICT` modifiers are accepted by the parser and ignored — SQLite has no real distinction here either.
+
+---
+
+## `DROP TABLE`
+
+```sql
+DROP TABLE [IF EXISTS] <table>;
+```
+
+- Single target per statement. `DROP TABLE a, b, c;` is parsed but rejected with a NotImplemented error.
+- Reserved-name rejection: `DROP TABLE sqlrite_master` errors with the same message `CREATE TABLE` uses.
+- All indexes attached to the table (auto, explicit, HNSW, FTS) disappear with the table — they live inside the `Table` struct and ride along.
+- Without `IF EXISTS`, dropping a table that doesn't exist errors. With it, that's a benign 0-tables-dropped no-op.
+- **Disk pages are orphaned, not freed.** SQLRite has no free-list yet — the file size doesn't shrink until a future `VACUUM`. The behavior is safe (orphan pages are unreachable from `sqlrite_master` after reopen) but means a write-heavy schema churn won't reclaim space until VACUUM lands.
+
+---
+
+## `DROP INDEX`
+
+```sql
+DROP INDEX [IF EXISTS] <index_name>;
+```
+
+- Single target per statement.
+- Walks every table searching for an index with the given name across the secondary B-Tree, HNSW, and FTS index families.
+- **Refuses to drop auto-indexes.** `sqlrite_autoindex_*` names are constraint-bound to the column they index — the only way to remove them is to drop the underlying column or table. Same rule SQLite enforces for its `sqlite_autoindex_*` indexes.
+- `IF EXISTS` makes a missing index a benign no-op.
+
+---
+
 ## Expressions
 
 Expressions work inside `WHERE` (both in `SELECT`, `UPDATE`, `DELETE`) and on the right-hand side of `UPDATE`'s `SET`.
@@ -405,11 +473,12 @@ For context when you hit `NotImplemented`. See [Roadmap](roadmap.md) for when th
 - Built-in functions (`LENGTH`, `UPPER`, `LOWER`, `COALESCE`, `IFNULL`, date/time, `printf`, …)
 
 ### DDL
-- `ALTER TABLE` (add column, rename column, rename table)
-- `DROP TABLE`, `DROP INDEX`
+- `ALTER TABLE` extras: multi-operation (`ALTER TABLE foo RENAME TO bar, ADD COLUMN x ...`), `ALTER COLUMN ... SET / DROP DEFAULT`, `ALTER COLUMN ... TYPE`
+- `ADD COLUMN` constraint extras: `PRIMARY KEY` and `UNIQUE` on the added column (would need backfill + uniqueness against existing rows)
+- `DROP TABLE` / `DROP INDEX` extras: multi-target (`DROP TABLE a, b, c;`)
 - `CREATE VIEW`, `CREATE TRIGGER`
 - Table-level constraints (composite PK, composite UNIQUE, `FOREIGN KEY`, `CHECK`)
-- Column defaults (`DEFAULT <value>`)
+- Non-literal `DEFAULT` expressions (`CURRENT_TIMESTAMP`, function calls, column references)
 - Composite / multi-column indexes
 
 ### Transactions

{sqlrite-0.2.0 → sqlrite-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlrite"
-version = "0.2.0"
+version = "0.3.0"
 description = "Python bindings for SQLRite — a small, embeddable SQLite clone written in Rust."
 authors = [{ name = "Joao Henrique Machado Silva", email = "joaoh82@gmail.com" }]
 license = { text = "MIT" }

{sqlrite-0.2.0 → sqlrite-0.3.0}/sdk/python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlrite-python"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["Joao Henrique Machado Silva <joaoh82@gmail.com>"]
 edition = "2024"
 rust-version = "1.85"

{sqlrite-0.2.0 → sqlrite-0.3.0}/sqlrite-ask/Cargo.toml

@@ -10,7 +10,7 @@
 # Published to crates.io as `sqlrite-ask`. Joins the lockstep release
 # wave (`sqlrite-ask-vX.Y.Z` tag) — see `docs/release-plan.md`.
 name = "sqlrite-ask"
-version = "0.2.0"
+version = "0.3.0"
 authors = ["Joao Henrique Machado Silva <joaoh82@gmail.com>"]
 edition = "2024"
 rust-version = "1.85"

{sqlrite-0.2.0 → sqlrite-0.3.0}/src/sql/db/table.rs

@@ -2,7 +2,7 @@ use crate::error::{Result, SQLRiteError};
 use crate::sql::db::secondary_index::{IndexOrigin, SecondaryIndex};
 use crate::sql::fts::PostingList;
 use crate::sql::hnsw::HnswIndex;
-use crate::sql::parser::create::CreateQuery;
+use crate::sql::parser::create::{CreateQuery, ParsedColumn};
 use std::collections::{BTreeMap, HashMap};
 use std::fmt;
 use std::sync::{Arc, Mutex};
@@ -207,12 +207,13 @@ impl Table {
             if col.is_pk {
                 primary_key = col_name.to_string();
             }
-            table_cols.push(Column::new(
+            table_cols.push(Column::with_default(
                 col_name.to_string(),
                 col.datatype.to_string(),
                 col.is_pk,
                 col.not_null,
                 col.is_unique,
+                col.default.clone(),
             ));
 
             let dt = DataType::new(col.datatype.to_string());
@@ -326,13 +327,235 @@ impl Table {
     }
 
     /// Finds a secondary index by its own name (e.g., `sqlrite_autoindex_users_email`
-    /// or a user-provided CREATE INDEX name). Used by Phase 3e.2 to look up
-    /// explicit indexes when DROP INDEX lands.
-    #[allow(dead_code)]
+    /// or a user-provided CREATE INDEX name). Used by DROP INDEX and the
+    /// rename helpers below.
     pub fn index_by_name(&self, name: &str) -> Option<&SecondaryIndex> {
         self.secondary_indexes.iter().find(|i| i.name == name)
     }
 
+    /// Renames a column in place. Updates row storage, the `Column`
+    /// metadata, every secondary / HNSW / FTS index whose `column_name`
+    /// matches, the `primary_key` pointer if the renamed column is the
+    /// PK, and any auto-index name that embedded the old column name.
+    ///
+    /// Caller-side validation (table existence, source-column existence
+    /// at the surface level, IF EXISTS) lives in the executor; this
+    /// method enforces the column-level invariants that have to be
+    /// checked under the `Table` borrow anyway.
+    pub fn rename_column(&mut self, old: &str, new: &str) -> Result<()> {
+        if !self.columns.iter().any(|c| c.column_name == old) {
+            return Err(SQLRiteError::General(format!(
+                "column '{old}' does not exist in table '{}'",
+                self.tb_name
+            )));
+        }
+        if old != new && self.columns.iter().any(|c| c.column_name == new) {
+            return Err(SQLRiteError::General(format!(
+                "column '{new}' already exists in table '{}'",
+                self.tb_name
+            )));
+        }
+        if old == new {
+            return Ok(());
+        }
+
+        for col in self.columns.iter_mut() {
+            if col.column_name == old {
+                col.column_name = new.to_string();
+            }
+        }
+
+        // Re-key the per-column row map.
+        {
+            let mut rows = self.rows.lock().expect("rows mutex poisoned");
+            if let Some(storage) = rows.remove(old) {
+                rows.insert(new.to_string(), storage);
+            }
+        }
+
+        if self.primary_key == old {
+            self.primary_key = new.to_string();
+        }
+
+        let table_name = self.tb_name.clone();
+        for idx in self.secondary_indexes.iter_mut() {
+            if idx.column_name == old {
+                idx.column_name = new.to_string();
+                if idx.origin == IndexOrigin::Auto
+                    && idx.name == SecondaryIndex::auto_name(&table_name, old)
+                {
+                    idx.name = SecondaryIndex::auto_name(&table_name, new);
+                }
+            }
+        }
+        for entry in self.hnsw_indexes.iter_mut() {
+            if entry.column_name == old {
+                entry.column_name = new.to_string();
+            }
+        }
+        for entry in self.fts_indexes.iter_mut() {
+            if entry.column_name == old {
+                entry.column_name = new.to_string();
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Appends a new column to this table from a parsed column spec.
+    /// The new column's row storage is allocated empty; existing rowids
+    /// read NULL for the new column unless `parsed.default` is set, in
+    /// which case those rowids are backfilled with the default value.
+    ///
+    /// Rejects PK / UNIQUE on the added column (would require
+    /// backfill-with-uniqueness-check against existing rows). Rejects
+    /// NOT NULL without DEFAULT on a non-empty table — same rule SQLite
+    /// applies, and necessary because we have no other backfill source.
+    pub fn add_column(&mut self, parsed: ParsedColumn) -> Result<()> {
+        if self.contains_column(parsed.name.clone()) {
+            return Err(SQLRiteError::General(format!(
+                "column '{}' already exists in table '{}'",
+                parsed.name, self.tb_name
+            )));
+        }
+        if parsed.is_pk {
+            return Err(SQLRiteError::General(
+                "cannot ADD COLUMN with PRIMARY KEY constraint on existing table".to_string(),
+            ));
+        }
+        if parsed.is_unique {
+            return Err(SQLRiteError::General(
+                "cannot ADD COLUMN with UNIQUE constraint on existing table".to_string(),
+            ));
+        }
+        let table_has_rows = self
+            .columns
+            .first()
+            .map(|c| {
+                self.rows
+                    .lock()
+                    .expect("rows mutex poisoned")
+                    .get(&c.column_name)
+                    .map(|r| r.rowids().len())
+                    .unwrap_or(0)
+                    > 0
+            })
+            .unwrap_or(false);
+        if parsed.not_null && parsed.default.is_none() && table_has_rows {
+            return Err(SQLRiteError::General(format!(
+                "cannot ADD COLUMN '{}' NOT NULL without DEFAULT to a non-empty table",
+                parsed.name
+            )));
+        }
+
+        let new_column = Column::with_default(
+            parsed.name.clone(),
+            parsed.datatype.clone(),
+            parsed.is_pk,
+            parsed.not_null,
+            parsed.is_unique,
+            parsed.default.clone(),
+        );
+
+        // Allocate empty row storage for the new column. Mirrors the
+        // dispatch in `Table::new` so the new column behaves identically
+        // to one declared at CREATE TABLE time.
+        let row_storage = match &new_column.datatype {
+            DataType::Integer => Row::Integer(BTreeMap::new()),
+            DataType::Real => Row::Real(BTreeMap::new()),
+            DataType::Text => Row::Text(BTreeMap::new()),
+            DataType::Bool => Row::Bool(BTreeMap::new()),
+            DataType::Vector(_dim) => Row::Vector(BTreeMap::new()),
+            DataType::Json => Row::Text(BTreeMap::new()),
+            DataType::Invalid | DataType::None => Row::None,
+        };
+        {
+            let mut rows = self.rows.lock().expect("rows mutex poisoned");
+            rows.insert(parsed.name.clone(), row_storage);
+        }
+
+        // Backfill existing rowids with the default value, if any.
+        // NULL defaults are a no-op — a missing key in the BTreeMap reads
+        // as NULL anyway. Type mismatches were caught at `parse_one_column`
+        // time when the DEFAULT was evaluated against the declared
+        // datatype; reaching the `_` arm here would indicate a bug.
+        if let Some(default) = &parsed.default {
+            let existing_rowids = self.rowids();
+            let mut rows = self.rows.lock().expect("rows mutex poisoned");
+            let storage = rows.get_mut(&parsed.name).expect("just inserted");
+            match (storage, default) {
+                (Row::Integer(tree), Value::Integer(v)) => {
+                    let v32 = *v as i32;
+                    for rowid in existing_rowids {
+                        tree.insert(rowid, v32);
+                    }
+                }
+                (Row::Real(tree), Value::Real(v)) => {
+                    let v32 = *v as f32;
+                    for rowid in existing_rowids {
+                        tree.insert(rowid, v32);
+                    }
+                }
+                (Row::Text(tree), Value::Text(v)) => {
+                    for rowid in existing_rowids {
+                        tree.insert(rowid, v.clone());
+                    }
+                }
+                (Row::Bool(tree), Value::Bool(v)) => {
+                    for rowid in existing_rowids {
+                        tree.insert(rowid, *v);
+                    }
+                }
+                (_, Value::Null) => {} // no-op
+                (storage_ref, _) => {
+                    return Err(SQLRiteError::Internal(format!(
+                        "DEFAULT type does not match column storage for '{}': storage variant {:?}, default {:?}",
+                        parsed.name,
+                        std::mem::discriminant(storage_ref),
+                        default
+                    )));
+                }
+            }
+        }
+
+        self.columns.push(new_column);
+        Ok(())
+    }
+
+    /// Removes a column from this table. Refuses to drop the PRIMARY KEY
+    /// column or the only remaining column. Cascades to every index
+    /// (auto, explicit, HNSW, FTS) that referenced the column.
+    pub fn drop_column(&mut self, name: &str) -> Result<()> {
+        if !self.contains_column(name.to_string()) {
+            return Err(SQLRiteError::General(format!(
+                "column '{name}' does not exist in table '{}'",
+                self.tb_name
+            )));
+        }
+        if self.primary_key == name {
+            return Err(SQLRiteError::General(format!(
+                "cannot drop primary key column '{name}'"
+            )));
+        }
+        if self.columns.len() == 1 {
+            return Err(SQLRiteError::General(format!(
+                "cannot drop the only column of table '{}'",
+                self.tb_name
+            )));
+        }
+
+        self.columns.retain(|c| c.column_name != name);
+        {
+            let mut rows = self.rows.lock().expect("rows mutex poisoned");
+            rows.remove(name);
+        }
+        self.secondary_indexes.retain(|i| i.column_name != name);
+        self.hnsw_indexes.retain(|i| i.column_name != name);
+        self.fts_indexes.retain(|i| i.column_name != name);
+
+        Ok(())
+    }
+
     /// Returns a `bool` informing if a `Column` with a specific name exists or not
     ///
     pub fn contains_column(&self, column: String) -> bool {
@@ -822,10 +1045,12 @@ impl Table {
         for i in 0..column_names.len() {
             let mut val = String::from("Null");
             let key = &column_names[i];
+            let mut column_supplied = false;
 
             if let Some(supplied_key) = cols.get(j) {
                 if supplied_key == &column_names[i] {
                     val = values[j].to_string();
+                    column_supplied = true;
                     j += 1;
                 } else if self.primary_key == column_names[i] {
                     // PK already stored in the auto-assign branch above.
@@ -835,6 +1060,17 @@ impl Table {
                 continue;
             }
 
+            // Column was omitted from the INSERT column list. Substitute its
+            // DEFAULT literal if one was declared at CREATE TABLE time;
+            // otherwise it stays as the "Null" sentinel set above. SQLite
+            // semantics: an *explicit* NULL is preserved as NULL — the
+            // default only fires for omitted columns.
+            if !column_supplied {
+                if let Some(default) = &self.columns[i].default {
+                    val = default.to_default_insert_string();
+                }
+            }
+
             // Step 1: write into row storage and compute the typed Value
             // we'll hand to the secondary index (if any).
             let typed_value: Option<Value> = {
@@ -1129,15 +1365,36 @@ pub struct Column {
     pub is_pk: bool,
     pub not_null: bool,
     pub is_unique: bool,
+    /// Literal value to substitute when this column is omitted from an
+    /// INSERT. Restricted to literal expressions at CREATE TABLE time.
+    /// `None` means "no DEFAULT declared"; an INSERT that omits the column
+    /// gets `Value::Null` instead.
+    pub default: Option<Value>,
 }
 
 impl Column {
+    /// Builds a `Column` without a `DEFAULT` clause. Existing call sites
+    /// (catalog-table setup, test fixtures) keep working unchanged.
     pub fn new(
         name: String,
         datatype: String,
         is_pk: bool,
         not_null: bool,
         is_unique: bool,
+    ) -> Self {
+        Self::with_default(name, datatype, is_pk, not_null, is_unique, None)
+    }
+
+    /// Builds a `Column` with an optional `DEFAULT` literal. Used by the
+    /// CREATE TABLE / `parse_create_sql` paths that propagate user-supplied
+    /// defaults from `ParsedColumn`.
+    pub fn with_default(
+        name: String,
+        datatype: String,
+        is_pk: bool,
+        not_null: bool,
+        is_unique: bool,
+        default: Option<Value>,
     ) -> Self {
         let dt = DataType::new(datatype);
         Column {
@@ -1146,6 +1403,7 @@ impl Column {
             is_pk,
             not_null,
             is_unique,
+            default,
         }
     }
 }
@@ -1275,6 +1533,25 @@ impl Value {
             Value::Null => String::from("NULL"),
         }
     }
+
+    /// Renders this value in the same stringly format that
+    /// [`crate::sql::parser::insert::InsertQuery::new`] produces for INSERT
+    /// values, so a DEFAULT can be substituted into the existing
+    /// `insert_row` parse pipeline without a parallel typed path.
+    ///
+    /// The differences from [`Self::to_display_string`] that matter:
+    ///   - `NULL` renders as the `"Null"` sentinel that `insert_row` matches.
+    ///   - Text stays unquoted (the insert pipeline strips quotes upstream).
+    pub fn to_default_insert_string(&self) -> String {
+        match self {
+            Value::Integer(v) => v.to_string(),
+            Value::Text(s) => s.clone(),
+            Value::Real(f) => f.to_string(),
+            Value::Bool(b) => b.to_string(),
+            Value::Vector(v) => format_vector_for_display(v),
+            Value::Null => String::from("Null"),
+        }
+    }
 }
 
 /// Parse a bracket-array literal like `"[0.1, 0.2, 0.3]"` (or `"[1, 2, 3]"`)