A FOREIGN KEY in one table points to a PRIMARY KEY in another table.

A foreign key is a field in a relational table that matches the primary key of another table. The foreign key can be used to cross-reference tables. A table may have multiple foreign keys, and each foreign key can have a different referenced table.

A Foreign Key is a Referential Constraint between two tables. A Referential Constraint or Referential Integrity is a property of data which, when satisfied, requires every value of one attribute (column) of a relation (table) to exist as a value of another attribute in a different (or the same) relation (table).

For MySQL, to support foreign key, the table type should be ‘InnoDB‘. Therefore, when we are cross-referencing two tables through foreign key, both the tables must be InnoDB tables and they must not be Temporary tables.

InnoDB also supports foreign key references within a table. The referencing and referenced table may be the same table, i.e. the foreign key refers back to the same table. Such a foreign key is known as a self-referencing or recursive foreign key.

When the user attempts to delete or update a row from a parent table, and there are one or more matching rows in the child table, InnoDB handles this through “Referential Action“. There are five options regarding the action to be taken. If ON DELETE or ON UPDATE are not specified, the default action is RESTRICT.

CASCADE: Delete or update the row from the parent table and automatically delete or update the matching rows in the child table. Both ON DELETE CASCADE and ON UPDATE CASCADE are supported.

SET NULL: Delete or update the row from the parent table and set the foreign key column or columns in the child table to NULL. This is valid only if the foreign key columns do not have the NOT NULL qualifier specified. Both ON DELETE SET NULL and ON UPDATE SET NULL clauses are supported.

NO ACTION: In standard SQL, NO ACTION means no action in the sense that an attempt to delete or update a primary key value is not permitted to proceed if there is a related foreign key value in the referenced table. InnoDB rejects the delete or update operation for the parent table.

RESTRICT: Rejects the delete or update operation for the parent table. Specifying RESTRICT (or NO ACTION) is the same as omitting the ON DELETE or ON UPDATE clause. The main difference between NO ACTION and RESTRICT is that with NO ACTION the referential integrity check is done after trying to alter the table. RESTRICT does the check before trying to execute the UPDATE or DELETE statement. However, in MySQL, foreign key constraints are checked immediately, so NO ACTION is the same as RESTRICT.

SET DEFAULT: Similar to SET NULL, the foreign key values in the referencing row are set to the column default when the referenced row is updated or deleted. This action is recognized by the parser, but InnoDB rejects table definitions containing ON DELETE SET DEFAULT or ON UPDATE SET DEFAULT clauses.

Here, I will be implementing the foreign key CASCADE update and delete.

CASCADE:-

Whenever rows in the master (referenced) table are deleted, the respective rows of the child (referencing) table with a matching foreign key column will get deleted as well. This is called a cascade delete.

Example Tables: test_customer(customer_id, name, address) and test_order(order_id, customer_id, status)

test_customer is the master table and test_order is the child table, where ‘customer_id’ is the foreign key in test_order and represents the customer who placed the order. When a row of test_customer is deleted, any test_order row matching the deleted test_customer’s customer_id will also be deleted.

Create Tables

CREATE TABLE test_customer (
customer_id int(10) unsigned NOT NULL auto_increment,
name varchar(100),
address varchar(100),
PRIMARY KEY (customer_id)
) ENGINE=InnoDB;

CREATE TABLE test_order (
order_id int(10) unsigned NOT NULL auto_increment,
customer_id int(10) unsigned NOT NULL,
status varchar(30),
PRIMARY KEY (order_id)
) ENGINE=InnoDB;

Add Foreign Key

ALTER TABLE test_order
ADD CONSTRAINT FK_test_order
FOREIGN KEY (customer_id) REFERENCES test_customer(customer_id)
ON UPDATE CASCADE
ON DELETE CASCADE;

Alternative way

Alternatively we can directly add Foreign Key at the time of table creation. You may choose any one way (the following way or the way above) for creating tables and assigning foreign key.

SET foreign_key_checks = 0;

SET foreign_key_checks = 1;

Insert sample data to test_customer and test_order tables

INSERT INTO test_customer
( customer_id , name , address )
VALUES
( '1', 'John', 'New York' ),
( '2', 'Tom', 'London' );

