Security
So to make good on my promise, let’s get our MongoDB a little be more secure than what it is today. (*Note: At the time of this writting, MongoDB only supports a simplistic security method, username and password. No encryption, no login server integration, ect.)

First open up your shell/command line and bring up the MongoDB Client. In *NIX, execute “./mongo” or Windows, “mongo”. Of course you might need to navigate to the location where MongoDB was install and execute it from the “bin” path. In my setup I have to execute it from “C:wampbinmongomongodb-win32-x86_64-1.4.1bin”.

Now that you have the client up enter in the following commands:

[bash]
use admin
db.addUser(“admin”, “admin_password”)
db.auth(“admin”, “admin_password”)
[/bash]

What we have done here is created a DB named “admin”, added a user to that DB named “admin” with the password of “admin_password” (I wouldn’t use “admin_password” for my admin password if I were you), then we authenticated our newly created user. If you don’t authenticate after adding the user, you won’t be able to perform any actions. OK, now that we have that taken care of, let get on with “relations”.

Having relations

In MySQL, you might have laid out some tables using foreign keys to create 1:1, 1:N> and N:N relationships between them. So lets take simple 1:1 relationship table layout from MySQL, say “user” and “user_profile”, which the “user_profile” table will have primary key of “user_id”, which will be used also as a foreign key to create the relationship.

MySQL

[php]
<?php
// Connect to MySQL
$host = ‘localhost’;
$user = ‘root’;
$pass = “”;
$db = ‘testdb’;
$link = mysql_connect($host, $user, $pass, 1) or die(“Could not connect to: {$host}. Check your settings and try again.”);

// Drop DB if exsists first
$sql = sprintf(‘SET FOREIGN_KEY_CHECKS = 0;’);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

$sql = sprintf(‘DROP DATABASE IF EXISTS `’.$db.’`;’);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Create the DB
$sql = sprintf(‘CREATE DATABASE `’.$db.’`;’);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Select the DB
mysql_select_db($db, $link);

// Create the “user” table
$sql = sprintf(‘CREATE TABLE `user`’.”n”.
‘ (`user_id` INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,’.”n”.
‘ `username` VARCHAR (24)NOT NULL,’.”n”.
‘ `password` CHAR(32) NOT NULL,’.”n”.
‘ `email` VARCHAR(255)’.”n”.
‘ ) TYPE=innodb;’);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Create the “user_profile” table
$sql = sprintf(‘CREATE TABLE `user_profile`’.”n”.
‘ (`user_id` INT UNSIGNED NOT NULL PRIMARY KEY,’.”n”.
‘ `aim` VARCHAR(24),’.”n”.
‘ `yahoo` VARCHAR(24),’.”n”.
‘ `icq` INT UNSIGNED,’.”n”.
‘ `likes` TEXT,’.”n”.
‘ `dislikes` TEXT’.”n”.
‘ ) TYPE=innodb;’);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Create the Foreign Key
$sql = sprintf(‘ALTER TABLE `user_profile`’.”n”.
‘ADD CONSTRAINT `FK_user_profile_user_user_id`’.”n”.
‘FOREIGN KEY (`user_id`)’.”n”.
‘REFERENCES `user` (`user_id`);’);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);
[/php]

So now we have created a relationship between two tables in MySQL, lets insert a user.
MySQL

[php]
// Insert a user
$user = ‘jsmith’;
$pass = ’5f4dcc3b5aa765d61d8327deb882cf99′;
$eml = ‘jsmith@example.com’;

$sql = sprintf(‘INSERT INTO `user`’.”n”.
‘SET `username` = ‘%s’,’.”n”.
‘ `password` = ‘%s’,’.”n”.
‘ `email` = ‘%s’;',
mysql_real_escape_string($user),
mysql_real_escape_string($pass),
mysql_real_escape_string($eml));

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Get the ID of last insert
$id = mysql_insert_id($link);
[/php]

Now that we have a user, let’s insert the user’s profile data.
MySQL

[php]
// Add a profile for the last inserted user
$aim = ‘MrGoodGuy’;
$like = ‘Ice cream, Pizza and puppies’;
$dis = ‘Oil spills’;
$sql = sprintf(‘INSERT INTO `user_profile`’.”n”.
‘SET `user_id` = %u,’.”n”.
‘ `aim` = ‘%s’,’.”n”.
‘ `likes` = ‘%s’,’.”n”.
‘ `dislikes` = ‘%s’;',
$id,
mysql_real_escape_string($aim),
mysql_real_escape_string($like),
mysql_real_escape_string($dis));

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);
[/php]

Now that we have some data in the profile table that relates to the first entry of the user, lets query both tables with an “INNER JOIN”.
MySQL

[php]
// Query both the “user” and “user_profile” tables with an “INNER JOIN”
$sql = sprintf(‘SELECT *’.”n”.
‘FROM `user` `u`’.”n”.
‘ INNER JOIN `user_profile` `p`’.”n”.
‘ ON `p`.`user_id` = `u`.`user_id`;’);

$qry = mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);
$cnt = mysql_num_rows($qry);

echo ‘All rows:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’;
}while(–$cnt > 0);
}
[/php]

Enough of the MySQL example, we will be using document embedding to do the same thing in MongoDB.
MongoDB

[php]
<?php
// Connect to MongoDB
$user = ‘admin’;
$pass = ‘admin_password’;

try
{
$link = new Mongo();
$db = $link->admin;

$db->authenticate($user, $pass);
}
catch(MongoConnectionException $e)
{
die(‘Could not connect. Check to make sure MongoDB is running.’);
}

// Create and use the DB
$db = $link->testdb;

// Drop DB if exsists first
$db->drop();

// Create and use the DB
$db = $link->testdb;

// Create the “user” colection
$col = $db->user;

// Insert a new document
$doc = array(‘username’ => ‘jsmith’, ‘password’ => ‘ 5f4dcc3b5aa765d61d8327deb882cf99′, ‘email’ => ‘jsmith@example.com’,
‘profile’ => array(‘aim’ => ‘MrGoodGuy’, ‘likes’ => ‘Ice cream, Pizza and puppies’, ‘dislikes’ => ‘Oil spills’));

$col->insert($doc, true);

// Get the ID of last insert
$id = $doc['_id'];

// Get all documents
$res = $col->find();

echo ‘All documents:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}
[/php]

“Wow, pretty simple!” is what I’m thinking you are saying to your self. With MongoDB, instead of having to create two tables, the FK, insert a record, get the id, and do another insert. We create the collection and just insert our data with a multidimensional associative array.

1:1 relationships are easy, but what about 1:N relationships? Let get back into MySQL mode.
MySQL

[php]
// Delete the “likes” and “dislikes” columns
$sql = sprintf(‘ALTER TABLE `user_profile`’.”n”.
‘DROP COLUMN `dislikes`,’.”n”.
‘DROP COLUMN `likes`;’);

$qry = mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Create the “user_likes” table
$sql = sprintf(‘CREATE TABLE `user_likes`’.”n”.
‘ (`user_likes_id` INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,’.”n”.
‘ `user_id` INT UNSIGNED NOT NULL,’.”n”.
‘ `likes` VARCHAR(255) NOT NULL’.”n”.
‘ ) TYPE=innodb;’);

$qry = mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Create the Foreign Key
$sql = sprintf(‘ALTER TABLE `user_likes`’.”n”.
‘ADD CONSTRAINT `FK_user_likes_user_user_id`’.”n”.
‘FOREIGN KEY (`user_id`)’.”n”.
‘REFERENCES `user` (`user_id`);’);

// Create the “user_dislikes” table
$sql = sprintf(‘CREATE TABLE `user_dislikes`’.”n”.
‘ (`user_dislikes_id` INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,’.”n”.
‘ `user_id` INT UNSIGNED NOT NULL,’.”n”.
‘ `dislikes` VARCHAR(255) NOT NULL’.”n”.
‘ ) TYPE=innodb;’);

$qry = mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Create the Foreign Key
$sql = sprintf(‘ALTER TABLE `user_dislikes`’.”n”.
‘ADD CONSTRAINT `FK_user_likes_user_user_id`’.”n”.
‘FOREIGN KEY (`user_id`)’.”n”.
‘REFERENCES `user` (`user_id`);’);

$qry = mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Insert some “likes” and “dislikes”
$like = array(‘Ice cream’, ‘Pizza’, ‘Puppies’);

foreach($like as $val)
{
$sql = sprintf(‘INSERT INTO `user_likes`’.”n”.
‘SET `user_id` = %u,’.”n”.
‘ `likes` = ‘%s’;',
$id,
mysql_real_escape_string($val));

$qry = mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);
}

$dis = array(‘Oil spills’);

foreach($dis as $val)
{
$sql = sprintf(‘INSERT INTO `user_dislikes`’.”n”.
‘SET `user_id` = %u,’.”n”.
‘ `dislikes` = ‘%s’;',
$id,
mysql_real_escape_string($val));

$qry = mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);
}

// Query the “user” table and pull in the “likes” and “dislikes” data.
$sql = sprintf(‘SELECT `u`.*,’.”n”.
‘ GROUP_CONCAT(DISTINCT `l`.`likes` SEPARATOR ‘, ‘) AS `likes`,’.”n”.
‘ GROUP_CONCAT(DISTINCT `d`.`dislikes` SEPARATOR ‘, ‘) AS `dislikes`’.”n”.
‘FROM `user` `u`’.”n”.
‘ INNER JOIN `user_likes` `l`’.”n”.
‘ ON `l`.`user_id` = `u`.`user_id`’.”n”.
‘ INNER JOIN `user_dislikes` `d`’.”n”.
‘ ON `d`.`user_id` = `u`.`user_id`’.”n”.
‘WHERE `u`.`user_id` = %u;’,
$id);

