Struct Column 

pub struct Column<T> { /* private fields */ }

Typed column reference.

Column is a zero-cost abstraction that carries type information at compile time without runtime overhead. It is Copy and uses only static string references.

Examples

use nautilus_core::{Column, Expr, Value};

let id_col: Column<i64> = Column::new("users", "id");
let expr = id_col.eq(42);

Implementations

impl<T> Column<T>

pub const fn new(table: &'static str, name: &'static str) -> Column<T>

Creates a new typed column reference.

This is a const fn, so columns can be defined as constants.

Examples

use nautilus_core::Column;

const USER_ID: Column<i64> = Column::new("users", "id");
const USER_EMAIL: Column<String> = Column::new("users", "email");

pub const fn table(&self) -> &'static str

Returns the table name.

pub const fn name(&self) -> &'static str

Returns the column name.

pub fn marker(&self) -> ColumnMarker

Returns a column marker for this column.

Static generated columns borrow their metadata without allocating.

pub fn alias(&self) -> String

Returns the join-safe alias for this column.

The alias uses the format "table__column" which is safe to use in queries with joins, preventing column name conflicts.

Matches the naming of ColumnMarker::alias.

Examples

use nautilus_core::Column;

let id: Column<i64> = Column::new("users", "id");
assert_eq!(id.alias(), "users__id");

pub fn eq<V>(self, value: V) -> Expr

where V: Into<Value>,

Creates an equality comparison (=).

Examples

use nautilus_core::{Column, Expr, Value};

let id: Column<i64> = Column::new("users", "id");
let expr = id.eq(42);

pub fn eq_column<U>(self, other: Column<U>) -> Expr

Creates a column-to-column equality expression.

This is useful for JOIN ON conditions where both sides are columns.

Examples

use nautilus_core::{Column, Expr};

let user_id: Column<i64> = Column::new("users", "id");
let post_user_id: Column<i64> = Column::new("posts", "user_id");
let on = user_id.eq_column(post_user_id);

pub fn desc(self) -> OrderBy

Creates a descending ORDER BY clause.

Examples

use nautilus_core::{Column, OrderBy, OrderDir};

let email: Column<String> = Column::new("users", "email");
let order = email.desc();
assert_eq!(order.direction, OrderDir::Desc);

pub fn asc(self) -> OrderBy

Creates an ascending ORDER BY clause.

Examples

use nautilus_core::{Column, OrderBy, OrderDir};

let email: Column<String> = Column::new("users", "email");
let order = email.asc();
assert_eq!(order.direction, OrderDir::Asc);

impl Column<String>

pub fn ends_with(self, suffix: impl Into<String>) -> Expr

Creates a LIKE expression for suffix matching.

Generates a SQL LIKE pattern of the form %suffix.

Examples

use nautilus_core::{Column, Expr, Value};

let email: Column<String> = Column::new("users", "email");
let expr = email.ends_with("example.com");

pub fn starts_with(self, prefix: impl Into<String>) -> Expr

Creates a LIKE expression for prefix matching.

Generates a SQL LIKE pattern of the form prefix%.

Examples

use nautilus_core::{Column, Expr, Value};

let email: Column<String> = Column::new("users", "email");
let expr = email.starts_with("admin");

pub fn contains(self, substring: impl Into<String>) -> Expr

Creates a LIKE expression for substring matching.

Generates a SQL LIKE pattern of the form %substring%.

Examples

use nautilus_core::{Column, Expr, Value};

let email: Column<String> = Column::new("users", "email");
let expr = email.contains("example");

impl<T> Column<Vec<T>>

where T: Into<Value> + Clone,

pub fn contains_elem(self, elem: T) -> Expr

Creates an array contains expression (@> in PostgreSQL).

Returns rows where the column array contains the given element.

Examples

use nautilus_core::{Column, Expr, Value};

let tags: Column<Vec<String>> = Column::new("posts", "tags");
let expr = tags.contains_elem("rust".to_string());

pub fn contains_all(self, elements: Vec<T>) -> Expr

Creates an array contains expression for multiple elements (@> in PostgreSQL).

Returns rows where the column array contains all the given elements.

Examples

use nautilus_core::{Column, Expr, Value};

let tags: Column<Vec<String>> = Column::new("posts", "tags");
let expr = tags.contains_all(vec!["rust".to_string(), "programming".to_string()]);

pub fn contained_by(self, container: Vec<T>) -> Expr

Creates an array contained by expression (<@ in PostgreSQL).

Returns rows where the column array is contained by the given array.

Examples

use nautilus_core::{Column, Expr, Value};

let tags: Column<Vec<String>> = Column::new("posts", "tags");
let expr = tags.contained_by(vec!["rust".to_string(), "go".to_string()]);

pub fn overlaps(self, other: Vec<T>) -> Expr

Creates an array overlaps expression (&& in PostgreSQL).

Returns rows where the column array has any elements in common with the given array.

Examples

use nautilus_core::{Column, Expr, Value};

let tags: Column<Vec<String>> = Column::new("posts", "tags");
let expr = tags.overlaps(vec!["rust".to_string(), "go".to_string()]);

Trait Implementations

impl<T> Clone for Column<T>

where T: Clone,

fn clone(&self) -> Column<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Copy for Column<T>

where T: Copy,

impl<T> Debug for Column<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Eq for Column<T>

where T: Eq,

impl<T> PartialEq for Column<T>

where T: PartialEq,

fn eq(&self, other: &Column<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> StructuralPartialEq for Column<T>