1. Inserting New Breadcrumb

   CREATE PROCEDURE [dbo].[addnewbreadcrumb]
     @PageTitleParent AS VARCHAR(100),
   	@PageTitle AS VARCHAR(100),
   	@PageURL AS VARCHAR(100)
   AS
   BEGIN
   DECLARE @ParentLevel INTEGER;
   DECLARE @RecCount INTEGER;
   DECLARE @CheckRecCount INTEGER;
   DECLARE @MyPageTitle VARCHAR(100);
     -- routine body goes here, e.g.
   SET @ParentLevel = (SELECT Rgt FROM [dbo].[breadcrumblinks] WHERE 
   Page_Title = @PageTitleParent);
    
   SET @CheckRecCount = (SELECT COUNT(*) AS RecordCount FROM [dbo].[breadcrumblinks] WHERE 
   Page_Title = @PageTitle);
   	IF @CheckRecCount > 0
     BEGIN 
   		SET @MyPageTitle = 'The following Page_Title is already exists in database: ' +  @PageTitle;
   		SELECT @MyPageTitle;
   		GOTO GoodBye;
     END
    
    
   UPDATE [dbo].[breadcrumblinks] 
      SET Lft = CASE WHEN Lft > @ParentLevel THEN
         Lft + 2
       ELSE
         Lft + 0
       END,
      Rgt = CASE WHEN Rgt >= @ParentLevel THEN
         Rgt + 2
      ELSE
         Rgt + 0
      END
   WHERE  Rgt >= @ParentLevel;
    
   SET @RecCount = (SELECT COUNT(*) FROM [dbo].[breadcrumblinks]);
   	IF @RecCount = 0
       BEGIN
   		-- this is for handling the first record
   		INSERT INTO [dbo].[breadcrumblinks] (Page_Title, Page_URL, Lft, Rgt)
   					VALUES (@PageTitle, @PageURL, 1, 2);
   		END
   	ELSE
       BEGIN
   		-- whereas the following is for the second record, and so forth!
   		INSERT INTO [dbo].[breadcrumblinks] (Page_Title, Page_URL, Lft, Rgt)
   					VALUES (@PageTitle, @PageURL, @ParentLevel, (@ParentLevel + 1));
    
   	  END
    
     GoodBye:
    
   END
   GO

2. Removing or Deleting Breadcrumb

   CREATE PROCEDURE [dbo].[deletebreadcrumbbasedonpagetitle]
     @PageTitle AS VARCHAR(100)
   AS
   BEGIN
    
   DECLARE @DeletedPageTitle VARCHAR(100);
   DECLARE @DeletedLft INTEGER;
   DECLARE @DeletedRgt INTEGER;
    
   SELECT @DeletedPageTitle=Page_Title, @DeletedLft=Lft, @DeletedRgt=Rgt
   FROM   [dbo].[breadcrumblinks] 
   WHERE  Page_Title = @PageTitle;
    
   DELETE FROM [dbo].[breadcrumblinks]
   WHERE Lft BETWEEN @DeletedLft AND @DeletedRgt;
    
   UPDATE [dbo].[breadcrumblinks]
      SET Lft = CASE WHEN Lft > @DeletedLft THEN
                Lft - (@DeletedRgt - @DeletedLft + 1)
             ELSE
                Lft
             END,
          Rgt = CASE WHEN Rgt > @DeletedLft THEN
                Rgt - (@DeletedRgt - @DeletedLft + 1)
             ELSE
                Rgt
             END
      WHERE Lft > @DeletedLft
         OR Rgt > @DeletedLft;
   END
   GO

