Aller au contenu principal

Référence du Schema Builder

Ceci est la référence complète de l'API du Schema Builder de Sarah. Toutes les méthodes sont disponibles lors de la définition des migrations ou de la construction de requêtes.

Types de Colonnes​

uuid​

Crée une colonne UUID/VARCHAR(36).

// Définition seule
table.uuid("player_id");

// Avec valeur
table.uuid("player_id", playerUuid);

string​

Crée une colonne VARCHAR.

// Définition avec longueur
table.string("name", 64);

// Avec valeur
table.string("name", playerName);

text​

Crée une colonne TEXT pour les chaînes plus longues.

table.text("description");

longText​

Crée une colonne LONGTEXT pour les contenus très longs.

table.longText("content");

integer​

Crée une colonne INT.

table.integer("count");

bigInt​

Crée une colonne BIGINT.

// Définition seule
table.bigInt("balance");

// Avec valeur
table.bigInt("balance", 1000L);

decimal​

Crée une colonne DECIMAL.

// Précision par défaut
table.decimal("price");

// Précision personnalisée (10 chiffres au total, 2 après la virgule)
table.decimal("price", 10, 2);

// Avec valeur
table.decimal("price", 99.99);

bool​

Crée une colonne TINYINT(1)/BOOLEAN.

// Définition seule
table.bool("is_active");

// Avec valeur
table.bool("is_active", true);

json​

Crée une colonne JSON.

table.json("metadata");

blob​

Crée une colonne BLOB pour les données binaires.

// Définition seule
table.blob("data");

// Avec tableau d'octets
table.blob("data", byteArray);

// Avec objet (auto-sérialisé)
table.blob("data", myObject);

date​

Crée une colonne DATE.

table.date("birth_date", new Date());

timestamp​

Crée une colonne TIMESTAMP.

table.timestamp("verified_at");

object​

Stocke n'importe quel objet (sérialisé).

table.object("settings", settingsObject);

Auto Incrémentation​

autoIncrement​

Crée une clé primaire INT auto-incrémentée.

table.autoIncrement("id");

autoIncrementBigInt​

Crée une clé primaire BIGINT auto-incrémentée.

table.autoIncrementBigInt("id");

Modificateurs de Colonnes​

primary​

Marque la colonne comme clé primaire.

table.uuid("uuid").primary();

nullable​

Autorise les valeurs NULL.

table.string("nickname", 32).nullable();

unique​

Ajoute une contrainte UNIQUE.

table.string("email", 255).unique();

// Ou avec booléen explicite
table.string("email", 255).unique(true);

defaultValue​

Définit une valeur par défaut.

table.bigInt("balance").defaultValue(0);
table.string("status", 16).defaultValue("pending");
table.bool("active").defaultValue(true);

defaultCurrentTimestamp​

Définit la valeur par défaut à CURRENT_TIMESTAMP.

table.timestamp("created_at").defaultCurrentTimestamp();

foreignKey​

Crée une relation de clé étrangère.

// Basique (référence la colonne 'id')
table.uuid("user_id").foreignKey("users");

// Avec colonne personnalisée et suppression en cascade
table.uuid("user_id").foreignKey("users", "uuid", true);

Aides pour les Timestamps​

timestamps​

Ajoute les colonnes created_at et updated_at.

table.timestamps();

createdAt​

Ajoute seulement la colonne created_at.

table.createdAt();

updatedAt​

Ajoute seulement la colonne updated_at.

table.updatedAt();

Conditions WHERE​

where​

Égalité ou comparaison basique.

// Égalité
table.where("name", "Steve");
table.where("uuid", playerUuid);

// Comparaison
table.where("balance", ">", 1000);
table.where("level", ">=", 10);
table.where("score", "<", 50);
table.where("rank", "<=", 100);
table.where("status", "!=", "banned");

whereNull​

Vérifie les valeurs NULL.

table.whereNull("deleted_at");

whereNotNull​

Vérifie les valeurs non-NULL.

table.whereNotNull("verified_at");

whereIn​

Vérifie si la valeur est dans une liste.

// Varargs
table.whereIn("status", "active", "pending", "review");

// Liste
table.whereIn("name", Arrays.asList("Steve", "Alex"));

// Avec préfixe de table
table.whereIn("users", "status", statusList);

Opérations JOIN​

leftJoin​

table.leftJoin(
    "users",          // Table primaire
    "u",              // Alias
    "uuid",           // Colonne primaire
    "orders",         // Table étrangère
    "user_uuid"       // Colonne étrangère
);

rightJoin​

table.rightJoin("users", "u", "uuid", "orders", "user_uuid");

innerJoin​

table.innerJoin("users", "u", "uuid", "orders", "user_uuid");

fullJoin​

table.fullJoin("users", "u", "uuid", "orders", "user_uuid");

Join avec Condition Supplémentaire​

