Data Flow¶

typedef struct WlSchema {
    WlModelConfig config;       /* model_config block (name, version) */
    WlTable *tables;            /* array of tables */
    size_t table_count;         /* number of tables */
    WlIndex *indexes;           /* array of indexes */
    size_t index_count;         /* number of indexes */
    WlView *views;              /* array of views */
    size_t view_count;          /* number of views */
    WlTrigger *triggers;        /* array of triggers */
    size_t trigger_count;       /* number of triggers */
} WlSchema;

typedef struct WlTable {
    char *name;                 /* SQLite table name */
    char *comment;              /* table comment (or NULL) */
    WlField *fields;            /* array of columns */
    size_t field_count;         /* number of columns */
    WlConstraint *constraints;  /* array of constraints */
    size_t constraint_count;    /* number of constraints */
    int strict;                 /* STRICT mode flag */
    int without_rowid;          /* WITHOUT ROWID flag */
} WlTable;

typedef struct WlField {
    char *name;                 /* column name */
    WlColType type;             /* normalized column type */
    char *raw_type;             /* original type string from model */
    int nullable;               /* 1 if nullable, 0 if NOT NULL */
    int primary_key;            /* 1 if part of primary key */
    int autoincrement;          /* 1 if AUTOINCREMENT */
    int unique;                 /* 1 if UNIQUE */
    char *default_value;        /* default expression (or NULL) */
    char *collate;              /* collation name (or NULL) */
    char *references_table;     /* foreign key target table (or NULL) */
    char *references_column;    /* foreign key target column (or NULL) */
    char *generated_expr;       /* generated column expression (or NULL) */
    int generated_stored;       /* 1 if STORED, 0 if VIRTUAL */
    char *comment;              /* column comment (or NULL) */
} WlField;

typedef struct WlPlan {
    WlPlanStep *steps;      /* array of SQL statements */
    size_t step_count;       /* number of steps */
} WlPlan;

typedef struct WlPlanStep {
    char *sql;               /* SQL statement to execute */
    int is_rebuild;          /* 1 if part of a table rebuild */
    char *table_name;        /* table name (if rebuild step) */
} WlPlanStep;

// wlite_migrate wraps everything in:
BEGIN IMMEDIATE;
  CREATE TABLE users__wlite_new (...);
  INSERT INTO users__wlite_new (...) SELECT ... FROM users;
  DROP TABLE users;
  ALTER TABLE users__wlite_new RENAME TO users;
  CREATE INDEX ...;
COMMIT;
// If any step fails: ROLLBACK

#include <stdio.h>
#include <string.h>
#include <wlite/wlite.h>

int main(void) {
    wlite_model *model = NULL;
    wlite_db *db = NULL;
    wlite_result rc;

    /* ==========================================
     * Stage 1: Parse
     * Load the .wlite model file into WlSchema
     * ========================================== */
    rc = wlite_model_load_file("app.wlite", &model);
    if (rc != WLITE_OK) {
        fprintf(stderr, "Parse error: %s\n", wlite_strerror(rc));
        return 1;
    }

    /* Validate the model structure */
    rc = wlite_model_validate(model);
    if (rc != WLITE_OK) {
        fprintf(stderr, "Model validation failed: %s\n", wlite_strerror(rc));
        wlite_model_free(model);
        return 1;
    }

    printf("Stage 1 complete: model loaded\n");
    printf("  Model: %s v%d\n",
           wl_schema_model_name(model->schema),
           wl_schema_model_version(model->schema));
    printf("  Tables: %zu\n", wlite_model_table_count(model));

    /* Print table details */
    for (size_t i = 0; i < wlite_model_table_count(model); i++) {
        const wlite_table *table = wlite_model_table(model, "users");
        if (!table) continue;
        printf("  Table: %s (%zu fields)\n",
               wlite_table_name(table),
               wlite_table_field_count(table));
        for (size_t j = 0; j < wlite_table_field_count(table); j++) {
            const wlite_field *field = wlite_table_field_at(table, j);
            if (!field) continue;
            printf("    %s: type=%d nullable=%d pk=%d\n",
                   wlite_field_name(field),
                   wlite_field_type(field),
                   wlite_field_is_nullable(field),
                   wlite_field_is_primary_key(field));
        }
    }

    /* ==========================================
     * Stage 2: Introspect
     * Open the database and read its schema
     * ========================================== */
    rc = wlite_open("app.db", &db);
    if (rc != WLITE_OK) {
        fprintf(stderr, "Database error: %s\n", wlite_strerror(rc));
        wlite_model_free(model);
        return 1;
    }

    printf("\nStage 2 complete: database opened and introspected\n");

    /* ==========================================
     * Stage 3: Diff
     * Compare model against database
     * ========================================== */
    /* Diff is computed internally by wlite_migrate */

    /* ==========================================
     * Stage 4: Plan
     * The plan is computed internally
     * ========================================== */
    printf("\nStage 3 & 4: diff and plan computed internally\n");

    /* ==========================================
     * Stage 5: Migrate
     * Execute the plan
     * ========================================== */
    rc = wlite_migrate(db, model);
    if (rc != WLITE_OK) {
        fprintf(stderr, "Migration failed: %s\n", wlite_strerror(rc));
        wlite_close(db);
        wlite_model_free(model);
        return 1;
    }
    printf("\nStage 5 complete: migration executed and committed\n");

    /* ==========================================
     * Query the database
     * ========================================== */
    wlite_stmt *stmt = NULL;
    rc = wlite_prepare(db,
        "INSERT INTO todos (title, completed, created_at) "
        "VALUES (?, 0, strftime('%s','now'))", &stmt);
    if (rc == WLITE_OK) {
        wlite_bind_text(stmt, 1, "Buy groceries");
        wlite_step(stmt);
        wlite_stmt_finalize(stmt);
    }

    rc = wlite_prepare(db,
        "SELECT id, title, completed FROM todos", &stmt);
    if (rc == WLITE_OK) {
        printf("\nTodos:\n");
        while (wlite_step(stmt) == WLITE_OK) {
            printf("  [%s] %s (id=%lld)\n",
                wlite_column_int64(stmt, 2) ? "x" : " ",
                wlite_column_text(stmt, 1),
                (long long)wlite_column_int64(stmt, 0));
        }
        wlite_stmt_finalize(stmt);
    }

    /* Cleanup */
    wlite_close(db);
    wlite_model_free(model);

    printf("\nDone.\n");
    return 0;
}