Here the SQL I came up with for the aforementioned example:

SELECT 
    Tag.name, 
    COUNT(*) as postcount
FROM 
    tags AS t 
    INNER JOIN posts_tags AS pt ON (t.id = pt.tag_id) 
    INNER JOIN posts AS p ON (pt.post_id = p.id) 
    INNER JOIN posts_tags AS pota ON (p.id = pota.post_id) 
    INNER JOIN tags AS Tag ON (pota.tag_id = Tag.id) 
WHERE 
    t.name = 'sql'  
    AND t.id <> Tag.id
GROUP BY 
    Tag.name';

I hope this SQL snippet is useful for some of you!

During the NoseRub DevCamp last weekend (here a short summary) I had to implement request tokens with a limited life time. In our case this life time is 24 hours, i.e. the user has to use the request token within 24 hours, or else it expires. To remove the expired request tokens I wrote the following method:

// in the RequestToken model
public function deleteExpired() {
    $this->deleteAll(array('RequestToken.modified <= DATE_SUB(NOW(), INTERVAL 24 HOUR)'));
}

This snippet performs the following steps: it gets the current date and time, subtracts 24 hours, and then deletes all request tokens whose “modified” value is smaller (i.e. older) or equal to the result of the subtraction.

MySQL’s date and time functions are much more powerful than shown in this example, so I recommended to check out the documentation, too.

I hope this is helpful for some of you :)

Ok, let’s do some examples to learn more about it. We will use the following countries table:

[1] => USA
[2] => Germany
[3] => Russia
[4] => Austria
[5] => China
[6] => Switzerland

Now, we don’t want to sort them by the id, but by some “strange” order: Austria, USA, China, Russia, Switzerland, Germany. For this purpose we can use “order by field”: the first parameter is the column name and all following parameters are values of the respective column. In CakePHP it is done in the following way:

$this->Country->find('list', array('order' => array('FIELD(Country.id, 4, 1, 5, 3, 6, 2)')));

And we get the expected result:

[4] => Austria
[1] => USA
[5] => China
[3] => Russia
[6] => Switzerland
[2] => Germany

Probably more common is the scenario that you want to have certain values at the top of a list, and the other values of the list should be ordered alphabetically. If we want the German-speaking countries at the top of the list we would do:

$this->Country->find('list', array('order' => array('FIELD(Country.id, 2, 4, 6)', 'Country.name')));

or 

$this->Country->find('list', array('order' => array('FIELD(Country.name, "Germany", "Austria", "Switzerland")', 'Country.name')));

Unfortunately, this doesn’t return the expected result, the records which should be at the top are at the bottom:

[5] => China
[3] => Russia
[1] => USA
[2] => Germany
[4] => Austria
[6] => Switzerland

We can solve this “problem” by using the “DESC” keyword and changing the order of the provided values:

$this->Country->find('list', array('order' => array('FIELD(Country.id, 6, 4, 2) DESC', 'Country.name')));

or

$this->Country->find('list', array('order' => array('FIELD(Country.name, "Switzerland", "Austria", "Germany") DESC', 'Country.name')))

With those changes we get the expected result:

[2] => Germany
[4] => Austria
[6] => Switzerland
[5] => China
[3] => Russia
[1] => USA

Thanks to Tarique for mentioning “order by field” and to Abhimanyu Grover for asking the original question.

The obvious solution — using findCount() — doesn’t work, as there is no way to specify that you want to use “distinct”.

So to get the desired result we have to use a find() or findAll() statement as shown in the following example:

$this->User->find(null, "COUNT(DISTINCT User.city) AS 'count'");

The solution is rather simple:

$this->User->findAll(null, 'DISTINCT User.city');

Or with the array syntax:

$this->User->findAll(null, array('DISTINCT User.city'));

Please notice that the keyword “DISTINCT” has to be uppercase, else you will get the following error:

Unknown column 'distinct User.city'

$this->User->findAll(array('DATE(User.modified)' => '-!CURDATE()'));

This snippet returns all user records modified at the current day. Now John-Henrique asked in a comment how to do the contrary, i.e. select those records not modified at the current day.

There exist at least two possible ways to accomplish this, the simplest one is to use “<>”:

$this->User->findAll(array('DATE(User.modified)' => '<> -!CURDATE()'));

It creates the following SQL code:

... WHERE DATE(`User`.`modified`) <> CURDATE()

Another approach is to use the “NOT” keyword of SQL:

$this->User->findAll(array('NOT' => array('DATE(User.modified)' => '-!CURDATE()')));

