use std::fmt;
use std::str::FromStr;
use sqlx::{ColumnIndex, Row};
#[derive(Debug)]
struct DecodeTextError(String);
impl fmt::Display for DecodeTextError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str(&self.0)
}
}
impl std::error::Error for DecodeTextError {}
fn decode_text_error<E: fmt::Display>(e: E) -> sqlx::Error {
sqlx::Error::Decode(Box::new(DecodeTextError(e.to_string())))
}
fn decode_text<R, T>(row: &R, col: &str) -> Result<T, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
T: FromStr,
T::Err: fmt::Display + Send + Sync + 'static,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
if let Ok(s) = row.try_get::<String, _>(col) {
return s.parse().map_err(decode_text_error);
}
let bytes: Vec<u8> = row.try_get(col)?;
let s = String::from_utf8(bytes).map_err(decode_text_error)?;
s.parse().map_err(decode_text_error)
}
fn decode_text_idx<R, T>(row: &R, idx: usize) -> Result<T, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
T: FromStr,
T::Err: fmt::Display + Send + Sync + 'static,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
if let Ok(s) = row.try_get::<String, _>(idx) {
return s.parse().map_err(decode_text_error);
}
let bytes: Vec<u8> = row.try_get(idx)?;
let s = String::from_utf8(bytes).map_err(decode_text_error)?;
s.parse().map_err(decode_text_error)
}
pub fn text<R, T>(row: &R, col: &str) -> Result<T, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
T: FromStr,
T::Err: fmt::Display + Send + Sync + 'static,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
decode_text(row, col)
}
pub fn text_idx<R, T>(row: &R, idx: usize) -> Result<T, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
T: FromStr,
T::Err: fmt::Display + Send + Sync + 'static,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
decode_text_idx(row, idx)
}
pub fn text_opt<R, T>(row: &R, col: &str) -> Result<Option<T>, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
T: FromStr,
T::Err: fmt::Display + Send + Sync + 'static,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
match row.try_get::<Option<String>, _>(col) {
Ok(Some(s)) => s.parse::<T>().map(Some).map_err(decode_text_error),
Ok(None) => Ok(None),
Err(_) => match row.try_get::<Option<Vec<u8>>, _>(col) {
Ok(Some(bytes)) => {
let s = String::from_utf8(bytes).map_err(decode_text_error)?;
s.parse().map(Some).map_err(decode_text_error)
}
Ok(None) => Ok(None),
Err(e) => Err(e),
},
}
}
pub fn text_opt_idx<R, T>(row: &R, idx: usize) -> Result<Option<T>, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
T: FromStr,
T::Err: fmt::Display + Send + Sync + 'static,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
match row.try_get::<Option<String>, _>(idx) {
Ok(Some(s)) => s.parse::<T>().map(Some).map_err(decode_text_error),
Ok(None) => Ok(None),
Err(_) => match row.try_get::<Option<Vec<u8>>, _>(idx) {
Ok(Some(bytes)) => {
let s = String::from_utf8(bytes).map_err(decode_text_error)?;
s.parse().map(Some).map_err(decode_text_error)
}
Ok(None) => Ok(None),
Err(e) => Err(e),
},
}
}
pub fn rich<R, T>(row: &R, col: &str) -> Result<T, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
T: FromStr,
T::Err: fmt::Display + Send + Sync + 'static,
T: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
if let Ok(v) = row.try_get::<T, _>(col) {
return Ok(v);
}
decode_text(row, col)
}
pub fn rich_idx<R, T>(row: &R, idx: usize) -> Result<T, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
T: FromStr,
T::Err: fmt::Display + Send + Sync + 'static,
T: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
if let Ok(v) = row.try_get::<T, _>(idx) {
return Ok(v);
}
decode_text_idx(row, idx)
}
pub fn rich_opt<R, T>(row: &R, col: &str) -> Result<Option<T>, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
T: FromStr,
T::Err: fmt::Display + Send + Sync + 'static,
Option<T>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
match row.try_get::<Option<T>, _>(col) {
Ok(v) => Ok(v),
Err(_) => text_opt(row, col),
}
}
pub fn rich_opt_idx<R, T>(row: &R, idx: usize) -> Result<Option<T>, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
T: FromStr,
T::Err: fmt::Display + Send + Sync + 'static,
Option<T>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
match row.try_get::<Option<T>, _>(idx) {
Ok(v) => Ok(v),
Err(_) => text_opt_idx(row, idx),
}
}
pub fn json<R>(row: &R, col: &str) -> Result<serde_json::Value, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
sqlx::types::Json<serde_json::Value>:
for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
if let Ok(j) = row.try_get::<sqlx::types::Json<serde_json::Value>, _>(col) {
return Ok(j.0);
}
if let Ok(s) = row.try_get::<String, _>(col) {
return serde_json::from_str(&s).map_err(|e| sqlx::Error::Decode(Box::new(e)));
}
let bytes: Vec<u8> = row.try_get(col)?;
let s = String::from_utf8(bytes).map_err(decode_text_error)?;
serde_json::from_str(&s).map_err(|e| sqlx::Error::Decode(Box::new(e)))
}
pub fn json_idx<R>(row: &R, idx: usize) -> Result<serde_json::Value, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
sqlx::types::Json<serde_json::Value>:
for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
if let Ok(j) = row.try_get::<sqlx::types::Json<serde_json::Value>, _>(idx) {
return Ok(j.0);
}
if let Ok(s) = row.try_get::<String, _>(idx) {
return serde_json::from_str(&s).map_err(|e| sqlx::Error::Decode(Box::new(e)));
}
let bytes: Vec<u8> = row.try_get(idx)?;
let s = String::from_utf8(bytes).map_err(decode_text_error)?;
serde_json::from_str(&s).map_err(|e| sqlx::Error::Decode(Box::new(e)))
}
pub fn json_opt<R>(row: &R, col: &str) -> Result<Option<serde_json::Value>, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
sqlx::types::Json<serde_json::Value>:
for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
if let Ok(j) = row.try_get::<Option<sqlx::types::Json<serde_json::Value>>, _>(col) {
return Ok(j.map(|j| j.0));
}
match row.try_get::<Option<String>, _>(col) {
Ok(Some(s)) => serde_json::from_str(&s)
.map(Some)
.map_err(|e| sqlx::Error::Decode(Box::new(e))),
Ok(None) => Ok(None),
Err(_) => match row.try_get::<Option<Vec<u8>>, _>(col) {
Ok(Some(bytes)) => {
let s = String::from_utf8(bytes).map_err(decode_text_error)?;
serde_json::from_str(&s)
.map(Some)
.map_err(|e| sqlx::Error::Decode(Box::new(e)))
}
Ok(None) => Ok(None),
Err(e) => Err(e),
},
}
}
pub fn json_text_idx<R>(row: &R, idx: usize) -> Result<serde_json::Value, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
if let Ok(s) = row.try_get::<String, _>(idx) {
return serde_json::from_str(&s).map_err(|e| sqlx::Error::Decode(Box::new(e)));
}
let bytes: Vec<u8> = row.try_get(idx)?;
let s = String::from_utf8(bytes).map_err(decode_text_error)?;
serde_json::from_str(&s).map_err(|e| sqlx::Error::Decode(Box::new(e)))
}
pub fn json_text_opt_idx<R>(row: &R, idx: usize) -> Result<Option<serde_json::Value>, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
match row.try_get::<Option<String>, _>(idx) {
Ok(Some(s)) => serde_json::from_str(&s)
.map(Some)
.map_err(|e| sqlx::Error::Decode(Box::new(e))),
Ok(None) => Ok(None),
Err(_) => match row.try_get::<Option<Vec<u8>>, _>(idx) {
Ok(Some(bytes)) => {
let s = String::from_utf8(bytes).map_err(decode_text_error)?;
serde_json::from_str(&s)
.map(Some)
.map_err(|e| sqlx::Error::Decode(Box::new(e)))
}
Ok(None) => Ok(None),
Err(e) => Err(e),
},
}
}
pub fn json_opt_idx<R>(row: &R, idx: usize) -> Result<Option<serde_json::Value>, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
sqlx::types::Json<serde_json::Value>:
for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
if let Ok(j) = row.try_get::<Option<sqlx::types::Json<serde_json::Value>>, _>(idx) {
return Ok(j.map(|j| j.0));
}
match row.try_get::<Option<String>, _>(idx) {
Ok(Some(s)) => serde_json::from_str(&s)
.map(Some)
.map_err(|e| sqlx::Error::Decode(Box::new(e))),
Ok(None) => Ok(None),
Err(_) => match row.try_get::<Option<Vec<u8>>, _>(idx) {
Ok(Some(bytes)) => {
let s = String::from_utf8(bytes).map_err(decode_text_error)?;
serde_json::from_str(&s)
.map(Some)
.map_err(|e| sqlx::Error::Decode(Box::new(e)))
}
Ok(None) => Ok(None),
Err(e) => Err(e),
},
}
}
pub fn array_idx<R, T>(row: &R, idx: usize) -> Result<Vec<T>, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
T: for<'de> serde::Deserialize<'de>,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
if let Ok(s) = row.try_get::<String, _>(idx) {
return serde_json::from_str(&s).map_err(|e| sqlx::Error::Decode(Box::new(e)));
}
let bytes: Vec<u8> = row.try_get(idx)?;
let s = String::from_utf8(bytes).map_err(decode_text_error)?;
serde_json::from_str(&s).map_err(|e| sqlx::Error::Decode(Box::new(e)))
}
pub fn array<R, T>(row: &R, col: &str) -> Result<Vec<T>, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
T: for<'de> serde::Deserialize<'de>,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
if let Ok(s) = row.try_get::<String, _>(col) {
return serde_json::from_str(&s).map_err(|e| sqlx::Error::Decode(Box::new(e)));
}
let bytes: Vec<u8> = row.try_get(col)?;
let s = String::from_utf8(bytes).map_err(decode_text_error)?;
serde_json::from_str(&s).map_err(|e| sqlx::Error::Decode(Box::new(e)))
}
pub fn array_opt_idx<R, T>(row: &R, idx: usize) -> Result<Option<Vec<T>>, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
T: for<'de> serde::Deserialize<'de>,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
match row.try_get::<Option<String>, _>(idx) {
Ok(Some(s)) => serde_json::from_str(&s)
.map(Some)
.map_err(|e| sqlx::Error::Decode(Box::new(e))),
Ok(None) => Ok(None),
Err(_) => match row.try_get::<Option<Vec<u8>>, _>(idx) {
Ok(Some(bytes)) => {
let s = String::from_utf8(bytes).map_err(decode_text_error)?;
serde_json::from_str(&s)
.map(Some)
.map_err(|e| sqlx::Error::Decode(Box::new(e)))
}
Ok(None) => Ok(None),
Err(e) => Err(e),
},
}
}
pub fn array_opt<R, T>(row: &R, col: &str) -> Result<Option<Vec<T>>, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
T: for<'de> serde::Deserialize<'de>,
String: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
match row.try_get::<Option<String>, _>(col) {
Ok(Some(s)) => serde_json::from_str(&s)
.map(Some)
.map_err(|e| sqlx::Error::Decode(Box::new(e))),
Ok(None) => Ok(None),
Err(_) => match row.try_get::<Option<Vec<u8>>, _>(col) {
Ok(Some(bytes)) => {
let s = String::from_utf8(bytes).map_err(decode_text_error)?;
serde_json::from_str(&s)
.map(Some)
.map_err(|e| sqlx::Error::Decode(Box::new(e)))
}
Ok(None) => Ok(None),
Err(e) => Err(e),
},
}
}
pub fn bytes<R>(row: &R, col: &str) -> Result<Vec<u8>, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
row.try_get(col)
}
pub fn bytes_idx<R>(row: &R, idx: usize) -> Result<Vec<u8>, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
row.try_get(idx)
}
pub fn bytes_opt<R>(row: &R, col: &str) -> Result<Option<Vec<u8>>, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
row.try_get(col)
}
pub fn bytes_opt_idx<R>(row: &R, idx: usize) -> Result<Option<Vec<u8>>, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
Vec<u8>: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
row.try_get(idx)
}
pub fn direct<R, T>(row: &R, col: &str) -> Result<T, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
T: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
row.try_get(col)
}
pub fn direct_idx<R, T>(row: &R, idx: usize) -> Result<T, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
T: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
row.try_get(idx)
}
pub fn direct_opt<R, T>(row: &R, col: &str) -> Result<Option<T>, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
T: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
row.try_get(col)
}
pub fn direct_opt_idx<R, T>(row: &R, idx: usize) -> Result<Option<T>, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
T: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
row.try_get(idx)
}
pub fn boolean<R>(row: &R, col: &str) -> Result<bool, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
bool: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
i64: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
if let Ok(b) = row.try_get::<bool, _>(col) {
return Ok(b);
}
let i: i64 = row.try_get(col)?;
Ok(i != 0)
}
pub fn boolean_idx<R>(row: &R, idx: usize) -> Result<bool, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
bool: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
i64: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
if let Ok(b) = row.try_get::<bool, _>(idx) {
return Ok(b);
}
let i: i64 = row.try_get(idx)?;
Ok(i != 0)
}
pub fn boolean_opt<R>(row: &R, col: &str) -> Result<Option<bool>, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
bool: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
i64: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
match row.try_get::<Option<bool>, _>(col) {
Ok(Some(b)) => Ok(Some(b)),
Ok(None) => Ok(None),
Err(_) => match row.try_get::<Option<i64>, _>(col) {
Ok(Some(i)) => Ok(Some(i != 0)),
Ok(None) => Ok(None),
Err(e) => Err(e),
},
}
}
pub fn boolean_opt_idx<R>(row: &R, idx: usize) -> Result<Option<bool>, sqlx::Error>
where
R: Row,
usize: ColumnIndex<R>,
for<'a> &'a str: ColumnIndex<R>,
bool: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
i64: for<'r> sqlx::Decode<'r, R::Database> + sqlx::Type<R::Database>,
{
match row.try_get::<Option<bool>, _>(idx) {
Ok(Some(b)) => Ok(Some(b)),
Ok(None) => Ok(None),
Err(_) => match row.try_get::<Option<i64>, _>(idx) {
Ok(Some(i)) => Ok(Some(i != 0)),
Ok(None) => Ok(None),
Err(e) => Err(e),
},
}
}