Tables: schemas, rows, updates, and compaction

import infino
import pyarrow as pa

# Durable storage (a path or s3:// URI), required if you'll update/delete later.
db = infino.connect("./data")

schema = pa.schema([
    pa.field("doc_id", pa.large_utf8(), nullable=False),
    pa.field("body", pa.large_utf8(), nullable=False),
    pa.field("embedding", pa.list_(pa.float32(), 384), nullable=False),
])
docs = db.create_table(
    "docs", schema,
    infino.IndexSpec().fts("body").vector("embedding", 384, 64, "cosine"),
)

# One append is one atomic commit, durable when the call returns.
docs.append([
    {"doc_id": "1", "body": "To cancel, open Settings then Billing.", "embedding": embed("...")},
])

import { connect, IndexSpec } from "@infino-ai/infino";

// Durable storage (a path or s3:// URI), required if you'll update/delete later.
const db = connect("./data");

const docs = db.createTable(
  "docs",
  { doc_id: "large_utf8", body: "large_utf8", embedding: { vector: 384 } },
  new IndexSpec().fts("body").vector("embedding", 384, 64, "cosine"),
);

// One append is one atomic commit, durable when the call returns.
docs.append([
  { doc_id: "1", body: "To cancel, open Settings then Billing.", embedding: embed("...") },
]);

use std::sync::Arc;
use arrow_schema::{DataType, Field, Schema};
use infino::{connect, IndexSpec, Metric};

// Durable storage (a path or s3:// URI), required if you'll update/delete later.
let db = connect("./data")?;

let item = Arc::new(Field::new("item", DataType::Float32, true));
let schema = Arc::new(Schema::new(vec![
    Field::new("doc_id", DataType::LargeUtf8, false),
    Field::new("body", DataType::LargeUtf8, false),
    Field::new("embedding", DataType::FixedSizeList(item, 384), false),
]));
let docs = db.create_table(
    "docs", schema,
    IndexSpec::new().fts("body").vector("embedding", 384, 64, Metric::Cosine),
)?;

// One append is one atomic commit. Build `batch` as an Arrow RecordBatch
// matching the schema (see the Quickstart).
docs.append(&batch)?;

docs = db.open_table("docs")

const docs = db.openTable("docs");

let docs = db.open_table("docs")?;

# Replace the row(s) matching the predicate (1:1 with the new rows):
docs.update("doc_id = '1'", [
    {"doc_id": "1", "body": "Refunds go to the original payment method.", "embedding": embed("...")},
])

# Delete rows matching a predicate:
stats = docs.delete("doc_id = '1'")
print(stats.matched, stats.n_tombstoned)

// Replace the row(s) matching the predicate (1:1 with the new rows):
docs.update("doc_id = '1'", [
  { doc_id: "1", body: "Refunds go to the original payment method.", embedding: embed("...") },
]);

// Delete rows matching a predicate:
const stats = docs.delete("doc_id = '1'");
console.log(stats.matched, stats.nTombstoned);

use datafusion_expr::{col, lit};   // build predicates as DataFusion expressions

// Replace the row(s) matching the predicate (1:1 with the new rows in `batch`):
docs.update(col("doc_id").eq(lit("1")), &batch)?;

// Delete rows matching a predicate:
let stats = docs.delete(col("doc_id").eq(lit("1")))?;
println!("{} matched, {} tombstoned", stats.matched, stats.n_tombstoned);

docs.optimize()                    # merge small / underfilled superfiles
db.list_tables()                   # ["docs"]
db.drop_table("docs", purge=True)  # purge=True also deletes the table's storage

docs.optimize();                   // merge small / underfilled superfiles
db.listTables();                   // ["docs"]
db.dropTable("docs", true);        // purge=true also deletes the table's storage

use infino::OptimizeOptions;

docs.optimize(&OptimizeOptions::default())?;  // merge small / underfilled superfiles
db.list_tables()?;                            // Vec<String>
db.drop_table("docs", true)?;                 // purge = true also deletes storage

report = docs.gc(3600.0)                        # delete orphans older than 1 hour
print(report.bytes_freed, report.objects_deleted)

const report = docs.gc(3600);                   // delete orphans older than 1 hour
console.log(report.bytesFreed, report.objectsDeleted);

use std::time::Duration;

let report = docs.gc(Duration::from_secs(3600))?;  // delete orphans older than 1 hour
println!("{} {}", report.bytes_freed, report.objects_deleted);