How to get PDO object and set properties? (detailed code explanation)

Like any other database extension, PDO can create instances of existing classes directly from selected data. However, unlike other extensions, PDO provides many features for powerful and flexible object manipulation.

Get a single object

To create a single object from the query results, there are two methods.

1. Use the familiar fetch() method:

class User {};
$stmt = $pdo->query('SELECT name FROM users LIMIT 1');
$stmt->setFetchMode(PDO::FETCH_CLASS, 'User');
$user = $stmt->fetch();

2. The dedicated fetchObject() method:

class User {};
$user = $pdo->query('SELECT name FROM users LIMIT 1')->fetchObject('User');

Although both code snippets will provide you with the same User class instance,

/* object(User)#3 (1) {
  ["name"] => string(4) "John"
} */

The latter approach definitely looks cleaner. Additionally, if the fetch() method is used but the class is not defined with such a name, an array will be silently returned, whereas using fetchObject() will throw an appropriate error.

Getting an array of objects

Of course, both methods described above can be used with a familiar while statement to get from the database Result line.

Use a convenient fetchAll() method to get all the returned records in the object array at once:

class User {};
$users = $pdo->query('SELECT name FROM users')->fetchAll(PDO::FETCH_CLASS, 'User');

will give you an array consisting of an object of the User class , return the data fill attribute:

/* array(2) {
  [0]=> object(User)#3 (1) {
    ["name"] => string(4) "John"
  }
  [1]=> object(User)#4 (1) {
    ["name"]=> string(4) "Mike"
  }
} */

Note, you can combine this mode with PDO::FETCH_UNIQUE and PDO::FETCH_GROUP , to obtain an array of results indexed by unique fields, or to group results separately using non-unique fields.

For example, the code below will return an array where the record id will be used as an array index rather than a consecutive number.

class User {};
$stmt  = $pdo->query('SELECT id, id, name, car FROM users');
$users = ->fetchAll(PDO::FETCH_CLASS|PDO::FETCH_UNIQUE, 'User');

Assign class attributes

No matter which method is selected, all columns returned by the query will be assigned to the corresponding class attributes according to the following rules :

1. If there is a class attribute with the same name as the column name, then the column value will be assigned to the attribute

2. If there is no such attribute, then a magic will be called Method __set()

3. If the __set() method is not defined for the class, then a public property will be created and assigned a column value.

For example, this code

class User
{
    public $name;
}
$user = $pdo->query('SELECT * FROM users LIMIT 1')->fetchObject('User');

will give you an object with all properties automatically assigned regardless of whether they exist in the class:

/* object(User)#3 (4) {
  ["id"]   => string(3) "104"
  ["name"] => string(4) "John"
  ["sex"]  => string(4) "male"
  ["car"]  => string(6) "Toyota"
} */

As you can see from this , to avoid automatically creating attributes, you can use the magic method __set() to filter out attributes. The simplest filtering technique is an empty __set() method. Using it, only existing properties will be set:

class User
{
    private $name;
    public function __set($name, $value) {}
}
$user = $pdo->query('SELECT * FROM users LIMIT 1')->fetchObject('User');
/*
array(1) {
  [0]=> object(User)#3 (1) {
    ["name":"User":private]=> string(4) "John"
  }
} */

As above, PDO can also assign values ​​to private properties.

Pass constructor parameters to the object

Of course, for newly created objects, we may need to provide constructor parameters. For this purpose, the fetchObject() and fetchAll() methods have a dedicated parameter that you can use to pass the constructor parameters in the form of an array.

Suppose we have a class User, which has a car attribute that can be set in the constructor by providing the variable:

class User {
    public function __construct($car) {
        $this->car = $car;
    }
}

When getting the record, we should add a constructor with Array of parameters:

$users = $pdo->query('SELECT name FROM users LIMIT 1')
             ->fetchAll(PDO::FETCH_CLASS, 'User', ['Caterpillar']);

$user = $pdo->query('SELECT name FROM users LIMIT 1')
            ->fetchObject('User',['Caterpillar']);

/* object(User)#3 (2) {
    ["name"] => string(4) "John"
    ["car"]  => string(11) "Caterpillar"
} */

As you can see, the values ​​in the database are overwritten because by default PDO assigns class properties before calling the constructor. This can be a problem, but it's easy to fix:

