Before we proceed, a disclaimer. This tutorial shows a rather quick and dirty integration with Doctrine (as you’ll see it’s all mostly done in a base model class), while the most clean approach would be to implement all this as an extension, using Datasources and Query parsing. I’m happy to say this is all being done as we speak (thanks kuja!), so very soon you’ll find an even better approach to Doctrine integration.

Other Lithium Tutorials

Of course I’m not the only one to have written about Lithium! Here are some tutorials you may enjoy:

• Video Tutorial: li3 on Apache2, and li3 on IIS7.
• The original Lithium blog tutorial.

The Basics

For the sakes of me being lazy, I’ll assume you have prior knowledge of:

• PHP 5.3 basics
• Another PHP framework (like CakePHP, the most popular PHP framework).
• Using GIT (you should have it installed, Ubunty folks: $ sudo apt-get install git-core)
• You should have an account setup with your SSH key in rad-dev.org (instructions here)

Adding PHP 5.3 support

There are many ways people have shown how to enable PHP 5.3 support on your servers. In my case, since I run my own compiled version of Apache + PHP, it gets easier. I’ll show you here how to set up dual support (PHP 5.2 and PHP 5.3) on your Apache in case you are as smart as me, and decided to build it yourself as well ;-]

First download and compile PHP 5.3 (this instructions point to the latest release of PHP 5.3 at the time of this writing, you may need to check PHP.net to see if there’s a newer version):

$ cd /usr/local/src
$ sudo wget http://ar.php.net/get/php-5.3.1.tar.gz/from/this/mirror
$ sudo tar xzvf php-5.3.1.tar.gz
$ sudo chown -R $USER:$USER php-5.3.1/
$ cd php-5.3.1/
$ ./configure \
  --prefix=/usr/local/php5.3 \
  --with-config-file-path=/usr/local/php5.3 \
  --with-libxml-dir=/usr/include/libxml2 \
  --with-mysql=/usr/local/mysql \
  --enable-pdo \
  --with-pdo-mysql=/usr/local/mysql \
  --with-zlib=/usr/local/zlib \
  --with-curl \
  --with-gd \
  --with-jpeg-dir=/usr/lib \
  --with-png-dir=/usr/lib \
  --with-freetype-dir=/usr/lib \
  --with-gettext \
  --enable-mbstring \
  --enable-soap \
  --enable-ftp \
  --with-openssl
$ make
$ sudo make install

Easy right? Now, whenever you want to add a virtual host that supports PHP 5.3, you’ll have to add these lines inside the <VirtualHost> directive:

ScriptAlias /cgi-bin/ /usr/local/php5.3/bin/
Action php53-cgi /cgi-bin/php-cgi
AddHandler php53-cgi .php5 .php

<Directory "/usr/local/php5.3/bin">
	Options +ExecCGI -Includes
	Order allow,deny
	Allow from all
</Directory>

Installing Lithium

First thing you’ll have to do is clone from lithium’s git repository. We’ll do it in a generic place, that we’ll be able to share from all our lithium applications, in order to keep up with the amazing ongoing development in Lithium. So let’s clone that stuff:

$ cd /var/www
$ git clone code@rad-dev.org:lithium.git lithium

So now in our /var/www/lithium directory we have lithium installed. Every time we’ll want to ugrade to lithium’s latest release, we’ll just do:

$ cd /var/www/lithium
$ git pull --rebase

Setup the application structure

We now have a generic place (/var/www/lithium) where we have lithium installed. Each time we start a new application, we’ll just copy over the application directory, and link to lithium’s core directory.

So we want to create an application in the host http://blog.li3 so we’ll store its files in /var/www/blog.li3. Let’s copy the files, and link to the core:

$ mkdir /var/www/blog.li3
$ cd /var/www/blog.li3
$ cp -pR /var/www/lithium/app .
$ ln -s /var/www/lithium/libraries libraries

Add the virtual host

Ok we now have the application installed in /var/www/blog.li3. Let’s create the virtual host for it. First edit your /etc/hosts file and add this line:

127.0.1.1	blog.li3

Now let’s add the virtual host to apache. Edit the file /usr/local/apache2/conf/extra/httpd-vhosts.conf (obviously this may be different in your setup) and add the following:

<VirtualHost *:80>
	ServerName blog.li3
	DocumentRoot "/var/www/blog.li3/app/webroot"
	ErrorLog "logs/blog.li3.error.log"
	CustomLog "logs/blog.li3.access.log" combined

	ScriptAlias /cgi-bin/ /usr/local/php5.3/bin/
	Action php53-cgi /cgi-bin/php-cgi
	AddHandler php53-cgi .php5 .php

	<Directory "/usr/local/php5.3/bin">
		Options +ExecCGI -Includes
		Order allow,deny
		Allow from all
	</Directory>
</VirtualHost>

You should now restart apache:

$ sudo /etc/init.d/apachectl restart

And you should be able to browse to http://blog.li3 and see a screen just like this:

Lithium's welcome screen

Install Doctrine 2.0

We’ll install doctrine as a system-wide library. Therefore we’ll move to our generic lithium install’s library path (/var/www/lithium/libraries) and download doctrine inside. Now we need the Doctrine ORM release (you may need to check the doctrine download page for a more up-to-date version of the 2.0 branch:

$ cd /var/www/lithium/libraries
$ mkdir doctrine
$ cd doctrine
$ wget http://www.doctrine-project.org/download/2_0_0_ALPHA3/format/tgz/package/ORM
$ tar -xzvf DoctrineORM-2.0.0-ALPHA3.tgz

Loading the Database

Now that we have the basics in place (PHP 5.3 enabled, Lithium installed, Doctrine installed), we’ll start building our application.

Creating the Database and loading some data

Let’s start by creating a database named blog_li3:

$ mysqladmin -uroot -p create blog_li3

Now load this SQL statements to the database we’ve just created:

CREATE TABLE `posts`(
    `id` INT NOT NULL AUTO_INCREMENT,
    `title` VARCHAR(255) NOT NULL,
    `body` TEXT NOT NULL,
    `published` BOOLEAN NOT NULL default FALSE,
    `created` DATETIME NOT NULL,
    `modified` DATETIME NOT NULL,
    PRIMARY KEY(`id`)
);

CREATE TABLE `comments`(
    `id` INT NOT NULL AUTO_INCREMENT,
    `post_id` INT NOT NULL,
    `name` VARCHAR(255) NOT NULL,
    `email` VARCHAR(255) NOT NULL,
    `body` TEXT NOT NULL,
    `created` DATETIME NOT NULL,
    `modified` DATETIME NOT NULL,
    PRIMARY KEY(`id`)
);

ALTER TABLE `comments`
    ADD KEY `post_id`(`post_id`),
    ADD CONSTRAINT `comments__posts` FOREIGN KEY (`post_id`) REFERENCES `posts`(`id`);

INSERT INTO `posts` VALUES
    (1, 'First post', 'This is the body for the first post', TRUE, NOW(), NOW());

INSERT INTO `comments` VALUES
    (1, 1, 'Mariano Iglesias', 'mariano@email.com', 'This is a nice post!', NOW(), NOW());

Setting up the DB connection

Let’s add the basics Doctrine needs to run into Lithium’s bootstrap. Edit the file app/config/bootstrap.php in your application directory (/var/www/blog.li3) and add the following at the end:

/**
 * Load Doctrine
 */

Libraries::add('Doctrine', array(
	'path' => LITHIUM_LIBRARY_PATH . '/doctrine/DoctrineORM-2.0.0/Doctrine'
));

Now how easy was that? Since Doctrine shares the same name structure Lithium does, the inclusion of Doctrine classes in Lithium is that easy. Next step: let’s set up the connection. Open app/config/connections.php and replace the whole Connections::add expression with the following (notice how we are adding a connection of type ‘doctrine’ rather than the default type ‘database’ lithium provides):

Connections::add('default', 'doctrine', array(
	'driver' => 'pdo_mysql',
	'host' => 'localhost',
	'user' => 'root',
	'password' => 'password',
	'dbname' => 'blog_li3'
));

Creating a wrapper for some Doctrine functionality

If you go through doctrine documentation, you’ll see it’s quite powerful and flexible. However, we’ll want to have a basic wrapper around the most common functionality (establishing the connection, querying a model, creating / editing / deleting records) so our work from our controllers is more transparent, and Doctrine agnostic. So let’s create a base class for all models (CakePHP folks, this will sound familiar) and name it AppModel

First, the code. Create a file named AppModel.php in your app/ directory, with the following contents.

<?php
namespace app;

use \lithium\data\Connections;

abstract class AppModel extends \lithium\data\model\Record {
	protected static $_alias;
	protected static $_entityManagers = array();

	public static function create($data = array()) {
		$class = get_called_class();
		$record = new $class();
		return $record->set($data);
	}

	public function set($data = array()){
		if (isset($data) && count($data) > 1) {
			if (!isset($data['created']) && !isset($data['id']) && !isset($this->id)) {
				$data['created'] = new \DateTime(date('Y-m-d H:i:s'));
			}

			if (!isset($data['modified'])) {
				$data['modified'] = new \DateTime(date('Y-m-d H:i:s'));
			}

			foreach($data as $key => $value) {
				$this->$key = $value;
			}
		}
		return $this;
	}

	public function save() {
		$entityManager = $this->_entityManager();
		$entityManager->persist($this);
		$entityManager->flush();
		return $this;
	}

	public function delete($id = null) {
		if (empty($id)) {
			$id = $this->id;
		}
		$entityManager = $this->_entityManager();
		$entityManager->remove($this);
		$entityManager->flush();
		return $this;
	}

	public static function find($type = 'first', $query = array()) {
		$class = get_called_class();
		$alias = self::$_alias ?: substr($class, strrpos($class, '\\') + 1);
		$methods = array('first', 'all');

		if (!in_array($type, $methods)) {
			throw new \Exception("Find method \"{$type}\" is not implemented");
		}

		$query = array_merge(array(
			'fields' => null,
			'conditions' => null,
			'order' => null
		), $query);

		$fields = array();
		if (isset($query['fields'])) {
			foreach($query['fields'] as $field) {
				$model = $alias;
				if (strpos($field, '.') === false) {
					list($model, $field) = explode('.', $field);
				}
			}
		} else {
			$fields[] = $alias;
		}

		$queryBuilder = self::_entityManager()->createQueryBuilder();
		$queryBuilder->add('select', $alias)->add('from', $queryBuilder->expr()->from($class, $alias));

		$expression = self::_conditionsToDqlExpr($alias, $queryBuilder, $query['conditions']);
		if (isset($expression)) {
			$queryBuilder->add('where', $expression);
		}

		if (!empty($query['order'])) {
			$order = $query['order'];
			if (is_array($query['order'])) {
				$order = array();
				foreach($query['order'] as $field => $direction) {
					if (!is_string($field)) {
						$field = $direction;
						$direction = 'asc';
					}
					$order[] = (strpos($field, '.') === false ? $alias . '.' : '') . $field . ' ' . $direction;
				}
				$order = implode(',', $order);
			}
			$queryBuilder->add('orderBy', $order);
		}

		$dql = $queryBuilder->getDql();
		$result = self::_entityManager()->createQuery($dql)->getResult();
		if (isset($result) && $type == 'first') {
			$result = current($result);
		}
		return $result;
	}

	protected static function _conditionsToDqlExpr($alias, $queryBuilder, $conditions) {
		$expr = $queryBuilder->expr();
		if (empty($conditions)) {
			return null;
		} else if (is_string($conditions)) {
			$expr = $expr->andx($conditions);
		} else {
			foreach($conditions as $key => $value) {
				if (is_string($key) && in_array(strtolower($key), array('and', 'or'))) {
					$clause = strtolower($key);
					$pieces = array();
					foreach((array) $value as $innerKey => $piece) {
						if (is_string($innerKey)) {
							$piece = array($innerKey => $piece);
						}
						$pieces[] = self::_conditionsToDqlExpr($alias, $queryBuilder, $piece);
					}
					$expr = call_user_func_array(array($expr, $clause . 'x'), $pieces);
				} else if (is_string($key)) {
					if (strpos($key, '.') === false) {
						$key = $alias . '.' . $key;
					}
					if (is_array($value)) {
						$values = $value;
						foreach($values as $iv => $value) {
							$values[$iv] = $expr->literal($value);
						}
						$expr = $expr->in($key, $values);
					} else {
						$expr = $expr->eq($key, $expr->literal($value));
					}
				} else {
					$expr = $expr->andx(self::_conditionsToDqlExpr($alias, $queryBuilder, $value));
				}
			}
		}

		return $expr;
	}

	protected static function _entityManager($connectionName = 'default') {
		if (!isset(self::$_entityManagers[$connectionName])) {
			$connection = Connections::get($connectionName, array('config'=>true));
			if (!isset($connection)) {
				throw new \Exception("Configuration {$connectionName} not found");
			} else if ($connection['type'] != 'doctrine') {
				throw new \Exception("Configuration {$connectionName} is not a doctrine configuration");
			}

			$config = new \Doctrine\ORM\Configuration();
			$config->setProxyDir(LITHIUM_APP_PATH . '/models');
			$config->setProxyNamespace('app\models');

			self::$_entityManagers[$connectionName] = \Doctrine\ORM\EntityManager::create($connection, $config);
		}
		return self::$_entityManagers[$connectionName];
	}

	/**
	 * Overrides for lithium/data/model/Record
	 */

	public function exists() {
		return !empty($this->id);
	}

	public function __get($name) {
		return isset($this->$name) ? $this->$name : null;
	}
}

?>

That’s a lot, right? First of all, this is generic enough so we won’t go through the detailed explanation line by line, but we’ll go through what each method does, and why is there. So let’s see:

• create(): creates a new instance of a record class, loading it with the specified data.
• set(): sets the specified data on the current record instance
• save(): saves (persists) the current record
• delete(): deletes the current record, or the record whose ID is specified
• find(): it finds :-] It tries to mimic the same parameters CakePHP has on its find method. Takes two parameters: first, the find type (only ‘first’ and ‘all’ supported here), and second an array of options (supported options: ‘fields’, ‘conditions’, ‘order’)
• _conditionsToDqlExpr(): helper method used by find() to convert the array based conditions into a Doctrine DQL Query (using Doctrine’s QueryBuilder)
• _entityManager(): gives back Doctrine’s EntityManager used to perform actual operations
• exists(): Tells if current record exists. Overriden from Lithium’s record to add support for the record in the FormHelper
• __get(): Gives back the given field’s value for current record. Overriden from Lithium’s record to add support for the record in the FormHelper

