pub struct Engine { /* private fields */ }Expand description
Unified query engine composed from explicit storage, durable-catalog, session, extension, epoch, and query-runtime ownership domains.
Implementations§
Source§impl Engine
impl Engine
Sourcepub fn sql_simple_query(
&self,
query: &str,
params: &[SQLParam],
consume: impl FnMut(&SQLResult) -> Result<(), SQLError>,
) -> Result<(), SQLError>
pub fn sql_simple_query( &self, query: &str, params: &[SQLParam], consume: impl FnMut(&SQLResult) -> Result<(), SQLError>, ) -> Result<(), SQLError>
Execute a simple-query message, delivering each statement’s result in order. The whole message is parsed before execution, and implicit transaction segments retain the same boundaries as Engine::sql. The final result is delivered only after its implicit transaction has committed. Earlier results may have been delivered when a later statement fails; such failure still rolls back its implicit segment. An empty message delivers one result with no command completion.
Sourcepub fn sql(
&self,
query: &str,
params: &[SQLParam],
) -> Result<SQLResult, SQLError>
pub fn sql( &self, query: &str, params: &[SQLParam], ) -> Result<SQLResult, SQLError>
Execute a complete SQL message and return its final result. Multiple statements retain their native implicit transaction segments and explicit transaction boundaries; an empty message returns an empty result without a command tag.
Sourcepub fn sql_cursor(
&self,
query: &str,
params: &[SQLParam],
) -> Result<SQLCursor, SQLError>
pub fn sql_cursor( &self, query: &str, params: &[SQLParam], ) -> Result<SQLCursor, SQLError>
Execute one read query into a bounded spill and return a columnar batch
cursor. Unlike Engine::sql, this path never retains the complete
result as Vec<ResultRow> in memory. The statement finishes and its
snapshot is committed before the cursor is returned.
Sourcepub fn sql_columnar(
&self,
query: &str,
params: &[SQLParam],
consume: impl FnMut(ColumnarBatch) -> Result<(), SQLError>,
) -> Result<SQLCursorSummary, SQLError>
pub fn sql_columnar( &self, query: &str, params: &[SQLParam], consume: impl FnMut(ColumnarBatch) -> Result<(), SQLError>, ) -> Result<SQLCursorSummary, SQLError>
Consume the bounded cursor synchronously without retaining batches.
Source§impl Engine
impl Engine
pub fn register_named_analyzer( &self, name: &str, config_json: &str, ) -> Result<(), String>
Sourcepub fn analyze_text(&self, name: &str, input: &str) -> Result<Value, String>
pub fn analyze_text(&self, name: &str, input: &str) -> Result<Value, String>
Analyze one input with a resolved revision and return the SQL diagnostic object.
pub fn drop_named_analyzer(&self, name: &str) -> Result<bool, String>
pub fn list_named_analyzers(&self) -> Result<Vec<String>, String>
pub fn set_table_field_analyzer( &self, table: &str, field: &str, analyzer_name: &str, phase: &str, ) -> Result<(), String>
pub fn table_field_analyzer( &self, table: &str, field: &str, ) -> Result<Option<(String, String)>, String>
Sourcepub fn create_analyzer(
&self,
name: &str,
config_json: &str,
) -> Result<(), String>
pub fn create_analyzer( &self, name: &str, config_json: &str, ) -> Result<(), String>
compatibility alias for Engine::register_named_analyzer.
Sourcepub fn drop_analyzer(&self, name: &str) -> Result<bool, String>
pub fn drop_analyzer(&self, name: &str) -> Result<bool, String>
compatibility alias for Engine::drop_named_analyzer.
Sourcepub fn set_table_analyzer(
&self,
table: &str,
field: &str,
analyzer_name: &str,
phase: &str,
) -> Result<(), String>
pub fn set_table_analyzer( &self, table: &str, field: &str, analyzer_name: &str, phase: &str, ) -> Result<(), String>
compatibility alias for Engine::set_table_field_analyzer.
Sourcepub fn get_table_analyzer(
&self,
table: &str,
field: &str,
phase: &str,
) -> Result<Option<String>, String>
pub fn get_table_analyzer( &self, table: &str, field: &str, phase: &str, ) -> Result<Option<String>, String>
Resolve the analyzer assigned to (table, field) for the given
phase. phase is "index", "search", or "both". Returns the
exact bound configuration JSON. both requires the same named revision on both sides; an unnamed default has no explicit assignment to return.
Source§impl Engine
impl Engine
pub fn cancel(&self)
Sourcepub fn reset_cancellation(&self)
pub fn reset_cancellation(&self)
Reset the cancellation flag so subsequent queries run normally. Call between query batches when reusing the same engine for many cancellable executions.
pub fn cancellation_token(&self) -> CancellationToken
Sourcepub fn cancel_token(&self) -> CancellationToken
pub fn cancel_token(&self) -> CancellationToken
compatibility alias for Engine::cancellation_token.
pub fn is_cancelled(&self) -> bool
Source§impl Engine
impl Engine
pub fn register_view( &self, name: &str, body: SelectStmt, ) -> Result<(), SQLError>
Source§impl Engine
impl Engine
Sourcepub fn render_enum_labels(&self, result: &mut SQLResult) -> Result<(), SQLError>
pub fn render_enum_labels(&self, result: &mut SQLResult) -> Result<(), SQLError>
Replace the enum values of a query result by their current labels, as PostgreSQL clients receive them from the type’s output function. Declared column types keep the enum type.
§Errors
Returns an error when a result value names an enum type or label that this session’s catalog no longer contains.
Source§impl Engine
impl Engine
pub fn nextval(&self, name: &str) -> Result<i64, String>
pub fn currval(&self, name: &str) -> Result<i64, String>
pub fn lastval(&self) -> Result<i64, String>
pub fn setval(&self, name: &str, value: i64) -> Result<i64, String>
pub fn setval_with_is_called( &self, name: &str, value: i64, is_called: bool, ) -> Result<i64, String>
Source§impl Engine
impl Engine
pub fn register_catalog_index( &self, name: &str, index_type: &str, table: &str, columns: &[String], options: &[(String, String)], ) -> StorageBackendResult<()>
pub fn drop_catalog_index( &self, name: &str, ) -> StorageBackendResult<Option<CatalogIndexRow>>
pub fn catalog_index( &self, name: &str, ) -> StorageBackendResult<Option<CatalogIndexRow>>
pub fn has_catalog_index(&self, name: &str) -> StorageBackendResult<bool>
Source§impl Engine
impl Engine
pub fn register_foreign_server( &self, name: String, fdw_type: String, options: Vec<(String, String)>, if_not_exists: bool, ) -> Result<(), String>
pub fn register_foreign_table( &self, name: String, server_name: String, columns: Vec<ColumnDef>, options: Vec<(String, String)>, if_not_exists: bool, ) -> Result<(), String>
pub fn drop_foreign_server(&self, name: &str) -> Result<bool, String>
pub fn drop_foreign_table(&self, name: &str) -> Result<bool, String>
Sourcepub fn foreign_server_definition(
&self,
name: &str,
) -> Result<Option<ForeignServerDefinition>, String>
pub fn foreign_server_definition( &self, name: &str, ) -> Result<Option<ForeignServerDefinition>, String>
Read the retained SQL server definition without requiring a source handler.
Sourcepub fn foreign_table_definition(
&self,
name: &str,
) -> Result<Option<StoredForeignTable>, String>
pub fn foreign_table_definition( &self, name: &str, ) -> Result<Option<StoredForeignTable>, String>
Read the complete retained SQL table definition without requiring a source handler.
pub fn foreign_server( &self, name: &str, ) -> Result<Option<ForeignServer>, String>
pub fn foreign_table(&self, name: &str) -> Result<Option<ForeignTable>, String>
pub fn list_foreign_servers(&self) -> Result<Vec<String>, String>
pub fn list_foreign_tables(&self) -> Result<Vec<String>, String>
pub fn foreign_table_columns(&self, table: &str) -> Result<Vec<String>, String>
pub fn load_memory_foreign_table( &self, table_name: impl Into<String>, rows: Vec<Row>, ) -> Result<(), String>
Source§impl Engine
impl Engine
pub fn create_graph( &self, name: impl Into<String>, ) -> StorageBackendResult<bool>
Sourcepub fn drop_graph(&self, name: &str) -> StorageBackendResult<bool>
pub fn drop_graph(&self, name: &str) -> StorageBackendResult<bool>
Drop a named graph. No-op when the graph is missing.
Sourcepub fn list_graphs(&self) -> StorageBackendResult<Vec<String>>
pub fn list_graphs(&self) -> StorageBackendResult<Vec<String>>
Return every named graph registered on this engine in sorted order.
Sourcepub fn has_graph(&self, name: &str) -> StorageBackendResult<bool>
pub fn has_graph(&self, name: &str) -> StorageBackendResult<bool>
Return true when a graph with name is registered.
Sourcepub fn graph_label_catalog(
&self,
) -> StorageBackendResult<Vec<(String, Vec<GraphLabelInfo>)>>
pub fn graph_label_catalog( &self, ) -> StorageBackendResult<Vec<(String, Vec<GraphLabelInfo>)>>
Every named graph with its ag_label entries, read under one catalog
lock so catalog relations that mirror graphs do not re-read the
registry once per graph.
Sourcepub fn list_graph_labels(
&self,
graph: &str,
) -> StorageBackendResult<Option<Vec<GraphLabelInfo>>>
pub fn list_graph_labels( &self, graph: &str, ) -> StorageBackendResult<Option<Vec<GraphLabelInfo>>>
The surviving ag_label entries of a named graph in label-id order.
None when the graph does not exist.
Sourcepub fn create_graph_label(
&self,
graph: &str,
label: &str,
kind: LabelKind,
) -> StorageBackendResult<bool>
pub fn create_graph_label( &self, graph: &str, label: &str, kind: LabelKind, ) -> StorageBackendResult<bool>
Register an empty vertex or edge label in a named graph
(create_vlabel / create_elabel). Returns false when a label of
that name already exists in the graph and fails when the graph does
not exist.
Sourcepub fn drop_graph_label(
&self,
graph: &str,
label: &str,
) -> StorageBackendResult<bool>
pub fn drop_graph_label( &self, graph: &str, label: &str, ) -> StorageBackendResult<bool>
Drop a label and every entity carrying it from a named graph
(drop_label). Incident edge rows survive vertex-label removal like
AGE’s DROP TABLE. Returns false when the label is not registered
and fails when the graph does not exist.
Sourcepub fn rename_graph(&self, from: &str, to: &str) -> StorageBackendResult<bool>
pub fn rename_graph(&self, from: &str, to: &str) -> StorageBackendResult<bool>
Rename a named graph (alter_graph(..., 'RENAME', ...)). Returns
false when from does not exist and fails when to is already a
graph.
Sourcepub fn add_graph_vertex(
&self,
vertex: Vertex,
graph: &str,
) -> StorageBackendResult<()>
pub fn add_graph_vertex( &self, vertex: Vertex, graph: &str, ) -> StorageBackendResult<()>
Insert a vertex into a named graph, creating the graph if needed.
Sourcepub fn add_graph_edge(
&self,
edge: Edge,
graph: &str,
) -> StorageBackendResult<()>
pub fn add_graph_edge( &self, edge: Edge, graph: &str, ) -> StorageBackendResult<()>
Insert an edge into a named graph, creating the graph if needed.
Sourcepub fn apply_graph_delta(
&self,
graph: &str,
delta: &GraphDelta,
) -> StorageBackendResult<()>
pub fn apply_graph_delta( &self, graph: &str, delta: &GraphDelta, ) -> StorageBackendResult<()>
Apply a uqa_graph::GraphDelta to a named graph as one atomic batch
of vertex and edge additions or removals.
Sourcepub fn build_path_index(
&self,
name: &str,
graph: &str,
label_sequences: &[Vec<String>],
) -> StorageBackendResult<bool>
pub fn build_path_index( &self, name: &str, graph: &str, label_sequences: &[Vec<String>], ) -> StorageBackendResult<bool>
Build (or replace) a path index for graph keyed by name.
label_sequences is the set of label sequences to materialize; each
sequence becomes a hash-friendly direct lookup for RPQ.
Sourcepub fn drop_path_index(
&self,
name: &str,
graph: &str,
) -> StorageBackendResult<bool>
pub fn drop_path_index( &self, name: &str, graph: &str, ) -> StorageBackendResult<bool>
Drop a path index by (graph, name). Return true when one existed.
Sourcepub fn get_path_index(
&self,
name: &str,
graph: &str,
) -> StorageBackendResult<Option<PathIndex>>
pub fn get_path_index( &self, name: &str, graph: &str, ) -> StorageBackendResult<Option<PathIndex>>
Look up a path index by (graph, name). Return a clone so the caller
is not tied to the engine’s lock.
Sourcepub fn list_path_indexes(&self) -> StorageBackendResult<Vec<String>>
pub fn list_path_indexes(&self) -> StorageBackendResult<Vec<String>>
Sorted list of registered path index keys. Each key has the
shape <graph>::<name> so the caller can split as needed.
Sourcepub fn graph_with<R>(
&self,
name: &str,
f: impl FnOnce(&GraphStoreHandle) -> R,
) -> StorageBackendResult<Option<R>>
pub fn graph_with<R>( &self, name: &str, f: impl FnOnce(&GraphStoreHandle) -> R, ) -> StorageBackendResult<Option<R>>
Read-only borrow of a named graph for ad-hoc query construction
outside the SQL function path. Returns None when the graph
is unknown.
Sourcepub fn graph_with_mut<R>(
&self,
name: &str,
f: impl FnOnce(&mut GraphStoreHandle) -> GraphStoreResult<R>,
) -> StorageBackendResult<Option<R>>
pub fn graph_with_mut<R>( &self, name: &str, f: impl FnOnce(&mut GraphStoreHandle) -> GraphStoreResult<R>, ) -> StorageBackendResult<Option<R>>
Mutable borrow of a named graph for vertex / edge insertion.
Sourcepub fn run_cypher(
&self,
graph: &str,
query: &str,
params: BTreeMap<String, Value>,
) -> Result<(Vec<String>, Vec<ResultRow>), CypherError>
pub fn run_cypher( &self, graph: &str, query: &str, params: BTreeMap<String, Value>, ) -> Result<(Vec<String>, Vec<ResultRow>), CypherError>
Run a Cypher query against a named graph and return the
(columns, rows) projected by the query’s RETURN clause (or
empty vectors when the query has no RETURN).
This wires the full CREATE / MERGE / SET / DELETE /
UNWIND surface through to the selected storage backend. The named graph is
auto-created on first use.
Source§impl Engine
impl Engine
pub fn save_model(&self, name: &str, model: &DeepModel) -> Result<(), SQLError>
pub fn load_model(&self, name: &str) -> Result<Option<DeepModel>, SQLError>
pub fn drop_model(&self, name: &str) -> Result<bool, SQLError>
Sourcepub fn delete_model(&self, name: &str) -> Result<bool, SQLError>
pub fn delete_model(&self, name: &str) -> Result<bool, SQLError>
compatibility alias for Engine::drop_model.
Sourcepub fn deep_learn(
&self,
name: &str,
training_set: &TrainingSet,
options: &LearnOptions,
) -> Result<DeepLearnOutput, SQLError>
pub fn deep_learn( &self, name: &str, training_set: &TrainingSet, options: &LearnOptions, ) -> Result<DeepLearnOutput, SQLError>
Train an analytical deep model and persist it under name.
Sourcepub fn deep_learn_json(
&self,
name: &str,
training_json: &str,
options: &LearnOptions,
) -> Result<DeepLearnOutput, SQLError>
pub fn deep_learn_json( &self, name: &str, training_json: &str, options: &LearnOptions, ) -> Result<DeepLearnOutput, SQLError>
Parse a JSON TrainingSet, train it, and persist the model.
Sourcepub fn deep_learn_table(
&self,
name: &str,
table: &str,
options: &LearnOptions,
) -> Result<DeepLearnOutput, SQLError>
pub fn deep_learn_table( &self, name: &str, table: &str, options: &LearnOptions, ) -> Result<DeepLearnOutput, SQLError>
Train from a table containing features and label columns.
Sourcepub fn save_scoring_params(
&self,
name: &str,
params_json: &str,
) -> Result<(), SQLError>
pub fn save_scoring_params( &self, name: &str, params_json: &str, ) -> Result<(), SQLError>
Persist Bayesian calibration parameters for a named signal. The
Parameters arrive serialized as JSON so callers can persist arbitrary
(alpha, beta, base_rate, ...) shapes without a fixed struct.
Sourcepub fn load_scoring_params(
&self,
name: &str,
) -> Result<Option<String>, SQLError>
pub fn load_scoring_params( &self, name: &str, ) -> Result<Option<String>, SQLError>
Load persisted scoring parameters for a single signal. Falls back to the in-memory cache when the engine is not catalog-backed.
Sourcepub fn try_load_scoring_params(
&self,
name: &str,
) -> Result<Option<String>, SQLError>
pub fn try_load_scoring_params( &self, name: &str, ) -> Result<Option<String>, SQLError>
Fallible scoring-parameter read. Persistent sessions consult their own catalog connection instead of trusting an engine-local snapshot; this preserves transaction isolation and makes commits from sibling sessions visible without reopening the engine.
Sourcepub fn load_all_scoring_params(&self) -> Result<Vec<(String, String)>, SQLError>
pub fn load_all_scoring_params(&self) -> Result<Vec<(String, String)>, SQLError>
Snapshot every persisted (name, params_json) pair.
Sourcepub fn drop_scoring_params(&self, name: &str) -> Result<bool, SQLError>
pub fn drop_scoring_params(&self, name: &str) -> Result<bool, SQLError>
Drop persisted scoring parameters for a single signal. Returns
true when something was removed.
Sourcepub fn save_vector_calibration_model(
&self,
name: &str,
model: &VectorCalibrationModel,
) -> Result<(), SQLError>
pub fn save_vector_calibration_model( &self, name: &str, model: &VectorCalibrationModel, ) -> Result<(), SQLError>
Persist a typed vector-calibration model, including the corpus, index, embedding-model, candidate-K, and version provenance that constrains its safe reuse.
Sourcepub fn load_vector_calibration_model(
&self,
name: &str,
) -> Result<Option<VectorCalibrationModel>, SQLError>
pub fn load_vector_calibration_model( &self, name: &str, ) -> Result<Option<VectorCalibrationModel>, SQLError>
Load and validate a persisted vector-calibration model. Unsupported schema versions and invalid numeric parameters are errors rather than silently falling back to query-pool calibration.
pub fn drop_vector_calibration_model( &self, name: &str, ) -> Result<bool, SQLError>
Sourcepub fn deep_predict(
&self,
name: &str,
) -> Result<Option<Vec<(DocId, f64)>>, SQLError>
pub fn deep_predict( &self, name: &str, ) -> Result<Option<Vec<(DocId, f64)>>, SQLError>
Run saved-model inference through the shared operator optimizer and
plan executor. A missing model retains the public API’s None
contract; the physical driver only receives known models.
pub fn deep_predict_features( &self, name: &str, examples: &[(DocId, Vec<f64>)], ) -> Result<Vec<(DocId, f64)>, SQLError>
Source§impl Engine
impl Engine
Sourcepub fn configure_sql_notifications(
&self,
options: SQLNotificationOptions,
) -> Result<(), NotificationSubscriptionError>
pub fn configure_sql_notifications( &self, options: SQLNotificationOptions, ) -> Result<(), NotificationSubscriptionError>
Configure bounded LISTEN delivery once, before opening a transaction or listening.
This does not create another session, change channels or execute SQL. The adapter
must use try_take_sql_notifications or try_take_sql_notification_with and close
this session on a terminal error.
Sourcepub fn try_take_sql_notifications(
&self,
) -> Result<Vec<SQLNotification>, SQLError>
pub fn try_take_sql_notifications( &self, ) -> Result<Vec<SQLNotification>, SQLError>
Synchronize committed messages and atomically drain the same SQL session’s inbox. Transactional LISTEN, UNLISTEN, NOTIFY and savepoint semantics remain unchanged. An overflow or source failure remains terminal; no lost message is called success.
Sourcepub fn try_take_sql_notification_with<T, E>(
&self,
prepare: impl FnOnce(&SQLNotification) -> Result<T, E>,
) -> Result<NotificationReceive<T>, E>where
E: From<NotificationSubscriptionError>,
pub fn try_take_sql_notification_with<T, E>(
&self,
prepare: impl FnOnce(&SQLNotification) -> Result<T, E>,
) -> Result<NotificationReceive<T>, E>where
E: From<NotificationSubscriptionError>,
Receive one event from a configured bounded SQL LISTEN inbox, admitting its destination
before dequeue. The ordinary SQL transaction deferral and cross-process synchronization
remain native. prepare follows NotificationSubscription::poll_with’s no-reentry contract.
A source failure remains terminal in this inbox; admission failures do not consume it.
Source§impl Engine
impl Engine
Sourcepub fn require_notification_subscriptions(&self) -> Result<(), SQLError>
pub fn require_notification_subscriptions(&self) -> Result<(), SQLError>
Require independently owned subscriptions instead of SQL LISTEN/UNLISTEN for this session and subsequently created sibling sessions. Stateless SQL hosts must enable this before serving requests. NOTIFY and pg_notify retain their transactional behavior.
This is irreversible for the session and survives rollback, DISCARD and nested execution. Enabling it fails with SQLSTATE 55000 during SQL execution, inside a transaction or while SQL channels are registered. Repeated calls after successful configuration are harmless. Independently owned subscription handles are unaffected.
Source§impl Engine
impl Engine
Sourcepub fn subscribe_notifications(
&self,
channels: &[&str],
options: NotificationSubscriptionOptions,
) -> Result<NotificationSubscription, NotificationSubscriptionError>
pub fn subscribe_notifications( &self, channels: &[&str], options: NotificationSubscriptionOptions, ) -> Result<NotificationSubscription, NotificationSubscriptionError>
Register one independent idle listener before returning a ready handle. Channels are exact, unique, nonempty UTF-8 names of at most 63 bytes; no identifier folding or truncation is performed. The caller’s transaction and low-level SQL listener remain independent.
Registration and close can perform native provider I/O. Runtime adapters must run them outside their event-loop worker. Polling never performs I/O; a wait timeout does not unsubscribe.
Sourcepub fn subscribe_notifications_with_cancellation(
&self,
channels: &[&str],
options: NotificationSubscriptionOptions,
cancellation: &CancellationToken,
) -> Result<NotificationSubscription, NotificationSubscriptionError>
pub fn subscribe_notifications_with_cancellation( &self, channels: &[&str], options: NotificationSubscriptionOptions, cancellation: &CancellationToken, ) -> Result<NotificationSubscription, NotificationSubscriptionError>
Register with independent caller cancellation through statement, hub and native registry waits. A pending registration already owns subscription capacity. Cancellation before the committed registration boundary returns Cancelled without publishing a partial listener; successful readiness wins a simultaneous cancellation race.
The signal applies to registration only. After readiness the handle retains its independent lifetime until close/drop. Native file opening and provider-session construction already in progress remain synchronous; this method does not establish an operating-system I/O deadline.
Sourcepub fn reserve_notification_subscription(
&self,
options: NotificationSubscriptionOptions,
cancellation: &CancellationToken,
) -> Result<NotificationSubscriptionPermit, NotificationSubscriptionError>
pub fn reserve_notification_subscription( &self, options: NotificationSubscriptionOptions, cancellation: &CancellationToken, ) -> Result<NotificationSubscriptionPermit, NotificationSubscriptionError>
Reserve the original hub’s shared pending/live allowance without waiting on Engine or provider gates. Runtime adapters must retain this Engine separately and obtain the permit before submitting work. The cancellation token applies to this reservation call; the consuming registration accepts its own retained signal.
Sourcepub fn subscribe_notifications_with_permit(
&self,
channels: &[&str],
permit: NotificationSubscriptionPermit,
cancellation: &CancellationToken,
) -> Result<NotificationSubscription, NotificationSubscriptionError>
pub fn subscribe_notifications_with_permit( &self, channels: &[&str], permit: NotificationSubscriptionPermit, cancellation: &CancellationToken, ) -> Result<NotificationSubscription, NotificationSubscriptionError>
Consume one pre-submission reservation on its original hub. The permit fixes every limit and cannot be reused or transferred to another database identity. Invalid input, cancellation or failure releases it; readiness transfers that same permit to the listener through completed cleanup.
Source§impl Engine
impl Engine
Sourcepub fn backend_process_id(&self) -> i32
pub fn backend_process_id(&self) -> i32
PostgreSQL-compatible backend process identifier for this logical SQL session.
Sourcepub fn poll_sql_notifications(&self) -> Result<usize, SQLError>
pub fn poll_sql_notifications(&self) -> Result<usize, SQLError>
Pull committed cross-process messages into this session without draining them.
Sourcepub fn wait_for_sql_notifications(
&self,
timeout: Duration,
) -> Result<bool, SQLError>
pub fn wait_for_sql_notifications( &self, timeout: Duration, ) -> Result<bool, SQLError>
Wait until at least one committed notification is ready for this idle SQL session or the timeout elapses.
Sourcepub fn take_sql_notifications(&self) -> Vec<SQLNotification>
pub fn take_sql_notifications(&self) -> Vec<SQLNotification>
Drain committed notifications available to this SQL session. Notifications received during a transaction remain queued until that transaction ends.
Source§impl Engine
impl Engine
Sourcepub fn new_session_for_user(&self, user: &str) -> Result<Self, SQLError>
pub fn new_session_for_user(&self, user: &str) -> Result<Self, SQLError>
Open an independent session for a role authenticated by the embedding host. This checks role existence, LOGIN, and database CONNECT privileges; credential verification and connection limits belong to the host’s connection manager.
Source§impl Engine
impl Engine
pub fn open(path: &Path) -> Result<Self, SQLiteError>
Sourcepub fn detect_database_file(path: &Path) -> Result<DatabaseFileFormat>
pub fn detect_database_file(path: &Path) -> Result<DatabaseFileFormat>
Classify the on-disk format of path without opening it: plain
SQLite, UQA compressed container (with its encryption flag), a
missing/empty file, or an unrecognized header (SQLCipher
databases fall here because SQLCipher encrypts the whole file).
Sourcepub fn open_auto(path: &Path, key: Option<&str>) -> Result<Self, SQLiteError>
pub fn open_auto(path: &Path, key: Option<&str>) -> Result<Self, SQLiteError>
Open path with the variant its on-disk format calls for.
- Missing/empty file: creates a new database,
SQLCipherencrypted whenkeyis provided, plaintext otherwise. - Plain
SQLite: opens plaintext; providing a key is an error (SQLiteError::NotEncrypted) rather than a silent no-op so callers never believe an unencrypted database is protected. - Compressed container: opens with the codec recorded in the
container header; the encryption flag decides whether
keyis required (SQLiteError::EncryptionKeyRequired) or rejected (SQLiteError::NotEncrypted). - Unrecognized header: treated as
SQLCipherwhenkeyis provided; without a key this fails withSQLiteError::EncryptionKeyRequiredbecause an encrypted database cannot be told apart from a foreign file.
New compressed containers are not created through this entry
point; use Engine::open_compressed or
Engine::open_compressed_encrypted to choose compression for
a new database.
Sourcepub fn open_encrypted(path: &Path, key: &str) -> Result<Self, SQLiteError>
pub fn open_encrypted(path: &Path, key: &str) -> Result<Self, SQLiteError>
SQLCipher-backed engine. Applies key before any catalog
access, runs migrations, and rebuilds the in-memory table
registry from the encrypted catalog.
Sourcepub fn open_compressed(
path: &Path,
compression: SQLiteCompressionOptions,
) -> Result<Self, SQLiteError>
pub fn open_compressed( path: &Path, compression: SQLiteCompressionOptions, ) -> Result<Self, SQLiteError>
Compressed SQLite-backed engine. The compression VFS is
schema-neutral: it compresses SQLite byte ranges in chunks
without knowledge of UQA catalog tables or columns.
Sourcepub fn open_compressed_encrypted(
path: &Path,
key: &str,
compression: SQLiteCompressionOptions,
) -> Result<Self, SQLiteError>
pub fn open_compressed_encrypted( path: &Path, key: &str, compression: SQLiteCompressionOptions, ) -> Result<Self, SQLiteError>
Compressed and encrypted SQLite-backed engine. Chunk payloads
are compressed first, then encrypted by the compressed VFS. The v2
format authenticates container metadata, chunk placement, and commit
records, but cannot distinguish replacement by an internally valid
snapshot or fork without an external trusted state anchor.
Security-sensitive deployments that do not require compression should
prefer Engine::open_encrypted and SQLCipher.
Sourcepub fn open_compressed_encrypted_with_anchor(
path: &Path,
key: &str,
compression: SQLiteCompressionOptions,
trusted_anchor: SQLiteCompressedContainerAnchor,
) -> Result<Self, SQLiteError>
pub fn open_compressed_encrypted_with_anchor( path: &Path, key: &str, compression: SQLiteCompressionOptions, trusted_anchor: SQLiteCompressedContainerAnchor, ) -> Result<Self, SQLiteError>
Open an encrypted compressed database and reject a different file or
any state other than trusted_anchor before SQLite reads the main
database. Refresh the trusted anchor after every committed write.
Sourcepub fn compressed_container_anchor(
path: &Path,
key: &str,
) -> Result<SQLiteCompressedContainerAnchor, SQLiteError>
pub fn compressed_container_anchor( path: &Path, key: &str, ) -> Result<SQLiteCompressedContainerAnchor, SQLiteError>
Authenticate and return the anchor to persist in a trusted store after committed writes to an encrypted compressed database.
Sourcepub fn new_session(&self) -> StorageBackendResult<Self>
pub fn new_session(&self) -> StorageBackendResult<Self>
Create an independent SQL session over this engine’s durable database.
The new session gets its own catalog/backend pair, transaction stack, runtime variables, prepared statements, statement cache, and cancellation token. Committed catalog definitions share immutable allocations; mutations detach the session’s copy and synchronize through shared epochs. Runtime-only Rust extensions are shared. The provider must return catalog and data handles bound to one session transaction so every durable mutation commits atomically.
Whether these sessions use the same database identity. This reuses the provider-identified coordinator shared by independent opens and sibling sessions; memory engines have independent identities. Providers without stable storage identity can share only through their retained provider or backend owner.
Sourcepub fn from_persistent_provider(
provider: Arc<dyn PersistentStorageProvider>,
) -> StorageBackendResult<Self>
pub fn from_persistent_provider( provider: Arc<dyn PersistentStorageProvider>, ) -> StorageBackendResult<Self>
Build an engine and retain the provider used to create future independent sessions.
Sourcepub fn from_persistent_backends(
catalog: Arc<dyn CatalogFacade>,
backend: Arc<dyn PersistentStorageBackend>,
) -> StorageBackendResult<Self>
pub fn from_persistent_backends( catalog: Arc<dyn CatalogFacade>, backend: Arc<dyn PersistentStorageBackend>, ) -> StorageBackendResult<Self>
Build an engine from already-open persistent metadata and data backends. The backend’s session factory is retained for independent SQL sessions and latest-committed row-lock rechecks. Prefer Self::from_persistent_provider when a database-level owner is already available.
Source§impl Engine
impl Engine
Sourcepub fn create_range_parameter_with_control(
&self,
type_name: &str,
bounds: RangeParameterBounds<'_>,
control: &ProductionControl<'_>,
) -> Result<Produced<SQLParam>, SQLError>
pub fn create_range_parameter_with_control( &self, type_name: &str, bounds: RangeParameterBounds<'_>, control: &ProductionControl<'_>, ) -> Result<Produced<SQLParam>, SQLError>
Construct typed range bounds with the native statement scope; SQL owns endpoint conversion and Execution invokes selected catalog support.
Sourcepub fn create_multirange_parameter_with_control(
&self,
type_name: &str,
members: &[SQLParam],
control: &ProductionControl<'_>,
) -> Result<Produced<SQLParam>, SQLError>
pub fn create_multirange_parameter_with_control( &self, type_name: &str, members: &[SQLParam], control: &ProductionControl<'_>, ) -> Result<Produced<SQLParam>, SQLError>
Normalize typed range members and validate an enclosing domain in the native statement scope.
Sourcepub fn create_record_parameter_with_control(
&self,
type_name: &str,
fields: &[SQLParam],
control: &ProductionControl<'_>,
) -> Result<Produced<SQLParam>, SQLError>
pub fn create_record_parameter_with_control( &self, type_name: &str, fields: &[SQLParam], control: &ProductionControl<'_>, ) -> Result<Produced<SQLParam>, SQLError>
Construct a typed host record in the native statement scope. SQL owns attribute selection, source binding, scalar casts and domain checks.
Sourcepub fn create_array_parameter_with_control(
&self,
type_name: &str,
dimensions: &[usize],
lower_bounds: &[i32],
elements: &[SQLParam],
control: &ProductionControl<'_>,
) -> Result<Produced<SQLParam>, SQLError>
pub fn create_array_parameter_with_control( &self, type_name: &str, dimensions: &[usize], lower_bounds: &[i32], elements: &[SQLParam], control: &ProductionControl<'_>, ) -> Result<Produced<SQLParam>, SQLError>
Construct a typed host array in the session’s native statement/catalog scope. SQL owns parameter identities, scalar conversion, dimensions and domain constraints.
Sourcepub fn create_typed_parameter_with_control(
&self,
type_name: &str,
text: Option<&str>,
control: &ProductionControl<'_>,
) -> Result<Produced<SQLParam>, SQLError>
pub fn create_typed_parameter_with_control( &self, type_name: &str, text: Option<&str>, control: &ProductionControl<'_>, ) -> Result<Produced<SQLParam>, SQLError>
Create a typed parameter from external text, or a typed SQL NULL from None. Type input runs with the session’s current catalog, privileges and presentation settings. Domain checks and input callbacks share native transaction admission, commit and failure recovery; the returned parameter retains the supplied production allowance.
Source§impl Engine
impl Engine
Sourcepub fn prepare_statement(
&self,
sql: &str,
declared: &[ColumnType],
) -> Result<PreparedStatement, SQLError>
pub fn prepare_statement( &self, sql: &str, declared: &[ColumnType], ) -> Result<PreparedStatement, SQLError>
Prepare native SQL with optional explicit parameter declarations. Definitions survive transaction rollback and are removed by finalize, DEALLOCATE or DISCARD ALL.
pub fn validate_prepared_statement( &self, statement: &PreparedStatement, ) -> Result<(), SQLError>
pub fn describe_prepared_statement( &self, statement: &PreparedStatement, ) -> Result<PreparedStatementDescription, SQLError>
pub fn execute_prepared_statement( &self, statement: &PreparedStatement, params: &[SQLParam], ) -> Result<SQLResult, SQLError>
Sourcepub fn finalize_prepared_statement(&self, statement: &PreparedStatement)
pub fn finalize_prepared_statement(&self, statement: &PreparedStatement)
An invalidated handle is harmless to release and cannot remove a replacement definition.
pub fn register_prepared( &self, name: String, definition: Statement, ) -> Result<(), SQLError>
Sourcepub fn lookup_prepared(&self, name: &str) -> Option<SharedExecutablePlan>
pub fn lookup_prepared(&self, name: &str) -> Option<SharedExecutablePlan>
Retain the current generic executable, or its analyzed input before planning, without copying the plan tree.
pub fn deallocate_prepared(&self, name: Option<&str>)
Source§impl Engine
impl Engine
Sourcepub fn bayesian_params_for(
&self,
table: &str,
field: &str,
) -> Result<BayesianBM25Params, SQLError>
pub fn bayesian_params_for( &self, table: &str, field: &str, ) -> Result<BayesianBM25Params, SQLError>
Resolve the Bayesian BM25 calibration for table.field.
Saved parameters win. Absent or stale auto-estimated parameters trigger a corpus-driven estimation. Writable transactions persist it for subsequent queries; read-only transactions use it without publication. The raw-score identity calibration (alpha = 1, beta = 0) never silently ships a score for a populated field. Parameters written by the online learner carry no estimated_doc_count stamp and are never overwritten automatically.
Source§impl Engine
impl Engine
Sourcepub fn hybrid_search(
&self,
params: &HybridSearchParams<'_>,
) -> Result<Vec<ScoredEntry>, SQLError>
pub fn hybrid_search( &self, params: &HybridSearchParams<'_>, ) -> Result<Vec<ScoredEntry>, SQLError>
Exact single-prior hybrid retrieval under cross-modal conditional
independence. Query-level Bayesian BM25 and query-pool-transformed KNN
emit signed prior-free evidence, the evidence logits add without
gating or confidence scaling, and the resolved corpus relevance prior
enters exactly once. Returns the top-top_k entries by descending
posterior score.
Sourcepub fn robust_hybrid_search(
&self,
params: &RobustHybridSearchParams<'_>,
) -> Result<Vec<ScoredEntry>, SQLError>
pub fn robust_hybrid_search( &self, params: &RobustHybridSearchParams<'_>, ) -> Result<Vec<ScoredEntry>, SQLError>
Explicit robust positive-evidence hybrid ranking. This method applies
Softplus gating, confidence scaling, and adaptive query-pool weights;
its output is a bounded ranking heuristic rather than the exact
single-prior posterior returned by Self::hybrid_search.
Source§impl Engine
impl Engine
pub fn learn_scoring_params( &self, table: &str, field: &str, query: &str, labels: &[u8], ) -> Result<BTreeMap<String, f64>, SQLError>
Sourcepub fn estimate_scoring_params(
&self,
table: &str,
field: &str,
n_samples: usize,
tokens_per_query: usize,
seed: i64,
) -> Result<BTreeMap<String, f64>, SQLError>
pub fn estimate_scoring_params( &self, table: &str, field: &str, n_samples: usize, tokens_per_query: usize, seed: i64, ) -> Result<BTreeMap<String, f64>, SQLError>
Estimate and persist an unsupervised BM25 score transform from a field’s indexed vocabulary and raw score distribution.
pub fn update_scoring_params( &self, table: &str, field: &str, score: f64, label: u8, ) -> Result<(), SQLError>
Source§impl Engine
impl Engine
Sourcepub fn search(
&self,
table: &str,
field: &str,
query: &str,
mode: &ScoringMode,
top_k: usize,
) -> Result<Vec<ScoredEntry>, SQLError>
pub fn search( &self, table: &str, field: &str, query: &str, mode: &ScoringMode, top_k: usize, ) -> Result<Vec<ScoredEntry>, SQLError>
Run a text query through the shared operator optimizer and executor.
Sourcepub fn search_profiled(
&self,
table: &str,
field: &str,
query: &str,
mode: &ScoringMode,
top_k: usize,
) -> Result<TextSearchProfile, SQLError>
pub fn search_profiled( &self, table: &str, field: &str, query: &str, mode: &ScoringMode, top_k: usize, ) -> Result<TextSearchProfile, SQLError>
Run the same planner-selected physical text path as Self::search
while returning exact candidate/skip counters for benchmarks and
production diagnostics.
Sourcepub fn calibration_report(
&self,
table: &str,
field: &str,
query: &str,
labels: &[u8],
) -> Result<CalibrationReport, SQLError>
pub fn calibration_report( &self, table: &str, field: &str, query: &str, labels: &[u8], ) -> Result<CalibrationReport, SQLError>
Compute calibration diagnostics for a Bayesian BM25 query
against every document in table, aligned to labels in
ascending document-id order.
Source§impl Engine
impl Engine
Sourcepub fn rebuild_text_block_max(
&self,
table: &str,
field: &str,
mode: &ScoringMode,
) -> Result<bool, SQLError>
pub fn rebuild_text_block_max( &self, table: &str, field: &str, mode: &ScoringMode, ) -> Result<bool, SQLError>
Materialize scorer-versioned block bounds for one text field. SQLite
persists them across reopen; when a backend returns false, execution
falls back from the planned BMW strategy to exact WAND.
Source§impl Engine
impl Engine
Sourcepub fn knn_search(
&self,
table: &str,
field: &str,
query_vector: impl AsRef<[f32]>,
top_k: usize,
) -> Result<Vec<ScoredEntry>, SQLError>
pub fn knn_search( &self, table: &str, field: &str, query_vector: impl AsRef<[f32]>, top_k: usize, ) -> Result<Vec<ScoredEntry>, SQLError>
Top-k nearest neighbors through the shared operator optimizer and
executor.
Sourcepub fn diskann_calibration_target(
&self,
table: &str,
field: &str,
embedding_model_id: &str,
embedding_model_version: &str,
candidate_k: usize,
) -> Result<VectorCalibrationTarget, SQLError>
pub fn diskann_calibration_target( &self, table: &str, field: &str, embedding_model_id: &str, embedding_model_version: &str, candidate_k: usize, ) -> Result<VectorCalibrationTarget, SQLError>
Obtain the actual DiskANN corpus and physical-generation versions for fitting a fixed calibration model. Embedding identity remains the caller’s contract. This metadata read does not execute KNN or register a serializable vector predicate.
Sourcepub fn calibrated_vector_search_with_model(
&self,
table: &str,
field: &str,
query_vector: impl AsRef<[f32]>,
model: &VectorCalibrationModel,
target: &VectorCalibrationTarget,
) -> Result<Vec<ScoredEntry>, SQLError>
pub fn calibrated_vector_search_with_model( &self, table: &str, field: &str, query_vector: impl AsRef<[f32]>, model: &VectorCalibrationModel, target: &VectorCalibrationTarget, ) -> Result<Vec<ScoredEntry>, SQLError>
Apply a persisted/offline vector calibration model to a KNN pool.
Unlike calibrated_vector_match, this path never fits parameters from the current query’s top-K results. The target must match the model provenance, physical table/field, index kind, dimensions and candidate K. For DiskANN, obtain actual corpus/generation versions with Self::diskann_calibration_target; execution revalidates them against the same retained index used for KNN. Embedding identity and other index methods’ version labels remain explicit caller contracts.
Source§impl Engine
impl Engine
pub fn create_sequence( &self, name: &str, start: i64, increment: i64, if_not_exists: bool, ) -> Result<bool, String>
Sourcepub fn alter_sequence(
&self,
name: &str,
restart: Option<Option<i64>>,
increment: Option<i64>,
start: Option<i64>,
) -> Result<(), String>
pub fn alter_sequence( &self, name: &str, restart: Option<Option<i64>>, increment: Option<i64>, start: Option<i64>, ) -> Result<(), String>
Compatibility wrapper for the original direct API. SQL lowering and
all internal execution use SequenceRestart instead.
Sourcepub fn try_sequences_snapshot(
&self,
) -> StorageBackendResult<BTreeMap<String, SequenceState>>
pub fn try_sequences_snapshot( &self, ) -> StorageBackendResult<BTreeMap<String, SequenceState>>
Snapshot of all registered sequences as (name, state) pairs.
pub fn sequences_snapshot( &self, ) -> StorageBackendResult<BTreeMap<String, SequenceState>>
Sourcepub fn sequence_state(
&self,
name: &str,
) -> StorageBackendResult<Option<(String, SequenceState)>>
pub fn sequence_state( &self, name: &str, ) -> StorageBackendResult<Option<(String, SequenceState)>>
Resolve a sequence name through the current search_path and return
its canonical name with the current state.
Source§impl Engine
impl Engine
Sourcepub fn run_analyze(&self, table: Option<&str>) -> StorageBackendResult<()>
pub fn run_analyze(&self, table: Option<&str>) -> StorageBackendResult<()>
Refresh per-column statistics for one table, or every table when
table is None. The analysis scans each document and collects per-
column distinct count / null count / min / max / equi-depth
histogram (100 buckets) / MCV list (top 10 above-average
frequency), and stores the result on the per-table state so the
cardinality estimator can read it on subsequent queries.
Sourcepub fn column_stats(
&self,
table: &str,
) -> StorageBackendResult<BTreeMap<String, ColumnStats>>
pub fn column_stats( &self, table: &str, ) -> StorageBackendResult<BTreeMap<String, ColumnStats>>
Snapshot of the cardinality estimator’s per-column statistics
for table. Clean statistics are reused, including sampled scalar
statistics from automatic maintenance. Dirty stats are recomputed
through the same durable transaction boundary as ANALYZE. Use
run_analyze to force full collection regardless of cached statistics.
Persistent query planning only consumes already-collected statistics.
pub fn try_column_stats( &self, table: &str, ) -> StorageBackendResult<BTreeMap<String, ColumnStats>>
Source§impl Engine
impl Engine
pub fn list_catalog_indexes(&self) -> StorageBackendResult<Vec<CatalogIndexRow>>
Sourcepub fn register_schema(
&self,
name: &str,
if_not_exists: bool,
) -> StorageBackendResult<bool>
pub fn register_schema( &self, name: &str, if_not_exists: bool, ) -> StorageBackendResult<bool>
Create a durable schema catalog object. Returns true when a new
schema was created and false only for IF NOT EXISTS.
Sourcepub fn drop_schema(&self, name: &str) -> StorageBackendResult<bool>
pub fn drop_schema(&self, name: &str) -> StorageBackendResult<bool>
Drop an empty durable schema. Virtual system namespaces cannot be removed.
pub fn has_schema(&self, name: &str) -> StorageBackendResult<bool>
Sourcepub fn has_namespace(&self, name: &str) -> StorageBackendResult<bool>
pub fn has_namespace(&self, name: &str) -> StorageBackendResult<bool>
Whether name resolves as a namespace: a durable schema, a virtual
system schema (pg_catalog, information_schema, ag_catalog), or
the namespace a named graph owns.
Sourcepub fn list_schemas(&self) -> StorageBackendResult<Vec<String>>
pub fn list_schemas(&self) -> StorageBackendResult<Vec<String>>
Return every registered schema in sorted order.
Sourcepub fn tables_in_schema(
&self,
schema: &str,
) -> StorageBackendResult<Vec<String>>
pub fn tables_in_schema( &self, schema: &str, ) -> StorageBackendResult<Vec<String>>
Local names of tables whose structural relation identity is owned by
schema. No string-prefix inference participates in this lookup.
pub fn list_sequences(&self) -> StorageBackendResult<Vec<String>>
Source§impl Engine
impl Engine
Sourcepub fn session_termination(&self) -> Option<SQLError>
pub fn session_termination(&self) -> Option<SQLError>
The error that terminated this session, if a session timeout did; every later statement reports it, and a server closes the connection after sending it at FATAL.
Source§impl Engine
impl Engine
Sourcepub fn search_path(&self) -> Vec<String>
pub fn search_path(&self) -> Vec<String>
Return the current search_path.
Sourcepub fn load_library(&self, library: &str) -> Result<(), SQLError>
pub fn load_library(&self, library: &str) -> Result<(), SQLError>
LOAD 'library'. The engine embeds Apache AGE and PL/pgSQL, so loading either succeeds as a no-op through every spelling PostgreSQL resolves against $libdir; any other library fails exactly like a missing shared object.
Sourcepub fn current_schema_name(&self) -> StorageBackendResult<Option<String>>
pub fn current_schema_name(&self) -> StorageBackendResult<Option<String>>
First usable namespace on this logical session’s explicit search path: a durable, virtual system or graph namespace.
Sourcepub fn current_schema_names(
&self,
include_implicit: bool,
) -> StorageBackendResult<Vec<String>>
pub fn current_schema_names( &self, include_implicit: bool, ) -> StorageBackendResult<Vec<String>>
Existing schemas with USAGE privilege in this logical session’s search path. PostgreSQL implicitly searches pg_catalog unless it is already named explicitly.
Sourcepub fn next_random_u64(&self) -> u64
pub fn next_random_u64(&self) -> u64
Draw every bit of one word from this logical session’s PRNG.
Sourcepub fn next_random_value(&self) -> f64
pub fn next_random_value(&self) -> f64
Draw one value in [0, 1) from this logical session’s PRNG.
Sourcepub fn set_random_seed(&self, seed: f64) -> Result<(), String>
pub fn set_random_seed(&self, seed: f64) -> Result<(), String>
Reseed this logical session’s PRNG. Equal seeds produce equal streams without changing any sibling session.
Sourcepub fn set_search_path(&self, path: &[String]) -> Result<(), SQLError>
pub fn set_search_path(&self, path: &[String]) -> Result<(), SQLError>
Set the session’s search_path to path, each schema quoted as an identifier needs, as SET search_path TO with those names does. An empty path finds unqualified names only in the system schemas.
Sourcepub fn set_query_memory_limit(&self, bytes: Option<usize>)
pub fn set_query_memory_limit(&self, bytes: Option<usize>)
Bound the memory each query workspace of this session may hold before it spills, in place of work_mem; None returns to work_mem. Unlike work_mem, whose minimum is PostgreSQL’s 64 kB, the bound may be as small as one byte, so that a host can make queries over little data spill.
Sourcepub fn set_variable(&self, name: &str, value: &str) -> Result<(), SQLError>
pub fn set_variable(&self, name: &str, value: &str) -> Result<(), SQLError>
Apply SET <name> [TO|=] <value> for the session.
pub fn reset_variable(&self, name: &str) -> Result<(), SQLError>
Sourcepub fn reset_all_variables(&self)
pub fn reset_all_variables(&self)
RESET ALL: every parameter except those RESET ALL leaves alone returns to the setting RESET restores.
Source§impl Engine
impl Engine
Sourcepub fn install_sql_function_context(
&self,
context: SQLFunctionContext,
) -> Result<(), SQLFunctionRegistrationError>
pub fn install_sql_function_context( &self, context: SQLFunctionContext, ) -> Result<(), SQLFunctionRegistrationError>
Install immutable host invocation data for this session. Public sibling sessions start empty; internal readers and portal workers inherit it.
pub fn register_scalar_function<F>(
&self,
name: &str,
function: F,
) -> Result<(), SQLError>where
F: SQLScalarFunction + 'static,
Sourcepub fn register_scalar_function_with_options<F>(
&self,
name: &str,
options: SQLFunctionOptions,
function: F,
) -> Result<(), SQLError>where
F: SQLScalarFunction + 'static,
pub fn register_scalar_function_with_options<F>(
&self,
name: &str,
options: SQLFunctionOptions,
function: F,
) -> Result<(), SQLError>where
F: SQLScalarFunction + 'static,
Register a Rust scalar callback with explicit optimizer and transaction properties.
Sourcepub fn register_scalar_function_retained<F>(
&self,
name: &str,
options: SQLFunctionOptions,
function: F,
) -> Result<SQLFunctionRegistration, SQLFunctionRegistrationError>where
F: SQLScalarFunction + 'static,
pub fn register_scalar_function_retained<F>(
&self,
name: &str,
options: SQLFunctionOptions,
function: F,
) -> Result<SQLFunctionRegistration, SQLFunctionRegistrationError>where
F: SQLScalarFunction + 'static,
Register a callback and return its independent retirement handle.
pub fn register_table_function<F>(
&self,
name: &str,
function: F,
) -> Result<(), SQLError>where
F: SQLTableFunction + 'static,
Sourcepub fn register_table_function_with_options<F>(
&self,
name: &str,
options: SQLFunctionOptions,
function: F,
) -> Result<(), SQLError>where
F: SQLTableFunction + 'static,
pub fn register_table_function_with_options<F>(
&self,
name: &str,
options: SQLFunctionOptions,
function: F,
) -> Result<(), SQLError>where
F: SQLTableFunction + 'static,
Register a Rust table callback with explicit optimizer and transaction properties.
Sourcepub fn register_table_function_retained<F>(
&self,
name: &str,
options: SQLFunctionOptions,
function: F,
) -> Result<SQLFunctionRegistration, SQLFunctionRegistrationError>where
F: SQLTableFunction + 'static,
pub fn register_table_function_retained<F>(
&self,
name: &str,
options: SQLFunctionOptions,
function: F,
) -> Result<SQLFunctionRegistration, SQLFunctionRegistrationError>where
F: SQLTableFunction + 'static,
Register a callback and return its independent retirement handle.
pub fn register_aggregate_function<F>(
&self,
name: &str,
function: F,
) -> Result<(), SQLError>where
F: SQLAggregateFactory + 'static,
Sourcepub fn register_aggregate_function_with_options<F>(
&self,
name: &str,
options: SQLFunctionOptions,
function: F,
) -> Result<(), SQLError>where
F: SQLAggregateFactory + 'static,
pub fn register_aggregate_function_with_options<F>(
&self,
name: &str,
options: SQLFunctionOptions,
function: F,
) -> Result<(), SQLError>where
F: SQLAggregateFactory + 'static,
Register a Rust aggregate callback with explicit optimizer and transaction properties.
Sourcepub fn register_aggregate_function_retained<F>(
&self,
name: &str,
options: SQLFunctionOptions,
function: F,
) -> Result<SQLFunctionRegistration, SQLFunctionRegistrationError>where
F: SQLAggregateFactory + 'static,
pub fn register_aggregate_function_retained<F>(
&self,
name: &str,
options: SQLFunctionOptions,
function: F,
) -> Result<SQLFunctionRegistration, SQLFunctionRegistrationError>where
F: SQLAggregateFactory + 'static,
Register a callback and return its independent retirement handle.
Source§impl Engine
impl Engine
pub fn automatic_statistics_status(&self) -> AutomaticStatisticsStatus
pub fn automatic_diskann_maintenance_status(&self) -> DiskANNMaintenanceStatus
Sourcepub fn diskann_rebuild_policy(&self) -> DiskANNRebuildPolicy
pub fn diskann_rebuild_policy(&self) -> DiskANNRebuildPolicy
Database-shared, process-local rebuild thresholds for future maintenance admissions.
Sourcepub fn set_diskann_rebuild_policy(&self, policy: DiskANNRebuildPolicy)
pub fn set_diskann_rebuild_policy(&self, policy: DiskANNRebuildPolicy)
Revisit pending changes under this policy at the next maintenance poll. Current builds retain their admitted policy and resource limits; this setting is not persisted.
Source§impl Engine
impl Engine
Sourcepub fn register_column(
&self,
table: &str,
column: ColumnDef,
) -> StorageBackendResult<()>
pub fn register_column( &self, table: &str, column: ColumnDef, ) -> StorageBackendResult<()>
Append a column to the schema. No data migration is needed because
the document store is sparse; rows missing the column read back as
Value::Null.
Sourcepub fn drop_column(
&self,
table: &str,
column: &str,
) -> StorageBackendResult<bool>
pub fn drop_column( &self, table: &str, column: &str, ) -> StorageBackendResult<bool>
Drop a column and the copies its inheritors have from no other source, as ALTER TABLE ... DROP COLUMN does without CASCADE. Returns false when the table or column does not exist.
pub fn rename_column( &self, table: &str, from: &str, to: &str, ) -> StorageBackendResult<bool>
pub fn rename_table(&self, from: &str, to: &str) -> StorageBackendResult<bool>
Source§impl Engine
impl Engine
pub fn set_column_default( &self, table: &str, column: &str, default: Option<Expr>, ) -> StorageBackendResult<bool>
pub fn set_column_not_null( &self, table: &str, column: &str, not_null: bool, ) -> StorageBackendResult<bool>
pub fn set_column_type( &self, table: &str, column: &str, ty: &ColumnType, ) -> StorageBackendResult<bool>
Sourcepub fn register_table_constraints(
&self,
table: &str,
checks: Vec<TableCheck>,
foreign_keys: Vec<ForeignKey>,
key_constraints: Vec<TableKeyConstraint>,
) -> StorageBackendResult<()>
pub fn register_table_constraints( &self, table: &str, checks: Vec<TableCheck>, foreign_keys: Vec<ForeignKey>, key_constraints: Vec<TableKeyConstraint>, ) -> StorageBackendResult<()>
Register table-level CHECK, FK, PRIMARY KEY, and UNIQUE constraints. Called by the
SQL CREATE TABLE path after the columns are in place.
Sourcepub fn check_constraints(
&self,
table: &str,
) -> StorageBackendResult<Vec<(Option<String>, Expr)>>
pub fn check_constraints( &self, table: &str, ) -> StorageBackendResult<Vec<(Option<String>, Expr)>>
Snapshot of every CHECK constraint that applies to table, merging the
column-level CHECKs into the table-level list. Returns (name, expr)
pairs for backward API compatibility; use
Self::try_check_constraint_definitions when enforcement metadata is
required.
pub fn try_check_constraints( &self, table: &str, ) -> StorageBackendResult<Vec<(Option<String>, Expr)>>
Sourcepub fn try_check_constraint_definitions(
&self,
table: &str,
) -> StorageBackendResult<Vec<TableCheck>>
pub fn try_check_constraint_definitions( &self, table: &str, ) -> StorageBackendResult<Vec<TableCheck>>
Snapshot of every CHECK constraint, including PostgreSQL 18 enforcement
metadata.
Sourcepub fn foreign_keys(&self, table: &str) -> StorageBackendResult<Vec<ForeignKey>>
pub fn foreign_keys(&self, table: &str) -> StorageBackendResult<Vec<ForeignKey>>
Snapshot of every FOREIGN KEY constraint that applies to
table. Column-level REFERENCES are lifted to single-column
ForeignKey entries.
pub fn try_foreign_keys( &self, table: &str, ) -> StorageBackendResult<Vec<ForeignKey>>
Sourcepub fn referrers_to(
&self,
table: &str,
) -> StorageBackendResult<Vec<(String, ForeignKey)>>
pub fn referrers_to( &self, table: &str, ) -> StorageBackendResult<Vec<(String, ForeignKey)>>
Tables that hold a FOREIGN KEY pointing at table. Used by
DELETE / DROP CASCADE to refuse the operation when a referrer
has at least one row matching the target value.
pub fn try_referrers_to( &self, table: &str, ) -> StorageBackendResult<Vec<(String, ForeignKey)>>
Sourcepub fn unique_columns(&self, table: &str) -> StorageBackendResult<Vec<String>>
pub fn unique_columns(&self, table: &str) -> StorageBackendResult<Vec<String>>
Names of columns with a UNIQUE or PRIMARY KEY constraint
declared on the table. Auto-increment columns are excluded
because the engine guarantees their uniqueness through the
monotonic id watermark, so re-checking is redundant.
pub fn try_unique_columns( &self, table: &str, ) -> StorageBackendResult<Vec<String>>
Sourcepub fn key_constraints(
&self,
table: &str,
) -> StorageBackendResult<Vec<TableKeyConstraint>>
pub fn key_constraints( &self, table: &str, ) -> StorageBackendResult<Vec<TableKeyConstraint>>
Every PRIMARY KEY / UNIQUE tuple declared on table. Legacy
column metadata is lifted into scalar constraints so pre-v16 and API-
created tables retain their existing behavior.
pub fn try_key_constraints( &self, table: &str, ) -> StorageBackendResult<Vec<TableKeyConstraint>>
Source§impl Engine
impl Engine
pub fn find_doc_id_by_field( &self, table: &str, field: &str, value: &Value, ) -> Result<Option<DocId>, SQLError>
Sourcepub fn find_conflict(
&self,
table: &str,
columns: &[String],
values: &[Value],
) -> Result<Option<DocId>, SQLError>
pub fn find_conflict( &self, table: &str, columns: &[String], values: &[Value], ) -> Result<Option<DocId>, SQLError>
Find a matching conflict key in the caller’s transaction snapshot. Execution selects the integer primary-key mapping, an answerable value index, or an evaluated scan and records the corresponding serializable read.
Source§impl Engine
impl Engine
Sourcepub fn update_document_fields(
&self,
table: &str,
doc_id: DocId,
updates: BTreeMap<String, Value>,
vectors: BTreeMap<String, Vec<f32>>,
) -> Result<bool, SQLError>
pub fn update_document_fields( &self, table: &str, doc_id: DocId, updates: BTreeMap<String, Value>, vectors: BTreeMap<String, Vec<f32>>, ) -> Result<bool, SQLError>
Apply per-column updates to an existing document. Mirrors the
DO UPDATE SET col = expr branch of an ON CONFLICT clause.
Returns whether the row was updated; Ok(false) when the
document no longer exists. Storage write failures surface as
Err so the enclosing transaction rolls back instead of
committing a delete whose re-insert never happened.
pub fn update_document_fields_with_vector_values( &self, table: &str, doc_id: DocId, updates: BTreeMap<String, Value>, vectors: BTreeMap<String, Vec<Vec<f32>>>, ) -> Result<bool, SQLError>
Sourcepub fn patch_document_fields(
&self,
table: &str,
doc_id: DocId,
updates: &BTreeMap<String, Value>,
vectors: &BTreeMap<String, Vec<f32>>,
) -> Result<bool, SQLError>
pub fn patch_document_fields( &self, table: &str, doc_id: DocId, updates: &BTreeMap<String, Value>, vectors: &BTreeMap<String, Vec<f32>>, ) -> Result<bool, SQLError>
Apply field-level updates to the current command-visible row. Callers must only use this path when constraints and referential actions do not need the old or complete new row.
pub fn patch_document_fields_with_vector_values( &self, table: &str, doc_id: DocId, updates: &BTreeMap<String, Value>, vectors: &BTreeMap<String, Vec<Vec<f32>>>, ) -> Result<bool, SQLError>
pub fn delete_document( &self, table: &str, doc_id: DocId, ) -> Result<(), SQLError>
Source§impl Engine
impl Engine
Sourcepub fn add_fts_field(&self, table: &str, field: FieldName) -> Result<(), String>
pub fn add_fts_field(&self, table: &str, field: FieldName) -> Result<(), String>
Append field to the table’s FTS field list. Existing rows are
indexed immediately so SQL CREATE INDEX USING gin behaves like a
real secondary-index build rather than a metadata-only toggle.
Sourcepub fn add_fts_field_with_analyzer(
&self,
table: &str,
field: FieldName,
analyzer: Option<&str>,
) -> Result<(), String>
pub fn add_fts_field_with_analyzer( &self, table: &str, field: FieldName, analyzer: Option<&str>, ) -> Result<(), String>
Same as Engine::add_fts_field, but allows registering a
per-field analyzer name (e.g. standard_cjk). When None, the
table-level analyzer continues to apply.
Source§impl Engine
impl Engine
Sourcepub fn drop_table(&self, name: &str) -> StorageBackendResult<bool>
pub fn drop_table(&self, name: &str) -> StorageBackendResult<bool>
Drop a table from the catalog and release its in-memory state.
Returns true if the table existed.
pub fn has_table(&self, name: &str) -> StorageBackendResult<bool>
pub fn try_has_table(&self, name: &str) -> StorageBackendResult<bool>
Sourcepub fn table_columns(&self, table: &str) -> StorageBackendResult<Vec<String>>
pub fn table_columns(&self, table: &str) -> StorageBackendResult<Vec<String>>
All schema-declared columns for table, in declaration order.
pub fn try_table_columns( &self, table: &str, ) -> StorageBackendResult<Vec<String>>
pub fn table_has_column( &self, table: &str, column: &str, ) -> StorageBackendResult<bool>
pub fn try_table_has_column( &self, table: &str, column: &str, ) -> StorageBackendResult<bool>
Sourcepub fn table_names(&self) -> StorageBackendResult<Vec<String>>
pub fn table_names(&self) -> StorageBackendResult<Vec<String>>
Sorted list of every registered table name.
Sourcepub fn describe_table(
&self,
table: &str,
) -> StorageBackendResult<Option<Vec<ColumnDef>>>
pub fn describe_table( &self, table: &str, ) -> StorageBackendResult<Option<Vec<ColumnDef>>>
Snapshot the column schema of table. Returns None when no
table by that name is registered.
pub fn try_describe_table( &self, table: &str, ) -> StorageBackendResult<Option<Vec<ColumnDef>>>
Sourcepub fn column_default_expr(
&self,
table: &str,
column: &str,
) -> StorageBackendResult<Option<Expr>>
pub fn column_default_expr( &self, table: &str, column: &str, ) -> StorageBackendResult<Option<Expr>>
DEFAULT expression for column on table, when one was
declared via ... <col> <type> DEFAULT <expr>.
pub fn try_column_default_expr( &self, table: &str, column: &str, ) -> StorageBackendResult<Option<Expr>>
Source§impl Engine
impl Engine
Source§impl Engine
impl Engine
Sourcepub fn create_table(
&self,
name: impl Into<String>,
analyzer: Analyzer,
fts_fields: Vec<FieldName>,
) -> StorageBackendResult<()>
pub fn create_table( &self, name: impl Into<String>, analyzer: Analyzer, fts_fields: Vec<FieldName>, ) -> StorageBackendResult<()>
Register a table. fts_fields is the list of field names that are
tokenized into the inverted index when documents are inserted.
Other fields are still stored in the document store but are not
queryable via text_match / uqa_operators::TermOperator.
Sourcepub fn create_vector_field(
&self,
table: &str,
field: impl Into<FieldName>,
dimensions: u32,
) -> StorageBackendResult<bool>
pub fn create_vector_field( &self, table: &str, field: impl Into<FieldName>, dimensions: u32, ) -> StorageBackendResult<bool>
Register a vector field on a table. Existing document values in the
same field are indexed immediately; later calls to Engine::add_vector
or Engine::add_document_with_vectors keep it current. CREATE INDEX ... USING ivf or CREATE INDEX ... USING hnsw upgrades the field to
the corresponding approximate backend.
pub fn add_vector( &self, table: &str, doc_id: DocId, field: &str, vector: Vec<f32>, ) -> Result<bool, SQLError>
pub fn add_vector_values( &self, table: &str, doc_id: DocId, field: &str, vectors: Vec<Vec<f32>>, ) -> Result<bool, SQLError>
pub fn add_document_with_vectors( &self, table: &str, doc_id: DocId, document: Document, vectors: BTreeMap<FieldName, Vec<f32>>, ) -> Result<(), SQLError>
pub fn add_document_with_vector_values( &self, table: &str, doc_id: DocId, document: Document, vectors: BTreeMap<FieldName, Vec<Vec<f32>>>, ) -> Result<(), SQLError>
pub fn create_default_table( &self, name: impl Into<String>, fts_fields: Vec<FieldName>, ) -> StorageBackendResult<()>
Source§impl Engine
impl Engine
Sourcepub fn close(&self) -> Result<(), SQLError>
pub fn close(&self) -> Result<(), SQLError>
Roll back open transactions, remove this session’s temporary objects and their dependents, and release its runtime resources. A failed completion retains the session and its transaction receipt for retry. Successful closure is idempotent; subsequent query use is unsupported.
Source§impl Engine
impl Engine
Sourcepub fn execute_with_completion<T, E>(
&self,
operation: impl FnOnce(&Self) -> Result<T, E>,
) -> ExecutionOutcome<T, E>
pub fn execute_with_completion<T, E>( &self, operation: impl FnOnce(&Self) -> Result<T, E>, ) -> ExecutionOutcome<T, E>
Run one host operation under the session statement gate and report its native completion facts. The operation retains its own admission, execution and recovery owner; this adapter neither starts a transaction nor retries work. Nested native calls contribute to the same interval, while earlier calls and sibling sessions do not. A successful operation without a retained transaction has finished its implicit work, including a read-only evaluation that required no physical transaction.
Source§impl Engine
impl Engine
pub fn run_transaction_statement( &self, tx: TransactionStmt, ) -> Result<(), SQLError>
Source§impl Engine
impl Engine
pub fn begin(&self) -> Result<(), SQLError>
Sourcepub fn savepoint(&self, name: &str) -> Result<(), SQLError>
pub fn savepoint(&self, name: &str) -> Result<(), SQLError>
Mark a savepoint inside the current transaction.
Sourcepub fn rollback_to_savepoint(&self, name: &str) -> Result<(), SQLError>
pub fn rollback_to_savepoint(&self, name: &str) -> Result<(), SQLError>
Roll back to a named savepoint.
Sourcepub fn transaction_depth(&self) -> usize
pub fn transaction_depth(&self) -> usize
Number of currently-open transaction frames (BEGIN count
minus COMMIT/ROLLBACK count). Useful for assertions in tests
and for status displays in the CLI.
Sourcepub fn transaction_failed(&self) -> bool
pub fn transaction_failed(&self) -> bool
Whether the current transaction has failed and requires rollback. This reports the engine’s transaction state, including failures raised outside SQL text execution and recovery through a savepoint.
Sourcepub fn pending_commit(&self) -> Option<StorageTransactionId>
pub fn pending_commit(&self) -> Option<StorageTransactionId>
Physical write identity of an unresolved completion. Read-only serializable completion has no physical receipt; use pending_transaction_completion to inspect either kind. Callers must not replay transaction bodies.
Sourcepub fn pending_transaction_completion(&self) -> Option<TransactionOutcomeId>
pub fn pending_transaction_completion(&self) -> Option<TransactionOutcomeId>
Retained physical or logical completion identity. Only completion resolution or whole-transaction rollback may proceed while this is present. A failed transaction retains its rollback intent even when the caller requests COMMIT.
Sourcepub fn begin_simple_query_transaction(&self) -> Result<(), SQLError>
pub fn begin_simple_query_transaction(&self) -> Result<(), SQLError>
Start the implicit transaction segment owned by a multi-statement simple-query message.
Sourcepub fn promote_simple_query_transaction(&self) -> Result<(), SQLError>
pub fn promote_simple_query_transaction(&self) -> Result<(), SQLError>
Promote the current simple-query transaction to an explicit block after BEGIN.
Source§impl Engine
impl Engine
Sourcepub fn transaction<R>(
&self,
f: impl FnOnce(&Self) -> Result<R, SQLError>,
) -> Result<R, SQLError>
pub fn transaction<R>( &self, f: impl FnOnce(&Self) -> Result<R, SQLError>, ) -> Result<R, SQLError>
Run f inside one engine transaction. An error or panic from f rolls back the transaction. A successful callback commits; an indeterminate commit retains its sealed attempt in the session for resolution through commit or rollback, without replaying f.
Sourcepub fn sql_batch(
&self,
statements: &[(&str, &[SQLParam])],
) -> Result<Vec<SQLResult>, SQLError>
pub fn sql_batch( &self, statements: &[(&str, &[SQLParam])], ) -> Result<Vec<SQLResult>, SQLError>
Execute multiple SQL statements inside one engine transaction.
Sourcepub fn sql_batch_diagnosed(
&self,
statements: &[(&str, &[SQLParam])],
) -> Result<Vec<SQLResult>, SQLBatchError>
pub fn sql_batch_diagnosed( &self, statements: &[(&str, &[SQLParam])], ) -> Result<Vec<SQLResult>, SQLBatchError>
Execute the same atomic batch while retaining the zero-based failing member. Transaction-boundary failures carry no member; no statement is retried.
Sourcepub fn sql_batch_with_labels(
&self,
statements: &[(&str, &[SQLParam])],
) -> Result<Vec<SQLResult>, SQLError>
pub fn sql_batch_with_labels( &self, statements: &[(&str, &[SQLParam])], ) -> Result<Vec<SQLResult>, SQLError>
Execute multiple SQL statements inside one engine transaction like Engine::sql_batch, replacing each result’s enum values by their labels before the next statement runs, so a later statement cannot remove a type an earlier result still names. Host bindings return these results.
Source§impl Engine
impl Engine
Sourcepub fn sql_function_depth_limit(&self) -> usize
pub fn sql_function_depth_limit(&self) -> usize
Current nesting cap for user-defined routine calls.
Sourcepub fn set_sql_function_depth_limit(&self, limit: usize)
pub fn set_sql_function_depth_limit(&self, limit: usize)
Adjust the nesting cap for user-defined routine calls
(minimum 1). Mirrors PostgreSQL’s max_stack_depth role for
recursive functions.
Sourcepub fn take_sql_notices(&self) -> Vec<SQLNotice>
pub fn take_sql_notices(&self) -> Vec<SQLNotice>
Drain the queued notices in emission order, each with its level, SQLSTATE, message, and the detail and hint PostgreSQL reports as fields of their own.
Sourcepub fn try_take_sql_notice_with<T, E>(
&self,
prepare: impl FnOnce(&SQLNotice) -> Result<T, E>,
) -> Result<Option<(SQLNotice, T)>, E>
pub fn try_take_sql_notice_with<T, E>( &self, prepare: impl FnOnce(&SQLNotice) -> Result<T, E>, ) -> Result<Option<(SQLNotice, T)>, E>
Prepare a destination for the oldest notice before removing it. The callback runs only when a notice exists; rejection or unwinding preserves the queue. It must not reenter this Engine or its notice queue. Success moves the original notice and prepared owner.
Source§impl Engine
impl Engine
Sourcepub fn copy_from(
&self,
statement: &str,
input: impl Read,
) -> Result<u64, SQLError>
pub fn copy_from( &self, statement: &str, input: impl Read, ) -> Result<u64, SQLError>
Consume a PostgreSQL text or CSV COPY relation FROM STDIN stream.
The complete input is decoded before the single underlying multi-row insert starts. Row routing, defaults, identity allocation, generated columns, checks, foreign keys, and statement rollback consequently use exactly the same implementation as INSERT.
Trait Implementations§
Source§impl AddedColumnKeys for Engine
impl AddedColumnKeys for Engine
fn try_key_constraints( &self, table: &str, ) -> Result<Vec<TableKeyConstraint>, ColumnCatalogError>
fn try_foreign_keys( &self, table: &str, ) -> Result<Vec<ForeignKey>, ColumnCatalogError>
Source§impl AggregateClassifier for Engine
impl AggregateClassifier for Engine
fn is_registered_aggregate(&self, name: &str) -> bool
Source§fn is_registered_aggregate_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
) -> Result<bool, SQLError>
fn is_registered_aggregate_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<bool, SQLError>
Source§impl AggregateFunctionRegistry for Engine
impl AggregateFunctionRegistry for Engine
fn registered_aggregate_function( &self, name: &str, ) -> Option<Arc<dyn SQLAggregateFactory>>
Source§impl AnalyzeCatalog for Engine
impl AnalyzeCatalog for Engine
fn resolve(&self, name: &str) -> Result<Option<AnalyzeTarget>, SQLError>
fn all_tables(&self) -> Vec<AnalyzeTarget>
fn current_target(&self, object_id: [u8; 16]) -> Option<AnalyzeTarget>
fn descendants(&self, name: &str) -> Result<Vec<String>, SQLError>
Source§impl AnalyzeLocks for Engine
impl AnalyzeLocks for Engine
Source§impl AnalyzerRevisions for Engine
impl AnalyzerRevisions for Engine
fn analyzer_revision(&self, name: &str) -> Result<Arc<CompiledAnalyzer>, String>
Source§impl AnalyzerTableFunctions for Engine
impl AnalyzerTableFunctions for Engine
fn register_named_analyzer( &self, name: &str, config: &str, ) -> Result<(), String>
fn drop_named_analyzer(&self, name: &str) -> Result<bool, String>
fn list_named_analyzers(&self) -> Result<Vec<String>, String>
fn set_table_field_analyzer( &self, table: &str, field: &str, analyzer: &str, phase: &str, ) -> Result<(), SQLError>
fn fts_index_stats( &self, table: Option<&str>, ) -> Result<Vec<FtsIndexStat>, SQLError>
Source§impl AssignmentColumnCatalog for Engine
impl AssignmentColumnCatalog for Engine
fn try_describe_table( &self, table: &str, ) -> Result<Option<Vec<ColumnDef>>, ColumnCatalogError>
fn columns_declared(&self, table: &str) -> Result<bool, ColumnCatalogError>
Source§fn with_column_metadata_with_control(
&self,
table: &str,
control: &ProductionControl<'_>,
read: &mut dyn FnMut(&[ColumnDef]) -> Result<(), SQLError>,
) -> Result<bool, SQLError>
fn with_column_metadata_with_control( &self, table: &str, control: &ProductionControl<'_>, read: &mut dyn FnMut(&[ColumnDef]) -> Result<(), SQLError>, ) -> Result<bool, SQLError>
fn columns_declared_with_control( &self, table: &str, control: &ProductionControl<'_>, ) -> Result<bool, SQLError>
fn try_column_insert_default_expr( &self, table: &str, column: &str, ) -> Result<Option<Expr>, ColumnCatalogError>
Source§fn try_identity_column_sequence(
&self,
table: &str,
column: &str,
) -> Result<Option<String>, SQLError>
fn try_identity_column_sequence( &self, table: &str, column: &str, ) -> Result<Option<String>, SQLError>
PostgreSQL’s error.Source§fn try_column_shape(
&self,
table: &str,
column: &str,
) -> Result<Option<Option<ColumnShape>>, ColumnCatalogError>
fn try_column_shape( &self, table: &str, column: &str, ) -> Result<Option<Option<ColumnShape>>, ColumnCatalogError>
None for an unknown table, and an inner None for a column the table does not declare. Every written value asks for it, so a catalog answers from the column alone. The default describes the whole table, which copies every column and resolves every default expression.Source§impl AssignmentContext for Engine
impl AssignmentContext for Engine
Source§fn evaluate_domain_check_with_control(
&self,
expression: &Expr,
row: &dyn RowLookup,
schema: &RowSchema,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>, SQLError>
fn evaluate_domain_check_with_control( &self, expression: &Expr, row: &dyn RowLookup, schema: &RowSchema, control: &ProductionControl<'_>, ) -> Result<Produced<Value>, SQLError>
Source§fn domain_display_name_with_control(
&self,
oid: u32,
control: &ProductionControl<'_>,
) -> Result<Produced<String>, SQLError>
fn domain_display_name_with_control( &self, oid: u32, control: &ProductionControl<'_>, ) -> Result<Produced<String>, SQLError>
fn evaluate_domain_check( &self, expression: &Expr, row: &dyn RowLookup, schema: &RowSchema, ) -> Result<Value, SQLError>
Source§impl AsyncSQLEngine for Engine
impl AsyncSQLEngine for Engine
type Error = SQLError
fn sql<'a>( &'a self, query: &'a str, params: &'a [SQLParam], ) -> impl Future<Output = Result<SQLResult, Self::Error>> + Send + 'a
fn sql_batch<'a>( &'a self, statements: &'a [(&'a str, &'a [SQLParam])], ) -> impl Future<Output = Result<Vec<SQLResult>, Self::Error>> + Send + 'a
Source§impl BatchRowLocks for Engine
impl BatchRowLocks for Engine
fn begin_row_lock_statement(&self) -> Box<dyn RowLockStatementGuard + '_>
fn statement_row_lock_cache(&self) -> Result<Arc<RowLockRetryCache>, SQLError>
Source§impl BatchTransactions for Engine
impl BatchTransactions for Engine
Source§fn refresh_idle_statement_view(&self) -> Result<(), SQLError>
fn refresh_idle_statement_view(&self) -> Result<(), SQLError>
fn begin_simple_query_transaction(&self) -> Result<(), SQLError>
fn promote_simple_query_transaction(&self) -> Result<(), SQLError>
fn run_transaction_statement( &self, statement: TransactionStmt, ) -> Result<(), SQLError>
Source§fn with_active_transaction(
&self,
operation: &mut dyn FnMut() -> Result<(), SQLError>,
) -> Result<(), SQLError>
fn with_active_transaction( &self, operation: &mut dyn FnMut() -> Result<(), SQLError>, ) -> Result<(), SQLError>
fn prepare_explicit_statement_snapshot( &self, sets_snapshot: bool, ) -> Result<(), SQLError>
fn prepare_explicit_transaction_writer(&self) -> Result<bool, SQLError>
fn begin_implicit_statement_transaction( &self, read_only: bool, ) -> Result<(), SQLError>
Source§impl BuiltinRoutineSecurityCatalog for Engine
impl BuiltinRoutineSecurityCatalog for Engine
fn builtin_routine_securities(&self) -> BuiltinRoutineSecurityRead<'_>
Source§impl BuiltinRoutineSecurityState for Engine
impl BuiltinRoutineSecurityState for Engine
fn builtin_routine_securities_write( &self, ) -> Box<dyn DerefMut<Target = BuiltinRoutineSecurities> + '_>
Source§impl CatalogExpressionEvaluation for Engine
impl CatalogExpressionEvaluation for Engine
Source§impl CatalogInputFunctions for Engine
impl CatalogInputFunctions for Engine
Source§fn read_unknown_input_with_control(
&self,
text: &str,
target: &ColumnType,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>, SQLError>
fn read_unknown_input_with_control( &self, text: &str, target: &ColumnType, control: &ProductionControl<'_>, ) -> Result<Produced<Value>, SQLError>
fn read_unknown_input( &self, text: &str, target: &ColumnType, ) -> Result<Value, SQLError>
Source§impl CatalogNamespace for Engine
impl CatalogNamespace for Engine
fn current_schema_names(&self, implicit: bool) -> Result<Vec<String>, SQLError>
Source§fn current_schema_names_with_catalog(
&self,
catalog: &CatalogReadView,
implicit: bool,
) -> Result<Vec<String>, SQLError>
fn current_schema_names_with_catalog( &self, catalog: &CatalogReadView, implicit: bool, ) -> Result<Vec<String>, SQLError>
Source§impl CatalogPublicationChanges for Engine
impl CatalogPublicationChanges for Engine
Source§fn prepared_relation_changed(&self, relation: &RelationIdentity)
fn prepared_relation_changed(&self, relation: &RelationIdentity)
fn prepared_catalog_changed(&self, change: PreparedCatalogChange)
fn table_catalog_changed(&self)
fn catalog_registry_changed(&self)
Source§impl CatalogRemovalInputs for Engine
impl CatalogRemovalInputs for Engine
fn catalog_removal_context(&self) -> CatalogRemovalContext<'_>
Source§impl CatalogRoutineScopes for Engine
impl CatalogRoutineScopes for Engine
fn with_catalog_scope( &self, analyze: StatementAnalysisOperation<'_>, ) -> Result<(), SQLError>
Source§impl CatalogSession for Engine
impl CatalogSession for Engine
fn current_role(&self) -> RoleReference
fn temporary_schema_name(&self) -> String
fn relation_name_resolution(&self) -> RelationNameResolution
Source§fn relation_name_resolution_with_control(
&self,
control: &ProductionControl<'_>,
) -> Result<Produced<RelationNameResolution>, SQLError>
fn relation_name_resolution_with_control( &self, control: &ProductionControl<'_>, ) -> Result<Produced<RelationNameResolution>, SQLError>
Source§fn show_parameter(&self, name: &str) -> Result<(String, String), SQLError>
fn show_parameter(&self, name: &str) -> Result<(String, String), SQLError>
name refers to and its value as SHOW reports it.Source§fn parameter_name_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
) -> Result<Produced<String>, SQLError>
fn parameter_name_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<Produced<String>, SQLError>
Source§fn parameter_settings(&self) -> Vec<ParameterSetting>
fn parameter_settings(&self) -> Vec<ParameterSetting>
SHOW ALL and pg_settings report, in name order.Source§fn explain_settings(
&self,
control: &ProductionControl<'_>,
) -> Result<Produced<ExplainSettings>, SQLError>
fn explain_settings( &self, control: &ProductionControl<'_>, ) -> Result<Produced<ExplainSettings>, SQLError>
fn prepared_statements(&self) -> Vec<PreparedStatementMetadata>
fn cursors(&self) -> Vec<CursorMetadata>
Source§impl CatalogSnapshotSource for Engine
impl CatalogSnapshotSource for Engine
Source§fn bind_query_reads(
&self,
snapshot: CatalogReadView,
) -> Result<CatalogReadView, SQLError>
fn bind_query_reads( &self, snapshot: CatalogReadView, ) -> Result<CatalogReadView, SQLError>
Source§fn retain_catalog_rows(
&self,
snapshot: CatalogReadView,
) -> Result<CatalogReadView, SQLError>
fn retain_catalog_rows( &self, snapshot: CatalogReadView, ) -> Result<CatalogReadView, SQLError>
fn refreshed_catalog_snapshot(&self) -> Result<CatalogReadView, SQLError>
Source§fn refresh_catalog(&self) -> Result<(), SQLError>
fn refresh_catalog(&self) -> Result<(), SQLError>
fn catalog_snapshot(&self) -> CatalogReadView
Source§fn builtin_routine_permissions(
&self,
current_role: RoleReference,
) -> BuiltinRoutinePermissions
fn builtin_routine_permissions( &self, current_role: RoleReference, ) -> BuiltinRoutinePermissions
Source§fn current_catalog_snapshot(&self) -> CatalogReadView
fn current_catalog_snapshot(&self) -> CatalogReadView
Source§fn current_catalog_revision(&self) -> Option<u64>
fn current_catalog_revision(&self) -> Option<u64>
None.Source§impl ColumnAdditionState for Engine
impl ColumnAdditionState for Engine
fn has_column(&self, table: &str, column: &str) -> StorageBackendResult<bool>
fn create_vector_field( &self, table: &str, column: String, dimensions: u32, ) -> StorageBackendResult<bool>
fn add_text_field(&self, table: &str, column: String) -> Result<(), SQLError>
fn set_missing_value( &self, table: &str, column: &str, value: Option<Value>, ) -> Result<(), SQLError>
fn persist_schema(&self, table: &str) -> StorageBackendResult<bool>
Source§impl ColumnBackfillState for Engine
impl ColumnBackfillState for Engine
fn column_type( &self, table: &str, column: &str, ) -> StorageBackendResult<Option<ColumnType>>
fn clear_missing_values(&self, table: &str) -> Result<(), SQLError>
Source§impl ColumnChangeCatalog for Engine
impl ColumnChangeCatalog for Engine
fn has_column( &self, table: &str, column: &str, ) -> Result<bool, ColumnCatalogError>
fn column_type( &self, table: &str, column: &str, ) -> Result<Option<ColumnType>, ColumnCatalogError>
fn stored_columns( &self, table: &str, ) -> Result<Vec<ColumnDef>, ColumnCatalogError>
Source§impl ColumnDropCatalog for Engine
impl ColumnDropCatalog for Engine
fn resolve_table( &self, table: &str, action: &str, ) -> StorageBackendResult<Option<String>>
fn table( &self, table: &str, ) -> StorageBackendResult<Option<Box<dyn ColumnDropTable + '_>>>
fn entries(&self) -> ColumnDependencyEntries<'_>
Source§impl ColumnDropIndexes for Engine
impl ColumnDropIndexes for Engine
fn read_indexes(&self) -> IndexRowsRead<'_>
fn write_indexes(&self) -> IndexRowsWrite<'_>
fn drop_catalog_index( &self, name: &RelationIdentity, ) -> StorageBackendResult<()>
fn remove_value_index( &self, table: &str, key: &ValueIndexKey, ) -> StorageBackendResult<()>
fn remove_field_analyzer(&self, table: &str, column: &str)
fn refresh_value_indexes(&self, table: &str) -> StorageBackendResult<()>
Source§impl ColumnDropRows for Engine
impl ColumnDropRows for Engine
Source§impl ColumnDropRules for Engine
impl ColumnDropRules for Engine
fn prepare( &self, table: &str, column: &str, ) -> StorageBackendResult<PreparedRuleColumnDrop>
fn finish(&self, prepared: PreparedRuleColumnDrop) -> StorageBackendResult<()>
Source§impl ColumnDropSequences for Engine
impl ColumnDropSequences for Engine
fn owned_by_column( &self, table: [u8; 16], column: [u8; 16], ) -> StorageBackendResult<BTreeSet<String>>
Source§impl ColumnIndexChanges for Engine
impl ColumnIndexChanges for Engine
fn drop_vector_indexes( &self, table: &str, column: &str, ) -> StorageBackendResult<bool>
fn prepare_vector_rewrite( &self, table: &str, column: &str, dimensions: u32, ) -> StorageBackendResult<()>
fn rebuild_vector_index( &self, table: &str, column: &str, dimensions: u32, ) -> StorageBackendResult<bool>
Source§impl ColumnRemovalViews for Engine
impl ColumnRemovalViews for Engine
fn dependents( &self, table: &str, column: &str, ) -> StorageBackendResult<Vec<String>>
Source§impl ColumnRewritePublication for Engine
impl ColumnRewritePublication for Engine
Source§impl CommentPublication for Engine
impl CommentPublication for Engine
fn comments(&self) -> Box<dyn Deref<Target = CommentRegistry> + '_>
fn comment_catalog(&self) -> Option<&dyn CatalogFacade>
fn publish_comments(&self, registry: CommentRegistry)
Source§impl CommittedRowSource for Engine
impl CommittedRowSource for Engine
fn get_committed_document( &self, table: &str, doc_id: DocId, ) -> Result<Option<StoredDocument>, SQLError>
Source§impl CompositeRegistryPublication for Engine
impl CompositeRegistryPublication for Engine
fn composite_registry(&self) -> CompositeRegistryRead<'_>
fn composite_catalog(&self) -> Option<&dyn CatalogFacade>
fn composite_role_definitions(&self) -> BTreeMap<String, RoleDefinition>
fn publish_composite_definitions(&self, registry: CompositeRegistry)
Source§impl CompositeTypeCatalog for Engine
impl CompositeTypeCatalog for Engine
Source§fn composite_type_with_control(
&self,
type_oid: u32,
control: &ProductionControl<'_>,
) -> Result<Option<OwnedCompositeTypeDescriptor>, SQLError>
fn composite_type_with_control( &self, type_oid: u32, control: &ProductionControl<'_>, ) -> Result<Option<OwnedCompositeTypeDescriptor>, SQLError>
Source§fn composite_type(
&self,
type_oid: u32,
) -> Result<Option<Arc<CompositeTypeDescriptor>>, SQLError>
fn composite_type( &self, type_oid: u32, ) -> Result<Option<Arc<CompositeTypeDescriptor>>, SQLError>
None when the catalog has no such type.Source§impl CompositeValueTables for Engine
impl CompositeValueTables for Engine
Source§impl ConflictCatalog for Engine
impl ConflictCatalog for Engine
fn try_describe_table( &self, table: &str, ) -> Result<Option<Vec<ColumnDef>>, String>
Source§fn with_column_metadata_with_control(
&self,
table: &str,
control: &ProductionControl<'_>,
read: &mut dyn FnMut(&[ColumnDef]) -> Result<(), SQLError>,
) -> Result<bool, SQLError>
fn with_column_metadata_with_control( &self, table: &str, control: &ProductionControl<'_>, read: &mut dyn FnMut(&[ColumnDef]) -> Result<(), SQLError>, ) -> Result<bool, SQLError>
fn enforced_keys(&self, table: &str) -> Result<Vec<EnforcedKey>, String>
fn try_declared_table_constraints( &self, table: &str, ) -> Result<TableConstraintSet, String>
Source§impl ConstraintAlterAccess for Engine
impl ConstraintAlterAccess for Engine
Source§impl ConstraintCatalog for Engine
impl ConstraintCatalog for Engine
fn try_unique_columns(&self, table: &str) -> Result<Vec<String>, String>
fn try_check_constraint_definitions( &self, table: &str, ) -> Result<Vec<TableCheck>, String>
fn try_foreign_keys(&self, table: &str) -> Result<Vec<ForeignKey>, String>
fn column_type( &self, table: &str, column: &str, ) -> Result<Option<ColumnType>, String>
fn hierarchy_scan_tables( &self, table: &str, descendants: bool, ) -> Result<Vec<String>, SQLError>
Source§impl ConstraintDiagnosticSource for Engine
impl ConstraintDiagnosticSource for Engine
fn diagnostic_context(&self) -> ConstraintDiagnosticContext<'_>
Source§impl ConstraintModes for Engine
impl ConstraintModes for Engine
Source§impl ConstraintNameCatalog for Engine
impl ConstraintNameCatalog for Engine
fn constraint_table( &self, relation: &RelationIdentity, ) -> Option<ConstraintTableMetadata>
fn constraint_owner( &self, object_id: [u8; 16], ) -> Option<(RelationIdentity, ConstraintTableMetadata)>
fn constraint_schema_tables(&self, schema: &str) -> Vec<ConstraintTableMetadata>
fn constraint_foreign_tables( &self, ) -> Arc<BTreeMap<RelationIdentity, StoredForeignTable>> ⓘ
fn constraint_domains(&self) -> Arc<DomainRegistry> ⓘ
fn constraint_triggers(&self) -> Arc<TriggerCatalog> ⓘ
Source§impl ConstraintRelations for Engine
impl ConstraintRelations for Engine
fn table_names(&self) -> StorageBackendResult<Vec<String>>
fn table_hierarchy(&self, table: &str) -> StorageBackendResult<TableHierarchy>
Source§impl ConstraintTransactions for Engine
impl ConstraintTransactions for Engine
fn foreign_key_is_deferred( &self, table: &str, key: &ForeignKey, ) -> Result<bool, SQLError>
Source§fn referenced_key_is_deferred(
&self,
table: &str,
key: &ForeignKey,
derived: Option<&ReferencedPartitionConstraint>,
) -> Result<bool, SQLError>
fn referenced_key_is_deferred( &self, table: &str, key: &ForeignKey, derived: Option<&ReferencedPartitionConstraint>, ) -> Result<bool, SQLError>
derived names when the foreign key derives one on the firing partition.fn refresh_explicit_statement_snapshot(&self) -> Result<(), SQLError>
fn lock_key_reservation( &self, key: [u8; 32], table: &str, ) -> Result<LockAcquire, SQLError>
Source§fn lock_key_reservations(
&self,
keys: &[[u8; 32]],
table: &str,
) -> Result<Vec<LockAcquire>, SQLError>
fn lock_key_reservations( &self, keys: &[[u8; 32]], table: &str, ) -> Result<Vec<LockAcquire>, SQLError>
Source§impl ConstraintTriggerEvents for Engine
impl ConstraintTriggerEvents for Engine
fn forget(&self, identity: &ConstraintIdentity)
fn rename_trigger(&self, identity: &ConstraintIdentity, name: &str)
fn rename_constraint(&self, identity: &ConstraintIdentity, name: &str)
Source§impl ConstraintTriggerQueue for Engine
impl ConstraintTriggerQueue for Engine
fn constraint_trigger_is_deferred( &self, trigger: &StoredTrigger, ) -> Result<bool, SQLError>
fn defer_constraint_trigger_event( &self, event: DeferredConstraintTriggerEvent, ) -> Result<(), SQLError>
Source§impl ConstraintTypeReferrers for Engine
impl ConstraintTypeReferrers for Engine
fn try_referrers_to( &self, table: &str, ) -> Result<Vec<(String, ForeignKey)>, ColumnCatalogError>
Source§impl CopyCatalog for Engine
impl CopyCatalog for Engine
Source§impl CopyPrivileges for Engine
impl CopyPrivileges for Engine
fn ensure_any_column( &self, table: &str, privilege: TableAclPrivilege, ) -> Result<(), SQLError>
fn ensure_column( &self, table: &str, column: &str, privilege: TableAclPrivilege, ) -> Result<(), SQLError>
Source§impl CopyStatements for Engine
impl CopyStatements for Engine
Source§impl CreationRelationGuards for Engine
impl CreationRelationGuards for Engine
fn named_type_exists(&self, identity: &RelationIdentity) -> bool
fn tables(&self) -> Box<dyn CreationRelationNames + '_>
fn views(&self) -> Box<dyn CreationRelationNames + '_>
fn sequences(&self) -> Box<dyn CreationRelationNames + '_>
fn foreign_tables(&self) -> Box<dyn CreationRelationNames + '_>
fn indexes(&self) -> Box<dyn CreationRelationNames + '_>
Source§fn composite_types(&self) -> Box<dyn CreationRelationNames + '_>
fn composite_types(&self) -> Box<dyn CreationRelationNames + '_>
Source§impl CypherTableRuntime for Engine
impl CypherTableRuntime for Engine
Source§impl DatabasePrivilegeCatalog for Engine
impl DatabasePrivilegeCatalog for Engine
fn refresh_privilege_catalog(&self) -> Result<(), SQLError>
fn security(&self) -> DatabaseSecurityRead<'_>
Source§impl DatabasePrivilegePublication for Engine
impl DatabasePrivilegePublication for Engine
fn prepare_writer(&self) -> Result<(), SQLError>
fn refresh_catalog(&self) -> StorageBackendResult<()>
fn persist_security(&self, json: &str) -> Result<(), SQLError>
fn catalog_changed(&self)
fn notice(&self, notice: SQLNotice)
Source§impl DatabaseSecurityRegistry for Engine
impl DatabaseSecurityRegistry for Engine
fn security_read(&self) -> DatabaseSecurityRead<'_>
fn security_write(&self) -> DatabaseSecurityWrite<'_>
Source§impl DetachedConstraintModes for Engine
impl DetachedConstraintModes for Engine
fn preserve_split_modes( &self, retained: &[ConstraintIdentity], detached: &[ConstraintIdentityChange], ) -> Result<(), SQLError>
Source§impl DomainCatalog for Engine
impl DomainCatalog for Engine
Source§fn domain_by_oid_with_control(
&self,
oid: u32,
control: &ProductionControl<'_>,
) -> Result<Option<Produced<StoredDomain>>, SQLError>
fn domain_by_oid_with_control( &self, oid: u32, control: &ProductionControl<'_>, ) -> Result<Option<Produced<StoredDomain>>, SQLError>
fn domain_by_oid(&self, oid: u32) -> Option<StoredDomain>
Source§impl DomainConstraintBinding for Engine
impl DomainConstraintBinding for Engine
fn bind_added_check( &self, definition: &CreateDomain, check: DomainCheck, ) -> Result<DomainCheck, SQLError>
fn bind_added_not_null( &self, definition: &CreateDomain, constraint: DomainNotNull, ) -> Result<DomainNotNull, SQLError>
Source§impl DomainDeclarationBinding for Engine
impl DomainDeclarationBinding for Engine
fn bind_domain_declaration( &self, definition: &mut CreateDomain, ) -> Result<(), SQLError>
Source§impl DomainDependencyCatalog for Engine
impl DomainDependencyCatalog for Engine
fn domain_definitions(&self) -> BTreeMap<String, StoredDomain>
Source§impl DomainDropNotices for Engine
impl DomainDropNotices for Engine
fn domain_drop_notice(&self, notice: SQLNotice)
Source§impl DomainRegistryPublication for Engine
impl DomainRegistryPublication for Engine
fn domain_registry(&self) -> DomainRegistryRead<'_>
fn domain_catalog(&self) -> Option<&dyn CatalogFacade>
fn publish_domain_definitions( &self, registry: BTreeMap<String, StoredDomain>, ) -> Result<(), SQLError>
Source§impl DomainValidationTables for Engine
impl DomainValidationTables for Engine
Source§impl DropStatementBindings for Engine
impl DropStatementBindings for Engine
fn with_foreign_server_removal_write( &self, write: ForeignServerRemovalWrite<'_>, ) -> Result<SQLResult, SQLError>
fn with_schema_removal_write( &self, write: SchemaRemovalWrite<'_>, ) -> Result<SQLResult, SQLError>
fn with_domain_removal_write( &self, write: DomainRemovalWrite<'_>, ) -> Result<SQLResult, SQLError>
fn with_relation_removal_inputs( &self, run: RelationRemovalWrite<'_>, ) -> Result<SQLResult, SQLError>
Source§impl EmptySchemaCatalog for Engine
impl EmptySchemaCatalog for Engine
fn schema_registered(&self, name: &str) -> bool
fn schema_is_empty(&self, name: &str) -> bool
Source§impl EmptySchemaRemovalPersistence for Engine
impl EmptySchemaRemovalPersistence for Engine
fn drop_schema_row(&self, name: &str) -> StorageBackendResult<()>
Source§impl EmptySchemaRemovalState for Engine
impl EmptySchemaRemovalState for Engine
fn schema_registry_write(&self) -> SchemaRegistryWrite<'_>
Source§impl EngineHook for Engine
impl EngineHook for Engine
Source§fn construct_range(
&self,
oid: u32,
bounds: RangeBoundsInput,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>, SQLError>
fn construct_range( &self, oid: u32, bounds: RangeBoundsInput, control: &ProductionControl<'_>, ) -> Result<Produced<Value>, SQLError>
Source§fn construct_multirange(
&self,
oid: u32,
members: &[Value],
control: &ProductionControl<'_>,
) -> Result<Produced<Value>, SQLError>
fn construct_multirange( &self, oid: u32, members: &[Value], control: &ProductionControl<'_>, ) -> Result<Produced<Value>, SQLError>
Source§fn sql_notice(&self, notice: SQLNotice)
fn sql_notice(&self, notice: SQLNotice)
Source§fn read_range_input(
&self,
oid: u32,
text: &str,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>, SQLError>
fn read_range_input( &self, oid: u32, text: &str, control: &ProductionControl<'_>, ) -> Result<Produced<Value>, SQLError>
Source§fn require_builtin_execute(
&self,
binding: &FunctionBinding,
) -> Result<(), SQLError>
fn require_builtin_execute( &self, binding: &FunctionBinding, ) -> Result<(), SQLError>
Source§fn require_builtin_execute_with_control(
&self,
binding: &FunctionBinding,
control: &ProductionControl<'_>,
) -> Result<(), SQLError>
fn require_builtin_execute_with_control( &self, binding: &FunctionBinding, control: &ProductionControl<'_>, ) -> Result<(), SQLError>
Source§fn transaction_timestamp_micros(&self) -> Option<i64>
fn transaction_timestamp_micros(&self) -> Option<i64>
Source§fn statement_timestamp_micros(&self) -> Option<i64>
fn statement_timestamp_micros(&self) -> Option<i64>
Source§fn resolve_oid_alias_input_with_control(
&self,
ty: &ColumnType,
name: &str,
control: &ProductionControl<'_>,
) -> Result<Option<i64>, SQLError>
fn resolve_oid_alias_input_with_control( &self, ty: &ColumnType, name: &str, control: &ProductionControl<'_>, ) -> Result<Option<i64>, SQLError>
Source§fn resolve_regtype_input(&self, name: &str) -> Result<Option<i64>, SQLError>
fn resolve_regtype_input(&self, name: &str) -> Result<Option<i64>, SQLError>
Source§fn cast_domain(
&self,
value: &Value,
source: Option<&str>,
target: &ColumnType,
) -> Result<Option<Value>, SQLError>
fn cast_domain( &self, value: &Value, source: Option<&str>, target: &ColumnType, ) -> Result<Option<Value>, SQLError>
Source§fn cast_domain_with_control(
&self,
value: &Value,
source: Option<&str>,
target: &ColumnType,
control: &ProductionControl<'_>,
) -> Result<Option<Produced<Value>>, SQLError>
fn cast_domain_with_control( &self, value: &Value, source: Option<&str>, target: &ColumnType, control: &ProductionControl<'_>, ) -> Result<Option<Produced<Value>>, SQLError>
Source§fn resolve_type_name(&self, name: &str) -> Result<Option<ColumnType>, String>
fn resolve_type_name(&self, name: &str) -> Result<Option<ColumnType>, String>
Source§fn resolve_type_oid(&self, oid: u32) -> Result<Option<ColumnType>, String>
fn resolve_type_oid(&self, oid: u32) -> Result<Option<ColumnType>, String>
Source§fn resolve_type_name_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
) -> Result<Option<Produced<ColumnType>>, SQLError>
fn resolve_type_name_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<Option<Produced<ColumnType>>, SQLError>
fn resolve_type_oid_with_control( &self, oid: u32, control: &ProductionControl<'_>, ) -> Result<Option<Produced<ColumnType>>, SQLError>
Source§fn type_oid_exists(&self, oid: u32) -> Result<bool, String>
fn type_oid_exists(&self, oid: u32) -> Result<bool, String>
Source§fn resolve_regclass_input(&self, name: &str) -> Result<Option<i64>, SQLError>
fn resolve_regclass_input(&self, name: &str) -> Result<Option<i64>, SQLError>
regclass input while preserving typed SQL errors. Embedders that implement the historical string-error hook retain its previous behavior; engines with catalog privilege checks override this method directly.Source§fn resolve_regproc(&self, name: &str) -> Result<Option<i64>, SQLError>
fn resolve_regproc(&self, name: &str) -> Result<Option<i64>, SQLError>
regproc input does.Source§fn resolve_regprocedure(&self, name: &str) -> Result<Option<i64>, String>
fn resolve_regprocedure(&self, name: &str) -> Result<Option<i64>, String>
regprocedure.Source§fn resolve_regprocedure_input(
&self,
name: &str,
) -> Result<Option<i64>, SQLError>
fn resolve_regprocedure_input( &self, name: &str, ) -> Result<Option<i64>, SQLError>
regprocedure input while preserving the typed errors regprocedurein reports. Embedders that implement only the historical lookup hook keep its behavior.Source§fn resolve_regrole(&self, name: &str) -> Result<Option<i64>, SQLError>
fn resolve_regrole(&self, name: &str) -> Result<Option<i64>, SQLError>
regrole input while preserving hard input errors for direct casts.Source§fn resolve_regnamespace(&self, name: &str) -> Result<Option<i64>, SQLError>
fn resolve_regnamespace(&self, name: &str) -> Result<Option<i64>, SQLError>
regnamespace input while preserving hard input errors for direct casts.Source§fn resolve_regcollation(&self, name: &str) -> Result<Option<i64>, SQLError>
fn resolve_regcollation(&self, name: &str) -> Result<Option<i64>, SQLError>
regcollation input with the direct input function’s diagnostics.Source§fn resolve_regobject(
&self,
ty: &ColumnType,
name: &str,
) -> Result<Option<i64>, SQLError>
fn resolve_regobject( &self, ty: &ColumnType, name: &str, ) -> Result<Option<i64>, SQLError>
PostgreSQL to_reg* lookup function. The engine override owns catalog visibility and the lookup function’s NULL-versus-error boundary; the default preserves the two historical hooks for embedders that only implement regclass or regprocedure.Source§fn resolve_regtype_output(
&self,
ty: &ColumnType,
oid: i64,
) -> Result<Option<String>, String>
fn resolve_regtype_output( &self, ty: &ColumnType, oid: i64, ) -> Result<Option<String>, String>
PostgreSQL text output.Source§fn enum_labels(&self) -> Option<&dyn EnumLabelCatalog>
fn enum_labels(&self) -> Option<&dyn EnumLabelCatalog>
Source§fn composite_types(&self) -> Option<&dyn CompositeTypeCatalog>
fn composite_types(&self) -> Option<&dyn CompositeTypeCatalog>
fn nextval(&self, name: &str) -> Result<i64, SQLError>
fn currval(&self, name: &str) -> Result<i64, SQLError>
fn lastval(&self) -> Result<i64, SQLError>
fn setval( &self, name: &str, value: i64, is_called: bool, ) -> Result<i64, SQLError>
fn call_scalar_function( &self, name: &str, args: &[Value], ) -> Option<Result<Value, SQLError>>
Source§fn call_bound_builtin_function(
&self,
binding: &FunctionBinding,
args: &[(Option<String>, Value)],
) -> Option<Result<Value, SQLError>>
fn call_bound_builtin_function( &self, binding: &FunctionBinding, args: &[(Option<String>, Value)], ) -> Option<Result<Value, SQLError>>
call_scalar_function, this path is also available
when dynamic dispatch is disabled, so runtime callbacks cannot override
the stored built-in identity.fn has_scalar_functions(&self) -> bool
Source§fn call_bound_builtin_function_with_control(
&self,
binding: &FunctionBinding,
args: &[(Option<String>, Value)],
control: &ProductionControl<'_>,
) -> Option<Result<Produced<Value>, SQLError>>
fn call_bound_builtin_function_with_control( &self, binding: &FunctionBinding, args: &[(Option<String>, Value)], control: &ProductionControl<'_>, ) -> Option<Result<Produced<Value>, SQLError>>
Source§fn current_schema(&self) -> Result<Option<String>, String>
fn current_schema(&self) -> Result<Option<String>, String>
None when there is none, which current_schema() reports as NULL. A hook without a session reports public, the first schema of the default search path.fn current_user(&self) -> Result<Option<String>, SQLError>
fn session_user(&self) -> Result<Option<String>, SQLError>
Source§fn runtime_parameter(&self, name: &str) -> Result<Option<String>, SQLError>
fn runtime_parameter(&self, name: &str) -> Result<Option<String>, SQLError>
None means the parameter is unknown; errors must remain visible even for current_setting(..., true).Source§fn temporal_interval_style(
&self,
) -> Result<Option<TemporalIntervalStyle>, SQLError>
fn temporal_interval_style( &self, ) -> Result<Option<TemporalIntervalStyle>, SQLError>
Source§fn temporal_time_zone(&self) -> Result<Option<TemporalTimeZone>, SQLError>
fn temporal_time_zone(&self) -> Result<Option<TemporalTimeZone>, SQLError>
Source§fn sleep(&self, duration: Duration) -> Result<(), SQLError>
fn sleep(&self, duration: Duration) -> Result<(), SQLError>
duration, ending at once when the statement is canceled or times out (pg_sleep).Source§fn set_runtime_parameter(
&self,
name: &str,
value: Option<&str>,
local: bool,
) -> Result<String, SQLError>
fn set_runtime_parameter( &self, name: &str, value: Option<&str>, local: bool, ) -> Result<String, SQLError>
set_config(name, value, is_local) does, restoring the reset setting for None, and return the new value as SHOW reports it.Source§fn current_schemas(
&self,
include_implicit: bool,
) -> Result<Option<Vec<String>>, String>
fn current_schemas( &self, include_implicit: bool, ) -> Result<Option<Vec<String>>, String>
Source§fn random_value(&self) -> Result<Option<f64>, String>
fn random_value(&self) -> Result<Option<f64>, String>
None keeps pure,
engine-free expression evaluation available for library callers.Source§fn random_u64(&self) -> Result<Option<u64>, String>
fn random_u64(&self) -> Result<Option<u64>, String>
bigint and
arbitrary-precision numeric bounds remain uniform.Source§fn set_random_seed(&self, seed: f64) -> Result<bool, String>
fn set_random_seed(&self, seed: f64) -> Result<bool, String>
false means the hook does not own a
mutable random stream and the caller must report the unsupported call.Source§fn call_user_function(
&self,
name: &str,
args: &[(Option<String>, Value)],
) -> Option<Result<Value, SQLError>>
fn call_user_function( &self, name: &str, args: &[(Option<String>, Value)], ) -> Option<Result<Value, SQLError>>
PL/pgSQL function. Consulted
after built-in dispatch misses (and immediately for calls with
named arguments, which built-ins never accept). None means
no user-defined function with this name exists.Source§fn catalog_cast_scope(&self) -> Option<&CatalogCastScope>
fn catalog_cast_scope(&self) -> Option<&CatalogCastScope>
Source§fn resolve_regclass(&self, _name: &str) -> Result<Option<i64>, String>
fn resolve_regclass(&self, _name: &str) -> Result<Option<i64>, String>
regclass.fn call_bound_user_function( &self, _binding: &FunctionBinding, _args: &[(Option<String>, Value)], ) -> Option<Result<Value, SQLError>>
Source§fn call_bound_user_function_with_control(
&self,
binding: &FunctionBinding,
args: &[(Option<String>, Value)],
control: &ProductionControl<'_>,
) -> Option<Result<Produced<Value>, SQLError>>
fn call_bound_user_function_with_control( &self, binding: &FunctionBinding, args: &[(Option<String>, Value)], control: &ProductionControl<'_>, ) -> Option<Result<Produced<Value>, SQLError>>
Source§fn routine_description_scope(&self) -> Option<RoutineDescriptionScope>
fn routine_description_scope(&self) -> Option<RoutineDescriptionScope>
Source§fn call_bound_user_function_with_descriptions(
&self,
binding: &FunctionBinding,
args: &[(Option<String>, Value)],
_descriptions: &RoutineCallDescriptions,
_control: &ProductionControl<'_>,
) -> Option<Result<Value, SQLError>>
fn call_bound_user_function_with_descriptions( &self, binding: &FunctionBinding, args: &[(Option<String>, Value)], _descriptions: &RoutineCallDescriptions, _control: &ProductionControl<'_>, ) -> Option<Result<Value, SQLError>>
Source§impl EnumLabelVisibility for Engine
impl EnumLabelVisibility for Engine
fn enum_type_created(&self, type_oid: u32)
fn enum_label_added(&self, type_oid: u32, label_oid: u32)
Source§impl EnumRegistryPublication for Engine
impl EnumRegistryPublication for Engine
fn enum_registry(&self) -> EnumRegistryRead<'_>
fn enum_catalog(&self) -> Option<&dyn CatalogFacade>
fn enum_role_definitions(&self) -> BTreeMap<String, RoleDefinition>
fn publish_enum_definitions(&self, registry: EnumRegistry)
Source§impl EventCatalogGuards for Engine
impl EventCatalogGuards for Engine
fn triggers(&self) -> TriggerCatalogWrite<'_>
fn rules(&self) -> RuleCatalogWrite<'_>
Source§impl EventCatalogPublication for Engine
impl EventCatalogPublication for Engine
fn finish_publication(&self) -> Result<(), SQLError>
fn persist_triggers(&self, triggers: &TriggerCatalog) -> Result<(), SQLError>
fn persist_rules(&self, rules: &RuleCatalog) -> Result<(), SQLError>
Source§impl EventCatalogReads for Engine
impl EventCatalogReads for Engine
fn read_rules(&self) -> RuleCatalogRead<'_>
fn read_triggers(&self) -> TriggerCatalogRead<'_>
Source§impl EventForeignPrivileges for Engine
impl EventForeignPrivileges for Engine
fn ensure_foreign_table_privilege( &self, name: &str, privilege: TableAclPrivilege, ) -> Result<(), SQLError>
Source§impl EventLookupState for Engine
impl EventLookupState for Engine
fn query_rules(&self) -> Option<&RuleCatalog>
fn query_triggers(&self) -> Option<&TriggerCatalog>
fn session_replication_role_is_replica(&self) -> bool
Source§impl EventPartitionCatalog for Engine
impl EventPartitionCatalog for Engine
fn contains_loaded_table(&self, relation: &RelationIdentity) -> bool
fn table_names(&self) -> Result<Vec<String>, String>
fn try_table_hierarchy(&self, name: &str) -> Result<TableHierarchy, String>
Source§impl EventRelationCatalog for Engine
impl EventRelationCatalog for Engine
fn event_relation_owner( &self, relation: &RelationIdentity, ) -> Result<(RoleIdentity, &'static str), SQLError>
fn view_kind(&self, relation: &RelationIdentity) -> Option<StoredViewKind>
fn view(&self, relation: &RelationIdentity) -> Option<StoredView>
Source§fn with_view_with_control(
&self,
relation: &RelationIdentity,
control: &ProductionControl<'_>,
read: &mut dyn FnMut(&StoredView) -> Result<(), SQLError>,
) -> Result<bool, SQLError>
fn with_view_with_control( &self, relation: &RelationIdentity, control: &ProductionControl<'_>, read: &mut dyn FnMut(&StoredView) -> Result<(), SQLError>, ) -> Result<bool, SQLError>
fn foreign_columns(&self, relation: &RelationIdentity) -> Option<Vec<ColumnDef>>
fn restored_catalog_view_definition( &self, name: &str, ) -> Result<Option<StoredView>, SQLError>
fn stored_view_schema(&self, view: &StoredView) -> Result<RowSchema, SQLError>
fn stored_view_schema_with_control( &self, view: &StoredView, control: &ProductionControl<'_>, ) -> Result<RowSchema, SQLError>
fn loaded_table_hierarchy( &self, relation: &RelationIdentity, ) -> Option<TableHierarchy>
Source§impl EventRelationPersistence for Engine
impl EventRelationPersistence for Engine
fn rule_relation_is_temporary(&self, relation: &RelationIdentity) -> bool
fn trigger_relation_persistence( &self, relation: &RelationIdentity, ) -> Option<RelationPersistence>
Source§impl ExecutablePlanOptimizer for Engine
impl ExecutablePlanOptimizer for Engine
fn planning_control(&self) -> Result<OwnedProductionControl, SQLError>
fn plan_owned_for_execution( &self, plan: MutableExecutablePlan, params: &[SQLParam], control: &ProductionControl<'_>, ) -> Result<SharedExecutablePlan, SQLError>
fn plan_owned_with_result( &self, plan: MutableExecutablePlan, params: &[SQLParam], control: &ProductionControl<'_>, ) -> Result<(SharedExecutablePlan, AnalyzedResult), SQLError>
fn plan_owned_for_statement_cache( &self, plan: MutableExecutablePlan, params: &[SQLParam], control: &ProductionControl<'_>, ) -> Result<(SharedExecutablePlan, bool), SQLError>
fn plan_owned_with_cached_analysis( &self, plan: MutableExecutablePlan, params: &[SQLParam], cached: Option<AnalyzedStatement>, control: &ProductionControl<'_>, ) -> Result<(SharedExecutablePlan, Option<AnalyzedStatement>), SQLError>
Source§fn plan_retained_with_cached_analysis(
&self,
plan: SharedExecutablePlan,
params: &[SQLParam],
cached: Option<AnalyzedStatement>,
control: &ProductionControl<'_>,
) -> Result<(SharedExecutablePlan, Option<AnalyzedStatement>), SQLError>
fn plan_retained_with_cached_analysis( &self, plan: SharedExecutablePlan, params: &[SQLParam], cached: Option<AnalyzedStatement>, control: &ProductionControl<'_>, ) -> Result<(SharedExecutablePlan, Option<AnalyzedStatement>), SQLError>
Source§fn plan_with_cached_analysis(
&self,
plan: UnifiedPlan,
params: &[SQLParam],
cached: Option<AnalyzedStatement>,
) -> Result<(SharedExecutablePlan, Option<AnalyzedStatement>), SQLError>
fn plan_with_cached_analysis( &self, plan: UnifiedPlan, params: &[SQLParam], cached: Option<AnalyzedStatement>, ) -> Result<(SharedExecutablePlan, Option<AnalyzedStatement>), SQLError>
Source§fn plan_for_statement_cache(
&self,
plan: UnifiedPlan,
params: &[SQLParam],
) -> Result<(SharedExecutablePlan, bool), SQLError>
fn plan_for_statement_cache( &self, plan: UnifiedPlan, params: &[SQLParam], ) -> Result<(SharedExecutablePlan, bool), SQLError>
fn plan_for_execution( &self, plan: UnifiedPlan, params: &[SQLParam], ) -> Result<SharedExecutablePlan, SQLError>
Source§fn plan_with_result(
&self,
plan: UnifiedPlan,
params: &[SQLParam],
) -> Result<(SharedExecutablePlan, AnalyzedResult), SQLError>
fn plan_with_result( &self, plan: UnifiedPlan, params: &[SQLParam], ) -> Result<(SharedExecutablePlan, AnalyzedResult), SQLError>
Source§impl ForeignCreationNamespace for Engine
impl ForeignCreationNamespace for Engine
fn synchronize_catalog_registries(&self) -> StorageBackendResult<()>
fn relation_kind_at( &self, name: &str, ) -> StorageBackendResult<Option<&'static str>>
Source§impl ForeignCreationRegistry for Engine
impl ForeignCreationRegistry for Engine
fn wrappers_write(&self) -> ForeignWrappersWrite<'_>
fn servers_write(&self) -> ForeignServersWrite<'_>
Source§impl ForeignCreationTransactions for Engine
impl ForeignCreationTransactions for Engine
fn with_foreign_catalog_write( &self, write: ForeignCatalogWrite<'_>, ) -> Result<(), SQLError>
Source§impl ForeignKeyCheckRunner for Engine
impl ForeignKeyCheckRunner for Engine
fn run_foreign_key_check( &self, check: &ForeignKeyCheck, queue: &AfterTriggerQueue, ) -> Result<(), SQLError>
Source§impl ForeignKeyDefinitionCatalog for Engine
impl ForeignKeyDefinitionCatalog for Engine
fn resolve_table_reference(&self, name: &str) -> Result<String, SQLError>
fn bound_table_name(&self, name: &str) -> Result<Option<String>, SQLError>
fn referenceable_keys( &self, table: &str, ) -> Result<Vec<TableKeyConstraint>, ColumnCatalogError>
fn ensure_reference_privilege( &self, table: &str, column: &str, ) -> Result<(), SQLError>
Source§impl ForeignLookupState for Engine
impl ForeignLookupState for Engine
fn query_wrappers(&self) -> Option<&ForeignWrappers>
fn query_servers(&self) -> Option<&BTreeMap<String, ForeignServerDefinition>>
fn query_tables( &self, ) -> Option<&BTreeMap<RelationIdentity, StoredForeignTable>>
fn synchronize_catalog_registries(&self) -> StorageBackendResult<()>
fn relation_lookup_candidates( &self, name: &str, ) -> StorageBackendResult<Vec<RelationIdentity>>
Source§impl ForeignRegistryReads for Engine
impl ForeignRegistryReads for Engine
fn wrappers(&self) -> ForeignWrappersRead<'_>
fn servers(&self) -> ForeignServersRead<'_>
fn tables(&self) -> ForeignTablesRead<'_>
fn security(&self) -> ForeignSecurityRead<'_>
Source§impl ForeignSchemaPublication for Engine
impl ForeignSchemaPublication for Engine
fn foreign_tables(&self) -> BTreeMap<RelationIdentity, StoredForeignTable>
fn persist_foreign_table( &self, relation: &RelationIdentity, table: &StoredForeignTable, ) -> StorageBackendResult<()>
fn publish_foreign_tables( &self, updates: Vec<(RelationIdentity, StoredForeignTable)>, )
Source§impl ForeignTableAlterAccess for Engine
impl ForeignTableAlterAccess for Engine
Source§impl ForeignTableAlterCatalog for Engine
impl ForeignTableAlterCatalog for Engine
fn contains_table(&self, relation: &RelationIdentity) -> bool
fn security(&self, relation: &RelationIdentity) -> Option<BoundTableSecurity>
fn table(&self, relation: &RelationIdentity) -> Option<StoredForeignTable>
Source§impl ForeignTableAlterPublication for Engine
impl ForeignTableAlterPublication for Engine
fn persist_definition( &self, relation: &RelationIdentity, table: &StoredForeignTable, ) -> StorageBackendResult<()>
fn persist_rename( &self, from: &RelationIdentity, to: &RelationIdentity, ) -> StorageBackendResult<Option<bool>>
fn tables_write(&self) -> ForeignTableRegistryWrite<'_>
fn security_write(&self) -> ForeignSecurityRegistryWrite<'_>
fn memory_tables_write(&self) -> ForeignMemoryRegistryWrite<'_>
fn sequence_security_write(&self) -> OwnedSequenceSecurityWrite<'_>
fn persist_security( &self, relation: &RelationIdentity, security: &BoundTableSecurity, ) -> Result<(), SQLError>
Source§impl ForeignTableAlterTransactions for Engine
impl ForeignTableAlterTransactions for Engine
fn with_foreign_table_write( &self, write: ForeignTableAlterWrite<'_>, ) -> Result<(), SQLError>
Source§impl ForeignTableOwnerWriter for Engine
impl ForeignTableOwnerWriter for Engine
Source§impl ForeignTableScan for Engine
impl ForeignTableScan for Engine
fn scan_foreign_source( &self, name: &str, filter: Option<&ScalarExpr>, params: &[SQLParam], ) -> Result<ForeignSourceRows<'_>, String>
Source§impl FunctionTypeResolver for Engine
impl FunctionTypeResolver for Engine
Source§fn format_type_name(&self, ty: &ColumnType) -> Result<String, SQLError>
fn format_type_name(&self, ty: &ColumnType) -> Result<String, SQLError>
Source§fn format_type_name_with_control(
&self,
ty: &ColumnType,
control: &ProductionControl<'_>,
) -> Result<Produced<String>, SQLError>
fn format_type_name_with_control( &self, ty: &ColumnType, control: &ProductionControl<'_>, ) -> Result<Produced<String>, SQLError>
Source§fn has_untyped_function_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
) -> Result<bool, SQLError>
fn has_untyped_function_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<bool, SQLError>
Source§fn has_untyped_function(&self, name: &str) -> bool
fn has_untyped_function(&self, name: &str) -> bool
Source§fn resolve_type_name(&self, name: &str) -> Result<Option<ColumnType>, SQLError>
fn resolve_type_name(&self, name: &str) -> Result<Option<ColumnType>, SQLError>
ColumnType::from_sql_name mapping, such as a domain.Source§fn resolve_type_name_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
) -> Result<Option<Produced<ColumnType>>, SQLError>
fn resolve_type_name_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<Option<Produced<ColumnType>>, SQLError>
Source§fn resolve_collation_name(&self, name: &str) -> Result<Option<u32>, SQLError>
fn resolve_collation_name(&self, name: &str) -> Result<Option<u32>, SQLError>
Source§fn resolve_collation_name_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
) -> Result<Option<u32>, SQLError>
fn resolve_collation_name_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<Option<u32>, SQLError>
Source§fn enum_labels(&self) -> Option<&dyn EnumLabelCatalog>
fn enum_labels(&self) -> Option<&dyn EnumLabelCatalog>
unknown literals coerced to an enum type with them, as PostgreSQL parse analysis calls the type’s input function.Source§fn catalog_input_functions(&self) -> Option<&dyn CatalogInputFunctions>
fn catalog_input_functions(&self) -> Option<&dyn CatalogInputFunctions>
Source§fn composite_types(&self) -> Option<&dyn CompositeTypeCatalog>
fn composite_types(&self) -> Option<&dyn CompositeTypeCatalog>
Source§fn require_type_usage(&self, ty: &ColumnType) -> Result<(), SQLError>
fn require_type_usage(&self, ty: &ColumnType) -> Result<(), SQLError>
USAGE privilege on a type that a relation column, domain or routine declares, as object_aclcheck(TypeRelationId, ..., ACL_USAGE) and aclcheck_error_type require it; see crate::catalog::security::type_inquiry::usage_governing_type. A resolver without roles and type privileges has nothing to deny.fn resolve_function_type_with_control( &self, name: &str, binding: Option<&FunctionBinding>, argument_names: &[Option<String>], argument_types: &[Option<ColumnType>], explicit_variadic: bool, control: &ProductionControl<'_>, ) -> Result<Option<Produced<ColumnType>>, SQLError>
fn resolve_function_overload_with_control( &self, name: &str, binding: Option<&FunctionBinding>, argument_names: &[Option<String>], argument_types: &[Option<ColumnType>], explicit_variadic: bool, control: &ProductionControl<'_>, ) -> Result<Option<Produced<ResolvedFunctionOverload>>, SQLError>
fn resolve_function_overload_with_builtins_and_control( &self, name: &str, binding: Option<&FunctionBinding>, argument_names: &[Option<String>], argument_types: &[Option<ColumnType>], explicit_variadic: bool, builtins: &[BuiltinFunctionOverload], control: &ProductionControl<'_>, ) -> Result<Option<Produced<ResolvedFunctionOverload>>, SQLError>
fn resolve_function_type( &self, name: &str, binding: Option<&FunctionBinding>, argument_names: &[Option<String>], argument_types: &[Option<ColumnType>], explicit_variadic: bool, ) -> Result<Option<ColumnType>, SQLError>
Source§fn resolve_function_overload(
&self,
name: &str,
binding: Option<&FunctionBinding>,
argument_names: &[Option<String>],
argument_types: &[Option<ColumnType>],
explicit_variadic: bool,
) -> Result<Option<ResolvedFunctionOverload>, SQLError>
fn resolve_function_overload( &self, name: &str, binding: Option<&FunctionBinding>, argument_names: &[Option<String>], argument_types: &[Option<ColumnType>], explicit_variadic: bool, ) -> Result<Option<ResolvedFunctionOverload>, SQLError>
Source§fn is_scalar_function_binding(
&self,
binding: &FunctionBinding,
) -> Result<bool, SQLError>
fn is_scalar_function_binding( &self, binding: &FunctionBinding, ) -> Result<bool, SQLError>
ScalarExpr::Func.Source§fn is_scalar_function_binding_with_control(
&self,
binding: &FunctionBinding,
control: &ProductionControl<'_>,
) -> Result<bool, SQLError>
fn is_scalar_function_binding_with_control( &self, binding: &FunctionBinding, control: &ProductionControl<'_>, ) -> Result<bool, SQLError>
Source§fn resolve_function_overload_with_builtins(
&self,
name: &str,
binding: Option<&FunctionBinding>,
argument_names: &[Option<String>],
argument_types: &[Option<ColumnType>],
explicit_variadic: bool,
builtins: &[BuiltinFunctionOverload],
) -> Result<Option<ResolvedFunctionOverload>, SQLError>
fn resolve_function_overload_with_builtins( &self, name: &str, binding: Option<&FunctionBinding>, argument_names: &[Option<String>], argument_types: &[Option<ColumnType>], explicit_variadic: bool, builtins: &[BuiltinFunctionOverload], ) -> Result<Option<ResolvedFunctionOverload>, SQLError>
PostgreSQL candidate set. Implementations with catalog visibility
should override this so search-path shadowing and unknown-category
selection happen before a winner is chosen.fn resolve_scalar_subquery_type_with_control( &self, subquery: usize, outer_schema: &RowSchema, params: &[SQLParam], control: &ProductionControl<'_>, ) -> Result<Option<Produced<ColumnType>>, SQLError>
Source§fn resolve_scalar_subquery_type(
&self,
_subquery: usize,
_outer_schema: &RowSchema,
_params: &[SQLParam],
) -> Result<Option<ColumnType>, SQLError>
fn resolve_scalar_subquery_type( &self, _subquery: usize, _outer_schema: &RowSchema, _params: &[SQLParam], ) -> Result<Option<ColumnType>, SQLError>
Source§impl GeneratedRewriteState for Engine
impl GeneratedRewriteState for Engine
fn advance_next_id(&self, table: &str, id: DocId) -> StorageBackendResult<()>
Source§impl GrantNamespace for Engine
impl GrantNamespace for Engine
fn temporary_schema_name(&self) -> String
fn temporary_namespace_allocated(&self) -> bool
fn has_namespace(&self, name: &str) -> Result<bool, String>
Source§impl GraphLifecycle for Engine
impl GraphLifecycle for Engine
fn has_graph(&self, name: &str) -> StorageBackendResult<bool>
fn has_namespace(&self, name: &str) -> StorageBackendResult<bool>
fn create_graph(&self, name: String) -> StorageBackendResult<bool>
fn drop_graph(&self, name: &str) -> StorageBackendResult<bool>
fn list_graph_labels( &self, graph: &str, ) -> StorageBackendResult<Option<Vec<GraphLabelInfo>>>
fn create_graph_label( &self, graph: &str, label: &str, kind: LabelKind, ) -> StorageBackendResult<bool>
fn drop_graph_label( &self, graph: &str, label: &str, ) -> StorageBackendResult<bool>
fn graph_label_relation_dependents( &self, graph: &str, label: &str, ) -> StorageBackendResult<Vec<String>>
fn rename_graph(&self, from: &str, to: &str) -> StorageBackendResult<bool>
Source§impl GraphNameCatalog for Engine
impl GraphNameCatalog for Engine
Source§impl HierarchyCatalog for Engine
impl HierarchyCatalog for Engine
fn try_describe_table( &self, table: &str, ) -> StorageBackendResult<Option<Vec<ColumnDef>>>
fn try_check_constraint_definitions( &self, table: &str, ) -> StorageBackendResult<Vec<TableCheck>>
fn try_key_constraints( &self, table: &str, ) -> StorageBackendResult<Vec<TableKeyConstraint>>
fn try_foreign_keys(&self, table: &str) -> StorageBackendResult<Vec<ForeignKey>>
fn try_declared_table_constraints( &self, table: &str, ) -> StorageBackendResult<TableConstraintSet>
fn table_persistence( &self, table: &str, ) -> StorageBackendResult<Option<RelationPersistence>>
Source§impl HierarchyDropCatalog for Engine
impl HierarchyDropCatalog for Engine
fn tables(&self) -> Box<dyn HierarchyDropTables + '_>
Source§impl HierarchyNamespace for Engine
impl HierarchyNamespace for Engine
fn resolve_visible_relation_kind( &self, name: &str, ) -> Result<RelationResolution, SQLError>
fn lock_relation( &self, table: &str, mode: TableLockMode, ) -> Result<(), SQLError>
Source§impl IdentitySequences for Engine
impl IdentitySequences for Engine
Source§impl ImplicitOwnerPublication for Engine
impl ImplicitOwnerPublication for Engine
fn attach_owner( &self, sequence: &str, owner: SequenceOwner, ) -> Result<(), SQLError>
Source§impl ImplicitOwnerTables for Engine
impl ImplicitOwnerTables for Engine
fn table_owner_columns( &self, table: &str, ) -> StorageBackendResult<Option<([u8; 16], Vec<ColumnDef>)>>
Source§impl ImplicitSequencePublication for Engine
impl ImplicitSequencePublication for Engine
fn create_implicit_sequence( &self, name: &str, state: SequenceState, persistence: RelationPersistence, ) -> Result<(), SQLError>
Source§impl IndexBuildCatalog for Engine
impl IndexBuildCatalog for Engine
fn table_hierarchy(&self, table: &str) -> Result<TableHierarchy, SQLError>
fn scan_tables(&self, table: &str) -> Result<Vec<String>, SQLError>
Source§fn partition_tree(
&self,
table: &str,
) -> Result<Vec<PartitionTreeNode>, SQLError>
fn partition_tree( &self, table: &str, ) -> Result<Vec<PartitionTreeNode>, SQLError>
table, each after its parent with siblings in partition bound order.Source§impl IndexCreationNamespace for Engine
impl IndexCreationNamespace for Engine
Source§impl IndexCreationPublication for Engine
impl IndexCreationPublication for Engine
fn create_diskann_field( &self, row: &CatalogIndexRow, field: &str, dimensions: u32, parameters: DiskANNIndexParams, ) -> Result<(), SQLError>
fn add_text_field( &self, table: &str, column: &str, analyzer: Option<&str>, ) -> Result<(), SQLError>
fn rebuild_vector_field( &self, table: &str, column: &str, dimensions: u32, spec: VectorIndexSpec, ) -> Result<bool, SQLError>
fn register_index( &self, name: &str, method: &str, table: &str, keys: &[IndexKey], options: &[(String, String)], definition: &IndexDefinition, ) -> Result<(), SQLError>
Source§fn planned_partition_indexes(
&self,
name: &str,
method: &str,
table: &str,
keys: &[IndexKey],
options: &[(String, String)],
definition: &IndexDefinition,
) -> Result<BTreeMap<String, String>, SQLError>
fn planned_partition_indexes( &self, name: &str, method: &str, table: &str, keys: &[IndexKey], options: &[(String, String)], definition: &IndexDefinition, ) -> Result<BTreeMap<String, String>, SQLError>
table, as partition and index name.Source§impl IndexKeyDescription for Engine
impl IndexKeyDescription for Engine
Source§impl IndexNameCatalog for Engine
impl IndexNameCatalog for Engine
fn automatic_constraint_names( &self, table: &str, ) -> Result<BTreeSet<String>, SQLError>
fn existing_constraint_names( &self, table: &str, ) -> Result<BTreeSet<String>, SQLError>
fn existing_constraint_keys( &self, table: &str, ) -> Result<Vec<TableKeyConstraint>, SQLError>
fn relation_name_available( &self, qualified_name: &str, ) -> Result<bool, SQLError>
Source§impl IndexRegistryPublication for Engine
impl IndexRegistryPublication for Engine
fn persist_index( &self, row: &CatalogIndexRow, kind: IndexPublicationKind, ) -> StorageBackendResult<()>
fn erase_index( &self, row: &CatalogIndexRow, kind: IndexPublicationKind, ) -> StorageBackendResult<()>
fn publish_index(&self, row: CatalogIndexRow)
fn forget_index(&self, relation: &RelationIdentity)
Source§fn rebind_diskann_index(
&self,
row: &CatalogIndexRow,
) -> StorageBackendResult<()>
fn rebind_diskann_index( &self, row: &CatalogIndexRow, ) -> StorageBackendResult<()>
fn refresh_index_table(&self, table: &str) -> StorageBackendResult<()>
Source§fn rebind_persistent_vector_field(
&self,
table: &str,
field: &str,
dimensions: u32,
spec: VectorIndexSpec,
) -> StorageBackendResult<()>
fn rebind_persistent_vector_field( &self, table: &str, field: &str, dimensions: u32, spec: VectorIndexSpec, ) -> StorageBackendResult<()>
Source§impl IndexRemovalCatalog for Engine
impl IndexRemovalCatalog for Engine
fn resolve_relation_kind( &self, name: &str, ) -> Result<RelationResolution, SQLError>
fn bound_catalog_index( &self, name: &str, ) -> StorageBackendResult<Option<CatalogIndexRow>>
fn list_catalog_indexes(&self) -> StorageBackendResult<Vec<CatalogIndexRow>>
fn column_type( &self, table: &str, column: &str, ) -> StorageBackendResult<Option<ColumnType>>
Source§impl IndexRemovalPrivileges for Engine
impl IndexRemovalPrivileges for Engine
Source§impl IndexRemovalPublication for Engine
impl IndexRemovalPublication for Engine
fn retire_diskann_index( &self, row: &CatalogIndexRow, field: &str, dimensions: u32, ) -> StorageBackendResult<()>
fn drop_catalog_index_relation( &self, relation: &RelationIdentity, ) -> StorageBackendResult<Option<CatalogIndexRow>>
fn drop_fts_field(&self, table: &str, field: &str) -> Result<(), SQLError>
fn release_fts_analyzer_owner( &self, table: &str, field: &str, ) -> Result<(), SQLError>
fn drop_vector_field_index( &self, table: &str, field: String, dimensions: u32, ) -> StorageBackendResult<bool>
fn drop_vector_index_metadata( &self, table: &str, field: &str, ) -> StorageBackendResult<()>
Source§impl IndexRemovalTransactions for Engine
impl IndexRemovalTransactions for Engine
fn with_index_write( &self, write: IndexRemovalWrite<'_>, ) -> Result<SQLResult, SQLError>
Source§impl IndexRenameTransactions for Engine
impl IndexRenameTransactions for Engine
fn with_index_rename( &self, write: IndexRenameWrite<'_>, ) -> Result<SQLResult, SQLError>
Source§impl IndexRoutineRegistry for Engine
impl IndexRoutineRegistry for Engine
fn routine_index_rows(&self) -> IndexRoutineRead<'_>
fn publish_routine_index_row(&self, row: CatalogIndexRow)
Source§impl InferenceBindingScope for Engine
impl InferenceBindingScope for Engine
fn binding_scope_with_control( &self, control: &ProductionControl<'_>, ) -> Result<ControlledBindingSnapshot, SQLError>
fn binding_scope(&self) -> Result<BindingSnapshot, SQLError>
Source§impl InheritanceCatalog for Engine
impl InheritanceCatalog for Engine
fn resolve_parent(&self, name: &str) -> Result<String, SQLError>
fn declared_constraints( &self, table: &str, ) -> Result<TableConstraintSet, String>
fn check_definitions(&self, table: &str) -> Result<Vec<TableCheck>, String>
Source§impl InsertIdentityCatalog for Engine
impl InsertIdentityCatalog for Engine
Source§impl LoadedTableSchemas for Engine
impl LoadedTableSchemas for Engine
fn table_schemas(&self) -> Vec<LoadedTableSchema<'_>> ⓘ
Source§impl LockingCatalog for Engine
impl LockingCatalog for Engine
fn hierarchy_scan_tables_with_control( &self, table: &str, descendants: bool, control: &ProductionControl<'_>, ) -> Result<Produced<Vec<String>>, SQLError>
fn resolve_relation_with_control( &self, name: &str, bound: bool, control: &ProductionControl<'_>, ) -> Result<Produced<RelationResolution>, SQLError>
Source§fn with_view_plan_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
read: &mut dyn FnMut(&QueryPlan) -> Result<(), SQLError>,
) -> Result<bool, SQLError>
fn with_view_plan_with_control( &self, name: &str, control: &ProductionControl<'_>, read: &mut dyn FnMut(&QueryPlan) -> Result<(), SQLError>, ) -> Result<bool, SQLError>
fn view_exists_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<bool, SQLError>
fn table_persistence( &self, name: &str, ) -> Result<Option<RelationPersistence>, String>
fn referenceable_keys( &self, table: &str, ) -> Result<Vec<TableKeyConstraint>, String>
fn table_columns(&self, table: &str) -> Result<Option<Vec<ColumnDef>>, String>
Source§impl MaterializedViewAccess for Engine
impl MaterializedViewAccess for Engine
fn ensure_maintenance( &self, name: &str, view: &StoredView, ) -> Result<(), SQLError>
Source§impl MutationCommandRows for Engine
impl MutationCommandRows for Engine
Source§impl MutationCommandState for Engine
impl MutationCommandState for Engine
fn prepare_writer(&self) -> Result<(), SQLError>
fn begin_overlay(&self)
fn end_overlay(&self) -> CommandMutationOverlay
Source§impl MutationConstraintDeferrals for Engine
impl MutationConstraintDeferrals for Engine
Source§impl MutationHistory for Engine
impl MutationHistory for Engine
Source§impl MutationIdentifiers for Engine
impl MutationIdentifiers for Engine
fn allocate_next_id(&self, table: &str) -> Result<DocId, SQLError>
Source§fn allocate_unmapped_id(&self, table: &str) -> Result<DocId, SQLError>
fn allocate_unmapped_id(&self, table: &str) -> Result<DocId, SQLError>
table whose integer primary key names none: one at or above KEY_IDENTITY_LIMIT, where no key names an identity.Source§fn maps_integer_keys(&self, table: &str) -> Result<bool, SQLError>
fn maps_integer_keys(&self, table: &str) -> Result<bool, SQLError>
table names its rows’ identities: each row whose key lies below KEY_IDENTITY_LIMIT has the identity equal to its key, and no other row has an identity below the limit. A table that does not keep this, as one an earlier version wrote can fail to, resolves its keys through the key’s index.fn advance_next_id( &self, table: &str, doc_id: DocId, ) -> StorageBackendResult<()>
fn persist_next_id(&self, table: &str) -> StorageBackendResult<()>
Source§fn generates_unused_identities(&self, table: &str) -> Result<bool, SQLError>
fn generates_unused_identities(&self, table: &str) -> Result<bool, SQLError>
allocate_next_id returns for table is one no document of the table ever had. That holds where the table reserves identities in its own durable namespace, whose watermark every write of the table raises. A table that draws from another table’s namespace, as a partition does, or keeps only a local counter cannot say.Source§impl MutationIndexRead for Engine
impl MutationIndexRead for Engine
fn index_definitions(&self) -> Result<Arc<PhysicalIndexDefinitions>, SQLError>
fn find_conflict( &self, table: &str, columns: &[String], values: &[Value], ) -> Result<Option<DocId>, SQLError>
Source§fn staged_matches(
&self,
table: &str,
columns: &[String],
values: &[Value],
) -> Result<Vec<DocId>, SQLError>
fn staged_matches( &self, table: &str, columns: &[String], values: &[Value], ) -> Result<Vec<DocId>, SQLError>
table whose columns hold values, a missing column holding null.fn visit_staged_matches( &self, table: &str, columns: &[String], values: &[Value], visit: &mut dyn FnMut(DocId) -> Result<(), SQLError>, ) -> Result<(), SQLError>
Source§fn staged_expression_matches(
&self,
table: &str,
physical_key: &str,
values: &[Value],
) -> Result<CommandIndexProbe, SQLError>
fn staged_expression_matches( &self, table: &str, physical_key: &str, values: &[Value], ) -> Result<CommandIndexProbe, SQLError>
fn visit_staged_expression_matches( &self, table: &str, physical_key: &str, values: &[Value], visit: &mut dyn FnMut(DocId) -> Result<(), SQLError>, ) -> Result<DocumentChanges, SQLError>
Source§fn visit_value_index_key(
&self,
table: &str,
key: &ValueIndexKey,
predicate: &Predicate,
visit: &mut dyn FnMut(DocId) -> Result<(), SQLError>,
) -> Result<bool, SQLError>
fn visit_value_index_key( &self, table: &str, key: &ValueIndexKey, predicate: &Predicate, visit: &mut dyn FnMut(DocId) -> Result<(), SQLError>, ) -> Result<bool, SQLError>
fn value_index_scan_key( &self, table: &str, key: &ValueIndexKey, predicate: &Predicate, ) -> Result<Option<PostingList>, SQLError>
Source§impl MutationNamespace for Engine
impl MutationNamespace for Engine
fn current_role(&self) -> RoleReference
fn require_schema_privilege( &self, schema: &str, role: &RoleReference, privilege: SchemaAclPrivilege, ) -> Result<(), SQLError>
Source§impl MutationPrivilegeCatalog for Engine
impl MutationPrivilegeCatalog for Engine
Source§fn visit_bound_table_column_names_with_control(
&self,
table: &str,
control: &ProductionControl<'_>,
read: &mut dyn FnMut(&str) -> Result<(), SQLError>,
) -> Result<(), SQLError>
fn visit_bound_table_column_names_with_control( &self, table: &str, control: &ProductionControl<'_>, read: &mut dyn FnMut(&str) -> Result<(), SQLError>, ) -> Result<(), SQLError>
fn ensure_table_privilege_for_with_control( &self, table: &str, subject: &RoleReference, privilege: TableAclPrivilege, control: &ProductionControl<'_>, ) -> Result<(), SQLError>
fn ensure_column_privilege_for_with_control( &self, table: &str, column: &str, subject: &RoleReference, privilege: TableAclPrivilege, control: &ProductionControl<'_>, ) -> Result<(), SQLError>
fn ensure_any_column_privilege_for_with_control( &self, table: &str, subject: &RoleReference, privilege: TableAclPrivilege, control: &ProductionControl<'_>, ) -> Result<(), SQLError>
fn bound_table_column_names(&self, table: &str) -> Result<Vec<String>, SQLError>
fn ensure_table_privilege_for( &self, table: &str, subject: &RoleReference, privilege: TableAclPrivilege, ) -> Result<(), SQLError>
fn ensure_column_privilege_for( &self, table: &str, column: &str, subject: &RoleReference, privilege: TableAclPrivilege, ) -> Result<(), SQLError>
fn ensure_any_column_privilege_for( &self, table: &str, subject: &RoleReference, privilege: TableAclPrivilege, ) -> Result<(), SQLError>
Source§impl MutationRead for Engine
impl MutationRead for Engine
fn table_doc_ids(&self, table: &str) -> Result<Vec<DocId>, SQLError>
fn table_doc_id_page( &self, table: &str, after: Option<DocId>, limit: usize, control: &StorageReadControl, ) -> Result<BudgetedVec<DocId>, SQLError>
fn live_table_doc_ids(&self, table: &str) -> Result<Vec<DocId>, SQLError>
fn live_table_doc_id_page( &self, table: &str, after: Option<DocId>, limit: usize, control: &StorageReadControl, ) -> Result<BudgetedVec<DocId>, SQLError>
fn get_document( &self, table: &str, doc_id: DocId, ) -> Result<Option<Document>, SQLError>
Source§fn raw_document(
&self,
table: &str,
doc_id: DocId,
) -> Result<Option<Document>, SQLError>
fn raw_document( &self, table: &str, doc_id: DocId, ) -> Result<Option<Document>, SQLError>
Source§fn command_overlay_changes(
&self,
table: &str,
) -> Result<Option<DocumentChanges>, SQLError>
fn command_overlay_changes( &self, table: &str, ) -> Result<Option<DocumentChanges>, SQLError>
table that the active command overlays and this transaction’s fixed-snapshot reads hold above its storage view, without copying them.Source§impl MutationRowCatalog for Engine
impl MutationRowCatalog for Engine
fn column_definitions( &self, table: &str, ) -> Result<Option<Vec<ColumnDef>>, String>
fn column_names(&self, table: &str) -> Result<Vec<String>, String>
Source§fn visit_column_names_with_control(
&self,
table: &str,
control: &ProductionControl<'_>,
read: &mut dyn FnMut(&str) -> Result<(), SQLError>,
) -> Result<(), SQLError>
fn visit_column_names_with_control( &self, table: &str, control: &ProductionControl<'_>, read: &mut dyn FnMut(&str) -> Result<(), SQLError>, ) -> Result<(), SQLError>
fn view_schema(&self, name: &str) -> Result<RowSchema, SQLError>
Source§impl MutationStorage for Engine
impl MutationStorage for Engine
Source§fn can_defer_document_text(&self, table: &str) -> Result<bool, SQLError>
fn can_defer_document_text(&self, table: &str) -> Result<bool, SQLError>
fn delete_document(&self, table: &str, doc_id: DocId) -> Result<(), SQLError>
Source§fn observe_document_identity(
&self,
table: &str,
doc_id: DocId,
) -> Result<ObservedIdentifier, SQLError>
fn observe_document_identity( &self, table: &str, doc_id: DocId, ) -> Result<ObservedIdentifier, SQLError>
Source§fn delete_document_deferred_text(
&self,
table: &str,
doc_id: DocId,
) -> Result<(), SQLError>
fn delete_document_deferred_text( &self, table: &str, doc_id: DocId, ) -> Result<(), SQLError>
fn insert_document( &self, table: &str, doc_id: DocId, document: Document, vectors: DocumentVectors, inserted: InsertedIdentity, ) -> Result<(), SQLError>
fn insert_document_deferred_text( &self, table: &str, doc_id: DocId, document: Document, vectors: DocumentVectors, inserted: InsertedIdentity, ) -> Result<(), SQLError>
fn rewrite_document( &self, table: &str, doc_id: DocId, document: Document, ) -> Result<(), SQLError>
Source§impl MutationTargetColumns for Engine
impl MutationTargetColumns for Engine
Source§impl MutationTargetResolution for Engine
impl MutationTargetResolution for Engine
Source§fn resolve_target_with_control(
&self,
name: &str,
bound: bool,
control: &ProductionControl<'_>,
) -> Result<Produced<String>, SQLError>
fn resolve_target_with_control( &self, name: &str, bound: bool, control: &ProductionControl<'_>, ) -> Result<Produced<String>, SQLError>
fn resolve_target(&self, name: &str, bound: bool) -> Result<String, SQLError>
Source§impl MutationTextIndex for Engine
impl MutationTextIndex for Engine
Source§impl MutationTupleMetadata for Engine
impl MutationTupleMetadata for Engine
Source§fn table_relation_oid(&self, table: &str) -> Result<i64, SQLError>
fn table_relation_oid(&self, table: &str) -> Result<i64, SQLError>
fn document_metadata( &self, table: &str, doc_id: DocId, ) -> Result<Option<DocumentMetadata>, SQLError>
fn tuple_version_xid(&self) -> Result<u32, SQLError>
Source§impl NamespaceCatalogChanges for Engine
impl NamespaceCatalogChanges for Engine
fn prepared_catalog_changed(&self, change: PreparedCatalogChange)
fn catalog_registry_changed(&self)
fn catalog_registry_changed_kind(&self, change: CatalogRegistryChange)
fn namespace_catalog_changed(&self)
Source§impl NamespaceCatalogRefresh for Engine
impl NamespaceCatalogRefresh for Engine
fn refresh_catalog(&self) -> StorageBackendResult<()>
Source§impl OperatorJoinBinding for Engine
impl OperatorJoinBinding for Engine
fn lower( &self, name: &str, relations: Option<&OperatorJoinRelations>, args: &[ScalarExpr], params: &[SQLParam], ) -> Result<(OperatorJoinRelations, OperatorTree), SQLError>
Source§impl OwnedSequenceSecurityCatalog for Engine
impl OwnedSequenceSecurityCatalog for Engine
fn owned_sequences(&self, table_object_id: [u8; 16]) -> Vec<RelationIdentity>
fn security_registry(&self) -> OwnedSequenceSecurityRead<'_>
Source§impl PartitionCatalog for Engine
impl PartitionCatalog for Engine
fn try_table_hierarchy(&self, table: &str) -> Result<TableHierarchy, String>
fn direct_hierarchy_children( &self, parent: &str, ) -> Result<Vec<String>, SQLError>
fn try_resolve_table_name(&self, name: &str) -> Result<Option<String>, String>
fn try_resolve_table_name_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<Option<Produced<String>>, SQLError>
fn try_describe_table( &self, table: &str, ) -> Result<Option<Vec<ColumnDef>>, String>
Source§impl PartitionExpressions for Engine
impl PartitionExpressions for Engine
Source§fn expression_text(&self, expression: &Expr) -> Result<String, SQLError>
fn expression_text(&self, expression: &Expr) -> Result<String, SQLError>
fn evaluate_bound( &self, expression: &Expr, params: &[SQLParam], ) -> Result<Value, SQLError>
fn evaluate_row( &self, expression: &Expr, row: &dyn RowLookup, schema: &RowSchema, params: &[SQLParam], ) -> Result<Value, SQLError>
Source§impl PhysicalExplainPlanning for Engine
impl PhysicalExplainPlanning for Engine
fn explained_plan_estimates( &self, body: &UnifiedPlan, params: &[SQLParam], control: &ProductionControl<'_>, ) -> Result<Produced<Vec<ExplainNodeEstimate>>, SQLError>
Source§fn plan_explained_statement(
&self,
body: PlanRef<'_>,
) -> Result<OwnedExecutablePlan, SQLError>
fn plan_explained_statement( &self, body: PlanRef<'_>, ) -> Result<OwnedExecutablePlan, SQLError>
fn physical_explain_plan( &self, body: &UnifiedPlan, params: &[SQLParam], costs: bool, control: &ProductionControl<'_>, ) -> Result<Produced<ExplainPhysicalPlan>, SQLError>
Source§impl PhysicalTextRetrieval for Engine
impl PhysicalTextRetrieval for Engine
fn validate_text_search_field( &self, table: &str, field: &str, ) -> Result<(), SQLError>
fn fts_fields_for_table(&self, table: &str) -> Result<Vec<String>, SQLError>
fn bayesian_params_for_relation( &self, table: &str, signal_table: &str, field: &str, ) -> Result<BayesianBM25Params, SQLError>
fn search_leaf( &self, table: &str, field: &str, query: &str, mode: &ScoringMode, limit: usize, top_k: Option<TextTopKPlan>, ) -> Result<Vec<ScoredEntry>, SQLError>
fn visit_search_leaf( &self, table: &str, field: &str, query: &str, mode: &ScoringMode, visitor: &mut dyn FnMut(ScoredEntry) -> Result<(), SQLError>, ) -> Result<(), SQLError>
Source§impl PhysicalVectorRetrieval for Engine
impl PhysicalVectorRetrieval for Engine
fn knn_search_leaf( &self, table: &str, field: &str, query: &[f32], k: usize, diagnostics: Option<&CapturedDiagnostics>, ) -> Result<Vec<ScoredEntry>, SQLError>
Source§impl PlannerStatisticsCatalog for Engine
impl PlannerStatisticsCatalog for Engine
fn storage_table( &self, table: &str, ) -> Result<Option<Arc<dyn StatisticsTableState>>, SQLError>
fn hierarchy_scan_tables(&self, table: &str) -> Result<Vec<String>, SQLError>
fn table_row_count(&self, table: &str) -> Result<u64, SQLError>
fn column_statistics(&self, table: &str) -> Result<ColumnStatistics, SQLError>
fn resolved_table_name(&self, table: &str) -> Result<Option<String>, SQLError>
fn catalog_indexes(&self) -> Result<CatalogIndexSnapshot, SQLError>
Source§impl PointMutationStorage for Engine
impl PointMutationStorage for Engine
fn find_doc_id_by_field( &self, table: &str, field: &str, value: &Value, ) -> Result<Option<DocId>, SQLError>
Source§fn patch_document_fields_with_vector_values(
&self,
table: &str,
doc_id: DocId,
updates: &BTreeMap<String, Value>,
vectors: &RowUpdateVectors,
) -> Result<bool, SQLError>
fn patch_document_fields_with_vector_values( &self, table: &str, doc_id: DocId, updates: &BTreeMap<String, Value>, vectors: &RowUpdateVectors, ) -> Result<bool, SQLError>
Source§impl PortalRelationCatalog for Engine
impl PortalRelationCatalog for Engine
fn try_resolve_table_name(&self, name: &str) -> Result<Option<String>, String>
fn hierarchy_scan_tables( &self, table: &str, include_descendants: bool, ) -> Result<Vec<String>, SQLError>
fn view_plan(&self, name: &str) -> Result<Option<QueryPlan>, SQLError>
fn try_resolve_visible_relation_kind( &self, name: &str, ) -> Result<Option<(String, &'static str)>, SQLError>
fn resolve_age_label_relation_name( &self, name: &str, ) -> Result<Option<String>, SQLError>
fn try_resolve_sequence_reference( &self, name: &str, ) -> Result<Option<String>, String>
Source§impl PortalTransitionRelations for Engine
impl PortalTransitionRelations for Engine
fn active_transition_relation_names(&self) -> BTreeSet<String>
Source§impl PreparedArgumentScopes for Engine
impl PreparedArgumentScopes for Engine
fn with_scope( &self, parameters: &[SQLParam], operation: &mut ScopedArgumentOperation<'_>, ) -> Result<Vec<SQLParam>, SQLError>
Source§impl PreparedDefinitionRegistry for Engine
impl PreparedDefinitionRegistry for Engine
fn production_resources(&self) -> Result<OwnedProductionControl, SQLError>
fn write_definitions( &self, control: &ProductionControl<'_>, ) -> Result<Box<dyn PreparedDefinitionWrite + '_>, SQLError>
Source§impl PreparedPlanOptimization for Engine
impl PreparedPlanOptimization for Engine
fn planning_resources(&self) -> Result<OwnedProductionControl, SQLError>
fn optimize_plan( &self, plan: MutableExecutablePlan, control: &ProductionControl<'_>, ) -> Result<SharedExecutablePlan, SQLError>
fn estimate_plan( &self, plan: &UnifiedPlan, control: &ProductionControl<'_>, ) -> Result<PlanCost, SQLError>
Source§impl PreparedPlanProvider for Engine
impl PreparedPlanProvider for Engine
fn plan_for_execution( &self, name: &str, parameters: &[SQLParam], ) -> Result<Option<SharedExecutablePlan>, SQLError>
Source§impl PreparedPlanSession for Engine
impl PreparedPlanSession for Engine
fn prepared_entry(&self, name: &str) -> Option<PreparedStatementPlan>
fn plan_cache_mode(&self) -> Result<String, SQLError>
fn plan_cache_mode_with_control( &self, control: &ProductionControl<'_>, ) -> Result<Produced<String>, SQLError>
fn publish_usage( &self, name: &str, logical_plan: &SharedExecutablePlan, update: PreparedPlanUpdate, )
Source§impl PreparedPlanState for Engine
impl PreparedPlanState for Engine
fn lookup_prepared(&self, name: &str) -> Option<SharedExecutablePlan>
fn prepared_parameter_types( &self, name: &str, ) -> Option<Vec<Option<ColumnType>>>
fn deallocate_prepared(&self, name: Option<&str>)
Source§impl PreparedSessionMetadata for Engine
impl PreparedSessionMetadata for Engine
fn show_result_schema(&self, name: &str) -> Result<RowSchema, SQLError>
fn show_result_schema_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<RowSchema, SQLError>
fn portal_result_schema(&self, name: &str) -> Option<RowSchema>
fn prepared_result_schema(&self, name: &str) -> Option<RowSchema>
fn portal_result_schema_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<Option<RowSchema>, SQLError>
fn prepared_result_schema_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<Option<RowSchema>, SQLError>
Source§impl QueryDocumentRead for Engine
impl QueryDocumentRead for Engine
fn document_ids(&self, table: &str) -> Result<Vec<DocId>, SQLError>
fn document( &self, table: &str, doc_id: DocId, ) -> Result<Option<Document>, SQLError>
fn document_fields( &self, table: &str, ids: &[DocId], fields: &[&str], ) -> Result<BTreeMap<DocId, Vec<Value>>, SQLError>
fn column_definitions( &self, table: &str, ) -> Result<Option<Vec<ColumnDef>>, String>
Source§impl QueryEffectCatalog for Engine
impl QueryEffectCatalog for Engine
fn registered_runtime_function_may_mutate_engine(&self, name: &str) -> bool
fn domain_by_oid(&self, oid: u32) -> Option<StoredDomain>
fn sequence_persistence( &self, name: &str, ) -> Result<Option<RelationPersistence>, String>
fn table_persistence( &self, name: &str, ) -> Result<Option<RelationPersistence>, String>
fn view_plan(&self, name: &str) -> Result<Option<QueryPlan>, SQLError>
fn lookup_prepared(&self, name: &str) -> Option<SharedExecutablePlan>
Source§impl QueryIndexRead for Engine
impl QueryIndexRead for Engine
Source§fn visit_value_index(
&self,
table: &str,
field: &str,
predicate: &Predicate,
visit: &mut dyn FnMut(DocId) -> Result<(), SQLError>,
) -> Result<bool, SQLError>
fn visit_value_index( &self, table: &str, field: &str, predicate: &Predicate, visit: &mut dyn FnMut(DocId) -> Result<(), SQLError>, ) -> Result<bool, SQLError>
Source§fn visit_exact_command_matches(
&self,
table: &str,
field: &str,
value: &Value,
visit: &mut dyn FnMut(DocId) -> Result<(), SQLError>,
) -> Result<DocumentChanges, SQLError>
fn visit_exact_command_matches( &self, table: &str, field: &str, value: &Value, visit: &mut dyn FnMut(DocId) -> Result<(), SQLError>, ) -> Result<DocumentChanges, SQLError>
Source§fn value_index_scan(
&self,
table: &str,
field: &str,
predicate: &Predicate,
) -> Result<Option<PostingList>, SQLError>
fn value_index_scan( &self, table: &str, field: &str, predicate: &Predicate, ) -> Result<Option<PostingList>, SQLError>
fn command_overlay_changes( &self, table: &str, ) -> Result<Option<DocumentChanges>, SQLError>
Source§fn exact_command_matches(
&self,
table: &str,
field: &str,
value: &Value,
) -> Result<CommandIndexProbe, SQLError>
fn exact_command_matches( &self, table: &str, field: &str, value: &Value, ) -> Result<CommandIndexProbe, SQLError>
Source§impl QueryOutputRewriter for Engine
impl QueryOutputRewriter for Engine
Source§fn optimize_retained_query(
&self,
query: MutableQueryPlan,
control: &ProductionControl<'_>,
) -> Result<OwnedQueryPlan, SQLError>
fn optimize_retained_query( &self, query: MutableQueryPlan, control: &ProductionControl<'_>, ) -> Result<OwnedQueryPlan, SQLError>
fn prune_owned_query_outputs( &self, query: MutableQueryPlan, aliases: &[String], projection: &SourceProjection, schema: &RowSchema, visible_ctes: &dyn Fn(&str) -> bool, control: &ProductionControl<'_>, ) -> Result<MutableQueryPlan, SQLError>
Source§fn push_output_filter(
&self,
query: &QueryPlan,
qualifier: &str,
filter: &ScalarExpr,
columns: Option<&[String]>,
) -> Result<Option<OwnedQueryPlan>, SQLError>
fn push_output_filter( &self, query: &QueryPlan, qualifier: &str, filter: &ScalarExpr, columns: Option<&[String]>, ) -> Result<Option<OwnedQueryPlan>, SQLError>
None when the caller must retain it.Source§fn push_derived_output_filter(
&self,
query: &QueryPlan,
qualifier: &str,
filter: &ScalarExpr,
columns: Option<&[String]>,
) -> Result<Option<OwnedQueryPlan>, SQLError>
fn push_derived_output_filter( &self, query: &QueryPlan, qualifier: &str, filter: &ScalarExpr, columns: Option<&[String]>, ) -> Result<Option<OwnedQueryPlan>, SQLError>
push_output_filter.Source§impl QueryRowLockSession for Engine
impl QueryRowLockSession for Engine
fn lock_relation( &self, table: &str, mode: RelationLockMode, ) -> Result<(), SQLError>
fn rollback_row_lock_acquisition(&self, acquisition: RowLockAcquisition)
fn row_changed_in_open_transaction( &self, table: &str, doc_id: DocId, ) -> Result<bool, SQLError>
fn row_lock_change_requires_recheck(&self) -> Result<bool, SQLError>
fn current_transaction_is_read_only(&self) -> bool
fn statement_row_lock_cache(&self) -> Result<Arc<RowLockRetryCache>, SQLError>
Source§impl QueryTableAccess for Engine
impl QueryTableAccess for Engine
fn index_read_control(&self) -> Result<StorageReadControl, SQLError>
fn serializable_read( &self, name: &str, ) -> Result<Option<SerializableRelationRead>, SQLError>
fn table(&self, name: &str) -> Result<Arc<dyn TableRead>, SQLError>
Source§fn index_holds_fields(
&self,
name: &str,
table: &Arc<dyn TableRead>,
fields: &[String],
) -> Result<bool, SQLError>
fn index_holds_fields( &self, name: &str, table: &Arc<dyn TableRead>, fields: &[String], ) -> Result<bool, SQLError>
table, the handle Self::table returned for name, hold fields for every row, loading or building what the catalog provides. An index-only read then projects those fields without reading a document.Source§impl RangeCanonicalInvocation for Engine
impl RangeCanonicalInvocation for Engine
fn invoke_canonical( &self, catalog: &CatalogReadView, oid: u32, value: &Value, control: &ProductionControl<'_>, ) -> Result<Produced<Value>, SQLError>
Source§impl RangeRegistryPublication for Engine
impl RangeRegistryPublication for Engine
fn range_registry(&self) -> RangeRegistryRead<'_>
fn range_catalog(&self) -> Option<&dyn CatalogFacade>
fn range_catalog_snapshot(&self) -> CatalogReadView
fn range_role_definitions(&self) -> BTreeMap<String, RoleDefinition>
fn publish_range_definitions(&self, registry: RangeRegistry)
Source§impl ReferencingTableAccess for Engine
impl ReferencingTableAccess for Engine
fn table_names(&self) -> StorageBackendResult<Vec<String>>
fn lock_relation( &self, table: &str, mode: RelationLockMode, ) -> Result<(), SQLError>
Source§impl ReferentialCatalog for Engine
impl ReferentialCatalog for Engine
fn session_replication_role_is_replica(&self) -> bool
Source§fn partition_ancestor_tables(
&self,
table: &str,
) -> Result<Vec<String>, SQLError>
fn partition_ancestor_tables( &self, table: &str, ) -> Result<Vec<String>, SQLError>
crate::semantics::partition::partition_ancestor_tables returns them.fn try_referrers_to( &self, table: &str, ) -> Result<Vec<(String, ForeignKey)>, String>
Source§impl ReferentialDeferrals for Engine
impl ReferentialDeferrals for Engine
fn defer_foreign_key_check( &self, constraint_table: &str, firing_table: &str, row: (&str, DocId), foreign_key: &ForeignKey, derived: Option<&ReferencedPartitionConstraint>, values: Arc<[Value]>, ) -> Result<(), SQLError>
fn defer_foreign_key_parent_event( &self, constraint_table: &str, firing_table: &str, foreign_key: &ForeignKey, derived: Option<&ReferencedPartitionConstraint>, ) -> Result<(), SQLError>
Source§impl ReferentialSnapshots for Engine
impl ReferentialSnapshots for Engine
fn latest_reference_snapshot( &self, ) -> Result<Box<dyn ReferentialReadSnapshot + '_>, SQLError>
fn transaction_document_metadata( &self, table: &str, doc_id: DocId, ) -> Result<Option<DocumentMetadata>, SQLError>
Source§impl RelationAlterNames for Engine
impl RelationAlterNames for Engine
fn resolve_relation_kind( &self, name: &str, ) -> Result<RelationResolution, SQLError>
fn relation_kind_at(&self, name: &str) -> Result<Option<&'static str>, String>
Source§impl RelationCandidateState for Engine
impl RelationCandidateState for Engine
fn temporary_schema_name_with_control( &self, control: &ProductionControl<'_>, ) -> Result<Produced<String>, SQLError>
fn with_search_path_with_control( &self, control: &ProductionControl<'_>, read: &mut dyn FnMut(&dyn SearchPathView) -> Result<(), SQLError>, ) -> Result<(), SQLError>
fn temporary_schema_name(&self) -> String
fn search_path(&self) -> SearchPathRead<'_>
Source§impl RelationCounts for Engine
impl RelationCounts for Engine
Source§impl RelationCreationRuntime for Engine
impl RelationCreationRuntime for Engine
fn relation_array_name( &self, relation: &RelationIdentity, array_oid: u32, ) -> Option<String>
fn displace_generated_array( &self, identity: &RelationIdentity, ) -> Result<bool, SQLError>
fn displace_relation_array( &self, identity: &RelationIdentity, ) -> Result<bool, SQLError>
fn synchronize_catalog_registries(&self) -> StorageBackendResult<()>
fn synchronize_table_catalog(&self) -> StorageBackendResult<()>
fn synchronize_table_data(&self) -> StorageBackendResult<()>
fn backend_transaction_is_deferred(&self) -> bool
fn fence_catalog_writer_and_refresh_snapshot(&self) -> Result<(), SQLError>
Source§impl RelationDefinitionSession for Engine
impl RelationDefinitionSession for Engine
Source§impl RelationDropCatalog for Engine
impl RelationDropCatalog for Engine
fn resolve_relation_kind( &self, name: &str, ) -> Result<RelationResolution, SQLError>
fn resolve_age_label_relation_name( &self, name: &str, ) -> Result<Option<String>, SQLError>
Source§impl RelationEventAlterTransactions for Engine
impl RelationEventAlterTransactions for Engine
fn with_event_write( &self, write: RelationEventAlterWrite<'_>, ) -> Result<SQLResult, SQLError>
Source§impl RelationLockCatalog for Engine
impl RelationLockCatalog for Engine
fn relation_object_id(&self, name: &str) -> Result<Option<[u8; 16]>, SQLError>
fn relation_object_id_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<Option<[u8; 16]>, SQLError>
Source§fn relation_catalog_oid(&self, name: &str) -> Result<Option<u32>, SQLError>
fn relation_catalog_oid(&self, name: &str) -> Result<Option<u32>, SQLError>
pg_class OID of a table, view, materialized view or foreign table, which addresses its catalog tuple.fn table_name(&self, object_id: [u8; 16]) -> Option<String>
fn table_name_with_control( &self, object_id: [u8; 16], control: &ProductionControl<'_>, ) -> Result<Option<Produced<String>>, SQLError>
Source§impl RelationLockSession for Engine
impl RelationLockSession for Engine
Source§impl RelationOwnerSchemas for Engine
impl RelationOwnerSchemas for Engine
fn schema_security(&self, schema: &str) -> Option<BoundSchemaSecurity>
Source§impl RelationRemovalEvents for Engine
impl RelationRemovalEvents for Engine
Source§impl RelationRemovalLocks for Engine
impl RelationRemovalLocks for Engine
Source§impl RelationRemovalPrivileges for Engine
impl RelationRemovalPrivileges for Engine
Source§impl RelationRemovalTransactions for Engine
impl RelationRemovalTransactions for Engine
fn with_relation_write( &self, write: RelationRemovalWrite<'_>, ) -> Result<SQLResult, SQLError>
Source§impl RelationRemovalViews for Engine
impl RelationRemovalViews for Engine
Source§impl RelationRenameDependencies for Engine
impl RelationRenameDependencies for Engine
fn rewrite_views( &self, renames: &BTreeMap<RelationIdentity, RelationIdentity>, ) -> StorageBackendResult<()>
fn rewrite_routines( &self, from: &RelationIdentity, to: &RelationIdentity, ) -> Result<(), String>
fn rename_events( &self, from: &RelationIdentity, to: &RelationIdentity, ) -> StorageBackendResult<()>
Source§impl RelationRetrieval for Engine
impl RelationRetrieval for Engine
fn prepare_accelerated<'a>( &'a self, table: &'a str, signal_table: &'a str, predicate: Option<&ScalarExpr>, params: &'a [SQLParam], capture_complete_scores: bool, ) -> Result<Option<ScoredEntriesProducer<'a>>, SQLError>
fn optimized( &self, table: &str, predicate: Option<&ScalarExpr>, params: &[SQLParam], ) -> Result<Option<Vec<ScoredEntry>>, SQLError>
fn captured( &self, table: &str, predicate: Option<&ScalarExpr>, params: &[SQLParam], ) -> Result<Option<ProducedScoredEntries>, SQLError>
fn function( &self, table: &str, signal_table: &str, name: &str, args: &[ScalarExpr], params: &[SQLParam], top_k: Option<usize>, ) -> Result<Vec<ScoredEntry>, SQLError>
Source§impl RelationRetrievalPlanner for Engine
impl RelationRetrievalPlanner for Engine
fn accelerated_tree( &self, table: &str, expression: &ScalarExpr, tree: OperatorTree, ) -> Result<Option<OperatorTree>, SQLError>
fn text_top_k( &self, table: &str, tree: OperatorTree, top_k: usize, ) -> Result<OperatorTree, SQLError>
Source§impl RetrievalAccess for Engine
impl RetrievalAccess for Engine
fn direct_vector_retrieval( &self, predicate: &ScalarExpr, params: &[SQLParam], ) -> Result<Option<DirectVectorRetrieval>, SQLError>
fn knn_entries( &self, table: &str, field: &str, query: &[f32], top_k: usize, committed: bool, ) -> Result<Vec<ScoredEntry>, SQLError>
fn retrieval_entries( &self, table: &str, predicate: &ScalarExpr, params: &[SQLParam], committed: bool, ) -> Result<Option<Vec<ScoredEntry>>, SQLError>
fn retrieval_input( &self, table: &str, predicate: &ScalarExpr, params: &[SQLParam], committed: bool, ) -> Result<Option<ProducedScoredEntries>, SQLError>
Source§impl RetrievalDocuments for Engine
impl RetrievalDocuments for Engine
Source§impl RetrievalGraphs for Engine
impl RetrievalGraphs for Engine
fn graph_handle( &self, graph: &str, ) -> Result<Option<Arc<GraphStoreHandle>>, SQLError>
Source§impl RetrievalIndexes for Engine
impl RetrievalIndexes for Engine
fn query_table_indexes( &self, table: &str, ) -> StorageBackendResult<Option<Box<dyn RetrievalIndexState>>>
fn table_indexes( &self, table: &str, ) -> StorageBackendResult<Option<Box<dyn RetrievalIndexState>>>
fn catalog_index( &self, name: &str, ) -> StorageBackendResult<Option<CatalogIndexRow>>
fn resolve_table_name( &self, table: &str, ) -> StorageBackendResult<Option<String>>
Source§impl RetrievalModels for Engine
impl RetrievalModels for Engine
Source§impl RetrievalPlanOptimizer for Engine
impl RetrievalPlanOptimizer for Engine
fn optimize( &self, table: &str, tree: &OperatorTree, ) -> Result<OperatorTree, SQLError>
Source§impl RetrievalPlanningCatalog for Engine
impl RetrievalPlanningCatalog for Engine
Source§fn production_resources(&self) -> Result<Option<PlanningResources>, SQLError>
fn production_resources(&self) -> Result<Option<PlanningResources>, SQLError>
fn has_table(&self, table: &str) -> Result<bool, String>
fn resolve_table_name(&self, table: &str) -> Result<Option<String>, String>
fn list_catalog_indexes(&self) -> Result<CatalogIndexSnapshot, String>
fn value_index_cardinality( &self, table: &str, field: &str, predicate: &Predicate, ) -> Result<Option<usize>, SQLError>
fn value_index_supports( &self, table: &str, field: &str, predicate: &Predicate, ) -> Result<bool, String>
Source§fn text_top_k_capabilities(
&self,
table: &str,
field: &str,
query: &str,
) -> Result<TextTopKCapabilities, SQLError>
fn text_top_k_capabilities( &self, table: &str, field: &str, query: &str, ) -> Result<TextTopKCapabilities, SQLError>
fn table_doc_count(&self, table: &str) -> Result<u64, SQLError>
fn try_query_table( &self, table: &str, ) -> Result<Option<Box<dyn RetrievalStatisticsTable>>, String>
fn try_query_column_stats( &self, table: &str, ) -> Result<ColumnStatistics, String>
Source§fn graph_snapshot(
&self,
graph: &str,
) -> Result<Option<GraphStatisticsSnapshot>, String>
fn graph_snapshot( &self, graph: &str, ) -> Result<Option<GraphStatisticsSnapshot>, String>
Source§impl RetrievalRelations for Engine
impl RetrievalRelations for Engine
fn serializable_read( &self, table: &str, ) -> Result<Option<SerializableRelationRead>, SQLError>
fn try_describe_query_table( &self, table: &str, ) -> StorageBackendResult<Option<Vec<ColumnDef>>>
fn has_table(&self, table: &str) -> StorageBackendResult<bool>
fn column_type( &self, table: &str, field: &str, ) -> StorageBackendResult<Option<ColumnType>>
fn table_doc_ids(&self, table: &str) -> Result<Vec<DocId>, SQLError>
fn table_doc_id_page( &self, table: &str, after: Option<DocId>, limit: usize, control: &StorageReadControl, ) -> Result<BudgetedVec<DocId>, SQLError>
fn get_document_fields( &self, table: &str, ids: &[DocId], field: &str, ) -> Result<BTreeMap<DocId, Value>, SQLError>
Source§fn capture_document_filter(
&self,
table: &str,
ids: &SelectedIds,
field: &str,
predicate: &Predicate,
bytes: usize,
cancellation: &CancellationToken,
) -> Result<CapturedScoredEntries, SQLError>
fn capture_document_filter( &self, table: &str, ids: &SelectedIds, field: &str, predicate: &Predicate, bytes: usize, cancellation: &CancellationToken, ) -> Result<CapturedScoredEntries, SQLError>
Source§impl RetrievalSnapshots for Engine
impl RetrievalSnapshots for Engine
fn snapshot_context( &self, table: &str, ) -> Result<Option<ExecutionContext>, SQLError>
Source§fn snapshot_context_for_scores(
&self,
table: &str,
) -> Result<Option<ExecutionContext>, SQLError>
fn snapshot_context_for_scores( &self, table: &str, ) -> Result<Option<ExecutionContext>, SQLError>
fn snapshot_context_with_document_store( &self, table: &str, documents: Arc<dyn DocumentStore>, ) -> Result<Option<ExecutionContext>, SQLError>
fn get_documents_with_materialized_projection( &self, table: &str, ids: &[DocId], projection: &[String], ) -> Result<BTreeMap<DocId, Document>, SQLError>
Source§impl RetrievalSourceCosting for Engine
impl RetrievalSourceCosting for Engine
fn operator_join_access( &self, name: &str, relations: Option<&OperatorJoinRelations>, args: &[ScalarExpr], ) -> Result<LocalAccessEstimate, SQLError>
fn local_access( &self, table: &str, predicate: &ScalarExpr, ) -> Result<Option<LocalAccessEstimate>, SQLError>
Source§impl RetrievalTransactionState for Engine
impl RetrievalTransactionState for Engine
fn transaction_depth(&self) -> usize
Source§impl ReturningCatalog for Engine
impl ReturningCatalog for Engine
fn try_describe_table_row_type( &self, table: &str, ) -> Result<Option<Vec<ColumnDef>>, String>
Source§fn with_table_row_type_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
read: &mut dyn FnMut(&[ColumnDef]) -> Result<(), SQLError>,
) -> Result<bool, SQLError>
fn with_table_row_type_with_control( &self, name: &str, control: &ProductionControl<'_>, read: &mut dyn FnMut(&[ColumnDef]) -> Result<(), SQLError>, ) -> Result<bool, SQLError>
fn try_table_columns(&self, table: &str) -> Result<Vec<String>, String>
Source§fn visit_column_names_with_control(
&self,
table: &str,
control: &ProductionControl<'_>,
read: &mut dyn FnMut(&str) -> Result<(), SQLError>,
) -> Result<(), SQLError>
fn visit_column_names_with_control( &self, table: &str, control: &ProductionControl<'_>, read: &mut dyn FnMut(&str) -> Result<(), SQLError>, ) -> Result<(), SQLError>
fn view_schema(&self, table: &str) -> Result<Option<RowSchema>, SQLError>
Source§impl ReturningScope for Engine
impl ReturningScope for Engine
fn binding_snapshot(&self) -> Result<BindingSnapshot, SQLError>
Source§impl RewriteRowChanges for Engine
impl RewriteRowChanges for Engine
Source§impl RoleCatalogGuards for Engine
impl RoleCatalogGuards for Engine
fn role_definitions(&self) -> RoleDefinitionRead<'_>
fn role_memberships(&self) -> RoleMembershipRead<'_>
Source§fn with_role_catalogs_with_control(
&self,
control: &ProductionControl<'_>,
read: &mut RoleCatalogVisitor<'_>,
) -> Result<(), SQLError>
fn with_role_catalogs_with_control( &self, control: &ProductionControl<'_>, read: &mut RoleCatalogVisitor<'_>, ) -> Result<(), SQLError>
Source§fn inquiry_role_definitions(&self) -> Result<RoleDefinitionRead<'_>, SQLError>
fn inquiry_role_definitions(&self) -> Result<RoleDefinitionRead<'_>, SQLError>
Source§impl RoleDependencyCatalog for Engine
impl RoleDependencyCatalog for Engine
fn database(&self) -> RoleDependencyRead<'_, BoundDatabaseSecurity>
fn schemas( &self, ) -> RoleDependencyRead<'_, BTreeMap<String, BoundSchemaSecurity>>
fn tables(&self) -> Box<dyn RoleTablesRead + '_>
fn views( &self, ) -> RoleDependencyRead<'_, BTreeMap<RelationIdentity, StoredView>>
fn foreign_tables( &self, ) -> RoleDependencyRead<'_, BTreeMap<RelationIdentity, BoundTableSecurity>>
fn sequences( &self, ) -> RoleDependencyRead<'_, BTreeMap<RelationIdentity, BoundSequenceSecurity>>
fn routines( &self, ) -> RoleDependencyRead<'_, BTreeMap<String, Vec<Arc<SQLUserFunction>>>>
fn domains(&self) -> RoleDependencyRead<'_, BTreeMap<String, StoredDomain>>
Source§impl RolePublication for Engine
impl RolePublication for Engine
fn prepare_writer(&self) -> Result<(), SQLError>
fn persist_roles( &self, before: &BTreeMap<String, RoleDefinition>, roles: &BTreeMap<String, RoleDefinition>, ) -> Result<(), SQLError>
fn persist_memberships( &self, before: &BTreeMap<RoleMembershipKey, RoleMembership>, memberships: &BTreeMap<RoleMembershipKey, RoleMembership>, ) -> Result<(), SQLError>
fn catalog_changed(&self)
fn set_current_role(&self, target: Option<RoleBinding>)
Source§impl RoleReferenceNames for Engine
impl RoleReferenceNames for Engine
Source§fn outer_role(&self) -> RoleReference
fn outer_role(&self) -> RoleReference
fn current_role(&self) -> RoleReference
fn session_role(&self) -> RoleReference
fn authenticated_role(&self) -> RoleReference
Source§impl RoleRegistry for Engine
impl RoleRegistry for Engine
fn write_roles(&self) -> RoleDefinitionWrite<'_>
fn write_memberships(&self) -> RoleMembershipWrite<'_>
Source§fn role_dependency_detail(
&self,
role: RoleIdentity,
) -> Result<Option<String>, SQLError>
fn role_dependency_detail( &self, role: RoleIdentity, ) -> Result<Option<String>, SQLError>
role; None when nothing does. Projection may restore catalog state, so callers release registry guards before invoking it.Source§impl RoleTargetSchemaAccess for Engine
impl RoleTargetSchemaAccess for Engine
fn require_schema_create( &self, schema: &str, role: &RoleReference, ) -> Result<(), SQLError>
Source§impl RoutineBodySession for Engine
impl RoutineBodySession for Engine
fn retain_routine_body( &self, function: &SQLUserFunction, body: CompiledFunctionBody, ) -> Result<(), SQLError>
Source§impl RoutineCompilationCatalog for Engine
impl RoutineCompilationCatalog for Engine
Source§fn binding_snapshot_with_control(
&self,
control: &ProductionControl<'_>,
) -> Result<ControlledBindingSnapshot, SQLError>
fn binding_snapshot_with_control( &self, control: &ProductionControl<'_>, ) -> Result<ControlledBindingSnapshot, SQLError>
fn stored_query_namespace_with_control( &self, control: &ProductionControl<'_>, ) -> Result<ControlledStoredQueryNamespace, SQLError>
fn has_registered_aggregate_function(&self, name: &str) -> bool
fn binding_snapshot(&self) -> Result<BindingSnapshot, SQLError>
fn stored_query_namespace(&self) -> StoredQueryNamespace
Source§impl RoutineCompilationSession for Engine
impl RoutineCompilationSession for Engine
fn routine_search_path(&self) -> Vec<String>
fn replace_routine_search_path(&self, path: Vec<String>) -> Vec<String>
fn restore_routine_search_path(&self, path: Vec<String>)
Source§fn routine_settings_scope(
&self,
settings: &[(String, String)],
) -> Result<Box<dyn RoutineConfigurationGuard + '_>, SQLError>
fn routine_settings_scope( &self, settings: &[(String, String)], ) -> Result<Box<dyn RoutineConfigurationGuard + '_>, SQLError>
Source§impl RoutineConfigurationSession for Engine
impl RoutineConfigurationSession for Engine
fn routine_configuration_guard(&self) -> Box<dyn RoutineConfigurationGuard + '_>
fn set_routine_variable(&self, name: &str, value: &str) -> Result<(), SQLError>
fn show_routine_variable(&self, name: &str) -> Result<String, SQLError>
Source§fn routine_variable_name(&self, name: &str) -> Result<String, SQLError>
fn routine_variable_name(&self, name: &str) -> Result<String, SQLError>
name refers to, which a routine’s configuration stores.Source§fn load_language_library(&self, language: &str)
fn load_language_library(&self, language: &str)
Source§impl RoutineDropNotices for Engine
impl RoutineDropNotices for Engine
fn routine_drop_notice(&self, notice: SQLNotice)
Source§impl RoutineExecutionAuthority for Engine
impl RoutineExecutionAuthority for Engine
fn current_role(&self) -> RoleReference
fn current_user_has_role_identity_privileges(&self, role: RoleIdentity) -> bool
Source§fn current_user_has_role_identity_privileges_with_control(
&self,
role: RoleIdentity,
control: &ProductionControl<'_>,
) -> Result<bool, SQLError>
fn current_user_has_role_identity_privileges_with_control( &self, role: RoleIdentity, control: &ProductionControl<'_>, ) -> Result<bool, SQLError>
Source§impl RoutineExpressions for Engine
impl RoutineExpressions for Engine
fn expression_type_with_control( &self, plan: &ExpressionPlan, params: &[SQLParam], control: &ProductionControl<'_>, ) -> Result<Option<Produced<ColumnType>>, SQLError>
fn column_type_name(&self, name: &str) -> Result<ColumnType, SQLError>
fn evaluate(&self, expression: &Expr) -> Result<Value, SQLError>
fn evaluate_with_type( &self, expression: &Expr, ) -> Result<TypedCatalogValue, SQLError>
fn expression_type( &self, plan: &ExpressionPlan, params: &[SQLParam], ) -> Result<Option<ColumnType>, SQLError>
Source§impl RoutineInvocationSession for Engine
impl RoutineInvocationSession for Engine
fn plpgsql_body( &self, function: &SQLUserFunction, definition: &CreateFunction, relation: Option<i64>, ) -> Result<Arc<CompiledFunctionBody>, SQLError>
fn depth_limit(&self) -> usize
fn state_guard( &self, configured: bool, security_definer: bool, ) -> Box<dyn RoutineInvocationState + '_>
fn set_current_user(&self, user: RoleIdentity) -> Result<(), SQLError>
fn set_configured_parameter( &self, name: &str, value: &str, ) -> Result<(), SQLError>
Source§fn plpgsql_variable_conflict(&self) -> VariableConflict
fn plpgsql_variable_conflict(&self) -> VariableConflict
plpgsql.variable_conflict setting a PL/pgSQL body compiled now takes, with the language’s library loaded as its call handler loads it.Source§impl RoutineNameCatalog for Engine
impl RoutineNameCatalog for Engine
fn schema_security(&self, schema: &str) -> Option<BoundSchemaSecurity>
fn current_role(&self) -> RoleReference
fn search_path(&self) -> Vec<String>
fn search_path_with_control( &self, control: &ProductionControl<'_>, ) -> Result<Produced<Vec<String>>, SQLError>
Source§fn temporary_schema(&self) -> Option<String>
fn temporary_schema(&self) -> Option<String>
fn temporary_schema_with_control( &self, control: &ProductionControl<'_>, ) -> Result<Option<Produced<String>>, SQLError>
fn schema_exists_with_control( &self, schema: &str, control: &ProductionControl<'_>, ) -> Result<bool, SQLError>
fn require_schema_usage( &self, schema: &str, role: &RoleReference, ) -> Result<(), SQLError>
fn schema_has_usage(&self, schema: &str, role: &RoleReference) -> bool
fn schema_has_usage_with_control( &self, schema: &str, role: &RoleReference, control: &ProductionControl<'_>, ) -> Result<bool, SQLError>
fn require_schema_usage_with_control( &self, schema: &str, role: &RoleReference, control: &ProductionControl<'_>, ) -> Result<(), SQLError>
Source§fn routine_type_display(&self, type_name: &str) -> String
fn routine_type_display(&self, type_name: &str) -> String
format_type_be of a routine argument type: a user-defined type, recorded by identity, is spelled by its current name.Source§impl RoutineOverloadCatalog for Engine
impl RoutineOverloadCatalog for Engine
fn routine_type_snapshot(&self) -> RoutineTypeSnapshot
fn routine_search_path(&self) -> Vec<String>
Source§fn routine_schema_precedes_pg_catalog(
&self,
schema: RelationName<'_>,
control: &ProductionControl<'_>,
) -> Result<bool, SQLError>
fn routine_schema_precedes_pg_catalog( &self, schema: RelationName<'_>, control: &ProductionControl<'_>, ) -> Result<bool, SQLError>
fn has_registered_scalar_function_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<bool, SQLError>
fn has_registered_scalar_function(&self, name: &str) -> bool
fn lookup_sql_routine_candidates( &self, name: &str, ) -> Result<Option<Vec<Arc<SQLUserFunction>>>, SQLError>
fn lookup_sql_routine_candidates_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<Option<Produced<Vec<Arc<SQLUserFunction>>>>, SQLError>
fn lookup_bound_sql_routine_candidates_by_binding( &self, binding: &FunctionBinding, ) -> Option<Vec<Arc<SQLUserFunction>>>
fn lookup_bound_sql_functions_by_binding( &self, binding: &FunctionBinding, ) -> Option<Vec<Arc<SQLUserFunction>>>
Source§fn select_bound_routine_with_control(
&self,
binding: &FunctionBinding,
kind: RoutineCallKind,
control: &ProductionControl<'_>,
) -> Result<Option<Arc<SQLUserFunction>>, SQLError>
fn select_bound_routine_with_control( &self, binding: &FunctionBinding, kind: RoutineCallKind, control: &ProductionControl<'_>, ) -> Result<Option<Arc<SQLUserFunction>>, SQLError>
Source§impl RoutineParserCatalog for Engine
impl RoutineParserCatalog for Engine
fn parser_settings(&self) -> ParserSettings
fn parser_notice(&self, notice: SQLNotice)
fn plpgsql_catalog(&self) -> Result<PlpgsqlCatalog, SQLError>
Source§impl RoutinePlanExpressions for Engine
impl RoutinePlanExpressions for Engine
Source§fn evaluate_constant_routine_with_control(
&self,
expression: &ScalarExpr,
control: &ProductionControl<'_>,
) -> Result<Produced<Value>, SQLError>
fn evaluate_constant_routine_with_control( &self, expression: &ScalarExpr, control: &ProductionControl<'_>, ) -> Result<Produced<Value>, SQLError>
Source§fn evaluate_constant_routine(
&self,
expression: &ScalarExpr,
) -> Result<Value, SQLError>
fn evaluate_constant_routine( &self, expression: &ScalarExpr, ) -> Result<Value, SQLError>
Source§impl RoutinePortals for Engine
impl RoutinePortals for Engine
fn ensure_available(&self, name: &str) -> Result<(), SQLError>
fn open( &self, params: &[SQLParam], name: &str, scroll: Option<bool>, plan: &UnifiedPlan, source_sql: &str, ) -> Result<(), SQLError>
fn fetch(&self, request: &FetchCursorStmt) -> Result<SQLResult, SQLError>
fn close(&self, name: &str) -> Result<(), SQLError>
fn allocate_name(&self) -> String
fn pin(&self, name: &str) -> Result<(), SQLError>
fn unpin(&self, name: &str) -> Result<(), SQLError>
Source§impl RoutinePrivilegeNotices for Engine
impl RoutinePrivilegeNotices for Engine
fn routine_privilege_notice(&self, notice: SQLNotice)
Source§impl RoutineRegclassCatalog for Engine
impl RoutineRegclassCatalog for Engine
Source§impl RoutineRegistryPublication for Engine
impl RoutineRegistryPublication for Engine
fn persist_routine_definitions( &self, registry: &RoutineRegistry, ) -> Result<(), SQLError>
Source§impl RoutineRegistryState for Engine
impl RoutineRegistryState for Engine
fn routine_snapshot(&self) -> RoutineRegistry
fn routines_write(&self) -> RoutineRegistryWrite<'_>
Source§impl RoutineRenameDependents for Engine
impl RoutineRenameDependents for Engine
fn rewrite_schema_routine_identity( &self, target: &FunctionBinding, new_name: &str, ) -> StorageBackendResult<()>
fn rewrite_view_routine_identity( &self, target: &FunctionBinding, new_name: &str, ) -> StorageBackendResult<()>
fn rewrite_event_routine_identity( &self, target: &FunctionBinding, new_name: &str, ) -> Result<(), SQLError>
Source§impl RoutineResolution for Engine
impl RoutineResolution for Engine
Source§fn routine_body(
&self,
function: &SQLUserFunction,
) -> Result<Arc<CompiledFunctionBody>, SQLError>
fn routine_body( &self, function: &SQLUserFunction, ) -> Result<Arc<CompiledFunctionBody>, SQLError>
Source§fn routine_analysis_body(
&self,
function: &SQLUserFunction,
) -> Result<Arc<CompiledFunctionBody>, SQLError>
fn routine_analysis_body( &self, function: &SQLUserFunction, ) -> Result<Arc<CompiledFunctionBody>, SQLError>
Source§fn lookup_bound_sql_functions(
&self,
name: &str,
) -> Option<Vec<Arc<SQLUserFunction>>>
fn lookup_bound_sql_functions( &self, name: &str, ) -> Option<Vec<Arc<SQLUserFunction>>>
fn lookup_bound_sql_functions_by_binding( &self, binding: &FunctionBinding, ) -> Option<Vec<Arc<SQLUserFunction>>>
fn has_registered_scalar_function(&self, name: &str) -> bool
fn has_registered_table_function(&self, name: &str) -> bool
Source§fn has_registered_scalar_function_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
) -> Result<bool, SQLError>
fn has_registered_scalar_function_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<bool, SQLError>
Source§fn has_registered_table_function_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
) -> Result<bool, SQLError>
fn has_registered_table_function_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<bool, SQLError>
fn has_registered_aggregate_function_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<bool, SQLError>
Source§fn registered_table_function_columns(&self, name: &str) -> Option<Vec<String>>
fn registered_table_function_columns(&self, name: &str) -> Option<Vec<String>>
None means its result supplies the descriptor at execution.Source§fn registered_table_function_columns_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
) -> Result<Option<Produced<Vec<String>>>, SQLError>
fn registered_table_function_columns_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<Option<Produced<Vec<String>>>, SQLError>
fn has_registered_aggregate_function(&self, name: &str) -> bool
fn lookup_visible_sql_functions( &self, name: &str, ) -> Result<Option<Vec<Arc<SQLUserFunction>>>, SQLError>
Source§fn has_visible_sql_functions_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
) -> Result<bool, SQLError>
fn has_visible_sql_functions_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<bool, SQLError>
Source§fn lookup_visible_sql_functions_for_analysis(
&self,
name: &str,
) -> Result<Option<Vec<Arc<SQLUserFunction>>>, SQLError>
fn lookup_visible_sql_functions_for_analysis( &self, name: &str, ) -> Result<Option<Vec<Arc<SQLUserFunction>>>, SQLError>
Source§fn visible_function_returns_set_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
) -> Result<bool, SQLError>
fn visible_function_returns_set_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<bool, SQLError>
Source§fn visible_function_setness_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
) -> Result<VisibleFunctionSetness, SQLError>
fn visible_function_setness_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<VisibleFunctionSetness, SQLError>
Source§fn select_bound_function_with_control(
&self,
binding: &FunctionBinding,
control: &ProductionControl<'_>,
) -> Result<Option<Arc<SQLUserFunction>>, SQLError>
fn select_bound_function_with_control( &self, binding: &FunctionBinding, control: &ProductionControl<'_>, ) -> Result<Option<Arc<SQLUserFunction>>, SQLError>
fn resolve_static_sql_function( &self, name: &str, binding: Option<&FunctionBinding>, argument_names: &[Option<String>], argument_types: &[Option<ColumnType>], explicit_variadic: bool, ) -> Result<Option<Arc<SQLUserFunction>>, SQLError>
fn resolve_static_sql_function_match( &self, name: &str, binding: Option<&FunctionBinding>, argument_names: &[Option<String>], argument_types: &[Option<ColumnType>], explicit_variadic: bool, ) -> Result<Option<StaticFunctionMatch>, SQLError>
Source§fn resolve_static_sql_function_setness_with_control(
&self,
name: &str,
binding: Option<&FunctionBinding>,
argument_names: &[Option<String>],
argument_types: &[Option<ColumnType>],
explicit_variadic: bool,
control: &ProductionControl<'_>,
) -> Result<Option<bool>, SQLError>
fn resolve_static_sql_function_setness_with_control( &self, name: &str, binding: Option<&FunctionBinding>, argument_names: &[Option<String>], argument_types: &[Option<ColumnType>], explicit_variadic: bool, control: &ProductionControl<'_>, ) -> Result<Option<bool>, SQLError>
Source§fn resolve_static_sql_function_strictness_with_control(
&self,
name: &str,
binding: Option<&FunctionBinding>,
call: RoutineCallDescriptor<'_>,
control: &ProductionControl<'_>,
) -> Result<Option<bool>, SQLError>
fn resolve_static_sql_function_strictness_with_control( &self, name: &str, binding: Option<&FunctionBinding>, call: RoutineCallDescriptor<'_>, control: &ProductionControl<'_>, ) -> Result<Option<bool>, SQLError>
Source§fn resolve_static_sql_function_match_with_control(
&self,
name: &str,
binding: Option<&FunctionBinding>,
call: RoutineCallDescriptor<'_>,
control: &ProductionControl<'_>,
) -> Result<Option<OwnedStaticFunctionMatch>, SQLError>
fn resolve_static_sql_function_match_with_control( &self, name: &str, binding: Option<&FunctionBinding>, call: RoutineCallDescriptor<'_>, control: &ProductionControl<'_>, ) -> Result<Option<OwnedStaticFunctionMatch>, SQLError>
Source§fn resolve_static_sql_function_binding_with_control(
&self,
name: &str,
binding: Option<&FunctionBinding>,
argument_names: &[Option<String>],
argument_types: &[Option<ColumnType>],
explicit_variadic: bool,
control: &ProductionControl<'_>,
) -> Result<Option<Produced<FunctionBinding>>, SQLError>
fn resolve_static_sql_function_binding_with_control( &self, name: &str, binding: Option<&FunctionBinding>, argument_names: &[Option<String>], argument_types: &[Option<ColumnType>], explicit_variadic: bool, control: &ProductionControl<'_>, ) -> Result<Option<Produced<FunctionBinding>>, SQLError>
fn resolve_table_function_overload_with_builtins_and_control( &self, name: &str, binding: Option<&FunctionBinding>, call: RoutineCallDescriptor<'_>, builtins: &[BuiltinFunctionOverload], control: &ProductionControl<'_>, ) -> Result<Option<Produced<ResolvedFunctionOverload>>, SQLError>
fn resolve_table_function_overload_with_builtins( &self, name: &str, binding: Option<&FunctionBinding>, argument_names: &[Option<String>], argument_types: &[Option<ColumnType>], explicit_variadic: bool, builtins: &[BuiltinFunctionOverload], ) -> Result<Option<ResolvedFunctionOverload>, SQLError>
Source§impl RoutineRestoreSchemas for Engine
impl RoutineRestoreSchemas for Engine
Source§impl RoutineStatementInputs for Engine
impl RoutineStatementInputs for Engine
fn invocation_context(&self) -> RoutineInvocationContext<'_>
fn anonymous_block_context(&self) -> AnonymousBlockContext<'_>
fn registration_context(&self) -> RoutineRegistrationContext<'_>
fn privilege_context(&self) -> RoutinePrivilegeContext<'_>
Source§impl RoutineStatementTransactions for Engine
impl RoutineStatementTransactions for Engine
fn with_rename(&self, operation: RoutineRenameWrite<'_>) -> Result<(), SQLError>
fn with_removal( &self, operation: RoutineRemovalWrite<'_>, ) -> Result<(), SQLError>
Source§impl RoutineStatements for Engine
impl RoutineStatements for Engine
fn with_statement_scope_with_control( &self, control: &ProductionControl<'_>, analyze: ControlledStatementScopeOperation<'_>, ) -> Result<(), SQLError>
Source§fn planning_resources(&self) -> Result<OwnedProductionControl, SQLError>
fn planning_resources(&self) -> Result<OwnedProductionControl, SQLError>
fn body_input_context(&self) -> Option<SQLRoutineInputContext<'_>>
fn plpgsql_preparations( &self, definition: &CreateFunction, parsed: &PLpgSQLFunction, control: &ProductionControl<'_>, ) -> Result<Arc<PLpgSQLPreparations>, SQLError>
Source§fn analyze_static_plan(
&self,
plan: &mut UnifiedPlan,
parameters: &[SQLParam],
) -> Result<ProceduralPlanAnalysis, SQLError>
fn analyze_static_plan( &self, plan: &mut UnifiedPlan, parameters: &[SQLParam], ) -> Result<ProceduralPlanAnalysis, SQLError>
fn analyze_static_plan_owned( &self, plan: MutableExecutablePlan, parameters: &[SQLParam], control: &ProductionControl<'_>, ) -> Result<OwnedProceduralPlanAnalysis, SQLError>
fn parser_settings(&self) -> ParserSettings
Source§fn execute_body_statement(
&self,
plan: UnifiedPlan,
params: &[SQLParam],
check: Option<StatementResultCheck<'_>>,
) -> Result<SQLResult, SQLError>
fn execute_body_statement( &self, plan: UnifiedPlan, params: &[SQLParam], check: Option<StatementResultCheck<'_>>, ) -> Result<SQLResult, SQLError>
check sees what the statement’s analysis derives about its result before it runs, as PostgreSQL checks a body’s final statement before running it.Source§fn select_body_plan(
&self,
entry: &PreparedStatementPlan,
params: &[SQLParam],
control: &ProductionControl<'_>,
) -> Result<PreparedPlanSelection, SQLError>
fn select_body_plan( &self, entry: &PreparedStatementPlan, params: &[SQLParam], control: &ProductionControl<'_>, ) -> Result<PreparedPlanSelection, SQLError>
Source§fn select_simple_expression_plan(
&self,
entry: &PreparedStatementPlan,
params: &[SQLParam],
control: &ProductionControl<'_>,
) -> Result<PreparedPlanSelection, SQLError>
fn select_simple_expression_plan( &self, entry: &PreparedStatementPlan, params: &[SQLParam], control: &ProductionControl<'_>, ) -> Result<PreparedPlanSelection, SQLError>
Source§fn execute_selected_body_plan(
&self,
plan: &UnifiedPlan,
params: &[SQLParam],
) -> Result<SQLResult, SQLError>
fn execute_selected_body_plan( &self, plan: &UnifiedPlan, params: &[SQLParam], ) -> Result<SQLResult, SQLError>
fn execute_bound( &self, statement: Statement, params: &[SQLParam], ) -> Result<SQLResult, SQLError>
fn execute_text( &self, text: &str, params: &[SQLParam], ) -> Result<SQLResult, SQLError>
fn optimize_plan( &self, plan: UnifiedPlan, ) -> Result<SharedExecutablePlan, SQLError>
fn optimize_owned_plan( &self, plan: MutableExecutablePlan, control: &ProductionControl<'_>, ) -> Result<SharedExecutablePlan, SQLError>
fn assertions_enabled(&self) -> bool
Source§fn load_language_library(&self, language: &str)
fn load_language_library(&self, language: &str)
Source§fn with_statement_scope(
&self,
analyze: StatementScopeOperation<'_>,
) -> Result<(), SQLError>
fn with_statement_scope( &self, analyze: StatementScopeOperation<'_>, ) -> Result<(), SQLError>
analyze with the routines and the catalog, namespace and transition relations that a statement the routine runs now is analyzed with.Source§impl RoutineSupportAuthority for Engine
impl RoutineSupportAuthority for Engine
fn current_user_is_superuser(&self) -> bool
Source§impl RoutineTransactions for Engine
impl RoutineTransactions for Engine
Source§impl RoutineTypeCatalog for Engine
impl RoutineTypeCatalog for Engine
Source§fn shell_type_oid(&self, name: &str) -> Result<Option<u32>, SQLError>
fn shell_type_oid(&self, name: &str) -> Result<Option<u32>, SQLError>
fn require_type_oid_usage(&self, oid: u32) -> Result<(), SQLError>
fn try_describe_table( &self, name: &str, ) -> Result<Option<Vec<ColumnDef>>, String>
fn resolve_catalog_column_type(&self, name: &str) -> Option<ColumnType>
fn resolve_catalog_column_type_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<Option<Produced<ColumnType>>, SQLError>
fn resolve_catalog_column_type_name( &self, name: &str, ) -> Result<ColumnType, SQLError>
Source§fn resolve_catalog_column_type_name_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
) -> Result<Produced<ColumnType>, SQLError>
fn resolve_catalog_column_type_name_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<Produced<ColumnType>, SQLError>
fn resolve_catalog_user_type_by_oid(&self, oid: u32) -> Option<ColumnType>
Source§fn format_type(&self, ty: &ColumnType) -> Result<String, SQLError>
fn format_type(&self, ty: &ColumnType) -> Result<String, SQLError>
PostgreSQL’s format_type_be gives a type in messages.fn format_type_with_control( &self, ty: &ColumnType, control: &ProductionControl<'_>, ) -> Result<Produced<String>, SQLError>
Source§fn format_type_oid(&self, oid: u32) -> Result<String, SQLError>
fn format_type_oid(&self, oid: u32) -> Result<String, SQLError>
Source§fn composite_types(&self) -> Option<&dyn CompositeTypeCatalog>
fn composite_types(&self) -> Option<&dyn CompositeTypeCatalog>
Source§fn require_type_usage(&self, ty: &ColumnType) -> Result<(), SQLError>
fn require_type_usage(&self, ty: &ColumnType) -> Result<(), SQLError>
USAGE on a type a routine declares, as crate::FunctionTypeResolver::require_type_usage requires it.Source§impl RoutineValueContext for Engine
impl RoutineValueContext for Engine
fn catalog_column_type_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<Option<Produced<ColumnType>>, SQLError>
fn catalog_column_type(&self, name: &str) -> Option<ColumnType>
Source§impl RowLockReadSource for Engine
impl RowLockReadSource for Engine
Source§impl RowLockSession for Engine
impl RowLockSession for Engine
fn lock_manager(&self) -> Arc<RowLockManager> ⓘ
fn lock_row( &self, table: &str, doc_id: DocId, strength: LockStrength, wait: LockWait, display_name: &str, ) -> Result<LockAcquire, SQLError>
fn uses_fixed_snapshot(&self) -> bool
fn committed_row_successor( &self, table: &str, doc_id: DocId, ) -> Result<RowChangeTarget, SQLError>
fn committed_physical_row_successor( &self, table: &str, doc_id: DocId, ) -> Result<PhysicalRowChangeTarget, SQLError>
fn table_for_lock_hash(&self, table_hash: u64) -> Result<String, SQLError>
Source§impl RuleCatalog for Engine
impl RuleCatalog for Engine
fn relation_has_rules(&self, table: &str) -> Result<bool, SQLError>
fn resolve_rule_relation( &self, table: &str, ) -> Result<RelationIdentity, SQLError>
fn rules_for( &self, table: &str, event: RuleEvent, ) -> Result<Vec<StoredRule>, SQLError>
fn capture_rules( &self, table: &str, event: RuleEvent, ) -> Result<CapturedRules, SQLError>
Source§fn capture_rules_with_control(
&self,
table: &str,
event: RuleEvent,
control: &ProductionControl<'_>,
) -> Result<CapturedRules, SQLError>
fn capture_rules_with_control( &self, table: &str, event: RuleEvent, control: &ProductionControl<'_>, ) -> Result<CapturedRules, SQLError>
fn resolve_mutation_target( &self, name: &str, bound: bool, ) -> Result<String, SQLError>
fn resolve_rule_relation_with_control( &self, table: &str, control: &ProductionControl<'_>, ) -> Result<Produced<RelationIdentity>, SQLError>
fn resolve_mutation_target_with_control( &self, name: &str, bound: bool, control: &ProductionControl<'_>, ) -> Result<Produced<String>, SQLError>
Source§fn visit_rules_with_control(
&self,
table: &str,
event: RuleEvent,
reverse: bool,
control: &ProductionControl<'_>,
visit: &mut dyn FnMut(&StoredRule) -> Result<(), SQLError>,
) -> Result<(), SQLError>
fn visit_rules_with_control( &self, table: &str, event: RuleEvent, reverse: bool, control: &ProductionControl<'_>, visit: &mut dyn FnMut(&StoredRule) -> Result<(), SQLError>, ) -> Result<(), SQLError>
Source§impl RuleInputColumns for Engine
impl RuleInputColumns for Engine
Source§impl RuleSecurity for Engine
impl RuleSecurity for Engine
fn privilege_subject(&self, table: &str) -> Result<RoleReference, SQLError>
fn privilege_subject_with_control( &self, table: &str, control: &ProductionControl<'_>, ) -> Result<Produced<RoleReference>, SQLError>
Source§impl RuleSourceCatalog for Engine
impl RuleSourceCatalog for Engine
fn query_source_columns( &self, name: &str, relations_bound: bool, ) -> Result<Option<Vec<String>>, SQLError>
fn rule_relation_definitions( &self, name: &str, ) -> Result<Vec<ColumnDef>, SQLError>
fn rule_relation_columns_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<Produced<Vec<String>>, SQLError>
Source§fn rule_relation_definitions_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
) -> Result<Produced<Vec<ColumnDef>>, SQLError>
fn rule_relation_definitions_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<Produced<Vec<ColumnDef>>, SQLError>
fn query_source_columns_with_control( &self, name: &str, relations_bound: bool, control: &ProductionControl<'_>, ) -> Result<Option<Produced<Vec<String>>>, SQLError>
Source§impl SQLValueCatalog for Engine
impl SQLValueCatalog for Engine
Source§fn enum_label_uncommitted(&self, label_oid: u32) -> bool
fn enum_label_uncommitted(&self, label_oid: u32) -> bool
Labels added by the outermost transaction to a type it did not create stay unusable until commit.
Source§fn enum_type_name(&self, type_oid: u32) -> Result<Option<String>, SQLError>
fn enum_type_name(&self, type_oid: u32) -> Result<Option<String>, SQLError>
The regtype spelling of an enum, read from the enum registry alone: label errors are raised while catalog restoration holds transaction state, where building the complete catalog projection must not be attempted.
Source§fn compare_range_bounds(
&self,
range_oid: u32,
left: &Value,
right: &Value,
control: &ProductionControl<'_>,
) -> Result<Ordering, SQLError>
fn compare_range_bounds( &self, range_oid: u32, left: &Value, right: &Value, control: &ProductionControl<'_>, ) -> Result<Ordering, SQLError>
Source§fn range_bound_equality_key(
&self,
range_oid: u32,
value: &Value,
control: &ProductionControl<'_>,
) -> Result<Produced<Vec<u8>>, SQLError>
fn range_bound_equality_key( &self, range_oid: u32, value: &Value, control: &ProductionControl<'_>, ) -> Result<Produced<Vec<u8>>, SQLError>
compare_range_bounds returns Equal; an ordinary hash is not an exact key. Execution owns this encoding and any selected normalization.Source§fn value_range_type(
&self,
oid: u32,
) -> Result<Option<Arc<RangeValueDescriptor>>, SQLError>
fn value_range_type( &self, oid: u32, ) -> Result<Option<Arc<RangeValueDescriptor>>, SQLError>
Source§fn value_type_by_oid_with_control(
&self,
oid: u32,
control: &ProductionControl<'_>,
) -> Result<Option<Produced<ColumnType>>, SQLError>
fn value_type_by_oid_with_control( &self, oid: u32, control: &ProductionControl<'_>, ) -> Result<Option<Produced<ColumnType>>, SQLError>
Source§fn value_type_by_oid(&self, oid: u32) -> Result<Option<ColumnType>, SQLError>
fn value_type_by_oid(&self, oid: u32) -> Result<Option<ColumnType>, SQLError>
Source§fn value_type_exists(&self, oid: u32) -> Result<bool, SQLError>
fn value_type_exists(&self, oid: u32) -> Result<bool, SQLError>
Source§fn value_composite_type(
&self,
oid: u32,
) -> Result<Option<Arc<CompositeTypeDescriptor>>, SQLError>
fn value_composite_type( &self, oid: u32, ) -> Result<Option<Arc<CompositeTypeDescriptor>>, SQLError>
fn value_composite_type_with_control( &self, oid: u32, control: &ProductionControl<'_>, ) -> Result<Option<OwnedCompositeTypeDescriptor>, SQLError>
Source§fn enum_type_comparison_states(&self) -> Option<&EnumTypeComparisonStates>
fn enum_type_comparison_states(&self) -> Option<&EnumTypeComparisonStates>
Source§fn enum_label_position(
&self,
label_oid: u32,
) -> Result<Option<(u32, usize)>, SQLError>
fn enum_label_position( &self, label_oid: u32, ) -> Result<Option<(u32, usize)>, SQLError>
Source§fn enum_value_by_oid(
&self,
label_oid: u32,
) -> Result<Option<EnumValue>, SQLError>
fn enum_value_by_oid( &self, label_oid: u32, ) -> Result<Option<EnumValue>, SQLError>
Source§fn enum_type_labels(
&self,
type_oid: u32,
) -> Result<Option<Arc<EnumTypeLabels>>, SQLError>
fn enum_type_labels( &self, type_oid: u32, ) -> Result<Option<Arc<EnumTypeLabels>>, SQLError>
None when the catalog has no such type.Source§fn has_enum_types(&self) -> bool
fn has_enum_types(&self) -> bool
Source§fn value_regtype_output(
&self,
_ty: &ColumnType,
_oid: i64,
) -> Result<Option<String>, SQLError>
fn value_regtype_output( &self, _ty: &ColumnType, _oid: i64, ) -> Result<Option<String>, SQLError>
None retains numeric output.Source§impl ScalarSession for Engine
impl ScalarSession for Engine
Source§impl SchemaDropCatalog for Engine
impl SchemaDropCatalog for Engine
fn schema_security(&self, name: &str) -> Option<BoundSchemaSecurity>
fn current_user_has_role_privileges(&self, role: &RoleIdentity) -> bool
fn schema_is_graph(&self, name: &str) -> Result<bool, String>
Source§impl SchemaDropNotices for Engine
impl SchemaDropNotices for Engine
fn schema_drop_notice(&self, notice: SQLNotice)
Source§impl SchemaExpressionCatalog for Engine
impl SchemaExpressionCatalog for Engine
Source§fn plan_schema_expression(
&self,
expression: &Expr,
columns: &[ColumnDef],
) -> Result<PlannedSchemaExpression, SQLError>
fn plan_schema_expression( &self, expression: &Expr, columns: &[ColumnDef], ) -> Result<PlannedSchemaExpression, SQLError>
fn registered_runtime_function_volatility( &self, name: &str, ) -> Option<FunctionVolatility>
fn schema_expression_columns( &self, table: &str, ) -> Result<Option<Vec<ColumnDef>>, SQLError>
Source§impl SchemaMemberRelocation for Engine
impl SchemaMemberRelocation for Engine
fn relocate_relation( &self, relation: &SchemaRelation, schema: &str, ) -> Result<(), SQLError>
fn relocate_routine( &self, registry_key: &str, schema: &str, ) -> Result<(), SQLError>
fn relocate_type( &self, name: &str, kind: TypeObjectKind, schema: &str, ) -> Result<(), SQLError>
Source§impl SchemaMembers for Engine
impl SchemaMembers for Engine
Source§impl SchemaOwnerTransactions for Engine
impl SchemaOwnerTransactions for Engine
fn with_owner_write( &self, operation: SchemaOwnerWrite<'_>, ) -> Result<SQLResult, SQLError>
Source§impl SchemaPrivilegeCatalog for Engine
impl SchemaPrivilegeCatalog for Engine
fn refresh_namespace_catalog(&self) -> Result<(), SQLError>
fn schemas(&self) -> SchemaRegistryRead<'_>
fn graphs(&self) -> Box<dyn GraphNamespaceRead + '_>
Source§fn temporary_namespace_oids(&self) -> Option<TemporaryNamespaceOids>
fn temporary_namespace_oids(&self) -> Option<TemporaryNamespaceOids>
fn temporary_schema_name(&self) -> String
fn temporary_namespace_allocated(&self) -> bool
Source§impl SchemaPrivilegeNotices for Engine
impl SchemaPrivilegeNotices for Engine
fn schema_privilege_notice(&self, notice: SQLNotice)
Source§impl SchemaPrivilegeRegistry for Engine
impl SchemaPrivilegeRegistry for Engine
fn schemas_read(&self) -> SchemaRegistryRead<'_>
fn schemas_write(&self) -> SchemaRegistryWrite<'_>
Source§impl SchemaReferenceCatalog for Engine
impl SchemaReferenceCatalog for Engine
fn loaded_relation_name( &self, reference: &str, ) -> Result<Option<String>, String>
fn bound_relation_oid(&self, canonical: &str) -> Result<Option<i64>, String>
fn visible_relation_oid(&self, reference: &str) -> Result<Option<i64>, String>
fn sequence_for_binding(&self, reference: &str) -> Result<String, String>
Source§impl SchemaRegistration for Engine
impl SchemaRegistration for Engine
fn register_schema( &self, name: &str, if_not_exists: bool, role_owner: RoleIdentity, tuple: SchemaTupleIdentity, ) -> StorageBackendResult<bool>
Source§impl SchemaRemovalNames for Engine
impl SchemaRemovalNames for Engine
fn graph_tables(&self, schema: &str) -> StorageBackendResult<Vec<String>>
Source§impl SchemaRemovalPublication for Engine
impl SchemaRemovalPublication for Engine
fn drop_graph(&self, name: &str) -> StorageBackendResult<()>
Source§impl SchemaRenamePersistence for Engine
impl SchemaRenamePersistence for Engine
Source§fn save_schema_row(
&self,
name: &str,
security: &BoundSchemaSecurity,
) -> Result<(), SQLError>
fn save_schema_row( &self, name: &str, security: &BoundSchemaSecurity, ) -> Result<(), SQLError>
name.Source§impl SchemaRenameRegistry for Engine
impl SchemaRenameRegistry for Engine
fn schemas_write(&self) -> SchemaRegistryWrite<'_>
fn contains_graph(&self, name: &str) -> bool
fn temporary_schema_name(&self) -> String
Source§impl SchemaRenameTransactions for Engine
impl SchemaRenameTransactions for Engine
fn with_rename_write( &self, operation: SchemaRenameWrite<'_>, ) -> Result<SQLResult, SQLError>
Source§impl SchemaSecurityCatalog for Engine
impl SchemaSecurityCatalog for Engine
fn schema_security(&self, name: &str) -> Option<BoundSchemaSecurity>
Source§impl SchemaSecurityPersistence for Engine
impl SchemaSecurityPersistence for Engine
fn persist_security( &self, name: &str, security: &BoundSchemaSecurity, ) -> Result<(), SQLError>
Source§impl SchemaSecurityPublication for Engine
impl SchemaSecurityPublication for Engine
fn publish_security(&self, name: &str, security: BoundSchemaSecurity)
Source§impl SchemaStatementWriter for Engine
impl SchemaStatementWriter for Engine
Source§impl SchemaWriteTransaction for Engine
impl SchemaWriteTransaction for Engine
fn with_schema_write(&self, write: SchemaWrite<'_>) -> StorageBackendResult<()>
Source§impl SequenceAlterTransactions for Engine
impl SequenceAlterTransactions for Engine
fn with_sequence_write( &self, write: SequenceAlterWrite<'_>, ) -> Result<bool, SQLError>
Source§impl SequenceCommandCatalog for Engine
impl SequenceCommandCatalog for Engine
fn resolve_visible_relation( &self, name: &str, ) -> Result<RelationResolution, SQLError>
fn sequence_persistence( &self, relation: &RelationIdentity, ) -> RelationPersistence
Source§impl SequenceCreationNamespace for Engine
impl SequenceCreationNamespace for Engine
fn refresh_sequences(&self) -> StorageBackendResult<()>
fn relation_exists(&self, name: &str) -> StorageBackendResult<bool>
Source§impl SequenceCreationPublication for Engine
impl SequenceCreationPublication for Engine
Source§fn insert_sequence(
&self,
name: &str,
relation: &RelationIdentity,
state: SequenceState,
persistence: RelationPersistence,
role_owner: RoleIdentity,
catalog_oid: u32,
) -> Result<bool, SQLError>
fn insert_sequence( &self, name: &str, relation: &RelationIdentity, state: SequenceState, persistence: RelationPersistence, role_owner: RoleIdentity, catalog_oid: u32, ) -> Result<bool, SQLError>
pg_class OID reserved for it.Source§impl SequenceCreationTransactions for Engine
impl SequenceCreationTransactions for Engine
fn with_sequence_creation( &self, write: SequenceCreationWrite<'_>, ) -> Result<bool, SQLError>
Source§impl SequenceDefinitionCatalog for Engine
impl SequenceDefinitionCatalog for Engine
fn object_id(&self, relation: &RelationIdentity) -> Option<[u8; 16]>
Source§fn state(
&self,
relation: &RelationIdentity,
) -> Result<Option<SequenceState>, SQLError>
fn state( &self, relation: &RelationIdentity, ) -> Result<Option<SequenceState>, SQLError>
fn owner_target(&self, owner: SequenceOwner) -> Option<(String, String, bool)>
Source§impl SequenceDefinitionPublication for Engine
impl SequenceDefinitionPublication for Engine
fn replace_sequence( &self, name: &str, relation: &RelationIdentity, object_id: [u8; 16], persistence: RelationPersistence, state: SequenceState, invalidate_current_cache: bool, ) -> Result<(), SQLError>
Source§impl SequenceDependencyCatalog for Engine
impl SequenceDependencyCatalog for Engine
fn refresh_tables(&self) -> StorageBackendResult<()>
fn refresh_catalog(&self) -> StorageBackendResult<()>
fn table_entries(&self) -> Vec<(String, Arc<dyn SequenceTableMetadata>)>
fn resolve_table_name(&self, name: &str) -> StorageBackendResult<Option<String>>
fn table( &self, name: &str, ) -> StorageBackendResult<Option<Arc<dyn SequenceTableMetadata>>>
fn foreign_tables(&self) -> ForeignTablesRead<'_>
Source§impl SequenceIntrospectionCatalog for Engine
impl SequenceIntrospectionCatalog for Engine
fn refresh_sequences(&self) -> StorageBackendResult<()>
fn object_ids(&self) -> SequenceObjectIdsRead<'_>
fn states(&self) -> SequenceStatesRead<'_>
fn sequence_state(&self, relation: &RelationIdentity) -> Option<SequenceState>
fn sequence_persistence( &self, relation: &RelationIdentity, ) -> Option<RelationPersistence>
Source§impl SequenceLifecycleCatalog for Engine
impl SequenceLifecycleCatalog for Engine
fn temporary_schema_name(&self) -> String
fn sequence_is_owned(&self, relation: &RelationIdentity) -> bool
fn relation_kind_at(&self, name: &str) -> Result<Option<&'static str>, String>
Source§impl SequenceOwnerCatalog for Engine
impl SequenceOwnerCatalog for Engine
fn resolve_owner_relation( &self, name: &str, ) -> Result<Option<(String, &'static str)>, SQLError>
fn owner_table_columns( &self, canonical: &str, ) -> Result<Option<SequenceOwnerColumns>, SQLError>
fn owner_foreign_columns( &self, relation: &RelationIdentity, ) -> Option<SequenceOwnerColumns>
Source§impl SequenceOwnerNames for Engine
impl SequenceOwnerNames for Engine
fn resolve_sequence_name( &self, name: &str, ) -> StorageBackendResult<Option<String>>
Source§impl SequencePrivilegePublication for Engine
impl SequencePrivilegePublication for Engine
fn prepare_writer(&self) -> Result<(), SQLError>
fn refresh_catalog(&self) -> StorageBackendResult<()>
fn security_write(&self) -> SequenceSecurityWrite<'_>
fn catalog_changed(&self)
fn prepared_relation_changed(&self, relation: &RelationIdentity)
fn notice(&self, notice: SQLNotice)
Source§impl SequencePrivilegeResolution for Engine
impl SequencePrivilegeResolution for Engine
fn visible_relation_kind( &self, reference: &str, ) -> Result<RelationResolution, SQLError>
fn sequence_privilege_oid( &self, oid: i64, ) -> Result<Option<(String, RelationIdentity)>, SQLError>
Source§impl SequenceRemovalInputs for Engine
impl SequenceRemovalInputs for Engine
fn sequence_removal_context(&self) -> SequenceRemovalContext<'_>
Source§impl SequenceRemovalPublication for Engine
impl SequenceRemovalPublication for Engine
Source§impl SequenceRenameCatalog for Engine
impl SequenceRenameCatalog for Engine
fn has_catalog(&self) -> bool
fn rename_sequence_row( &self, source: &str, target: &str, ) -> StorageBackendResult<bool>
Source§impl SequenceRestoreRegistry for Engine
impl SequenceRestoreRegistry for Engine
fn persistence(&self) -> SequencePersistenceRead<'_>
fn install(&self, registry: RestoredSequenceRegistry)
Source§impl SequenceSecurityCatalog for Engine
impl SequenceSecurityCatalog for Engine
fn security_read(&self) -> SequenceSecurityRead<'_>
Source§impl SequenceSecurityPublication for Engine
impl SequenceSecurityPublication for Engine
fn security(&self, relation: &RelationIdentity) -> Option<BoundSequenceSecurity>
fn persist_security( &self, name: &str, relation: &RelationIdentity, security: &BoundSequenceSecurity, ) -> Result<(), SQLError>
fn publish_security( &self, relation: &RelationIdentity, security: BoundSequenceSecurity, )
Source§impl SequenceSnapshotSource for Engine
impl SequenceSnapshotSource for Engine
Source§fn sequence_read_snapshot(&self) -> StorageBackendResult<SequenceReadSnapshot>
fn sequence_read_snapshot(&self) -> StorageBackendResult<SequenceReadSnapshot>
Source§fn sequence_position(
&self,
key: SequencePositionKey,
) -> StorageBackendResult<Option<RecordedSequencePosition>>
fn sequence_position( &self, key: SequencePositionKey, ) -> StorageBackendResult<Option<RecordedSequencePosition>>
Source§impl SequenceStateRename for Engine
impl SequenceStateRename for Engine
fn move_state( &self, source: &RelationIdentity, target: &RelationIdentity, ) -> Result<(), SQLError>
Source§impl SequenceValueRuntime for Engine
impl SequenceValueRuntime for Engine
fn cancellation(&self) -> &CancellationToken
fn states_write(&self) -> SequenceStatesWrite<'_>
fn caches(&self) -> SequenceCachesWrite<'_>
fn session_read(&self) -> Box<dyn SequenceSessionRead + '_>
fn session_write(&self) -> Box<dyn SequenceSessionWrite + '_>
fn current_transaction_is_read_only(&self) -> bool
fn require_sequence_value_durability(&self) -> StorageBackendResult<()>
fn open_nontransactional_sequence_session( &self, ) -> StorageBackendResult<Option<PersistentStorageSession>>
fn prepare_explicit_transaction_writer(&self) -> Result<(), SQLError>
Source§fn sequence_positions(&self) -> Option<&RowLockManager>
fn sequence_positions(&self) -> Option<&RowLockManager>
fn record_nontransactional_sequence_value( &self, definition_generation: [u8; 16], value: NontransactionalSequenceValue, defines_lastval: bool, )
Source§impl SequenceValueTransactions for Engine
impl SequenceValueTransactions for Engine
fn with_value_transaction( &self, operation: SequenceValueOperation<'_>, ) -> Result<i64, SequenceValueError>
fn transaction_lock_mark(&self) -> u32
Source§impl SerializableWrites for Engine
impl SerializableWrites for Engine
fn serializable_session(&self) -> Option<&dyn SerializableSession>
fn serializable_cancellation(&self) -> &CancellationToken
fn serializable_write_object( &self, table: &str, ) -> Result<Option<[u8; 16]>, SQLError>
Source§fn next_catalog_oid(&self) -> Result<u32, SQLError>
fn next_catalog_oid(&self) -> Result<u32, SQLError>
crate::catalog::identity::CatalogOidCounter::next_oid advances it.Source§impl ShellRegistryPublication for Engine
impl ShellRegistryPublication for Engine
fn shell_registry(&self) -> ShellRegistryRead<'_>
fn shell_catalog(&self) -> Option<&dyn CatalogFacade>
fn shell_role_definitions(&self) -> BTreeMap<String, RoleDefinition>
fn publish_shell_definitions(&self, registry: ShellRegistry)
Source§impl StatementAnalysisScopes for Engine
impl StatementAnalysisScopes for Engine
Source§fn planning_control(&self) -> Result<OwnedProductionControl, SQLError>
fn planning_control(&self) -> Result<OwnedProductionControl, SQLError>
Source§fn with_controlled_scope(
&self,
control: &ProductionControl<'_>,
analyze: ControlledStatementAnalysisOperation<'_>,
) -> Result<(), SQLError>
fn with_controlled_scope( &self, control: &ProductionControl<'_>, analyze: ControlledStatementAnalysisOperation<'_>, ) -> Result<(), SQLError>
fn with_scope( &self, analyze: StatementAnalysisOperation<'_>, ) -> Result<(), SQLError>
Source§impl StatementCache for Engine
impl StatementCache for Engine
Source§fn retire_sql_logical_plan(
&self,
sql: &str,
control: &ProductionControl<'_>,
) -> Result<(), SQLError>
fn retire_sql_logical_plan( &self, sql: &str, control: &ProductionControl<'_>, ) -> Result<(), SQLError>
Source§fn cached_sql_analysis(&self, sql: &str) -> Option<AnalyzedStatement>
fn cached_sql_analysis(&self, sql: &str) -> Option<AnalyzedStatement>
fn cache_sql_analysis( &self, sql: &str, analysis: Option<AnalyzedStatement>, control: &ProductionControl<'_>, ) -> Result<(), SQLError>
fn cached_sql_statement(&self, sql: &str) -> Option<CachedStatement>
fn cache_sql_statement( &self, sql: &str, statement: Arc<Statement>, logical_plan: Option<SharedExecutablePlan>, parser: ParserMetadata, control: &ProductionControl<'_>, ) -> Result<(), SQLError>
fn cache_optimized_sql_plan( &self, sql: &str, optimized_plan: SharedExecutablePlan, control: &ProductionControl<'_>, ) -> Result<(), SQLError>
Source§impl StatementControl for Engine
impl StatementControl for Engine
fn transaction_failed(&self) -> bool
fn run_transaction_statement( &self, statement: TransactionStmt, ) -> Result<(), SQLError>
fn set_constraints( &self, requested: &[SetConstraintName], deferred: bool, nested_statement: bool, ) -> Result<(), SQLError>
Source§impl StatementDiagnostics for Engine
impl StatementDiagnostics for Engine
fn diagnostics_control(&self) -> Result<StorageReadControl, SQLError>
fn diagnostics_scope( &self, timing: Option<bool>, io: IOOptions, ) -> Result<DiagnosticsScope, SQLError>
Source§impl StatementEffects for Engine
impl StatementEffects for Engine
fn query_effect_context(&self) -> QueryEffectContext<'_>
Source§impl StatementNotifications for Engine
impl StatementNotifications for Engine
Source§impl StatementOptimizationContexts for Engine
impl StatementOptimizationContexts for Engine
Source§fn production_resources(&self) -> Result<Option<PlanningResources>, SQLError>
fn production_resources(&self) -> Result<Option<PlanningResources>, SQLError>
fn constant_storage( &self, ) -> Result<Option<Arc<dyn ConstantValueStorage>>, SQLError>
Source§fn constant_storage_with_control(
&self,
control: &ProductionControl<'_>,
) -> Result<Option<Arc<dyn ConstantValueStorage>>, SQLError>
fn constant_storage_with_control( &self, control: &ProductionControl<'_>, ) -> Result<Option<Arc<dyn ConstantValueStorage>>, SQLError>
fn builtin_permissions(&self) -> Option<Arc<dyn BuiltinRoutineExecution>>
fn statistics(&self) -> StatementStatisticsContext<'_>
Source§fn builtin_permissions_with_control(
&self,
control: &ProductionControl<'_>,
) -> Result<Option<Arc<dyn BuiltinRoutineExecution>>, SQLError>
fn builtin_permissions_with_control( &self, control: &ProductionControl<'_>, ) -> Result<Option<Arc<dyn BuiltinRoutineExecution>>, SQLError>
fn rule_inputs(&self) -> RuleInputPlanningContext<'_>
fn routine_inlining(&self) -> Option<RoutineInliningContext<'_>>
Source§impl StatementPortals for Engine
impl StatementPortals for Engine
fn in_transaction_block(&self) -> bool
fn ensure_session_portal_available(&self, name: &str) -> Result<(), SQLError>
fn open_pending_session_portal( &self, declaration: SessionPortalDeclaration, ) -> Result<(), SQLError>
fn open_pending_command_session_portal( &self, declaration: SessionPortalCommandDeclaration, ) -> Result<(), SQLError>
fn fetch_session_portal( &self, fetch: &FetchCursorStmt, ) -> Result<SQLResult, SQLError>
fn close_session_portal(&self, name: &str) -> Result<(), SQLError>
fn close_all_session_portals(&self)
Source§impl StatementSettings for Engine
impl StatementSettings for Engine
Source§impl StatementTransactions for Engine
impl StatementTransactions for Engine
fn transaction_depth(&self) -> usize
Source§fn commit_resolution_pending(&self) -> bool
fn commit_resolution_pending(&self) -> bool
fn current_transaction_is_read_only(&self) -> bool
fn mark_transaction_snapshot_set(&self)
Source§fn retain_completed_statement_snapshot(&self)
fn retain_completed_statement_snapshot(&self)
fn abort_after_error(&self, error: SQLError) -> SQLError
fn rollback(&self) -> Result<(), SQLError>
Source§impl StoredColumnCatalog for Engine
impl StoredColumnCatalog for Engine
Source§impl StoredMergeColumnCatalog for Engine
impl StoredMergeColumnCatalog for Engine
Source§impl StoredQuerySequences for Engine
impl StoredQuerySequences for Engine
Source§impl StoredRelationCatalog for Engine
impl StoredRelationCatalog for Engine
fn resolve_age_label_relation_name( &self, reference: &str, ) -> Result<Option<String>, SQLError>
fn resolve_visible_relation_kind( &self, reference: &str, ) -> Result<RelationResolution, SQLError>
fn resolve_loaded_visible_relation_kind( &self, reference: &str, ) -> Result<RelationResolution, SQLError>
fn resolve_bound_relation_kind( &self, reference: &str, ) -> Result<RelationResolution, SQLError>
fn resolve_visible_relation_kind_with_control( &self, reference: &str, control: &ProductionControl<'_>, ) -> Result<Produced<RelationResolution>, SQLError>
fn resolve_loaded_visible_relation_kind_with_control( &self, reference: &str, control: &ProductionControl<'_>, ) -> Result<Produced<RelationResolution>, SQLError>
fn resolve_bound_relation_kind_with_control( &self, reference: &str, control: &ProductionControl<'_>, ) -> Result<Produced<RelationResolution>, SQLError>
fn resolve_age_label_relation_name_with_control( &self, reference: &str, control: &ProductionControl<'_>, ) -> Result<Option<Produced<String>>, SQLError>
Source§impl StoredSequenceNames for Engine
impl StoredSequenceNames for Engine
Source§impl StoredSequenceRegistry for Engine
impl StoredSequenceRegistry for Engine
fn visit_sequence_names_with_control( &self, control: &ProductionControl<'_>, visit: &mut dyn FnMut(&RelationIdentity) -> Result<(), SQLError>, ) -> Result<(), SQLError>
fn contains_sequence(&self, relation: &RelationIdentity) -> bool
fn sequence_names(&self) -> Vec<RelationIdentity>
Source§impl StoredSourceCatalog for Engine
impl StoredSourceCatalog for Engine
fn stored_source_columns(&self) -> StoredSourceColumns
Source§impl StoredTableNames for Engine
impl StoredTableNames for Engine
fn stored_table_exists(&self, relation: &RelationIdentity) -> bool
fn stored_table_names(&self) -> Vec<RelationIdentity>
Source§impl SystemRelationSecurityCatalog for Engine
impl SystemRelationSecurityCatalog for Engine
fn system_relation_securities(&self) -> SystemRelationSecurityRead<'_>
fn system_relation_security( &self, relation: SystemRelation, ) -> BoundTableSecurity
Source§impl SystemRelationSecurityState for Engine
impl SystemRelationSecurityState for Engine
fn system_relation_securities_write( &self, ) -> Box<dyn DerefMut<Target = SystemRelationSecurities> + '_>
Source§impl TableAlterSession for Engine
impl TableAlterSession for Engine
fn in_transaction_block(&self) -> bool
Source§impl TableAsNamespace for Engine
impl TableAsNamespace for Engine
Source§impl TableAsPublication for Engine
impl TableAsPublication for Engine
fn create_relation( &self, name: &str, persistence: RelationPersistence, on_commit: OnCommitAction, owner: &RoleBinding, ) -> Result<(), SQLError>
fn create_vector_field( &self, name: &str, column: &str, dimensions: u32, ) -> Result<bool, SQLError>
fn publish_columns( &self, name: &str, columns: &[ColumnDef], ) -> Result<(), SQLError>
fn insert_document( &self, table: &str, id: DocId, document: Document, vectors: DocumentVectors, ) -> Result<(), SQLError>
Source§impl TableAsQuerySource for Engine
impl TableAsQuerySource for Engine
Source§impl TableCreationNamespace for Engine
impl TableCreationNamespace for Engine
Source§impl TableCreationPublication for Engine
impl TableCreationPublication for Engine
Source§fn create_table(
&self,
name: &str,
persistence: RelationPersistence,
on_commit: OnCommitAction,
owner: &RoleBinding,
catalog_oids: RelationCatalogOids,
) -> StorageBackendResult<()>
fn create_table( &self, name: &str, persistence: RelationPersistence, on_commit: OnCommitAction, owner: &RoleBinding, catalog_oids: RelationCatalogOids, ) -> StorageBackendResult<()>
CREATE TABLE allocated for it where heap_create_with_catalog allocates them.fn create_vector_field( &self, table: &str, field: String, dimensions: u32, ) -> StorageBackendResult<bool>
fn install_hierarchy( &self, table: &str, hierarchy: TableHierarchy, ) -> StorageBackendResult<()>
Source§fn validate_default_partition_rows(
&self,
parent: &str,
bound: &PartitionBound,
) -> Result<(), SQLError>
fn validate_default_partition_rows( &self, parent: &str, bound: &PartitionBound, ) -> Result<(), SQLError>
fn persist_schema(&self, table: &str) -> StorageBackendResult<bool>
fn refresh_value_indexes(&self, table: &str) -> StorageBackendResult<()>
Source§impl TableCreationTransactions for Engine
impl TableCreationTransactions for Engine
fn with_new_table_transaction( &self, write: TableCreationWrite<'_>, ) -> Result<SQLResult, SQLError>
Source§impl TableEventLifecycle for Engine
impl TableEventLifecycle for Engine
fn rename_trigger( &self, table: &str, from: &str, to: &str, ) -> Result<(), SQLError>
fn rename_trigger_constraint( &self, table: &str, from: &str, to: &str, ) -> Result<(), SQLError>
fn rename_rule(&self, table: &str, from: &str, to: &str) -> Result<(), SQLError>
fn set_trigger_enable_mode( &self, table: &str, name: Option<&str>, mode: EventEnableMode, ) -> Result<(), SQLError>
fn set_rule_enable_mode( &self, table: &str, name: &str, mode: EventEnableMode, ) -> Result<(), SQLError>
Source§impl TableFunctionSession for Engine
impl TableFunctionSession for Engine
Source§impl TableGrantInputs for Engine
impl TableGrantInputs for Engine
fn table_grant_context(&self) -> TableGrantContext<'_>
Source§impl TableGrantPersistence for Engine
impl TableGrantPersistence for Engine
fn persist_relation_acl( &self, relation: &RelationIdentity, column: Option<&str>, entry: &RelationAclTuple, ) -> StorageBackendResult<()>
Source§impl TableGrantRegistry for Engine
impl TableGrantRegistry for Engine
fn tables(&self) -> Box<dyn TableGrantRead<'_> + '_>
Source§impl TableGrantResolution for Engine
impl TableGrantResolution for Engine
fn resolve_visible_relation_kind( &self, name: &str, ) -> Result<RelationResolution, SQLError>
Source§impl TableLifecycle for Engine
impl TableLifecycle for Engine
fn rename_table(&self, from: &str, to: &str) -> StorageBackendResult<bool>
fn rename_column( &self, table: &str, from: &str, to: &str, ) -> StorageBackendResult<bool>
Source§impl TableLockCatalog for Engine
impl TableLockCatalog for Engine
fn resolve( &self, name: &str, bound: bool, ) -> Result<RelationResolution, SQLError>
fn table( &self, name: &str, _roles: &BTreeMap<String, RoleDefinition>, ) -> Result<Option<TableLockMetadata>, SQLError>
fn view(&self, name: &str) -> Result<Option<StoredView>, SQLError>
fn descendants(&self, name: &str) -> Result<Vec<String>, SQLError>
Source§impl TableLockSession for Engine
impl TableLockSession for Engine
fn in_transaction_block(&self) -> bool
fn current_role(&self) -> RoleReference
Source§impl TableOwnerPublication for Engine
impl TableOwnerPublication for Engine
fn sequence_security_write(&self) -> OwnedSequenceSecurityWrite<'_>
Source§impl TableOwnerRegistry for Engine
impl TableOwnerRegistry for Engine
fn table( &self, relation: &RelationIdentity, ) -> Option<Box<dyn TableOwnerState + '_>>
Source§impl TablePrivilegeRegistry for Engine
impl TablePrivilegeRegistry for Engine
fn refresh_tables(&self) -> StorageBackendResult<()>
fn refresh_catalog(&self) -> StorageBackendResult<()>
Source§fn retained_table_with_control(
&self,
relation: &RelationIdentity,
control: &ProductionControl<'_>,
) -> Result<Option<Arc<dyn TablePrivilegeState>>, SQLError>
fn retained_table_with_control( &self, relation: &RelationIdentity, control: &ProductionControl<'_>, ) -> Result<Option<Arc<dyn TablePrivilegeState>>, SQLError>
fn tables(&self) -> Box<dyn TablePrivilegeRead + '_>
fn views(&self) -> PrivilegeViewsRead<'_>
fn foreign_tables(&self) -> PrivilegeForeignTablesRead<'_>
fn foreign_security(&self) -> PrivilegeForeignSecurityRead<'_>
Source§impl TableRemovalCatalog for Engine
impl TableRemovalCatalog for Engine
fn contains_relation(&self, relation: &RelationIdentity) -> bool
Source§impl TableRemovalPublication for Engine
impl TableRemovalPublication for Engine
fn prune_constraint_modes(&self) -> Result<(), SQLError>
fn remove_state( &self, name: &str, relation: &RelationIdentity, ) -> StorageBackendResult<()>
Source§impl TableSchemaCatalog for Engine
impl TableSchemaCatalog for Engine
fn resolve_table_name(&self, name: &str) -> StorageBackendResult<Option<String>>
fn table_state( &self, canonical: &str, ) -> StorageBackendResult<Option<Box<dyn TableSchemaState + '_>>>
Source§impl TemporaryRoleDependencyCatalog for Engine
impl TemporaryRoleDependencyCatalog for Engine
fn foreign_table_persistence(&self) -> Box<dyn RoleForeignPersistenceRead + '_>
fn temporary_namespace_allocated(&self) -> bool
fn sequence_persistence( &self, ) -> RoleDependencyRead<'_, BTreeMap<RelationIdentity, RelationPersistence>>
Source§impl TextMatchCatalog for Engine
impl TextMatchCatalog for Engine
Source§impl TextRetrieval for Engine
impl TextRetrieval for Engine
fn bayesian_params( &self, table: &str, field: &str, ) -> Result<BayesianBM25Params, SQLError>
fn search( &self, table: &str, field: &str, query: &str, mode: &ScoringMode, top_k: usize, ) -> Result<Vec<ScoredEntry>, SQLError>
Source§impl TrainedModels for Engine
impl TrainedModels for Engine
Source§impl TrainingTables for Engine
impl TrainingTables for Engine
fn training_table( &self, name: &str, ) -> StorageBackendResult<Option<Box<dyn TrainingTable + '_>>>
fn training_documents( &self, table: &str, doc_ids: &[DocId], projection: &[String], ) -> Result<BTreeMap<DocId, Document>, SQLError>
Source§impl TriggerCatalog for Engine
impl TriggerCatalog for Engine
fn has_row_triggers( &self, table: &str, event: TriggerEvent, ) -> Result<bool, SQLError>
fn trigger_relation_definitions( &self, table: &str, ) -> Result<Vec<ColumnDef>, SQLError>
fn triggers_for( &self, table: &str, timing: TriggerTiming, event: TriggerEvent, row: bool, updated_columns: &[String], ) -> Result<Vec<StoredTrigger>, SQLError>
Source§fn row_trigger_definitions(
&self,
table: &str,
timing: TriggerTiming,
event: TriggerEvent,
updated_columns: Option<&[String]>,
) -> Result<Vec<StoredTrigger>, SQLError>
fn row_trigger_definitions( &self, table: &str, timing: TriggerTiming, event: TriggerEvent, updated_columns: Option<&[String]>, ) -> Result<Vec<StoredTrigger>, SQLError>
table for a timing and an event, whatever replication role fires them. None includes every UPDATE column restriction; a statement resolves definitions once and applies the role at each firing.fn has_trigger_definition( &self, table: &str, timing: TriggerTiming, event: TriggerEvent, row: bool, ) -> Result<bool, SQLError>
fn hierarchy_scan_tables( &self, table: &str, descendants: bool, ) -> Result<Vec<String>, SQLError>
fn rule_relation_columns( &self, table: &str, ) -> Result<Vec<(String, ColumnType)>, SQLError>
Source§impl TriggerRoutineInvoker for Engine
impl TriggerRoutineInvoker for Engine
fn resolve_bound_trigger_function( &self, name: &str, object_id: Option<[u8; 16]>, ) -> Result<Arc<SQLUserFunction>, SQLError>
fn execute_trigger_routine( &self, function: &Arc<SQLUserFunction>, context: &TriggerRoutineContext, ) -> Result<Value, SQLError>
Source§impl TruncateAccess for Engine
impl TruncateAccess for Engine
Source§impl TruncateCatalog for Engine
impl TruncateCatalog for Engine
fn try_resolve_visible_relation_kind( &self, name: &str, ) -> Result<Option<(String, &'static str)>, SQLError>
fn is_partitioned(&self, table: &str) -> Result<bool, String>
fn hierarchy_scan_tables( &self, table: &str, descendants: bool, ) -> Result<Vec<String>, SQLError>
fn referrers_to(&self, table: &str) -> Result<Vec<String>, String>
Source§impl TruncateStorage for Engine
impl TruncateStorage for Engine
Source§impl TruncateTransactions for Engine
impl TruncateTransactions for Engine
fn transaction_depth(&self) -> usize
fn with_transaction(&self, operation: TruncateWrite<'_>) -> Result<(), SQLError>
Source§impl TruncateTriggers for Engine
impl TruncateTriggers for Engine
Source§impl TypeObjectAuthority for Engine
impl TypeObjectAuthority for Engine
fn schema_usage(&self, schema: &str, role: &RoleReference) -> bool
fn current_user_has_role_privileges(&self, role: &dyn RoleSubject) -> bool
Source§impl TypeObjectCatalog for Engine
impl TypeObjectCatalog for Engine
Source§fn temporary_schema(&self) -> Option<String>
fn temporary_schema(&self) -> Option<String>
fn shell_by_type_oid(&self, oid: u32) -> Option<StoredShellType>
fn schema_security(&self, name: &str) -> Option<BoundSchemaSecurity>
fn resolve_drop_type_oid(&self, name: &str) -> Result<Option<i64>, SQLError>
fn format_drop_type(&self, oid: i64) -> Result<Option<String>, String>
Source§fn enum_by_type_oid(&self, oid: u32) -> Option<StoredEnum>
fn enum_by_type_oid(&self, oid: u32) -> Option<StoredEnum>
Source§fn composite_by_type_oid(&self, oid: u32) -> Option<StoredComposite>
fn composite_by_type_oid(&self, oid: u32) -> Option<StoredComposite>
Source§fn user_array_element(&self, oid: u32) -> Option<u32>
fn user_array_element(&self, oid: u32) -> Option<u32>
Source§fn row_type_relation(&self, oid: u32) -> Option<RowTypeRelation>
fn row_type_relation(&self, oid: u32) -> Option<RowTypeRelation>
Source§impl TypeReferenceDependents for Engine
impl TypeReferenceDependents for Engine
fn rewrite_type_references( &self, oid: u32, identity: &RelationIdentity, ) -> Result<(), SQLError>
Source§impl VacuumCatalog for Engine
impl VacuumCatalog for Engine
Source§impl VacuumLocks for Engine
impl VacuumLocks for Engine
fn lock_exclusive(&self, table: &str) -> Result<(), SQLError>
fn release_session(&self)
Source§impl VacuumPrivileges for Engine
impl VacuumPrivileges for Engine
Source§impl VacuumRelations for Engine
impl VacuumRelations for Engine
Source§impl VacuumRows for Engine
impl VacuumRows for Engine
fn restore_document( &self, table: &str, id: DocId, document: StoredDocument, vectors: DocumentVectors, ) -> Result<(), SQLError>
fn refresh_indexes(&self, table: &str) -> StorageBackendResult<()>
fn note_table_data_changed(&self)
Source§impl VacuumStatisticsRefresh for Engine
impl VacuumStatisticsRefresh for Engine
Source§impl VacuumStorage for Engine
impl VacuumStorage for Engine
fn reclaim_obsolete(&self) -> StorageBackendResult<()>
fn vacuum(&self) -> StorageBackendResult<()>
fn clear_btree_indexes(&self, table: &str) -> StorageBackendResult<()>
Source§impl VacuumTransactions for Engine
impl VacuumTransactions for Engine
fn depth(&self) -> usize
fn with_maintenance_write( &self, write: VacuumWrite<'_>, ) -> StorageBackendResult<()>
Source§impl ValueRestorationSession for Engine
impl ValueRestorationSession for Engine
fn index_build_context(&self) -> IndexBuildContext<'_>
fn rebuild_value_indexes_and_refresh_statistics( &self, table: &str, ) -> StorageBackendResult<()>
Source§impl VectorIndexCatalog for Engine
impl VectorIndexCatalog for Engine
Source§impl VectorPoolRetrieval for Engine
impl VectorPoolRetrieval for Engine
fn query_pool( &self, table: &str, field: &str, query_vector: &[f32], k: usize, diagnostics: Option<&CapturedDiagnostics>, ) -> Result<Vec<ScoredEntry>, SQLError>
Source§impl ViewAlterAccess for Engine
impl ViewAlterAccess for Engine
fn ensure_owner( &self, name: &str, view: &StoredView, ) -> Result<String, SQLError>
Source§impl ViewAlterCatalog for Engine
impl ViewAlterCatalog for Engine
fn view(&self, relation: &RelationIdentity) -> Option<StoredView>
fn persistence( &self, relation: &RelationIdentity, ) -> Option<RelationPersistence>
Source§impl ViewAlterPublication for Engine
impl ViewAlterPublication for Engine
fn persist_rename( &self, from: &RelationIdentity, to: &RelationIdentity, ) -> StorageBackendResult<Option<bool>>
Source§impl ViewAlterTransactions for Engine
impl ViewAlterTransactions for Engine
fn with_view_write(&self, write: ViewAlterWrite<'_>) -> Result<(), SQLError>
Source§impl ViewCatalogCapabilities for Engine
impl ViewCatalogCapabilities for Engine
fn view_updatability_with_catalog( &self, name: &str, catalog: &CatalogReadView, resolution: &RelationNameResolution, ) -> Result<ViewCatalogMetadata, SQLError>
fn has_instead_of_trigger_with_catalog( &self, name: &str, event: TriggerEvent, catalog: &CatalogReadView, resolution: &RelationNameResolution, ) -> Result<bool, SQLError>
fn view_updatability(&self, name: &str) -> Result<ViewCatalogMetadata, SQLError>
fn has_instead_of_trigger( &self, name: &str, event: TriggerEvent, ) -> Result<bool, SQLError>
Source§impl ViewCatalogPublication for Engine
impl ViewCatalogPublication for Engine
fn synchronize_catalog(&self) -> StorageBackendResult<()>
fn view_definitions(&self) -> ViewDefinitionsRead<'_>
fn has_catalog(&self) -> bool
fn save_view_row(&self, row: &ViewRow) -> StorageBackendResult<()>
fn publish_views(&self, updates: Vec<(RelationIdentity, StoredView)>)
Source§impl ViewColumnRenameInputs for Engine
impl ViewColumnRenameInputs for Engine
fn view_column_rename_context(&self) -> ViewColumnRenameContext<'_>
Source§impl ViewCreationCatalog for Engine
impl ViewCreationCatalog for Engine
fn synchronize(&self) -> StorageBackendResult<()>
Source§impl ViewCreationTransactions for Engine
impl ViewCreationTransactions for Engine
fn explain_existing_target( &self, name: &str, if_not_exists: bool, ) -> Result<bool, SQLError>
fn with_view_creation( &self, write: ViewCreationWrite<'_>, ) -> Result<(), SQLError>
fn with_materialized_view_creation( &self, write: MaterializedViewWrite<'_>, ) -> Result<Option<u64>, SQLError>
Source§impl ViewIdentityAllocation for Engine
impl ViewIdentityAllocation for Engine
fn allocate_identity(&self) -> StorageBackendResult<[u8; 16]>
Source§impl ViewPlanBinding for Engine
impl ViewPlanBinding for Engine
fn lock_relations(&self, plan: &QueryPlan) -> Result<(), SQLError>
fn bind_relations(&self, plan: &mut QueryPlan) -> Result<bool, SQLError>
fn bind_routines( &self, plan: &mut QueryPlan, params: &[SQLParam], ) -> Result<RowSchema, SQLError>
Source§impl ViewPrivilegeCatalog for Engine
impl ViewPrivilegeCatalog for Engine
Source§fn with_view_definition_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
read: &mut dyn FnMut(Option<&StoredView>) -> Result<(), SQLError>,
) -> Result<(), SQLError>
fn with_view_definition_with_control( &self, name: &str, control: &ProductionControl<'_>, read: &mut dyn FnMut(Option<&StoredView>) -> Result<(), SQLError>, ) -> Result<(), SQLError>
fn ensure_query_select_with_control( &self, query: &QueryPlan, control: &ProductionControl<'_>, ) -> Result<(), SQLError>
fn bound_role_with_control( &self, identity: RoleIdentity, control: &ProductionControl<'_>, ) -> Result<Produced<RoleReference>, SQLError>
fn ensure_query_select(&self, query: &QueryPlan) -> Result<(), SQLError>
fn view_definition(&self, name: &str) -> Result<Option<StoredView>, SQLError>
fn current_role(&self) -> RoleReference
fn bound_role(&self, identity: RoleIdentity) -> Result<RoleReference, SQLError>
fn ensure_view_privilege_for_with_control( &self, name: &str, view: &StoredView, subject: &RoleReference, privilege: TableAclPrivilege, control: &ProductionControl<'_>, ) -> Result<(), SQLError>
fn ensure_view_column_privilege_for_with_control( &self, name: &str, view: &StoredView, column: &str, subject: &RoleReference, privilege: TableAclPrivilege, control: &ProductionControl<'_>, ) -> Result<(), SQLError>
fn ensure_any_view_column_privilege_for_with_control( &self, name: &str, view: &StoredView, subject: &RoleReference, privilege: TableAclPrivilege, control: &ProductionControl<'_>, ) -> Result<(), SQLError>
fn ensure_view_privilege_for( &self, name: &str, view: &StoredView, subject: &RoleReference, privilege: TableAclPrivilege, ) -> Result<(), SQLError>
fn ensure_view_column_privilege_for( &self, name: &str, view: &StoredView, column: &str, subject: &RoleReference, privilege: TableAclPrivilege, ) -> Result<(), SQLError>
fn ensure_any_view_column_privilege_for( &self, name: &str, view: &StoredView, subject: &RoleReference, privilege: TableAclPrivilege, ) -> Result<(), SQLError>
fn ensure_target_select( &self, request: TargetSelectPrivilegeRequest<'_, '_>, ) -> Result<(), SQLError>
fn ensure_target_select_with_control( &self, request: TargetSelectPrivilegeRequest<'_, '_>, control: &ProductionControl<'_>, ) -> Result<(), SQLError>
fn current_role_with_control( &self, control: &ProductionControl<'_>, ) -> Result<Produced<RoleReference>, SQLError>
Source§impl ViewPublication for Engine
impl ViewPublication for Engine
fn has_catalog(&self) -> bool
fn save_view(&self, row: &ViewRow) -> StorageBackendResult<()>
Source§fn save_view_representation(&self, row: &ViewRow) -> StorageBackendResult<()>
fn save_view_representation(&self, row: &ViewRow) -> StorageBackendResult<()>
save_view.Source§impl ViewQueryOwners for Engine
impl ViewQueryOwners for Engine
fn with_owner( &self, owner: &RoleReference, operation: ViewOwnerQuery<'_>, ) -> Result<SQLResult, SQLError>
Source§impl ViewRegistryState for Engine
impl ViewRegistryState for Engine
fn views_read(&self) -> ViewRegistryRead<'_>
fn views_write(&self) -> ViewRegistryWrite<'_>
Source§impl ViewRemovalEvents for Engine
impl ViewRemovalEvents for Engine
fn drop_relation_events_inner( &self, relation: &RelationIdentity, ) -> StorageBackendResult<()>
Source§impl ViewRemovalPublication for Engine
impl ViewRemovalPublication for Engine
fn drop_view( &self, relation: &RelationIdentity, object: Option<[u8; 16]>, ) -> StorageBackendResult<Option<bool>>
Source§impl ViewRestoreNamespace for Engine
impl ViewRestoreNamespace for Engine
fn tables(&self) -> Box<dyn ViewRestoreTableNames + '_>
fn foreign_tables(&self) -> ViewRestoreForeignRead<'_>
fn graphs(&self) -> ViewRestoreGraphsRead<'_>
Source§impl ViewRestoreSchemas for Engine
impl ViewRestoreSchemas for Engine
fn stored_schema(&self, view: &StoredView) -> Result<RowSchema, SQLError>
Source§impl ViewRestoreSequences for Engine
impl ViewRestoreSequences for Engine
fn resolve_loaded(&self, reference: &str) -> StorageBackendResult<String>
Source§impl ViewRewriteCatalog for Engine
impl ViewRewriteCatalog for Engine
Source§fn visit_table_column_names_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
read: &mut dyn FnMut(&str) -> Result<(), SQLError>,
) -> Result<(), SQLError>
fn visit_table_column_names_with_control( &self, name: &str, control: &ProductionControl<'_>, read: &mut dyn FnMut(&str) -> Result<(), SQLError>, ) -> Result<(), SQLError>
fn capture_rules( &self, name: &str, event: RuleEvent, ) -> Result<CapturedRules, SQLError>
fn capture_rules_with_control( &self, name: &str, event: RuleEvent, control: &ProductionControl<'_>, ) -> Result<CapturedRules, SQLError>
Source§fn with_view_definition_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
read: &mut dyn FnMut(Option<ViewRewriteDefinitionRef<'_>>) -> Result<(), SQLError>,
) -> Result<(), SQLError>
fn with_view_definition_with_control( &self, name: &str, control: &ProductionControl<'_>, read: &mut dyn FnMut(Option<ViewRewriteDefinitionRef<'_>>) -> Result<(), SQLError>, ) -> Result<(), SQLError>
fn try_resolve_view_name_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<Option<Produced<String>>, SQLError>
fn visit_rules_with_control( &self, name: &str, event: RuleEvent, reverse: bool, control: &ProductionControl<'_>, visit: &mut dyn FnMut(&StoredRule) -> Result<(), SQLError>, ) -> Result<(), SQLError>
fn target_view_kind_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<Option<StoredViewKind>, SQLError>
fn has_trigger_definition_with_control( &self, name: &str, timing: TriggerTiming, event: TriggerEvent, row: bool, control: &ProductionControl<'_>, ) -> Result<bool, SQLError>
fn binding_scope_with_control( &self, control: &ProductionControl<'_>, ) -> Result<ControlledBindingSnapshot, SQLError>
fn restored_view_scope_with_control( &self, control: &ProductionControl<'_>, ) -> Result<ControlledBindingContext<'static>, SQLError>
fn view_definition( &self, name: &str, ) -> Result<Option<ViewRewriteDefinition>, SQLError>
fn try_resolve_view_name(&self, name: &str) -> Result<Option<String>, String>
fn try_describe_table( &self, name: &str, ) -> Result<Option<Vec<ColumnDef>>, String>
fn try_table_columns(&self, name: &str) -> Result<Vec<String>, String>
fn rules_for( &self, name: &str, event: RuleEvent, ) -> Result<Vec<StoredRule>, SQLError>
fn rule_definitions_for( &self, name: &str, event: RuleEvent, ) -> Result<Vec<StoredRule>, SQLError>
fn has_trigger_definition( &self, name: &str, timing: TriggerTiming, event: TriggerEvent, row: bool, ) -> Result<bool, SQLError>
fn rule_new_row_columns( &self, rule: &StoredRule, ) -> Result<Option<BTreeSet<String>>, SQLError>
fn rule_new_row_columns_with_control( &self, rule: &StoredRule, control: &ProductionControl<'_>, ) -> Result<Option<Produced<Vec<String>>>, SQLError>
fn target_view_kind( &self, name: &str, ) -> Result<Option<StoredViewKind>, SQLError>
fn binding_scope(&self) -> Result<BindingSnapshot, SQLError>
fn restored_view_catalog(&self) -> (CatalogReadView, RelationNameResolution)
Source§fn try_table_column_names_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
) -> Result<Produced<Vec<String>>, SQLError>
fn try_table_column_names_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<Produced<Vec<String>>, SQLError>
fn try_relation_column_names_with_control( &self, name: &str, control: &ProductionControl<'_>, ) -> Result<Option<Produced<Vec<String>>>, SQLError>
Source§impl VolatilityCatalog for Engine
impl VolatilityCatalog for Engine
fn host_function_volatility(&self, name: &str) -> Option<FunctionVolatility>
Source§fn routine_volatility_with_control(
&self,
name: &str,
binding: Option<&FunctionBinding>,
control: &ProductionControl<'_>,
) -> Result<Option<FunctionVolatility>, SQLError>
fn routine_volatility_with_control( &self, name: &str, binding: Option<&FunctionBinding>, control: &ProductionControl<'_>, ) -> Result<Option<FunctionVolatility>, SQLError>
fn routine_volatilities( &self, name: &str, binding: Option<&FunctionBinding>, ) -> Option<Vec<FunctionVolatility>>
fn view_query(&self, name: &str) -> Result<Option<QueryPlan>, SQLError>
Source§fn with_view_query(
&self,
name: &str,
read: &mut dyn FnMut(&QueryPlan) -> Result<bool, SQLError>,
) -> Result<Option<bool>, SQLError>
fn with_view_query( &self, name: &str, read: &mut dyn FnMut(&QueryPlan) -> Result<bool, SQLError>, ) -> Result<Option<bool>, SQLError>
Source§fn with_view_query_with_control(
&self,
name: &str,
control: &ProductionControl<'_>,
read: &mut dyn FnMut(&QueryPlan) -> Result<bool, SQLError>,
) -> Result<Option<bool>, SQLError>
fn with_view_query_with_control( &self, name: &str, control: &ProductionControl<'_>, read: &mut dyn FnMut(&QueryPlan) -> Result<bool, SQLError>, ) -> Result<Option<bool>, SQLError>
Auto Trait Implementations§
impl !Freeze for Engine
impl !RefUnwindSafe for Engine
impl !UnwindSafe for Engine
impl Send for Engine
impl Sync for Engine
impl Unpin for Engine
impl UnsafeUnpin for Engine
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
impl<T> ErasedDestructor for Twhere
T: 'static,
Source§impl<T> IntoEither for T
impl<T> IntoEither for T
Source§fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left is true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read moreSource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
self into a Left variant of Either<Self, Self>
if into_left(&self) returns true.
Converts self into a Right variant of Either<Self, Self>
otherwise. Read more