$qry = mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);
$cnt = mysql_num_rows($qry);

echo ‘All rows:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’;
}while(–$cnt > 0);
}
[/php]

Boy is that a lot of work and I cheated with “group_concat” function. Let do this with MongoDB.
MongoDB

[php]
// Create a “1:N” for “likes” and “dislikes” in the “profile” element
$col->update(array(‘_id’ => $id), array(‘$set’ => array(‘profiles’ => array(‘likes’ => array(‘Ice cream’, ‘Pizza’, ‘Puppies’),
‘dislikes’ => array(‘Oil spills’)))));

echo ‘All documents:<br/>’;

// Get all documents
$res = $col->find();

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}
[/php]

Since MongoDB is schema-less, we can update how we store the “likes” and “dislikes” and it comes back to us as an array that we could iterate through. So what’s next?

N:N relationships. Oh boy are those the ultimate in a relational model. Once again, I’ll how we do this in MySQL.
MySQL

[php]
// Drop “user_likes” table if exsists first
$sql = sprintf(‘SET FOREIGN_KEY_CHECKS = 0;’);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

$sql = sprintf(‘DROP TABLE IF EXISTS `user_likes`;’);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Drop “dislikes” table if exsists first
$sql = sprintf(‘SET FOREIGN_KEY_CHECKS = 0;’);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

$sql = sprintf(‘DROP TABLE IF EXISTS `user_dislikes`;’);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Create the “likes” table
$sql = sprintf(‘CREATE TABLE `likes`’.”n”.
‘ (`likes_id` INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,’.”n”.
‘ `likes` VARCHAR (255) NOT NULL’.”n”.
‘ ) TYPE=innodb;’);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Create the “like” joins table
$sql = sprintf(‘CREATE TABLE `user_likes`’.”n”.
‘ (`user_id` INT UNSIGNED NOT NULL,’.”n”.
‘ `likes_id` INT UNSIGNED NOT NULL,’.”n”.
‘ PRIMARY KEY (`user_id`, `likes_id`)’.”n”.
‘ ) TYPE=innodb;’);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Create Foriegn Keys
$sql = sprintf(‘ALTER TABLE `user_likes`’.”n”.
‘ADD CONSTRAINT `FK_user_likes_user_user_id`’.”n”.
‘FOREIGN KEY (`user_id`) REFERENCES `user` (`user_id`),’.”n”.
‘ADD CONSTRAINT `FK_user_likes_likes_likes_id`’.”n”.
‘FOREIGN KEY (`likes_id`) REFERENCES `likes` (`likes_id`);’);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Insert some “likes”
$sql = sprintf(‘INSERT INTO `likes`’.”n”.
‘SET `likes` = ‘%s’;',
mysql_real_escape_string(‘Ice Cream’));

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

$sql = sprintf(‘INSERT INTO `%s`’.”n”.
‘SET `likes` = ‘%s’;',
mysql_real_escape_string(‘likes’),
mysql_real_escape_string(‘Pizza’)
);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

$sql = sprintf(‘INSERT INTO `%s`’.”n”.
‘SET `likes` = ‘%s’;',
mysql_real_escape_string(‘likes’),
mysql_real_escape_string(‘Puppies’)
);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

$sql = sprintf(‘INSERT INTO `likes`’.”n”.
‘SET `likes` = ‘%s’;',
mysql_real_escape_string(‘Kittens’));

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Create some “likes” relations (Cheating – since I already know the id’s)
$sql = sprintf(‘INSERT INTO `user_likes`’.”n”.
‘SET `user_id` = %u,’.”n”.
‘ `likes_id` = %u;’,
1,
1);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

$sql = sprintf(‘INSERT INTO `user_likes`’.”n”.
‘SET `user_id` = %u,’.”n”.
‘ `likes_id` = %u;’,
1,
2);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

$sql = sprintf(‘INSERT INTO `user_likes`’.”n”.
‘SET `user_id` = %u,’.”n”.
‘ `likes_id` = %u;’,
1,
3);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Create the “dislikes” table
$sql = sprintf(‘CREATE TABLE `dislikes`’.”n”.
‘ (`dislikes_id` INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,’.”n”.
‘ `dislikes` VARCHAR (255) NOT NULL’.”n”.
‘ ) TYPE=innodb;’);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Create the “dislike” joins table
$sql = sprintf(‘CREATE TABLE `user_dislikes`’.”n”.
‘ (`user_id` INT UNSIGNED NOT NULL,’.”n”.
‘ `dislikes_id` INT UNSIGNED NOT NULL,’.”n”.
‘ PRIMARY KEY (`user_id`, `dislikes_id`)’.”n”.
‘ ) TYPE=innodb;’);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Create Foriegn Keys
$sql = sprintf(‘ALTER TABLE `user_dislikes`’.”n”.
‘ADD CONSTRAINT `FK_user_dislikes_user_user_id`’.”n”.
‘FOREIGN KEY (`user_id`) REFERENCES `user` (`user_id`),’.”n”.
‘ADD CONSTRAINT `FK_user_dislikes_likes_likes_id`’.”n”.
‘FOREIGN KEY (`dislikes_id`) REFERENCES `dislikes` (`dislikes_id`);’);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Insert some “dislikes”
$sql = sprintf(‘INSERT INTO `dislikes`’.”n”.
‘SET `dislikes` = ‘%s’;',
mysql_real_escape_string(‘Oil Spills’));

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

$sql = sprintf(‘INSERT INTO `dislikes`’.”n”.
‘SET `dislikes` = ‘%s’;',
mysql_real_escape_string(‘Screaming Babies’));

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Create some “dislikes” relations
$sql = sprintf(‘INSERT INTO `user_dislikes`’.”n”.
‘SET `user_id` = %u,’.”n”.
‘ `dislikes_id` = %u;’,
1,
1);

mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);

// Query “USER” and join with “likes” and “dislikes”
$sql = sprintf(‘SELECT `u`.*,’.”n”.
‘ GROUP_CONCAT(DISTINCT `l`.`likes` SEPARATOR ‘, ‘) AS `likes`,’.”n”.
‘ GROUP_CONCAT(DISTINCT `d`.`dislikes` SEPARATOR ‘, ‘) AS `dislikes`’.”n”.
‘FROM `user` `u`’.”n”.
‘ INNER JOIN `user_likes` `ul`’.”n”.
‘ ON `ul`.`user_id` = `u`.`user_id`’.”n”.
‘ INNER JOIN `likes` `l`’.”n”.
‘ ON `l`.`likes_id` = `ul`.`likes_id`’.”n”.
‘ INNER JOIN `user_dislikes` `ud`’.”n”.
‘ ON `ud`.`user_id` = `u`.`user_id`’.”n”.
‘ INNER JOIN `dislikes` `d`’.”n”.
‘ ON `d`.`dislikes_id` = `ud`.`dislikes_id`’.”n”.
‘WHERE `u`.`user_id` = 1;’);

$qry = mysql_query($sql, $link) or die(“<pre>SQL:n{$sql}nERROR:n”.mysql_error($link).’</pre>’);
$cnt = mysql_num_rows($qry);

echo ‘All rows:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’;
}while(–$cnt > 0);
}
[/php]

Wow! Again, MySQL is making us work some more. With MongoDB we have three approaches. The first way is to fake it with a 1:1 or 1:N with an extra collection with the values you want to validate against. This might seem odd if you want to do a N:N relation, but there is reason why would want to do this in MongoDB . The second way is to create “manual relations”. This is kind of like MyISAM, where there isn’t an automatic relation, you have to specify it in your query. So lets look that one over.

MongoDB
[php]
// Create the “likes” and “dislikes” collections (create, drop and recreate).
$likes = $db->likes;
$likes->drop();
$likes = $db->likes;

$dis = $db->dislikes;
$dis->drop();
$dis = $db->dislikes;

// Insert some “likes” and “dislikes”
// “Likes”
$doc = array(‘likes’ => ‘Ice cream’);
$likes->insert($doc, true);

$doc = array(‘likes’ => ‘Pizza’);
$likes->insert($doc, true);

$doc = array(‘likes’ => ‘Puppies’);
$likes->insert($doc, true);

$doc = array(‘likes’ => ‘Kittens’);
$likes->insert($doc, true);

$ls = $likes->find();

// “Dislikes”
$doc = array(‘dislikes’ => ‘Oil spills’);
$dis->insert($doc, true);

$doc = array(‘dislikes’ => ‘Screeming children’);
$dis->insert($doc, true);

// Create a “N:N” for “likes” and “dislikes” in the “profile” element
// Find our “likes”
$ic = $likes->findOne(array(‘likes’ => ‘Ice cream’));
$pz = $likes->findOne(array(‘likes’ => ‘Pizza’));
$ps = $likes->findOne(array(‘likes’ => ‘Puppies’));

// Find our “dislikes”
// Find our “likes”
$os = $dis->findOne(array(‘dislikes’ => ‘Oil spills’));