The models

Ok now to the fun part, creating the models our application will need. If you remember, the SQL script created two tables: posts and comments. Therefore we’ll have two models, Post and Comment. In order to link each comment’s property to a real table field, we’ll use Doctrine’s annotations. They define the characteristics of each record field through source code comments.

Let’s first create the Post model. Create a file named Post.php in your app/models folder with the following contents:

<?php
namespace app\models;

/**
 * @Entity
 * @Table(name="posts")
 */
class Post extends \app\AppModel {
	/**
	 * @Id @Column(type="integer")
	 * @GeneratedValue(strategy="AUTO")
	 */
	public $id;

	/** @Column(type="string") */
	public $title;

	/** @Column(type="text") */
	public $body;

	/** @Column(type="datetime") */
	public $created;

	/** @Column(type="datetime") */
	public $modified;

	/** @OneToMany(targetEntity="Comment", mappedBy="post", cascade={"remove"}) */
	public $comments;
}
?>

To understand the actual annotations, go through Doctrine’s introduction to docblock annotations. What it’s important for us is seeing that we have a property for each field in our posts table (what we want mapped to our record class), plus a property to store all related comments (the $comments property), each of which will be an instance of the Comment class.

So what about the Comment class? Create a file named Comment.php in your app/models folder with the following contents:

