Pure.RelationalSchema.Samples 0.1.0-preview.1.0.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:

The join graph

Every domain relation is reachable from every other by following foreign keys in either direction; the longest cross-domain path touches all three schemas in three hops (audit.logins → users ← orders → refs.statuses):

        audit.logins ──login_user_id──┐
                                      ▼
  employees ──employee_user_id──▶  users  ◀──order_user_id── orders ──order_status──▶ refs.statuses
      │                                                        ▲
      └─manager_id─┘ (self)                                    │ (order_id, order_tenant_id)
                                                          order_items ──item_product_id──▶ products

Schema Catalogue

Pure.RelationalSchema.Samples.Schemas/
├── EmptyRelationalSchema                    (empty_schema)
│
├── SingleTableRelationalSchema               (single_table_schema)
│   └── SingleColumnTable
│       └── id
│
├── RelationalSchemaWithoutForeignKeys        (schema_without_foreign_keys)
│   ├── EmptyTable
│   ├── SingleColumnTable
│   │   └── id
│   └── TableWithoutIndexes
│       ├── id
│       ├── name
│       └── created_at
│
├── RelationalSchemaWithIndexes               (schema_with_indexes)
│   ├── TableWithSingleIndex
│   │   ├── id
│   │   └── name
│   └── TableWithIndexes
│       ├── id
│       ├── tenant_id
│       ├── name
│       └── created_at
│
├── RelationalSchemaWithAllColumnTypes        (schema_with_all_column_types)
│   └── AllColumnTypesTable
│       ├── id
│       ├── name
│       ├── age
│       ├── quantity
│       ├── price
│       ├── is_active
│       ├── birth_date
│       ├── start_time
│       ├── created_at
│       └── (empty name)
│
├── RelationalSchemaWithForeignKeys           (schema_with_foreign_keys)  ← core domain, query-grade
│   ├── UsersTable       users        13 cols   all seven readable types
│   │   ├── user_id
│   │   ├── user_tenant_id
│   │   ├── user_name
│   │   ├── signup_date
│   │   ├── user_active
│   │   ├── last_login
│   │   ├── user_age
│   │   ├── shift_start
│   │   ├── user_score
│   │   ├── user_precision_value
│   │   ├── user_edge_date
│   │   ├── user_edge_datetime
│   │   └── user_edge_time
│   ├── OrdersTable       orders        7 cols
│   │   ├── order_id
│   │   ├── order_tenant_id
│   │   ├── order_user_id
│   │   ├── order_total
│   │   ├── placed_at
│   │   ├── order_status
│   │   └── placed_on
│   ├── ProductsTable     products      5 cols
│   │   ├── product_id
│   │   ├── product_name
│   │   ├── product_description
│   │   ├── product_price
│   │   └── product_in_stock
│   ├── OrderItemsTable   order_items   5 cols
│   │   ├── item_id
│   │   ├── item_tenant_id
│   │   ├── item_order_id
│   │   ├── item_product_id
│   │   └── item_qty
│   ├── EmployeesTable    employees     5 cols
│   │   ├── employee_id
│   │   ├── employee_name
│   │   ├── employee_manager_id
│   │   ├── employee_shift_start
│   │   └── employee_user_id
│   └── ForeignKeys
│       ├── SingleColumnForeignKey           orders.order_user_id → users.user_id
│       ├── CompositeForeignKey              order_items.(item_order_id, item_tenant_id)
│       │                                      → orders.(order_id, order_tenant_id)
│       ├── OrderItemsToProductsForeignKey   order_items.item_product_id → products.product_id
│       ├── SelfReferencingForeignKey        employees.employee_manager_id → employees.employee_id
│       ├── EmployeesToUsersForeignKey       employees.employee_user_id → users.user_id
│       └── OrdersToStatusesForeignKey       orders.order_status → statuses.status_code   ← cross-domain, string key
│
├── RelationalSchemaWithCompositeForeignKey   (schema_with_composite_foreign_key)
│   ├── OrdersTable       orders        7 cols   (see above)
│   ├── OrderItemsTable   order_items   5 cols   (see above)
│   └── ForeignKeys
│       └── CompositeForeignKey        order_items.(item_order_id, item_tenant_id)
│                                         → orders.(order_id, order_tenant_id)
│
├── RelationalSchemaWithSelfReferencingTable  (schema_with_self_referencing_table)
│   ├── EmployeesTable    employees     5 cols   (see above)
│   └── ForeignKeys
│       └── SelfReferencingForeignKey  employees.employee_manager_id → employees.employee_id
│
├── AuditRelationalSchema                      (audit)   ← audit domain
│   └── LoginsTable       logins        3 cols
│       ├── login_id
│       ├── login_user_id
│       └── login_at
│       └── ForeignKeys
│           └── LoginsToUsersForeignKey   logins.login_user_id → users.user_id   ← cross-domain, uuid key
│
├── RefsRelationalSchema                       (refs)   ← refs domain, referenced only
│   └── StatusesTable     statuses      3 cols
│       ├── status_code
│       ├── status_label
│       └── status_is_final
│
└── FullRelationalSchema                      (full_schema)
    ├── EmptyTable
    ├── SingleColumnTable
    │   └── id
    ├── TableWithoutIndexes
    │   ├── id
    │   ├── name
    │   └── created_at
    ├── TableWithSingleIndex
    │   ├── id
    │   └── name
    ├── TableWithIndexes
    │   ├── id
    │   ├── tenant_id
    │   ├── name
    │   └── created_at
    ├── AllColumnTypesTable
    │   ├── id
    │   ├── name
    │   ├── age
    │   ├── quantity
    │   ├── price
    │   ├── is_active
    │   ├── birth_date
    │   ├── start_time
    │   ├── created_at
    │   └── (empty name)
    ├── UsersTable        users         13 cols   (see above)
    ├── OrdersTable       orders         7 cols   (see above)
    ├── ProductsTable     products       5 cols   (see above)
    ├── OrderItemsTable   order_items    5 cols   (see above)
    ├── EmployeesTable    employees      5 cols   (see above)
    ├── LoginsTable       logins         3 cols   (see above)
    ├── StatusesTable     statuses       3 cols   (see above)
    └── ForeignKeys
        ├── EmptyColumnsForeignKey          empty_table.() → single_column_table.()
        ├── SingleColumnForeignKey          orders.order_user_id → users.user_id
        ├── CompositeForeignKey             order_items.(item_order_id, item_tenant_id)
        │                                     → orders.(order_id, order_tenant_id)
        ├── OrderItemsToProductsForeignKey  order_items.item_product_id → products.product_id
        ├── SelfReferencingForeignKey       employees.employee_manager_id → employees.employee_id
        ├── LoginsToUsersForeignKey         logins.login_user_id → users.user_id
        ├── OrdersToStatusesForeignKey      orders.order_status → statuses.status_code
        └── EmployeesToUsersForeignKey      employees.employee_user_id → users.user_id

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