Doctrine has by far the best known method of Nested Set operation I have come across. My main reason for this is the ability for it to store multiple roots in a single table. For example, this could come in handy for an application that implements multiple blogs.

So, let’s dive in and take a look at how we use this system.

For this example, I am going to show how this would come in use for a web application that hosts multiple blogs. Our database schema looks like this.

CREATE TABLE `Blogs` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `blog_admin` int(11) unsigned NOT NULL,
  `blog_title` text,
  `blog_description` text,
  `status` enum('live','private','offline') NOT NULL DEFAULT 'live',
  PRIMARY KEY (`id`),
  KEY `FK_Blogs_users` (`blog_admin`),
  CONSTRAINT `FK_Blogs_users` FOREIGN KEY (`blog_admin`) REFERENCES `Users` (`id`) ON DELETE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=latin1 ROW_FORMAT=DYNAMIC;

CREATE TABLE `BlogCategories` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `blog_id` int(11) unsigned NOT NULL,
  `name` varchar(140) DEFAULT NULL,
  `description` text,
  `lft` int(11) unsigned NOT NULL,
  `rgt` int(11) unsigned NOT NULL,
  `level` int(10) unsigned NOT NULL DEFAULT '0',
  `root_id` int(11) unsigned NOT NULL,
  PRIMARY KEY (`id`),
  KEY `FK_BlogCategories_blogs` (`blog_id`),
  CONSTRAINT `FK_BlogCategories_blogs` FOREIGN KEY (`blog_id`) REFERENCES `Blogs` (`id`) ON DELETE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=latin1 ROW_FORMAT=DYNAMIC;

Simply, we have a blogs table that has a foreign key back to a user table and the BlogCategories table will hold our categories relating to all the blogs. Next we will create our models…

I’m not going to cover model creation but for reference, I prefer to design my database through MySQL Query Browser first, then let Doctrine to generate the models for me using the generateModelsFromDb method like this;

//...
Doctrine_Core::generateModelsFromDb('/path/to/where/i/want/to/output/my/models/', array('doctrine'), array('generateTableClasses' => true));

In my BlogsCategories model, I tell it to act as a nested set, tell it there are many roots and declare the root column name (by default it is root_id, so I don’t need to declare it here but this is to show you how you would declare it to be a name other than root_id)

//...
$this->actAs('NestedSet', array(
	'hasManyRoots' => TRUE,
	'rootColumnName' => 'root_id'
	));

Now we’re good to go. The first thing we want to do is create a new root category. This category will be the parent category for all other categories.

$root = new BlogCategories();
$root->blog_id = 1; // relates back to the Blogs table
$root->name = 'ROOT';
$root->description = 'DO NOT DELETE';
$root->save(); // saves the new root category

$treeObject = Doctrine_Core::getTable('BlogCategories')->getTree();
$treeObject->createRoot($root);

If you look in your database now, you notice this has inserted the row and set the left/right/level/root columns appropriately. You can do this a few times to create a few roots. Now let’s look at inserting nodes for a particular blog. We’ll work with blog_id 1.

$blogOneRoot = Doctrine_Core::getTable('BlogCategories')->find(1); // the primary key of the root node for blog_id 1

$child = new BlogCategories();
$child->blog_id = 1;
$child->name = 'Doctrine';
$child->description = 'Good Doctrine tutorials';
$child->getNode()->insertAsLastChildOf($blogOneRoot);

This has now inserteda new child category for blog_id 1.

The last step we’ll take now is rendering a category tree of a particular blog. For this example again, I’ll assume blog_id 1.

$categoryTree = Doctrine_Core::getTable('BlogCategories')->getTree();
foreach($categoryTree ->fetchTree(array('root_id' => 1)) as $cat)
{
     echo str_repeat(' ', $cat['level']) . $cat['name'] . "\n";

}

