Struct PgArray 

pub struct PgArray<T>(pub Vec<T>);

Binds a Vec<T> as a single PostgreSQL array parameter.

A plain Vec<T> renders one parameter per element ($1, $2, $3), which suits IN (...) lists. The array operators need one array value instead, so wrap the list: PgArray(vec![1, 2]) renders as a single $1.

Its SQL type is Array<T's SQL type>, so PgArray(vec!["a"]) is an Array<Text> and PgArray(vec![1_i32]) an Array<Int4>. It is never NULL.

Examples

use drizzle_core::{ToSQL, expr::raw_non_null};
use drizzle_postgres::expr::{array_contains, PgArray};
use drizzle_postgres::values::PostgresValue;
use drizzle_types::{Array, postgres::types::Text};

let tags = raw_non_null::<PostgresValue, Array<Text>>("tags");
let condition = array_contains(tags, PgArray(vec!["rust", "python"]));
let sql = condition.to_sql();
assert_eq!(sql.sql(), "tags @> $1");
assert_eq!(sql.params().count(), 1); // one array parameter

Tuple Fields

0: Vec<T>

Trait Implementations

impl<'a, T> Expr<'a, PostgresValue<'a>> for PgArray<T>

where T: Expr<'a, PostgresValue<'a>> + Into<PostgresValue<'a>> + Clone,

type SQLType = Array<<T as Expr<'a, PostgresValue<'a>>>::SQLType>

The SQL data type this expression evaluates to.

type Nullable = NonNull

Whether this expression can be NULL.

type Aggregate = Scalar

Whether this is an aggregate (COUNT, SUM) or scalar expression.

fn to_expr_sql(&self) -> SQL<'a, V>

Renders this value as a scalar expression, borrowing it.

fn into_expr_sql(self) -> SQL<'a, V>

where Self: Sized,

Renders this value as a scalar expression, consuming it.

fn to_condition_sql(&self) -> Option<SQL<'a, V>>

Renders this value as one element of a ConditionList.

fn into_condition_sql(self) -> Option<SQL<'a, V>>

where Self: Sized,

Consuming counterpart of Expr::to_condition_sql.

impl<T> ExprSources for PgArray<T>

type Sources = ()

Type-level tree with one Src leaf per column read.

impl<'a, T> ToSQL<'a, PostgresValue<'a>> for PgArray<T>

where T: Into<PostgresValue<'a>> + Clone,

fn to_sql(&self) -> SQL<'a, PostgresValue<'a>>

Renders self as a SQL fragment.

fn into_sql(self) -> SQL<'a, V>

where Self: Sized,

Renders self as a SQL fragment, consuming it.