dml-tools is a library for DML generation and serialization from/to code or YAML files
See examples for usage.
```toml
[dependencies] dml-tools = "0.1" ```
To read DML (Data Manipulation Language) definitions from a .yaml file, such as:
yaml
- tag: Schema
name: my_schema
owner: rw_user
- tag: Table
path:
schema: my_schema
name: users
otype: Table
fields:
- name: workspace
attributes:
unique: true
primary_key: true
- name: user_id
attributes:
empty: false
primary_key: true
- name: user_name
attributes:
unique: true
- name: full_name
attributes: {}
- name: role
attributes:
empty: false
- name: is_locked
attributes:
type: bool
empty: false
- name: email
attributes: {}
- name: is_locked_by_supervisor
attributes:
type: bool
empty: false
defval: 'false'
- tag: ForeignKey
table:
schema: schema1
name: my_table
otype: Table
fields:
- field1
- field2
ref_table:
schema: schema1
name: my_reftable
otype: Table
ref_fields:
- rfield1
- rfield2
on_delete: Restrict
on_update: Cascade
You can load it with:
```rust
use dmltools::Loader;
use dmltools::Processor;
use std::error::Error;
use std::fs::File;
use std::io::prelude::*;
fn main() -> Result<(), Box
and generate:
sql
CREATE SCHEMA myschema AUTHORIZATION rwuser;
CREATE TABLE myschema.users (
workspace text NULL,
userid text NULL,
username text NULL,
fullname text NULL,
"role" text NULL,
islocked text NULL,
email text NULL,
islockedbysupervisor text NULL
);
ALTER TABLE schema1.mytable
ADD CONSTRAINT mytablemyreftablefield1field2fk
FOREIGN KEY (field1,field2)
REFERENCES schema1.my_reftable (rfield1,rfield2)
ON DELETE RESTRICT ON UPDATE CASCADE;
```
To generate DML definitions with code you can write: ```rust use dmltools::sql::*; use dmltools::Processor; use std::error::Error; use dml_tools::macros::*;
pub struct MyRoles { pub rw: String, pub ro: String, pub upd: String, } impl Default for MyRoles { fn default() -> Self { MyRoles { rw: "rwuser".into(), ro: "rouser".into(), upd: "upd_user".into(), } } }
macrorules! grantperms { ($proc:expr, $roles:expr, $opath:expr) => { addowner!($proc, &($roles).rw, $opath); addgrant!($proc, GrantType::All, &($roles).rw, $opath); addgrant!($proc, GrantType::All, &($roles).upd, $opath); addgrant!($proc, GrantType::Select, &($roles).ro, $opath); } }
fn main() -> Result<(), Box
let roles = MyRoles::default();
let my_schema = String::from("my_schema");
let schema = Schema::new(&my_schema, &roles.rw);
processor.add(&schema);
let oschema = ObjectPath::new_schema(&schema.name);
add_grant!(processor, GrantType::All, &roles.rw, &oschema);
add_grant!(processor, GrantType::Usage, &roles.upd, &oschema);
add_grant!(processor, GrantType::Usage, &roles.ro, &oschema);
let u_fields = vec![
Field::new("workspace", &FieldAttributes::new_uk_pk(FieldType::Txt)),
Field::new("is_archived", &FieldAttributes::new(FieldType::Bool)),
Field::new("user_name", &FieldAttributes::new_uk(FieldType::Txt)),
Field::new("full_name", &FieldAttributes::new(FieldType::Txt)),
Field::new("role", &FieldAttributes::new_nn(FieldType::Txt)),
Field::new("is_locked_by_supervisor", &FieldAttributes::new_nn_def(FieldType::Bool, "false")),
];
let t_users = Table::new(&ObjectPath::new_table(&my_schema, "users"), u_fields);
// println!("{}", t_users);
processor.add(&t_users);
grant_perms!(&mut processor, roles, &t_users.path);
processor.serialize_to_yaml_file("local-dmls.sql")?;
Ok(())
}
and this is the resulting file:
sql
CREATE SCHEMA myschema AUTHORIZATION rwuser;
CREATE TABLE myschema.users (
workspace text NULL,
userid text NULL,
username text NULL,
fullname text NULL,
"role" text NULL,
islocked text NULL,
email text NULL,
islockedbysupervisor text NULL
);
ALTER TABLE schema1.mytable
ADD CONSTRAINT mytablemyreftablefield1field2fk
FOREIGN KEY (field1,field2)
REFERENCES schema1.myreftable (rfield1,rfield2)
ON DELETE RESTRICT ON UPDATE CASCADE;
```
Licensed under MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)