PHP asynchrone mysql-query

Ma première application requêtes 2 grands ensembles de données, puis fait un peu de travail sur le premier ensemble de données, et "utilise" sur le second.

Si possible j'aimerais qu'il en fait, seulement une requête de la première série synchrone et la seconde de manière asynchrone, faire le travail sur le premier set, puis attendez que la requête de la deuxième set pour terminer si elle n'a pas déjà et, enfin, utiliser le premier ensemble de données.

Est-ce possible?

OriginalL'auteur Clox | 2014-12-02

  1. 16

    C'est possible.

    $mysqli->query($long_running_sql, MYSQLI_ASYNC);

echo 'run other stuff';

$result = $mysqli->reap_async_query(); //gives result (and blocks script if query is not done)
$resultArray = $result->fetch_assoc();

    Ou vous pouvez utiliser mysqli_poll si vous ne voulez pas d'avoir un appel de blocage

    http://php.net/manual/en/mysqli.poll.php

    L'air facile. Mais est-il un moyen de le faire avec PDO plutôt que mysqli?
    Je vous conseille d'inclure PDO dans votre question ou de votre titre si c'est une exigence.
    Je ne suis pas au courant d'une semblable AOP méthode, mais vous pouvez toujours utiliser asynchrone curl demandes: github.com/barbushin/multirequest -> créer deux scripts php, chacun effectue une requête, puis appeler ces scripts asynchrone avec curl. Je ne dis pas que c'est la solution la plus élégante, mais il fonctionne.
    la courte et la réponse directe est que PDO ne supporte pas les non-blocage, les requêtes asynchrones comme par php.net/manual/ru/mysqlinfo.api.choosing.php.
    Par la réponse ci-dessous, il n'est pas possible de l'utiliser pour paralléliser l'interrogation sur la même connexion?

    OriginalL'auteur Thorsten

  2. 11

    MySQL exige que, à l'intérieur d'une connexion, une requête est complètement manipulé avant la prochaine requête est lancée. Que comprend l'extraction de tous résultats.

    Il est possible, cependant, d':

    • extraire les résultats un par un au lieu de tout à la fois
    • lancer plusieurs requêtes en créant de multiples connexions

    Par défaut, PHP va attendre jusqu'à ce que tous résultats sont disponibles à l'interne (dans le pilote mysql) récupérer tous les résultats à la fois. C'est vrai même en utilisant par exemple PDOStatement::fetch() de les importer dans votre code ligne par ligne. Lors de l'utilisation de PDO, cela peut être évité avec la définition de l'attribut \PDO::MYSQL_ATTR_USE_BUFFERED_QUERY à false. Ceci est utile pour:

    Être conscient que, souvent, la vitesse est limitée par un système de stockage, avec des caractéristiques qui signifie que le temps total de traitement pour les deux requêtes est plus grande lors de l'exécution en même temps que lors de l'exécution d'eux un par un.

    Un exemple (ce qui peut être fait complètement dans MySQL, mais pour montrer le concept...):

    $dbConnectionOne = new \PDO('mysql:hostname=localhost;dbname=test', 'user', 'pass');
$dbConnectionOne->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);

$dbConnectionTwo = new \PDO('mysql:hostname=localhost;dbname=test', 'user', 'pass');
$dbConnectionTwo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
$dbConnectionTwo->setAttribute(\PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);

$synchStmt = $dbConnectionOne->prepare('SELECT id, name, factor FROM measurementConfiguration');
$synchStmt->execute();

$asynchStmt = $dbConnectionTwo->prepare('SELECT measurementConfiguration_id, timestamp, value FROM hugeMeasurementsTable');
$asynchStmt->execute();

$measurementConfiguration = array();
foreach ($synchStmt->fetchAll() as $synchStmtRow) {
    $measurementConfiguration[$synchStmtRow['id']] = array(
        'name' => $synchStmtRow['name'],
        'factor' => $synchStmtRow['factor']
    );
}

while (($asynchStmtRow = $asynchStmt->fetch()) !== false) {
    $currentMeasurementConfiguration = $measurementConfiguration[$asynchStmtRow['measurementConfiguration_id']];
    echo 'Measurement of sensor ' . $currentMeasurementConfiguration['name'] . ' at ' . $asynchStmtRow['timestamp'] . ' was ' . ($asynchStmtRow['value'] * $currentMeasurementConfiguration['factor']) . PHP_EOL;
}
    Super, bien expliqué réponse! Viens d'apprendre quelque chose de nouveau 🙂
    Je pense que cette réponse est en désordre considérant que PDO n'a pas de support natif des opérations asynchrones. Vous devez travailler avec MYSQLI à la place.

    OriginalL'auteur Tomas Creemers