WEB-NES-BAY » mysql

Using Foriegn Keys in MySql with simple example

WEBNESBAY — Wed, 02 Sep 2009 03:55:11 +0000

Referential integrity is usually implemented through the use of foreign keys. In previous versions the popular open-source RDBMS MySQL did not support foreign keys. However, given the high volume of user interest in this feature, later versions of MySQL implemented support for foreign keys through the InnoDB table engine. Consequently, maintaining referential integrity within the tables that make up a database is significantly simpler.

These are the following criteria to form a table with foriegn keys

1. Both tables must be of the InnoDB table type.
2. The fields used in the foreign key relationship must be indexed.
3. The fields used in the foreign key relationship must be similar in data type.

Lets talk with anexample with foriegn keys with better understanding

The idea here is to link the two tables by the species code, so that only those entries in the zoo table which have a valid species code in the species table are accepted and saved to the database.

mysql> CREATE TABLE Fruits (id TINYINT NOT NULL AUTO_INCREMENT,
name VARCHAR(50) NOT NULL, PRIMARY KEY(id)) ENGINE=INNODB;
Query OK, 0 rows affected (0.11 sec)

mysql> INSERT INTO Fruits VALUES (1, ‘orange’), (2, ‘apple’),
(3, ‘banana’), (4, ‘grapes’);
Query OK, 4 rows affected (0.06 sec)
Records: 4 Duplicates: 0 Warnings: 0

mysql> CREATE TABLE basket (
id INT(4) NOT NULL,
name VARCHAR(50) NOT NULL,
FK_Fruits TINYINT(4) NOT NULL,
INDEX (FK_Fruits),
FOREIGN KEY (FK_Fruits) REFERENCES Fruits (id),
PRIMARY KEY(id)
) ENGINE=INNODB;

Important: For non-InnoDB tables, the FOREIGN KEY clause is ignored.

As the above illustrates, a foreign key relationship now exists between the basket.species and Fruits.id. An entry in the basket table will be permitted only if the corresponding Basket.fruits field matches a value in the fruits.idfield. This is clearly visible in the following output, which demonstrates what happens when you attempt to enter a record for Orrange with an invalid Fruits code:

mysql> INSERT INTO Basket VALUES (1, ‘Orrange’, 5);
ERROR 1216 (23000): Cannot add or update a child row: a foreign key
constraint fails

Here, MySQL checks the Fruist table to see if the Fruits code exists and, finding that it does not, rejects the record. Contrast this with what happens when you enter the same record with a valid Fruits code (one that already exists in the Fruits table):

mysql> INSERT INTO basket VALUES (1, ‘Orrange’, 3);
Query OK, 1 row affected (0.06 sec)

Here, MySQL checks the Fruits table to see if the Fruits code exists and, finding that it does, permits the record to be saved to the basket table.

Adding and deleting a foriegn Key

To delete a foreign key relationship, first use the SHOW CREATE TABLE command to find out InnoDB’s internal label for the field.

