PHP 8.5.0 Alpha 2 available for testing

PDOStatement::fetchAll

(PHP 5 >= 5.1.0, PHP 7, PHP 8, PECL pdo >= 0.1.0)

PDOStatement::fetchAll Recupera las líneas restantes de un conjunto de resultados

Descripción

public PDOStatement::fetchAll(int $mode = PDO::FETCH_DEFAULT): array
public PDOStatement::fetchAll(int $mode = PDO::FETCH_COLUMN, int $column): array
public PDOStatement::fetchAll(int $mode = PDO::FETCH_CLASS, string $class, ?array $constructorArgs): array
public PDOStatement::fetchAll(int $mode = PDO::FETCH_FUNC, callable $callback): array

Parámetros

mode

Controla el contenido del array retornado como se documenta en la función PDOStatement::fetch(). Valor por omisión: PDO::ATTR_DEFAULT_FETCH_MODE (que toma su valor por omisión de PDO::FETCH_BOTH).

Para retornar un array que contenga todos los valores de una sola columna desde el conjunto de resultados, se especifica PDO::FETCH_COLUMN. Puede especificarse qué columna se desea con el argumento column.

Para indexar el array resultante por el valor de una cierta columna (en lugar de por números consecutivos), se coloca el nombre de esta columna en primer lugar en la lista de columnas en SQL, y se utiliza PDO::FETCH_UNIQUE. Esta columna debe contener únicamente valores únicos, de lo contrario se perderán algunos datos.

Para agrupar los resultados en forma de un array de tres dimensiones indexado por los valores de una columna especificada, se coloca el nombre de esta columna en primer lugar en la lista de columnas en SQL y se utiliza PDO::FETCH_GROUP.

Para agrupar los resultados en forma de un array de dos dimensiones, se utiliza un OU a nivel de bits con PDO::FETCH_GROUP y PDO::FETCH_COLUMN. Los resultados serán agrupados por la primera columna, el valor del elemento del array siendo una lista de entradas correspondientes de la segunda columna.

Los argumentos siguientes son dinámicos y dependen del modo de recuperación. No pueden ser utilizados con argumentos nombrados.
column

Utilizado con PDO::FETCH_COLUMN. Retorna la columna indicada indexada a 0.

class

Utilizado con PDO::FETCH_CLASS. Retorna instancias de la clase especificada, haciendo corresponder las columnas de cada línea a propiedades nombradas en la clase.

constructorArgs

Argumentos del constructor personalizado de la clase cuando el argumento mode es PDO::FETCH_CLASS.

callback

Utilizado con PDO::FETCH_FUNC. Retorna los resultados de la llamada de la función especificada, utilizando las columnas de cada línea como argumentos en la llamada.

Valores devueltos

PDOStatement::fetchAll() retorna un array que contiene todas las líneas del conjunto de registros. El array representa cada línea como un array de valores de las columnas, o un objeto con propiedades correspondientes a cada nombre de columna. Un array vacío es retornado si no hay resultados.

El uso de este método para recuperar grandes conjuntos de resultados puede aumentar el uso de recursos del sistema, pero también estos recursos. En lugar de recuperar todas las datos y manipularlas con PHP, se utiliza el servidor de base de datos para manipular los conjuntos de resultados. Por ejemplo, se utilizan las cláusulas WHERE y ORDER BY en las consultas SQL para restringir los resultados antes de recuperarlos y procesarlos con PHP.

Errores/Excepciones

Emite un error de nivel E_WARNING si el atributo PDO::ATTR_ERRMODE está definido a PDO::ERRMODE_WARNING.

Lanza una excepción PDOException si el atributo PDO::ATTR_ERRMODE está definido a PDO::ERRMODE_EXCEPTION.

Historial de cambios

Versión Descripción
8.0.0 Este método retorna ahora siempre un array, anteriormente false podía ser retornado en caso de fallo.

Ejemplos

Ejemplo #1 Recuperación de todas las líneas de un conjunto de resultados

<?php
$sth
= $dbh->prepare("SELECT nom, couleur FROM fruit");
$sth->execute();

/* Recuperación de todas las líneas de un conjunto de resultados */
print "Recuperación de todas las líneas de un conjunto de resultados :\n";
$result = $sth->fetchAll();
print_r($result);
?>