INSERT INTO test_order
( order_id , customer_id , status )
VALUES
( '1', '1', 'pending' ),
( '2', '1', 'processing' ),
( '3', '2', 'complete' ),
( '4', '2', 'pending' );

Doing UPDATE CASCADE

When we update customer_id in test_customer (parent table), the customer_id field in test_order (child table) will also get updated.

UPDATE test_customer SET customer_id = 3 WHERE customer_id = 1;

Note:-

We CANNOT directly update the foreign key in child table.

Doing this will result in error saying “Cannot add or update a child row: a foreign key constraint fails“.

UPDATE test_order SET customer_id = 4 WHERE customer_id = 3;

Doing DELETE CASCADE

When we delete customer_id in test_customer (parent table), the customer_id field in test_order (child table) will also get deleted.

DELETE FROM test_customer WHERE customer_id = 2;

Note:-

We CAN directly delete rows from test_order (child table) like below:-

DELETE FROM test_order WHERE customer_id = 3;

Hope this helps. Thanks

References:-
1. http://dev.mysql.com/doc/refman/5.1/en/innodb-foreign-key-constraints.html
2. http://en.wikipedia.org/wiki/Foreign_key

Related posts:

1. Alter MySQL table to add & drop column & add Foreign Key
2. 10 Very Useful SQL Queries with JOINS
3. Backup and Recovery of MySQL database
4. SQL Error: Cannot insert the value NULL into column… column does not allow nulls. INSERT fails.
5. Magento: How to delete System Attribute?

You have created a custom module.
You have entered certain data in your database.
You need to show the data randomly.

Solution:

In MySQL the rand() function helps the select query to fetch data randomly. In Magento, you can select random rows from MySQL table using Zend_Db_Expr(‘RAND()’).

You have to create a new function in your module’s collection class (YourNamespace/YourModule/Model/Mysql4/YourModule/Collection.php)

public function setRandomOrder()
{
	$this->getSelect()->order(new Zend_Db_Expr('RAND()'));
	return $this;
}

Now, you can fetch random data from your table using the above create setRandomOrder function. The code below can be kept in the block or template (.phtml) file of your module.

$collection = Mage::getModel('yourmodule/yourmodule')
					->getCollection()
					->setRandomOrder();

echo "<pre>"; print_r($collection->getData()); echo "</pre>";

Hope this helps. Thanks.

Related posts:

1. Generating random image
2. Random number, string generation in PHP
3. Magento: Very Useful Collection Functions
4. PHP: Generating Multiple Random String
5. Magento: How to filter product collection using 2 or more category filters?

The JOIN keyword is used in an SQL statement to query data from two or more tables, based on a relationship between certain columns in these tables. [@via w3schools]

A SQL JOIN clause combines records from two or more tables in a database. It creates a set that can be saved as a table or used as is. A JOIN is a means for combining fields from two tables by using values common to each. ANSI standard SQL specifies four types of JOINs: INNER, OUTER, LEFT, and RIGHT. In special cases, a table (base table, view, or joined table) can JOIN to itself in a self-join. [@via wikipedia]

SQL Joins are helpful when we have to fetch data with a single query from two or more database tables.

Case:

I need to store news/article information. The news can also have comments and tags. News can be submitted/posted by multiple users.

According to the above scenario, I have created 5 tables and inserted some data into them :-

news - to store news
comments - to store comments for any particular news
tags - to store tags associated with any particular news
users - to store user information
tags_news – to store relationship between news and tags

–
– Table structure for table `comments`
–

