> ## Documentation Index > Fetch the complete documentation index at: https://docs.lancedb.com/llms.txt > Use this file to discover all available pages before exploring further. # Ingesting Data > Learn about different methods to ingest data into tables in LanceDB, including from various data sources and empty tables. In LanceDB, tables store records with a defined schema that specifies column names and types. Across the SDKs, you can create tables from row-oriented data and Apache Arrow data structures. The Python SDK additionally supports: * PyArrow schemas for explicit schema control * `LanceModel` for Pydantic-based validation ## Create a table with data Initialize a LanceDB connection and create a table import lancedb uri = "data/sample-lancedb" db = lancedb.connect(uri) import \* as lancedb from "@lancedb/lancedb"; async function connectExample(uri: string) \{ const db = await lancedb.connect(uri); return db; } async fn connect\_example(uri: \&str) \{ let db = connect(uri).execute().await.unwrap(); let \_ = db; } Depending on the SDK, LanceDB can ingest arrays of records, Arrow tables or record batches, and Arrow batch iterators or readers. Let's take a look at some of the common patterns. ### From list of objects You can provide a list of objects to create a table. The Python and TypeScript SDKs support lists/arrays of dictionaries, while the Rust SDK supports lists of structs. In Python, pass a list or other batch-like object; a single bare `dict` or single `LanceModel` is rejected. data = \[ \{"vector": \[1.1, 1.2], "lat": 45.5, "long": -122.7}, \{"vector": \[0.2, 1.8], "lat": 40.1, "long": -74.1}, ] db = tmp\_db db.create\_table("test\_table", data, mode="overwrite") tbl = db\["test\_table"] tbl.head() type Location = \{ vector: number\[]; lat: number; long: number; }; const data: Location\[] = \[ \{ vector: \[1.1, 1.2], lat: 45.5, long: -122.7 }, \{ vector: \[0.2, 1.8], lat: 40.1, long: -74.1 }, ]; const table = await db.createTable("test\_table", data, \{ mode: "overwrite", }); struct Location \{ vector: \[f32; 2], lat: f32, long: f32, } let data = vec!\[ Location \{ vector: \[1.1, 1.2], lat: 45.5, long: -122.7, }, Location \{ vector: \[0.2, 1.8], lat: 40.1, long: -74.1, }, ]; let schema = Arc::new(Schema::new(vec!\[ Field::new( "vector", DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Float32, true)), 2), false, ), Field::new("lat", DataType::Float32, false), Field::new("long", DataType::Float32, false), ])); let batch = RecordBatch::try\_new( schema.clone(), vec!\[ Arc::new( FixedSizeListArray::from\_iter\_primitive::\( data.iter() .map(|row| Some(row\.vector.iter().copied().map(Some).collect::\>())), 2, ), ), Arc::new(Float32Array::from\_iter\_values( data.iter().map(|row| row\.lat), )), Arc::new(Float32Array::from\_iter\_values( data.iter().map(|row| row\.long), )), ], ) .unwrap(); let reader: Box\ = Box::new(RecordBatchIterator::new(vec!\[Ok(batch)].into\_iter(), schema.clone())); let table = db .create\_table("test\_table", reader) .mode(CreateTableMode::Overwrite) .execute() .await .unwrap(); ### Handle existing tables By default, `create_table` raises an error if a table with the same name already exists. You can change this behavior with two parameters that resolve the conflict in different ways: * **Idempotent open**: return the existing table without modifying it. Use when your code may run more than once (notebooks, retries, init scripts) and you want to reuse the table on subsequent runs. The provided data is ignored, but the schema is validated against the existing table and a mismatch raises an error. * **Overwrite**: drop the existing table and create a new one with the provided data. Use this for test fixtures or when you intentionally want to replace prior contents. This permanently discards the old table's data. \# Idempotent open: reuse the existing table if it exists. \# The provided data is ignored; the schema is validated against the \# existing table and a mismatch raises an error. tbl = db.create\_table("conflict\_table", data, exist\_ok=True) \# Overwrite: drop the existing table and create a new one with the \# provided data. This permanently discards the old table's data. tbl = db.create\_table("conflict\_table", data, mode="overwrite") // Idempotent open: reuse the existing table if it exists. // The provided data is ignored; the schema is validated against the // existing table and a mismatch raises an error. let conflictTable = await db.createTable("conflict\_table", data, \{ existOk: true, }); // Overwrite: drop the existing table and create a new one with the // provided data. This permanently discards the old table's data. conflictTable = await db.createTable("conflict\_table", data, \{ mode: "overwrite", }); // Idempotent open: reuse the existing table if it exists. // The provided data is ignored; the schema is validated against the // existing table and a mismatch raises an error. let \_conflict\_table = db .create\_table("conflict\_table", exist\_ok\_reader) .mode(CreateTableMode::exist\_ok(|req| req)) .execute() .await .unwrap(); // Overwrite: drop the existing table and create a new one with the // provided data. This permanently discards the old table's data. let conflict\_table = db .create\_table("conflict\_table", overwrite\_reader) .mode(CreateTableMode::Overwrite) .execute() .await .unwrap(); > [!NOTE] > > `exist_ok` / `existOk` does not append the provided data to an existing table. Use > [`table.add()`](https://docs.lancedb.com/tables/update) for that. If you need to ensure a table exists *and* > contains specific rows, prefer the [empty-table-then-add pattern](#create-empty-table). ### From a custom schema You can define a custom Arrow schema for the table. This is useful when you want to have more control over the column types and metadata. import pyarrow as pa custom\_schema = pa.schema( \[ pa.field("vector", pa.list\_(pa.float32(), 4)), pa.field("lat", pa.float32()), pa.field("long", pa.float32()), ] ) data = \[ \{"vector": \[1.1, 1.2, 1.3, 1.4], "lat": 45.5, "long": -122.7}, \{"vector": \[0.2, 1.8, 0.4, 3.6], "lat": 40.1, "long": -74.1}, ] db = tmp\_db tbl = db.create\_table( "my\_table\_custom\_schema", data, schema=custom\_schema, mode="overwrite" ) const customSchema = new arrow\.Schema(\[ new arrow\.Field( "vector", new arrow\.FixedSizeList( 4, new arrow\.Field("item", new arrow\.Float32(), true), ), ), new arrow\.Field("lat", new arrow\.Float32()), new arrow\.Field("long", new arrow\.Float32()), ]); const customSchemaData = lancedb.makeArrowTable( \[ \{ vector: \[1.1, 1.2, 1.3, 1.4], lat: 45.5, long: -122.7 }, \{ vector: \[0.2, 1.8, 0.4, 3.6], lat: 40.1, long: -74.1 }, ], \{ schema: customSchema }, ); const customSchemaTable = await db.createTable( "my\_table\_custom\_schema", customSchemaData, \{ mode: "overwrite" }, ); let custom\_schema = Arc::new(Schema::new(vec!\[ Field::new( "vector", DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Float32, true)), 4), false, ), Field::new("lat", DataType::Float32, false), Field::new("long", DataType::Float32, false), ])); let custom\_batch = RecordBatch::try\_new( custom\_schema.clone(), vec!\[ Arc::new( FixedSizeListArray::from\_iter\_primitive::\( vec!\[ Some(vec!\[Some(1.1), Some(1.2), Some(1.3), Some(1.4)]), Some(vec!\[Some(0.2), Some(1.8), Some(0.4), Some(3.6)]), ], 4, ), ), Arc::new(Float32Array::from(vec!\[45.5, 40.1])), Arc::new(Float32Array::from(vec!\[-122.7, -74.1])), ], ) .unwrap(); let custom\_reader: Box\ = Box::new(RecordBatchIterator::new(vec!\[Ok(custom\_batch)].into\_iter(), custom\_schema.clone())); let custom\_table = db .create\_table("my\_table\_custom\_schema", custom\_reader) .mode(CreateTableMode::Overwrite) .execute() .await .unwrap(); An explicit schema is also where you control nullability. If later writes omit a non-nullable column, or provide actual nulls for it, ingestion fails; nullable columns can be omitted or written with null values. Without an explicit schema, Python infers list-like vector values as fixed-size `float32` vector fields from the observed dimension. For Python ingest, malformed vector values fail by default. If you expect occasional wrong-length, null, or NaN vectors, choose an `on_bad_vectors` policy: `"drop"` removes those rows, `"fill"` writes `fill_value`, and `"null"` writes nulls. ### From an Arrow Table You can also create LanceDB tables directly from Arrow tables. Rust uses an Arrow `RecordBatchReader` for the same Arrow-native ingest flow. import numpy as np import pyarrow as pa dim = 16 total = 2 schema = pa.schema( \[pa.field("vector", pa.list\_(pa.float16(), dim)), pa.field("text", pa.string())] ) data = pa.Table.from\_arrays( \[ pa.array( \[np.random.randn(dim).astype(np.float16) for \_ in range(total)], pa.list\_(pa.float16(), dim), ), pa.array(\["foo", "bar"]), ], \["vector", "text"], ) db = tmp\_db tbl = db.create\_table("f16\_tbl", data, schema=schema, mode="overwrite") const arrowSchema = new arrow\.Schema(\[ new arrow\.Field( "vector", new arrow\.FixedSizeList( 16, new arrow\.Field("item", new arrow\.Float32(), true), ), ), new arrow\.Field("text", new arrow\.Utf8()), ]); const arrowData = lancedb.makeArrowTable( \[ \{ vector: Array(16).fill(0.1), text: "foo" }, \{ vector: Array(16).fill(0.2), text: "bar" }, ], \{ schema: arrowSchema }, ); const arrowTable = await db.createTable("f32\_tbl", arrowData, \{ mode: "overwrite", }); let arrow\_schema = Arc::new(Schema::new(vec!\[ Field::new( "vector", DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Float32, true)), 16), false, ), Field::new("text", DataType::Utf8, false), ])); let arrow\_batch = RecordBatch::try\_new( arrow\_schema.clone(), vec!\[ Arc::new( FixedSizeListArray::from\_iter\_primitive::\( vec!\[Some(vec!\[Some(0.1); 16]), Some(vec!\[Some(0.2); 16])], 16, ), ), Arc::new(StringArray::from(vec!\["foo", "bar"])), ], ) .unwrap(); let arrow\_reader: Box\ = Box::new(RecordBatchIterator::new(vec!\[Ok(arrow\_batch)].into\_iter(), arrow\_schema.clone())); let arrow\_table = db .create\_table("arrow\_table\_example", arrow\_reader) .mode(CreateTableMode::Overwrite) .execute() .await .unwrap(); ### From a Pandas DataFrame Python Only import pandas as pd data = pd.DataFrame( \{ "vector": \[\[1.1, 1.2, 1.3, 1.4], \[0.2, 1.8, 0.4, 3.6]], "lat": \[45.5, 40.1], "long": \[-122.7, -74.1], } ) db = tmp\_db db.create\_table("my\_table\_pandas", data, mode="overwrite") db\["my\_table\_pandas"].head() > [!NOTE] > > Data is converted to Arrow before being written to disk. For maximum control over how data is saved, either provide the PyArrow schema to convert to or else provide a PyArrow Table directly. > [!NOTE] > > The **`vector`** column needs to be a [Vector](https://docs.lancedb.com/integrations/data/pydantic.md#vector-field) (defined as [pyarrow.FixedSizeList](https://arrow.apache.org/docs/python/generated/pyarrow.list_.html)) type. ### From a Polars DataFrame Python Only LanceDB supports [Polars](https://pola.rs/), a modern, fast DataFrame library written in Rust. Just like in Pandas, the Polars integration is enabled by PyArrow under the hood. A deeper integration between LanceDB Tables and Polars DataFrames is on the way. import polars as pl data = pl.DataFrame( \{ "vector": \[\[3.1, 4.1], \[5.9, 26.5]], "item": \["foo", "bar"], "price": \[10.0, 20.0], } ) db = tmp\_db tbl = db.create\_table("my\_table\_pl", data, mode="overwrite") ### From Pydantic Models Python Only When you create an empty table without data, you must specify the table schema. LanceDB supports creating tables by specifying a PyArrow schema or a specialized Pydantic model called `LanceModel`. For example, the following Content model specifies a table with 5 columns: `movie_id`, `vector`, `genres`, `title`, and `imdb_id`. When you create a table, you can pass the class as the value of the `schema` parameter to `create_table`. The `vector` column is a `Vector` type, which is a specialized Pydantic type that can be configured with the vector dimensions. It is also important to note that LanceDB only understands subclasses of `lancedb.pydantic.LanceModel` (which itself derives from `pydantic.BaseModel`). from lancedb.pydantic import LanceModel, Vector class Content(LanceModel): movie\_id: int vector: Vector(128) genres: str title: str imdb\_id: int @property def imdb\_url(self) -> str: return f"https\://www\.imdb.com/title/tt\{self.imdb\_id}" db = tmp\_db tbl = db.create\_table("movielens\_small", schema=Content, mode="overwrite") #### Nested schemas Sometimes your data model may contain nested objects. For example, you may want to store the document string and the document source name as a nested Document object: from pydantic import BaseModel class Document(BaseModel): content: str source: str This can be used as the type of a LanceDB table column: from lancedb.pydantic import LanceModel, Vector \# --8\<-- \[start:tables\_document\_model] from pydantic import BaseModel class Document(BaseModel): content: str source: str \# --8\<-- \[end:tables\_document\_model] class NestedSchema(LanceModel): id: str vector: Vector(1536) document: Document db = tmp\_db tbl = db.create\_table("nested\_table", schema=NestedSchema, mode="overwrite") This creates a struct column called "document" that has two subfields called "content" and "source": ```bash theme={"theme":{"light":"vitesse-light","dark":"catppuccin-mocha"}} In [28]: tbl.schema Out[28]: id: string not null vector: fixed_size_list[1536] not null child 0, item: float document: struct not null child 0, content: string not null child 1, source: string not null ``` #### Validators Because `LanceModel` inherits from Pydantic's `BaseModel`, you can combine them with Pydantic's [field validators](https://docs.pydantic.dev/latest/concepts/validators). The example below shows how to add a validator to ensure that only valid timezone-aware datetime objects are used for a `created_at` field. from datetime import datetime from zoneinfo import ZoneInfo from lancedb.pydantic import LanceModel from pydantic import Field, ValidationError, ValidationInfo, field\_validator tzname = "America/New\_York" tz = ZoneInfo(tzname) class TestModel(LanceModel): dt\_with\_tz: datetime = Field(json\_schema\_extra=\{"tz": tzname}) @field\_validator("dt\_with\_tz") @classmethod def tz\_must\_match(cls, dt: datetime) -> datetime: assert dt.tzinfo == tz return dt ok = TestModel(dt\_with\_tz=datetime.now(tz)) try: TestModel(dt\_with\_tz=datetime.now(ZoneInfo("Asia/Shanghai"))) assert 0 == 1, "this should raise ValidationError" except ValidationError: print("A ValidationError was raised.") pass When you run this code it, should raise the `ValidationError`. ### Loading Large Datasets When ingesting large datasets, use `table.add()` on an existing table rather than passing all data to `create_table()`. The `add()` method auto-parallelizes large writes, while `create_table(name, data)` does not. > [!TIP] > > For best performance with large datasets, create an empty table first and then call > `table.add()`. This enables automatic write parallelism for materialized data sources. #### From files (Parquet, CSV, etc.) Python Only For file-based data, pass a `pyarrow.dataset.Dataset` to `table.add()`. This streams data from disk without loading the entire dataset into memory. import pyarrow\.dataset as ds dataset = ds.dataset(data\_path, format="parquet") db = tmp\_db table = db.create\_table("my\_table", schema=dataset.schema, mode="overwrite") table.add(dataset) > [!NOTE] > > `pa.dataset()` input is currently Python-only. TypeScript and Rust support for > file-based dataset ingestion is tracked in > [lancedb#3173](https://github.com/lancedb/lancedb/issues/3173). #### From iterators (custom batch generation) When you need custom batch logic — generating embeddings on the fly, transforming rows from an external source, etc. — use an iterator of `RecordBatch` objects. import pyarrow as pa schema = pa.schema( \[ pa.field("vector", pa.list\_(pa.float32(), 4)), pa.field("item", pa.utf8()), pa.field("price", pa.float32()), ] ) def make\_batches(): for i in range(5): yield pa.RecordBatch.from\_arrays( \[ pa.array( \[\[3.1, 4.1, 5.1, 6.1], \[5.9, 26.5, 4.7, 32.8]], pa.list\_(pa.float32(), 4), ), pa.array(\["foo", "bar"]), pa.array(\[10.0, 20.0]), ], \["vector", "item", "price"], ) db = tmp\_db db.create\_table("batched\_table", make\_batches(), schema=schema, mode="overwrite") const batchSchema = new arrow\.Schema(\[ new arrow\.Field( "vector", new arrow\.FixedSizeList( 4, new arrow\.Field("item", new arrow\.Float32(), true), ), ), new arrow\.Field("item", new arrow\.Utf8()), new arrow\.Field("price", new arrow\.Float32()), ]); const tableForBatches = await db.createEmptyTable( "batched\_table", batchSchema, \{ mode: "overwrite", }, ); const rows = Array.from(\{ length: 10 }, (\_, i) => (\{ vector: \[i + 0.1, i + 0.2, i + 0.3, i + 0.4], item: \`item-\$\{i + 1}\`, price: (i + 1) \* 10, })); const chunkSize = 2; for (let i = 0; i \< rows.length; i += chunkSize) \{ const batch = lancedb.makeArrowTable(rows.slice(i, i + chunkSize), \{ schema: batchSchema, }); await tableForBatches.add(batch); } let batch\_schema = Arc::new(Schema::new(vec!\[ Field::new( "vector", DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Float32, true)), 4), false, ), Field::new("item", DataType::Utf8, false), Field::new("price", DataType::Float32, false), ])); let batches = (0..5) .map(|i| \{ RecordBatch::try\_new( batch\_schema.clone(), vec!\[ Arc::new( FixedSizeListArray::from\_iter\_primitive::\( vec!\[ Some(vec!\[Some(3.1 + i as f32), Some(4.1), Some(5.1), Some(6.1)]), Some(vec!\[ Some(5.9), Some(26.5 + i as f32), Some(4.7), Some(32.8), ]), ], 4, ), ), Arc::new(StringArray::from(vec!\[ format!("item\{}", i \* 2 + 1), format!("item\{}", i \* 2 + 2), ])), Arc::new(Float32Array::from(vec!\[ ((i \* 2 + 1) \* 10) as f32, ((i \* 2 + 2) \* 10) as f32, ])), ], ) .unwrap() }) .collect::\>(); let batch\_reader: Box\ = Box::new(RecordBatchIterator::new(batches.into\_iter().map(Ok), batch\_schema.clone())); let batch\_table = db .create\_table("batched\_table", batch\_reader) .mode(CreateTableMode::Overwrite) .execute() .await .unwrap(); Use this pattern when: * Your source data already arrives in Arrow batches, readers, datasets, or streams. * Materializing the entire ingest as one giant in-memory list or array would be too expensive. * You want to control chunk size explicitly during ingestion. Python can also consume iterators of other supported types like Pandas DataFrames or Python lists. #### Write parallelism > [!NOTE] > > For materialized data (`pa.Table`, `pd.DataFrame`, `pa.dataset()`), LanceDB > automatically parallelizes large writes — no configuration needed. Auto-parallelism > targets approximately 1M rows or 2GB per write partition. > > For streaming sources (iterators, `RecordBatchReader`), LanceDB cannot determine > total size upfront. A `parallelism` parameter to control this manually is planned > but not yet exposed in Python or TypeScript > ([tracking issue](https://github.com/lancedb/lancedb/issues/3173)). #### Tracking ingestion progress TypeScript Only For long-running writes, pass a `progress` callback to `table.add()` to surface per-batch progress in your UI, logs, or metrics pipeline. The callback fires once per batch written and once more with `done: true` when the write completes. Each invocation receives a `WriteProgress` object: | Field | Description | | :- | :- | | `outputRows` | Rows written so far. | | `outputBytes` | Bytes written so far. | | `totalRows` | Expected total rows when the input source reports one. Always set on the final callback. | | `elapsedSeconds` | Wall-clock seconds since the write started. | | `activeTasks` | Parallel write tasks currently in flight. | | `totalTasks` | Total parallel write tasks (the write parallelism). | | `done` | `true` only for the final callback. | {TsAddProgress} A few things to know before you wire this up: * Back-pressures the writer: callback invocations are serialized and run inline with each batch, so a slow callback will slow the write rather than drop updates. Every batch update is delivered, and the final `done: true` callback always fires (even on error or cancellation). Keep the callback cheap — offload heavy work to a queue you drain elsewhere. * Errors swallowed: anything your callback throws is logged with `console.warn` and won't abort the write, so keep the callback side-effect-only and don't rely on it for control flow. * Row totals: `totalRows` is only populated when the input source can report it up front (for example, a materialized `arrow.Table`). For streaming sources it stays `undefined` until the final callback, where it falls back to the actual rows written. ## Create empty table You can create an empty table for scenarios where you want to add data to the table later. An example would be when you want to collect data from a stream/external file and then add it to a table in batches. An empty table can be initialized via an Arrow schema. import pyarrow as pa schema = pa.schema( \[ pa.field("vector", pa.list\_(pa.float32(), 2)), pa.field("item", pa.string()), pa.field("price", pa.float32()), ] ) db = tmp\_db tbl = db.create\_table("test\_empty\_table", schema=schema, mode="overwrite") const emptySchema = new arrow\.Schema(\[ new arrow\.Field( "vector", new arrow\.FixedSizeList( 2, new arrow\.Field("item", new arrow\.Float32(), true), ), ), new arrow\.Field("item", new arrow\.Utf8()), new arrow\.Field("price", new arrow\.Float32()), ]); const emptyTable = await db.createEmptyTable( "test\_empty\_table", emptySchema, \{ mode: "overwrite", }, ); let empty\_schema = Arc::new(Schema::new(vec!\[ Field::new( "vector", DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Float32, true)), 2), false, ), Field::new("item", DataType::Utf8, false), Field::new("price", DataType::Float32, false), ])); let empty\_table = db .create\_empty\_table("test\_empty\_table", empty\_schema) .mode(CreateTableMode::Overwrite) .execute() .await .unwrap(); Alternatively, you can also use Pydantic to specify the schema for the empty table. Note that we do not directly import `pydantic` but instead use `lancedb.pydantic` which is a subclass of `pydantic.BaseModel` that has been extended to support LanceDB specific types like `Vector`. from lancedb.pydantic import LanceModel, Vector class Item(LanceModel): vector: Vector(2) item: str price: float db = tmp\_db tbl = db.create\_table( "test\_empty\_table\_new", schema=Item.to\_arrow\_schema(), mode="overwrite" ) Once the empty table has been created, you can append to it or modify its contents, as explained in the [updating and modifying tables](https://docs.lancedb.com/tables/update.md) section. ## Open an existing table You can open an existing table by specifying the name of the table to the `open_table` / `openTable` method. If you forget the name of your table, you can always get a listing of all table names. db = tmp\_db \# Create a table first data = \[\{"vector": \[1.1, 1.2], "lat": 45.5, "long": -122.7}] db.create\_table("test\_table", data, mode="overwrite") \# List table names print(db.list\_tables().tables) \# Open existing table tbl = db.open\_table("test\_table") const openTableData = \[\{ vector: \[1.1, 1.2], lat: 45.5, long: -122.7 }]; await db.createTable("test\_table\_open", openTableData, \{ mode: "overwrite", }); console.log(await db.tableNames()); const openedTable = await db.openTable("test\_table\_open"); let open\_schema = Arc::new(Schema::new(vec!\[ Field::new( "vector", DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Float32, true)), 2), false, ), Field::new("lat", DataType::Float32, false), Field::new("long", DataType::Float32, false), ])); let open\_batch = RecordBatch::try\_new( open\_schema.clone(), vec!\[ Arc::new( FixedSizeListArray::from\_iter\_primitive::\( vec!\[Some(vec!\[Some(1.1), Some(1.2)])], 2, ), ), Arc::new(Float32Array::from(vec!\[45.5])), Arc::new(Float32Array::from(vec!\[-122.7])), ], ) .unwrap(); let open\_reader: Box\ = Box::new(RecordBatchIterator::new(vec!\[Ok(open\_batch)].into\_iter(), open\_schema.clone())); db.create\_table("test\_table", open\_reader) .mode(CreateTableMode::Overwrite) .execute() .await .unwrap(); println!("\{:?}", db.table\_names().execute().await.unwrap()); let opened\_table = db.open\_table("test\_table").execute().await.unwrap(); ## Drop a table Use the `drop_table()` method on the database to remove a table. db = tmp\_db \# Create a table first data = \[\{"vector": \[1.1, 1.2], "lat": 45.5}] db.create\_table("my\_table", data, mode="overwrite") \# Drop the table db.drop\_table("my\_table") await db.createTable("my\_table", \[\{ vector: \[1.1, 1.2], lat: 45.5 }], \{ mode: "overwrite", }); await db.dropTable("my\_table"); let drop\_schema = Arc::new(Schema::new(vec!\[ Field::new( "vector", DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Float32, true)), 2), false, ), Field::new("lat", DataType::Float32, false), ])); let drop\_batch = RecordBatch::try\_new( drop\_schema.clone(), vec!\[ Arc::new( FixedSizeListArray::from\_iter\_primitive::\( vec!\[Some(vec!\[Some(1.1), Some(1.2)])], 2, ), ), Arc::new(Float32Array::from(vec!\[45.5])), ], ) .unwrap(); let drop\_reader: Box\ = Box::new(RecordBatchIterator::new(vec!\[Ok(drop\_batch)].into\_iter(), drop\_schema.clone())); db.create\_table("my\_table", drop\_reader) .mode(CreateTableMode::Overwrite) .execute() .await .unwrap(); db.drop\_table("my\_table", &\[]).await.unwrap(); This permanently removes the table and is not recoverable, unlike deleting rows. By default, if the table does not exist an exception is raised. To suppress this, you can pass in `ignore_missing=True`. This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.