Pure.RelationalSchema.Samples 0.1.0-preview.1.1.0

Pure.RelationalSchema.Samples

Named, predefined ISchema instances — and the tables, columns, indexes, column types and foreign keys they are built from — for the Pure ecosystem.

Overview

Pure.RelationalSchema.Samples provides a fixed, deterministic catalogue of relational schema shapes implemented as sealed records over the interfaces from Pure.RelationalSchema.Abstractions. Every sample is a concrete named type with a parameterless constructor and stable contents — nothing is random, nothing is generated.

The catalogue is graded from trivial to full-set, so a consumer can pick the exact shape it needs:

Because samples are ordinary ISchema/ITable/IColumn/IIndex/IForeignKey implementations, they compose with the rest of the ecosystem — hashing, serialization, OpenAPI schemas, storage adapters and conditions — without any adapter code.

Query-grade domains

schema_with_foreign_keys, audit and refs are the query-grade schemas: every column on every relation they hold is readable by a projection (bool, date, datetime, double, string, time, uuid — never int/long), and every column name is globally unique across all seven domain relations, so a cross-domain query never needs to qualify a bare field reference. The three schemas are joined by foreign keys crossing schema boundaries in both directions and on both key shapes a query engine can meet:

FullRelationalSchema is the exhaustive fixture — it holds both the query-grade domain relations and the generic shape tables (EmptyTable, SingleColumnTable, TableWithoutIndexes, TableWithSingleIndex, TableWithIndexes, AllColumnTypesTable), so it is the one schema where id, name, created_at and tenant_id are deliberately ambiguous across relations. It is never a qualifier for a cross-domain query — use schema_with_foreign_keys, audit or refs for that.

Domains

Each domain relation has exactly one home schema — the schema a cross-domain query qualifies it with. A relation may also appear in other sample schemas (users is also in FullRelationalSchema), but only its home is unambiguous:

Entity-Relationship Diagrams

One diagram per ISchema sample, in the same order as the grading table above — these are the primary reference for what each schema contains; see Schemas and the tables that follow for the underlying class names. Each diagram reflects exactly that schema's own Tables and ForeignKeys collections — PK/FK markers, and the relationship lines themselves, are per-schema facts, not universal facts about a column. For example, orders.order_user_id is a foreign-key column wherever SingleColumnForeignKey is in scope, but is drawn as a plain column in schema_with_composite_foreign_key, which does not include that foreign key. A PK marker means the column is covered by a unique IIndex sample on that table (see Indexes); logins and statuses declare no indexes at all, so their natural keys (login_id, status_code) are drawn unmarked, matching the source exactly.

Where a foreign key crosses into a table that is not itself a member of the schema (a foreign key is listed in the schema of its referencing relation — see Query-grade domains), the referenced table is still drawn so the edge renders, with a note underneath naming its real home schema.

empty_schema — EmptyRelationalSchema

No tables and no foreign keys — nothing to diagram.

single_table_schema — SingleTableRelationalSchema

erDiagram
    single_column_table {
        uuid id
    }

schema_without_foreign_keys — RelationalSchemaWithoutForeignKeys

erDiagram
    empty_table {
    }
    single_column_table {
        uuid id
    }
    table_without_indexes {
        uuid id
        string name
        datetime created_at
    }

No foreign keys connect these tables — the sample exists to exercise a multi-table, relation-free schema.

schema_with_indexes — RelationalSchemaWithIndexes

erDiagram
    table_with_single_index {
        uuid id PK
        string name
    }
    table_with_indexes {
        uuid id PK
        uuid tenant_id
        string name
        datetime created_at
    }

No foreign keys — the sample exercises unique, non-unique and composite indexes, not relations. tenant_id on table_with_indexes is also covered by CompositeUniqueIndex alongside id; only single-column primary keys are marked PK here to keep the diagram readable.

schema_with_all_column_types — RelationalSchemaWithAllColumnTypes

