Home arrow PHP arrow Page 4 - Working with MySQL and Sessions to Serialize Objects in PHP

Another implementation of object serialization: saving objects to MySQL tables - PHP

If you're interested in learning how to combine objects, sessions and MySQL, this is the article that you’ve been waiting for. It's the final part of the series “Serializing objects in PHP.” In three parts, this series goes through the fundamentals of serializing objects in PHP applications, and explores some advanced topics with regard to this subject, including the use of the magic “__sleep()” and “__wakeup()” functions, and the manipulation of serialized objects inside of MySQL tables.

  1. Working with MySQL and Sessions to Serialize Objects in PHP
  2. The basics of automated object serialization: using objects and sessions
  3. Combining objects and sessions: defining a session handling class
  4. Another implementation of object serialization: saving objects to MySQL tables
  5. The complete list of classes for the example
By: Alejandro Gervasio
Rating: starstarstarstarstar / 16
June 20, 2006

print this article



As I said before, the last example I’m going to show you illustrates the entire process for storing serialized objects in a MySQL table. To begin with, I’ll define a simple “objects” database table, composed of  “id” and “users” fields, which will house the IDs of stored objects and their serialized structure. Here is the SQL statement that creates this table:

CREATE TABLE objects (

As you can see, the table for storing serialized objects is fairly simple, thus now I’m going to build a basic “User” class, which will store some data about fictional people, such as Name, Postal Address and Email. The signature of the class looks like this:

// define 'User' class
class User{
    var $name;
    var $address;
    var $email;
    function User($userData=array()){
            trigger_error('User data must be an
        foreach($userData as $property=>$value){
                trigger_error('Invalid values for user
    // obtain user name
    function getName(){
        return $this->name;
    // obtain user address
    function getAddress(){
        return $this->address;
    // obtain user email
    function getEmail(){
        return $this->email;


That’s it. Now I defined the corresponding “User” class, which will serve to spawn as many objects as required, and after being serialized, these objects will be stored in the “objects” sample table.

There’s still one more thing that I wish to do before proceeding to store objects in a MySQL table: I’ll create an object serializing class, in order to handle the complete serialize/unserialize process by using its interface. The source code of this class, which I called “ObjectSerializer”, is shown below:

class ObjectSerializer{
    function ObjectSerializer(){}
    function getSerializedObj($obj){
            trigger_error($obj.'input parameter must be an
        return serialize($obj);
    function getUnserializedObj($data){
            trigger_error($data. 'must be a
        return unserialize($data);

In this case, the above class was defined as a simple wrapper for the pair of “serialize()/unserialize()” PHP functions, so it does not require much discussion about how it works. Given that, the next step consists of populating the “objects” table with some users, so first I’ll proceed to create them, like this:

// instantiate some 'User' objects
$usr1=&new User(array('name'=>'John Doe','address'=>'5456
Protocol Avenue MA','email'=>'john@domain.com'));
$usr2=&new User(array('name'=>'Susan Smith','address'=>'12345 Web
Boulevard CA','email'=>'susan@domain.com'));
$usr3=&new User(array('name'=>'Jeff Williams','address'=>'154321
Hyperlink Road NV','email'=>'jeff@domain.com'));
$usr4=&new User(array('name'=>'Bridget Lopez','address'=>'13579
Socket Street NY','email'=>'bridget@domain.com'));

All right, now that some fictional users have been created, it’s time to serialize them and store them in the “objects” database table. To do this, I’ll use a couple of MySQL wrapper classes that will be listed at the end of the example. Here is how the entire set of “Users” objects are stored in the corresponding table:

// connect to MySQL
$db=&new MySQL(array('host'=>'host','user'=>'user','password'=>'pass',
// instantiate 'ObjectSerializer' object
$objSer=&new ObjectSerializer();
// insert objects into database table
$db->query("INSERT INTO objects (id,users) VALUES
$db->query("INSERT INTO objects (id,users) VALUES
$db->query("INSERT INTO objects (id,users) VALUES
$db->query("INSERT INTO objects (id,users) VALUES

As you can see, the above script first connects to MySQL, then instantiates a new “ObjectSerializer” object, and finally inserts all the serialized “User” objects into the sample “objects” database table. Definitely, you’ll agree with me that this step is simple and comprehensive.

Once the respective users have been stored, I’m going to reverse the process and fetch the objects from the respective table, so I’m able to use their methods to display the information attached to them. Take a look at the piece of code below that precisely demonstrates how the objects are restored:

// restore objects from database table
$result=$db->query("SELECT * from objects");
    echo 'ID: '. $row['id'].' Name: '.$obj->getName().' Postal
Address: '.$obj->getAddress().' Email: '.$obj->getEmail().'<br />';

In this case, objects are first fetched from the database table by using a regular SELECT statement, and then unserialized by the “getUnserializedObj()” method. Finally, the data associated with each user is displayed by calling each of the corresponding getters.

Of course, below I listed the output generated by the previous example:

ID: 1 Name: John Doe Postal Address: 5456 Protocol Avenue MA Email: john@domain.com
ID: 2 Name: Susan Smith Postal Address: 12345 Web Boulevard CA Email: susan@domain.com
ID: 3 Name: Jeff Williams Postal Address: 154321 Hyperlink Road NV Email: jeff@domain.com
ID: 4 Name: Bridget Lopez Postal Address: 13579 Socket Street NY Email: bridget@domain.com

Even when you’re usually storing your binary objects in BLOB table fields, the approach that I just showed you before can be considered a useful alternative for saving objects as plain strings.

>>> More PHP Articles          >>> More By Alejandro Gervasio

blog comments powered by Disqus
escort Bursa Bursa escort Antalya eskort


- Hackers Compromise PHP Sites to Launch Attac...
- Red Hat, Zend Form OpenShift PaaS Alliance
- PHP IDE News
- BCD, Zend Extend PHP Partnership
- PHP FAQ Highlight
- PHP Creator Didn't Set Out to Create a Langu...
- PHP Trends Revealed in Zend Study
- PHP: Best Methods for Running Scheduled Jobs
- PHP Array Functions: array_change_key_case
- PHP array_combine Function
- PHP array_chunk Function
- PHP Closures as View Helpers: Lazy-Loading F...
- Using PHP Closures as View Helpers
- PHP File and Operating System Program Execut...
- PHP: Effects of Wrapping Code in Class Const...

Developer Shed Affiliates


Dev Shed Tutorial Topics: