DBTables, clase utilitaria para consultas preparadas - https://es.stackoverflow.com/q/594082/29967, Php

Language: Layout:

<?php //php 7.2.24
/*
    DBTables, clase utilitaria para consultas preparadas - https://es.stackoverflow.com/q/594082/29967
    Clase para crear consultas preparadas dinámicas
    de cualquier tabla que se pase en parámetro
    Esta clase podría ser muy útil por ejemplo para manejar
    listas blancas, y aumentar la seguridad de cara a
    riesgos de Inyección SQL
*/
class DBTables
{
    /*
        $tables es un array que representará tus tablas
        simplemente está, por fuera, el nombre de la tabla:
        user, film, etc
        y dentro de cada una un array asociativo con
        el nombre de cada columna y el tipo de dato
        usando las constantes predefinidas de PDO
        esto será útil para el bindParam...
        $tables se puede ampliar, indicando por ejemplo
        si la columna es AUTO_INCREMENT, para excluirla
        en los casos de INSERT, etc.
        Es IMPORTANTE evitar el uso de palabras reservadas
        para tablas y columnas, por ejemplo, "user"
        suele ser una palabra reservada, por eso para el ejemplo
        he preferido usar "user_app" como nombre de tabla
        o "film_year" como nombre de columna en la tabla "film"
    */
    private $tables=
        array(
            "user_app"=>
                array(
                        "columns"=>
                            array(
                                    "user_id"=>PDO::PARAM_INT,
                                    "user_name"=>PDO::PARAM_STR,
                                    "user_lastname"=>PDO::PARAM_STR,
                                 )
                    ),
             "film"=>
                array(
                        "columns"=>
                            array(
                                    "film_id"=>PDO::PARAM_INT,
                                    "title"=>PDO::PARAM_STR,
                                    "description"=>PDO::PARAM_STR,
                                    "film_year"=>PDO::PARAM_INT,
                                    "language_id"=>PDO::PARAM_INT,                              
                                 )
                    ),       
            );

public function __construct() 
    {}

/*
        Este método crea la consulta preparada
        de cualquier tabla y devuelve un array
        con dos claves: una clave "query"
        que contiene la consulta preparada
        y una clave "columns" que devuelve las
        columnas de la tabla, para saber el tipo de dato
        a la hora del bindParam.
        Ampliando la clase, se podría pasar un parámetro
        con el tipo de consulta que se quiere pasar: 
        INSERT, UPDATE, SELECT
        y en base a ello, trabajar la sintaxis de la
        instrucción que se va a preparar
    */
    public function prepareQuery($tableName) 
    {
        $table=$this->tables[$tableName] ?? null;
        if( !$table ) 
        {
            throw new Exception("La tabla $tableName no existe.");
        }
        $columns=array_keys($table["columns"]);
        $sql=sprintf("INSERT INTO %s (%s) VALUES (%s)",
                      $tableName,
                      implode(",",$columns),
                      sprintf("%s%s",":",implode(",:",$columns))
                     );
        return array("query"=>$sql, "columns"=>$table['columns']);
    }   
}

/*
    Varios casos de uso.
    Primero pasamos la tabla "user_app"
    y luego la tabla "film"
*/
try 
{
    /*
        $users y $films son datos que podrían ser recogidos
        en cualquier contexto de la aplicación
        La clave aquí es que los nombres de columna coincidan
        con los nombres de columna de cada tabla
        definida en DBTables
    */
    $users=array(
                    array("user_id"=>1,"user_name"=>"Pedro", "user_lastname"=>"Díaz"),
                    array("user_id"=>2,"user_name"=>"Marta", "user_lastname"=>"Pérez"), 
                );
    $films=array(
            array("film_id"=>1,"title"=>"FilmA", "description"=>"Descr. A", "film_year"=>2022,"language_id"=>3),
            array("film_id"=>2,"title"=>"FilmB", "description"=>"Descr. B", "film_year"=>2023,"language_id"=>2),
            array("film_id"=>3,"title"=>"FilmC", "description"=>"Descr. C", "film_year"=>2024,"language_id"=>1),  
    );    
    
    /*
        Instanciamos la clase y veremos que
        podremos usar la misma instancia, tanto para users como para films
    */
    $dbTables=new DBTables();
    /*
        Pasamos "user_app" para preparar e insertar
        los datos de los usuarios
    */
    $queryWithColumns=$dbTables->prepareQuery("user_app");

/*
        Prueba de los datos:
        un var_dump para mostrar lo que devuelve el método
        Y los bucles for, imprimiendo, esto sería lo que usaríamos
        para los bindParam dentro del for interno: foreach ($row as $column=>&$value) {
        y en el for externo el execute
    */
    var_dump($queryWithColumns);
    #La consulta preparada estará en $queryWithColumns["query"]
    foreach ($users as $row) {
        foreach ($row as $column=>&$value) {
            #Aquí irían los bindParam
            printf(":%s %s %d %s",$column,$value,$queryWithColumns["columns"][$column],PHP_EOL);                              
        }
        echo PHP_EOL;
        #Aquí iría el execute
    }
    
    /*
        Ahora la prueba con "film"
        el código es el mismo, solo cambia el parámetro
        que le pasamos a prepareQuery() y al primer foreach
    */
    echo PHP_EOL,"Prueba de film",PHP_EOL;
    $queryWithColumns=$dbTables->prepareQuery("film");
    var_dump($queryWithColumns);
    foreach ($films as $row) {
        foreach ($row as $column=>&$value) {
            #Aquí irían los bindParam
            printf(":%s %s %d %s",$column,$value,$queryWithColumns["columns"][$column],PHP_EOL);                              
        }
        echo PHP_EOL;
        #Aquí iría el execute
    }
    
} 
catch (Exception $e) 
{
    echo $e->getMessage();
}

[ + ] Show input
Absolute running time: 0.16 sec, cpu time: 0.04 sec, memory peak: 25 Mb, absolute service time: 0,24 sec

DBTables, clase utilitaria para consultas preparadas - https://es.stac...