diff options
Diffstat (limited to 'development/libs/barrel/src/types/builders.rs')
-rw-r--r-- | development/libs/barrel/src/types/builders.rs | 116 |
1 files changed, 116 insertions, 0 deletions
diff --git a/development/libs/barrel/src/types/builders.rs b/development/libs/barrel/src/types/builders.rs new file mode 100644 index 000000000000..43d44f76c513 --- /dev/null +++ b/development/libs/barrel/src/types/builders.rs @@ -0,0 +1,116 @@ +//! Builder API's module + +use super::impls::{BaseType, WrapVec}; +use crate::types::Type; + +/// A standard primary numeric key type +/// +/// It's 64-bit wide, can't be null or non-unique +/// and auto-increments on inserts. +/// Maps to `primary` on `Pg` and manually enforces +/// this behaviour for other Sql variants. +pub fn primary() -> Type { + Type::new(BaseType::Primary) + .nullable(true) // Primary keys are non-null implicitly + .increments(true) // This is ignored for now + .primary(false) // Primary keys are primary implictly + .unique(false) // Primary keys are unique implicitly + .indexed(false) +} + +/// A (standardised) UUID primary key type +/// +/// Similar to `primary()`, but uses a standard +/// layout UUID type, mapping to `uuid` on `Pg` +/// and not supported by all Sql variants. +pub fn uuid() -> Type { + Type::new(BaseType::UUID) + .nullable(false) + .unique(true) + .indexed(true) +} + +/// Create a basic integer type +pub fn integer() -> Type { + Type::new(BaseType::Integer) +} + +/// A 32-bit floating point type +pub fn float() -> Type { + Type::new(BaseType::Float) +} + +/// A 64-bit floating point type +pub fn double() -> Type { + Type::new(BaseType::Double) +} + +/// A boolean data type (true, false) +pub fn boolean() -> Type { + Type::new(BaseType::Boolean) +} + +/// A fixed-length string type +pub fn varchar(len: usize) -> Type { + Type::new(BaseType::Varchar(len)) +} + +/// A variable-length string type +pub fn text() -> Type { + Type::new(BaseType::Text) +} + +/// A json-type column – not supported by all backends +pub fn json() -> Type { + Type::new(BaseType::Json) +} + +/// Embed binary data +pub fn binary<'inner>() -> Type { + Type::new(BaseType::Binary) +} + +/// Create a column that points to some foreign table +pub fn foreign<S, I>(table: S, keys: I) -> Type +where + S: Into<String>, + I: Into<WrapVec<String>>, +{ + Type::new(BaseType::Foreign(None, table.into(), keys.into())) +} + +/// Like `foreign(...)` but letting you provide an external schema +/// +/// This function is important when making cross-schema references +pub fn foreign_schema<S, I>(schema: S, table: S, keys: I) -> Type +where + S: Into<String>, + I: Into<WrapVec<String>>, +{ + Type::new(BaseType::Foreign( + Some(schema.into()), + table.into(), + keys.into(), + )) +} + +/// Any custom SQL type that is embedded into a migration +pub fn custom(sql: &'static str) -> Type { + Type::new(BaseType::Custom(sql)) +} + +/// An SQL date type +pub fn date() -> Type { + Type::new(BaseType::Date) +} + +/// Create an array of inner types +pub fn array(inner: &Type) -> Type { + Type::new(BaseType::Array(Box::new(inner.get_inner()))) +} + +/// Create an index over multiple, existing columns of the same type +pub fn index<S: Into<String>>(columns: Vec<S>) -> Type { + let vec: Vec<String> = columns.into_iter().map(|s| s.into()).collect(); + Type::new(BaseType::Index(vec)) +} |