Quelle est la meilleure façon d'abstraction de la base de données à partir d'une application PHP?

À l'aide d'un ORM est généralement le moyen privilégié de l'abstraction de la base de données. Une liste incomplète de PHP implémentations sont disponibles sur Wikipédia.

Je suis venu avec un concept intéressant qui permettrait aux développeurs de créer des de base de données agnostique code, mais à la différence de l'ORM va pas sacrifier la performance:

• simple à utiliser (comme ORM)
• db-agnostique: fonctionne avec SQL, NoSQL, fichiers, etc
• toujours optimiser les requêtes si le fournisseur le permet (sous-sélectionner, de réduire la carte)

Le résultat est Agile de Données - base de données access cadre (voir la vidéo pour plus d'explications).

De problèmes de la vie réelle de la tâche avec DB-agnostique de code et de Données flexible

1. Commencer par décrire les modèles d'affaires.
2. Créer persistance pilote $db (un mot de fantaisie pour connexion DB), ce qui pourrait être un fichier CSV, SQL ou LDAP.
3. Associer modèle avec $db et d'exprimer votre Action
4. Exécuter Action

Au point de ce cadre permettra de déterminer la meilleure stratégie étant donné les capacités de la base de données, permettra de mapper les champs de la déclaration, de préparer et d'exécuter des requêtes pour vous, afin que vous n'avez pas à les écrire.

Exemple De Code

Mon extrait de code suivant permet de résoudre une assez complexe problème de la détermination de quel est le courant total de la dette de tous nos clients VIP. Schéma:

Suivant est le fournisseur indépendant de code:

$clients = new Model_Client($db);
//Object representing all clients - DataSet

$clients -> addCondition('is_vip', true);
//Now DataSet is limited to VIP clients only

$vip_client_orders = $clients->refSet('Order');
//This DataSet will contain only orders placed by VIP clients

$vip_client_orders->addExpression('item_price')->set(function($model, $query){
    return $model->ref('item_id')->fieldQuery('price');
});
//Defines a new field for a model expressed through relation with Item

$vip_client_orders->addExpression('paid')
  ->set(function($model, $query){
    return $model->ref('Payment')->sum('amount');
});
//Defines another field as sum of related payments

$vip_client_orders->addExpression('due')->set(function($model, $query){
    return $query->expr('{item_price} * {qty} - {paid}');
});
//Defines third field for calculating due

$total_due_payment = $vip_client_orders->sum('due')->getOne();
//Defines and executes "sum" action on our expression across specified data-set

La requête si $db est SQL:

select sum(
  (select `price` from `item` where `item`.`id` = `order`.`item_id` )
  * `order`.`qty`
  - (select sum(`payment`.`amount`) `amount` 
     from `payment` where `payment`.`order_id` = `order`.`id` )
) `due` from `order` 
where `order`.`user_id` in (
  select `id` from `user` where `user`.`is_client` = 1 and `user`.`is_vip` = 1 
)

Pour d'autres sources de données, l'exécution de la stratégie pourrait lourd et encore plus de données, mais serait de travailler de manière cohérente.

Je pense que mon approche est un excellent moyen de résumé de la base de données et je travaille pour le mettre en œuvre sous licence MIT:

https://github.com/atk4/data

Le meilleur moyen est d'utiliser un ORM (Object-relational mapping) de la bibliothèque. Il y en a beaucoup pour PHP. J'ai personnellement utilisé et peut recommander orm doctrine (je l'ai utilisé en combinaison avec des silex, qui est un minimaliste framework php).

Voici un StackOverflow thread à propos de PHP Orm où vous pouvez trouver quelques solutions de rechange si vous le souhaitez: Bon PHP ORM Bibliothèque?

En règle générale, si vous vous donnez la peine d'utiliser une base de données, alors votre demande pourront bénéficier de l'aide des fonctionnalités spécifiques à une "marque" de la base de données, et sera plus solide app pour elle.

Il est très rare de passer d'un système de base de données à l'autre. Le seul moment où l'on pourrait, de manière réaliste de considérer que les aa caractéristique qui mérite d'être mise en œuvre est que si vous écrivez une sorte de système faiblement couplé ou d'un cadre destiné à la consommation de masse (comme le Zend Framework, ou Django).

En fait, la solution pour le thème "où en œuvre logique d'accès aux données?" n'est pas complexe. Tout ce que vous avez à retenir est que votre modèle de code doit être séparé de votre code d'accès aux données.

Comme:

Modèle de couche avec un peu de logique métier de l'Utilisateur::name() la méthode

class User 
{
  public $first;
  public $last;
  public $email;
  public function name ()
  {
      return $this->first." ".$this->last;
  }
}

Couche d'accès aux données:

class Link
{
    $this->connection;
    public function __construct ()
    {
        $this->connection = PDO_Some_Connect_Function();
    }
    public function query ($query)
    {
        PDO_Some_Query ($this->connection, $query);
    }

}

class Database
{
    public $link;
    public function __construct ()
    {
        $this->link = new Link();
    }
    public function query ($query)
    {
        $this->link->query ($query);
    }
}

class Users
{
    public $database;
    public function __construct (&$database)
    {
         $this->database = &$database;
    } 
    public save ($user)
    {
        $this->database->link->query ("INSERT INTO user VALUES( '$user->first', '$user->last', '$user->email' ))";
    }

Utilisation:

$database = new Database();

$users = new Users();

$users->save (new User());

Dans cet exemple, il est évident que vous pouvez toujours modifier vos données d'accès de la classe Lien qui permettra d'exécuter des requêtes sur n'importe quoi (Cela signifie que vous pouvez enregistrer vos utilisateurs sur un serveur comme vous le lien modifier).

Dans le même temps, vous devez nettoyer la couche de modèle de code qui vit de manière autonome et n'a aucune idée de qui et où est l'enregistrement de ses objets.

Également les bases de données de classe ici semble inutile, mais en fait ça peut donner naissance à de grandes idées comme la collecte de nombreux liens un exemple pour de nombreux db connections dans un projet.

Il y a aussi seul fichier plus simple et le tout-puissant cadre appelé db.php(http://dbphp.net) qui est construit sur le modèle que j'ai décrit ici, et même crée automatiquement des tables avec la capacité de contrôler pleinement son standard sql champ/table de paramètres et de synchronisation de base de données de la structure de votre modèle chaque fois que vous le souhaitez.