// Create manual reference
$col->update(array(‘_id’ => $id), array(‘$set’ => array(‘profile’ => array(‘likes’ => array($ic['_id'], $pz['_id'], $ps['_id']),
‘dislikes’ => array($os['_id'])))));

// Get all documents
$res = $col->find();

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);

echo “nLikes:n”;

foreach($doc['profile']['likes'] as $key=>$val)
{
$l = $likes->findOne(array(‘_id’ => $val));
echo $l['likes'].”n”;
}

echo “nDislikes:n”;

foreach($doc['profile']['dislikes'] as $key=>$val)
{
$d = $dis->findOne(array(‘_id’ => $val));
echo $d['dislikes'].”n”;
}

echo ‘</pre>’;
}
[/php]

The thirday way is to create a reference (DBRef) to another document.
MongoDB

[php]
// Create an automatic reference
$col->update(array(‘_id’ => $id), array(‘$set’ => array(‘profile’ => array(‘likes’ => array(array(‘$ref’ => ‘likes’, ‘$id’ => $ic['_id']),
array(‘$ref’ => ‘likes’, ‘$id’ => $pz['_id']),
array(‘$ref’ => ‘likes’, ‘$id’ => $ps['_id'])
),
‘dislikes’ => array(array(‘$ref’ => ‘dislikes’, ‘$id’ => $os['_id']))))));

// Get all documents
$res = $col->find();

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);

echo “nLikes:n”;

foreach($doc['profile']['likes'] as $key=>$val)
{
$l = $likes->findOne(array(‘_id’ => $val['$id']));
echo $l['likes'].”n”;
}

echo “nDislikes:n”;

foreach($doc['profile']['dislikes'] as $key=>$val)
{
$d = $dis->findOne(array(‘_id’ => $val['$id']));
echo $d['dislikes'].”n”;
}

echo ‘</pre>’;
}
[/php]

So we’ve created an element that references a document. The key was to query what we needed, then used “$ref” identifier (More information) along with the ID return from our query to create the element. There is another way to do this in PHP by using the “MongoCollection::createDBRef” method.
MongoDB