<?php
namespace app\models;

/**
 * @Entity
 * @Table(name="comments")
 */
class Comment extends \app\AppModel {
	/**
	 * @Id @Column(type="integer")
	 * @GeneratedValue(strategy="AUTO")
	 */
	public $id;

	/** @Column(type="string") */
	public $name;

	/** @Column(type="string") */
	public $email;

	/** @Column(type="text") */
	public $body;

	/** @Column(type="datetime") */
	public $created;

	/** @Column(type="datetime") */
	public $modified;

	/**
	 * @ManyToOne(targetEntity="Post")
	 * @JoinColumn(name="post_id", referencedColumnName="id")
	 */
	public $post;
}
?>

Just as before, we have a property per field, plus a property named $post to hold the instance of the Post a Comment belongs to.

The Controllers

Let’s first create the basic controller for Post records, that will simply show the list of post titles, with links for operations that we don’t yet have (editing, adding, removing, etc.) Create a file named PostsController.php in your app/controllers folder with the following contents.

<?php
namespace app\controllers;

use app\models\Post;

class PostsController extends \lithium\action\Controller {
	public function index() {
		$posts = Post::find('all');
		$this->set(compact('posts'));
	}
}
?>

That’s a very simple controller, isn’t it? We just get the posts, and pass it to the view as a $posts variable. So let’s create the view then. Create a folder named posts in your app/views/ folder, and then create a file named index.html.php in the newly created app/views/posts folder with the following contents:

<h1>Posts</h1>
<p><?php echo $this->html->link('Add new Post', '/posts/edit'); ?></p>
<ul>
<?php foreach($posts as $post) { ?>
	<li>
		<?php echo $this->html->link($post->title, '/posts/view/' . $post->id); ?>
		[<?php echo $this->html->link('Edit', '/posts/edit/' . $post->id); ?>]
		[<?php echo $this->html->link('Delete', '/posts/delete/' . $post->id, array('onClick'=>'return confirm("Are you sure you want to delete this record");')); ?>]
	</li>
<?php } ?>
</ul>

This code also speaks for itself. So let’s now create an action to view an actual post. Add a method named view() in your PostsController with the following code:

public function view($id = null) {
	$id = $id ?: $this->request->id;
	$post = Post::find('first', array('conditions' => compact('id')));
	$this->set(compact('post'));
}

We are basically getting the ID first (since it’s a numeric ID, a convenient Lithium route check will set it as part of the request information), and then looking for a Post with the given ID. That post will also contain the comments attached to it, so knowing that we can create the view for this action. Create a file named view.html.php in your app/views/posts folder with the following contents:

<h1><?php echo $post->title; ?></h1>
<p><small><?php echo $post->created->format('F d, Y H:i'); ?></small></p>
<?php echo $post->body; ?>

<?php if (!$post->comments->isEmpty()) { ?>
	<h3>Comments</h3>
	<?php foreach($post->comments as $comment) { ?>
			<p><small>
			by <a href="mailto:<?php echo $comment->email; ?>"><?php echo $comment->name; ?></a>
			on <?php echo $comment->created->format('F d, Y H:i'); ?>
			</small></p>
			<?php echo $comment->body; ?>
	<?php } ?>
<?php } ?>

<h3>Add your Comment</h3>
<?php echo $this->form->create(null, array('url'=>array('controller'=>'comments', 'action'=>'add'))); ?>
	<?php echo $this->form->hidden('post_id', array('value' => $post->id)); ?>
	<label>Your email:</label> <?php echo $this->form->text('email', array('size'=>60)); ?>
	<label>Your name:</label> <?php echo $this->form->text('name', array('size'=>60)); ?>
	<label>Comment:</label> <?php echo $this->form->textarea('body', array('rows'=>5, 'cols'=>60)); ?>
	<?php echo $this->form->submit('Add Comment'); ?>