3. Moving Breadcrumb to Another Parent

   CREATE PROCEDURE [dbo].[movebreadcrumb]
     @CurrentRoot AS VARCHAR(100),
   	@NewParent AS VARCHAR(100)
   AS
   BEGIN
     -- routine body goes here, e.g.
     DECLARE @Origin_Lft INTEGER;
   	DECLARE @Origin_Rgt INTEGER;
   	DECLARE @NewParent_Rgt INTEGER;
    
   SELECT @Origin_Lft=Lft, @Origin_Rgt=Rgt
   	FROM [dbo].breadcrumblinks 
   	WHERE Page_Title = @CurrentRoot;
   SET @NewParent_Rgt = (SELECT Rgt FROM [dbo].breadcrumblinks
   	WHERE Page_Title = @NewParent);
   UPDATE [dbo].breadcrumblinks 
   	SET Lft = Lft + 
   	CASE
   		WHEN @NewParent_Rgt < @Origin_Lft
   			THEN CASE
   				WHEN Lft BETWEEN @Origin_Lft AND @Origin_Rgt
   					THEN @NewParent_Rgt - @Origin_Lft
   				WHEN Lft BETWEEN @NewParent_Rgt	AND @Origin_Lft - 1
   					THEN @Origin_Rgt - @Origin_Lft + 1
   				ELSE 0 END
   		WHEN @NewParent_Rgt > @Origin_Rgt
   			THEN CASE
   				WHEN Lft BETWEEN @Origin_Lft	AND @Origin_Rgt
   					THEN @NewParent_Rgt - @Origin_Rgt - 1
   				WHEN Lft BETWEEN @Origin_Rgt + 1 AND @NewParent_Rgt - 1
   					THEN @Origin_Lft - @Origin_Rgt - 1
   				ELSE 0 END
   			ELSE 0 END,
   	Rgt = Rgt + 
   	CASE
   		WHEN @NewParent_Rgt < @Origin_Lft
   			THEN CASE
   		WHEN Rgt BETWEEN @Origin_Lft AND @Origin_Rgt
   			THEN @NewParent_Rgt - @Origin_Lft
   		WHEN Rgt BETWEEN @NewParent_Rgt AND @Origin_Lft - 1
   			THEN @Origin_Rgt - @Origin_Lft + 1
   		ELSE 0 END
   		WHEN @NewParent_Rgt > @Origin_Rgt
   			THEN CASE
   				WHEN Rgt BETWEEN @Origin_Lft AND @Origin_Rgt
   					THEN @NewParent_Rgt - @Origin_Rgt - 1
   				WHEN Rgt BETWEEN @Origin_Rgt + 1	AND @NewParent_Rgt - 1
   					THEN @Origin_Lft - @Origin_Rgt - 1
   				ELSE 0 END
   			ELSE 0 END;
    
   END
   GO

Hope it helps!

Some of the advantages of this Nested Set Data Model are:

1. You can create unlimited levels and it only needs one query to get all the related path.
2. Since it only need one query, then it is faster to get and display the full path.
3. It is easy to manage the records (inserting, deleting, and moving record). We will focus on this item in this article using MySQL database.

The only one disadvantage of this model is it is more complex than the others. You have to be careful to manage all of the records (inserting, deleting, and moving), otherwise you will break all of the breadcrumb records!

I came across the following article: Using the Nested Set Data Model for Breadcrumb Links and I think this is the smartest way how you can create the independent breadcrumb for any websites which have not implemented it. Since that article only explained how to add and delete a row (breadcrumb), but had not explained more detail how can you move the certain breadcrumb from the current position to the new parent, then in this article I wrote, I will try to explain you step by step, how you can create the Stored Procedures in MySQL for inserting new breadcrumb, deleting breadcrumbs based on their parent, and also: Moving the Breadcrumb from the current location to the new parent. This will be helpful to manage your breadcrumb easily and quickly especially if the current location has many breadcrumb childs. If you do not handle this carefully then you will destroy all of your breadcrumb records in your table.

1. Creating Table for Breadcrumb

   First of all, let’s create a table which we will use to store all the breadcrumb records using the following SQL query:

   CREATE TABLE `breadcrumblinks` (
     `Page_Title` VARCHAR(100) NOT NULL,
     `Page_URL` VARCHAR(100) NOT NULL,
     `Lft` int(4) NOT NULL,
     `Rgt` int(4) NOT NULL,
     PRIMARY KEY (`Page_Title`)
   ) ENGINE=MyISAM DEFAULT CHARSET=utf8;