Resultado del ejemplo anterior es similar a :

Recuperación de todas las líneas de un conjunto de resultados :
Array
(
    [0] => Array
        (
            [nom] => apple
            [0] => apple
            [couleur] => red
            [1] => red
        )

    [1] => Array
        (
            [nom] => pear
            [0] => pear
            [couleur] => green
            [1] => green
        )

    [2] => Array
        (
            [nom] => watermelon
            [0] => watermelon
            [couleur] => pink
            [1] => pink
        )

)

Ejemplo #2 Recuperación de todos los valores de una sola columna desde un conjunto de resultados

El siguiente ejemplo muestra cómo retornar todos los valores de una sola columna desde un conjunto de resultados, incluso si la consulta SQL retorna varias columnas por líneas.

<?php
$sth
= $dbh->prepare("SELECT name, colour FROM fruit");
$sth->execute();

/* Recuperación de todos los valores de la primera columna */
$result = $sth->fetchAll(PDO::FETCH_COLUMN, 0);
var_dump($result);
?>

Resultado del ejemplo anterior es similar a :

Array(3)
(
    [0] =>
    string(5) => apple
    [1] =>
    string(4) => pear
    [2] =>
    string(10) => watermelon
)

Ejemplo #3 Agrupar todos los valores de una sola columna

El siguiente ejemplo muestra cómo retornar un array asociativo agrupado por los valores de la columna especificada de un conjunto de resultados. El array contiene tres claves: los valores apple y pear son retornados en forma de arrays que contienen dos colores diferentes, mientras que watermelon es retornado en forma de un array que contiene únicamente un solo color.

<?php
$insert
= $dbh->prepare("INSERT INTO fruit(name, colour) VALUES (?, ?)");
$insert->execute(array('apple', 'green'));
$insert->execute(array('pear', 'yellow'));

$sth = $dbh->prepare("SELECT name, colour FROM fruit");
$sth->execute();

/* Agrupar los valores de la primera columna */
var_dump($sth->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_GROUP));
?>

Resultado del ejemplo anterior es similar a :

array(3) {
  ["apple"]=>
    array(2) {
      [0]=>
        string(5) "green"
      [1]=>
        string(3) "red"
    }
  ["pear"]=>
    array(2) {
      [0]=>
        string(5) "green"
      [1]=>
        string(6) "yellow"
    }
  ["watermelon"]=>
    array(1) {
      [0]=>
        string(5) "pink"
    }
}

Ejemplo #4 Instanciar una clase para cada resultado

El siguiente ejemplo muestra el comportamiento de PDO::FETCH_CLASS.

<?php
class fruit {
public
$name;
public
$colour;
}

$sth = $dbh->prepare("SELECT name, colour FROM fruit");
$sth->execute();

$result = $sth->fetchAll(PDO::FETCH_CLASS, "fruit");
var_dump($result);
?>

Resultado del ejemplo anterior es similar a :

array(3) {
  [0]=>
  object(fruit)#1 (2) {
    ["name"]=>
    string(5) "apple"
    ["colour"]=>
    string(5) "green"
  }
  [1]=>
  object(fruit)#2 (2) {
    ["name"]=>
    string(4) "pear"
    ["colour"]=>
    string(6) "yellow"
  }
  [2]=>
  object(fruit)#3 (2) {
    ["name"]=>
    string(10) "watermelon"
    ["colour"]=>
    string(4) "pink"
  }
  [3]=>
  object(fruit)#4 (2) {
    ["name"]=>
    string(5) "apple"
    ["colour"]=>
    string(3) "red"
  }
  [4]=>
  object(fruit)#5 (2) {
    ["name"]=>
    string(4) "pear"
    ["colour"]=>
    string(5) "green"
  }
}

Ejemplo #5 Llamada de una función para cada resultado

El siguiente ejemplo muestra el comportamiento de PDO::FETCH_FUNC.

<?php
function fruit($name, $colour) {
return
"{$name}: {$colour}";
}

$sth = $dbh->prepare("SELECT name, colour FROM fruit");
$sth->execute();

$result = $sth->fetchAll(PDO::FETCH_FUNC, "fruit");
var_dump($result);
?>

Resultado del ejemplo anterior es similar a :

