PHP UD3 OP ALTA

Introdución

Nesta unidade veremos como realizar operacións de alta sobre unha base de datos MySQL/MariaDB desde PHP 8.5.

O mecanismo principal empregado nos apuntes será PDO (PHP Data Objects). PDO proporciona unha interface uniforme para traballar con diferentes sistemas xestores de bases de datos e permite empregar consultas preparadas con parámetros.

Ao final da unidade inclúese tamén unha explicación equivalente empregando mysqli, como ampliación e para poder interpretar código existente escrito con esta extensión.

• Requirimentos previos:

• Ter creada a base de datos indicada nunha sección anterior.
• Ter gardados os parámetros de conexión nun arquivo separado, fóra de /var/www/html.
• Ter instalada e habilitada a extensión pdo_mysql.
• Os exemplos están pensados para PHP 8.5.

• CONSIDERACIÓNS:

• Crear un usuario/password con permisos de acceso a dita base de datos (sempre dádelle os mínimos permisos posibles, neste caso, serán os de SELECT/UPDATE/DELETE/INSERT/EXECUTE de toda a base de datos)
• Crear nun arquivo separado do sitio web todos os datos necesarios para conectarse á base de datos e onde van estar definidas as constantes coas ordes SQL, tal como vimos nun punto anterior desta sección.
• Lembrar poñer as ordes para amosar os erros que se poidan dar. Nunha aplicación final esas ordes hai que quitalas.
• En Linux, lembrar dar permiso 644 (rw,r,r) aos arquivos php e cambiar o propietario a www-data:www-data. Nos cartafoles permisos 755 cando rematedes.
• Ao principio ides faiar en moitas cousas. Lembrade ter posto o display_errors como vimos nas seccións anteriores. Tamén axuda moito facer un echo da sentenza a enviar á base de datos antes de enviala para ver que estea todo ben (espazos en branco, comillas,...).
• Lembrar que tamén podedes activar o debugger como está indicado nesta sección da wiki.

Organización dos exemplos

Nos exemplos completos empregaremos o seguinte esquema.

No arquivo /var/www/confBD/bd.php, que se atopa fóra da ruta pública /var/www/html, gardaremos os datos da conexión e as consultas que se vaian empregar:

<?php

define('SERVIDOR', 'localhost');
define('USUARIO', 'user_php');
define('PASSWORD', 'user_php');
define('BD', 'php');

define(
    'NOME_DA_CONSULTA',
    'SELECT col1, col2
     FROM taboa
     ORDER BY col1'
);

Nas páxinas PHP que accedan á base de datos empregaremos como base o seguinte esquema:

<?php

try {

    require '/var/www/confBD/bd.php';

    $dsn = sprintf(
        'mysql:host=%s;dbname=%s;charset=utf8mb4',
        SERVIDOR,
        BD
    );

    $conex = new PDO(
        $dsn,
        USUARIO,
        PASSWORD,
        [
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION
        ]
    );

    // Operacións coa base de datos...

} catch (PDOException $e) {

    // Rexistrar o erro nun log.
    // Nunha aplicación real tamén poderían empregarse
    // ferramentas como Monolog.
    error_log($e->getMessage());

    die('Erro relacionado coa base de datos.');

} catch (Throwable $e) {

    error_log($e->getMessage());

    die('Produciuse un erro na aplicación.');
}

IMPORTANTE:

• O usuario da aplicación non debe recibir detalles internos da excepción, nomes de táboas, rutas do servidor nin credenciais.
• Durante o desenvolvemento podemos consultar os logs do servidor para localizar o problema.
• En PHP 8 PDO emprega excepcións por defecto, pero nos exemplos indicamos explicitamente PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION para que o comportamento quede claro.
• Indicamos tamén PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, polo que os métodos fetch() e fetchAll() devolverán por defecto arrays asociativos.

Consultas preparadas

Sempre que unha consulta conteña datos variables procedentes do usuario ou da aplicación, empregaremos unha consulta preparada.

Por exemplo, non construiremos unha consulta desta forma:

$consulta = sprintf(
    "INSERT INTO estados (descripcion) VALUES ('%s')",
    $descripcion
);

Empregaremos un parámetro:

$stmt = $conex->prepare(
    'INSERT INTO estados (descripcion) VALUES (:descripcion)'
);

$stmt->execute([
    ':descripcion' => $descripcion
]);

Os parámetros representan valores. Non se poden utilizar para substituír nomes de táboas, nomes de columnas, palabras clave SQL ou fragmentos arbitrarios dunha consulta.

Alta de rexistros: INSERT

Para dar de alta novos rexistros nunha base de datos empregamos a instrución SQL INSERT.

Por exemplo:

INSERT INTO TABOA_1 (col1, col2)
VALUES (123, 'Texto de proba');

Desde PHP empregaremos normalmente unha consulta preparada.

Alta empregando PDO

Supoñamos a seguinte táboa:

CREATE TABLE TABOA_1 (
    col1 INT PRIMARY KEY AUTO_INCREMENT,
    col2 VARCHAR(100) NOT NULL
);

Neste caso non indicaremos col1 no INSERT, xa que MySQL/MariaDB xerará automaticamente o seu valor.

Arquivo /var/www/confBD/bd.php

<?php

define('SERVIDOR', 'localhost');
define('USUARIO', 'user_php');
define('PASSWORD', 'user_php');
define('BD', 'php');

define(
    'INSERIR_TABOA_1',
    'INSERT INTO TABOA_1 (col2)
     VALUES (:col2)'
);

Arquivo inserir_taboa_1.php

<?php

try {

    require '/var/www/confBD/bd.php';

    $dsn = sprintf(
        'mysql:host=%s;dbname=%s;charset=utf8mb4',
        SERVIDOR,
        BD
    );

    $conex = new PDO(
        $dsn,
        USUARIO,
        PASSWORD,
        [
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION
        ]
    );

    $valor = 'Texto de proba';

    $stmt = $conex->prepare(INSERIR_TABOA_1);

    $stmt->execute([
        ':col2' => $valor
    ]);

    echo 'Rexistro dado de alta correctamente.';

} catch (PDOException $e) {

    error_log($e->getMessage());

    die('Erro relacionado coa base de datos.');

} catch (Throwable $e) {

    error_log($e->getMessage());

    die('Produciuse un erro na aplicación.');
}

Neste exemplo:

• prepare() prepara a orde SQL.
• :col2 é un parámetro con nome.
• execute() envía o valor asociado ao parámetro e executa a orde.
• Non é necesario engadir comiñas manualmente ao valor nin empregar real_escape_string().

Número de filas afectadas

Despois dun INSERT, podemos consultar o número de filas afectadas mediante rowCount() sobre o obxecto PDOStatement:

$stmt->execute([
    ':col2' => $valor
]);

$numRexistros = $stmt->rowCount();

if ($numRexistros === 1) {
    echo 'Rexistro dado de alta correctamente.';
}

Nun INSERT dunha única fila o normal é obter o valor 1 se a operación se realizou.

Nota: non debemos utilizar rowCount() para determinar de forma portable o número de filas devoltas por un SELECT. Para un SELECT recuperaremos os datos con fetch() ou fetchAll().

Obtendo o valor dun campo autonumérico

Cando unha táboa ten unha clave primaria AUTO_INCREMENT, MySQL/MariaDB xera automaticamente o identificador da nova fila.

Non debemos inserir unha fila e realizar despois:

SELECT MAX(id) FROM taboa;

Nunha aplicación con varios usuarios outra conexión podería inserir unha fila entre ambas as operacións.

Con PDO empregaremos:

$id = $conex->lastInsertId();

lastInsertId() devolve o identificador asociado á última inserción realizada pola conexión.

Exemplo:

$stmt = $conex->prepare(INSERIR_TABOA_1);

$stmt->execute([
    ':col2' => $valor
]);

$id = $conex->lastInsertId();