With this snippet we get the following SQL statement:

... WHERE NOT (DATE(`User`.`modified`) = CURDATE())

The obvious approach doesn’t work:

$this->User->findAll(array('DATE(User.modified)' => 'CURDATE()'));

The function “CURDATE()” is escaped and treated as a string as you can see in the generated SQL statement:

... WHERE DATE(`User`.`modified`) = 'CURDATE()'

To avoid the escaping we have to add the magical “-!” marker in front of the function name:

$this->User->findAll(array('DATE(User.modified)' => '-!CURDATE()'));

This will generate the expected SQL:

... WHERE DATE(`User`.`modified`) = CURDATE()

Hooray!

Thanks to Kabturek who mentioned this little trick some time ago in his blog.

First the obvious solution:

$this->User->findAll('User.id NOT IN (1, 2, 3)');

And here the solution using the array syntax:

$this->User->findAll(array('NOT' => array('User.id' => array(1, 2, 3))));

The next logical step on the way from the domain model to the Cake models would be to refine the domain model to a database diagram. I say “would be” as it is something I almost never do, especially not for small projects. For me it isn’t worth the additional effort as a database diagram doesn’t add much value if you know some basic rules (Cake conventions). And well, I don’t have found a free tool for this task which convinced me ;-)

So I will go on and create the tables manually. For this purpose I will create a create.sql file in app/config/sql.

The first rule is that table names are plural. So we can write the SQL statement for the table for the “User” class (I omit the other classes as it is the same for them):

CREATE TABLE users (
);

The second rule is that each table has a primary key field with the name “id”. So we can modify the script from above to:

CREATE TABLE users (
    id INT(11) NOT NULL AUTO_INCREMENT,
    PRIMARY KEY (id)
);

The third rule is optional, but you can add the fields “created” and “modified” to the table, which are later automatically populated by CakePHP:

CREATE TABLE users (
    id INT(11) NOT NULL AUTO_INCREMENT,
    created DATETIME,
    modified DATETIME,
    PRIMARY KEY (id)
);

The fourth rule affects 1:n relations: The “n” table must contain a field named “singular name of ’1′ table” + “_id”. In our domain model the relation between User and Project is such a 1:n relation: one User can have many Projects. So we have to add the field “user_id” to the “projects” table:

CREATE TABLE projects (
    id INT(11) NOT NULL AUTO_INCREMENT,
    user_id INT(11) NOT NULL,
    created DATETIME,
    modified DATETIME,
    PRIMARY KEY (id)
);

The fifth rule affects n:n relations. Such relations cannot be mapped directly to the database, we have to introduce a join table. The name of this join table is “plural name of first ‘n’ table” + “_” + “plural name of second ‘n’ table” whereby the names are sorted alphabetically. In our domain model we have only one n:n relation, between User and Project. So the table name is “projects_users”. We also have to apply the fourth rule, as the relations between “projects” and “projects_users” resp. between “users” and “projects_users” are 1:n relations. And so we get:

CREATE TABLE projects_users (
    project_id INT(11) NOT NULL,
    user_id INT(11) NOT NULL
);

Now we can add the attributes from the conceptual classes as fields to the respective tables and write the drop statements. And we get:

CREATE TABLE users (
    id INT(11) NOT NULL AUTO_INCREMENT,
    created DATETIME,
	modified DATETIME,
    PRIMARY KEY (id)
);

CREATE TABLE projects (
    id INT(11) NOT NULL AUTO_INCREMENT,
    user_id INT(11) NOT NULL,
    created DATETIME,
    modified DATETIME,
    PRIMARY KEY (id)
);

CREATE TABLE messages (
    id INT(11) NOT NULL AUTO_INCREMENT,
    project_id INT(11) NOT NULL,
    title VARCHAR(255) NOT NULL,
    content TEXT NOT NULL,
    created DATETIME,
    modified DATETIME,
    PRIMARY KEY (id)
);

CREATE TABLE feeds (
    id INT(11) NOT NULL AUTO_INCREMENT,
    user_id INT(11) NOT NULL,
    url VARCHAR(255) NOT NULL,
    created DATETIME,
    modified DATETIME,
    PRIMARY KEY (id)
);

CREATE TABLE projects_users (
    project_id INT(11) NOT NULL,
    user_id INT(11) NOT NULL
);

And in app/config/sql/drop.sql:

DROP TABLE IF EXISTS users;
DROP TABLE IF EXISTS projects;
DROP TABLE IF EXISTS messages;
DROP TABLE IF EXISTS feeds;
DROP TABLE IF EXISTS projects_users;

To execute these SQL scripts I use a simple Ant script (app/config/sql/build.xml):

<?xml version="1.0"?>
<project name="n" default="default">
    <property name="driver" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost/n?characterEncoding=UTF-8"></property>
    <property name="user" value="root"></property>
    <property name="password" value=""></property>

    <target name="default">
        <sql driver="${driver}" password="${password}" url="${url}" userid="${user}" src="drop.sql" encoding="UTF-8"></sql>
        <sql driver="${driver}" password="${password}" url="${url}" userid="${user}" src="create.sql" encoding="UTF-8"></sql>
    </target>
</project>

After executing the Ant script, we are ready to bake the models. I will use the bake script (available in cake/scripts) to generate the User model, as I was asked to show how bake.php is used. I think it should be self-explanatory:

This will create the following model in app/models/user.php:

<?php
class User extends AppModel {
    var $name = 'User';

    //The Associations below have been created with all possible keys, those that are not needed can be removed
    var $hasMany = array(
        'Feed' => array('className' => 'Feed',
            'foreignKey' => 'user_id',
            'conditions' => '',
            'fields' => '',
            'order' => '',
            'limit' => '',
            'offset' => '',
            'dependent' => '',
            'exclusive' => '',
            'finderQuery' => '',
            'counterQuery' => ''),
        'Project' => array('className' => 'Project',
            'foreignKey' => 'user_id',
            'conditions' => '',
            'fields' => '',
            'order' => '',
            'limit' => '',
            'offset' => '',
            'dependent' => '',
            'exclusive' => '',
            'finderQuery' => '',
            'counterQuery' => ''),
    );

    var $hasAndBelongsToMany = array(
        'Project' => array('className' => 'Project',
            'joinTable' => 'projects_users',
            'foreignKey' => 'user_id',
            'associationForeignKey' => 'project_id',
            'conditions' => '',
            'fields' => '',
            'order' => '',
            'limit' => '',
            'offset' => '',
            'unique' => '',
            'finderQuery' => '',
            'deleteQuery' => '',
            'insertQuery' => ''),
    );
}
?>

It generates also a test case for the model in app/tests/cases/models/user.test.php:

<?php 

loadModel('User');

class UserTestCase extends UnitTestCase {
    var $object = null;

    function setUp() {
        $this->object = new User();
    }

    function tearDown() {
        unset($this->object);
    }

    /*
    function testMe() {
        $result = $this->object->doSomething();
        $expected = 1;
        $this->assertEqual($result, $expected);
    }
    */
}
?>

As you see, when using the bake script you have to answer many questions. That’s a bit of a pain when you want to bake multiple models. And if you don’t want to write tests you have to remove them (that’s at least what I do with files which are not used). These are the reasons I prefer to write the models manually.

Here are the other models (please notice that I omit the $name variable as I am a) using PHP5 and b) lazy):

// app/models/feed.php
<?php

class Feed extends AppModel {
    var $belongsTo = array('User');
}
?>

// app/models/project.php
<?php

class Project extends AppModel {
    var $hasMany = array('Message');
    var $hasAndBelongsToMany = array('User');
}
?>

// app/models/message.php
<?php

class Message extends AppModel {
    var $belongsTo = array('Project');
}
?>

To test whether we defined the associations correctly, we can create for all models the corresponding controllers. Here the UsersController (the other controllers are similar):

// app/controllers/users_controller.php
<?php

class UsersController extends AppController {
    var $scaffold;
}
?>

With that, we have something to play, we can add, edit, and remove records. But it isn’t very useful yet ;-)

That’s it for today.

(other articles from this series)

The following call:

php bake2.php sqlscripts users profiles profiles_users

creates app/config/sql/create.sql:

CREATE TABLE users (
  id INT(11) NOT NULL AUTO_INCREMENT,
  created DATETIME,
  modified DATETIME,
  PRIMARY KEY (id)
); 

CREATE TABLE profiles (
  id INT(11) NOT NULL AUTO_INCREMENT,
  created DATETIME,
  modified DATETIME,
  PRIMARY KEY (id)
); 

CREATE TABLE profiles_users (
  profile_id INT(11) NOT NULL,
  user_id INT(11) NOT NULL,
  PRIMARY KEY (profile_id, user_id)
);

and app/config/sql/drop.sql:

DROP TABLE IF EXISTS users;

DROP TABLE IF EXISTS profiles;

DROP TABLE IF EXISTS profiles_users;

That’s it. You can find the code in the download section. Happy baking :)