Trait Param

pub trait Param {
    const PREFIX: ParamPrefix;

    // Required method
    fn bind(&self, statement: &mut Statement<'_>) -> Result<()>;
}

Describes types that can be bound as parameters to a compiled statement.

The kinds of types implementing this trait include:

• Primitives (numeric types, strings, blobs, etc.)
• Optionals of primitives
• Tuples or structs of any of the above
• Singleton/forwarding wrappers of any of the above, e.g. &T and Box

When derived on a struct, the rename_all (type-level), rename and ignore (field-level) attributes work identically to those of Table; see its documentation for more details.

Required Associated Constants

const PREFIX: ParamPrefix

The leading symbol in parameter names. (Must be consistent across parameters.)

Required Methods

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

Binds the primitive or the field(s) of a tuple to a raw rusqlite::Statement.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl Param for bool

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for f32

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for f64

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for i8

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for i16

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for i32

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for i64

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for isize

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for str

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for u8

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for u16

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for u32

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for u64

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for ()

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for usize

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for String

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for Vec<u8>

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for NonZeroI8

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for NonZeroI16

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for NonZeroI32

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for NonZeroI64

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for NonZeroIsize

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for NonZeroU8

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for NonZeroU16

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for NonZeroU32

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for NonZeroU64

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for NonZeroUsize

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl Param for [u8]

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> Param for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where A: ToSql, B: ToSql, C: ToSql, D: ToSql, E: ToSql, F: ToSql, G: ToSql, H: ToSql, I: ToSql, J: ToSql, K: ToSql, L: ToSql, M: ToSql, N: ToSql, O: ToSql, P: ToSql, Q: ToSql, R: ToSql, S: ToSql, T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> Param for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where B: ToSql, C: ToSql, D: ToSql, E: ToSql, F: ToSql, G: ToSql, H: ToSql, I: ToSql, J: ToSql, K: ToSql, L: ToSql, M: ToSql, N: ToSql, O: ToSql, P: ToSql, Q: ToSql, R: ToSql, S: ToSql, T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> Param for (C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where C: ToSql, D: ToSql, E: ToSql, F: ToSql, G: ToSql, H: ToSql, I: ToSql, J: ToSql, K: ToSql, L: ToSql, M: ToSql, N: ToSql, O: ToSql, P: ToSql, Q: ToSql, R: ToSql, S: ToSql, T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> Param for (D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where D: ToSql, E: ToSql, F: ToSql, G: ToSql, H: ToSql, I: ToSql, J: ToSql, K: ToSql, L: ToSql, M: ToSql, N: ToSql, O: ToSql, P: ToSql, Q: ToSql, R: ToSql, S: ToSql, T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> Param for (E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where E: ToSql, F: ToSql, G: ToSql, H: ToSql, I: ToSql, J: ToSql, K: ToSql, L: ToSql, M: ToSql, N: ToSql, O: ToSql, P: ToSql, Q: ToSql, R: ToSql, S: ToSql, T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> Param for (F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where F: ToSql, G: ToSql, H: ToSql, I: ToSql, J: ToSql, K: ToSql, L: ToSql, M: ToSql, N: ToSql, O: ToSql, P: ToSql, Q: ToSql, R: ToSql, S: ToSql, T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> Param for (G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where G: ToSql, H: ToSql, I: ToSql, J: ToSql, K: ToSql, L: ToSql, M: ToSql, N: ToSql, O: ToSql, P: ToSql, Q: ToSql, R: ToSql, S: ToSql, T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> Param for (H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where H: ToSql, I: ToSql, J: ToSql, K: ToSql, L: ToSql, M: ToSql, N: ToSql, O: ToSql, P: ToSql, Q: ToSql, R: ToSql, S: ToSql, T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> Param for (I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where I: ToSql, J: ToSql, K: ToSql, L: ToSql, M: ToSql, N: ToSql, O: ToSql, P: ToSql, Q: ToSql, R: ToSql, S: ToSql, T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> Param for (J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where J: ToSql, K: ToSql, L: ToSql, M: ToSql, N: ToSql, O: ToSql, P: ToSql, Q: ToSql, R: ToSql, S: ToSql, T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> Param for (K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where K: ToSql, L: ToSql, M: ToSql, N: ToSql, O: ToSql, P: ToSql, Q: ToSql, R: ToSql, S: ToSql, T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<K, V> Param for BTreeMap<K, V>

where K: Display, V: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Dollar

Dynamic maps use $ by default because it’s the most flexible prefix.

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<K, V> Param for HashMap<K, V>

where K: Display, V: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Dollar

Dynamic maps use $ by default because it’s the most flexible prefix.

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> Param for (L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where L: ToSql, M: ToSql, N: ToSql, O: ToSql, P: ToSql, Q: ToSql, R: ToSql, S: ToSql, T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z> Param for (M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where M: ToSql, N: ToSql, O: ToSql, P: ToSql, Q: ToSql, R: ToSql, S: ToSql, T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<N, O, P, Q, R, S, T, U, V, W, X, Y, Z> Param for (N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where N: ToSql, O: ToSql, P: ToSql, Q: ToSql, R: ToSql, S: ToSql, T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<O, P, Q, R, S, T, U, V, W, X, Y, Z> Param for (O, P, Q, R, S, T, U, V, W, X, Y, Z)

where O: ToSql, P: ToSql, Q: ToSql, R: ToSql, S: ToSql, T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<P, Q, R, S, T, U, V, W, X, Y, Z> Param for (P, Q, R, S, T, U, V, W, X, Y, Z)

where P: ToSql, Q: ToSql, R: ToSql, S: ToSql, T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<Q, R, S, T, U, V, W, X, Y, Z> Param for (Q, R, S, T, U, V, W, X, Y, Z)

where Q: ToSql, R: ToSql, S: ToSql, T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<R, S, T, U, V, W, X, Y, Z> Param for (R, S, T, U, V, W, X, Y, Z)

where R: ToSql, S: ToSql, T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<S, T, U, V, W, X, Y, Z> Param for (S, T, U, V, W, X, Y, Z)

where S: ToSql, T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<T> Param for Cow<'_, T>

where T: ?Sized + ToOwned + Param,

const PREFIX: ParamPrefix = T::PREFIX

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<T, U, V, W, X, Y, Z> Param for (T, U, V, W, X, Y, Z)

where T: ToSql, U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<T: ToSql> Param for Option<T>

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<T: ?Sized + Param> Param for &T

const PREFIX: ParamPrefix = T::PREFIX

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<T: ?Sized + Param> Param for &mut T

const PREFIX: ParamPrefix = T::PREFIX

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<T: ?Sized + Param> Param for Box<T>

const PREFIX: ParamPrefix = T::PREFIX

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<T: ?Sized + Param> Param for Rc<T>

const PREFIX: ParamPrefix = T::PREFIX

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<T: ?Sized + Param> Param for Arc<T>

const PREFIX: ParamPrefix = T::PREFIX

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<U, V, W, X, Y, Z> Param for (U, V, W, X, Y, Z)

where U: ToSql, V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<V, W, X, Y, Z> Param for (V, W, X, Y, Z)

where V: ToSql, W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<W, X, Y, Z> Param for (W, X, Y, Z)

where W: ToSql, X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<X, Y, Z> Param for (X, Y, Z)

where X: ToSql, Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<Y, Z> Param for (Y, Z)

where Y: ToSql, Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<Z> Param for (Z,)

where Z: ToSql,

const PREFIX: ParamPrefix = ParamPrefix::Question

Tuples use positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

impl<const N: usize> Param for [u8; N]

const PREFIX: ParamPrefix = ParamPrefix::Question

Primitives are bound as positional parameters, hence the prefix is ‘?’

fn bind(&self, statement: &mut Statement<'_>) -> Result<()>

Implementors

impl Param for ToSqlOutput<'_>

const PREFIX: ParamPrefix = ParamPrefix::Question

impl Param for Value

const PREFIX: ParamPrefix = ParamPrefix::Question

impl Param for ValueRef<'_>

const PREFIX: ParamPrefix = ParamPrefix::Question

impl Param for Null

const PREFIX: ParamPrefix = ParamPrefix::Question