// $queue is required, the rest is optionnal
function bind_queue($queue, $durable = false, $auto_delete = true, $name = false, $answer = null) { ... }

Later in your code, if you want to specify another value for $answer, you have to copy the values of every intermediate parameters in your function call. It’s time consuming, error prone and confusing.

// Good luck remember which parameter is what.
bind_queue($my_queue, false, true, false, 42);

So instead, it’s much better use an associative array, like this:

// leave the required parameter part of the function definition, the options goes into an array
function bind_queue($queue, array $opt = array())
{
  // we define the default values, and merge with the user values at the same timle
  $opt = array_merge(array(
    'durable' => false,
    'auto_delete' => true,
    'name' => false,
    'answer' => null
  ), $opt);

  // use $opt['answer'] to access the 'answer' optionnal parameter
}

Later in your code, if you want to override answer, you can only write this:

bind_queue($my_queue, array('answer' => 42));

Much easier to read, isn’t it?

define('FS_METHOD', 'direct');

I tried this out of desperation, and what do you know, the auto-update started to work just fine with this line… Don’t get me started on WordPress’ code logic.

However, it is also very famous for being flawed by design and easy to violate (like safe_mode by the way). Well, until now I didn’t realize how easy it is indeed to bypass it. During a security audit, I add the opportunity to study a backdoor left here by some script kiddie (thanks to an outdated version of a web application). Here is just one interesting example that uses MySQL:

1. create a temporary table
2. use MySQL’s command LOAD DATA INFILE to read any file and load is content to the table
3. select the content of the table

In clean PHP, the code would looks like:

$filename = '/etc/passwd';

$pdo = new PDO($dsn, $username, $password);
$pdo->exec('CREATE TEMPORARY TABLE tmp_file ( content LONGBLOB NOT NULL)');
$pdo->exec(sprintf(
	'LOAD DATA INFILE %s INTO TABLE tmp_file',
	$pdo->quote($filename)
));
$content = $pdo->query('SELECT * FROM tmp_file')->fetchAll(PDO::FETCH_COLUMN);

To prevent that exploit in particular, it’s easy: just make sure that the MySQL’s user doesn’t have the FILE privilege. But open_basedir is definitely not safe. As seen in Debian’s php.ini default file: This is considered a “broken” security measure. Applications relying on this feature will not recieve full support by the security team…

$file = @ fopen($filename, 'r');
$pos = 0; 

while (true) {
	fseek($file, $pos);
	while ($line = fgets($file)) {
		// do something with $line
	}
	$pos = ftell($file);
	sleep(1);
}
fclose($file);

According to PHP documentation: The destructor will be called even if script execution is stopped using exit(). So destructor’s code will be executed even after die() is called. What happens if a destructor’s code is faulty and gets stuck in an infinite loop ? The script will never end. In my story, I was using an third-party object-oriented library (for AMQP) that did some funky stuff in some objects destructor, and then waited forever for an event on the network… Needless to say, it’s a BAD idea to write that much application logic in a destructor.

So the moral of the story is: (1) die() can fail and (2) use destructor with caution, only write code that will NEVER fail and that is STRICLY necessary like closing connections, closing file handlers and such. Same goes for shutdown functions by the way.

A quick example for the sake of demonstration:

class Evil
{
	public function __destruct()
	{
		while (true);
	}
}

$foo = new Evil();
die();

Apache config

First, a little insight on the Apache configuration. If we would be using one virtual host directive per developer, this wouldn’t be an issue at all. Just set up the proper error_log path (using Apache’s php_value directive like so: php_value error_log /var/log/php/errors_username.log) for every virtual host, reload Apache and you’re done.

Our Apache, however, is using mod_vhost_alias. Basically we have “one virtual host to rule them all”, because I’m lazy and I don’t want to write one virtual host for every new dev, or modify a dozens of virtual host directives everytime I change a setting.

So how does it works? The first part of the URL is the developer username, then the second part is the project’s folder name, then the remaining part is the dev server hostname. With the VirtualDocumentRoot directive, you use parts of the URL has variable for calculating the correct document root path. (Actually, our setup includes a third part which is the subfolder to separate the document root of a project from all the include files, but that’s not the point of this article). Example:

<VirtualHost *:80>
	ServerName dev.domain.com
	ServerAlias *.dev.domain.com

	UseCanonicalName off
	VirtualDocumentRoot /home/%1/web/%2

	<Directory /home/*/web/*/*>
		Allow from all
		AllowOverride all
	</Directory>
</VirtualHost>

The address http://remi.awesome.dev.domain.com will automagically has a document root located in: /home/remi/web/awesome. The benefit is obvious: simplicity and flexibilty. I love convention over configuration design principle.

PHP config

Now the problem is that it’s impossible to tell PHP to logs the errors on a different file based on the first part of the URL directly into the Apache configuration, because the %1, %2,… variable are only valid inside the VirtualDocumentRoot directive.

So we need to do it inside PHP or inside an htaccess file on every folder. But doing it for every project is a pain, not to mention the conflicts to come in SVN because every developer will have his own path. That’s when PHP’s auto_prepend_file option come into play (and honestly, I would never have thought it’ll be useful one day).

I just create a file named /etc/php5/prepend.php with that one-liner:

<?php ini_set('error_log',sprintf('/var/log/php/errors_%s.log',substr($_SERVER['SERVER_NAME'], 0, strpos($_SERVER['SERVER_NAME'],'.'))));

And add this settings to php.ini:

auto_prepend_file = /etc/php5/prepend.php

Note that the directory /var/log/php will not be created out of the blue, so you have to take care of it, and it must be writeable by www-data. Files will be named errors_(first part of the url).log, so for example errors_remi.log in the previous example. Users belongs to group www-data, so as long as the logs are readable by the group (what they are by default) they’ll be able to read their logs.

And now the cherry on top of the cake, the logrotate configuration to rotate logs weekly, and keep one month (4 files) of archive:

/var/log/php/errors_*.log {
        weekly
        missingok
        rotate 4
        compress
        delaycompress
        notifempty
        create 640 www-data www-data
}

Et voilà!

Less rigid API

Until this version, I was focusing on implementing strictly the Google Chart API. However, I eventually realize that the API is sometimes too rigid. For example, say you want to hide an axis. You have to specify “_” (underscore) as the 5th value (axis_or_tick) in the chxs parameter (values are separated by a coma). Looks easy right? Except it is NOT ok to omit the first 4th values. So you have to specify the label_color, font_size and alignment before, in order to be able to hide your axis.

In version 0.3, you had to do exactly that, by using setStyle and specifying the 4th parameter ($axis_or_tick). If you wonder why it’s not the 5th, it’s because the “axis index” value is calculated on runtime. Fortunatly, you could pass null as the value for the parameter, and the library will replace them by the default value. Example:

$axis = new GoogleChartAxis('x');
$axis->setStyle(null, null, null, '_');

In version 0.4, the setStyle method as been removed and splitted into multiple methods setLabelColor, setFontSize, setLabelAlignment, setDrawLine, setDrawTickMarks and setTickColor. Now you don’t need to worry about how many parameter you have to set, just call the method you want and the library will take care of setting the appropriate intermediate values. Example:

$axis = new GoogleChartAxis('x');
$axis->setDrawLine(false)->setDrawTickMarks(false);

More abstraction

This version also comes up with a set of features to simplify chart creation. For example, one of my favorite is setBorder method for Shape Markers (GoogleChartShapeMarker).

To create a border in a shape with Google Chart API, you need to create another similar marker below the first one (think z-order), with a different color and a slightly bigger size. Well, this can be done exactly this way in version 0.3. However, starting version 0.4, the setBorder method does the job for you. Just specify a color and the size of the border, and it will create the second marker automatically. Not only this is more convenient and easy to write, but this is also faster and uses less memory.

New features

This version adds support for Dynamic Icon. Because icons can be either “freestanding” (used as a chart) or used as marker, I had to refactor the base class. Now the base class is GoogleChartApi which holds the logic to query the API. GoogleChart and GoogleChartIcon extends this class, so you can use a GoogleChartIcon exactly the same way as a chart.

Example:

require '../lib/icons/GoogleChartIconNote.php';

$chart = new GoogleChartIconNote('Hello world');
$chart->setTitle('Example');
$chart->setTextColor('D01F3C');

header('Content-Type: image/png');
echo $chart;

To use a icon as a marker, use the new addDynamicMarker method. Example:

require '../lib/GoogleChart.php';
require '../lib/icons/GoogleChartIconNote.php';

$values = array();
for ($i = 0; $i <= 10; $i += 1) {
	$values[] = rand(20,80);
}

$chart = new GoogleChart('ls', 500, 200);
$data = new GoogleChartData($values);
$chart->addData($data);

$marker = new GoogleChartIconNote('Hello');
$marker->setData($data);
$chart->addDynamicMarker($marker);

header('Content-Type: image/png');
echo $chart;

For the moment, only “note” icon (aka Fun style notes with text and optional title) are supported, but I’m working on it.

Hey, the project has a new home!

Yes, the project is now hosted by Google Code. Because there is already a shitload of abandonned projects named using every possible combinations of “google” “chart” and “php”, I had to use the (rather long) name “googlechartphplib”. So new home is here:
http://code.google.com/p/googlechartphplib. You’ll find source code, issue tracker, documentation and the new SVN access there.

Quick introduction

The library’s goal is to provide an easy way to build requests to Google Chart API, and especially to ease the painfull strings concatenation with comas, pipes, colons, etc. If you’ve already tried Google Chart API, you know what I mean! :-) So I wrote a couple of class, that allows to quickly create a chart (GoogleChart), add data series (GoogleChartData), axes (GoogleChartAxis) and markers (GoogleChartMarker), and compute an URL (for GET requests) or an array of parameters (for POST requests). It can even fetch the image for you (via GET or POST) so that you can display it directly (or cache it, or do whatever you want with it).

I wanted to stick really closely to the actual Google Chart API. I hate having to fight with a library when I wanted to do some fancy stuffs with the API. So most of the time, the library will only provides an set of convenient setters stricly mapped on the API specification with almost no additional logic (there is also an universal setter if the setter you need is unimplemented yet. ;-) But YOU will have to check in the Google documentation for the list of supported parameters, or how to do some advanced stuff (compound charts, anyone?). If you give an unsupported parameter, you might get some unexepected results from Google Chart API. Only the cases that would makes the API send a error are checked.

In other words: this library is only an interface, the PHP logic is kept to the minimum. One exception here though: the library provide an autoscaling feature, because scaling manually your chart is a pain in the ass (this feature can be disabled if you want). Therefore if you’re not ready to read at least some of the Google Chart API documentation, this tool might not be for you.

A quick example

One quick example on how to create a line chart with 3 lines, 2 axis and some data markers.

require '../lib/GoogleChart.php';
require '../lib/markers/GoogleChartTextMarker.php';
require '../lib/markers/GoogleChartShapeMarker.php';

// create some random values
$values = array(
	array(),
	array(),
	array()
);
$n = 10;
for ($i = 0; $i <= $n; $i += 1) {
	$v = rand($i , $i*10);
	$values[0][] = $v;
	$values[1][] = $v - $i;
	$values[2][] = rand(100 - ($i+10),100 - 10*$i);
}

// create the chart and define some options
$chart = new GoogleChart('lc', 400, 200);
$chart->setGridLines(10,10);
$chart->setLegendPosition('r');
$chart->setFill('ffffcc');
$chart->setGradientFill(45, array('cccccc', 'ffffff', 'cccccc'), GoogleChart::CHART_AREA);
$chart->setTitle('Us versus the others.');
$chart->setTitleStyle('999999', 20);

// create the first line
$line = new GoogleChartData($values[0]);
$line->setLegend('Us');
$chart->addData($line);

// add markers to this line
$marker = new GoogleChartShapeMarker(GoogleChartShapeMarker::X);
$marker->setData($line);
$marker->setColor('6699cc');
$chart->addMarker($marker);

$marker = new GoogleChartTextMarker(GoogleChartTextMarker::VALUE);
$marker->setData($line);
$chart->addMarker($marker);

// define a dotted line (not displayed in the legend)
$line = new GoogleChartData($values[1]);
$line->setStyle(2,2,2);
$line->setColor('6699cc');
$chart->addData($line);

// define a red line
$line = new GoogleChartData($values[2]);
$line->setLegend('The others');
$line->setColor('ff0000');
$chart->addData($line);

// add markers
$marker = new GoogleChartShapeMarker(GoogleChartShapeMarker::CIRCLE);
$marker->setData($line);
$marker->setColor('ff0000');
$chart->addMarker($marker);

// add axis
$y_axis = new GoogleChartAxis('y');
$chart->addAxis($y_axis);

$x_axis = new GoogleChartAxis('x');
$chart->addAxis($x_axis);

// debug the chart
if ( isset($_GET['debug']) ) {
	var_dump($chart->getQuery());
	echo $chart->validate();
	echo $chart->toHtml();
}
// display the chart
else{
	header('Content-Type: image/png');
	echo $chart;
}

Generated chart (I copy/pasted the generated URL, this is not the actual PHP code):

Requirements and limitations

GoogleChart PHP library works with PHP 5.2 (maybe works with other version as well, I don’t know), and doesn’t require any additional library. It’s released under the MIT license. Current version is 0.3, meaning that a lot of features are unimplemented yet (but otherwise it works fine, believe me ;-). Current major limitations includes :

• Only support Basic Text Format and Text Format with Custom Scaling.
• Only tested with Line Charts, Map Charts and Bar Charts. It’s designed to handle any type though, so with a little bit of luck it might works for other charts as well.

And also, because it’s a side project I do during my spare time, I only implement the features that I need for my other projets, and only when I need them. So if have different needs and you’re willing to help, you’re welcome!

Download and install

GoogleChart PHP library is available for download here: http://redmine.kuerti.net/projects/googlechart/files http://code.google.com/p/googlechartphplib. The archive comes with plenty examples and Doxygen documentation. Just copy the content of the lib folder inside your project.

You can also checkout the latest SVN version here: http://svn.kuerti.net/googlechart/trunk http://googlechartphplib.googlecode.com/svn/trunk/.

Doxygen-generated documentation is available here. This documentation is not always up-to-date nor complete, but I’m working on it, I promise.

Send me feebacks, I love feedbacks

Feedbacks are more than welcome! Feel to send feature requests, bug reports and more here as a comment, or (better) on the project’s Redmine: http://redmine.kuerti.net/projects/googlechart the project homepage in Google Code: http://code.google.com/p/googlechartphplib/. And if you’re a developer and interested on improving it, feel free, it’s open source! Mails are also always welcome at remi at cloudconnected dot fr.

use.tabs.*.yml=0
indent.size.*.yml=2
tab.size.*.yml=2

Ouf !

There are basically three ways to store a tree in a relationnal databases : adjacency list, nested set and materialized path, plus a few more like nested intervals. Let’s put it clear : they all suck.

• Adjacency list model is the one I used the first time (with parent_id column). It’s easy to create but impossible to query deeply without recursivity.
• Nested set model is quite easy to query, but is indeed pretty fucked up (tree is limited in size, very hard to read without maths, almost all the lines of the table need to be updated each time a node is added, moved or deleted!). Nested intervals model tries to remove the size limitation of nested sets model, but involves way to much maths.
• Materialized path is great and easy to understand, but very slow because it involves heavy use of the “LIKE” operator.

More on that here, here and here.

Then I found two very interesting articles. One is a reply on MySQL Forums about materialized path performance problem, recommending an approach based on normalized schema to store paths. The other is an implementation using PostgreSQL by depesz that also use a normalized schema. The point is to create a table dedicated to store all the paths from every nodes to every nodes. This looks to me like a very good approach, as it’s easy to understand, easy to maintain, easy to query and performance-ok (with appropriate indexes). Unfortunalty, the implementation I found relies to much on PostgreSQL and doesn’t work out-of-the-box with MySQL (because of the use of triggers and of some queries that needs to be rewriten). So I reworked it to work with MySQL 5, and changed a few things. I strongly recommend that you read depesz’s post for a complete understanding of the approach before you continue.

Data Model

First, we create a table containing the data, let’s name it data. The parent_id column stores the parent’s ID, like in the traditionnal adjacency list approach, but we’re not going to use it for querying the tree. The value column is whatever you need to store as value for the node, and we’re going to use it for ordering. We use InnoDB as storage engine.

CREATE TABLE data (
	id INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
	parent_id INTEGER UNSIGNED null,
	value VARCHAR(255) NOT NULL,

	PRIMARY KEY (id),

	INDEX data_data_fk (parent_id),
	FOREIGN KEY data_data_fk (parent_id) REFERENCES data (id) ON DELETE CASCADE
) ENGINE = InnoDB;

Then we create the table that will store every paths. A path contains a parent node, a child node, and the number of hops between the two nodes (depth). Each node has at least one entry on that table: the path to itself with a depth egal 0. The path column will hold the materialized path, that will be used for ordering. If you’re absolutely sure that you will never ever need to display your tree in alphabetical order, then you can safely remove this column and remove related queries from triggers.

CREATE TABLE data_tree (
	parent_id INTEGER UNSIGNED NOT NULL,
	child_id INTEGER UNSIGNED NOT NULL,
	depth INTEGER UNSIGNED NOT NULL default 0,
	path TEXT NOT NULL,

	PRIMARY KEY (parent_id, child_id),
	INDEX data_tree_child_depth_idx (child_id, depth),

	INDEX data_tree_parent_data_fk (parent_id),
	FOREIGN KEY data_tree_parent_data_fk (parent_id) REFERENCES data (id) ON DELETE CASCADE,
	INDEX data_tree_child_data_fk (child_id),
	FOREIGN KEY data_tree_child_data_fk (child_id) REFERENCES data (id) ON DELETE CASCADE,
);

Creating a new node

When a node is inserted in the table data, then every path leading to this node has to be inserted in the table data_tree. To achieve this, I use a trigger (MySQL 5 or higher) because it’s safer for the DB’s integrity, but a client side implementation (in PHP or any other langage) will do, as long as you use a transaction.

DELIMITER |
CREATE TRIGGER insert_data
AFTER INSERT ON data
FOR EACH ROW BEGIN
	INSERT INTO data_tree (parent_id, child_id, depth, path)
	VALUES (NEW.id, NEW.id, 0, CONCAT(NEW.value,"/"));

	INSERT INTO data_tree (parent_id, child_id, depth, path)
		SELECT parent_id, NEW.id, depth + 1, CONCAT(path, NEW.value, "/")
		FROM data_tree
		WHERE child_id = NEW.parent_id;
END; |
DELIMITER ;

Updating the tree

First possible update : moving a node. To move a node, we basically have to delete every path between the node’s ancestors (if any) to the node’s childs (if any), and then insert all the new paths. This can be done easily with two queries in a trigger, or again, if you prefer, client side. No big changes from depesz’s post, I only had to rewrite queries for MySQL.

Second possible update : changing a node’s value. This step is optionnal if you decided to drop the path column. When a node’s value is updated, for exemple from “Apinat” to “Banaanit”, then every path including that node value has to be updated as well, otherwise the tree won’t be correctly ordered. This step has to be completly rewriten for MySQL, has the original depesz’s implementation for PostgreSQL uses regexp replacements, which are not supported. Hence I came with a workaround, using only pure string functions to make the replacement.

DELIMITER |
CREATE TRIGGER update_data
AFTER UPDATE ON data
FOR EACH ROW BEGIN
	DECLARE old_path_len INT;
	IF NEW.parent_id != OLD.parent_id OR NEW.parent_id IS NULL OR OLD.parent_id IS NULL THEN
		if OLD.parent_id IS NOT NULL THEN
			DELETE t2
			FROM data_tree t1
			JOIN data_tree t2 ON t1.child_id = t2.child_id
			WHERE t1.parent_id = OLD.id
			AND t2.depth > t1.depth;
		END IF;

		IF NEW.parent_id IS NOT NULL THEN
			INSERT INTO data_tree (parent_id, child_id, depth, path)
				SELECT t1.parent_id, t2.child_id, t1.depth + t2.depth + 1, CONCAT(t1.path, t2.path)
				FROM data_tree t1, data_tree t2
				WHERE t1.child_id = NEW.parent_id
				AND t2.parent_id = OLD.id;
		END IF;
	END IF;

	IF NEW.value != OLD.value THEN
		SELECT CHAR_LENGTH(path) INTO old_path_len
		FROM data_tree
		WHERE child_id = OLD.id
		AND DEPTH = 0;

		IF old_path_len > 0 THEN
			UPDATE data_tree t1
			JOIN data_tree t2 ON t1.child_id = t2.child_id
			SET t2.path = CONCAT(
				SUBSTRING(t2.path, 1, CHAR_LENGTH(t2.path) - CHAR_LENGTH(t1.path)),
				CONCAT(NEW.value, SUBSTRING(t1.path, old_path_len))
			)
			WHERE t1.parent_id = OLD.id
			AND t2.depth >= t1.depth;
		END IF;
	END IF;
END; |
DELIMITER ;

Deleting a node

Thanks to the ON DELETE CASCADE clause, we don’t need to do anything when deleting a node. Beware that every childs will also be deleted from the tree and from the data table.

Examples

Let’s play a little with this implementation.

Populating the tree

mysql> INSERT INTO data (parent_id, value) VALUES (null, 'Heavy metal');
Query OK, 1 row affected (0.00 sec)

mysql> SELECT * FROM data;
+----+-----------+-------------+
| id | parent_id | value       |
+----+-----------+-------------+
|  1 |      NULL | Heavy metal |
+----+-----------+-------------+
1 row in set (0.00 sec)

mysql> SELECT * FROM data_tree;
+-----------+----------+-------+--------------+
| parent_id | child_id | depth | path         |
+-----------+----------+-------+--------------+
|         1 |        1 |     0 | Heavy metal/ |
+-----------+----------+-------+--------------+
1 row in set (0.00 sec)

mysql> INSERT INTO data (parent_id, value) VALUES (1, 'Power metal'), (1, 'Trash metal'), (1, 'Death metal');
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> SELECT * FROM data;
+----+-----------+-------------+
| id | parent_id | value       |
+----+-----------+-------------+
|  1 |      NULL | Heavy metal |
|  2 |         1 | Power metal |
|  3 |         1 | Trash metal |
|  4 |         1 | Death metal |
+----+-----------+-------------+
4 rows in set (0.00 sec)

mysql> SELECT * FROM data_tree;
+-----------+----------+-------+--------------------------+
| parent_id | child_id | depth | path                     |
+-----------+----------+-------+--------------------------+
|         1 |        1 |     0 | Heavy metal/             |
|         1 |        2 |     1 | Heavy metal/Power metal/ |
|         1 |        3 |     1 | Heavy metal/Trash metal/ |
|         1 |        4 |     1 | Heavy metal/Death metal/ |
|         2 |        2 |     0 | Power metal/             |
|         3 |        3 |     0 | Trash metal/             |
|         4 |        4 |     0 | Death metal/             |
+-----------+----------+-------+--------------------------+
7 rows in set (0.00 sec)

mysql> INSERT INTO data (parent_id, value) VALUES (2, 'Symphonic power metal'), (2, 'Extreme power metal'), (4, 'Brutal death metal');
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

mysql> SELECT * FROM data_tree;
+-----------+----------+-------+------------------------------------------------+
| parent_id | child_id | depth | path                                           |
+-----------+----------+-------+------------------------------------------------+
|         1 |        1 |     0 | Heavy metal/                                   |
|         1 |        2 |     1 | Heavy metal/Power metal/                       |
|         1 |        3 |     1 | Heavy metal/Trash metal/                       |
|         1 |        4 |     1 | Heavy metal/Death metal/                       |
|         1 |        5 |     2 | Heavy metal/Power metal/Symphonic power metal/ |
|         1 |        6 |     2 | Heavy metal/Power metal/Extreme power metal/   |
|         1 |        7 |     2 | Heavy metal/Death metal/Brutal death metal/    |
|         2 |        2 |     0 | Power metal/                                   |
|         2 |        5 |     1 | Power metal/Symphonic power metal/             |
|         2 |        6 |     1 | Power metal/Extreme power metal/               |
|         3 |        3 |     0 | Trash metal/                                   |
|         4 |        4 |     0 | Death metal/                                   |
|         4 |        7 |     1 | Death metal/Brutal death metal/                |
|         5 |        5 |     0 | Symphonic power metal/                         |
|         6 |        6 |     0 | Extreme power metal/                           |
|         7 |        7 |     0 | Brutal death metal/                            |
+-----------+----------+-------+------------------------------------------------+
16 rows in set (0.00 sec)

mysql> SELECT * FROM data;
+----+-----------+-----------------------+
| id | parent_id | value                 |
+----+-----------+-----------------------+
|  1 |      NULL | Heavy metal           |
|  2 |         1 | Power metal           |
|  3 |         1 | Trash metal           |
|  4 |         1 | Death metal           |
|  5 |         2 | Symphonic power metal |
|  6 |         2 | Extreme power metal   |
|  7 |         4 | Brutal death metal    |
+----+-----------+-----------------------+
7 rows in set (0.00 sec)

Requesting the tree

First generation of childs FROM “Heavy metal”

mysql> SELECT d.id, d.value
       FROM data_tree t
       JOIN data d ON d.id = t.child_id
       WHERE t.parent_id = 1
       AND depth = 1;
+----+-------------+
| id | value       |
+----+-------------+
|  2 | Power metal |
|  3 | Trash metal |
|  4 | Death metal |
+----+-------------+
3 rows in set (0.00 sec)

Printing the whole tree, ordered

mysql> SELECT CONCAT(REPEAT('-',t.depth), d.value) AS value
       FROM data_tree t
       JOIN data d ON d.id = t.child_id
       WHERE t.parent_id = 1
       ORDER by t.path;
+-------------------------+
| value                   |
+-------------------------+
| Heavy metal             |
| -Death metal            |
| --Brutal death metal    |
| -Power metal            |
| --Extreme power metal   |
| --Symphonic power metal |
| -Trash metal            |
+-------------------------+
7 rows in set (0.00 sec)

Ancestors of “Symphonic power metal”, starting from the root

mysql> SELECT d.id, d.value
       FROM data_tree t
       JOIN data d ON d.id = t.parent_id
       WHERE t.child_id = 5
       ORDER BY depth DESC;
+----+-----------------------+
| id | value                 |
+----+-----------------------+
|  1 | Heavy metal           |
|  2 | Power metal           |
|  5 | Symphonic power metal |
+----+-----------------------+
3 rows in set (0.00 sec)

Updating the tree

Moving a node to another place

Let’s add a Hard rock in our tree, and move Heavy metal as a child of Hard rock.

mysql> INSERT INTO data (parent_id, value) VALUES (null, 'Hard rock');
Query OK, 1 row affected (0.00 sec)

mysql> SELECT * FROM data;
+----+-----------+-----------------------+
| id | parent_id | value                 |
+----+-----------+-----------------------+
|  1 |      NULL | Heavy metal           |
|  2 |         1 | Power metal           |
|  3 |         1 | Trash metal           |
|  4 |         1 | Death metal           |
|  5 |         2 | Symphonic power metal |
|  6 |         2 | Extreme power metal   |
|  7 |         4 | Brutal death metal    |
|  8 |      NULL | Hard rock             |
+----+-----------+-----------------------+
8 rows in set (0.00 sec)

mysql> UPDATE data SET parent_id = 8 WHERE id = 1;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> SELECT * FROM data;
+----+-----------+-----------------------+
| id | parent_id | value                 |
+----+-----------+-----------------------+
|  1 |         8 | Heavy metal           |
|  2 |         1 | Power metal           |
|  3 |         1 | Trash metal           |
|  4 |         1 | Death metal           |
|  5 |         2 | Symphonic power metal |
|  6 |         2 | Extreme power metal   |
|  7 |         4 | Brutal death metal    |
|  8 |      NULL | Hard rock             |
+----+-----------+-----------------------+
8 rows in set (0.00 sec)

mysql> SELECT * FROM data_tree;
+-----------+----------+-------+----------------------------------------------------------+
| parent_id | child_id | depth | path                                                     |
+-----------+----------+-------+----------------------------------------------------------+
|         1 |        1 |     0 | Heavy metal/                                             |
|         1 |        2 |     1 | Heavy metal/Power metal/                                 |
|         1 |        3 |     1 | Heavy metal/Trash metal/                                 |
|         1 |        4 |     1 | Heavy metal/Death metal/                                 |
|         1 |        5 |     2 | Heavy metal/Power metal/Symphonic power metal/           |
|         1 |        6 |     2 | Heavy metal/Power metal/Extreme power metal/             |
|         1 |        7 |     2 | Heavy metal/Death metal/Brutal death metal/              |
|         2 |        2 |     0 | Power metal/                                             |
|         2 |        5 |     1 | Power metal/Symphonic power metal/                       |
|         2 |        6 |     1 | Power metal/Extreme power metal/                         |
|         3 |        3 |     0 | Trash metal/                                             |
|         4 |        4 |     0 | Death metal/                                             |
|         4 |        7 |     1 | Death metal/Brutal death metal/                          |
|         5 |        5 |     0 | Symphonic power metal/                                   |
|         6 |        6 |     0 | Extreme power metal/                                     |
|         7 |        7 |     0 | Brutal death metal/                                      |
|         8 |        1 |     1 | Hard rock/Heavy metal/                                   |
|         8 |        2 |     2 | Hard rock/Heavy metal/Power metal/                       |
|         8 |        3 |     2 | Hard rock/Heavy metal/Trash metal/                       |
|         8 |        4 |     2 | Hard rock/Heavy metal/Death metal/                       |
|         8 |        5 |     3 | Hard rock/Heavy metal/Power metal/Symphonic power metal/ |
|         8 |        6 |     3 | Hard rock/Heavy metal/Power metal/Extreme power metal/   |
|         8 |        7 |     3 | Hard rock/Heavy metal/Death metal/Brutal death metal/    |
|         8 |        8 |     0 | Hard rock/                                               |
+-----------+----------+-------+----------------------------------------------------------+
24 rows in set (0.00 sec)

mysql> SELECT CONCAT(REPEAT('-',t.depth), d.value) AS value
       FROM data_tree t
       JOIN data d ON d.id = t.child_id
       WHERE t.parent_id = 8
       ORDER BY t.path;
+--------------------------+
| value                    |
+--------------------------+
| Hard rock                |
| -Heavy metal             |
| --Death metal            |
| ---Brutal death metal    |
| --Power metal            |
| ---Extreme power metal   |
| ---Symphonic power metal |
| --Trash metal            |
+--------------------------+
8 rows in set (0.00 sec)

Changing a node’s value

Ok, I don’t know why we would do that, but let’s just rename Death metal to ZDeath metal and see what happens.

mysql> UPDATE data SET value = 'ZDeath metal' WHERE id = 4;
Query OK, 1 row affected (0.00 sec)
Rows matched: 1  Changed: 1  Warnings: 0

mysql> SELECT * FROM data_tree;
+-----------+----------+-------+----------------------------------------------------------+
| parent_id | child_id | depth | path                                                     |
+-----------+----------+-------+----------------------------------------------------------+
|         1 |        1 |     0 | Heavy metal/                                             |
|         1 |        2 |     1 | Heavy metal/Power metal/                                 |
|         1 |        3 |     1 | Heavy metal/Trash metal/                                 |
|         1 |        4 |     1 | Heavy metal/ZDeath metal/                                |
|         1 |        5 |     2 | Heavy metal/Power metal/Symphonic power metal/           |
|         1 |        6 |     2 | Heavy metal/Power metal/Extreme power metal/             |
|         1 |        7 |     2 | Heavy metal/ZDeath metal/Brutal death metal/             |
|         2 |        2 |     0 | Power metal/                                             |
|         2 |        5 |     1 | Power metal/Symphonic power metal/                       |
|         2 |        6 |     1 | Power metal/Extreme power metal/                         |
|         3 |        3 |     0 | Trash metal/                                             |
|         4 |        4 |     0 | ZDeath metal/                                            |
|         4 |        7 |     1 | ZDeath metal/Brutal death metal/                         |
|         5 |        5 |     0 | Symphonic power metal/                                   |
|         6 |        6 |     0 | Extreme power metal/                                     |
|         7 |        7 |     0 | Brutal death metal/                                      |
|         8 |        1 |     1 | Hard rock/Heavy metal/                                   |
|         8 |        2 |     2 | Hard rock/Heavy metal/Power metal/                       |
|         8 |        3 |     2 | Hard rock/Heavy metal/Trash metal/                       |
|         8 |        4 |     2 | Hard rock/Heavy metal/ZDeath metal/                      |
|         8 |        5 |     3 | Hard rock/Heavy metal/Power metal/Symphonic power metal/ |
|         8 |        6 |     3 | Hard rock/Heavy metal/Power metal/Extreme power metal/   |
|         8 |        7 |     3 | Hard rock/Heavy metal/ZDeath metal/Brutal death metal/   |
|         8 |        8 |     0 | Hard rock/                                               |
+-----------+----------+-------+----------------------------------------------------------+
24 rows in set (0.00 sec)

mysql> SELECT CONCAT(REPEAT('-',t.depth), d.value) AS value
       FROM data_tree t
       JOIN data d ON d.id = t.child_id
       WHERE t.parent_id = 8
       ORDER by t.path;
+--------------------------+
| value                    |
+--------------------------+
| Hard rock                |
| -Heavy metal             |
| --Power metal            |
| ---Extreme power metal   |
| ---Symphonic power metal |
| --Trash metal            |
| --ZDeath metal           |
| ---Brutal death metal    |
+--------------------------+
8 rows in set (0.00 sec)