2. Inserting New Breadcrumb

   Now let’s create a Stored Procedure for adding a new record to your breadcrumblinks table above:

   CREATE PROCEDURE `addnewbreadcrumb`(IN PageTitleParent VARCHAR(100), 
                                       PageTitle VARCHAR(100), 
                                       PageURL VARCHAR(100))
   GoodBye: BEGIN
   -- Need three parameters (PageTitleParent, PageTitle, and PageURL), 
   -- look at this line --> `Page_Title` = PageTitleParent);
   -- look at this line --> VALUES (PageTitle, PageURL, ParentLevel, (ParentLevel + 1));
   DECLARE ParentLevel INTEGER;
   DECLARE RecCount INTEGER;
   DECLARE CheckRecCount INTEGER;
   DECLARE MyPageTitle VARCHAR(100);
    
   SET ParentLevel = (SELECT Rgt FROM `breadcrumblinks` WHERE 
   `Page_Title` = PageTitleParent);
    
   SET CheckRecCount = (SELECT COUNT(*) AS RecCount FROM `breadcrumblinks` WHERE 
   `Page_Title` = PageTitle);
   	IF CheckRecCount > 0 THEN
   		SET MyPageTitle = CONCAT("The following Page_Title is already exists in database: ", PageTitle);
   		SELECT MyPageTitle;
   		LEAVE GoodBye;
     END IF;
    
   UPDATE `breadcrumblinks`
      SET Lft = CASE WHEN Lft > ParentLevel THEN
         Lft + 2
       ELSE
         Lft + 0
       END,
      Rgt = CASE WHEN Rgt >= ParentLevel THEN
         Rgt + 2
      ELSE
         Rgt + 0
      END
   WHERE  Rgt >= ParentLevel;
    
   SET RecCount = (SELECT COUNT(*) FROM `breadcrumblinks`);
   	IF RecCount = 0 THEN
   		-- this is for handling the first record
   		INSERT INTO `breadcrumblinks` (Page_Title, Page_URL, Lft, Rgt)
   					VALUES (PageTitle, PageURL, 1, 2);
   	ELSE
   		-- whereas the following is for the second record, and so forth!
   		INSERT INTO `breadcrumblinks` (Page_Title, Page_URL, Lft, Rgt)
   					VALUES (PageTitle, PageURL, ParentLevel, (ParentLevel + 1));
   	END IF;
    
   END

   Now let’s discuss that Stored Procedure (SP) above:
   Look at this following line:

   CREATE PROCEDURE `addnewbreadcrumb`(IN PageTitleParent VARCHAR(100), 
                                       PageTitle VARCHAR(100), 
                                       PageURL VARCHAR(100))

   We see that this SP has a name: addnewbreadcrumb, and it needs three parameters.
   They are:
   - PageTitleParent: This parameter is the page title parent of your new breadcrumb,
   - PageTitle: This parameter is the page title of your new breadcrumb,
   - PageURL: This parameter is the page URL of your new breadcrumb.

   Here is how we can keep the ParentLevel value based on the PageTitleParent parameter using this following SQL:

   SET ParentLevel = (SELECT Rgt FROM `breadcrumblinks` WHERE 
   `Page_Title` = PageTitleParent);

   Before we add a new breadcrumb record, let’s check to the table whether the new record that we will insert has already exists or not using this following code (this is important in order to avoid the summing up the value of Lft and Rgt of the breadcrumb):

   SET CheckRecCount = (SELECT COUNT(*) AS RecCount FROM `breadcru.mblinks` WHERE 
   `Page_Title` = PageTitle);
   	IF CheckRecCount > 0 THEN
   		SET MyPageTitle = CONCAT("The following Page_Title is already exists in database: ", PageTitle);
   		SELECT MyPageTitle;
   		LEAVE GoodBye;
     END IF;

   That code will tell us, if the record already exists, then display the custom message: “The following Page_Title is already exists in database: {ThePageTitle}”, and then exit from that SP by jumping to GoodBye label before the BEGIN statement above.

   The rest of that code is for adding the new breadcrumb. Important to know, that I added the special handling for adding the first record if the table is still empty, and also for adding the second record and so forth. Please look at the following code:

   SET RecCount = (SELECT COUNT(*) FROM `breadcrumblinks`);
   	IF RecCount = 0 THEN
   		-- this is for handling the first record
   		INSERT INTO `breadcrumblinks` (Page_Title, Page_URL, Lft, Rgt)
   					VALUES (PageTitle, PageURL, 1, 2);
   	ELSE
   		-- whereas the following is for the second record, and so forth!
   		INSERT INTO `breadcrumblinks` (Page_Title, Page_URL, Lft, Rgt)
   					VALUES (PageTitle, PageURL, ParentLevel, (ParentLevel + 1));
   	END IF;

   So, if you want to add your new breadcrumb record, simply execute this addnewbreadcrumb SP.