<?php echo $this->form->end(); ?>

This code should also speak for itself, except probably the isEmpty() method, which is part of the collection’s methods Doctrine provides.

Another thing to note in the above view is the form at the bottom, used to add comments to a post. First thing we notice there is that we are setting as action for the post an action called add in a controller named Comments. We don’t yet have this controller, do we? So let’s add it.

Create a file named CommentsController.php in your app/controllers folder with the following contents:

<?php
namespace app\controllers;

use app\models\Post;
use app\models\Comment;

class CommentsController extends \lithium\action\Controller {
	public function add() {
		if (empty($this->request->data)) {
			$this->redirect('/');
		}

		$post = Post::find('first', array(
			'conditions'=>array('Post.id' => $this->request->data['post_id'])
		));
		if (!$post) {
			throw new \Exception("No post found for ID {$this->request->data['post_id']}");
		}

		$comment = Comment::create($this->request->data);
		$comment->post = $post;
		$comment->save();

		$this->redirect('/posts/view/' . $post->id);
	}
}
?>

This action looks more involved. First thing we do, is make sure someone is posting data to this action (that’s the check on $this->request->data, where the posted data comes in Lithium). If they don’t, we kick their butts. Next, we make sure there’s an actual post for the given ID. If there’s not, we throw an exception. The last part is the actual saving of the comment, so let’s go through that:

• With $comment = Comment::create($this->request->data); we create an instance of the Comment class, initially populating with the posted data (so the properties $email, $name, etc. will get populated with the posted data)
• Next with $comment->post = $post; we specify to which Post the Comment belongs to.
• Finally we persist (save) the Comment with $comment->save();

Since we redirect them no matter what, we need no view for this action. Also, you may have noticed that there’s no validation. That will be left as homework for you. After the comment is saved, we redirect the user back to the post page.

So we now know how to show the list of posts, how to view a post, and add a comment. All we have to do next is add the ability to add/edit posts, and remove them. Let’s start with the easy part, deleting a post. Add the following to your PostsController:

public function delete($id = null) {
	$id = $id ?: $this->request->id;
	if (!isset($id)) {
		$this->redirect('/posts');
	}

	$post = Post::find('first', array('conditions' => compact('id')));
	if (!$post) {
		throw new \Exception("No post found for ID {$id}");
	}

	$post->delete();
	$this->redirect('/posts');
}

This code almost needs no explaining after what we’ve seen so far. The only important part there is the actual deletion of the Post by calling its delete() method. Also, this is another action that needs no view, since we are redirecting them after the operation.

Finally, and since we have seen how to add a comment, adding a post won’t be that different. In fact, we’ll deal with adding and editing posts in the same action.

Add the following action to your PostsController:

public function edit($id = null) {
	$id = $id ?: $this->request->id;
	if (isset($id)) {
		$post = Post::find('first', array('conditions' => compact('id')));
		if (!$post) {
			throw new \Exception("No post found for ID {$id}");
		}
	} else {
		$post = Post::create();
	}

	if (!empty($this->request->data)) {
		$post->set($this->request->data)->save();
		if (!isset($id)) {
			$this->redirect('/posts');
		}
		$this->redirect('/posts/view/' . $post->id);
	}
	$this->set(compact('post'));
}

The important thing to notice here is that if there’s an ID provided, we try to get the Post. If there’s none, we create a new Post record instance by calling Post::create();. Then, once we got submitted data, we simply populate the properties with posted data and save the record, all in a single line: $post->set($this->request->data)->save();. Yeah, there’s no validation here either. More homework!

So what about the view for this action? Create a file named edit.html.php in your app/views/posts folder with the following contents:

<h3>Edit Post</h3>
<?php echo $this->form->create($post, array('url'=>'/posts/edit/' . $post->id, 'method'=>'post')); ?>
	<label>Title:</label> <?php echo $this->form->text('title', array('size'=>60)); ?>
	<label>Body:</label> <?php echo $this->form->textarea('body', array('rows'=>5, 'cols'=>60)); ?>
	<?php echo $this->form->submit('Add Comment'); ?>
<?php echo $this->form->end(); ?>

This is yet another code that speaks for itself. How lazy am I?

Conclusion

We've had fun, didn't we? We now have a very basic blog system working, using PHP 5.3 only tools (Lithium, the most rad framework, and Doctrine 2, a very interesting ORM). We could easily extend this further, but we'll wait on the work the Lithium team is doing to offer a much better integration with Doctrine. In the meantime, use this knowledge to have some fun, and build some cool projects!

Related posts:

1. Pagination with custom find types in CakePHP

I’m not gonna go through custom find types, you can find more info about them at Matt’s blog, or at this article written by someone whose name I think I’ve heard somewhere. What I’m going to talk about is how to mix your custom find types with pagination, without having to use paginate and paginateCount in your models.

