How To Use Doctrine With CodeIgniter

I have already discussed few articles on codeigniter along with codeigniter basics. Codeigniter has good library/mechanism for manipulating database activity. Besides, it introduced active record class, which minimizes the complexity of writing SQL query. However, database support in codeigniter isn’t still good enough for many. Specially, many developers prefer to work with ORM for database layer and CodeIgniter doesn’t provide such built-in support. However, doctrine is a very powerful ORM in php and it is possible to easily integrate and use doctrine with CodeIgniter as ORM.

There is an official help page to do so, On official documentation page. However, you might get some issues and can’t understand why those are appearing clearly, specially as a beginner, same happened to me. That’s why, i think a more detailed explanation may help you in the way. So, In this tutorial, i will show how can we integrate this doctrine with CodeIgniter. This will follow will show some basic usage with PHO code examples. I am assuming, you have some basic knowledge in CodeIgniter. Basic understanding about what doctrine is and how it works, are also needed. You can follow an official getting started with doctrine tutorial.

Download And Install:

First, please download the latest doctrine orm. Now extract the contents and copy the extracted ‘doctrine’ directory to your CodeIgniter application’s ‘third_party’ directory.

Alternatively, if you are a composer fan, and already using composer with codeigniter, you can install doctrine orm via adding dependency on composer.json as below:

"require": {
            "doctrine/orm": "dev-master"
}

Now, in ‘application/libraries’ directory, lets create a new class file named ‘doctrine.php’ that will include all initialization of our doctrine library for our CodeIgniter application. The class is as follows:

use Doctrine\Common\ClassLoader,
    Doctrine\ORM\Configuration,
    Doctrine\ORM\EntityManager,
    Doctrine\Common\Cache\ArrayCache,
    Doctrine\DBAL\Logging\EchoSQLLogger,
    Doctrine\ORM\Mapping\Driver\DatabaseDriver,
    Doctrine\ORM\Tools\DisconnectedClassMetadataFactory,
    Doctrine\ORM\Tools\EntityGenerator;

/**
 * CodeIgniter Smarty Class
 *
 * initializes basic doctrine settings and act as doctrine object
 *
 * @final	Doctrine 
 * @category	Libraries
 * @author	Md. Ali Ahsan Rana
 * @link	http://codesamplez.com/
 */
class Doctrine {

  /**
   * @var EntityManager $em 
   */
    public $em = null;

  /**
   * constructor
   */
  public function __construct()
  {
    // load database configuration from CodeIgniter
    require APPPATH.'config/database.php';
    
    // Set up class loading. You could use different autoloaders, provided by your favorite framework,
    // if you want to.
    require_once APPPATH.'third_party/Doctrine/Common/ClassLoader.php';

    $doctrineClassLoader = new ClassLoader('Doctrine',  APPPATH.'third_party');
    $doctrineClassLoader->register();
    $entitiesClassLoader = new ClassLoader('models', rtrim(APPPATH, "/" ));
    $entitiesClassLoader->register();
    $proxiesClassLoader = new ClassLoader('proxies', APPPATH.'models');
    $proxiesClassLoader->register();

    // Set up caches
    $config = new Configuration;
    $cache = new ArrayCache;
    $config->setMetadataCacheImpl($cache);
    $driverImpl = $config->newDefaultAnnotationDriver(array(APPPATH.'models/Entities'));
    $config->setMetadataDriverImpl($driverImpl);
    $config->setQueryCacheImpl($cache);

    // Proxy configuration
    $config->setProxyDir(APPPATH.'models/proxies');
    $config->setProxyNamespace('Proxies');

    // Set up logger
    //$logger = new EchoSQLLogger;
    //$config->setSQLLogger($logger);

    $config->setAutoGenerateProxyClasses( TRUE );   
    // Database connection information
    $connectionOptions = array(
        'driver' => 'pdo_mysql',
        'user' =>     $db['default']['username'],
        'password' => $db['default']['password'],
        'host' =>     $db['default']['hostname'],
        'dbname' =>   $db['default']['database']
    );

    // Create EntityManager
    $this->em = EntityManager::create($connectionOptions, $config);   
  
    
  } 
}

NOTE: This above code requires php 5.3.x version installed on your server.

The above class is almost same as the one described on official reference, just optimized to be usable on codeigniter 2.x versions. Also, you will need to create two directories inside the ‘application/models’ directory, named ‘proxies’ and ‘entities’. On the above code, first we loaded codeigniter’s database configuration and doctrine class loaded to load necessary classes. Then it loads some necessary items. To know more in details about the configuration options and know how they works, please refer to official documentation of doctrine configuration options reference.

Create Entity From Database Automatically:

Although, its possible to generate entity classes from YAML file/ database through some command line argument, its much easier to have them generated right from the PHP script without any kind of extra effort. Following is an extra function that will help you to generate the entity classes. Just put it within the previously given class and call it at the last line on class constructor.

/**
   * generate entity objects automatically from mysql db tables
   * @return none
   */
  function generate_classes(){     
      
    $this->em->getConfiguration()
             ->setMetadataDriverImpl(
                new DatabaseDriver(
                        $this->em->getConnection()->getSchemaManager()
                )
    );

    $cmf = new DisconnectedClassMetadataFactory();
    $cmf->setEntityManager($this->em);
    $metadata = $cmf->getAllMetadata();     
    $generator = new EntityGenerator();
    
    $generator->setUpdateEntityIfExists(true);
    $generator->setGenerateStubMethods(true);
    $generator->setGenerateAnnotations(true);
    $generator->generate($metadata, APPPATH."models/Entities");
    
  }

