Exécuter du SQL brut à l'aide de Doctrine 2

Je veux exécuter du SQL brut en utilisant Doctrine 2

Je dois tronquer les tables de la base de données et initialiser les tables avec les données de test par défaut.

Voici un exemple de requête brute dans Doctrine 2 que je fais:

public function getAuthoritativeSportsRecords()
{   
    $sql = " 
        SELECT name,
               event_type,
               sport_type,
               level
          FROM vnn_sport
    ";

    $em = $this->getDoctrine()->getManager();
    $stmt = $em->getConnection()->prepare($sql);
    $stmt->execute();
    return $stmt->fetchAll();
}   

//$sql - sql statement
//$em - entity manager

$em->getConnection()->exec( $sql );

Je l'ai fait fonctionner en faisant cela, en supposant que vous utilisez PDO.

//Place query here, let's say you want all the users that have blue as their favorite color
$sql = "SELECT name FROM user WHERE favorite_color = :color";

//set parameters 
//you may set as many parameters as you have on your query
$params['color'] = blue;


//create the prepared statement, by getting the doctrine connection
$stmt = $this->entityManager->getConnection()->prepare($sql);
$stmt->execute($params);
//I used FETCH_COLUMN because I only needed one Column.
return $stmt->fetchAll(PDO::FETCH_COLUMN);

Vous pouvez modifier le FETCH_TYPE en fonction de vos besoins.

Comment exécuter une requête brute et renvoyer les données.

Accrochez-vous à votre manager et établissez une nouvelle connexion:

$manager = $this->getDoctrine()->getManager();
$conn = $manager->getConnection();

Créez votre requête et fetchAll:

$result= $conn->query('select foobar from mytable')->fetchAll();

Obtenez les données du résultat comme ceci:

$this->appendStringToFile("first row foobar is: " . $result[0]['foobar']);

J'ai découvert que la réponse est probablement:

Un NativeQuery vous permet d'exécuter du SQL natif, en mappant les résultats selon vos spécifications. Une telle spécification qui décrit comment un jeu de résultats SQL est mappé à un résultat Doctrine est représentée par un ResultSetMapping.

Source: SQL natif .

J'ai eu le même problème. Vous souhaitez consulter l'objet de connexion fourni par le gestionnaire d'entités:

$conn = $em->getConnection();

Vous pouvez ensuite interroger / exécuter directement contre lui:

$statement = $conn->query('select foo from bar');
$num_rows_effected = $conn->exec('update bar set foo=1');

Consultez la documentation de l'objet de connexion à l' adresse http://www.doctrine-project.org/api/dbal/2.0/doctrine/dbal/connection.html

Dans votre modèle, créez l'instruction SQL brute (l'exemple ci-dessous est un exemple d'intervalle de date que j'ai dû utiliser mais que je remplace le vôtre. Si vous effectuez un SELECT, ajoutez -> fetchall () à l'appel execute ().

   $sql = "DELETE FROM tmp 
            WHERE lastedit + INTERVAL '5 minute' < NOW() ";

    $stmt = $this->getServiceLocator()
                 ->get('Doctrine\ORM\EntityManager')
                 ->getConnection()
                 ->prepare($sql);

    $stmt->execute();

Vous ne pouvez pas, Doctrine 2 ne permet pas les requêtes brutes. Cela peut sembler possible, mais si vous essayez quelque chose comme ceci:

$sql = "SELECT DATE_FORMAT(whatever.createdAt, '%Y-%m-%d') FORM whatever...";
$em = $this->getDoctrine()->getManager();
$em->getConnection()->exec($sql);

La doctrine crachera une erreur disant que DATE_FORMAT est une fonction inconnue.

Mais ma base de données (mysql) connaît cette fonction, donc fondamentalement, ce qui se passe, c'est que Doctrine analyse cette requête dans les coulisses (et derrière votre dos) et trouve une expression qu'elle ne comprend pas, considérant que la requête est invalide.

Donc, si comme moi vous voulez pouvoir simplement envoyer une chaîne à la base de données et la laisser s'en occuper (et laisser le développeur prendre l'entière responsabilité de la sécurité), oubliez-la.

Bien sûr, vous pouvez coder une extension pour autoriser cela d'une manière ou d'une autre, mais vous pouvez tout aussi bien utiliser mysqli pour le faire et laisser Doctrine à son activité ORM.