And that pretty much covers the basics. It’s really easy – once you know how. There are many more cool things that can be done with Doctrine’s nested set method that I may cover on another day. Have fun!

Doctrine is a full blown PHP ORM framework that can be integrated into other frameworks or old school PHP applications. Here is how to integrate the framework to CodeIgniter.

Download a copy of the Doctrine framework and place it somewhere in your web directory (for this tutorial I am placing it at the web root directory /). My directory structure looks like;

.
..
.htaccess
index.php
licence.txt
user_guide
system
doctrine
application

Set database credentials

As you would with any other CI app that utilises a database, enter the connection details in the database.php file inside of the config folder.

//.. application/config/database.php
$db['default']['hostname'] = "[hostname]";
$db['default']['username'] = "[username]";
$db['default']['password'] = "[password]";
$db['default']['database'] = "[databasename]";
$db['default']['dbdriver'] = "[driver e.g. mysql]";
$db['default']['dbprefix'] = "";
$db['default']['pconnect'] = TRUE;
$db['default']['db_debug'] = TRUE;
$db['default']['cache_on'] = FALSE;
$db['default']['cachedir'] = "";
$db['default']['char_set'] = "utf8";
$db['default']['dbcollat'] = "utf8_general_ci";

Enable hooks

In the config file [application/config/config.php] enable hooks by setting hooks to TRUE.

//.. application/config/config.php
$config['enable_hooks'] = TRUE;

Insert the hook

Create a new file in the hooks directory [application/hooks] called doctrine.php

//.. application/hooks/doctrine.php
if(!defined('BASEPATH')) exit('file locked');

require_once( FCPATH . 'doctrine/lib/Doctrine.php' );

class DoctrineHook
{

	function bootstrap_doctrine()
	{
		require_once( APPPATH . '/config/database.php' );

		spl_autoload_register(array('Doctrine', 'autoload'));
		Doctrine_Manager::getInstance()->setAttribute('model_loading', 'aggressive');

		if (!isset($db[$active_group]['dsn'])) {
			$db[$active_group]['dsn'] = $db[$active_group]['dbdriver'] .
							'://' . $db[$active_group]['username'] .
							':' . $db[$active_group]['password'].
							'@' . $db[$active_group]['hostname'] .
							'/' . $db[$active_group]['database'];
		}

		Doctrine_Manager::connection($db[$active_group]['dsn']);
		Doctrine_Manager::setAttribute(Doctrine_Core::ATTR_AUTO_ACCESSOR_OVERRIDE, true);
		Doctrine_Manager::setAttribute(Doctrine_Core::ATTR_USE_NATIVE_ENUM, true);
		Doctrine::loadModels(APPPATH . DIRECTORY_SEPARATOR . 'models/doctrine/');
	}

}

Register the hook

So, now we have the hook in place we need to tell CI to execute the hook on system start up. Over to application/config/hooks.php…

//.. application/config/hooks.php
 if ( ! defined('BASEPATH')) exit('No direct script access allowed');
/*
| -------------------------------------------------------------------------
| Hooks
| -------------------------------------------------------------------------
| This file lets you define "hooks" to extend CI without hacking the core
| files.  Please see the user guide for info:
|
|	http://codeigniter.com/user_guide/general/hooks.html
|
*/
$hook['pre_controller'][] = array(
	'class' => 'DoctrineHook',
	'function' => 'bootstrap_doctrine',
	'filename' => 'doctrine.php',
	'filepath' => 'hooks'
	);

/* End of file hooks.php */
/* Location: ./system/application/config/hooks.php */

With this now in place, CI will load doctrine upon each load. There is one thing left to do. Some of you may have noticed in the doctrine.php hook we created, we told Doctrine to load our models from application/models/doctrine. I created the doctrine folder inside the models folder to purposely seperate doctrine classes from my CI models.

Everything should now work and you can call a model using native PHP class loading methods…

//.. inside a controller we may call a user class like this;
$user = new User();