So let’s first start by building yet another posts table, and inserting some records:

CREATE TABLE `posts`(
	`id` INT NOT NULL AUTO_INCREMENT,
	`title` VARCHAR(255) NOT NULL,
	`body` TEXT NOT NULL,
	`published` TINYINT(1) NOT NULL default 0,
	`created` DATETIME,
	`modified` DATETIME,
	PRIMARY KEY(`id`)
);

INSERT INTO `posts`(`title`, `body`, `published`, `created`, `modified`) VALUES
	('Post 1', 'Body for Post 1', 1, NOW(), NOW()),
	('Post 2', 'Body for Post 2', 0, NOW(), NOW()),
	('Post 3', 'Body for Post 3', 0, NOW(), NOW()),
	('Post 4', 'Body for Post 4', 1, NOW(), NOW()),
	('Post 5', 'Body for Post 5', 1, NOW(), NOW()),
	('Post 6', 'Body for Post 6', 0, NOW(), NOW()),
	('Post 7', 'Body for Post 7', 1, NOW(), NOW()),
	('Post 8', 'Body for Post 8', 1, NOW(), NOW()),
	('Post 9', 'Body for Post 9', 1, NOW(), NOW());

Now let’s assume we want a find type called published to fetch only the published posts, and that we also want to be able to paginate using this find type. We will be approaching this through a generic approach, something that can be used throughout all our models. With this in mind, let’s first introduce a model based member variable called $_types, where we define the specific needs of each custom find type. Therefore, that variable will hold what we need as conditions, order, etc. for each custom find type. So let’s build our Post model:

<?php
class Post extends AppModel {
	public $name = 'Post';
	protected $_types = array(
		'published' => array(
			'conditions' => array('Post.published' => 1),
			'order' => array('Post.created' => 'desc')
		)
	);
}
?>

As you can see, we define options for each find type as if we would be calling find() directly. So with the above, instead of doing:

$posts = $this->Post->find('all', array(
	'conditions' => array('Post.published' => 1),
	'order' => array('Post.created' => 'desc')
));

We can now do:

$posts = $this->Post->find('published');

Now, what if we wanted to paginate with the above custom find type? Just as we set pagination parameters through the controller member variable $paginate, we can specify which find type pagination we’ll use. We do so by specifying the find type in the index 0 of the pagination settings. Like so:

$this->paginate['Post'] = array(
	'published',
	'limit' => 10
);

$posts = $this->paginate('Post');

Easy, huh? When this is specified, paginate() does the following:

1. It issues a find('count') on the Post model, specifying the custom find type (published) in the $options array, through an option named type. Therefore, we can use $options['type'] when our model is about to do the count to use the given options for our custom find type.
2. It fetches the records by calling find() with the custom find type, find('published') in our example.

So where’s that sexy code? Add the following in your AppModel, making the above available for all our models.

<?php
class AppModel extends Model {
	public function find($type, $options = array()) {
		if (!empty($this->_types)) {
			$types = array_keys($this->_types);
			$type = (is_string($type) ? $type : null);
			if (!empty($type)) {
				if (($type == 'count' && !empty($options['type']) && in_array($options['type'], $types)) || in_array($type, $types)) {
					$options = Set::merge(
						$this->_types[($type == 'count' ? $options['type'] : $type)],
						array_diff_key($options, array('type'=>true))
					);
				}
				if (in_array($type, $types)) {
					$type = (!empty($this->_types[$type]['type']) ? $this->_types[$type]['type'] : 'all');
				}
			}
		}
		return parent::find($type, $options);
	}
}
?>

Now ain’t CakePHP great? Don’t tell me, tell everyone at CakeFest #3.

Related posts:

1. Modelizing HABTM join tables in CakePHP 1.2: with and auto-with models
2. CakePHP tip of the day: pay attention to conventions
3. CakePHP 1.2 tip of the day: be mindful of Model::set

What better place to talk CakePHP than the world’s beer nation? That was the question that made the CakePHP Team decide CakeFest third edition should be located in Berlin, Germany. Just as Buenos Aires was the meat fest, I hereby predict that this will be the Beer Fest.

Let’s face it, your code gets better when you use CakePHP. So attending the official CakePHP gathering where all Core Developers and prominent community members go to share their knowledge is an offer you should not ignore. Add awesome beer and guaranteed fun to that recipe, and you would be insane not to join us.

So what are you waiting for? Go and get your CakeFest ticket as soon as possible, you don’t want to be left behind! If you have a company, or you are a regular Baker just wanting to show your love back to the project, do not hesitate to sign up for the sponsorship packages. Also help us spread the word by placing these CakeFest badges in your site, and you may even get a free ticket!

Related posts:

1. CakePHP 1.2 beta released and CakeFest site launched
2. My talk in CakeFest: behaviors
3. CakeFest was a success

