Junrey Beduya

How ActiveRecord Works in phptarsier

It's Ruby on Rails, almost...

One of the great features about Ruby on Rails is its data model implementation in the form of ActiveRecord. It's really impressive the way it was implemented which really makes it promising. There has been some attempts to port that feature into PHP but I was not able to see an implementation that looks more like it.

In my attempt to create phptarsier, it was one of the things that I have to make sure it works closer to ActiveRecord in Rails.

Database Configuration

Before you run your application, you need to edit the config/config.php file for you to get started. This will setup the database connection for you and all your models will have the same connection as you instantiate them.

Data Model

Now you have setup your database connection, you need to setup your models for your database. Models are like representations of database tables. For example, if you have a table name "blogs", you would define your model like the following:

<?php
class Blog extends ActiveRecordBase {
	public function table_name() {
		return "blogs";
	}
	
	public function primary_key() {
		return "id";
	}
}
?>

As a general rule for phptarsier models, you have to name the above file as app/models/Blog.php. The file should represent the model, always keep that in mind. If we create a model, we need to extend the functionality of ActiveRecordBase class to enable our model to perform the way we want it to do. All the methods and properties in ActiveRecordBase class is now inherited by our model. You might have notice that I have implemented two methods, namely: table_name() and primary_key(). Actually, this overrides the same methods implemented in our base class. Why I suggest you to create your model like this, is to gain a little time. It is important for me, but if its not a great deal for you, you may not declare the two methods. With the above implementation, the table name and primary key are automatically returned and the object will not have to gather its information by querying the database.

Given that class, you can now perform the basic CRUD(create-retrieve-update-delete) operations. The following are example implementations.

CREATE an Entry

<?php
...
$Blog = new Blog();
$Blog->create(array(
	'title' => 'My first blog',
	'author' => 'jbeduya',
	'intro_text' => 'An introduction to my first blog.',
	'body' => 'The content of my first blog! Wow!'
));
...
?>

UPDATE an Entry

<?php
...
$Blog = new Blog();
$blog = $Blog->find(1);
$blog->title = "My First Blog's new title";
$blog->save();
...
?>

The $Blog->find(1) is then converted to some SQL statement that looks like this: SELECT * FROM blogs WHERE id=1. With the given query it returns an object that has all the fields for the blogs table. The next statement, updates the title to some other value and then updates the database with the changes. That's how easy it is.

DELETE an Entry

<?php
...
$Blog = new Blog();
$Blog->find(1)->delete();
...
?>

The above simply tells the object to query this row and delete it. That simple.

Model Relationships

We are doing fine and we can now create models for each and every table in our database. But what if we want to make some relationships our models. As with my example, a blog has comments. First we need to create our comment model that will look like the following:

<?php
class Comment extends ActiveRecordBase {
	public function table_name() {
		return "comments";
	}
	
	public function primary_key() {
		return "id";
	}
}
?>

How are we gonna make that relationship, that every blog has many comments? It is simple and it requires only a few lines of codes. We need to update our Blog model to tell it has many comments. Our new Blog model should have the following codes added:

<?php
....
class Blog extends ActiveRecordBase {
	public function __construct() {
		$this->has_many('comments', array(
				t_class_name => 'Comment',
				t_foreign_key => 'blog_id',
				t_reference_key => 'id'
			));
	}
	...
}
?>

The above code simply tells that each row of Blog has many "comments", as specified in the first parameter. The first parameter seves as the relationship to the model. The second parameter which is an array of some contants with values are additional parameters required to properly associate the given relationship. If we have to read it, blog has many comments, to determine its comments you instantiate the class named 'Comment' and check if the value for blog_id in 'Comment' is the same as my id. With that specified, you can simply perform the following query.

<?php
...
$Blog = new Blog();
$blog = $Blog->find(1);
$comments = $blog->comments->find_all();
while ($comment = $comments->each()) {
	echo $comment->comment;  // displays the comment itself.
}
...
?>

The "comments" property is automatically known by the class because of the relationship that we specified. The above statment simply queries the database for all the comments of the given blog.

find_by_<field(s)> and find_all_by_<field(s)>

One of the new implementations of ActiveRecordBase is the use of find_by and find_all_by clause.

<?php
...
$Blog = new Blog();
$blog = $Blog->find_by_title('How ActiveRecord Works in phptarsier');
echo $blog->author;
...
?>

That should pretty simple. It queries the blogs table using the title field. It could even take additional fields by adding more fields and separating it with an _and_.

<?php
...
$Blog = new Blog();
$blog = $Blog->find_by_title_and_author('How ActiveRecord Works in phptarsier', 'jbeduya');
echo $blog->author;
...
?>

Isn't that neat? How about the following:

<?php
...
$Blog = new Blog();
$blog = $Blog->find_all_by_author('jbeduya', array(t_condition => 'title'));
echo $blog->author;
...
?>

Phew...

A new release is full-packed with new features:

• pjs (a phptarsier version of rjs)
• ajax and effects
• components
• etc...

I am currently working for its site and sample applications. Just wait till it comes out, you can email me if you want an early copy of it. By the way I have changed its License from GPL to MIT.

Enjoy.