Setting class properties after calling the constructor

mysql_fetch_object()Notes:

If you use mysql_fetch_object and specify a class - the properties will be set before the constructor is executed. This is usually not a problem, but if your property is set via the __set() magic method, then the constructor logic must be performed first, otherwise it may cause some major problems.

Unfortunately, mysql is a mysqli extension, but we use PDO. So, is there a way to tell PDO to assign properties after the constructor executes. For this purpose, the PDO::FETCH_PROPS_LATE constant must be used.

Using fetchAll() will be very simple,

class User {
    public function __construct($car) {
        $this->car = $car;
    }
}
$stmt  = $pdo->query('SELECT name, car FROM users LIMIT 1');
$users = $stmt->fetchAll(PDO::FETCH_CLASS|PDO::FETCH_PROPS_LATE, 'User', ['Caterpillar']);

When fetching a single row, we need to call setFetchMode() and fetchObject() at the same time, which may be a bit inconvenient.

class User {
    public function __construct($car) {
        $this->car = $car;
    }
}
$stmt = $pdo->query('SELECT name, car FROM users LIMIT 1');
$stmt->setFetchMode(PDO::FETCH_CLASS|PDO::FETCH_PROPS_LATE, 'User');
$user = $stmt->fetchObject('User', ['Caterpillar']);
/*
object(User)#3 (2) {
  ["car"]  => string(6) "Toyota"
  ["name"] => string(4) "John"
} */

The above code is not efficient because we have to write the class name twice.

Alternatively, we can use fetch():

$stmt = $pdo->query('SELECT name, car FROM users LIMIT 1');
$stmt->setFetchMode(PDO::FETCH_CLASS|PDO::FETCH_PROPS_LATE, 'User', ['Caterpillar']);
$user = $stmt->fetch();

But, as mentioned above, if a class happens to be undefined, it will not help us handle the error message.

Get the class name from the database

There is also a more interesting flag, which tells PDO to get the class from the value of the first column name. Using this flag, you can avoid using setFetchMode() and fetch():

$data = $pdo->query("SELECT 'User', name FROM users")
            ->fetch(PDO::FETCH_CLASS | PDO::FETCH_CLASSTYPE);
/*
object(User)#3 (1) {
  ["name"]=> string(4) "John"
} */

Additionally, this mode will be useful if objects of different classes can be created from the same query

class Male {};
class Female {};
$stmt = $pdo->query('SELECT sex, name FROM users');
$users = $stmt->fetchAll(PDO::FETCH_CLASS | PDO::FETCH_CLASSTYPE);
/*
array(6) {
  [0]=> object(Male)#3 (1) {
    ["name"]=> string(4) "John"
  }
  [1]=> object(Male)#4 (1) {
    ["name"]=> string(4) "Mike"
  }
  [2]=> object(Female)#5 (1) {
    ["name"]=> string(4) "Mary"
  }
  [3]=> object(Female)#6 (1) {
    ["name"]=> string(5) "Kathy"
  }
}*/

However, when using this pattern, it seems impossible to pass any parameters in the class constructor.

Update existing object

除了创建新对象，PDO还可以更新现有对象。只使用setFetchMode()，它将现有变量作为参数。显然，使用fetchAll()是无用的。

class User
{
    public $name;
    public $state;

    public function __construct()
    {
        $this->name = NULL;
    }
}
$user = new User;
$user->state = "up'n'running";
var_dump($user);

$stmt = $pdo->query('SELECT name FROM users LIMIT 1');
$stmt->setFetchMode(PDO::FETCH_INTO, $user);
$data = $stmt->fetch();
var_dump($data, $user);
/*
object(Foo)#2 (2) {
  ["name"]  => NULL
  ["state"] => string(12) "up'n'running"
}
object(Foo)#2 (2) {
  ["name"]  => string(4) "John"
  ["state"] => string(12) "up'n'running"
}
object(Foo)#2 (2) {
  ["name"]  => string(4) "John"
  ["state"] => string(12) "up'n'running"
} */

如上，fetch()调用返回的是相同的对象，这在我看来是多余的。还要注意，与PDO::FETCH_CLASS不同，这种模式不分配私有属性。

The above is the detailed content of How to get PDO object and set properties? (detailed code explanation). For more information, please follow other related articles on the PHP Chinese website!