JoinCondition condition = new JoinCondition(...);
table.leftJoin("users", "u", "uuid", "orders", "user_uuid", condition);

Options SELECT​

addSelect​

Spécifier les colonnes à sélectionner.

table.addSelect("name");
table.addSelect("users", "name");              // Avec préfixe de table
table.addSelect("users", "name", "userName");  // Avec alias
table.addSelect("users", "name", "userName", "Unknown");  // Avec défaut

distinct​

Sélectionner seulement les lignes distinctes.

table.distinct();

orderBy​

Trier les résultats par ordre croissant.

table.orderBy("name");

orderByDesc​

Trier les résultats par ordre décroissant.

table.orderByDesc("created_at");

Types de Schema​

Sarah utilise différents types de schema pour différentes opérations :

TypeDescriptionCréé Par
CREATECréer une nouvelle tableSchemaBuilder.create()
ALTERModifier une table existanteSchemaBuilder.alter()
DROPSupprimer une tableSchemaBuilder.drop()
RENAMERenommer une tableSchemaBuilder.rename()
INSERTInsérer des donnéesSchemaBuilder.insert()
UPSERTInsérer ou mettre à jourSchemaBuilder.upsert()
UPDATEMettre à jour des donnéesSchemaBuilder.update()
SELECTRequêter des donnéesSchemaBuilder.select()
SELECT_COUNTCompter les lignesSchemaBuilder.selectCount()
DELETESupprimer des donnéesSchemaBuilder.delete()
CREATE_INDEXCréer un indexSchemaBuilder.createIndex()

Méthodes Statiques du SchemaBuilder​

create​

Créer une nouvelle table.

Schema schema = SchemaBuilder.create(migration, "users", table -> {
    table.uuid("uuid").primary();
    table.string("name", 64);
});

create (depuis template)​

Créer une table depuis un template de classe.

Schema schema = SchemaBuilder.create(migration, "users", UserDTO.class);

alter​

Modifier une table existante.

Schema schema = SchemaBuilder.alter(migration, "users", table -> {
    table.string("email", 255).nullable();
});

drop​

Supprimer une table.

Schema schema = SchemaBuilder.drop(migration, "old_table");

rename​

Renommer une table.

Schema schema = SchemaBuilder.rename(migration, "old_name", "new_name");

createIndex​

Créer un index.

Schema schema = SchemaBuilder.createIndex(migration, "users", "email");

insert​

Insérer des données.

Schema schema = SchemaBuilder.insert("users", table -> {
    table.uuid("uuid", uuid);
    table.string("name", name);
});

upsert​

Insérer ou mettre à jour des données.

Schema schema = SchemaBuilder.upsert("users", table -> {
    table.uuid("uuid", uuid).primary();
    table.string("name", name);
});

update​

Mettre à jour des données.

Schema schema = SchemaBuilder.update("users", table -> {
    table.string("name", newName);
    table.where("uuid", uuid);
});

select​

Requêter des données.

Schema schema = SchemaBuilder.select("users");

selectCount​

Compter les lignes.

Schema schema = SchemaBuilder.selectCount("users");

delete​

Supprimer des données.

Schema schema = SchemaBuilder.delete("users");

Méthodes d'Exécution​

execute​

Exécuter l'opération du schema.

int affectedRows = schema.execute(databaseConnection, logger);

executeSelect​

Exécuter une requête SELECT.

List<Map<String, Object>> results = schema.executeSelect(databaseConnection, logger);

executeSelect (avec mapping)​

Exécuter SELECT et mapper vers des objets.

List<UserDTO> users = schema.executeSelect(UserDTO.class, databaseConnection, logger);

executeSelectCount​

Exécuter une requête COUNT.

long count = schema.executeSelectCount(databaseConnection, logger);

Exemple Complet​

public class UserRepository {
    private final RequestHelper helper;

    public void createUser(User user) {
        helper.upsert("users", schema -> {
            schema.uuid("uuid", user.getUuid()).primary();
            schema.string("name", user.getName());
            schema.string("email", user.getEmail()).unique();
            schema.bigInt("balance", user.getBalance()).defaultValue(0);
            schema.bool("is_premium", user.isPremium()).defaultValue(false);
            schema.text("bio").nullable();
            schema.json("settings");
            schema.timestamps();
        });
    }

    public List<User> findPremiumUsers() {
        return helper.select("users", User.class, table -> {
            table.where("is_premium", true);
            table.whereNotNull("email");
            table.orderByDesc("balance");
        });
    }

    public List<User> searchUsers(String query) {
        return helper.select("users", User.class, table -> {
            table.where("name", "LIKE", "%" + query + "%");
        });
    }

    public void deleteInactiveUsers(Date threshold) {
        helper.delete("users", table -> {
            table.where("last_login", "<", threshold);
            table.where("is_premium", false);
        });
    }
}
Copyright © 2026 GroupeZ|Build #loading...|-