drizzle-postgres 0.1.5

A type-safe SQL query builder for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

use drizzle_core::{SQLColumn, SQLColumnInfo};
use std::any::Any;

use crate::traits::PostgresTableInfo;
use crate::values::PostgresValue;
pub trait PostgresColumn<'a>: SQLColumn<'a, PostgresValue<'a>> {
    const SERIAL: bool = false;
    const BIGSERIAL: bool = false;
    const GENERATED_IDENTITY: bool = false;
}
pub trait PostgresColumnInfo: SQLColumnInfo + Any {
    fn table(&self) -> &dyn PostgresTableInfo;

    fn is_serial(&self) -> bool;
    fn is_bigserial(&self) -> bool;
    fn is_generated_identity(&self) -> bool;
    fn postgres_type(&self) -> &'static str;

    /// Returns the foreign key reference if this column has one
    fn foreign_key(&self) -> Option<&'static dyn PostgresColumnInfo> {
        None
    }

    /// Erased access to the Postgres column info.
    fn as_postgres_column(&self) -> &dyn PostgresColumnInfo
    where
        Self: Sized,
    {
        self
    }

    /// Core-erased foreign key reference for call sites that only need generic info.
    fn foreign_key_core(&self) -> Option<&'static dyn SQLColumnInfo> {
        <Self as PostgresColumnInfo>::foreign_key(self).map(|fk| fk as &dyn SQLColumnInfo)
    }
}

// Blanket implementation for static references
impl<T: PostgresColumnInfo> PostgresColumnInfo for &'static T {
    fn table(&self) -> &dyn PostgresTableInfo {
        <T as PostgresColumnInfo>::table(*self)
    }

    fn is_serial(&self) -> bool {
        <T as PostgresColumnInfo>::is_serial(*self)
    }

    fn is_bigserial(&self) -> bool {
        <T as PostgresColumnInfo>::is_bigserial(*self)
    }

    fn is_generated_identity(&self) -> bool {
        <T as PostgresColumnInfo>::is_generated_identity(*self)
    }

    fn postgres_type(&self) -> &'static str {
        <T as PostgresColumnInfo>::postgres_type(*self)
    }

    fn foreign_key(&self) -> Option<&'static dyn PostgresColumnInfo> {
        <T as PostgresColumnInfo>::foreign_key(*self)
    }
}

impl std::fmt::Debug for dyn PostgresColumnInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("PostgresColumnInfo")
            .field("name", &self.name())
            .field("type", &self.r#type())
            .field("not_null", &self.is_not_null())
            .field("primary_key", &self.is_primary_key())
            .field("unique", &self.is_unique())
            .field("table", &PostgresColumnInfo::table(self))
            .field("has_default", &self.has_default())
            .field("is_serial", &self.is_serial())
            .field("is_bigserial", &self.is_bigserial())
            .field("is_generated_identity", &self.is_generated_identity())
            .finish()
    }
}