use-database is the RustUse facade/set for primitive database vocabulary. RustUse is a collection of composable, dependency-light Rust utility crates, and this workspace provides shared database concepts that can be reused by SQL, NoSQL, Postgres, SQLite, MySQL, document database, key-value database, graph database, search database, and other database-specific sets.

This repository is experimental while it is below 0.3.0. APIs are intentionally small and may change as the RustUse database vocabulary settles.

use-database is the common database vocabulary layer. It provides metadata and labels for schemas, tables, rows, columns, keys, indexes, constraints, relations, queries, result sets, transactions, migrations, drivers, database URLs, and database identifiers.

• Engine-neutral database primitive types.
• Focused child crates with small public APIs.
• A facade crate that re-exports common child crate types.
• Metadata and vocabulary useful across relational and non-relational systems.

• Not an ORM.
• Not a database client.
• Not a query executor.
• Not a migration runner.
• Not a SQL parser or query builder.
• Not an engine-specific crate.

[dependencies]
use-database = "0.1.0"

Focused crates can also be used directly:

[dependencies]
use-db-name = "0.1.0"
use-db-query = "0.1.0"

use use_database::{
    ColumnName, DatabaseName, PageRequest, PrimaryKey, SchemaName, SortDirection, TableName,
    TransactionIsolation,
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let database = DatabaseName::new("app")?;
    let schema = SchemaName::new("public")?;
    let table = TableName::new("users")?;
    let column = ColumnName::new("id")?;

    let primary_key = PrimaryKey::new(table.clone(), column.clone());
    let page = PageRequest::new(1, 50);
    let isolation = TransactionIsolation::Serializable;

    assert_eq!(database.as_str(), "app");
    assert_eq!(schema.as_str(), "public");
    assert_eq!(primary_key.table(), &table);
    assert_eq!(page.per_page(), 50);
    assert_eq!(SortDirection::Ascending.as_str(), "ascending");
    assert_eq!(isolation.as_str(), "serializable");

    Ok(())
}

use-database should hold common database vocabulary only. Database-specific sets may depend on it, but it should not depend on database-specific sets.

• use-sql should contain SQL-specific syntax, clauses, statements, dialect labels, and relational query concepts.
• use-nosql should contain non-relational database category primitives.
• use-postgres, use-sqlite, use-mysql, and similar sets should contain engine-specific primitives.

Engine-specific behavior, query execution, network connections, migrations, and SQL parsing belong outside use-database.