erDiagram
    all_column_types_table {
        uuid id
        string name
        int age
        long quantity
        double price
        bool is_active
        date birth_date
        time start_time
        datetime created_at
        string empty_name
    }

empty_name stands in for EmptyNameColumn, whose real Name is the empty string.

schema_with_foreign_keys — RelationalSchemaWithForeignKeys (core domain, query-grade)

erDiagram
    users {
        uuid user_id PK
        uuid user_tenant_id
        string user_name
        date signup_date
        bool user_active
        datetime last_login
        double user_age
        time shift_start
        double user_score
        double user_precision_value
        date user_edge_date
        datetime user_edge_datetime
        time user_edge_time
    }
    orders {
        uuid order_id PK
        uuid order_tenant_id
        uuid order_user_id FK
        double order_total
        datetime placed_at
        string order_status FK
        date placed_on
    }
    products {
        uuid product_id PK
        string product_name
        string product_description
        double product_price
        bool product_in_stock
    }
    order_items {
        uuid item_id PK
        uuid item_tenant_id
        uuid item_order_id FK
        uuid item_product_id FK
        double item_qty
    }
    employees {
        uuid employee_id PK
        string employee_name
        uuid employee_manager_id FK
        time employee_shift_start
        uuid employee_user_id FK
    }
    statuses {
        string status_code
        string status_label
        bool status_is_final
    }

    users ||--o{ orders : "order_user_id"
    users ||--o{ employees : "employee_user_id"
    employees ||--o{ employees : "employee_manager_id (self)"
    orders ||--o{ order_items : "item_order_id + item_tenant_id"
    products ||--o{ order_items : "item_product_id"
    statuses ||--o{ orders : "order_status"

statuses is not a member table of this schema. OrdersToStatusesForeignKey is listed here because it is homed with its referencing relation (orders), but statuses itself is homed in refs — it is drawn only to render the crossing edge.

schema_with_composite_foreign_key — RelationalSchemaWithCompositeForeignKey

erDiagram
    orders {
        uuid order_id PK
        uuid order_tenant_id
        uuid order_user_id
        double order_total
        datetime placed_at
        string order_status
        date placed_on
    }
    order_items {
        uuid item_id PK
        uuid item_tenant_id FK
        uuid item_order_id FK
        uuid item_product_id
        double item_qty
    }

    orders ||--o{ order_items : "item_order_id + item_tenant_id"

schema_with_self_referencing_table — RelationalSchemaWithSelfReferencingTable

erDiagram
    employees {
        uuid employee_id PK
        string employee_name
        uuid employee_manager_id FK
        time employee_shift_start
        uuid employee_user_id
    }

    employees ||--o{ employees : "employee_manager_id (self)"

audit — AuditRelationalSchema

erDiagram
    logins {
        uuid login_id
        uuid login_user_id FK
        datetime login_at
    }
    users {
        uuid user_id PK
        uuid user_tenant_id
        string user_name
        date signup_date
        bool user_active
        datetime last_login
        double user_age
        time shift_start
        double user_score
        double user_precision_value
        date user_edge_date
        datetime user_edge_datetime
        time user_edge_time
    }

    users ||--o{ logins : "login_user_id"

users is not a member table of audit — drawn only to render LoginsToUsersForeignKey's crossing edge; its home schema is schema_with_foreign_keys.

refs — RefsRelationalSchema

erDiagram
    statuses {
        string status_code
        string status_label
        bool status_is_final
    }

No foreign keys — refs is a leaf domain, referenced only (see Query-grade domains).

full_schema — FullRelationalSchema

Every table and every foreign key in the catalogue — the union of all diagrams above.

erDiagram
    empty_table {
    }
    single_column_table {
        uuid id
    }
    table_without_indexes {
        uuid id
        string name
        datetime created_at
    }
    table_with_single_index {
        uuid id PK
        string name
    }
    table_with_indexes {
        uuid id PK
        uuid tenant_id
        string name
        datetime created_at
    }
    all_column_types_table {
        uuid id
        string name
        int age
        long quantity
        double price
        bool is_active
        date birth_date
        time start_time
        datetime created_at
        string empty_name
    }
    users {
        uuid user_id PK
        uuid user_tenant_id
        string user_name
        date signup_date
        bool user_active
        datetime last_login
        double user_age
        time shift_start
        double user_score
        double user_precision_value
        date user_edge_date
        datetime user_edge_datetime
        time user_edge_time
    }
    orders {
        uuid order_id PK
        uuid order_tenant_id
        uuid order_user_id FK
        double order_total
        datetime placed_at
        string order_status FK
        date placed_on
    }
    products {
        uuid product_id PK
        string product_name
        string product_description
        double product_price
        bool product_in_stock
    }
    order_items {
        uuid item_id PK
        uuid item_tenant_id
        uuid item_order_id FK
        uuid item_product_id FK
        double item_qty
    }
    employees {
        uuid employee_id PK
        string employee_name
        uuid employee_manager_id FK
        time employee_shift_start
        uuid employee_user_id FK
    }
    logins {
        uuid login_id
        uuid login_user_id FK
        datetime login_at
    }
    statuses {
        string status_code
        string status_label
        bool status_is_final
    }

    empty_table ||--|| single_column_table : "EmptyColumnsForeignKey (no columns)"
    users ||--o{ orders : "order_user_id"
    users ||--o{ employees : "employee_user_id"
    employees ||--o{ employees : "employee_manager_id (self)"
    orders ||--o{ order_items : "item_order_id + item_tenant_id"
    products ||--o{ order_items : "item_product_id"
    users ||--o{ logins : "login_user_id"
    statuses ||--o{ orders : "order_status"

Schemas

namespace Pure.RelationalSchema.Samples.Schemas

Tables

namespace Pure.RelationalSchema.Samples.Tables

Foreign Keys

namespace Pure.RelationalSchema.Samples.ForeignKeys

Indexes

namespace Pure.RelationalSchema.Samples.Indexes

Columns

namespace Pure.RelationalSchema.Samples.Columns

Column Types

namespace Pure.RelationalSchema.Samples.ColumnTypes

int and long appear only on the shape tables (AllColumnTypesTable and friends) — no domain relation carries either, so every domain column is projection-readable.

Dependencies

• Pure.RelationalSchema.Abstractions 1.2.0 — the interfaces every sample implements (ISchema, ITable, IColumn, IColumnType, IIndex, IForeignKey)
• Pure.Primitives 3.6.5 — String, True and False used for sample names and index uniqueness

No implementation package (Pure.RelationalSchema and friends) is referenced, so the samples can be consumed by any repository in the ecosystem — including the implementations themselves — without a dependency cycle.

Target Frameworks

• .NET 7
• .NET 8
• .NET 9
• .NET 10

Installation

dotnet add package Pure.RelationalSchema.Samples

Usage

using Pure.RelationalSchema.Abstractions.Schema;
using Pure.RelationalSchema.Samples.Schemas;

ISchema schema = new FullRelationalSchema();

// schema.Name.TextValue      == "full_schema"
// schema.Tables.Count()      == 13
// schema.ForeignKeys.Count() == 8

Underlying components are usable on their own:

using Pure.RelationalSchema.Abstractions.ForeignKey;
using Pure.RelationalSchema.Abstractions.Table;
using Pure.RelationalSchema.Samples.ForeignKeys;
using Pure.RelationalSchema.Samples.Tables;

ITable table = new UsersTable();
IForeignKey foreignKey = new CompositeForeignKey();

Samples are deterministic, so they compare equal across instances by structural hash:

using Pure.RelationalSchema.HashCodes;
using Pure.RelationalSchema.Samples.Tables;

bool same = new TableHash(new UsersTable()).SequenceEqual(new TableHash(new UsersTable()));
// true