array(3) {
  [0]=>
  string(12) "apple: green"
  [1]=>
  string(12) "pear: yellow"
  [2]=>
  string(16) "watermelon: pink"
  [3]=>
  string(10) "apple: red"
  [4]=>
  string(11) "pear: green"
}

Ver también

add a note

User Contributed Notes 20 notes

up
102
simplerezo at gmail dot com
8 years ago
I still don't understand why FETCH_KEY_PAIR is not documented here (http://php.net/manual/fr/pdo.constants.php), because it could be very useful!

<?php
var_dump
($pdo->query('select id, name from table')->fetchAll(PDO::FETCH_KEY_PAIR));
?>

This will display:
array(2) {
[2]=>
string(10) "name2"
[5]=>
string(10) "name5"
}
up
53
dyukemedia at gmail dot com
10 years ago
Getting foreach to play nicely with some data from PDO FetchAll()
I was not understanding to use the $value part of the foreach properly, I hope this helps someone else.
Example:
<?php
$stmt
= $this->db->prepare('SELECT title, FMarticle_id FROM articles WHERE domain_name =:domain_name');
$stmt->bindValue(':domain_name', $domain);
$stmt->execute();
$article_list = $stmt->fetchAll(PDO::FETCH_ASSOC);
?>
which gives:

array (size=2)
0 =>
array (size=2)
'title' => string 'About Cats Really Long title for the article' (length=44)
'FMarticle_id' => string '7CAEBB15-6784-3A41-909A-1B6D12667499' (length=36)
1 =>
array (size=2)
'title' => string 'another cat story' (length=17)
'FMarticle_id' => string '0BB86A06-2A79-3145-8A02-ECF6EA5C405C' (length=36)

Then use:
<?php
foreach ($article_list as $row => $link) {
echo
'<a href="'. $link['FMarticle_id'].'">' . $link['title']. '</a></br>';
}
?>
up
37
esw at pixeloution dot removeme dot com
15 years ago
Interestingly enough, when you use fetchAll, the constructor for your object is called AFTER the properties are assigned. For example:

<?php
class person {
public
$name;

function
__construct() {
$this->name = $this->name . " is my name.";
}
}

# set up select from a database here with PDO
$obj = $STH->fetchALL(PDO::FETCH_CLASS, 'person');
?>

Will result in ' is my name' being appended to all the name columns. However if you call it slightly differently:

<?php
$obj
= $obj = $STH->fetchAll(PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE, 'person');
?>

Then the constructor will be called before properties are assigned. I can't find this documented anywhere, so I thought it would be nice to add a note here.
up
22
Daniel Hofmann
16 years ago
PLEASE BE AWARE: If you do an OUTER LEFT JOIN and set PDO FetchALL to PDO::FETCH_ASSOC, any primary key you used in the OUTER LEFT JOIN will be set to a blank if there are no records returned in the JOIN.

For example:
<?php
//query the product table and join to the image table and return any images, if we have any, for each product
$sql = "SELECT * FROM product, image
LEFT OUTER JOIN image ON (product.product_id = image.product_id)"
;

$array = $stmt->fetchAll(PDO::FETCH_ASSOC);

print_r($array);
?>

The resulting array will look something like this:

Array
(
[0] => Array
(
[product_id] =>
[notes] => "this product..."
[brand] => "Best Yet"
...

The fix is to simply specify your field names in the SELECT clause instead of using the * as a wild card, or, you can also specify the field in addition to the *. The following example returns the product_id field correctly:

<?php
$sql
= "SELECT *, product.product_id FROM product, image
LEFT OUTER JOIN image ON (product.product_id = image.product_id)"
;

$array = $stmt->fetchAll(PDO::FETCH_ASSOC);

print_r($array);
?>

The resulting array will look something like this:

Array
(
[0] => Array
(
[product_id] => 3
[notes] => "this product..."
[brand] => "Best Yet"
...
up
20
Anonymous
14 years ago
Note that fetchAll() can be extremely memory inefficient for large data sets. My memory limit was set to 160 MB this is what happened when I tried:

<?php
$arr
= $stmt->fetchAll();
// Fatal error: Allowed memory size of 16777216 bytes exhausted
?>

If you are going to loop through the output array of fetchAll(), instead use fetch() to minimize memory usage as follows:

<?php
while ($arr = $stmt->fetch()) {
echo
round(memory_get_usage() / (1024*1024),3) .' MB<br />';
// do_other_stuff();
}
// Last line for the same query shows only 28.973 MB usage
?>
up
11
michael dot arnauts at gmail dot com
11 years ago
If you want to use PDO::FETCH_CLASS but don't like that all the values are of the type string, you can always use the __construct function of the class specified to convert them to a different type.

Another way is using mysqlnd, but it seems I had to recompile PHP for that.

<?php

class Cdr {
public
$a; // int
public $b; // float
public $c; // string

public function __construct() {
$this->a = intval($this->a);
$this->b = floatval($this->b);
}

}

// ...
$arrCdrs = $objSqlStatement->fetchAll(PDO::FETCH_CLASS, 'Cdr');

?>
up
6
info at yuriblanc dot it
9 years ago
Something missing in the doc.
If for instance you try to fetchAll(PDO::CLASS, "Class") it sometimes return an array of objects with NULL values, but the count of objects fetched correspond to table rows.

In this way works fine:
fetchAll(PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE, "Class");

For example

$stm = $pdo->prepare("SELECT * FROM Fruit");
$stm->execute();
$stm->fetchAll(PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE, "Fruit");
up
21
Anonymous
17 years ago
If no rows have been returned, fetchAll returns an empty array.
up
1
shaunc
2 years ago
Note that \PDO::FETCH_DEFAULT was not introduced until PHP 8.0.7 and 8.1.0. It will throw an undefined constant error in earlier versions.
up
3
Anonymous
8 years ago
Be careful when using PDO::FETCH_COLUMN with PDO::FETCH_GROUP. By default, results are grouped by first column (index 0) and second column (index 1) is returned. But, if you provide fetch argument, it wouldn't affect returned column, but grouping column. If grouping column is set explicitly , first columns is returned instead of second.

<?php
$insert
= $dbh->prepare("INSERT INTO people(id, gender) VALUES (?, ?)");
$insert->execute(array('2', 'female'));
$insert->execute(array('3', 'female'));
$insert->execute(array('4', 'female'));
$insert->execute(array('5', 'male'));
$insert->execute(array('6', 'male'));

$sth = $dbh->prepare("SELECT gender, id FROM people");
$sth->execute();

/* Group values by the first column */
var_dump($sth->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_GROUP));
?>
Returns:
<?php
array (size=2)
'female' =>
array (
size=3)
0 => string '2' (length=1)
1 => string '3' (length=1)
2 => string '4' (length=1)
'male' =>
array (
size=2)
0 => string '5' (length=1)
1 => string '6' (length=1)
?>

But,
<?php
var_dump
($sth->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_GROUP, 0));
?>
returns:
<?php
array (size=2)
'female' =>
array (
size=3)
0 => string 'female' (length=1)
1 => string 'female' (length=1)
2 => string 'female' (length=1)
'male' =>
array (
size=2)
0 => string 'male' (length=1)
1 => string 'male' (length=1)
?>
and
<?php
var_dump
($sth->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_GROUP, 1));
?>
returns
<?php
array (size=5)
2 =>
array (
size=1)
0 => string 'female' (length=1)
3 =>
array (
size=1)
0 => string 'female' (length=1)
4 =>
array (
size=1)
0 => string 'female' (length=1)
5 =>
array (
size=1)
0 => string 'male' (length=1)
6 =>
array (
size=1)
0 => string 'male' (length=1)
?>

First column is retuned and grouping is done by provided column index.
up
1
rudigerw at hotmail dot com
7 years ago
I was blown away that you can actually combine PDO::FETCH_CLASS | PDO::FETCH_CLASSTYPE | PDO::FETCH_UNIQUE, because both PDO::FETCH_CLASSTYPE and PDO::FETCH_UNIQUE say they will use the first column, but it turns out PDO::FETCH_CLASSTYPE goes first and then PDO::FETCH_UNIQUE will use the next column. This way you can create an associative array of objects, with one of the table columns as key. For example a query such as

'SELECT Class, Id, t.* FROM subscriptions_tbl t'

might give you this result:

Array
(
[20481086] => WConsumerSubscription Object
(
[Variant] => 2
[_Expiration:WSubscriptionModel:private] => DateTime Object
(
[date] => 2018-08-08 00:00:00.000000
[timezone_type] => 3
[timezone] => UTC
)

[Notes] =>
[Id] => 20481086
[_Deleted:protected] => 0
[_VersionNo:protected] => 2
[ContactId] =>
[ConsumerId] => 2
)

[21878324] => WAdminSubscription Object
(
[Variant] =>
[_Expiration:WSubscriptionModel:private] =>
[Notes] =>
[Id] => 21878324
[_Deleted:protected] => 0
[_VersionNo:protected] => 1
[ContactId] =>
)
)
up
5
Hayley Watson
14 years ago
If you use the PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE flags to map columns to object properties, fetchAll() will use any __set() method your object has when carrying out the mapping.
up
3
mxrgus
15 years ago
In method body:

return $pstmt->fetchAll() or die("bad");

will not return correct value, but "1" instead.
up
3
stas at metalinfo dot ru
18 years ago
Note, that you can use PDO::FETCH_COLUMN|PDO::FETCH_GROUP pair only while selecting two columns, not like DB_common::getAssoc(), when grouping is set to true.
up
6
harlequin2 at gmx dot de
17 years ago
There is also another fetch mode supported on Oracle and MSSQL:
PDO::FETCH_ASSOC

> fetches only column names and omits the numeric index.

If you would like to return all columns from an sql statement with column keys as table headers, it's as simple as this:

<?php
$dbh
= new PDO("DS", "USERNAME", "PASSWORD");
$stmt = $dbh->prepare("SELECT * FROM tablename");
$stmt->execute();
$arrValues = $stmt->fetchAll(PDO::FETCH_ASSOC);
// open the table
print "<table wdith=\"100%\">\n";
print
"<tr>\n";
// add the table headers
foreach ($arrValues[0] as $key => $useless){
print
"<th>$key</th>";
}
print
"</tr>";
// display data
foreach ($arrValues as $row){
print
"<tr>";
foreach (
$row as $key => $val){
print
"<td>$val</td>";
}
print
"</tr>\n";
}
// close the table
print "</table>\n";
?>
up
1
akira at etnforum dot com
10 years ago
There may be some user who needs to upgrade their MySQL class to PDO class. The way of fetching results were changed from while loop into a foreach loop. For the people who wish to fetch the results in a while loop, here is a simple trick.

<?php

$db
= new DB();
$query = $db->prepare("SELECT * FROM CPUCategory");
$query = $db->execute();
$result = $db->fetchAll();
var_dump($result);

?>

The Output will be:
array(2) {
[0]=> array(2) {
["ccatid"]=> int(1)
["ccatname"]=> string(5) "Intel"
}
[1]=> array(2) {
["ccatid"]=> int(2)
["ccatname"]=> string(3) "AMD"
}
}

Never look like the output of old function.
[ORIGINAL STYLE] mysql_fetch_array($query)
[ MYSQL CLASS] $db->fetch_array($query)

And you may give up.
But there is a simple way to use while loop to fetch the results.

<?php

$db
= new DB();
$query = $db->prepare("SELECT * FROM CPUCategory");
$query = $db->execute();
$result = $db->fetchAll();
$row = array_shift($result);
// If you need to fetch them now, put it in a while loop just like below:
// while($row = array_shift($result)) { ... }

var_dump($row);

?>

The Output will be in a single array with while loop returns TRUE:
array(2) {
["ccatid"]=> int(1)
["ccatname"]=> string(5) "Intel"
}

So after fetching this row, while loop runs again and fetch the next row until all row has fetched, then the while loop will return false. (Just like the old function did)

When you need to upgrade to PDO class, not much code needs to be modified and remember.
up
1
Dennis
15 years ago
Error:
SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active. Consider using PDOStatement::fetchAll(). Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the PDO::MYSQL_ATTR_USE_BUFFERED_QUERY attribute.

If you're using something like:

while ($row = $query->fetchObject()) {
[...]
}

try using this instead:

$rows = $query->fetchAll(PDO::FETCH_CLASS, 'ArrayObject');

foreach ($rows as $row) {
[...]
}
up
0
Anonymous
4 months ago
It's important to note that PDO::FETCH_CLASS does not behave the way you would intuitively expect. Intuitively, you might expect that it either does not call the constructor at all and sets the properties "magically", or that it simply calls the constructor with the data from the database. Both assumptions are incorrect. It *does* call the constructor, but *not* with data from the database; it uses "magic" to set the properties. This can result in problems.

For example, one might intuitively expect code like this to work, perhaps as a starting point for doing Domain-Driven Design without a full-fat ORM. (It doesn't.)

<?php
final class Example{
private static ?
PDO $pdo;

private function
__construct(
public readonly
int $id,
public readonly
string $val1,
public readonly ?
string $val2,
){}

public static function
init(PDO $pdo){
static::
$pdo = $pdo;
static::
$pdo->exec("
CREATE TABLE IF NOT EXISTS example (
id INT AUTO_INCREMENT PRIMARY KEY,
val1 TEXT NULL,
val2 TEXT NOT NULL
)
"
);
}

public static function
create(string $val1, ?string $val2=null){
if (!isset(static::
$pdo)) throw new RuntimeException('Not yet initialized');
$query = static::$pdo->prepare("
INSERT INTO example
(val1, val2)
VALUES
(?, ?)
"
);
$query->execute([$val1, $val2]);
return static::
fetch(static::$pdo->lastInsertId());
}

public static function
fetch($id){
if (!isset(static::
$pdo)) throw new RuntimeException('Not yet initialized');
$query = static::$pdo->prepare("SELECT * FROM example WHERE id = ?");
$query->execute([$id]);
$result = $query->fetchAll(PDO::FETCH_CLASS, 'Example');
if (!empty(
$result)) return $result[0];
}
}
?>

For a pattern like this to work, you'll instead need to do one of the following:

1. Use PDO::FETCH_FUNC instead of PDO::FETCH_CLASS, and pass it an anonymous function that calls the constructor.
2. Have a constructor that does nothing, and use the create() method to set properties directly. This would require removing the readonly modifier (though you could use PHP's new asymmetric visibility instead to achieve a similar effect). This also means that you can no longer actually use the constructor to fully construct an object (which, depending on your needs, may or may not be an acceptable compromise). You'll need a private constructor to avoid having partially-constructed objects floating around.
3. Use PDO::FETCH_ASSOC instead of PDO::FETCH_CLASS, then use ReflectionClass::newInstanceWithoutConstructor(), ReflectionObject::getProperty(), and ReflectionProperty::setValue() to implement "magical" class construction yourself.
4. Give up and use Doctrine or some other ORM.

There is, unfortunately, no solution that doesn't either have some compromise, require writing boilerplate code, or require adding a dependency to your project.
up
1
php at erikthiart dot com
4 years ago
I am adding this here as I don’t seem to find any clear and easy to find examples and explanations of PDO::FETCH_GROUP and how it works by means of an example.

I find this to be one of the most useful modes available in fetchAll() when you need to work with any form of grouping.

In essence, PDO can group results into nested arrays, based on the first field selected.

Example

<?php

$data
= $pdo->query('SELECT sex, name, car FROM users')->fetchAll(PDO::FETCH_GROUP);

/* array (
'male' => array ( 0 =>
array (
'name' => 'John',
'car' => 'Toyota',
),
1 => array (
'name' => 'Mike',
'car' => 'Ford',
),
),
'female' => array (
0 => array (
'name' => 'Mary',
'car' => 'Mazda',
),
1 => array (
'name' => 'Kathy',
'car' => 'Mazda',
),
),
) */

?>

Tip: If you need to group the data by something other than the first field then you can do it like this as well

<?php
SELECT sex
, users.* FROM users
?>
up
0
Leonardo Costa linux at linuxmanbr dot com dot br
5 years ago
Method with Return object (PHP 7.2)

class MySql {

public function __construct()
{
parent::__construct();

try{



$options = array
(
PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES UTF8"
);

$this->pdo = new PDO('mysql:host=127.0.0.1;dbname=testuser','dbtest', 'xxxxxxx',$options);
$this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

}catch(PDOException $e) {
print "Error!: " . $e->getMessage() . "<br/>";
die();
}
}

public function selectAll(string $sql)
{
$conn = $this->pdo->query($sql);
return $conn->fetchAll(PDO::FETCH_OBJ);
}
}
To Top