mirror of
https://github.com/lancedb/lancedb.git
synced 2026-10-13 15:22:30 +00:00
Jack Ye
8541d6d9df
A view is a named query a database stores and plans on every read. It
holds no rows, which is the whole difference from a materialized view.
## API
| Verb | Route |
| --- | --- |
| `create_view(name, query, namespace_path)` | `POST
/v1/view/{id}/create` |
| `describe_view(name, namespace_path)` | `POST /v1/view/{id}/describe`
|
| `drop_view(name, namespace_path)` | `POST /v1/view/{id}/drop` |
| `list_views(namespace_path)` | `GET /v1/namespace/{id}/view/list` |
On `Connection` and the `Database` trait, with the remote client, Python
(sync and async) and Node bindings. Local databases return
`NotSupported`: the server side is Sophon's, where a view is an object
of the database manifest.
`ViewDescription` carries the defining query, the database *and
namespace path* unqualified names in it resolve against, and the schema
the query resolved to. `create_view` returns one, so a caller has the
schema without a second call.
Both defaults travel with the view because it outlives the session that
declared it: the server re-plans the stored query on every read, so a
reader resolving an unqualified name against its own defaults would read
a different table. `default_namespace_path` crosses the wire as
`default_namespace`, a path like `namespace`, absent for the root.
There is no replace: a name already taken is an error, and changing a
view is a drop followed by a create, each authorized against what it
actually touches.
Querying a view stays SQL's job. There are no rows behind a view, so
there is no `open_view` returning a `Table`.
49 lines
1.7 KiB
TypeScript
49 lines
1.7 KiB
TypeScript
// SPDX-License-Identifier: Apache-2.0
|
|
// SPDX-FileCopyrightText: Copyright The LanceDB Authors
|
|
|
|
import { Schema, tableFromIPC } from "apache-arrow";
|
|
import { ViewDescription as NativeViewDescription } from "./native";
|
|
|
|
/**
|
|
* What a database records about one view.
|
|
*
|
|
* A view holds no rows: it stores the statement that defines it and the
|
|
* schema that statement resolved to, so a reader sees its sources as they
|
|
* are at read time.
|
|
*/
|
|
export interface ViewDescription {
|
|
/** The view's name within its namespace. */
|
|
name: string;
|
|
/** The namespace holding the view; empty is the root namespace. */
|
|
namespacePath: string[];
|
|
/** The defining query, as the database stores it. */
|
|
query: string;
|
|
/** The database that unqualified table names in {@link query} resolve against. */
|
|
defaultDatabase: string;
|
|
/**
|
|
* The namespace path those unqualified names resolve against; empty is the
|
|
* root namespace.
|
|
*
|
|
* Recorded with the view because it outlives the session that declared it:
|
|
* a reader resolving the query against its own default namespace could read
|
|
* a different table than the view was defined over.
|
|
*/
|
|
defaultNamespacePath: string[];
|
|
/** The schema the defining query resolved to when the view was created. */
|
|
schema: Schema;
|
|
}
|
|
|
|
/** Decode the schema the binding hands over as an Arrow IPC file. */
|
|
export function viewDescriptionFromNative(
|
|
view: NativeViewDescription,
|
|
): ViewDescription {
|
|
return {
|
|
name: view.name,
|
|
namespacePath: view.namespacePath,
|
|
query: view.query,
|
|
defaultDatabase: view.defaultDatabase,
|
|
defaultNamespacePath: view.defaultNamespacePath,
|
|
schema: tableFromIPC(view.schema).schema,
|
|
};
|
|
}
|