CREATE TABLE `comments` (
`id` bigint(20) NOT NULL auto_increment,
`news_id` bigint(20) NOT NULL,
`user_id` bigint(20) NOT NULL,
`detail` text NOT NULL,
`status` tinyint(1) NOT NULL default '1',
`comment_date` int(11) NOT NULL,
PRIMARY KEY (`id`),
KEY `user_id` (`user_id`),
KEY `news_id` (`news_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;


–
– Dumping data for table `comments`
–

INSERT INTO `comments` (`id`, `news_id`, `user_id`, `detail`, `status`, `comment_date`) VALUES
(1, 1, 2, 'nice post :)', 1, 1273431296),
(2, 2, 2, 'hahaha', 1, 1273431420),
(3, 3, 2, '3123123', 1, 1273431452),
(4, 1, 2, 'thank You', 1, 1273431475),
(5, 2, 1, 'congratulations!', 1, 1273431500);

– ——————————————————–

–
– Table structure for table `news`
–

CREATE TABLE `news` (
`id` bigint(20) NOT NULL auto_increment,
`user_id` bigint(20) NOT NULL,
`title` text NOT NULL,
`detail` text NOT NULL,
`visit` int(11) NOT NULL default '0',
`status` tinyint(1) NOT NULL default '1',
`created_date` int(11) NOT NULL,
PRIMARY KEY (`id`),
KEY `user_id` (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;

–
– Dumping data for table `news`
–

INSERT INTO `news` (`id`, `user_id`, `title`, `detail`, `visit`, `status`, `created_date`) VALUES
(1, 1, 'Extra Content', 'fasdfasdf', 2, 1, 1273431296),
(2, 1, 'My My Question', 'this is jpt question.. :D', 16, 1, 1273431389),
(3, 2, 'Am I ram?', 'I am ram..yahoo !!', 3, 1, 1273431420);

– ——————————————————–

–
– Table structure for table `tags`
–

CREATE TABLE `tags` (
`id` bigint(20) NOT NULL auto_increment,
`name` varchar(255) NOT NULL,
`slug` varchar(255) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;

–
– Dumping data for table `tags`
–

INSERT INTO `tags` (`id`, `name`, `slug`) VALUES
(1, 'sagarmatha', 'sagarmatha'),
(2, 'nepal', 'nepal'),
(3, 'gautam buddha', 'gautam-buddha'),
(4, 'testing', 'testing'),
(5, 'tags', 'tags'),
(6, 'tasty apple', 'tasty-apple'),
(7, 'banana', 'banana');

– ——————————————————–

–
– Table structure for table `tags_news`
–

CREATE TABLE `tags_news` (
`id` bigint(20) NOT NULL auto_increment,
`news_id` bigint(20) NOT NULL,
`tags_id` bigint(20) NOT NULL,
PRIMARY KEY (`id`),
KEY `news_id` (`news_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;

–
– Dumping data for table `tags_news`
–

INSERT INTO `tags_news` (`id`, `news_id`, `tags_id`) VALUES
(1, 1, 1),
(2, 1, 2),
(3, 1, 3),
(4, 2, 4),
(5, 2, 5),
(6, 2, 6),
(7, 3, 6),
(8, 3, 7);

– ——————————————————–

–
– Table structure for table `users`
–

CREATE TABLE `users` (
`id` bigint(20) NOT NULL auto_increment,
`user_id` bigint(20) NOT NULL,
`firstname` varchar(100) NOT NULL,
`lastname` varchar(100) NOT NULL,
PRIMARY KEY (`id`),
KEY `user_id` (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;

–
– Dumping data for table `users`
–

INSERT INTO `users` (`id`, `user_id`, `firstname`, `lastname`) VALUES
(1, 1, 'Mukesh', 'Chapagain'),
(2, 2, 'Christopher', 'Gayle'),
(3, 3, 'Brian', 'Lara');

– ——————————————————–

Now, by using SQL JOINS, I can fetch data from these tables for different conditions and in different ways. Here follows the different SQL Queries with the magical JOIN statements:-

1) SELECT NEWS WITH COMMENTS COUNT FOR EACH NEWS


SELECT n.*, ifnull(c.count,0) AS comment FROM news AS n
LEFT JOIN
(SELECT COUNT(comments.id) AS count, comments.news_id FROM comments GROUP BY comments.news_id) AS c
ON n.id = c.news_id
ORDER BY n.created_date DESC;


2) SELECT NEWS POSTED BY ANY PARTICULAR USER (HERE, user_id = 1)


SELECT n.* FROM news AS n
INNER JOIN
users AS u
ON n.user_id = u.id
WHERE u.id = 1;


3) SELECT NEWS POSTED BY ANY PARTICULAR USER (WITH USER’S FIRSTNAME AND LASTNAME) (HERE, user_id = 1)


SELECT n.*, u.firstname AS firstname, u.lastname AS lastname FROM news AS n
INNER JOIN
users AS u
ON n.user_id = u.id
WHERE u.id = 1;


4) SELECT NEWS POSTED BY ANY PARTICULAR USER (WITH COMMENTS COUNT FOR EACH NEWS) (HERE, user_id = 1)


