dbui-database 0.0.64

Database access and schema introspection for dbui
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use anyhow::Result;
use dbui_core::database::column::Column;
use dbui_core::field_type::FieldType;

use postgres::Row;

#[derive(Debug)]
pub(crate) struct ColumnDefinition {
  table_schema: String,
  table_name: String,
  column_name: String,
  ordinal_position: i32,
  column_default: Option<String>,
  is_nullable: bool,
  data_type: String,
  array_type: Option<String>,
  character_maximum_length: Option<i32>,
  character_octet_length: Option<i32>,
  numeric_precision: Option<i32>,
  numeric_precision_radix: Option<i32>,
  numeric_scale: Option<i32>,
  datetime_precision: Option<i32>,
  interval_type: Option<String>,
  domain_schema: Option<String>,
  domain_name: Option<String>,
  udt_schema: String,
  udt_name: String,
  dtd_identifier: String,
  is_updatable: bool
}

impl ColumnDefinition {
  pub(crate) fn from_row(row: &Row) -> Result<Self> {
    Ok(ColumnDefinition {
      table_schema: crate::get(&row, "table_schema")?,
      table_name: crate::get(&row, "table_name")?,
      column_name: crate::get(&row, "column_name")?,
      ordinal_position: crate::get(&row, "ordinal_position")?,
      column_default: crate::get(&row, "column_default")?,
      is_nullable: crate::get::<String>(&row, "is_nullable")? == "YES",
      data_type: crate::get(&row, "data_type")?,
      array_type: crate::get(&row, "array_type")?,
      character_maximum_length: crate::get(&row, "character_maximum_length")?,
      character_octet_length: crate::get(&row, "character_octet_length")?,
      numeric_precision: crate::get(&row, "numeric_precision")?,
      numeric_precision_radix: crate::get(&row, "numeric_precision_radix")?,
      numeric_scale: crate::get(&row, "numeric_scale")?,
      datetime_precision: crate::get(&row, "datetime_precision")?,
      interval_type: crate::get(&row, "interval_type")?,
      domain_schema: crate::get(&row, "domain_schema")?,
      domain_name: crate::get(&row, "domain_name")?,
      udt_schema: crate::get(&row, "udt_schema")?,
      udt_name: crate::get(&row, "udt_name")?,
      dtd_identifier: crate::get(&row, "dtd_identifier")?,
      is_updatable: crate::get::<String>(&row, "is_updatable")? == "YES"
    })
  }

  pub(crate) fn table_schema(&self) -> &String {
    &self.table_schema
  }

  pub(crate) fn table_name(&self) -> &String {
    &self.table_name
  }

  pub(crate) fn typ(&self) -> FieldType {
    match self.data_type.as_ref() {
      "text" | "character varying" => FieldType::String,
      "boolean" => FieldType::Boolean,
      "character" => FieldType::Char,
      "smallint" => FieldType::I16,
      "integer" | "serial" => FieldType::I32,
      "bigint" | "bigserial" | "int8" => FieldType::I64,
      "real" => FieldType::F32,
      "double precision" => FieldType::F64,
      "numeric" | "money" => FieldType::Numeric,

      "oid" => FieldType::U32,

      "date" => FieldType::Date,
      "time" | "time without time zone" => FieldType::Time,
      "timetz" | "time with time zone" => FieldType::TimeZoned,
      "timestamp" | "timestamp without time zone" => FieldType::Timestamp,
      "timestamptz" | "timestamp with time zone" => FieldType::TimestampZoned,

      "uuid" => FieldType::Uuid,
      "json" | "jsonb" => FieldType::Json,
      "xml" => FieldType::Xml,
      "hstore" => FieldType::StringMap,

      "bytea" => FieldType::ByteArray,
      "but" | "bit varying" => FieldType::BitArray,

      "cidr" => FieldType::Cidr,
      "inet" => FieldType::InetAddr,
      "macaddr" => FieldType::MacAddr,

      "box" => FieldType::Box,
      "circle" => FieldType::Circle,
      "path" => FieldType::Path,
      "polygon" => FieldType::Polygon,
      "point" => FieldType::Point,

      "tsquery" => FieldType::TsQuery,
      "tsvector" => FieldType::TsVector,

      /*

      */
      "USER-DEFINED" => match self.udt_name.as_ref() {
        "hstore" => FieldType::StringMap,
        _ => {
          println!("Unhandled UDT [{}]: {:?}", self.data_type, self);
          FieldType::Unknown { t: self.data_type.clone() }
        }
      },

      "ARRAY" => FieldType::List {
        t: Box::new(FieldType::String)
      },

      _ => {
        println!("Unhandled column type [{}]: {:?}", self.data_type, self);
        FieldType::Unknown { t: self.data_type.clone() }
      }
    }
  }

  pub(crate) fn column(&self) -> Column {
    Column::new(self.column_name.clone(), self.typ())
  }
}