I want to share with some of you an easy way to set up your database design in a very flexible and reliable EAV like model.

EAV stands for Entity Attribute Value, which is a common design for complex database structures that require many different Entities using many different attributes with, again, many different values. It's very common to find this set up in medical offices or records.

Let's go ahead and assume a situation, and we'll work through it.

Let's say you're accepting a feed of some sort, and you need to save the items being fed to you into a database. The problem here, is that the content length of these items, attributes, and values varies.

So let's consider the following:

Item 'Node1' ->
	Attribute 'Main' ->
		Value 1
		Value 2
		Value 3
		Value 4
Item 'Node2' ->
	Attribute 'Main' ->
		Value 1
		Value 2
		Value 3
		Value 4
	Attribute 'Other' ->
		Value 1
		Value 2

Item 'Node3' ->
	Attribute 'Main' ->
		Value 1
		Value 2
		Value 3
		Value 4
		Value 5
		Value 6
		Value 7
		Value 8

Now this is a very cheap and generic example of a data structure. But we'll work with it for now.

So let's go ahead and draw some conclusions.

The Item list will come in with a name, and have Attributes. These attributes will have values. But the number of attributes and the number of values varies.

So with that in mind, we shall come up with some SQL to create some times. For this example we're going to need three tables: items, item_attributes, and attribute_values.

So here we go:

-- first our items table:
CREATE TABLE `items` (
`id` int(11) NOT NULL auto_increment,
`item_name` varchar(50) default NULL,
PRIMARY KEY  (`id`)
);

-- now our item attributes
CREATE TABLE  `item_attributes` (
`id` int(11) NOT NULL auto_increment,
`item_id` int(11) NOT NULL default '0',
`attribute_name` varchar(50) default NULL,
PRIMARY KEY  (`id`),
KEY `item_id_attribute_name` (`item_id`,`attribute_name`)
);

-- now finally our attribute values
CREATE TABLE  `attribute_values` (
`attribute_id` int(11) NOT NULL default '0',
`attribute_value` varchar(100) default NULL,
UNIQUE KEY `attribute_id` (`attribute_id`,`attribute_value`)
);

Now that we have our layout, let's take a look at how this is going to work:

Let's assume the following PHP array is a reprentation of our data...

<?php

// start up our array
$data = array();
//
// Now, let's just load it with some test data
$data['item_1'] = array();
$data['item_1']['attribute_1'] = array();
$data['item_1']['attribute_1'][] = 'value1';
$data['item_1']['attribute_1'][] = 'value2';
$data['item_1']['attribute_1'][] = 'value3';
$data['item_1']['attribute_1'][] = 'value4';
// that's good for now.

/**
* Now let's insert this int our new schema
*
* Please note, for example sake, I will not be double checking queries
* but you SHOULD check each query for an error.
**/

foreach($data as $item_name => $attributes)
{
	$sql = "INSERT INTO items (id, item_name) VALUES (NULL, '{$item_name}');";
	mysql_query($sql);
	$item_id = mysql_insert_id();
	// now let's loop through our attributes
	foreach($attributes as $attribute => $values)
	{
		// this is now our insert into the attributes...
		$sql = "INSERT INTO item_attributes (id, item_id, attribute_name) VALUES (NULL, {$item_id}, '{$attribute}');";
		mysql_query($sql);
		$attribute_id = mysql_insert_id();
		// now let's loop through the attribute values
		foreach($values as $value)
		{
			$sql = "INSERT INTO attribute_values (attribute_id, attribute_value) VALUES ({$attribute_id}, '{$value}');";
			mysql_query($sql);
		}
	}
}
?>

And there you have it - that's now how we can get our data into our database in a flexiable manner, without having to rely
on an 'excel' like database.

To get it out, we'll simply use some joins...

$sql =
	"SELECT
			items.item_name,
			ia.attribute_name,
			av.attribute_value
	 FROM
			attribute_values AS av
		JOIN item_attributes AS ia
			ON (ia.id = av.attribute_id)
		JOIN items AS items
			ON (items.id = ia.item_id);
	";

You could also use a concat_ws to make a comma seperated list, but now that you have it in your database, you can do anything you want with it

I've seen people respond with some seriously incorrect solutions, such as 'Simply load all of the results into an array and only show X amount' or 'Simple run another query without the LIMIT clause and count those rows.'

Those two, common, solutions are sadly not the best solution.

Read on to discover my solution.

Take for example the following query:

$sql = "SELECT id as id, name as name, full_title as title FROM articles ORDER BY id LIMIT 0,10";

Now, that looks all fine and dandy, you have probably used something very similar to that query many times. Now, say we want to actually show how many articles we have in our database?

We would simply change that query to:


$sql = "SELECT SQL_CALC_FOUND_ROWS id as id, name as name, full_title as title FROM articles ORDER BY id LIMIT 0,10";
$get = mysql_query($sql) or die(mysql_error());
$sql_2 = "SELECT FOUND_ROWS();";
$found_rows = mysql_query($sql_2) or die(mysql_error());


Now yes, we're running two queries, but we're not actually queries against any rows. So therefore, this solution is more elegant and ultimately more important, it's not attempting to scan any tables for data.

So next time you're looking to do a quick and pagination script, go ahead and try this technique out.

All too often I see on IRC & Forums people complaining/asking for help, regarding their mysql_query(). "It was working fine yesterday, now it''s broken." "Can someone tell me why this doesn''t work?" "Why doesn''t this work? It just doesn''t do anything."

People, you need to check for errors when you run a query. This is generally done like so:


$get = mysql_query($sql) or die (mysql_error());


Now, that in itself is rather simple to understand. If there are any error's with your query ($sql), your script will die() and tell you the error.

An even better implementation of this would be:


if(!$get = mysql_query($sql)) {
die("Get query evaluated to false. SQL : {$sql} MySQL Error: ".mysql_error());
}


Now, this is great for debugging purposes. It won't really fly on a live front end site. So you'd swap out the die() with:


if(!$get = mysql_query($sql)) {
error_log("Get query evaulted to false. SQL : {$sql} - MySQL Error: ".mysql_error());
} else {
/* Continue on with logic that relies upon this query */
}


Now, what happens is if your query failed, you will get an error_log message, and you do check your error logs? Right? Of course! I thought so.
Also, this ensures that only after we know our query was successful do we continue on with our logic that relies upon it.