PHP Doku:: Fetch results from a prepared statement into the bound variables - mysqli-stmt.fetch.html

Verlauf / Chronik / History: (1) anzeigen

Sie sind hier:
Doku-StartseitePHP-HandbuchFunktionsreferenzDatenbankerweiterungenAnbieterspezifische DatenbankerweiterungenMySQL Improved ExtensionThe MySQLi_STMT classmysqli_stmt::fetch -- mysqli_stmt_fetch

Ein Service von Reinhard Neidl - Webprogrammierung.

The MySQLi_STMT class

<<mysqli_stmt::execute -- mysqli_stmt_execute

mysqli_stmt->field_count -- mysqli_stmt_field_count>>

mysqli_stmt::fetch

mysqli_stmt_fetch

(PHP 5)

mysqli_stmt::fetch -- mysqli_stmt_fetchFetch results from a prepared statement into the bound variables

Beschreibung

Objektorientierter Stil

bool mysqli_stmt::fetch ( void )

Prozeduraler Stil

bool mysqli_stmt_fetch ( mysqli_stmt $stmt )

Fetch the result from a prepared statement into the variables bound by mysqli_stmt_bind_result().

Hinweis:

Note that all columns must be bound by the application before calling mysqli_stmt_fetch().

Hinweis:

Data are transferred unbuffered without calling mysqli_stmt_store_result() which can decrease performance (but reduces memory cost).

Parameter-Liste

stmt

Nur bei prozeduralem Aufruf: ein von mysqli_stmt_init() zurückgegebenes Statementobjekt.

Rückgabewerte

Rückgabewerte
Value Description
TRUE Success. Data has been fetched
FALSE Error occurred
NULL No more rows/data exists or data truncation occurred

Beispiele

Beispiel #1 Objektorientierter Stil

<?php
$mysqli 
= new mysqli("localhost""my_user""my_password""world");

/* check connection */
if (mysqli_connect_errno()) {
    
printf("Connect failed: %s\n"mysqli_connect_error());
    exit();
}

$query "SELECT Name, CountryCode FROM City ORDER by ID DESC LIMIT 150,5";

if (
$stmt $mysqli->prepare($query)) {

    
/* execute statement */
    
$stmt->execute();

    
/* bind result variables */
    
$stmt->bind_result($name$code);

    
/* fetch values */
    
while ($stmt->fetch()) {
        
printf ("%s (%s)\n"$name$code);
    }

    
/* close statement */
    
$stmt->close();
}

/* close connection */
$mysqli->close();
?>

Beispiel #2 Prozeduraler Stil

<?php
$link 
mysqli_connect("localhost""my_user""my_password""world");

/* check connection */
if (mysqli_connect_errno()) {
    
printf("Connect failed: %s\n"mysqli_connect_error());
    exit();
}

$query "SELECT Name, CountryCode FROM City ORDER by ID DESC LIMIT 150,5";

if (
$stmt mysqli_prepare($link$query)) {

    
/* execute statement */
    
mysqli_stmt_execute($stmt);

    
/* bind result variables */
    
mysqli_stmt_bind_result($stmt$name$code);

    
/* fetch values */
    
while (mysqli_stmt_fetch($stmt)) {
        
printf ("%s (%s)\n"$name$code);
    }

    
/* close statement */
    
mysqli_stmt_close($stmt);
}

/* close connection */
mysqli_close($link);
?>

The above examples will output:

Rockford (USA)
Tallahassee (USA)
Salinas (USA)
Santa Clarita (USA)
Springfield (USA)

Siehe auch


9 BenutzerBeiträge:
- Beiträge aktualisieren...
denath2 at yahoo dot com
19.05.2008 9:27
As php at johnbaldock dot co dot uk mentioned the problem is that the $row returned is reference and not data. So, when you write  $array[] = $row, the $array will be filled up with the last element of the dataset. To come up with this you can write the following hack:

// loop through all result rows
while ($stmt->fetch()) {

    foreach( $row as $key=>$value )
    {
        $row_tmb[ $key ] = $value;
    }
    $array[] = $row_tmb;
   
}
piedone at pyrocenter dot hu
8.05.2008 21:57
I tried the mentioned stmt_bind_assoc() function, but somehow, very strangely it doesn't allow the values to be written in an array! In the while loop, the row is fetched correctly, but if I write $array[] = $row;, the array will be filled up with the last element of the dataset... Unfortunately I couldn't find a solution.
Lyndon
24.04.2008 2:38
This function uses the same idea as the last, but instead binds the fields to a given array.
<?php
function stmt_bind_assoc (&$stmt, &$out) {
   
$data = mysqli_stmt_result_metadata($stmt);
   
$fields = array();
   
$out = array();

   
$fields[0] = $stmt;
   
$count = 1;

    while(
$field = mysqli_fetch_field($data)) {
       
$fields[$count] = &$out[$field->name];
       
$count++;
    }   
   
call_user_func_array(mysqli_stmt_bind_result, $fields);
}