+——-+—————————————————+
| Table | Create Table |
+——-+—————————————————+
| zoo | CREATE TABLE `basket` (
`id` int(4) NOT NULL default ‘0′,
`name` varchar(50) NOT NULL default ”,
`FK_Fruits` tinyint(4) NOT NULL default ‘0′,
KEY `FK_Fruits` (`FK_Fruits`),
CONSTRAINT `basket_ibfk_1` FOREIGN KEY (`FK_Fruits`)
REFERENCES `Fruits` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1 |
+——-+—————————————————-+

And then use the ALTER TABLE command with the DROP FOREIGN KEY clause, as below:

mysql> ALTER TABLE basket DROP FOREIGN KEY basket_ibfk_1;
Query OK, 1 row affected (0.11 sec)
Records: 1 Duplicates: 0 Warnings: 0

To add a foreign key to an existing table, use the ALTER TABLE command with an ADD FOREIGN KEY clause to define the appropriate field as a foreign key:

mysql> ALTER TABLE basket ADD FOREIGN KEY
(FK_Fruits) REFERENCES Fruits (id);
Query OK, 1 rows affected (0.11 sec)
Records: 1 Duplicates: 0 Warnings: 0

From the above example, foriegn key plays a mojot role in handling the data errors in the run time. Also this is also help ful in handling the data redundancy.

Please post your comments if you have any queries.

Refernce: dev.mysql.com

Oracle Owns MySQL, But This Is Open Source Code

WEBNESBAY — Mon, 29 Jun 2009 06:26:05 +0000

Oracle and MySQL are the favorite databases of developers who use the Eclipse open source programmers workbench. That’s no surprise, I thought. Developers like to develop in free MySQL and deploy in Oracle, right? Actually, Oracle and MySQL are their two favorite deployment databases, contrary to what I would have expected.

Not only are Eclipse users deploying both MySQL and Oracle, they’re deploying the two equally, while I would have given an advantage to Oracle.

Instead, the edge goes to MySQL. The Eclipse site survey showed that 27.7% deploy in MySQL; 27.3% in Oracle. In acquiring MySQL’s new owner, Sun, Oracle is also acquiring its own largest database competitor in the enterprise Java community. Oracle plus MySQL add up to 55% of deployments among the Eclipse users.

There’s two arguments against taking the 55% too seriously.

As you look at database deployments among the larger companies in this sample, the MySQL share drops and Oracle’s dominant share of newly deployed databases is weakened–though by less than I would have thought–by the presence of IBM. IBM’s DB2 goes from 6.2% of all users to 10.7% among the larger users. But that’s still less than 11% in the face of Oracle being deployed among 33.5% of this group, with MySQL being deployed by another 11.6%. Oracle’s combined share among larger Eclipse users is 45.1%.

Another argument against worrying that 55% is too much, however, is that MySQL remains open source code, a fact that’s hard to reverse. If current MySQL users don’t like what’s happening with the code, they can form a new MySQL project and back it.

That means, I think, that MySQL developers are a prize that Oracle will soon start angling for. I don’t think Oracle is likely to disturb MySQL’s existing code direction, though I question how willing it will be to encourage it to become a full fledged, transaction database, something that it isn’t now. MySQL founder Monty Widenius wants to see it go in that direction and left Sun to push the MariaDB, a version of MySQL capable of storing transactions.

He’s also founded the Open Database Alliance, a watchdog meant to safeguard the core MySQL system in the face of “uncertainties” over its second round of new ownership.

There’s both drama and comedy in this. If the original authors of MySQL were so concerned about its future, why did they agree to sell to Sun in the first place? Having cashed Sun’s check, can they still claim moral authority over the code? I doubt it, but this is open source and we are untested ground. I may wake up some morning and find that Monty does indeed still own a significant share of MySQL, even though it’s passed into the hands of new owners twice.

So what will Oracle do with MySQL under the watchful gaze of the Open Database Alliance?

My suspicion is that Oracle will keep its hands off, so much so that MySQL may suffer from benign neglect. Who’s to know if MySQL developers get reassigned within that 40,000 developer stable to redoing PeopleSoft applications or cobbling together code in Oracle middleware’s vasty keep? MySQL salesmen might be informed they’re too specialized now that they’re inside Oracle and be given a broader product list to sell. Not doing so well with Oracle 11g or Fusion middleware? Who will protest if their ranks thin out?

What exactly can the Open Database Alliance do about benign neglect, if it occurs?

Meanwhile, Oracle could boast of having MySQL uppermost in its thoughts as it brings out development tools, designed to work with either Oracle or MySQL. In its heart of hearts, it will hope to convert some MySQL users to Oracle in the future by making it easy to make the switch, but it doesn’t have to declare it on day one.

These tools might be provisioned to generate linkages to Oracle middleware, so that the Fusion product set could be used easily with either MySQL or Oracle databases. Even if the MySQL users never convert to 11g, getting 55% of the middleware market isn’t all bad as a consolation prize.

But the Eclipse survey makes me think that there are implications to Oracle’s ownership of MySQL that I hadn’t considered before. What’s the responsibility of an open source code owner? Is it obligated to honor previous initiatives that might bring the code into more direct competition with its own products?

And who owns open source code, a question that can’t be answered by simply examining who’s signing the checks. For the ownership to be honored, the community using the code has to recognize the leadership of the owner. If Oracle aggressively snipped off MySQL’s next round of improvements, I think it’s possible that ownership would transfer outside of Oracle to a new project, as the code forked.

Before, Widenius was a gifted programmer, a trusted figure to hundreds of thousands of MySQL users and pure of heart in his respect for the code, whether it was being handled by an independent MySQL AB or inside of Sun. Now he has a significant share of Sun’s $1 billion check in his pocket, which only makes him more dangerous, from Oracle’s point of view.

The Eclipse survey convinces me that MySQL is a significant asset that can be won or lost by any of its recent or current owners. It is open source code inside a large, proprietary company. Whatever you thought the rules of business were, be prepared to rewrite them as this drama unfolds.