Questa “guida” (se così possiamo chiamarla), è un modo, uno dei tanti, che possiamo sviluppare per renderci la vita migliore quando si tratta di lavorare con un database di tipo MySql attraverso PHP.
Niente di più semplice e, credetemi, si trovano molte risorse sul web legate a questo argomento. Ho voluto scrivere anche io un piccolo articolo giusto per promemoria e per fare da “base” ad ogni altro articolo che scriverò e che necessiterà di una connessione ad un database.
Per prima cosa sarà necessario scegliere il nome della classe. All’inizio ho utilizzato questa classe esclusivamente per avere funzioni da utilizzare sul database, ma la sua evoluzione è stata quella di ampliarla non solo ad db, ma anche ad una interessante serie di altre funzioni che, ciclicamente, mi servivano (e mi servono) sui miei siti web.
Comunque sia, l’intento di questo articolo, è quello di avere delle funzioni legate ad un database MySql perciò cominciamo
Come prima cosa appunto, come dicevo qualche riga più su, diamo un nome alla nostra classe e definiamola nel seguente modo. Anzi, prima cosa di tutto assicuriamoci di dare un nome significativo al file php che andremo a creare. Per questo esempio il mio file si chiamerà: databaseClass.php
Nel nostro file dunque inizieremo a dichiarare la classe:
class databaseClass {
protected $queries_log=array();
}
La prima cosa che balza agli occhi è naturalmente la riga con “protected $quries_log=array();”.
Voglio ricordare che, all’interno di una classe, si possono dichiarare tre tipi di variabili: pubbliche, private o protette (public, private, protected) appunto. Nel primo caso, cioè pubbliche, le variabili sono accessibili da qualsiasi parte. Se le dichiariamo protette invece, esse possono essere viste soltanto dalla classe in cui si trovano oppure da quelle incluse. Infine, se dichiariamo private potranno essere viste solo e soltanto all’interno della classe in cui si trovano!
A questo punto, la prima cosa da fare è definire una funzione per la connessione al database. In questo modo, quando andremo ad utilizzarla, sarà sufficiente chiamare solo tale funzione.
Nel nostro caso, la funzione che andremo a creare per la connessione al db si chiamerà connettiDatabase (con molta fantasia) 😉
function connettiDatabase() {
$this->database='nome_vostro_database';
$this->resource_link_id=mysql_connect('vostro_host','vostro_user','vostra_password');
mysql_select_db($this->database,$this->resource_link_id);
$this->mysqlError();
}
Salta subito all’occhio una cosa: questa funzione, al suo interno, fa riferimento ad un’altra funzione mediante la chiamata $this->mysqlError().
la funzione mysqlError() sarà la seconda funzione che scriveremo e ci servirà in ogni funzione che andremo a creare, nel caso in cui, una volta in produzione, la nostra query non funzionasse bene e generasse un errore.
Di seguito quindi la funzione mysqlError()
function mysqlError() {
$mysql_error=mysql_error();
if ($mysql_error) {
$mysql_error.='
Ultima query eseguita: '.$this->queries_log[count($this->queries_log)-1].'
';
trigger_error($mysql_error,E_USER_ERROR);
return true;
}
return false;
}
Vediamo ora la prima chiamata ad una funzione per estrapolare un singolo dato dal nostro database. La funzione si chiamerà quindi singoloValore. Come argomenti vengono richiesti: la tabella su cui operare, il campo da estrapolare ed un eventuale condizione sotto forma di array.
function singoloValore($table,$field,$where_array) {
$where=$this->_parseWhereArray($where_array);
$query = "SELECT ".$field." FROM ".$table." WHERE ".$where;
$this->_doQuery($query);
if (is_resource($this->last_resource) && mysql_num_rows($this->last_resource)==1) {
$row=mysql_fetch_assoc($this->last_resource);
return $this->_unescapeData($row[$field]);
}
return false;
}
Come potete notare da questa funzione si introducono altre funzioni (con il simbolo “_” davanti). Quest’ultime serviranno solo e soltanto per riconoscere quelle di nostro utilizzo da quelle (diciamo) di “sistema”.
Sotto i codici delle funzioni elencate sopra insieme ad altre “interne” che torneranno utili in altre funzioni:
function _parseWhereArray($where_array) {
$where=NULL;
if (is_array($where_array)) {
foreach ($where_array as $key=>$value) $where.=$key."='".$value."' AND ";
$where=rtrim($where,' AND ');
}
return $where;
}
function _doQuery($query,$table2optimize=false,$stamp=false) {
if($stamp) echo '
'.$query.'
';
$this->_logQuery($query);
$this->last_resource=mysql_query($query,$this->resource_link_id);
$this->affected_rows=mysql_affected_rows($this->resource_link_id);
$mysql_error=$this->mysqlError();
if ($table2optimize) $this->_optimizeQuery($table2optimize);
return $mysql_error;
}
function _escapeData($data,$flash=false) {
$patterns=array();
$replacements=array();
if ($flash) {
$patterns[]='/&/';
$replacements[]='and';
}
$patterns[]='/[“”]/';
$replacements[]='"';
$patterns[]='/[‘’`´’\']/';
$replacements[]='{s}'; // '{singlequote}';
$patterns[]='/ {2,}/';
$replacements[]=' ';
$patterns[]='/( )?((\r)?\n)/';
$replacements[]="\r\n";
$patterns[]='/(\r\n){2,}/';
$replacements[]="\r\n\r\n";
$patterns[]='/\r\n$/';
$replacements[]='';
$output = preg_replace($patterns,$replacements,$data);
return $output;
}
function _unescapeData($data) {
if (is_array($data)) {
$html_data=array();
foreach ($data as $key=>$value) $html_data[$key]=htmlentities($value);
} else $html_data=htmlentities($data);
$patterns=array();
$replacements=array();
$patterns[]='/{s}/';
$replacements[]='\'';
$patterns[]='/{euro}/';
$replacements[]='€';
return preg_replace($patterns,$replacements,$html_data);
}
function _optimizeQuery($table) {
$query="OPTIMIZE TABLE ".$table;
$this->_logQuery($query);
mysql_query($query,$this->resource_link_id);
}
function _logQuery($query) {
$n=count($this->queries_log);
$this->queries_log[$n]=$query;
}
Arrivati a questo punto non mi resta altro che elencare le altre funzioni di comune utilizzo come:
- eseguire una query “libera” cioè nella quale scriverete direttamente la query in SQL
- eseguire una query che restituisca un array di valori
- eseguire una UPDATE
- eseguire una INSERT
- eseguire una DELETE
function singleRowQuery($table,$where_array) {
$where=$this->_parseWhereArray($where_array);
$query = "SELECT * FROM ".$table." WHERE ".$where;
$this->_doQuery($query);
if (is_resource($this->last_resource) && mysql_num_rows($this->last_resource)==1) {
$row=mysql_fetch_assoc($this->last_resource);
return $this->_unescapeData($row);
}
return false;
}
function multiQuery($table,$fields,$where_array=NULL,$order=NULL) {
$where=$this->_parseWhereArray($where_array);
$query="SELECT ".$fields." FROM ".$table;
if (!is_null($where)) $query.=" WHERE ".$where;
if (!is_null($order)) $query.=" ORDER BY ".$order;
$this->_doQuery($query);
if (is_resource($this->last_resource) && mysql_num_rows($this->last_resource)>0) {
$n=0;
$matrix=NULL;
while ($row=mysql_fetch_assoc($this->last_resource)) {
$matrix[$n]=$this->_unescapeData($row);
$n++;
}
return $matrix;
}
return false;
}
function freeQuery($query,$table=NULL) {
$this->_doQuery($query,$table);
if (is_resource($this->last_resource) && mysql_num_rows($this->last_resource)>0) {
$n=0;
$matrix=NULL;
while ($row=mysql_fetch_assoc($this->last_resource)) {
$matrix[$n]=$this->_unescapeData($row);
$n++;
}
return $matrix;
} else return false;
}
function insertQuery($table,$insert_array,$escape=true) {
$keys=$values=NULL;
foreach ($insert_array as $key=>$value) {
$keys.=$key.',';
if ($escape) $value=$this->_escapeData($value);
if ($value=='') $values.="NULL,";
else $values.="'".$value."',";
}
$keys=rtrim($keys,',');
$values=rtrim($values,',');
$this->_doQuery("INSERT INTO ".$table." (".$keys.") VALUES (".$values.")",$table);
return $this->affected_rows;
}
function updateQuery($table,$update_array,$where_array,$escape=true) {
$update=NULL;
foreach ($update_array as $key=>$value) {
if ($escape) $value=$this->_escapeData($value);
if ($value=='') $update.=$key."=NULL,";
else $update.=$key."='".$value."',";
}
$update=rtrim($update,',');
$where=$this->_parseWhereArray($where_array);
$this->_doQuery("UPDATE ".$table." SET ".$update." WHERE ".$where,$table);
return $this->affected_rows;
}
function deleteQuery($table,$where_array) {
$where=$this->_parseWhereArray($where_array);
$this->_doQuery("DELETE FROM ".$table." WHERE ".$where,$table);
return $this->affected_rows;
}
Voglio precisare una cosa molto importante. E’ ormai molto tempo che utilizzo una classe come questa (ripeto, l’ho modificata molto nel tempo, ma questa è una versione molto base). Questo codice è quindi frutto di ricerche, nottate insonni davanti al PC e duro lavoro. Sicuramente, qualche parte o porzione di codice è stata presa in giro per la rete. Specifico questo in quanto non voglio assolutamente attribuirmi ne il merito, ne la proprietà intellettuale di questo codice sorgente. Anzi, con molta probabilità, alcune parti, saranno utilizzabili solo e soltanto mediante la FREE GNU GENERAL PUBLIC LICENSE consultabile a questo indirizzo: http://www.gnu.org/licenses/gpl.html
Comunque sia, se l’articolo ti è piaciuto, sai migliorarlo, vuoi commentarlo, un commento è sempre ben accetto e gradito, purché rispettoso 🙂
Per ultimo, ma non meno importante, vediamo come utilizzare questa classe. Nell’esempio utilizzerò la funzione freeQuery.
<!--?php <br ?-->
$oggetto = new databaseClass;
$oggetto->connettiDatabase();
$risultato = $oggetto->freeQuery("SELECT nome FROM tabella","tabella");
foreach($risultato as $valore){
echo $valore['nome'] . "
";
}
2 commenti