SeaSchema

The TableDef struct is the primary representation of a SQLite table in sea-schema. It holds metadata about the table's name, columns, foreign keys, indexes, and constraints. You can use it to discover the existing schema of a SQLite database by calling its discovery methods against a Connection.

Key fields in TableDef:

• name: The table name.
• columns: A list of ColumnInfo objects.
• foreign_keys: A list of ForeignKeysInfo objects.
• indexes: A list of IndexInfo objects.
• constraints: A list of IndexInfo objects representing UNIQUE and PRIMARY KEY constraints.
• auto_increment: A boolean indicating if the primary key is set to autoincrement.

use sea_schema::sqlite::TableDef;

// Assuming 'conn' is an active Connection to a SQLite database
let mut table_def = TableDef { 
    name: "users".to_string(), 
    ..Default::default() 
};

// Discover columns
table_def.get_column_info(&conn).await?;

// Discover foreign keys
table_def.get_foreign_keys(&conn).await?;

// Discover indexes
table_def.get_indexes(&conn).await?;

// Discover constraints (UNIQUE/PK)
table_def.get_constraints(&conn).await?;

// Check for autoincrement
table_def.pk_is_autoincrement(&conn).await?;

The TableDef struct is used to represent and discover the schema of an existing SQLite table. You can use it to inspect columns, indexes, foreign keys, and constraints by calling discovery methods that interact with a Connection.

To fully populate a TableDef from an existing database, you typically need to call several discovery methods in sequence:

1. get_column_info(conn): Retrieves column names, types, and nullability.
2. get_foreign_keys(conn): Retrieves foreign key relationships.
3. get_indexes(conn): Retrieves standard indexes.
4. get_constraints(conn): Retrieves UNIQUE and PRIMARY KEY constraints.
5. pk_is_autoincrement(conn): Specifically checks if the primary key is set to autoincrement.

Note that many of these methods return a DiscoveryResult<&mut Self>, allowing for method chaining.

// Example workflow for discovering a table's schema
let mut table_def = TableDef { 
    name: "users".to_string(), 
    ..Default::default() 
};

// Chain discovery methods
table_def
    .get_column_info(&conn)?
    .get_foreign_keys(&conn)?
    .get_indexes(&conn)?
    .get_constraints(&conn)?
    .pk_is_autoincrement(&conn)?;

When using the discovery module, SeaSchema produces a structured representation of your database tables. For a MySQL table like film_actor, the discovered TableDef includes detailed information about the table's engine, character set, columns (including types, nullability, and primary key status), indexes, and foreign key constraints.

TableDef {
    info: TableInfo {
        name: "film_actor",
        engine: InnoDb,
        auto_increment: None,
        char_set: Utf8Mb4,
        collation: Utf8Mb40900AiCi,
        comment: "",
    },
    columns: [
        ColumnInfo {
            name: "actor_id",
            col_type: SmallInt(
                NumericAttr {
                    maximum: None,
                    decimal: None,
                    unsigned: Some(true),
                    zero_fill: None,
                },
            ),
            null: false,
            key: Primary,
            default: None,
            extra: ColumnExtra {
                auto_increment: false,
                on_update_current_timestamp: false,
                generated: false,
                default_generated: false,
            },
            expression: None,
            comment: "",
        },
        // ... other columns
    ],
    indexes: [
        // ... index definitions
    ],
    foreign_keys: [
        // ... foreign key definitions
    ],
}