Struct QueryCore 

pub struct QueryCore {
    pub table: String,
    pub model_type: Option<String>,
    pub projection: Option<Vec<String>>,
    pub where_clauses: Vec<WhereClause>,
    pub order_by: Vec<OrderBy>,
    pub limit: Option<u32>,
    pub offset: Option<u32>,
    pub search_fields: Vec<String>,
    pub search_term: Option<String>,
    pub hop_source: Option<HopSource>,
    pub or_groups: Vec<Vec<WhereClause>>,
    pub group_by: Vec<String>,
}

Core query builder that compiles per registered engine.

Fields

table: String

model_type: Option<String>

projection: Option<Vec<String>>

where_clauses: Vec<WhereClause>

order_by: Vec<OrderBy>

limit: Option<u32>

offset: Option<u32>

search_fields: Vec<String>

search_term: Option<String>

hop_source: Option<HopSource>

Previous hop in the chain. None for root queries, Some for hopped queries.

or_groups: Vec<Vec<WhereClause>>

OR-combined clause groups for union queries.

group_by: Vec<String>

GROUP BY fields for distinct/aggregation queries.

Implementations

impl QueryCore

pub fn new(table: String) -> QueryCore

Create a new query core for a table

pub fn with_model_type( table: impl Into<String>, model_type: impl Into<String>, ) -> QueryCore

Create a QueryCore with model type information

impl QueryCore

pub fn where_int(self, field: String, predicate: IntPredicate) -> QueryCore

Add a WHERE clause for an integer field

pub fn where_string( self, field: String, predicate: StringPredicate, ) -> QueryCore

Add a WHERE clause for a string field

pub fn where_datetime( self, field: String, predicate: DateTimePredicate, ) -> QueryCore

Add a WHERE clause for a datetime field

pub fn where_record( self, field: String, predicate: RecordPredicate, ) -> QueryCore

Add a WHERE clause for a record field

pub fn where_null(self, field: String, predicate: NullPredicate) -> QueryCore

Add a WHERE clause for null/not-null check on optional fields

pub fn where_connection_exists( self, from_field: String, to_table: String, subquery: QueryCore, ) -> QueryCore

Add a correlated semi-join (SurrealQL SELECT … LIMIT 1 with $parent, not SQL EXISTS).

pub fn where_connection_exists_reverse( self, to_table: String, reverse_field: String, subquery: QueryCore, ) -> QueryCore

Correlated semi-join for reverse/HasMany: to_table rows with reverse_field = $parent.id.

pub fn where_connection_exists_many_to_many( self, edge_table: String, to_table: String, subquery: QueryCore, ) -> QueryCore

Semi-join filter for ManyToMany connections.

pub fn where_connection_contains_many_to_many( self, edge_table: String, target: RecordId, ) -> QueryCore

Add a direct edge-membership filter for ManyToMany connections.

impl QueryCore

pub fn order_by(self, field: String, direction: SortDirection) -> QueryCore

Add an ORDER BY clause

pub fn group_by(self, field: String) -> QueryCore

Add a GROUP BY field

pub fn limit(self, limit: u32) -> QueryCore

Set the LIMIT

pub fn offset(self, offset: u32) -> QueryCore

Set the OFFSET

pub fn set_search_fields(self, fields: Vec<String>) -> QueryCore

Set search fields for full-text search

pub fn search(self, term: String) -> QueryCore

Add a search term (expands to OR clause across search_fields)

impl QueryCore

pub fn union_with(self, other: QueryCore) -> QueryCore

OR-combine another query’s WHERE conditions with this one.

pub fn join_with(self, other: QueryCore) -> QueryCore

AND-combine another query’s WHERE conditions with this one.

impl QueryCore

pub async fn execute<T>(self, valence: &Valence) -> Result<Vec<T>, Error>

where T: DeserializeOwned + Serialize,

Compile the query for the active backend and execute it

pub async fn distinct_values( self, field: &str, valence: &Valence, ) -> Result<Vec<String>, Error>

Execute as a distinct-value query, returning a flat Vec<String>.

impl QueryCore

pub fn select(self, fields: Vec<String>) -> QueryCore

Set the projection fields for SELECT clause

If not set, defaults to SELECT *.

pub async fn get_id_only( table: impl Into<String>, id: impl AsRef<str>, valence: &Valence, ) -> Result<Option<IdOnlyRecord>, Error>

Get a record by ID, returning a minimal result with just the ID

Loads via DatabaseBackend::get_record using table:id wire form.

pub async fn get_record_json( table: impl Into<String>, id: impl AsRef<str>, valence: &Valence, ) -> Result<Option<Value>, Error>

Get a record by ID and return it as serde_json::Value.

Uses the table’s resolved crate::backend::DatabaseBackend (same routing as CRUD).

pub async fn latest_ids( table: impl Into<String>, limit: u32, valence: &Valence, ) -> Result<Vec<IdOnlyRecord>, Error>

Get the latest N record IDs from a table, ordered by ID descending

This is useful for displaying sample records where only the ID is needed.

pub async fn get_entity( table: impl Into<String>, id: impl AsRef<str>, valence: &Valence, ) -> Result<Option<ValenceEntity>, Error>

Get an entity with privacy filtering applied

This is the primary method for generic entity access. Returns a ValenceEntity with only the fields the viewer can see.

Flow:

1. Check if record exists (lightweight query)
2. Get schema metadata
3. Load full record
4. Check entity-level privacy
5. Apply field-level privacy filtering
6. Return ValenceEntity

Trait Implementations

impl Clone for QueryCore

fn clone(&self) -> QueryCore

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for QueryCore

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.