Ci sono aspetti negativi nella scrittura di istruzioni PDO / mysqli nel mio codice direttamente vs utilizzando i miei metodi di wrapper di reindirizzamento?

TL; DR: per accedere alle funzionalità DB nella mia base di codice attualmente utilizzo un livello personalizzato in tutto il codice. Il livello ha bisogno di un aggiornamento per iniziare ad accettare le istruzioni preparate, che attualmente non è possibile. Ho una scelta tra abbandonare l'uso del livello personalizzato a favore di usare un altro livello direttamente - come PDO / mysqli, o continuare a usare il mio layer così com'è, ma modificarlo per accettare le istruzioni preparate (per quanto consentirà qualsiasi modifica necessaria ai costrutti incapsulati all'interno del livello stesso (nel mio caso usando myslqi / PDO dietro il mio livello, per evitare di dover riscrivere ogni singola chiamata al livello attraverso il mio codice)

Al momento ho estensioni mysqli nella mia base di codice PHP. Inoltre, nel mio codebase non uso istruzioni preparate. Le mie chiamate a DB sono racchiuse in chiamate di metodi proprietarie che in realtà sono solo reindirizzamenti a mysqli . Qualcosa del genere:

/*
 * Thousands of calls like this in my codebase:
 */
db_query("SELECT * FROM table WHERE id = " . db_input($id));

/*
 * Single file with these functions:
 */
function db_query($query)
{
     global $dblink;
     return mysqli_query($dblink, $query);
}

function db_input($param)
{
    //various checks on input, if/else (redacted)
    global $dblink;
    $param = mysqli_real_escape_string($dblink, $param);
    return $param;
}

Sto pensando di passare all'utilizzo di PDO, perché PDO ha chiamato parametri & dichiarazioni preparate e mi piacciono quelle. ( mysqli ha anche istruzioni preparate ma non i parametri con nome e io sono parziale a quello). Come convertirò è un'altra domanda, ma la mia preoccupazione è ... Diciamo che ho convertito con successo il mio codebase in PDO. Quali sono le mie conseguenze a lungo termine?

Opzione 1

Posso continuare a utilizzare i miei metodi proprietari come db_query che ora usano PDO all'interno di essi, come questo:

function db_query($query)
{
     return $db->query($query, PDO::FETCH_ASSOC);
}

Ciò manterrà il mio codice intatto e manterrà i miei effettivi metodi PDO nativi del DB in un singolo file

Opzione 2

Posso iniziare a usare PDO direttamente dal mio codice, in tutta la sua gloria, qualcosa come

$sql = 'SELECT * FROM table WHERE id = :id';
$sth = $dbh->prepare($sql, ... );
$sth->execute(array(':id' => 1));
$record = $sth->fetchAll();

Non userò più db_query .

Questo renderà il mio codice pietrificato nelle istruzioni PDO ovunque e molto più difficile da riscrivere se voglio passare da PDO in seguito

Obiettivo / Spirito della domanda : Sono interessato a effetti a lungo termine, effetti collaterali, mantenimento del codice base. In sostanza sto chiedendo .. continuo a racchiudere PDO / mysqli nelle mie chiamate db_query proprietarie, o comincio a usare PDO / mysqli direttamente nel mio codice?

Per utilizzare pienamente le istruzioni preparate da PDO e la piena potenza di PDO, mi sembra preferibile utilizzare l'Opzione 2, ma ciò significa che PDO sarà "fuori dal sacco del confinamento delle mie chiamate di reindirizzamento proprietario ( db_query() )." e i metodi PDO si riverseranno nella mia base di codice e non saranno più confinati in un singolo file "metodi DB". Sono preoccupato che farlo diventerà un inconveniente più avanti nel mio codice se dovessi decidere ad esempio di tornare a myqsli o passare a Doctrine o a cosa sei.

La mia alternativa è continuare a usare db_query , ma rinforzarlo per consentire parametri con nome, in pratica scrivere il mio wrapper su PDO. (questa sarà l'opzione 1 + disposizioni per scrivere un wrapper su PDO in modo da poter continuare ad usare db_query() + parametri con nome + PDO dietro le quinte). Ma mi aprirò ad un mondo di guai (lavoro extra, poco guadagno, bug insiti nella scrittura del mio involucro). Anche se questa opzione significa che avrò il mio layer proprietario che in teoria rimarrà intatto, mentre posso cambiare mysqli in PDO e back, dietro le quinte.

Suggerimento di Robert

Opzione 1 + modifica il wrapper per accettare i parametri

//to call:
db_query(
    'SELECT * FROM table WHERE id = :id', 
    array(':id' => 1)
);

//update to accept params
function db_query($sql, $params = null)
{
    $sth = $dbh->prepare($sql, ... );
    $sth->execute($params);
    $record = $sth->fetchAll();
}