3. Removing or Deleting Breadcrumb

   Now let’s create another SP for deleting the certain breadcrumb based on the given PageTitle parameter. This SP only needs one parameter (PageTitle):

   CREATE PROCEDURE `deletebreadcrumbbasedonpagetitle` (IN `PageTitle` VARCHAR(100))
   BEGIN
   -- Need one parameter (PageTitle), look at the line: WHERE  Page_Title = PageTitle;
   DECLARE DeletedPageTitle VARCHAR(100);
   DECLARE DeletedLft INTEGER;
   DECLARE DeletedRgt INTEGER;
    
   SELECT `Page_Title`, `Lft`, `Rgt`
   INTO   DeletedPageTitle, DeletedLft, DeletedRgt
   FROM   `breadcrumblinks`
   WHERE `Page_Title` = PageTitle;
    
   DELETE FROM `breadcrumblinks`
   WHERE Lft BETWEEN DeletedLft AND DeletedRgt;
    
   UPDATE `breadcrumblinks`
      SET Lft = CASE WHEN Lft > DeletedLft THEN
                Lft - (DeletedRgt - DeletedLft + 1)
             ELSE
                Lft
             END,
          Rgt = CASE WHEN Rgt > DeletedLft THEN
                Rgt - (DeletedRgt - DeletedLft + 1)
             ELSE
                Rgt
             END
      WHERE Lft > DeletedLft
         OR Rgt > DeletedLft;
   END

   If you want to remove or delete the certain breadcrumb record, simply execute this deletebreadcrumbbasedonpagetitle SP.

4. Moving Breadcrumb to Another Parent

   So far we have already had the 2 SPs for inserting and deleting breadcrumb records. How about moving breadcrumb? Good question! Now the most important thing that we have to handle is how we can move the certain breadcrumb from the current position to the new parent. This is very important, especially if you want to move the certain breadcrumb which have so many childs beneath it. So we will create the third SP as following:

   CREATE PROCEDURE `movebreadcrumb`(IN CurrentRoot VARCHAR(100), IN NewParent VARCHAR(100))
   BEGIN
   -- Need two parameters: (1) CurrentRoot, and (2) NewParent.
   DECLARE Origin_Lft INTEGER;
   DECLARE Origin_Rgt INTEGER;
   DECLARE NewParent_Rgt INTEGER;
    
   SELECT `Lft`, `Rgt`
   	INTO Origin_Lft, Origin_Rgt
   	FROM `breadcrumblinks`
   	WHERE `Page_Title` = CurrentRoot;
   SET NewParent_Rgt = (SELECT `Rgt` FROM `breadcrumblinks`
   	WHERE `Page_Title` = NewParent);
   UPDATE `breadcrumblinks` 
   	SET `Lft` = `Lft` + 
   	CASE
   		WHEN NewParent_Rgt < Origin_Lft
   			THEN CASE
   				WHEN Lft BETWEEN Origin_Lft AND Origin_Rgt
   					THEN NewParent_Rgt - Origin_Lft
   				WHEN Lft BETWEEN NewParent_Rgt	AND Origin_Lft - 1
   					THEN Origin_Rgt - Origin_Lft + 1
   				ELSE 0 END
   		WHEN NewParent_Rgt > Origin_Rgt
   			THEN CASE
   				WHEN Lft BETWEEN Origin_Lft	AND Origin_Rgt
   					THEN NewParent_Rgt - Origin_Rgt - 1
   				WHEN Lft BETWEEN Origin_Rgt + 1 AND NewParent_Rgt - 1
   					THEN Origin_Lft - Origin_Rgt - 1
   				ELSE 0 END
   			ELSE 0 END,
   	Rgt = Rgt + 
   	CASE
   		WHEN NewParent_Rgt < Origin_Lft
   			THEN CASE
   		WHEN Rgt BETWEEN Origin_Lft AND Origin_Rgt
   			THEN NewParent_Rgt - Origin_Lft
   		WHEN Rgt BETWEEN NewParent_Rgt AND Origin_Lft - 1
   			THEN Origin_Rgt - Origin_Lft + 1
   		ELSE 0 END
   		WHEN NewParent_Rgt > Origin_Rgt
   			THEN CASE
   				WHEN Rgt BETWEEN Origin_Lft AND Origin_Rgt
   					THEN NewParent_Rgt - Origin_Rgt - 1
   				WHEN Rgt BETWEEN Origin_Rgt + 1	AND NewParent_Rgt - 1
   					THEN Origin_Lft - Origin_Rgt - 1
   				ELSE 0 END
   			ELSE 0 END;
   END

   You will see that this SP needs two parameter as you can see from this following line:

   CREATE PROCEDURE `movebreadcrumb`(IN CurrentRoot VARCHAR(100), IN NewParent VARCHAR(100))

   They are:
   - CurrentRoot: This is the name of the current page title that you want to move.
   - NewParent: This is the name of the page title where the CurrentRoot will be moved to. In other words, this is the new parent page title where the CurrentRoot will be located after the moving process is successfully done.

   If you want to move the certain breadcrumb record, simply execute this movebreadcrumb SP.