// example

$stmt = $mysqli->prepare("SELECT name, userid FROM somewhere");
$stmt->execute();

$row = array();
stmt_bind_assoc($stmt, $row);

// loop through all result rows
while ($stmt->fetch()) {
   
print_r($row);
}
?>
dan dot latter at gmail dot com
16.08.2007 21:14
The following function taken from PHP Cookbook 2, returns an associative array of a row in the resultset, place in while loop to iterate through whole result set.

<?php
public function fetchArray () {
  
$data = mysqli_stmt_result_metadata($this->stmt);
       
$fields = array();
       
$out = array();

       
$fields[0] = &$this->stmt;
       
$count = 1;

        while(
$field = mysqli_fetch_field($data)) {
           
$fields[$count] = &$out[$field->name];
           
$count++;
        }
       
       
call_user_func_array(mysqli_stmt_bind_result, $fields);
       
mysqli_stmt_fetch($this->stmt);
        return (
count($out) == 0) ? false : $out;

    }
?>
php at johnbaldock dot co dot uk
31.01.2007 1:35
Good point about the spaces in column names. I also had trouble with the fetch assoc returning references so when done multiple times all the data pointed to the last result set. I got around it by adding a foreach loop:

<?php
// creates an array of real values from an array of references
foreach ($this->results as $k => $v) {
   
$results[$k] = $v;
}
?>

To tidy all this up into a nice package I extended the mysqli and stmt classes. Here is the code to extend both, I also included 'Typer85 at gmail dot com's fix for column names that have spaces in them.

<?php
class mysqli_Extended extends mysqli
{
    protected
$selfReference;

    public function
__construct($dbHost, $dbUsername, $dbPassword, $dbDatabase)
    {
       
parent::__construct($dbHost, $dbUsername, $dbPassword, $dbDatabase);

    }

    public function
prepare($query)
    {
       
$stmt = new stmt_Extended($this, $query);

        return
$stmt;
    }
}

class
stmt_Extended extends mysqli_stmt
{
    protected
$varsBound = false;
    protected
$results;

    public function
__construct($link, $query)
    {
       
parent::__construct($link, $query);
    }

    public function
fetch_assoc()
    {
       
// checks to see if the variables have been bound, this is so that when
        //  using a while ($row = $this->stmt->fetch_assoc()) loop the following
        // code is only executed the first time
       
if (!$this->varsBound) {
           
$meta = $this->result_metadata();
            while (
$column = $meta->fetch_field()) {
               
// this is to stop a syntax error if a column name has a space in
                // e.g. "This Column". 'Typer85 at gmail dot com' pointed this out
               
$columnName = str_replace(' ', '_', $column->name);
               
$bindVarArray[] = &$this->results[$columnName];
            }
           
call_user_func_array(array($this, 'bind_result'), $bindVarArray);
           
$this->varsBound = true;
        }

        if (
$this->fetch() != null) {
           
// this is a hack. The problem is that the array $this->results is full
            // of references not actual data, therefore when doing the following:
            // while ($row = $this->stmt->fetch_assoc()) {
            // $results[] = $row;
            // }
            // $results[0], $results[1], etc, were all references and pointed to
            // the last dataset
           
foreach ($this->results as $k => $v) {
               
$results[$k] = $v;
            }
            return
$results;
        } else {
            return
null;
        }
    }
}

// this is an example use of the extended mysqli.
// the only difference is using "mysqli_Extended" instead of "mysqli"
$db = new mysqli_Extended($dbHost, $dbUsername, $dbPassword, $dbDatabase);
$query = 'SELECT foo FROM bar';
$stmt = $db->prepare($query);
$stmt->execute();
$stmt->store_result();
while (
$row = $stmt->fetch_assoc()) {
   
$foo[] = $row['foo'];
}
$stmt->close();
$db->close();
?>
Typer85 at gmail dot com
28.12.2006 2:55
Just a side note,