echo 'Novo rexistro co id ' .
     htmlspecialchars($id, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');

Nota: PDO::lastInsertId() devolve normalmente unha cadea. Se necesitamos tratar o identificador como enteiro podemos convertelo explicitamente:

$id = (int) $conex->lastInsertId();

Caso práctico: mantemento da táboa ESTADOS

Imos facer unha pequena parte do mantemento da táboa ESTADOS.

Supoñamos:

CREATE TABLE estados (
    id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
    descripcion VARCHAR(100) NOT NULL
);

Crearemos:

• consultar_estados.php: amosa os estados existentes.
• alta_estado.php: amosa o formulario de alta.
• campos_estado.php: contén os campos reutilizables do formulario. Isto quere decir que os campos van ser os mesmos se damos de alta ou se modificamos un rexistro, polo que nas dúas operacións (alta / modificar) podemos empregar o mesmo include cós campos tendo en conta que no caso de modificación teremos que ter o código php necesario para cargar o dato do rexistro a modificar.
• procesar_alta_estado.php: valida os datos e realiza o INSERT.
• /var/www/confBD/bd.php: contén credenciais e consultas SQL.

Neste punto do curso enviaremos o resultado da operación mediante parámetros na URL. Máis adiante, cando se estuden as sesións, será preferible empregar unha mensaxe gardada na sesión e facer o patrón POST/Redirect/GET.

Arquivo /var/www/confBD/bd.php

<?php

define('SERVIDOR', 'localhost');
define('USUARIO', 'user_php');
define('PASSWORD', 'user_php');
define('BD', 'php');

define(
    'CONSULTAR_ESTADOS',
    'SELECT id, descripcion
     FROM estados
     ORDER BY descripcion'
);

define(
    'CONSULTAR_ESTADO_NUM',
    'SELECT COUNT(*) AS existe
     FROM estados
     WHERE UPPER(descripcion) = UPPER(:descripcion)'
);

define(
    'INSERIR_ESTADO',
    'INSERT INTO estados (descripcion)
     VALUES (:descripcion)'
);

Fixarse en que:

• As credenciais non están nun arquivo accesible directamente desde a web.
• As consultas SQL están centralizadas.
• Os datos variables empréganse mediante parámetros como :descripcion.
• Non se introduce directamente ningún dato do formulario dentro da cadea SQL.

Arquivo campos_estado.php

<label for="descripcion">Descrición:</label>

<input
    type="text"
    id="descripcion"
    name="descripcion"
    minlength="4"
    maxlength="100"
    required
>

A validación HTML mellora a experiencia do usuario, pero non substitúe a validación no servidor. Unha petición HTTP pode enviarse sen utilizar o formulario.

Arquivo alta_estado.php

<!DOCTYPE html>
<html lang="gl">
<head>
    <meta charset="UTF-8">
    <title>Alta de estado</title>
</head>
<body>

    <h1>Alta de estado</h1>

    <form method="post" action="procesar_alta_estado.php">

        <?php require 'campos_estado.php'; ?>

        <div>
            <button type="submit" name="btnOperacion" value="ALTA">
                Dar de alta
            </button>
        </div>

    </form>

</body>
</html>

Arquivo consultar_estados.php

<?php

try {

    require '/var/www/confBD/bd.php';

    $dsn = sprintf(
        'mysql:host=%s;dbname=%s;charset=utf8mb4',
        SERVIDOR,
        BD
    );

    $conex = new PDO(
        $dsn,
        USUARIO,
        PASSWORD,
        [
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION
        ]
    );

    $stmt = $conex->query(CONSULTAR_ESTADOS);
    $estados = $stmt->fetchAll();

} catch (PDOException $e) {

    error_log($e->getMessage());

    die('Erro relacionado coa base de datos.');

} catch (Throwable $e) {

    error_log($e->getMessage());

    die('Produciuse un erro na aplicación.');
}
?>
<!DOCTYPE html>
<html lang="gl">
<head>
    <meta charset="UTF-8">
    <title>Xestión de estados</title>
</head>
<body>

    <h1>Xestión de estados</h1>

    <form action="alta_estado.php" method="get">
        <button type="submit">Novo estado</button>
    </form>

    <table>
        <thead>
            <tr>
                <th>Id</th>
                <th>Descrición</th>
            </tr>
        </thead>
        <tbody>

        <?php foreach ($estados as $estado): ?>

            <tr>
                <td>
                    <?= htmlspecialchars(
                        (string) $estado['id'],
                        ENT_QUOTES | ENT_SUBSTITUTE,
                        'UTF-8'
                    ) ?>
                </td>

                <td>
                    <?= htmlspecialchars(
                        $estado['descripcion'],
                        ENT_QUOTES | ENT_SUBSTITUTE,
                        'UTF-8'
                    ) ?>
                </td>
            </tr>

        <?php endforeach; ?>

        </tbody>
    </table>

    <?php if (isset($_GET['id'])): ?>

        <p>
            Estado con id
            <?= htmlspecialchars(
                $_GET['id'],
                ENT_QUOTES | ENT_SUBSTITUTE,
                'UTF-8'
            ) ?>
            dado de alta correctamente.
        </p>

    <?php endif; ?>

    <?php if (isset($_GET['error'])): ?>

        <p>
            <?= htmlspecialchars(
                $_GET['error'],
                ENT_QUOTES | ENT_SUBSTITUTE,
                'UTF-8'
            ) ?>
        </p>

    <?php endif; ?>

</body>
</html>

Neste caso CONSULTAR_ESTADOS non leva datos variables, polo que podemos executar directamente query().

Se a consulta tivese datos variables deberiamos empregar prepare() e execute().

Arquivo procesar_alta_estado.php

<?php

try {

    require '/var/www/confBD/bd.php';

    $dsn = sprintf(
        'mysql:host=%s;dbname=%s;charset=utf8mb4',
        SERVIDOR,
        BD
    );

    $conex = new PDO(
        $dsn,
        USUARIO,
        PASSWORD,
        [
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION
        ]
    );

    if (
        !isset($_POST['btnOperacion']) ||
        $_POST['btnOperacion'] !== 'ALTA'
    ) {
        throw new RuntimeException('Operación non válida.');
    }

    $descripcion = trim($_POST['descripcion'] ?? '');

    $lonxitude = function_exists('mb_strlen')
        ? mb_strlen($descripcion, 'UTF-8')
        : strlen($descripcion);

    if ($lonxitude < 4 || $lonxitude > 100) {

        header(
            'Location: consultar_estados.php?error=' .
            urlencode(
                'A descrición debe ter entre 4 e 100 caracteres.'
            )
        );
        exit;
    }

    if (function_exists('mb_strtoupper')) {
        $descripcion = mb_strtoupper($descripcion, 'UTF-8');
    } else {
        $descripcion = strtoupper($descripcion);
    }

    $stmt = $conex->prepare(CONSULTAR_ESTADO_NUM);

    $stmt->execute([
        ':descripcion' => $descripcion
    ]);

    $fila = $stmt->fetch();

    if ($fila !== false && (int) $fila['existe'] > 0) {

        header(
            'Location: consultar_estados.php?error=' .
            urlencode('Ese estado xa existe.')
        );
        exit;
    }

    $stmt = $conex->prepare(INSERIR_ESTADO);

    $stmt->execute([
        ':descripcion' => $descripcion
    ]);

    $id = (int) $conex->lastInsertId();

    header(
        'Location: consultar_estados.php?id=' .
        urlencode((string) $id)
    );
    exit;

} catch (PDOException $e) {

    error_log($e->getMessage());

    header(
        'Location: consultar_estados.php?error=' .
        urlencode('Erro relacionado coa base de datos.')
    );
    exit;

} catch (Throwable $e) {

    error_log($e->getMessage());

    header(
        'Location: consultar_estados.php?error=' .
        urlencode('Produciuse un erro na aplicación.')
    );
    exit;
}

Neste exemplo debemos destacar varias ideas:

• Os datos do formulario compróbanse de novo no servidor.
• trim() elimina espazos ao principio e ao final.
• A validación da lonxitude forma parte das regras da aplicación.
• A conversión a maiúsculas é unha normalización, non unha medida contra SQL Injection.
• Non se emprega real_escape_string().
• Os valores variables entran nas consultas mediante parámetros.
• Os detalles das excepcións escríbense no log, non se amosan ao usuario.
• Despois de header('Location: ...') emprégase exit para deter a execución.

Mellora: evitar duplicados tamén na base de datos

A comprobación cun SELECT é útil para explicar o proceso, pero nun entorno concorrente dúas peticións poderían comprobar ao mesmo tempo que o valor non existe e intentar inserilo.

Se a regra da aplicación indica que non pode haber dous estados coa mesma descrición, a base de datos tamén debería garantir esa restrición mediante un índice ou restrición UNIQUE axeitada á colación empregada.

Por exemplo:

ALTER TABLE estados
ADD CONSTRAINT uq_estados_descripcion
UNIQUE (descripcion);

A aplicación debe seguir tratando a posible excepción producida pola base de datos.

Alta utilizando procedementos almacenados

Podemos encapsular parte da lóxica nun procedemento almacenado de MySQL/MariaDB.

Neste exemplo o procedemento:

• comproba se o estado xa existe;
• devolve -1 se xa existe;
• realiza o INSERT en caso contrario;
• devolve o identificador xerado mediante LAST_INSERT_ID().

Procedemento almacenado

DELIMITER $$

CREATE PROCEDURE INSERIR_ESTADO_PROC(
    IN p_descripcion VARCHAR(100)
)
etiqueta: BEGIN

    IF (
        SELECT COUNT(*)
        FROM estados
        WHERE UPPER(descripcion) = UPPER(p_descripcion)
    ) > 0 THEN

        SELECT -1 AS valor_devolto;
        LEAVE etiqueta;

    END IF;

    INSERT INTO estados (descripcion)
    VALUES (p_descripcion);

    SELECT LAST_INSERT_ID() AS valor_devolto;

END$$

DELIMITER ;

Arquivo /var/www/confBD/bd.php

Engadimos a chamada ao procedemento:

define(
    'PROCEDEMENTO_INSERIR_ESTADO',
    'CALL INSERIR_ESTADO_PROC(:descripcion)'
);

Chamando ao procedemento con PDO

Arquivo procesar_alta_estado_proc.php

<?php

try {

    require '/var/www/confBD/bd.php';

    $dsn = sprintf(
        'mysql:host=%s;dbname=%s;charset=utf8mb4',
        SERVIDOR,
        BD
    );

    $conex = new PDO(
        $dsn,
        USUARIO,
        PASSWORD,
        [
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION
        ]
    );

    if (
        !isset($_POST['btnOperacion']) ||
        $_POST['btnOperacion'] !== 'ALTA'
    ) {
        throw new RuntimeException('Operación non válida.');
    }

    $descripcion = trim($_POST['descripcion'] ?? '');

    $lonxitude = function_exists('mb_strlen')
        ? mb_strlen($descripcion, 'UTF-8')
        : strlen($descripcion);

    if ($lonxitude < 4 || $lonxitude > 100) {

        header(
            'Location: consultar_estados.php?error=' .
            urlencode(
                'A descrición debe ter entre 4 e 100 caracteres.'
            )
        );
        exit;
    }

    $descripcion = mb_strtoupper($descripcion, 'UTF-8'); // A extensión mbstring ten que estar habilitada. Senon empregar strtoupper

    $stmt = $conex->prepare(
        PROCEDEMENTO_INSERIR_ESTADO
    );

    $stmt->execute([
        ':descripcion' => $descripcion
    ]);

    $fila = $stmt->fetch();

    $stmt->closeCursor();

    if ($fila === false) {

        throw new RuntimeException(
            'O procedemento non devolveu ningún resultado.'
        );
    }

    $valorDevolto = (int) $fila['valor_devolto'];

    if ($valorDevolto === -1) {

        header(
            'Location: consultar_estados.php?error=' .
            urlencode('Ese estado xa existe.')
        );
        exit;
    }

    header(
        'Location: consultar_estados.php?id=' .
        urlencode((string) $valorDevolto)
    );
    exit;

} catch (PDOException $e) {

    error_log($e->getMessage());

    header(
        'Location: consultar_estados.php?error=' .
        urlencode('Erro relacionado coa base de datos.')
    );
    exit;

} catch (Throwable $e) {

    error_log($e->getMessage());

    header(
        'Location: consultar_estados.php?error=' .
        urlencode('Produciuse un erro na aplicación.')
    );
    exit;
}

Con PDO non empregamos multi_query(). Executamos a chamada mediante unha consulta preparada e, despois de recuperar o resultado que nos interesa, empregamos closeCursor() para liberar os resultados pendentes antes de executar outra orde na mesma conexión.

Tratamento dos datos e caracteres especiais

Esta parte require diferenciar claramente tres problemas distintos:

1. evitar SQL Injection;
2. validar ou normalizar datos segundo as regras da aplicación;
3. evitar Cross-Site Scripting (XSS) ao amosar datos nunha páxina HTML.

Non debemos mesturar estas tres operacións.

SQL Injection

Para introducir valores variables nunha consulta SQL empregaremos consultas preparadas:

$stmt = $conex->prepare(
    'INSERT INTO autores (nome)
     VALUES (:nome)'
);

$stmt->execute([
    ':nome' => "O'Reilly"
]);

Non necesitamos modificar O'Reilly nin engadir barras invertidas. O valor envíase como dato asociado ao parámetro :nome.

Por tanto, con PDO e consultas preparadas non debemos empregar mysqli::real_escape_string().

Validación e normalización

A validación comproba se un dato cumpre as regras da aplicación.

Por exemplo:

$descripcion = trim($_POST['descripcion'] ?? '');

if ($descripcion === '') {
    die('A descrición é obrigatoria.');
}

A normalización transforma un valor á representación decidida pola aplicación.

Por exemplo:

$descripcion = mb_strtoupper(
    $descripcion,
    'UTF-8'
);

Ningunha destas operacións substitúe unha consulta preparada.

Saída HTML e XSS

Se un dato se vai inserir como texto nun documento HTML, debemos escapar a saída:

echo htmlspecialchars(
    $fila['descripcion'],
    ENT_QUOTES | ENT_SUBSTITUTE,
    'UTF-8'
);

Isto debe facerse ao amosar o dato en HTML, non necesariamente antes de gardalo na base de datos.

Por exemplo, se un usuario introduce:

<script>alert('ola')</script>

podemos gardar o texto orixinal se as regras da aplicación o permiten. Cando o amosemos nun contexto HTML aplicaremos htmlspecialchars() para que o navegador o trate como texto e non como marcado executable.

IMPORTANTE: o escapado depende do contexto de saída. htmlspecialchars() é apropiado para texto HTML, pero outros contextos como JavaScript, URLs ou atributos especiais poden requirir tratamentos diferentes.

Transaccións

• Se unha operación lóxica require varias modificacións na base de datos e todas deben completarse ou cancelarse xuntas, debemos empregar unha transacción.

Isto será explicado posteriormente nun punto da wiki.

Arquivo /var/www/confBD/bd.php

define(
    'INSERIR_PEDIDO',
    'INSERT INTO pedidos (cliente)
     VALUES (:cliente)'
);

define(
    'INSERIR_LINA_PEDIDO',
    'INSERT INTO lina_pedido (pedido_id, produto_id, cantidade)
     VALUES (:pedido_id, :produto_id, :cantidade)'
);

Exemplo de uso

<?php

try {

    require '/var/www/confBD/bd.php';

    $dsn = sprintf(
        'mysql:host=%s;dbname=%s;charset=utf8mb4',
        SERVIDOR,
        BD
    );

    $conex = new PDO(
        $dsn,
        USUARIO,
        PASSWORD,
        [
            PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION
        ]
    );

    $conex->beginTransaction();

    $stmtPedido = $conex->prepare(INSERIR_PEDIDO);

    $stmtPedido->execute([
        ':cliente' => 'Ana'
    ]);

    $pedidoId = (int) $conex->lastInsertId();

    $stmtLinha = $conex->prepare(
        INSERIR_LINA_PEDIDO
    );

    $stmtLinha->execute([
        ':pedido_id' => $pedidoId,
        ':produto_id' => 10,
        ':cantidade' => 2
    ]);

    $conex->commit();

} catch (PDOException $e) {

    if (
        isset($conex) &&
        $conex->inTransaction()
    ) {
        $conex->rollBack();
    }

    error_log($e->getMessage());

    die('Erro relacionado coa base de datos.');

} catch (Throwable $e) {

    if (
        isset($conex) &&
        $conex->inTransaction()
    ) {
        $conex->rollBack();
    }

    error_log($e->getMessage());

    die('Produciuse un erro na aplicación.');
}

A transacción garante que non quede gardada só unha parte da operación.

mysqli como ampliación

PDO será a opción principal nos apuntes, pero PHP tamén dispón da extensión mysqli para traballar especificamente con MySQL/MariaDB.

Se empregamos mysqli, tamén debemos utilizar consultas preparadas cando existan datos variables.

Conexión con mysqli

Exemplo equivalente de conexión:

<?php

try {

    require '/var/www/confBD/bd.php';

    mysqli_report(
        MYSQLI_REPORT_ERROR |
        MYSQLI_REPORT_STRICT
    );

    $conex = new mysqli(
        SERVIDOR,
        USUARIO,
        PASSWORD,
        BD
    );

    $conex->set_charset('utf8mb4');

    // Operacións coa base de datos...

} catch (mysqli_sql_exception $e) {

    error_log($e->getMessage());

    die('Erro relacionado coa base de datos.');

} catch (Throwable $e) {

    error_log($e->getMessage());

    die('Produciuse un erro na aplicación.');
}

INSERT preparado con mysqli

Se no arquivo bd.php temos:

define(
    'INSERIR_ESTADO_MYSQLI',
    'INSERT INTO estados (descripcion)
     VALUES (?)'
);

podemos facer:

$stmt = $conex->prepare(
    INSERIR_ESTADO_MYSQLI
);

$stmt->bind_param(
    's',
    $descripcion
);

$stmt->execute();

$id = $conex->insert_id;

A letra s indica que o parámetro é unha cadea.

Outros tipos habituais son:

• i: enteiro.
• d: número real.
• s: cadea.
• b: dato binario.

real_escape_string()

mysqli::real_escape_string() segue existindo, pero non será a técnica principal dos apuntes para introducir datos variables nas consultas.

Empregaremos preferentemente:

$stmt = $conex->prepare(
    'INSERT INTO autores (nome)
     VALUES (?)'
);

$stmt->bind_param(
    's',
    $nome
);

$stmt->execute();

Isto evita ter que construír manualmente a consulta SQL concatenando ou interpolando valores.

Resumo

• En PHP 8.5 empregaremos PDO como mecanismo principal de acceso a MySQL/MariaDB.
• As credenciais e as consultas gardaranse en /var/www/confBD/bd.php, fóra de /var/www/html.
• Para consultas con datos variables empregaremos prepare() e execute().
• Non concatenaremos datos recibidos do usuario dentro dunha orde SQL.
• Para obter un identificador AUTO_INCREMENT empregaremos PDO::lastInsertId().
• Para coñecer as filas afectadas por un INSERT, UPDATE ou DELETE podemos empregar PDOStatement::rowCount().
• Non empregaremos rowCount() como método portable para contar os resultados dun SELECT.
• As excepcións detalladas rexistraranse no log; ao usuario amosaráselle unha mensaxe xenérica.
• htmlspecialchars() aplicarase ao xerar saída HTML cando sexa necesario evitar que un dato se interprete como marcado.
• A validación, a normalización, a prevención de SQL Injection e o escapado da saída son problemas diferentes.
• mysqli explicarase como alternativa adicional, tamén empregando consultas preparadas.