5. Retrieving Breadcrumb

   As I mentioned above, you only need one query to get the full path of the certain given page.
   Here is one of the example of the code how you can retrieve the certain breadcrumb of the (e.g) ‘Statistik per Jam’ page:

   SELECT C.* FROM `breadcrumblinks` AS B, `breadcrumblinks` AS C
   WHERE (B.Lft BETWEEN C.Lft AND C.Rgt)
   AND (B.Page_Title = 'Statistik per Jam')
   ORDER BY C.Lft;

For example, you have a table named table1 which has the structure like this:

mysql> DESCRIBE `table1`;
+-------------+-------------+------+-----+---------+-------+
| Field       | Type        | Null | Key | Default | Extra |
+-------------+-------------+------+-----+---------+-------+
| code        | char(2)     | YES  |     |         |       |
| description | varchar(50) | YES  |     | NULL    |       |
+-------------+-------------+------+-----+---------+-------+

and it has the duplicate records as following:

mysql> select * from table1;
+------+-------------+
| code | description |
+------+-------------+
| 1    | One         |
| 1    | One         |
| 2    | Two         |
| 2    | Two         |
| 3    | Three       |
| 3    | Three       |
| 3    | Three       |
| 4    | Four        |
| 4    | Four        |
| 4    | Four        |
| 4    | Four        |
| 5    | Five        |
| 5    | Five        |
| 5    | Five        |
| 5    | Five        |
| 5    | Five        |
+------+-------------+

Let’s say, you want to delete and leave only one record from each the duplicate records. So the results become like this:

+------+-------------+
| code | description |
+------+-------------+
| 1    | One         |
| 2    | Two         |
| 3    | Three       |
| 4    | Four        |
| 5    | Five        |
+------+-------------+

So, in order to get that results, copy only the table structure of table1 to (for example) table1_copy using the following SQL statement:

mysql> CREATE TABLE `table1_copy` LIKE `table1`;

Afterwards, copy or insert only one record of the duplicate records from table1 into the table1_copy using the following SQL statement:

INSERT INTO table1_copy
SELECT DISTINCT * FROM table1;

Voila… here is the result:

mysql> SELECT * FROM table1_copy;
+------+-------------+
| code | description |
+------+-------------+
| 1    | One         |
| 2    | Two         |
| 3    | Three       |
| 4    | Four        |
| 5    | Five        |
+------+-------------+