[php]
$col->update(array(‘_id’ => $id), array(‘$set’ => array(‘profile’ => array(‘likes’ => array($likes->createDBRef($likes->findOne(array(‘likes’ => ‘Ice cream’))),
$likes->createDBRef($likes->findOne(array(‘likes’ => ‘Pizza’))),
$likes->createDBRef($likes->findOne(array(‘likes’ => ‘Puppies’)))
),
‘dislikes’ => array($dis->createDBRef($dis->findOne(array(‘dislikes’ => ‘Oil spills’))))));
[/php]

And we can also clean up our loop with less code:
MongoDB

[php]
foreach($doc['profile']['dislikes'] as $key=>$val)
{
$d = $col->getDBRef($val);
echo $d['dislikes'].”n”;
}
[/php]

Of course there is one problem with doing N:N in MongoDB . You can’t query it with a single query, since there is no “JOIN” support. So it would be better to embed the data you need to search on and return. Sure it might be redundant, but it seems that would be the best solution at this time. For more information about when to use DBRef vs Embedding, check out the Schema Design article.

Before we end this tutorial, let me leave you with a little extra, adding to the “likes” and “dislikes” in the “profile”:
MongoDB

[php]
// Add (Not replace) another “likes” and “Dislikes” to the profile.
$col->update(array(‘_id’ => $id), array(‘$pushAll’ => array(‘profile.likes’ => array($likes->createDBRef($likes->findOne(array(‘likes’ => ‘Kittens’)))),
‘profile.dislikes’ => array($dis->createDBRef($dis->findOne(array(‘dislikes’ => ‘Screeming children’)))))), array(‘safe’ => 1));

// Get all documents
$res = $col->find();

foreach($res as $doc)
{
echo “<pre>Pushed:n”;
print_r($doc);

echo “nLikes:n”;

foreach($doc['profile']['likes'] as $key=>$val)
{
$l = $col->getDBRef($val);
echo $l['likes'].”n”;
}

echo “nDislikes:n”;

foreach($doc['profile']['dislikes'] as $key=>$val)
{
$d = $col->getDBRef($val);
echo $d['dislikes'].”n”;
}

echo ‘</pre>’;
}
[/php]

You’ll notice that use used the “keyword” of “$pushAll” to push our array into the “likes” and “dislikes” element. Also note that we also used dot notation (“profile.likes”) to indicated that “likes” and “dislikes” are element of “profile”. So if we had something like “animal” which was an array element of “likes” which is part of “profile”, we would have done “profile.likes.animal”.

Until next time, when we will go over … I’m not sure yet, It’ll be a surprise … Happy Coding!

If you want a VPS with that has a “one-click” install of MongoDB, check out DreamHost. Also don’t forget to check out our tech blog and Computer related coupons.

Part 1

The first thing we need to do is create a folder named “vendors” under “application”. In the “vendors” folder, create another folder named “Zend” (yes, with a capital “Z”). Next we’ll need to download the latest version of Zend Framework, so click here to download 1.10.5. Open the archive up and extract everything from “ZendFramework-1.10.5-minimal/library/Zend/” into “application/vendors/Zend”.

Open the “application/bootstrap.php” file and add the following above the line which reads “echo Request::getInstance()”:

[php]
$path = Kohana::find_file(‘vendors’, ‘Zend/Loader’);

if($path)
{
ini_set(‘include_path’,
ini_get(‘include_path’) . PATH_SEPARATOR . dirname(dirname($path)));

require_once ‘Zend/Loader/Autoloader.php’;
Zend_Loader_Autoloader::getInstance();
}
[/php]

Open “application/views/pages/ko3.php” and put the following at the bottom:

[php]
<?php $validator = new Zend_Validate_Isbn();?>
<br />978-3-16-148410-0 <?php echo ($validator->isValid(’978-3-16-148410-0′)) ? ‘is’ : ‘is not’;?> valid.
<br />9783161484100 <?php echo ($validator->isValid(’9783161484100′)) ? ‘is’ : ‘is not’;?> valid.
[/php]

Now if you load “http://yourserver/mykohana3/ko3″ in your browser, you should see the two tests at the bottom.

Until next time, when I go over forms, happy coding.

If you enjoyed this tutorial, please check out our tech blog and computer related coupons.

Part 8

Here’s a couple links to get you up to speed:
Installing Mongo
MongoDB PHP Extension

If you have issues with MongoD not starting – something about “/data/db” missing, then you should create the directory. In *Nix: “mkdir /data/db”, in Win “mkdir c:data” then “mkdir c:datadb”.

Connecting
MySQL

[php]
<?php
$host = ‘localhost’;
$user = ‘root’;
$pass = “”;
$link = mysql_connect($host, $user, $pass, 1) or die(“Could not connect to: {$host}. Check your settings and try again.”);
[/php]

MongoDB

[php]
<?php
try
{
$link = new Mongo();
}
catch(MongoConnectionException $e)
{
die(‘Could not connect. Check to make sure MongoDB is running.’);
}
[/php]

As you can see, Mongo DB automatically will connect to the local host and default port. Yes, MySQL will do the same if you have the directives in your “php.ini” setup to do this. IE. “mysql.default_host”, “mysql.default_user” and “mysql.default_password”. You might notice that by default MongoDB doesn’t have a user name or password setup. I will go over how to set that up in part 2.

Creating and using a DB
MySQL

[php]$db = ‘testdb’;
$sql = “CREATE DATABASE `$db`”;

mysql_query($sql, $link);
mysql_select_db($db, $link);
[/php]

MongoDB

[php]$db = $link->testdb;
[/php]

In one line of code, MongoDB will create a DB automatically if it doesn’t already exists and select (use) it.

Create a Table / Collection
MySQL

[php]
// Create the Table
$tbl = ‘user’;
$sql = “CREATE TABLE `$tbl` (`id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY, `login` VARCHAR (24)NOT NULL, `password` CHAR(32) NOT NULL, `email` VARCHAR(255)) TYPE=innodb;”;
mysql_query($sql, $link);
[/php]

MongoDB

[php]
// Create the collection (AKA Table)
$col = $db->user;
[/php]

Once again, MongoDB will automatically create something for us if it doesn’t exist. In this example, it create our “user” table. You might notice we didn’t define how the table is formatted, this is because MongoDB is schema-less and doesn’t need column definitions. “Tables” in MongoDB are called “collections”.

Insert Data
MySQL

[php]
// Insert a row into the table
$sql = “INSERT INTO `$tbl` SET `login` = ‘jsmith’, `password` = ’5f4dcc3b5aa765d61d8327deb882cf99′, `email` = ‘jsmith@example.com’”;
mysql_query($sql);

$sql = “INSERT INTO `$tbl` SET `login` = ‘psmith’, `password` = ’5f4dcc3b5aa765d61d8327deb882cf99′, `email` = ‘psmith@example.com’”;
mysql_query($sql);

// Get the ID of last insert
$id = mysql_insert_id($link);
[/php]

MongoDB

[php]
// Insert a document (row) into the collection (table)
$doc = array(‘login’ => ‘jsmith’, ‘password’ => ‘ 5f4dcc3b5aa765d61d8327deb882cf99′, ‘email’ => ‘jsmith@example.com’);
$col->insert($doc, true);

$doc = array(‘login’ => ‘psmith’, ‘password’ => ‘ 5f4dcc3b5aa765d61d8327deb882cf99′, ‘email’ => ‘psmith@example.com’);
$col->insert($doc, true);

// Get the id of last insert
$id = $doc['_id'];
[/php]

You might have noticed that we used an array to define our “row” of data, which are called “documents”. On the insert method, the second argument will set the query to do a “safe insert”. This will allow us to find out if the query executed properly. If not set, it will not get that information. So I would set it to true if you want to be able to debug your queries. If you are wondering about the password, it’s the MD5 hash for “password”.

Querying Data
MySQL

[php]
// Get all rows
$sql = “SELECT * FROM `$tbl`”;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All rows:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’
}
}

// Query for the row matching the last insert ID
$sql = “SELECT * FROM `$tbl` WHERE `id` = {$id}”;
$qry = mysql_query($sql, $link);
$row = mysql_fetch_assoc($qry);

echo ‘Single row (id = $id):&lt;br/&gt;&lt;pre&gt;’;
print_r($row);
echo ‘</pre>
[/php]

MongoDB

[php]
// Get all documents
$res = $col->find();

echo ‘All documents:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}

// Query for the document matching the last insert ID
$doc = $col->findone(array(‘_id’ => $id));

echo ‘Single document (_id = $id):<br/><pre>’;
print_r($doc);
[/php]

The MongoDB support in PHP has function to pull a single document, or all the documents. Once again, we use arrays to define something, in this example, we define our constraint.

Upading Data
MySQL

[php]
$sql = “UPDATE `$tbl` SET `password` = ‘b497dd1a701a33026f7211533620780d’ WHERE `id` = {$id}”;
$qry = mysql_query($sql, $link);

$sql = “SELECT * FROM `$tbl` WHERE `id` = {$id}”;
$qry = mysql_query($sql, $link);
$row = mysql_fetch_assoc($qry);

echo ‘Updated row (id = $id):<br/><pre>’;
print_r($row);
echo ‘</pre>
[/php]

MogoDB

[php]
// Update a document
$col->update(array(‘_id’ => $id), array(‘$set’ => array(‘password’ => ‘b497dd1a701a33026f7211533620780d’)));

// Query the updated docuemnt
$doc = $col->findone(array(‘_id’ => $id));

echo ‘Updated docuement:<br/><pre>’;
print_r($doc);
echo ‘</pre>’;
[/php]

The MongoDB extension has a function to perform updates. The first argument is an array of constraints, IE “WHERE {expression}”. The second is the data we want to update and what we want to update it with. Pretty simple, right?

Indexing data
MySQL

[php]
// Create a unique index
$sql = “ALTER TABLE `$db`.`$tbl` ADD UNIQUE `login` (`login`)”;
$qry = mysql_query($sql, $link);
[/php]

MongoDB

[php]
// Create a unique index
$col->ensureIndex(array(“login” => 1), array(“unique” => true, “dropDups” => true));
[/php]

MongoDB has method for creating index name “ensureIndex”. The first parameter is an array of what we want to index and the value is ether 1 or -1. 1 means that the index will sort the data for this in an ascending manor, while -1 will sort it in a descending manor. The second parameter are extra options. In this example I tell it to make what ever I’m indexing as a unique index, that way I don’t end up with multiple “jsmith” entries. Also, I’ve told it to drop any documents that have duplicates of the data in the “login” “column”. Another note is that “columns” in MongoDB should be called “elements”, since we are really dealing with arrays.

Lets make sure our index is working shall we?
MongoDb

[php]
// Test our unique index
try
{
$doc = array(‘login’ => ‘jsmith’, ‘password’ => ‘ 5f4dcc3b5aa765d61d8327deb882cf99′, ‘email’ => ‘jsmith@example.com’);
$col->insert($doc, true);
}
catch(MongoCursorException $e)
{
echo ‘Could not insert document. Double check values.<br />’;
}
[/php]

If all works, we should get an error message.

Limiting Results
MySQL

[php]
// Limits
$sql = “SELECT * FROM `$tbl` LIMIT 1″;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All rows – Limit by 1:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’
}
}
[/php]

MongoDB

[php]
// Limits
$res = $col->find()->limit(1);

echo ‘All documents – Limited to 1:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}
[/php]

Offsetting
MySQL

[php]
// Limits
$sql = “SELECT * FROM `$tbl` OFFSET 1 LIMIT 1″;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All rows – Limit by 1 – Offset by 1:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’;
}
}
[/php]

MongoDB

[php]
// Offsets
$res = $col-&gt;find()-&gt;skip(1)-&gt;limit(1);

echo ‘All documents – Limited to 1, Offset by 1:<br/ >’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}
</pre>
[/php]

To offset a your query start point, we used the method “skip” with an integer value to create the offset.

Sorting
MySQL

[php]
// Sorting
$sql = “SELECT * FROM `$tbl` ORDERBY `login` DESC”;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All rows – Sorted by login descending:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’
}while(–$cnt > 0);
}
[/php]

MongoDB

[php]
// Sorting
$res = $col->find()->sort(array(‘login’ => -1));

echo ‘All documents – Sorted by login descending:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}
[/php]

Here we used the sort method, told it what element to sort on and which direction, -1 being descending. The record for “psmith” should show up first. A word of caution here, there is a 4MB limit if sorting on non-indexed element.

Advanced Queries
MySQL

[php]
// Advanced queries
// Add new column
$sql = “ALTER `$db`.`$tbl` ADD COLUMN `age` INT UNSIGNED”;
mysql_query($sql, $link);

// Add values
$sql = “UPDATE `$tbl` SET `age` = 40 WHERE `login` = ‘jsmith’”;
mysql_query($sql, $link);

$sql = “UPDATE `$tbl` SET `age` = 24 WHERE `login` = ‘psmith’”;
mysql_query($sql, $link);

// Query for anyone under 30
$sql = “SELECT * FROM `$tbl` WHERE `age` < 30″;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All documents – Anyone under 30:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’;
}
}

// Query for anyone over 30
$sql = “SELECT * FROM `$tbl` WHERE `age` > 30″;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All documents – Anyone over 30:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’;
}
}

// Query from anyone 25 and over
$sql = “SELECT * FROM `$tbl` WHERE `age` >= 25″;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All documents – Anyone 25 and over:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’;
}
}
// Query for anyone 25 and under
$sql = “SELECT * FROM `$tbl` WHERE `age` <= 25″;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All documents – Anyone 25 and under:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’;
}
}

// Query for anyone not 40
$sql = “SELECT * FROM `$tbl` WHERE `age` != 40″;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All documents – Anyone not 30:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’;
}
}

// Query for anyone 20-50
$sql = “SELECT * FROM `$tbl` WHERE `age` >= 20 AND `age` <= 50″;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All documents – Anyone 20-50:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’;
}
}
[/php]

MongoDB

[php]
// Advanced queries
// Add a new element and value
$col->update(array(‘login’ => ‘jsmith’), array(‘$set’ => array(‘age’ => 40)));
$col->update(array(‘login’ => ‘psmith’), array(‘$set’ => array(‘age’ => 24)));

// Confirm
$res = $col->find();

echo ‘All documents – Confirming age element:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}

// Query for anyone under 30
$res = $col->find(array(‘age’ => array(‘$lt’ => 30)));

echo ‘All documents – Anyone under 30:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}

// Query for anyone over 30
$res = $col->find(array(‘age’ => array(‘$gt’ => 30)));

echo ‘All documents – Anyone over 30:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}

// Query from anyone 25 or over
$res = $col->find(array(‘age’ => array(‘$gte’ => 25)));

echo ‘All documents – Anyone 25 or older:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}

// Query for anyone 25 and under
$res = $col->find(array(‘age’ => array(‘$lte’ => 25)));

echo ‘All documents – Anyone 25 or younger:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}

// Query for anyone not 40
$res = $col->find(array(‘age’ => array(‘$ne’ => 40)));

echo ‘All documents – Anyone not 40:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}

// Query for anyone 20-50
$res = $col->find(array(‘age’ => array(‘$gte’ => 20, ‘$lte’ => 50)));

echo ‘All documents – Anyone 20-50:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}
[/php]

With MongoDB you can do “<,<=, >, >=” conditional operator based queries. Only thing is that you can’t just use “<,<=, >, >=” in your constraints, you have to use MongoDB’s version. Those are “$lt” (less than), “$lte” (less than or equal), “$gt” (greater than), “$gte” (greater than or equal). Yes, you need the dollar sign. Other conditional operators are “$ne” (not equal to), “$in” (like MySQL’s IN statement), “$nin” (NOT IN), “$mod” (Modulo operation), “$all” (like in, but all values much be matched to a document), “$size” (Match of number of elements), “$exists” (element exists), “$type” (matches element type – int, string, etc) and there are couple more.

Deleting a Row / Docuement
MySQL

[php]
// Delete a row
$sql = “DELETE FROM `$tbl` WHERE `login` = ‘psmith’”
mysql_query($sql, $link);
[/php]

MongoDB

[php]
// Delete a document
$col->remove(array(‘age’ => 24), array(‘justOne’ => true, ‘safe’ => true));

// Confirm delete
$res = $col->find();

echo ‘All documents:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}
[/php]

Here we use the “remove” method. First argument has the constraints and the second tell it to only remove one item and also to run a “safe” query.

Dropping a Table / Collection
MySQL

[php]
// Drop table
$sql = “DROP TABLE `$db`.`$tbl`”;
mysql_query($sql, $link);
[/php]

MongoDB

[php]
// Drop collection
$col->drop();
[/php]

Dropping a database
MySQL

[php]
// Drop DB
$sql = “DROP DATABASE `$db`”;
mysql_query($sql, $link);
[/php]

MongoDB

[php]
// Drop DB
$db->drop();
[/php]

Disconnect
MySQL

[php]
// Disconnect
mysql_close($link);
[/php]

MongoDB

[php]
// Disconnect
$link->close();
[/php]

Until next time, when I will go over more stuff, happy coding.

Sources:
PHP.net, MongoDB

Part 2

Before we get into views, we’ll want to update the KO3 code base. Go in to “application” directory and rename your “bootstrap.php” to “bootstrap.bak.php”. Now point your browser to http://kohanaframework.org/download (Yes there is a new site), download the latest stable (3.0.4.2), open it and extract everything inside the “kohana” folder to “mykohana3″. Once you have done that, delete or rename the “install.php” in your “mykohana3″ folder. Next, delete the “bootstrap.php” file in the “application” folder and rename the “bootstrap.bak.php” to “bootstrap.php”.

So what is a module? A module is pretty much just a plug in. It can extend the core, give you whole new section to your project (IE. blogs and forums), or just give you a set of classes that are available globally. So lets jump right in!

Add a new directory to the “modules” directory and name it “fortune”. In the “module/fortune” directory add the following directories “classes” and “views”. In “/module/fortune/classes” create a folder named “kohana”. In “/module/fortune/views” create a folder named “fortune”. So you should have a directory that looks something like this:
[php]
modules
+– fortune
|– classes
| +– kohana
+– views
+– fortune
[/php]
Create a new file in “/module/fortune/classes/” named “fortune.php” and put the following into it:
[php]
<?php
defined(‘SYSPATH’) or die(‘No direct script access.’);
class Fortune extends Kohana_Fortune{}
[/php]
This is pretty simple. Just extends another class. If you’ve gone through the code base for KO3, this will probably look familiar. Now lets create the main class file, so open a new file and put the following into it:
[php]
<?php
defined(‘SYSPATH’) or die(‘No direct script access.’);

/**
* Fortune Cookie Module
*/
class Kohana_Fortune
{
// Merged configuration settings
protected $config = array(‘view’ => ‘fortune/default’);
protected $fortune = "";

/**
* Creates a new Fortune object.
*
* @return Forune
*/
public static function factory(array $config = array())
{
return new Fortune($config);
}

public function __construct(array $config = array())
{
// Overwrite system defaults with application defaults
$this->config = $this->config_group() + $this->config;
}

/**
* Retrieves a fortune config group from the config file. One config group can
* refer to another as its parent, which will be recursively loaded.
*
* @param STRING fortune config group; "default" if none given
* @return ARRAY config settings
*/
public function config_group($group = ‘default’)
{
// Load the fortune config file
$config_file = Kohana::config(‘fortune’);

// Initialize the $config array
$config = array(‘group’ => (string)$group);

// Recursively load requested config groups
while(isset($config['group']) && isset($config_file->$config['group']))
{
// Temporarily store config group name
$group = $config['group'];
unset($config['group']);

// Add config group values, not overwriting existing keys
$config += $config_file->$group;
}

// Get rid of possible stray config group names
unset($config['group']);

// Return the merged config group settings
return $config;
}

/**
* Randomly pick a fortune
*
* @return STRING fortune text
*/
public function getFortune()
{
// Stolen from: http://fortunes.cat-v.org/plan_9/
$fortunes = array(’2 is always smaller than 3, even for large values of 2.’,
‘A penny saved is a political breakthrough.’,
‘Avoid reality at all costs.’,
‘Bad taste is timeless.’);

$this->fortune = $fortunes[array_rand($fortunes, 1)];
}

/**
* Renders the fortune.
*
* @param MIXED string of the view to use, or a Kohana_View object
* @return STRING fortune output (HTML)
*/
public function render($view = NULL)
{
if($view === NULL)
{
// Use the view from config
$view = $this->config['view'];
}

if(!$view instanceof Kohana_View)
{
// Load the view file
$view = View::factory($view);
}

$this->getFortune();

// Pass on the whole Fortune object
return $view->set(get_object_vars($this))->set(‘page’, $this)->render();
}

/**
* Renders the fortune.
*
* @return STRING fortune output (HTML)
*/
public function __toString()
{
return $this->render();
}
}
[/php]
Save this as “fortune.php” in “/modules/fortune/classes/kohana”. For the most part this looks like a simple Kohana core. We have 2 protected properties, config and fortune. The config property is for, well, a configuration. We only use the view configuration value here. The fortune property is hopefully the land that my house sits on… er… It is used to store a single fortune for our output.

Next we have our factory method so we can do the factory pattern. Then we have our constructor which pulls in a configuration from the config variable and recreates the config property with default configurations from a file, set array element and from what has been passed to it with the help of the next method called “config_group”.

The heart of this class is the getFortune method. I cheated here and used an array instead of creating a model and pulling stuff from the db. So I pull a random element and place it in our fortune property. Next up is the render method. This just runs the getFortune method and then renders the view. The last one, __toString calls the render method.

Create a new file and put the following into it:
[php]
<div style="width: 250px; height: 52px; vertical-align: middle; display: table-cell; text-align: center; border: 1px solid #CCCCCC; border-right-color: #666666; border-bottom-color: #666666;">
<p><?php echo $fortune;?></p>
</div>
[/php]
Save this as “default.php” under “/modules/fortune/views/fortune/default.php”. Pretty simple. You might notice that I’m echoing out $fortune, which happens to the protected property in our class. In the render method, we pass all the properties to the view. Makes things simple.

Next up is to edit a couple files. Open up the “/application/bootstrap.php” file and locate the section with “Kohana::modules” in it. Now replace that with:
[php]Kohana::modules(array(// ‘auth’ => MODPATH.’auth’, // Basic authentication
// ‘codebench’ => MODPATH.’codebench’, // Benchmarking tool
‘database’ => MODPATH.’database’, // Database access
// ‘image’ => MODPATH.’image’, // Image manipulation
// ‘orm’ => MODPATH.’orm’, // Object Relationship Mapping
// ‘pagination’ => MODPATH.’pagination’, // Paging of results
// ‘userguide’ => MODPATH.’userguide’, // User guide and API documentation
‘fortune’ => MODPATH.’fortune’,
));[/php]
We’ve added the new fortune module and enabled it in our system here. Now open the the “/application/views/pages/ko3.php” file and add the following to the bottom of it.
[php]
<?php echo Fortune::factory();?>
[/php]

Now if you point your browser to “http://yourserver/mykohana3/ko3/” you should see the fortune at the bottom!

Until next time, when I go over including external libraries, happy coding.

Part 7 | Part 9

So pretty much they are static methods that “help” with doing common things, IE: working with arrays or URLs. Kohana comes with quite a few “helpers” prepackaged. See the KO3 API Guide.

So how do we make a “helper”? Fire up your IDE and let get coding. The first thing we should is create a new directory called “helper” under “/application/classes”. Create a new file and put the following into it:
[php]<?php
class Helper_MyUrl
{
public static function SEOIt($str)
{
$str = preg_replace(array(‘/s/’, ‘/[$.+!*'(),"]/’), array(‘-’, “”), $str);
return $str;
}
}[/php]
Save to this as “myurl.php” under “/application/classes/helper”. Now open “/application/views/pages/ko3.php” and add the following to the bottom and save it.:
[php] <br /><?php echo Helper_MyUrl::SEOIt(‘This Is a string!!!’);?>[/php]
So if you point your browser to “http://yourserver/mykohana3/ko3/”, you should see “ThisIsastring” at the bottom. Pretty simple!

Until next time, when I go over modules, happy coding.

Sources used: Kohana PHP 2.x Docs, Kohana Forums

Part 6 | Part 8

So what does a route look like? Open up “bootstrap.php” located in “application/”, and scroll down to the comment that says:
[php]/**
* Set the routes. Each route must have a minimum of a name, a URI and a set of
* defaults for the URI.
*/[/php]
The next thing you should see is something like this:
[php]Route::set(‘default’, ‘(<controller>(/<action>(/<id>)))’)
->defaults(array(‘controller’ => ‘welcome’,
‘action’ => ‘index’));[/php]
So we have a route setup initially for us, but what does this tell us. If we break it down we get:
1. Set a route with the name “default”
2. ‘((/(/)))’ Tells the route the controller, action and id are optional. The parentheses are containers that denote if an option is opional or not and the less / greater than symbols tell the the router to assign the value to the variable of the value in-between the less / greater than symbols.
3. The default values for the controller is “welcome” and the default value for the action is “index”

So when we go to “http://yourserver/mykohana3/”, the router see that we have not set a controller nor an action in our URL. It will go through the route rules that we have set to find a match. In our case, we have a default route, which is named “default”. This default route will replace the missing controller with “welcome” and the action with “index” and the rest of the system will process it. Simple so far?

If we were to to “http://yourserver/mykohana3/hmvc/”, the router would notice that the controller has been set, but not the action. The router then assign the default action value of “index” for us.

You might have noticed the optional “id” in the route. This I would say is pretty commonly used and we could pass an ID on to our action. Example:
“http://yourserver/mykohana3/hmvc/index/111″. Of course this example will not do anything special since we didn’t set up any logic to handle it. Now what if we browsed to “http://yourserver/mykohana3/hmvc/index/111/222″? We get an error. This is because our router rule is strict and says we can only route for upwards of 3 segments (action/controller/id) and the /222 creates a fourth. To over come this we can though in a overflow handler rule into our default route.
[php]Route::set(‘default’, ‘(<controller>(/<action>(/<id>(/<overflow>))))’, array(‘overflow’ => ‘.*?’))
->defaults(array(‘controller’ => ‘welcome’,
‘action’ => ‘index’));[/php]
If you save the ‘bootstrap.php’ file and reload, you should not see an error now.

You might notice that we’ve added in an extra array “array(‘overflow’ => ‘.*?’)”. This basically sets up a REGEX rules for the “overflow” option which tell the router to capture everything, including slashes and pass it as our “overflow” argument. So if slashes are captured, the router will no longer try to split out the options on slashes.

Lets go back to this “id” option we see in our route. Well, anything we put in that area will be passed to our action. If our id’s are integers, we might want to error out if we pass a non integer. One way we can do this is with the route:
[php]Route::set(‘default’, ‘(<controller>(/<action>(/<id>(/<overflow>))))’, array(‘id’ => ‘[[:digit:]]{1,}’, ‘overflow’ => ‘.*?’))
->defaults(array(‘controller’ => ‘welcome’,
‘action’ => ‘index’));[/php]
So now if you were go to: “http://yourserver/mykohana3/hmvc/index/xxx”, you would get an error about not being able to find the route, which should translate to a 404 in a production environment. Of course you could check the id for an integer inside the action action and decide how to handle it.

Now lets create a route that isn’t our default route. Add the following to the “bootstrap.php” before the default route:
[php]Route::set(‘monkeys’, ‘monkeys(/<action>(/<id>))’)
->defaults(array(‘controller’ => ‘ko3′,
‘action’ => ‘posts’));[/php]
Now if you were open up “http://yourserver/mykohana3/monkeys”, you would end up with the “posts” action of the “ko3″ controller. If you notice, the “monkeys” in the controller spot is not enclosed by parentheses, meaning that is not optional. So the router see “monkeys” in the controller spot and triggers this rule set.

Here’s an example you might want to use to serve up some static pages (Totally stole this from the Unofficial Kohana 3.0 Wiki):
[php]Route::set(‘static’, ‘<page>’, array(‘page’ => ‘about|faq|locations’))
->defaults(array(‘controller’ => ‘page’,
‘action’ => ‘static’));[/php]
There is a bit more you could do with routes, but the above should cover the majority of things you would want to use route for.

Until next time when we will go over modules and helpers, happy coding.
Sources used: Unofficial Kohana 3 Wiki

<<Part 5 | Part 7>>

So we’ve been design pages with a single controller as a page, with some actions that pulls data in from a model and populates a parts of a view to give us a complete browser page. Well, that can get messy with all the model calls and extra snippets we bring into with views. Using HMVC, we can organize our code a lot better, make more things reusable and with the way Kohana PHP 3 does HMVC, we can even make our application scale by calling out to other servers to give us our content for a section.

Lets go ahead and make a new controller:
[php]<?php
defined(‘SYSPATH’) or die(‘No direct script access.’);

class Controller_Hmvc extends Controller_DefaultTemplate
{
public function action_index()
{
// Set meta data
$this->template->title = ‘Kohana 3.0 HMVC Test’;
$this->template->meta_keywords = ‘PHP, Kohana, KO3, Framework, HMVC’;
$this->template->meta_description = ‘A test of of the KO3 framework HMVC pattern’;

// Fill in content
$ko3 = array();
$ko3['posts'] = Request::factory(‘posts/getposts’)->execute()->response;

$this->template->content = View::factory(‘pages/hmvc’, $ko3);
}

}[/php]
Save this as “hmvc.php” in “application/classes/controller”. The above should look pretty familiar. One line should stand out:
[php]$ko3['posts'] = Request::factory(‘posts/getposts’)->execute()->response;[/php]
This line is where the HMVC magic happen. This will call the controller “posts” an invoke the action “getposts”, execute the code and get the response. We take the response and save it to the array which we fill the view with.

Talking about views, let make our view for this controller:
[php]<?php echo $posts;?>[/php]
Save this as “hmvc.php” in “application/views/pages/”

Now for the “posts” controller:
[php]<?php
defined(‘SYSPATH’) or die(‘No direct script access.’);

class Controller_Posts extends Controller
{
public function action_index()
{
}

public function action_getposts()
{
// Load model
$posts = new Model_Post();

// Fill content array for view with last 10 posts.
$content = array();
$content['posts'] = $posts->getLastTenPosts();

// Render and output.
$this->request->response = View::factory(‘pages/hmvc_posts’, $content);
}
}[/php]
Save this as “posts.php” in “application/classes/controller”. Once again, pretty straight forward. This controller extends the basic controller, so nifty template or anything and is pretty much what we did in the last tutorial.

Now for the view.
[php]<?php foreach($posts as $post):?>
<h1><?php echo $post['title'];?></h1>
<?php echo $post['post'];?>
<hr />
<?php endforeach;?>[/php]
Save this as “hmvc_posts.php” under “applications/views/pages”.

Now if you point your browser to: “http://yourserver/mykohana3/hmvc”, you should see a couple posts up on the screen.

We can achieve the same result by calling the controller from the view instead of the controller. This is helpful for keeping it simple. So one template used all over the place, you wouldn’t have to worry about having to putting in all the HMVC stuff into the controllers that used that template.

Change the “hmvc” controller to look like this:
[php]<?php
defined(‘SYSPATH’) or die(‘No direct script access.’);

class Controller_Hmvc extends Controller_DefaultTemplate
{
public function action_index()
{
// Set meta data
$this->template->title = ‘Kohana 3.0 HMVC Test’;
$this->template->meta_keywords = ‘PHP, Kohana, KO3, Framework, HMVC’;
$this->template->meta_description = ‘A test of of the KO3 framework HMVC pattern’;

// Fill in content
$ko3 = array();
$ko3['content'] = ‘Hello there!’;
$this->template->content = View::factory(‘pages/hmvc’, $ko3);
}
}[/php]
Now edit the “hmvc” view to look like this:
[php]<?php echo $content;?><br/>
<?php echo Request::factory(‘posts/getposts’)->execute()->response;?>[/php]
This is example is pretty simple and we could expand this to use parameters to deliver the data in different ways, say, simple html, full html, xml, json, etc..

Sources used: Unofficial Kohana 3 Wiki, iBuildings: Scaling Web Applications with HMVC

<<Part 4 | Part 6>>

Models are classes designed to work with information given by or asked for by the controller. For example, you have a guestbook, the controller will ask the model to retrieve the last ten entries, the model returns those entries to the controller who passes them on to a view. The controller might also send new entries to the model, update existing ones or even delete some.

Simply a model is a data handler and manipulator.

The first thing we want to do is identify where and what the data is. Is it an XML feed, CSV, JSON, DB or something else? Well I’m going to make it easy. We are going to deal with our friend MySQL for this. The next step is to setup a MySQL DB connection.

Lets open up your bootstrap file (“application/bootstrap.php”) and find the like that reads “// ‘database’ => MODPATH.’database’, // Database access” and uncomment it. The whole block of code should look like the following:
[php]Kohana::modules(array(
// ‘auth’ => MODPATH.’auth’, // Basic authentication
// ‘codebench’ => MODPATH.’codebench’, // Benchmarking tool
‘database’ => MODPATH.’database’, // Database access
// ‘image’ => MODPATH.’image’, // Image manipulation
// ‘orm’ => MODPATH.’orm’, // Object Relationship Mapping
// ‘pagination’ => MODPATH.’pagination’, // Paging of results
// ‘userguide’ => MODPATH.’userguide’, // User guide and API documentation
));[/php]
Now save this. We’ve basically told the bootstrap to load the database module, but we need to configure it. Copy the “database.php” from “modules/database/config/” to “application/config/”. Open up the “application/config/database.php” file and edit accordingly to your settings. Mine looks like this:
[php]<?php defined(‘SYSPATH’) OR die(‘No direct access allowed.’);

return array
(
‘default’ => array
(
‘type’ => ‘mysql’,
‘connection’ => array(
/**
* The following options are available for MySQL:
*
* string hostname
* integer port
* string socket
* string username
* string password
* boolean persistent
* string database
*/
‘hostname’ => ‘localhost’,
‘username’ => ‘root’,
‘password’ => FALSE,
‘persistent’ => FALSE,
‘database’ => ‘mykohana3′,
),
‘table_prefix’ => ”,
‘charset’ => ‘utf8′,
‘caching’ => FALSE,
‘profiling’ => TRUE,
),
‘alternate’ => array(
‘type’ => ‘pdo’,
‘connection’ => array(
/**
* The following options are available for PDO:
*
* string dsn
* string username
* string password
* boolean persistent
* string identifier
*/
‘dsn’ => ‘mysql:host=localhost;dbname=mykohana3′,
‘username’ => ‘root’,
‘password’ => FALSE,
‘persistent’ => FALSE,
),
‘table_prefix’ => ”,
‘charset’ => ‘utf8′,
‘caching’ => FALSE,
‘profiling’ => TRUE,
),
);[/php]
Save this. You’ll notice I have a database setup just this tutorial series named “mykohana3″, you might want to do the same if you can. Now that we have saved, let get a table set up. Here’s the SQL:
[php]CREATE TABLE `posts` (
`id` MEDIUMINT(8) UNSIGNED NOT NULL AUTO_INCREMENT,
`title` VARCHAR(255) DEFAULT NULL,
`post` TEXT,
PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8 CHECKSUM=1 DELAY_KEY_WRITE=1 ROW_FORMAT=DYNAMIC;[/php]
Go run that in your favorite MySQL client, I personally like SQLYog. You might have noticed the “charset” is set to “utf8″ in both the config and create table statement. This will allow us to deal with i18n (Internationalization) stuff later on.

So let create a new folder under “application/classes” named “model”. Now lets create a new file and make it look like this:
[php]<?php
defined(‘SYSPATH’) or die(‘No direct script access.’);

class Model_Post extends Kohana_Model
{
/**
* Get the last 10 posts
* @return ARRAY
*/
public function getLastTenPosts()
{
$sql = ‘SELECT *’.”n”.
‘FROM `posts`’.”n”.
‘ORDER BY `id` DESC’.”n”.
‘LIMIT 0, 10′;

return $this->_db->query(Database::SELECT, $sql, FALSE)
->as_array();
}
}[/php]
Save this as “post.php” under “application/classes/model/”. Here’s an line by line explaination of the code.
[php] $sql = ‘SELECT *’.”n”.
‘FROM `posts`’.”n”.
‘ORDER BY `id` DESC’.”n”.
‘LIMIT 0, 10′;[/php]
This is a basic MySQL statement that selects up to ten rows from the DB which are sorted by the ‘id’ in a descending direction.
[php] return $this->_db->query(Database::SELECT, $sql, FALSE)
->as_array();[/php]
This return array of the result from a query. The “query” method in this example take 3 parameters. 1st being what type of query, our being select, we use the constant “Database::SELECT”. There are 3 others, “Database::INSERT”, “Database::UPDATE” and “Database::DELETE”. The “as_array()” will return an array of the results, no having to do “while($row = mysql_fetch_array())”.

Now that we have a model method, I’m sure we would want to put it use. Open up “ko3.php” in “/application/classes/controller” and lets add this into the class:
[php] public function action_posts()
{
$posts = new Model_Post();
$ko3 = array();
$this->template->title = ‘Kohana 3.0 Model Test’;
$this->template->meta_keywords = ‘PHP, Kohana, KO3, Framework, Model’;
$this->template->meta_description = ‘A test of of the KO3 framework Model’;
$this->template->styles = array();
$this->template->scripts = array();

// Get the last 10 posts
$ko3['posts'] = $posts->getLastTenPosts();
$this->template->content = View::factory(‘pages/posts’, $ko3);

}[/php]
Basically we’ve called our model’s “getLastTenPosts()” method and assigned it to an array which we pass to our view. Talking about views, open up a new file and put the following into it:
[php]<?php foreach($posts as $post):?>
<h1><?php echo $post['title'];?></h1>
<?php echo $post['post'];?>
<hr />
<?php endforeach;?>[/php]
Save to as “posts.php” under “application/views/pages/”. This view loops through the array we pass to it from the the controller and displays our posts from the DB. Wait, what? There’s no posts in our DB! Here’s some SQL you can run to populate your table:
[php]insert into `posts`(`id`,`title`,`post`) values (1,’Test Post’,'This is some sample text.’);
insert into `posts`(`id`,`title`,`post`) values (2,’Another post’,'Some more text’);[/php]
Now if you point your browser to “http://yourserver/mykohana3/ko3/posts” you should see the two entries on the screen.

Now lets add something to put data into our DB. Open the the post model (“application/classes/model/post.php”) and add this to the class:
[php] public function addPost($title, $post)
{
$sql = sprintf(‘INSERT INTO `posts`’.”n”.
‘SET `title` = %s,’.”n”.
‘ `post` = %s’,
$this->_db->escape($title),
$this->_db->escape($post));

$this->_db->query(Database::INSERT, $sql, FALSE);
}[/php]
The above is a pretty simple insert, but you may notice we are using “$this->_db>escape()”. This will wrap your strings in quotes and escape it content for you. Save it and now go back to the “posts.php” from “application/views/pages” and replace the contents with:
[php]<?php if(!empty($msg)):?>
<?php echo $msg.’<br />’;?>
<?php endif;?>
<?php foreach($posts as $post):?>
<h1><?php echo $post['title'];?></h1>
<?php echo $post['post'];?>
<hr />
<?php endforeach;?>
<form method=”POST” action=”<?php echo url::base();?>ko3/posts/”>
<table>
<tr>
<td>
Title
</td>
<td>
<input type=”text” name=”title” style=”border: 1px solid #000000;”/>
</td>
</tr>
<tr>
<td>
Post
</td>
<td>
<textarea cols=”20″ rows=”5″ name=”post”></textarea>
<input type=”submit” name=”submit” value=”Submit”/>
</td>
</table>
</form>[/php]
Save that and open the ko3 controller back up (“application/classes/controller/ko3.php”) and lets add a new method to it.
[php] private function _addPost($title, $post_content)
{
// Load model
$post = new Model_Post();

// Check required fields
if(empty($title))
{
return(array(‘error’ => ‘Please enter a title.’));
}
elseif(empty($post_content))
{
return(array(‘error’ => ‘Please enter a post.’));
}

// Add to DB
$post->addPost($title, $post_content);
return TRUE;
}[/php]
The above code is pretty much a middle man between the “action_posts” and the model that saves the post it self. Lets go back to the “action_posts” method and make it look like this:
[php] public function action_posts()
{
// Load model
$posts = new Model_Post();

// Setup view stuff
$ko3 = array();
$this->template->title = ‘Kohana 3.0 Model Test’;
$this->template->meta_keywords = ‘PHP, Kohana, KO3, Framework, Model’;
$this->template->meta_description = ‘A test of of the KO3 framework Model’;
$this->template->styles = array();
$this->template->scripts = array();
$ko3['msg'] = “”;

// Handle POST
if($_POST)
{
$ret = $this->_addPost((isset($_POST['title']) ? $_POST['title'] : “”),
(isset($_POST['post']) ? $_POST['post'] : “”));

if(isset($ret['error']))
{
$ko3['msg'] = $ret['error'];
}
else
{
$ko3['msg'] = ‘Saved.’;
}
}

// Get the last 10 posts
$ko3['posts'] = $posts->getLastTenPosts();

// Display it.
$this->template->content = View::factory(‘pages/posts’, $ko3);
}[/php]
Save this and reload your browser. Now you should see a pretty ugly form at bottom. Enter some stuff in and click the “submit” button. Your post should appear at the top along with the word “Saved”, this is if you entered stuff in both fields, if not you should see an error.

Before I end this tutorial, I want to go back to our little model for saving our posts. There are several ways to do queries in KO3, but want to quickly show you how you can use the query builder to do the same thing.
[php] public function addPost($title, $post)
{
DB::insert(‘posts’, array(‘title’,'post’))
->values(array($title, $post))
->execute();
}[/php]
That’s pretty simple! It does the same thing as the previous one, with less “hassle” There are advantages using the query builder method, like being able to convert between different DB types (MySQL to Oracle to what ever).

While I might not have gone over doing updates with your model, I thought I would give you a homework assignment to see if you can come up with you own update model for this. Until next time when we go over “H” in “HMVC”, happy coding.

Sources used: Unofficial Kohana 3 Wiki, Kohana PHP 2.x Docs, KO3 API Guide

<<Part 3 | Part 5>>

As you can see the above pretty much looks like a view we have done before, a bit more expanded. I will go over the “foreach” a little bit later. Unlike a view, this will most likely be used by all of your project. Since we will point to this file for our template, or shell, this will reduce the amount of code you have to put in each view, keeping thing separated, easier to maintain, or basically “DRY”.

Now that we have a template, our system isn’t going to do anything with it until well tell it to use it. So lets go back to our IDE and create a new file and put the following into it:
[php]
<?php
defined(‘SYSPATH’) or die(‘No direct script access.’);

class Controller_DefaultTemplate extends Controller_Template
{
public $template = ‘templates/default’;

/**
* Initialize properties before running the controller methods (actions),
* so they are available to our action.
*/
public function before()
{
// Run anything that need ot run before this.
parent::before();

if($this->auto_render)
{
// Initialize empty values
$this->template->title = ”;
$this->template->meta_keywords = ”;
$this->template->meta_description = ”;
$this->template->meta_copywrite = ”;
$this->template->header = ”;
$this->template->content = ”;
$this->template->footer = ”;
$this->template->styles = array();
$this->template->scripts = array();
}
}

/**
* Fill in default values for our properties before rendering the output.
*/
public function after()
{
if($this->auto_render)
{
// Define defaults
$styles = array(‘assets/css/reset.css’ => ‘screen’);
$scripts = array(‘http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js’);

// Add defaults to template variables.
$this->template->styles = array_reverse(array_merge($this->template->styles, $styles));
$this->template->scripts = array_reverse(array_merge($this->template->scripts, $scripts));
}

// Run anything that needs to run after this.
parent::after();
}
}
[/php]
And save this as “defaulttemplate.php” under your “/application/classes/controller/” folder.

The above code extends the “Controller_Template” class and does three main things, initialize some properties (variables) to be accessable by our methods (actions) and appends default values to them and then gets associates them to our template variables before we render the final output to the screen. This is where the foreach() loop in the template comes into play. The foreach() loop uses a static method for the helper class “HTML” to load CSS style sheets and load JS files. Both of these helper methods will iterate through an array and properly wrap it in the appropriate tag. They can take a path or a URL.

You might be wondering what a “Helper” is, so here is a quick definition from the Kohana PHP 2.x documents:

Helpers are simply “handy” functions that help you with development.

Helpers are similar to library methods, but there is a subtle difference. With a library, you have to create an instance of the library’s class to use its methods. Helpers are declared as static methods of a class, so there is no need to instantiate the class. You can think of them as “global functions”.

As with libraries, the helper classes are automatically loaded by the framework when they are used, so there is no need to load them yourself.

OK, back on course. You might have noticed there is a reference to “assets/css/reset.css”, so lets go ahead and get that in place. In your root create a folder named “assets” and in that folder create one named “css”. For the actual “reset.css” file, I went to Serene Destiny and copied the code from the article titled “Create The Perfect CSS Reset” into a file and saved it as “reset.css” in the “assets/css/” folder. You might want to also set up some other folders within “/assets/”, maybe “images”, “js” and “files”. Basically the assets folder should be used to store and organize static files and such.

At this point, our application still doesn’t know what to do what we have done, so we need to modify our controller. So open “/application/classes/controller/ko3.php”.
We want to change what class we are extending, so change the line:
[php]class Controller_Ko3 extends Controller[/php]
to:
[php]lass Controller_Ko3 extends Controller_DefaultTemplate[/php]

We also need to change up our “index” action (action_index() method) to look like the following:
[php]
public function action_index()
{
$ko3_inner = array();
$ko3 = array();
$this->template->title = ‘Kohana 3.0′;

View::set_global(‘x’, ‘This is a global variable’);

$ko3_inner['content'] = ‘We have more data’;
$ko3['content'] = ‘We have data’;
$ko3['ko3_inner'] = View::factory(‘blocks/ko3_inner’, $ko3_inner)
->render();
$this->template->content = View::factory(‘pages/ko3′, $ko3);
}
[/php]
Save it. Now you might noticed that we now have “$this->template->title = ‘Kohana 3.0′;”, this will assign a value to our templates “title” variable. The next thing you might notice is the absence of the last “render()” method. The “factory()” method actually will “auto render” it to our template’s “content” variable. Pretty simple, yes?

There is something we should probably do before loading up the page, so load up the “ko3.php” view file located in “application/views/pages/”. You might noticed that we have all the “shell” code in our view, so lets remove it. What you should only have in the view file is this:
[php]
<h1>This is my first view</h1>
<?php echo $content;?>
<?php echo $ko3_inner; ?>
<br/><?php echo $x;?>
[/php]

Now if you load it up, you should see that page has a title of “Kohana 3.0″ and the page should pretty much look the same as it did from the last tutorial. If you view the source thou, it would look much different. But you might be wondering about the other variables in the template and what to do with them. OK, let go back and edit our “index” action again. Make it look like:
[php]
public function action_index()
{
$ko3_inner = array();
$ko3 = array();
$this->template->title = ‘Kohana 3.0′;
$this->template->meta_keywords = ‘PHP, Kohana, KO3, Framework’;
$this->template->meta_description = ‘A test of of the KO3 framework’;
$this->template->styles = array(‘assets/css/red.css’ => ‘screen’);
$this->template->scripts = array(‘assets/js/jqtest.js’);

View::set_global(‘x’, ‘This is a global variable’);

$ko3_inner['content'] = ‘We have more data’;
$ko3['content'] = ‘We have data’;
$ko3['ko3_inner'] = View::factory(‘blocks/ko3_inner’, $ko3_inner)
->render();
$this->template->content = View::factory(‘pages/ko3′, $ko3);
}
[/php]
Pretty simple. You will notice I didn’t fill in the header or footer. I’m sure you know what to do there. Hint: Render a view to that variable =). Another thing you might notice is that I have put in “assets/css/red.css” and “assets/css/jqtest.js”. Lets make those two files starting with “/assets/css/red.css”:
[php]
h1
{
color: #FF0000;
}
[/php]

Next “/assets/js/jqtest.js”:
[php]
$(“document”).ready(function()
{
alert(‘Hello Kohana!’);
});
[/php]

Save them and refresh the site. You should see an alert pop up and the first line of text in red.

Today we have created a template file, extended a template controller and our controller use that template file. There is a lot of potential with what you could do with this already. So until next time when I will go over models, happy coding!
Sources used: Unofficial Kohana 3 Wiki, Kohana PHP 2.x Docs

Part 2 | Part 4

Simple enough, but there is another way of doing the above. We could have also done the following:
[php] public function action_index()
{
$data['content'] = ‘We have data!’;
$view = View::factory(‘pages/ko3′, $data);
$this->request->response = $view->render();
}[/php]
Basically the above use an array with element keys as the template variable names to assign the data. We are not done yet! There’s 2 more ways we can do the above.
[php] public function action_index()
{
$view = View::factory(‘pages/ko3′)
->set(‘content’, ‘We have data!’);

$this->request->response = $view->render();
}[/php]
The above used the set method of the view class, which you can use method chaining to set all your template variables. And now for forth way:
[php] public function action_index()
{
$content = ‘We have data!’;
$view = View::factory(‘pages/ko3′)
->bind(‘content’, $content);
$this->request->response = $view->render();
}[/php]
Now the above is using the bind method of the view class. Once again, this you can do method chaining here. This is a little bit different from the set method, since it will create a reference to a variable. So $content might equal ‘We have data!’ when we bound the variable to the template variable, but could change later on, since we are referencing the variable $content in our controller, instead of assigning data to the template variable.

If we were to do the following:
[php] public function action_index()
{
$content = ‘We have data!’;
$view = View::factory(‘pages/ko3′)
->bind(‘content’, $content);
$content = ‘Our data changed’;
$this->request->response = $view->render();
}[/php]
Instead of “We have data!” showing on our screen, we would have “Our data changed”.

Now lets do a view with in a view! Create a new folder in your “application/views/” named “blocks”. Lets create another view file named “ko3_inner.php” and put this in it:
[php] <h3>This is an inner view</h3>[/php]
Save that in your “application/views/blocks/” directory. Now lets edit the “ko3″ view (“application/views/pages/ko3.php”) and add the following:
[php] <?php echo View::factory(‘blocks/ko3_inner’)->render(); ?>[/php]
You view should like this:
[php]<html>
<head>
<title>Hello!</title>
</head>
<body>
<h1>This is my first view</h1>
<?php echo $content;?>
<?php echo View::factory(‘blocks/ko3_inner’)->render(); ?>
</body>
</html>[/php]
So if we run it we should see what we had before, then “This is an inner view”. This would be useful for static content, but we won’t be able to use variables directly to that view. So let fix this. Lets go back to our controller (“application/classes/controllers/ko3.php”) and edit the “Action_Index” method to look like this:
[php] public function action_index()
{
$ko3_inner['content'] = ‘We have more data’;
$ko3['content'] = ‘We have data’;
$ko3['ko3_inner'] = View::factory(‘blocks/ko3_inner’, $ko3_inner)
->render();
$view = View::factory(‘pages/ko3′, $ko3);
$this->request->response = $view->render();
}[/php]
This will render the view to a array that then is rendered by the main view. If you noticed I did the inner stuff first and went back to using array template variable setting style. Next we will need to edit the main view (“application/views/pages/ko3.php”). The line we put in before, we will change it to:
[php] <?php echo $ko3_inner; ?>[/php]
The view should look like this:
[php]<html>
<head>
<title>Hello!</title>
</head>
<body>
<h1>This is my first view</h1>
<?php echo $content;?>
<?php echo $ko3_inner; ?>
</body>
</html>[/php]
And the last change we need to make is to the inner view (“application/views/blocks/ko3_inner.php”). Make it look like this:
[php] <h3>This is an inner view</h3>
<?php echo $content;?>[/php]
If you refresh the browser after saving, you should now see the following:
[php]This is my first view

We have data

This is an inner view

We have more data[/php]
Pretty cool, now you can make your views more modular and reusable. Now lets get into making variables globally available to your views. Back to your controller (“applications/classes/controllers/ko3.php”) and edit the “Action_Index” method so the following is at the top of the method:
[php] View::set_global(‘x’, ‘This is a global variable’);[/php]
So now the method should look like this:
[php] public function action_index()
{
View::set_global(‘x’, ‘This is a global variable’);

$ko3_inner['content'] = ‘We have more data’;
$ko3['content'] = ‘We have data’;
$ko3['ko3_inner'] = View::factory(‘blocks/ko3_inner’, $ko3_inner)
->render();
$view = View::factory(‘pages/ko3′, $ko3);
$this->request->response = $view->render();
}[/php]
Now if you were to edit your views and add in:
[php] <br/><?php echo $x;?>[/php]
You should now see “This is a global variable” two times on the page. As you can see this could be very handy. Basically, we are using the static method of “set” from the view class, so it ends up being available to all view object instances. You can also use the static method of “bind” to reference variables. This could be handy for dry things “DRY” and could be used in other place, like a contruct.

Untill next time, when I go over “templates” (advanced views and controller stuff), happy coding!
Sources used: Unofficial Kohana 3 Wiki

Part 1 | Part 3