Come faccio a sapere quando effettuare il refactoring delle chiamate globali alle query del database e quando lasciarle da sole?

Ho le seguenti chiamate di istruzioni globali sparse in tutta la mia base di codice legacy PHP:

$jobnumber = db_quick($sql);
db_query($sql);

Cioè, quelle chiamate di funzione sono state inizializzate nello scope globale e esse stesse richiamano un oggetto globale MySQL precedentemente inizializzato, cioè:

//initializes MySQL connection object in the global scope
$dblink = MySqlConnector::getMySql();

function db_query($sql)
{
    //previously initialized MySQL connection object
    global $dblink;  

    //native MySQL API call:
    return mysqli_query($dblink, $sql);
}

Domanda

Ci sono dei vantaggi nel rifattorizzare queste affermazioni globali, oltre a dire semplicemente "Le ho rimosse dall'ambito globale"?

Lo spirito della mia domanda va ... quelli sono già nella base di codice, e funzionano. Devo scherzare con loro? Finora [3 anni di lavoro con il codice] non ci sono stati danni apparenti. Anche con la transizione da deprecato mysql a mysqli, è stata una transizione indolore. La conservazione di questi come globale causerà danni misurabili in seguito? Sono abbastanza buoni da essere lasciati così com'è?

Cosa succede se refactoring?

A proposito di refactor, sto pensando di usare un pattern Singleton per l'istanza del link al database e poi chiamarlo tramite una classe istanziata, che chiama Singleton. Mi piace così:

//in a calling class:
$repository = new GenericRepository();
$repository->getMySql()->persist($sql);
$value = $repository->getMySql()->paramQuery($sql, $param);

//GenericRepository makes a static call to the actual connector
class GenericRepository 
{
    final public function getMySql()
    {
        if ($this->link === null)
            $this->link = MySqlConnector::getMySql();

            return $this->link;
    }
}

//Connector calls MySQL API
class MySqlConnector
{

    public static function getMySql()
    {
        if (null === static::$instance)
        {
            include 'include/config.php';

            //class MySql extends mysqli library
            static::$instance = new MySql(DBHOST, DBUSER, DBPASS);
        }

        return static::$instance;
    }
}

Quindi, in sostanza, refactoring, rimuoverò i metodi del database globale e li sostituirò con chiamate istanziate al pattern Singleton. Il cambio di codice sarà piuttosto esteso, poiché ci sono un paio di migliaia di chiamate al database globali.

Effetti del precedente Refactoring

Attualmente posso chiamare i metodi "da qualsiasi luogo" - sono globali.

db_query($sql);    

Dopo il refactoring potrò ancora chiamarli "da qualsiasi luogo", ma usando una stringa di connessione più lunga.

(new \Namespace\GenericRepository())->getMySql()->persist($sql);

Sembra un po 'un danno - una stringa più lunga, più da digitare, più da copiare e amp; incolla. Ci sono davvero dei benefici in questo?