Comment surmonter les limitations de dénomination de PHP pour modéliser les opérateurs MongoDB

MongoDB fournit des pilotes pour différents langages, dont PHP. Pour simplifier le processus de création de pipelines d'agrégation en PHP, nous devons modéliser toutes les étapes et tous les opérateurs sous forme de fonctions pouvant être composées.

Le pipeline d'agrégation est une liste de documents « étape ». Nous allons donner un exemple d'interrogation de $match et de jointure à l'aide de $lookup :

db.orders.aggregate([
    {
        $match: {
            $or: [
                { status: "shipped" },
                { created_at: { $gte: ISODate("2023-01-01T00:00:00Z") } }
            ]
        }
    },
    {
        $lookup: {
            from: "inventory",
            localField: "product_id",
            foreignField: "product_id",
            as: "inventory_docs"
        }
    }
])

Chaque clé avec un préfixe dollar est un opérateur pour lequel nous souhaitons fournir une méthode d'usine.

Fonctions d'espace de noms

La solution la plus évidente est de créer une fonction d'espace de noms, par exemple : opérateur MongoDBOperatoreqof$eq.

namespace MongoDB\Operator;
function eq(mixed $value): array {
    return ['$eq' => $value];
}
function lookup(string $from, string $localField, string $foreignField, string $as): array {
    return ['$lookup' => [
        'from' => $from,
        'localField' => $localField,
        'foreignField' => $foreignField,
        'as' => $as,
    ]];
}

En utilisant des fonctions avec des paramètres nommés, les tubes seront écrits en PHP :

pipeline(
    match(
        or(
            query(status: eq('shipped')),
            query(date: gte(new UTCDateTime())),
        ),
    ),
    lookup(from: 'inventory', localField: 'product_id', foreignField: 'product_id', as: 'inventory_docs'),
);

Cependant, certains noms d'opérateurs entrent en conflit avec des mots-clés réservés en PHP. Nous ne pouvons pas créer de fonctions (globales ou espace de noms) avec les noms suivants :

et,

ou,

match,

unset,

set,

Ajouter un suffixe au nom de la fonction

Pour éviter le problème de conservation du nom, nous pouvons ajouter un préfixe ou un suffixe au nom de la fonction.

Suffixé du type d'opérateur :

function andQuery(...) { /* ... */ }
function matchStage(...) { /* ... */ }

Souligné :

function _and(...) { /* ... */ }
function _match(...) { /* ... */ }

Ou utilisez des émoticônes. Belle, mais peu pratique :

function ?and(...) { /* ... */ }
function ?match(...) { /* ... */ }

Méthode de classe statique

En fait, la liste des mots-clés réservés pour les noms de méthodes est plus courte. Nous pouvons créer des méthodes statiques sur les classes.

final class Stage {
    public static function lookup(...) { /* ... */ }
    public static function match(...) { /* ... */ }
}
final class Query {
    public static function and(...) { /* ... */ }
    public static function eq(...) { /* ... */ }
}

L’écriture est un peu longue, mais elle reste lisible.

new Pipeline(
    Stage::match(
        Query::or(
            Query::query(status: Query::eq('shipped')),
            Query::query(date: Query::gte(new UTCDateTime())),
        ),
    ),
    Stage::lookup(from: 'inventory', localField: 'product_id', foreignField: 'product_id', as: 'inventory_docs'),
);

Pour empêcher quiconque de créer une instance de cette classe, nous pouvons rendre le constructeur privé.

final class Operator {
    // ...
    private function __construct() {} // This constructor cannot be called 
}

Nous pouvons également utiliser enum sans shell. Enum accepte les méthodes statiques et ne peut pas être instancié.

enum Query {
    public static function and() { /* ... */ }
    public static function eq() { /* ... */ }
}

Les méthodes statiques de classe et d'énumération peuvent être appelées de la même manière.

Fermetures dans les variables

Comme nous ne parvenions pas à trouver une solution idéale, nous avons commencé à nous enthousiasmer pour les solutions improbables.

Si nous voulons une syntaxe courte qui ressemble beaucoup à la syntaxe MongoDB sans restrictions de nom, alors nous penserions à utiliser des variables pour stocker les fermetures. Notez que ceci (...) est la nouvelle syntaxe pour créer des fermetures dans PHP 8.1.

$eq = Operator::eq(...);
$and = Operator::and(...);

$PHP utilise un signe dollar pour les préfixes de variables et MongoDB utilise le même opérateur pour les préfixes.

pipeline(
    $match(
        $or(
            $query(status: $eq('shipped')),
            $query(date: $gte(new UTCDateTime())),
        ),
    ),
    $lookup(from: 'inventory', localField: 'product_id', foreignField: 'product_id', as: 'inventory_docs'),
);

La bibliothèque peut fournir ces fermetures sous forme de tableaux.

enum Query {
    public static function and(array ...$queries) { /* ... */ }
    public static function eq(mixed $value) { /* ... */ }
    public static function query(mixed ...$query) { /* ... */ }
    /** @return array{and:callable,eq:callable,query:callable} */
    public static function functions(): array {
        return [
            'and' => self::and(...),
            'eq' => self::eq(...),
            'query' => self::query(...),
        ];
    }
}

La syntaxe pour obtenir toutes les variables est un peu verbeuse, mais toujours lisible.

['and' => $and, 'eq' => $eq, 'query' => $query] = Query::functions();

extraire Nous pouvons importer toutes les variables dans la portée actuelle en utilisant une fonctionnalité magique de Laravel qui est souvent utilisée mais qui est détestée par PHPStorm et les outils d'analyse statique.

extract(Query::functions());
var_dump($and(
    $query(foo: $eq(5)),
    $query(bar: $eq(10))
));
// INFO: MixedFunctionCall - Cannot call function on mixed

Conclusion

Comme vous pouvez le constater, la dénomination des fonctions en PHP n'est pas si simple lorsqu'on utilise des mots-clés réservés.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!