Crate database_schema 

database-schema

This crate provides a simple way to dump a database structure to a file, in SQL format.

It takes inspiration by the ruby on rails schema dump.

Usage

use std::path::PathBuf;

database_schema::generate_without_runtime_using_defaults!();

Feature flags

database-schema uses a set of feature flags to reduce the size of the libray and therefore your binary. The way one should use this package is to pick the right combination of feature flags for their use case. Below is a list of the available feature flags and the combinations that are recommended for each use case.

• sqlite: Enables SQLite support.
• postgres: Enables PostgreSQL support.
• mysql: Enables MySQL support.
• sqlx: Enables sqlx support.
• diesel: Enables diesel support.

Feature flag matrix

Database	Query builder	Runtime
sqlite	sqlx	runtime-async-std
sqlite	sqlx	runtime-tokio
sqlite	diesel
mysql	sqlx	runtime-async-std
mysql	sqlx	runtime-tokio
mysql	diesel
postgres	sqlx	runtime-async-std
postgres	sqlx	runtime-tokio
postgres	diesel

Combining feature flags

The following are the recommended feature flag combinations for each use case.

First pick one of the following database feature flags:

• sqlite
• mysql
• postgres

Then pick one of the following database query building feature flags:

• sqlx
• diesel

If you’re using sqlx, you also have to pick one of the following runtime feature flags:

• runtime-async-std
• runtime-tokio

Example

[dependencies]
database-schema = { version = "0.1", features = ["sqlite", "sqlx", "runtime-async-std"] }

alternatively, if you’re using diesel:

[dependencies]
database-schema = { version = "0.1", features = ["sqlite", "diesel"] }

Macros

This crate also provides a set of macros that can be used to generate the SQL structure of a database at compile time. This is useful for generating the SQL from build.rs.

[dependencies]
database-schema = { version = "0.1", features = ["sqlite", "diesel", "macros"] }

use database_schema::generate_without_runtime;

let sql = generate_without_runtime!("./migrations", "structure.sql");

The above is strictly equivalent to calling:

use database_schema::generate_without_runtime_using_defaults;

let sql = generate_without_runtime!();

Customization

use database_schema::DatabaseSchemaBuilder;

let migrations_path = "db/migrations";
let destination_path = "db/structure.sql";

// This assumes you're using SQLite in memory.
//
// If you need to set up a `connection_url` you can use
// `DatabaseSchemaBuilder::connection_url` before calling
// `build()`.

DatabaseSchemaBuilder::new()
    .migrations_dir(migrations_path)?
    .destination_path(destination_path)
    .build()
    .dump()
    .await

Re-exports

pub use error::Error;

Modules

error

Error types for the library.

macrosmacros and (runtime-async-std or runtime-tokio)

This module contains a few useful macros in order to not need the builder.

Macros

generate_without_runtime

Generate a destination_path file using migrations from the provided migrations_path folder.

generate_without_runtime_using_defaults

Generate a ./structure.sql file using migrations from the ./migrations folder.

Structs

DatabaseSchema(sqlite or postgres or mysql) and (sqlx or diesel)

Entry point for using the crate and the result of calling DatabaseSchemaBuilder::build.

DatabaseSchemaBuilder(sqlite or postgres or mysql) and (sqlx or diesel)

Builder for DatabaseSchema

Functions

generate(sqlite or postgres or mysql) and (sqlx or diesel)

Generate a destination_path SQL file using migrations from the migrations_path folder.