Ups, don’t forget to remove the table1 table (assuming all the steps above goes smoothly):

DROP TABLE IF EXISTS `table1`;

and then rename the destination table to the original one:

RENAME TABLE `table1_copy` TO `table1`;

It’s very easy, isn’t?

MySQL has provided the great UPDATE SQL syntax for this. You can use this SQL (for instance, I want to replace the comma character inside the tablename table with the minus character that located in a field named thefield):

UPDATE tablename SET `thefield` = REPLACE(`thefield`, ',', '-');

Isn’t easy, huh?

1. Make sure your Wampserver is already running.
2. Click your mouse’s left-button on the Wampserver icon in your systray bar, then choose MySQL -> my.ini.
3. Find this code in the my.ini file:

   # The default storage engine that will be used when create new tables when
   default-storage-engine=INNODB

   then replace with this code:

   # The default storage engine that will be used when create new tables when
   default-storage-engine=MYISAM

4. Save your my.ini file.
5. Restart all services of your Wampserver.
6. Try to create a new table without define the engine type explicitely by using SQL syntax, then its engine type should be now the MyISAM.

Edited on September 19, 2011: If you are running Wampserver which has the MySQL version 5.5.8+ in it, you will not find that directive. So the trick for it is simply add the following code:

default-storage-engine=MYISAM

after this following line in your my.ini file:

[wampmysqld]

Hope it helps!

Suppose we have a table named mytable which has these following records inside:

+----+-------+
| id | name  |
+----+-------+
|  1 | One   |
|  2 | One   |
|  3 | Two   |
|  4 | Two   |
|  5 | Two   |
|  6 | Three |
|  7 | Three |
|  8 | Three |
|  9 | Three |
| 10 | Four  |
| 11 | Five  |
+----+-------+
11 rows in set (0.00 sec)

and you want to display which one has the duplicate content in the name filed become like this:

+-------+---------+
| name  | howmany |
+-------+---------+
| Three |       4 |
| Two   |       3 |
| One   |       2 |
+-------+---------+
3 rows in set (0.00 sec)

In the other words, we will display the value in name field which have more than one records, whereas, the records which do not the duplicate content, will be avoided (in this case the record which have the value in field name-nya: Four and Five).

Well, here is the SQL script to do make it came true:

SELECT name, COUNT(name) AS howmany 
FROM `my_table`
GROUP BY name 
HAVING howmany > 1
ORDER BY howmany DESC;

Let’s take a following example. We have had already about six thousand records in a table named mytable. Let’s say that in one of the fields named myfield has the multiple diverse value.
For example:

JAKARTA 10120
JAKARTA 10120
JAKARTA 10246
JAKARTA 10710
JAKARTA 11721
JAKARTA 11842
JAKARTA 12210
JAKARTA 12714
JAKARTA 13220
JAKARTA 13562
JAKARTA 13587
JAKARTA 14210
BOGOR 16125
BOGOR 16219
BOGOR 16242
BOGOR 16255
TANGERANG 15124
TANGERANG 15125
TANGERANG 15233
BEKASI 17121
BEKASI 17131
BEKASI 17142
BEKASI 17145
BEKASI 17233
...

then, I want to display only the unique city value become like this:

JAKARTA
BOGOR
TANGERANG
BEKASI

In the other words, we want to avoid the 5 digits of postcode of the city, and get the unique value of the city. So here is the SQL script how you can get that unique city value:

SELECT DISTINCT(SUBSTR(myfield, 1, LENGTH(myfield)-6)) FROM `mytable`;

This SQL tells the MySQL:
“Get the unique value from the myfield field started from the first character until the sixth position counted from upon the right of the field value”.

You can see that we have included three functions in that SQL:

1. DISTINCT, this keyword has the purpose to get the unique value from the set of records which has the possibility contains of the same value.
2. SUBSTR, this keyword has the purpose to get the certain characters from the certain field based on from the certain started position of character until the last position that we can specify.
3. LENGTH, this keyword has the purpose to get how many characters that contained in a field.

That SQL script worked like a charm and had been tested in MySQL version 5.0.51b which included in the WAMPSERVER version 2.0 installation.