<?php
function format($size) {
	$unit = 'B';
	$units = array(
		'GB' => 1024 * 1024 * 1024
		, 'MB' => 1024 * 1024
		, 'KB' => 1024
	);

	foreach($units as $currentUnit => $value) {
		if ($size > 2 * $value) {
			$size /= $value;
			$unit = $currentUnit;
			break;
		}
	}

	return number_format($size, 1) . ' ' . $unit;
}

$settings = array(
	'host' => 'localhost'
	, 'user' => 'root'
	, 'password' => 'password'
);

$databases = array();

mysql_connect($settings['host'], $settings['user'], $settings['password']);

$result = mysql_query('show databases');
while($row = mysql_fetch_array($result)) {
	$databases[] = $row['Database'];
}

foreach($databases as $database) {
	$sizes[$database] = 0;

	mysql_select_db($database);
	$result = mysql_query('show table status');
	while($row = mysql_fetch_array($result)) {
		$sizes[$database] += $row['Data_length'] + $row['Index_length'];
	}
}

mysql_close();

foreach($sizes as $database => $size) {
	echo $database . ' = ' . format($size) . '<br />';
}

echo '<br />TOTAL: ' . format(array_sum($sizes));

?>

When I ran it, I saw all my DBs where taking a total of 10.8 GB, much less than the 86 GB occupied in the partition. So it hit me, it has to be the binary logs, a set of files that store log events (more about them here). Indeed, if you would list the contents of /var/lib/mysql I would find a ton of .bin files, a lot of them as old as from 2007. Therefore, I realized I had to flush the logs.

In order to flush the binary logs, I logged in to the MySQL console as an administrator, and issued (if you are on a server with replication, you want to purge the binary logs instead):

FLUSH LOGS;
RESET MASTER;

After doing so, the MySQL partition is now taking a total of 12 GB. Much better!

No related posts.

I am not even close to finishing it, but so far I’m having LOTS of fun. What is amazing is that missing only the M in MVC (the database abstraction layer), CLAPP’s performance is already astonishing. Running as FastCGI, it outperforms the most basic PHP file by a ratio of 1000%. Amazing.

So what am I looking to gain from this? Nothing, just having fun going back to my absolute favourite language: C++. In the meantime, I get to play with speed comparisons, which gets particularly interesting as I enable more stuff in the framework. My ideal goal is to include a lot of the you-just-have-to-have-this kind of things available on real, serious frameworks such as CakePHP. This doesn’t mean that I will hereon start developing every web application in C++, that would just be dumb (if you are asking why, then that’s because you haven’t given CakePHP a try). It does mean, however, that I’ll be posting about CLAPP every now and then.

To calm your expectations, here’s a very, VERY small preview of the Dispatcher, which is directly attached to every controller:

#ifndef __CLAPP_DISPATCHER_HPP
#define __CLAPP_DISPATCHER_HPP

#include <clapp/cgi_stream.h>
#include <clapp/controller.h>

namespace clapp {
	template <class C>
	class Dispatcher {
		public:
			Dispatcher();
			~Dispatcher();
			void dispatch();

		private:
#ifdef CLAPP_WITH_FASTCGI
			CgiStreamFastCgi * cgiStream;
#else
			CgiStream * cgiStream;
#endif

			void execute();
	};
}

template <class C>
clapp::Dispatcher<C>::Dispatcher() {
#ifdef CLAPP_WITH_FASTCGI
	this->cgiStream = new CgiStreamFastCgi();
#else
	this->cgiStream = new CgiStream();
#endif
}

template <class C>
clapp::Dispatcher<C>::~Dispatcher() {
	delete this->cgiStream;
}

template <class C>
void clapp::Dispatcher<C>::dispatch() {
#ifdef CLAPP_WITH_FASTCGI
	FCGX_Request request;

	FCGX_Init();
	FCGX_InitRequest(&request, 0, 0);

	while (FCGX_Accept_r(&request) == 0) {
		this->cgiStream->setRequest(request);
		this->execute();
		FCGX_Finish_r(&request);
	}
#else
	this->execute();
#endif
}

template <class C>
void clapp::Dispatcher<C>::execute() {
	C *controller = NULL;

	try {
		controller = new C();

		controller->setStream(this->cgiStream);
		controller->dispatch();

		delete controller;
	} catch(...) {
		if (controller != NULL) {
			delete controller;
		}
		throw;
	}
}

#endif

As you can guess from the source code, CLAPP can produce FastCGIs and regular CGIs. It uses ClearSilver for its view / layout templates, the FastCGI development kit (when FastCGI mode is enabled), and GNU cgicc as a CGI / FastCGI input wrapper. More news coming soon!

No related posts.

An interesting meme, I was tagged by Jeff Loiselle