I see many people are contributing in ways to help return result sets for prepared statements in ASSOSITAVE arrays the same as the mysqli_fetch_assos function might return from a normal query issued via mysqli_query.

This is done, in all the examples I have seen, by dynamically getting the field names in the prepared statement and binding them using 'variable' variables, which are variables that are created dynamically with the name of the field names.

Some thing though you should take into consideration is illegal variable names in PHP. Assume that you have a field name in your database table named 'My Field' , notice the space between 'My' and 'Field'.

To dynamically create this variable is illegal in PHP as variables can not have spaces in them. Furthermore, you won't be able to access the binded data as you can not reference a variable like so:

<?php

// Syntax Error.

echo $My Table;

?>

The only suitable solution I find now is to replace all spaces in a field name with an underscore so that you can use the binded variable like so:

<?php

// This Works.

echo $My_Table;

// Notice the space is now replaced with an underscore.

?>

All you simply have to do is before you dynamically bind the data, so a string search for any spaces in the table name, replace them with an underscore, THEN bind the variable.

That way you should not run into problems.
php at johnbaldock dot co dot uk
9.11.2006 22:33
Having just learned about call_user_func_array I reworked my fetch_assoc example. Swapping the following code makes for a more elegant (and faster) solution.

Using:
<?php
while ($columnName = $meta->fetch_field()) {
   
$columns[] = &$results[$columnName->name];
}       
call_user_func_array(array($stmt, 'bind_result'), $columns);
?>

Instead of this code from my example below:
<?php
$bindResult
= '$stmt->bind_result(';
while (
$columnName = $meta->fetch_field()) {
  
$bindResult .= '$results["'.$columnName->name.'"],';
}
$bindResult = rtrim($bindResult, ',') . ');';
eval(
$bindResult);
?>

The full reworked fetch_assoc code for reference:
<?php
$mysqli
= new mysqli($dbHost, $dbUsername, $dbPassword, $dbDatabase);
$stmt = $mysqli->prepare('select * from foobar');
$stmt->execute();
$stmt->store_result();
$meta = $stmt->result_metadata();

while (
$column = $meta->fetch_field()) {
  
$bindVarsArray[] = &$results[$column->name];
}       
call_user_func_array(array($stmt, 'bind_result'), $bindVarsArray);

$stmt->fetch();

echo
var_dump($results);
// outputs:
//
// array(3) {
//  ["id"]=>
//  &int(1)
//  ["foo"]=>
//  &string(11) "This is Foo"
//  ["bar"]=>
//  &string(11) "This is Bar"
// }
?>
php at johnbaldock dot co dot uk
23.10.2006 22:07
I wanted a simple way to get the equivalent of fetch_assoc when using a prepared statement. I came up with the following:

<?php
$mysqli
= new mysqli($dbHost, $dbUsername, $dbPassword, $dbDatabase);
$stmt = $mysqli->prepare('select * from foobar');
$stmt->execute();
$stmt->store_result();
$meta = $stmt->result_metadata();

// the following creates a bind_result string with an argument for each column in the query
// e.g. $stmt->bind_result($results["id"], $results["foo"], $results["bar"]);
$bindResult = '$stmt->bind_result(';
while (
$columnName = $meta->fetch_field()) {
   
$bindResult .= '$results["'.$columnName->name.'"],';
}
$bindResult = rtrim($bindResult, ',') . ');';

// executes the bind_result string
eval($bindResult);
$stmt->fetch();

echo
var_dump($results);
// outputs:
//
// array(3) {
//   ["id"]=>
//   &int(1)
//   ["foo"]=>
//   &string(11) "This is Foo"
//   ["bar"]=>
//   &string(11) "This is Bar"
// }
?>
andrey at php dot net
27.04.2005 20:37
IMPORTANT note: Be careful when you use this function with big result sets or with BLOB/TEXT columns. When one or more columns are of type (MEDIUM|LONG)(BLOB|TEXT) and ::store_result() was not called mysqli_stmt_fetch() will try to allocate at least 16MB for every such column. It _doesn't_ matter that the longest value in the result set is for example 30 bytes, 16MB will be allocated. Therefore it is not the best idea ot use binding of parameters whenever fetching big data. Why? Because once the data is in the mysql result set stored in memory and then second time in the PHP variable.



PHP Powered Diese Seite bei php.net
The PHP manual text and comments are covered by the Creative Commons Attribution 3.0 License © the PHP Documentation Group - Impressum - mail("TO:Reinhard Neidl",...)