Remember, activate calling to this method only once. and then after the entity classes are generated, keep it commented, otherwise you may get errors. If sometime, database structure changes/tables added/removed, just clear the ‘entities’ directory and reactivate the method(one time only, as well).

Basic Usage Of Doctrine With CodeIgniter:

Lets do a contact form example to understand how to use doctrine ORM within CodeIgniter. Lets create a table on our MySQL database named ‘pd_contact’ as like follows:

This will generate and entity class as like follows:

<?php
/**
 * PdContact
 *
 * @Table(name="pd_contact")
 * @Entity
 */
class PdContact
{
    /**
     * @var integer $id
     *
     * @Column(name="id", type="integer", nullable=false)
     * @Id
     * @GeneratedValue(strategy="IDENTITY")
     */
    private $id;

    /**
     * @var string $name
     *
     * @Column(name="name", type="string", length=50, nullable=false)
     */
    private $name;

    /**
     * @var string $email
     *
     * @Column(name="email", type="string", length=50, nullable=false)
     */
    private $email;

    /**
     * @var string $subject
     *
     * @Column(name="subject", type="string", length=100, nullable=false)
     */
    private $subject;

    /**
     * @var text $message
     *
     * @Column(name="message", type="text", nullable=false)
     */
    private $message;


    /**
     * Get id
     *
     * @return integer $id
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * Set name
     *
     * @param string $name
     */
    public function setName($name)
    {
        $this->name = $name;
    }

    /**
     * Get name
     *
     * @return string $name
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * Set email
     *
     * @param string $email
     */
    public function setEmail($email)
    {
        $this->email = $email;
    }

    /**
     * Get email
     *
     * @return string $email
     */
    public function getEmail()
    {
        return $this->email;
    }

    /**
     * Set subject
     *
     * @param string $subject
     */
    public function setSubject($subject)
    {
        $this->subject = $subject;
    }

    /**
     * Get subject
     *
     * @return string $subject
     */
    public function getSubject()
    {
        return $this->subject;
    }

    /**
     * Set message
     *
     * @param text $message
     */
    public function setMessage($message)
    {
        $this->message = $message;
    }

    /**
     * Get message
     *
     * @return text $message
     */
    public function getMessage()
    {
        return $this->message;
    }
}

Now, lets create a model that will contain the database layer logic to insert submitted data from a contact form. Here it is:

require_once(APPPATH."models/Entities/PdContact.php");
use \PdContact;
/**
 * manipulates data and contains data access logics for Enity 'User'
 *
 * @final Homemodel
 * @category models 
 * @author Md. Ali Ahsan Rana
 * @link http://codesamplez.com
 */
class Homemodel extends CI_Model {
    
    /**     
     * @var \Doctrine\ORM\EntityManager $em 
     */
    var $em;
    
    public function __construct() {
        parent::__construct();
        $this->em = $this->doctrine->em;
    }
    
    /**
     * Add contact messages to database
     * @param array $contact_form
     * @return bool 
     */
    function add_message()
    {    
        /**
         * @var PdContact $contact
         */
        $contact = new PdContact();
        $contact->setName($this->input->post("name");
        $contact->setEmail($this->input->post("email");
        $contact->setSubject($this->input->post("subject");
        $contact->setMessage($this->input->post("message");
        
        try {
            //save to database
            $this->em->persist($contact);
            $this->em->flush();
        }
        catch(Exception $err){
            
            die($err->getMessage());
        }
        return true;        
    }
}

the above example will insert a new row to ‘pd_contact’ table with the posted data. Query execution will be in action when the “$this->em->flush();” is called. If there are more database operations, then those will be executed in this stage as a batch execution, which results faster performance then traditional query execution.

Using Doctrine Command Line Tool With Codeigniter:

If you are a CLI tool fan, you will might be more happier to know that, doctrine has support for command line! to add its support, we will have to create a file named ‘cli-config.php’ in current directory and add the following code in there:

$system_path = 'system';
$application_folder = 'application';
define('BASEPATH', str_replace("\\", "/", $system_path));
define('APPPATH', $application_folder.'/');
        
include __DIR__."/vendor/autoload.php";
include __DIR__."/application/libraries/doctrine.php";

$doctrine = new Doctrine();
$em = $doctrine->em;
$helperSet = new \Symfony\Component\Console\Helper\HelperSet(array(
    'db' => new \Doctrine\DBAL\Tools\Console\Helper\ConnectionHelper($em->getConnection()),
    'em' => new \Doctrine\ORM\Tools\Console\Helper\EntityManagerHelper($em)
));

return $helperSet;

Now we should be fine to use the tool. If all settings are OK, run ‘{path}/{to}/{cli}/doctrine’ and you should see some out like the below screenshot:

Other examples of commands can be as like below:

$./vendor/bin/doctrine orm:validate-schema
$./vendor/bin/doctrine orm:generate:proxies
....

Note that, here I assumed you are using composer installed doctrine. Otherwise, use the proper cli tool path instead of ‘./vendor/bin/doctrine’.

Final Words:

Hope this tutorial on using doctrine with CodeIgniter will be very helpful to have a basic start for you. Ask if you have any questions or facing any issues. Keep in touch for more useful tutorials. Happy coding 🙂