SELECT n.*, ifnull(c.count,0) AS comment, u.firstname AS firstname, u.lastname AS lastname FROM news AS n
LEFT JOIN
(SELECT COUNT(comments.id) AS count, comments.news_id FROM comments GROUP BY comments.news_id) AS c
ON n.id = c.news_id
INNER JOIN
users AS u
ON n.user_id = u.id
WHERE u.id = 1;


5) SELECT COMMENTS FOR ANY PARTICULAR NEWS (HERE, news_id =1)


SELECT c.* FROM comments AS c
INNER JOIN
news AS n
ON c.news_id = n.id
WHERE c.news_id = 1;


6) SELECT COMMENTS FOR ANY PARTICULAR NEWS (ALONG WITH USER INFORMATION) (HERE, news_id = 1)


SELECT c.*, u.firstname AS firstname, u.lastname AS lastname FROM comments AS c
INNER JOIN
news AS n
ON c.news_id = n.id
INNER JOIN
users AS u
ON c.user_id = u.id
WHERE c.news_id = 1;


7) SELECT TAGS FOR ANY PARTICULAR NEWS (HERE, news_id = 1)


SELECT t.* FROM tags AS t
INNER JOIN
(SELECT tags_news.news_id AS news_id, tags_news.tags_id FROM tags_news WHERE tags_news.news_id = 1) AS tn
ON t.id = tn.tags_id;


8) SELECT NEWS BY TAG NAME (HERE, tag = ‘nepal’)


SELECT n.*, t.name AS tag_name, t.slug AS tag_slug FROM news AS n
INNER JOIN
tags_news as tn
ON n.id = tn.news_id
INNER JOIN tags AS t
ON tn.tags_id = t.id
WHERE t.slug = 'nepal';


9) SELECT NEWS BY TAG NAME (ALONG WITH COMMENTS COUNT) (HERE, tag = ‘nepal’)


SELECT n.*, ifnull(c.count,0) AS comment, t.name AS tag_name, t.slug AS tag_slug, t.id AS tag_id FROM news AS n
INNER JOIN
tags_news AS tn
ON (n.id = tn.news_id)
INNER JOIN tags AS t
ON (tn.tags_id = t.id)
LEFT JOIN
(SELECT COUNT(comments.id) AS count, comments.news_id FROM comments
GROUP BY comments.news_id) AS c
ON n.id = c.news_id
WHERE t.slug = 'nepal'
ORDER BY n.created_date DESC;


10) SELECT TAG CLOUD


SELECT t . * , IFNULL( tq.count, 0 ) AS count
FROM tags AS t
LEFT JOIN (
SELECT COUNT( tags_news.id ) AS count, tags_news.tags_id
FROM tags_news
GROUP BY tags_news.tags_id
) AS tq ON t.id = tq.tags_id
ORDER BY t.name ASC
LIMIT 15;

Hope this helps. And thanks for reading.

Related posts:

1. Magento: Join, filter, select and sort attributes, fields and tables
2. Alter MySQL table to add & drop column & add Foreign Key
3. MySQL Database: Foreign Key Understanding and Implementation
4. Fun with strings in PHP (Part 1)
5. SQL Error: Cannot insert the value NULL into column… column does not allow nulls. INSERT fails.

Cannot insert the value NULL into column ‘SourceId’, table ‘Advisory.dbo.AdvDocSource’; column does not allow nulls. INSERT fails.
The statement has been terminated. The ‘CompanyAdd’ procedure attempted to return a status of NULL, which is not allowed. A status of 0 will be returned instead.
——————————-

This error occurs because the ‘SourceId’ column in my table is primary key and it is set to not null. i.e. it doesn’t allow null entries. And I have not made it auto increment.

For making a table column auto increment:
- Go to server explorer.
- In Column Properties, go to Identity Specification.
- Go to (Is Identity) and make it ‘Yes’ from the selection list.

You are done. You also have the option for Identity Increment and Identity Seed.

The SQL Query is:
CREATE TABLE [yourTableName](SourceID int IDENTITY(1,1) NOT NULL, …

Related posts:

1. Alter MySQL table to add & drop column & add Foreign Key
2. Magento: How to select, insert, update, and delete data?
3. 10 Very Useful SQL Queries with JOINS
4. MySQL Database: Foreign Key Understanding and Implementation
5. Displaying all products and new products listing in column/grid layout – Zen-cart