yato

yato — encore un autre orchestrateur de transformation

yato est le plus petit orchestrateur au monde pour orchestrer les transformations de données SQL au-dessus de DuckDB. Vous donnez simplement un dossier avec des requêtes SQL et il devine le DAG et exécute les requêtes dans le bon ordre.

Installation

Yato fonctionne avec Python 3.9+.

pip install yato-lib

Commencer

Créez un dossier nommé sql et placez-y vos fichiers SQL, vous pouvez par exemple utiliser les 2 requêtes données dans le dossier exemple.

 from yato import Yato

yato = Yato (
    # The path of the file in which yato will run the SQL queries.
    # If you want to run it in memory, just set it to :memory:
    database_path = "tmp.duckdb" ,
    # This is the folder where the SQL files are located.
    # The names of the files will determine the name of the table created.
    sql_folder = "sql/" ,
    # The name of the DuckDB schema where the tables will be created.
    schema = "transform" ,
)

# Runs yato against the DuckDB database with the queries in order.
yato . run ()

Vous pouvez également exécuter Yato avec le cli :

yato run --db tmp.duckdb sql/

Fonctionne avec dlt

yato est conçu pour fonctionner en paire avec dlt. dlt gère le chargement des données et yato la transformation des données.

 import dlt
from yato import Yato

yato = Yato (
    database_path = "db.duckdb" ,
    sql_folder = "sql/" ,
    schema = "transform" ,
)

# You restore the database from S3 before runnning dlt
yato . restore ()

pipeline = dlt . pipeline (
    pipeline_name = "get_my_data" ,
    destination = "duckdb" ,
    dataset_name = "production" ,
    credentials = "db.duckdb" ,
)

data = my_source ()

load_info = pipeline . run ( data )

# You backup the database after a successful dlt run
yato . backup ()
yato . run ()

Utilisation avancée

Mélanger la transformation SQL et Python

Même si nous aimerions tout faire en SQL, il arrive parfois qu'écrire une transformation en Python avec des pandas (ou d'autres librairies) soit plus rapide.

C'est pourquoi vous pouvez mélanger les transformations SQL et Python dans Yato.

Pour ce faire vous pouvez ajouter un fichier Python dans le dossier de transformation. Dans ce fichier Python, vous devez implémenter une classe Transformation avec une méthode run . Si vous dépendez d'une autre transformation SQL, vous devez définir la requête SQL source dans une méthode statique appelée source_sql .

Ci-dessous un exemple de transformation (comme orders.py ). Le framework comprendra que les commandes doivent être exécutées après source_orders.

 from yato import Transformation


class Orders ( Transformation ):
    @ staticmethod
    def source_sql ():
        return "SELECT * FROM source_orders"

    def run ( self , context , * args , ** kwargs ):
        df = self . get_source ( context )

        df [ "new_column" ] = 1

        return df

Variables d'environnement

yato prend en charge les variables env dans les requêtes SQL (comme dans l'exemple ci-dessous). Attention par défaut cela pose un problème si la variable env n'est pas définie.

 SELECT {{ VALUE }}, {{ OTHER_VALUE }}

Autres fonctionnalités

• Sous-dossiers — dans le dossier principal, créez simplement les dossiers dans lesquels vous souhaitez organiser vos transformations, les dossiers n'ont aucun impact sur l'inférence DAG. Attention à ne pas avoir 2 transformations portant le même nom.
• Plusieurs instructions SQL — dans le même fichier, Yato les exécutera dans l'ordre dans lequel elles apparaissent. Attention : vous ne pouvez avoir qu'une seule instruction SELECT. D'autres instructions peuvent être SET, etc. Pourtant, les dépendances (d'où le DAG) sont calculées sur le SELECT uniquement pour le moment.

Comment ça marche ?

Yato Runs s'appuie sur l'incroyable bibliothèque SQLGlot pour analyser syntaxiquement les requêtes SQL et créer un DAG des dépendances. Ensuite, il exécute les requêtes dans le bon ordre.

FAQ

Pourquoi choisir Yato plutôt que Dbt Core, SQLMesh ou Lea ?

Il n'y a pas de bonne réponse à cette question mais Yato n'a pas été conçu pour remplacer complètement les orchestrateurs de transformation SQL. Yato est censé être rapide à installer et à configurer avec quelques fonctionnalités. Vous donnez un dossier contenant un tas de SQL (ou Python) et il s'exécute.

Vous pouvez imaginer Yato comme du noir pour l'orchestration des transformations. Un seul paramètre et c'est parti.

Pourquoi seulement DuckDB

Pour le moment, Yato ne prend en charge DuckDB qu'en tant que backend/dialecte. La raison principale est que DuckDB propose des fonctionnalités qui seraient difficiles à implémenter avec une base de données client/serveur. Je n'exclus pas d'ajouter Postgres ou des entrepôts cloud, mais cela nécessiterait de réfléchir à la manière de le faire, notamment lors du mélange des transformations SQL et Python.

Yato peut-il prendre en charge les modèles Jinja ?

Non, je ne le fais pas. Je ne suis pas sûr que ce soit le cas. Je pense que lorsque vous ajoutez des modèles Jinja à vos requêtes SQL, vous êtes déjà trop loin. Je recommanderais de ne pas utiliser Yato pour cela. Pourtant, si vous voulez vraiment utiliser Yato et que l'assistance de Jinja me contacte.

Petite remarque, Yato prend en charge les variables d'environnement dans les requêtes SQL.

Puis-je contribuer ?

Oui évidemment, pour le moment le projet en est à ses débuts et je serais heureux d'avoir des retours et des contributions. Gardez à l’esprit qu’il s’agit d’un petit orchestrateur et que combler toute l’écart avec les autres orchestrateurs n’a aucun sens car il suffit de les utiliser, ils sont géniaux.

Limites

• Vous ne pouvez pas avoir 2 transformations portant le même nom.
• Il n'y a pas de tests pour le moment. J'y travaille.