1. I once worked a full day serving beverages and hamburguers to a lot of people who were attending the agricultural exposition at La Rural. The issue was that out of every burger / soda we served, me and my friends would get one for ourselves. Not too productive.
2. I can’t sleep without a fan. I’m not kidding. Even if it’s freezing, I would turn on the heat and still power on the fan. Just two days ago (I’m currently on vacations at a beach location south of BA), I had to buy a fan since the house I rent doesn’t have one.
3. I spent almost two years helping out local Rock / Reggae bands, including Todos Tus Muertos & Actitud Maria Marta. I started there because I faxed the manager of AMM telling him if he wanted to build a website. I think this was 1996 or something. Needless to say it was an interesting experience.
4. I don’t know how to drive, nor I can’t because of an eye condition. In reality, they would give me the license if I wanted to, but I firmly believe I would be a danger to other drivers (even in Argentina, where drivers suck big time.)
5. I absolutely hate politicians. With strong passion. I mean, seriously, if you are a politician, get the hell out of my way. I would tap dance on your ass if you don’t.
6. When I was on my last year of high school, I stopped going to class and instead would spend my time at the school bar. I ended up not going for over 7 months to class, so obviously I had to take a test in March for every subject (I think we had over 20), otherwise I wouldn’t graduate. Since I didn’t tell my parents what I did, they only thought I had to take just one test, for one class. I had to take them all *while* I was taking the exams to enter University. Somehow it all worked out, and I managed to pass those over 20 exams for high school and 4 university subjects in less than a month. Crazy.
7. I absolutely love the new Guns N’ Roses album, Chinese Democracy. I haven’t bought a music CD since 1993, but I decided to buy this one. Totally worth it. If you don’t think so, you are clueless about rock.

Tagees:

• Clauz: the coolest person to have near you
• Tim Koschützki: someone who needs help figuring out how to play soccer and not cut his leg in the process
• Chris Hartjes: one of the coolest canucks I’ve ever met. He gets grumpy though.
• Martín Bavio: a fellow baker from argentina, who knows a thing or two about design
• Mark Story: the other awesome canuck, this one is almost the opposite of the grumpy one: he’s strong with the force, since he never seems to loose his coolness
• Lorena Iglesias: my fellow sister, a prolific writer (if you don’t know spanish, she’s worth the trouble to learn it)
• Dennis Hennen: someone who I’ve been working with for a long time now, so I happen to know him quite well

Here are the MEME rules:

• Link your original tagger(s), and list these rules on your blog.
• Share seven facts about yourself in the post — some random, some weird.
• Tag seven people at the end of your post by leaving their names and the links to their blogs.
• Let them know they’ve been tagged by leaving a comment on their blogs and/or Twitter.

Related posts:

1. Argentina on the Basketball World Championship
2. Argentina: 3.71 % of its population affected by traffic accidents every 10 years

Picking up the meme from jono and matthew, here’s my meme:

“a state of emergency became the rule” – The Dachau Concentration Camp, 1933 to 1945

1. Grab the nearest book.
2. Open it to page 56.
3. Find the fifth sentence.
4. Post the text of the sentence in your journal along with these instructions.
5. Don’t dig for your favorite book, the cool book, or the intellectual one: pick the CLOSEST.

Related posts:

1. Seven Things You Don’t Know About Me (MEME)

Wanna test your box performance, both its hard disk and memory? Try setting up a +370 table database, and then build a huge MySQL update file. Run it and get something like this:

Related posts:

1. Apache2 + PHP5 + MySQL + xDebug + SSL + SVN + Python + Trac on Ubuntu Hardy (8.04) 64 bits
2. Let your MySQL partition breathe

ps -C "firefox" -o pid=,vsz=,rss= | awk '{ printf "PID: %d, Virtual: %-.2f MB, Resources: %-.2f MB\n", $1, $2 / 1024, $3 / 1024 }'

And I got:

PID: 6223, Virtual: 778.06 MB, Resources: 403.70 MB

And I had just a couple of tabs open. So I said, ok, let’s start fresh. Here’s the same command with a firefox with just an about:blank, having just started up:

PID: 9139, Virtual: 462.02 MB, Resources: 56.34 MB

Nice to see resources drop, but Virtual is still at over 450 MB. Why oh why are you so hungry, dear firefox?

Related posts:

1. Well… Firefox behaves strangely somehow

history | awk '{a[$2]++ } END{for(i in a){print a[i] " " i}}' | sort -rn | head

Brings the following list of top 10 commands:

66 ls
40 sudo
37 cd
36 httperf
36 exit
31 svn
18 mysql
17 ssh
17 chmod
15 ./amreg-vpn.sh

Only custom script there is amreg-vpn.sh, which looks like the following:

if [ "$1" == "" ]
then
	echo "Usage: $0 <start | stop>"
else
	case $1 in
	start)
		echo "Starting VPN..."
		sudo vpnc /etc/vpnc/amreg.conf --natt-mode natt --dpd-idle 0
	;;
	stop)
		echo "Stopping VPN..."
		sudo vpnc-disconnect
	;;
	*)
		echo "Usage: $0 <start | stop>"
	;;
	esac
fi

Related posts:

1. Simple backup script for Ubuntu