Struct Text 

pub struct Text<T>(pub T);

Map a SQL text value to/from a Rust type using Display and FromStr.

This can be useful for types that do not have a direct SQL equivalent, or are simply not supported by SQLx for one reason or another.

For strongly typed databases like Postgres, this will report the value’s type as TEXT. Explicit conversion may be necessary on the SQL side depending on the desired type.

Panics

You should only use this adapter with Display implementations that are infallible, otherwise you may encounter panics when attempting to bind a value.

This is because the design of the Encode trait assumes encoding is infallible, so there is no way to bubble up the error.

Fortunately, most Display implementations are infallible by convention anyway (the standard ToString trait also assumes this), but you may still want to audit the source code for any types you intend to use with this adapter, just to be safe.

Example: SocketAddr

MySQL and SQLite do not have a native SQL equivalent for SocketAddr, so if you want to store and retrieve instances of it, it makes sense to map it to TEXT:

use std::net::SocketAddr;

use sqlx::Connection;
use sqlx::mysql::MySqlConnection;
use sqlx::types::Text;

use uuid::Uuid;
use time::OffsetDateTime;

#[derive(sqlx::FromRow, Debug)]
struct Login {
    user_id: Uuid,
    socket_addr: Text<SocketAddr>,
    login_at: OffsetDateTime
}


let mut conn: MySqlConnection = MySqlConnection::connect("<DATABASE URL>").await?;

let user_id: Uuid = "e9a72cdc-d907-48d6-a488-c64a91fd063c".parse().unwrap();
let socket_addr: SocketAddr = "198.51.100.47:31790".parse().unwrap();

// CREATE TABLE user_login(user_id VARCHAR(36), socket_addr TEXT, login_at TIMESTAMP);
sqlx::query("INSERT INTO user_login(user_id, socket_addr, login_at) VALUES (?, ?, NOW())")
    .bind(user_id)
    .bind(Text(socket_addr))
    .execute(&mut conn)
    .await?;

let logins: Vec<Login> = sqlx::query_as("SELECT * FROM user_login")
    .fetch_all(&mut conn)
    .await?;

println!("Logins for user ID {user_id}: {logins:?}");

Tuple Fields

0: T

Implementations

impl<T> Text<T>

pub fn into_inner(self) -> T

Extract the inner value.

Trait Implementations

impl<T> Clone for Text<T>

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Text<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<'r, T> Decode<'r, Postgres> for Text<T>

where T: FromStr, Box<dyn Error + Sync + Send>: From<<T as FromStr>::Err>,

fn decode( value: PgValueRef<'r>, ) -> Result<Text<T>, Box<dyn Error + Sync + Send>>

Decode a new value of this type using a raw value from the database.

impl<T> Default for Text<T>

where T: Default,

fn default() -> Text<T>

Returns the “default value” for a type.

impl<T> Deref for Text<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &<Text<T> as Deref>::Target

Dereferences the value.

impl<T> DerefMut for Text<T>

fn deref_mut(&mut self) -> &mut <Text<T> as Deref>::Target

Mutably dereferences the value.

impl<'q, T> Encode<'q, Postgres> for Text<T>

where T: Display,

fn encode_by_ref( &self, buf: &mut PgArgumentBuffer, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>

Writes the value of self into buf without moving self.

fn encode( self, buf: &mut <DB as Database>::ArgumentBuffer<'q>, ) -> Result<IsNull, Box<dyn Error + Sync + Send>>

where Self: Sized,

Writes the value of self into buf in the expected format for the database.

fn produces(&self) -> Option<<DB as Database>::TypeInfo>

fn size_hint(&self) -> usize

impl<T> Ord for Text<T>

where T: Ord,

fn cmp(&self, other: &Text<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T> PartialEq for Text<T>

where T: PartialEq,

fn eq(&self, other: &Text<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> PartialOrd for Text<T>

where T: PartialOrd,

fn partial_cmp(&self, other: &Text<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> PgHasArrayType for Text<T>

fn array_type_info() -> PgTypeInfo

fn array_compatible(ty: &PgTypeInfo) -> bool

impl<T> Type<Postgres> for Text<T>

fn type_info() -> PgTypeInfo

Returns the canonical SQL type for this Rust type.

fn compatible(ty: &PgTypeInfo) -> bool

Determines if this Rust type is compatible with the given SQL type.

impl<T> Copy for Text<T>

where T: Copy,

impl<T> Eq for Text<T>

where T: Eq,

impl<T> StructuralPartialEq for Text<T>