chiarimenti sulle funzioni DAL e MySQLi in PHP

1

Fino ad ora, stavo considerando funzioni MySQLi in PHP un esempio di DAL. E ho avviato un semplice progetto da pubblicare in un articolo con il titolo "che inizia con PHP e DAL e MySQL"

Ma quando ho fatto una ricerca per alcuni argomenti da aggiungere nel mio articolo ho "scoperto" due cose:

  1. Il sito PHP.net non elenca MySQLi pagina su DAL
  2. Molti articoli parlano di MySQLi come libreria o API, ma non ho trovato nessuno che lo affermasse come DAL.

E ora ho questa domanda: perché il PDO di classe è considerato un esempio di DAL, ma la classe MySQLi non è considerata un esempio DAL?

Quello che stavo pensando di scrivere è qualcosa del genere:

If you create a class named Container, like the code bellow, it's easy to see the access to DAL by functions: mysqli_connect, mysqli_query, and the others mysqli_functions

// this is a very basic implementation, and need many improvements, it is just an example

class Container 
{
    private $_Connection = null;
    private $_Fields = null;

    function __construct($host, $user, $password, $database) 
    {
        $connection = mysqli_connect($host,$user,$password);
        if( $connection ) 
        {
            mysqli_select_db($connection, $database);
            mysqli_set_charset($connection, "utf8");
            $this->_Connection = $connection;
        }
    }

    function __destruct() 
    {
         if( $this->_Connection )
         {
             mysqli_close($this->_Connection);    
         }         
    }

    function Query( $sql ) 
    {
        $dataset = array();
        $result  = mysqli_query( $this->_Connection, $sql );

        if ($result)
        {
            $this->_Fields = mysqli_fetch_fields($result);

            while($data = mysqli_fetch_assoc($result)) 
            {
                $dataset[] = $row;
            }
        }

        return $dataset;   
    }

    function Fields( $index ) 
    {
        if(isset($index))
        {
            return $this->_Fields[$index];
        }
        else
        {
            return $this->_Fields;    
        }           
    }
}

16/02/17:

Che cosa succede se modifico il costruttore della mia classe Container in qualcosa del tipo:

function __construct($driver, $host, $user, $password, $database) 
{
    switch( $driver )
    {
        case "MYSQL": $connection = mysqli_connect($host,$user,$password);
                      if( $connection ) 
                      {
                          mysqli_select_db($connection, $database);
                          mysqli_set_charset($connection, "utf8");
                          $this->_Connection = $connection;
                      }
                      break;

        case "SQLServer": // to do...
        case "Oracle":    // to do...
    }
}

E apporta modifiche simili ai metodi Contenitore :: Query e Contenitore :: Campi .

Quindi, in questo caso, la mia classe Container sarà un esempio di DAL?

17/02/17:

Qualcuno può creare un DAL per un database specifico?

In questo modo: link

This is a Data Access Layer for MySQL

    
posta apagando_tudo 15.02.2017 - 20:08
fonte

2 risposte

2

Poiché Mysqli non è un livello di astrazione, è specifico per Mysql.

Il PDO è un'astrazione, non devi sapere come i driver PDO parlano con diversi tipi di database. Hai solo un'interfaccia di cui preoccuparti.

ODBC / JDBC sono anche esempi di astrazioni.

Seconda domanda

Questo renderebbe la classe un esempio di DAL se non non fa "modifica simile" ai metodi Query () e Fields (). Ti consigliamo di cambiare il costruttore di container in:

public function __construct(Connection $connection) {
    $this->_Connection = $connection;
}

e creare una classe Connection con il metodo factory che richiede ($driver, $host, $user, $password, $database) . Le specifiche su come fare Query () e Fields () dovrebbero andare a specifiche implementazioni di Connection, non nel livello di Container abstraction.

    
risposta data 16.02.2017 - 07:12
fonte
0

Per prima cosa, ci sono DAL e DAL:

Livello di accesso ai dati: è uno strato di un programma per computer che fornisce un accesso semplificato ai dati memorizzati nella memoria persistente (en.wikipedia.org/wiki/Data_access_layer)

MySQLi è un esempio di Access Layer, poiché fornisce un accesso semplificato al database MySQL.

Data Abstraction Layer: è un'interfaccia API (Application Programming Interface) che unifica la comunicazione tra un'applicazione e database come SQL Server, DB2, MySQL, PostgreSQL, Oracle o SQLite (en.wikipedia.org/wiki/Database_abstraction_layer)

PDO è un esempio di Abstract Layer, poiché fornisce un accesso semplificato a un elenco di database.

Il tuo primo codice è in effetti un Access Layer, per MySQL, che usa le funzioni di MySQLi.

Il tuo secondo codice potrebbe essere un livello di astrazione, dipende da come scrivi le altre funzioni.

Nell'ultima domanda, come puoi vedere e capire ora, il livello di accesso ai dati è specifico per un database.

Ulteriori letture:

  1. www.xaprb.com/blog/2006/08/13/four-types-of-database-abstraction-layers /
  2. stackoverflow.com/questions/2838661/what-is-the-difference-between-database-abstraction-layer-data-acess-layer
risposta data 17.02.2017 - 16:43
fonte

Leggi altre domande sui tag