ViralPatel.net » MySQL

How To Reset MySQL Autoincrement Column

Viral Patel — Thu, 22 Dec 2011 07:31:38 +0000

MySQL database provides a wonderful feature of Autoincrement Column index. Your database table can define its primary key as Autoincrement number and MySQL will take care of its unique value while inserting new rows.

Each time you add a new row, MySQL increments the value automatically and persist it to table. But sometime you may want to reset the Autoincrement column value to 1. Say you writing a sample application and you have inserted few rows already in the table. Now you want to delete these rows and reset the autoincrement column to 1 so that new row which you insert will have primary key value 1.

There are few methods to achieve this.

1. Directly Reset Autoincrement Value

Alter table syntax provides a way to reset autoincrement column. Take a look at following example.

ALTER TABLE table_name AUTO_INCREMENT = 1;

Note that you cannot reset the counter to a value less than or equal to any that have already been used. For MyISAM, if the value is less than or equal to the maximum value currently in the AUTO_INCREMENT column, the value is reset to the current maximum plus one. For InnoDB, if the value is less than the current maximum value in the column, no error occurs and the current sequence value is not changed.

2. Truncate Table

Truncate table automatically reset the Autoincrement values to 0.

TRUNCATE TABLE table_name;

Use this with caution. When Truncation is used, it resets any AUTO_INCREMENT counter to zero. From MySQL 5.0.13 on, the AUTO_INCREMENT counter is reset to zero by TRUNCATE TABLE, regardless of whether there is a foreign key constraint.

Once TRUNCATE is fired, the table handler does not remember the last used AUTO_INCREMENT value, but starts counting from the beginning. This is true even for MyISAM and InnoDB, which normally do not reuse sequence values.

3. Drop & Recreate Table

This is another way of reseting autoincrement index. Although not very desirable.

DROP TABLE table_name;
CREATE TABLE table_name { ... };

All these techniques are value techniques to reset autoincrement column number. Use whatever suits your requirement.

Disclaimer: The above commands can delete all your data! Be very very cautious.

Hibernate One To One Mapping Tutorial (XML Mapping)

Viral Patel — Tue, 15 Nov 2011 08:10:56 +0000

Let us understand how One-to-one mapping works in Hibernate. Following is a simply yet concept building example where we will understand One-to-one mapping in Hibernate framework using XML Mappings. We will use two tables “employee” and “employeedetail” which exhibits one-to-one relationship. Using Hibernate we will implement this relationship.

Hibernate Tutorial Series

Tools and technologies used in this article:

Java JDK 1.5 above
MySQL 5 above
Eclipse 3.2 above
Hibernate 3 above
Maven 3 above

1. Create Database

We will use MySQL in our example. Create two tables “employee” and “employeedetail” with One-to-one relationship. Following is the SQL script for same.

/* EMPLOYEE table */
CREATE TABLE `employee` (
	`employee_id` BIGINT(10) NOT NULL AUTO_INCREMENT,
	`firstname` VARCHAR(50) NULL DEFAULT NULL,
	`lastname` VARCHAR(50) NULL DEFAULT NULL,
	`birth_date` DATE NOT NULL,
	`cell_phone` VARCHAR(15) NOT NULL,
	PRIMARY KEY (`employee_id`)
)
COLLATE='latin1_swedish_ci'
ENGINE=InnoDB
ROW_FORMAT=DEFAULT
AUTO_INCREMENT=216

/* EMPLOYEEDETAIL table */
CREATE TABLE `employeedetail` (
	`employee_id` BIGINT(20) NOT NULL AUTO_INCREMENT,
	`street` VARCHAR(50) NULL DEFAULT NULL,
	`city` VARCHAR(50) NULL DEFAULT NULL,
	`state` VARCHAR(50) NULL DEFAULT NULL,
	`country` VARCHAR(50) NULL DEFAULT NULL,
	PRIMARY KEY (`employee_id`),
	CONSTRAINT `FKEMPL` FOREIGN KEY (`employee_id`) REFERENCES `employee` (`employee_id`)
)
COLLATE='latin1_swedish_ci'
ENGINE=InnoDB
ROW_FORMAT=DEFAULT
AUTO_INCREMENT=216

Note that a one-to-one relationships occurs when one entity is related to exactly one occurrence in another entity. Thus, there will be one primary key which will be mapped with both the entities.

2. Hibernate Maven dependency

Following dependencies we will use in Maven which will add Hibernate support.

File: /pom.xml


	4.0.0
	net.viralpatel.hibernate
	HibernateHelloWorldXML
	jar
	1.0-SNAPSHOT
	HibernateHelloWorldXML
	http://maven.apache.org
	
		
			mysql
			mysql-connector-java
			5.1.10
		
		
			org.hibernate
			hibernate
			3.2.6.ga

3. Hibernate Model class

For this example we will create two Model class: Employee.java and EmployeeDetail.java. Add following in your project.

File: /src/main/java/net/viralpatel/hibernate/Employee.java

package net.viralpatel.hibernate;

import java.sql.Date;

public class Employee {

	private Long employeeId;
	private String firstname;
	private String lastname;
	private Date birthDate;
	private String cellphone;
	private EmployeeDetail employeeDetail;

	public Employee() {

	}

	public Employee(String firstname, String lastname, Date birthdate,
			String phone) {
		this.firstname = firstname;
		this.lastname = lastname;
		this.birthDate = birthdate;
		this.cellphone = phone;
	}

	// Getter and Setter methods
}

File: /src/main/java/net/viralpatel/hibernate/EmployeeDetail.java

package net.viralpatel.hibernate;

public class EmployeeDetail {

	private Long employeeId;
	private String street;
	private String city;
	private String state;
	private String country;

	private Employee employee;

	public EmployeeDetail() {

	}

	public EmployeeDetail(String street, String city, String state, String country) {
		this.street = street;
		this.city = city;
		this.state = state;
		this.country = country;
	}

	// Getter and Setter methods	

}

Note that in above model classes, employeeId is common. This is the primary key of Employee table that exhibits One-to-one relationship with EmployeeDetail table.

4. Hibernate XML Mapping (HBM)

Add following hibernate mapping (hbm) files Employee.hbm.xml and EmployeeDetail.hbm.xml for the model classes created in above steps.

File: /src/main/java/net/viralpatel/hibernate/Employee.hbm.xml

File: /src/main/java/net/viralpatel/hibernate/EmployeeDetail.hbm.xml






    

 		
			
			
				employee

Note that in above hibernate mapping we are implementing One-to-one relationship. For both the model classes we are using a single primary key EmployeeId. In EmployeeDetail hbm file we have defined a foreign identifier generator so that primary it uses primary key of Employee table.

5. Hibernate Configuration

Following is the hibernate configuration hibernate.cfg.xml file. Add this in your project.

File: /src/main/resources/hibernate.cfg.xml





    
        com.mysql.jdbc.Driver
        jdbc:mysql://localhost:3306/tutorial
        root
        

        1
        org.hibernate.dialect.MySQLDialect
        thread
        org.hibernate.cache.NoCacheProvider
        true
        validate

6. Hibernate Utility class

File:/src/main/java/net/viralpatel/hibernate/HibernateUtil.java

package net.viralpatel.hibernate;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

    private static final SessionFactory sessionFactory = buildSessionFactory();

    private static SessionFactory buildSessionFactory() {
        try {
            // Create the SessionFactory from hibernate.cfg.xml
            return new Configuration()
            		.configure()
                    .buildSessionFactory();
        } catch (Throwable ex) {
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

7. Main class to test One-to-one mapping

Add following Main.java class in your project to test One-to-one relationship mapping functionality.

File:/src/main/java/net/viralpatel/hibernate/Main.java

package net.viralpatel.hibernate;

import java.sql.Date;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

public class Main {

	public static void main(String[] args) {

		SessionFactory sf = HibernateUtil.getSessionFactory();
		Session session = sf.openSession();
		session.beginTransaction();

		EmployeeDetail employeeDetail = new EmployeeDetail("10th Street", "LA", "San Francisco", "U.S.");

		Employee employee = new Employee("Nina", "Mayers", new Date(121212),
				"114-857-965");
		employee.setEmployeeDetail(employeeDetail);
		employeeDetail.setEmployee(employee);

		session.save(employee);

		List employees = session.createQuery("from Employee").list();
		for (Employee employee1 : employees) {
			System.out.println(employee1.getFirstname() + " , "
					+ employee1.getLastname() + ", "
					+ employee1.getEmployeeDetail().getState());
		}

		session.getTransaction().commit();
		session.close();

	}
}

8. Review Project Structure

Below is the final project structure with all the source files.

8. Execute the example

Execute the Main class. Hibernate will insert a row in Employee and EmployeeDetail table.

Output:

Hibernate: insert into EMPLOYEE (firstname, lastname, birth_date, cell_phone) values (?, ?, ?, ?)
Hibernate: insert into EMPLOYEEDETAIL (STREET, CITY, STATE, COUNTRY, EMPLOYEE_ID) values (?, ?, ?, ?, ?)
Hibernate: select employee0_.EMPLOYEE_ID as EMPLOYEE1_1_, employee0_.firstname as firstname1_, employee0_.lastname as lastname1_, employee0_.birth_date as birth4_1_, employee0_.cell_phone as cell5_1_ from EMPLOYEE employee0_
Hibernate: select employeede0_.EMPLOYEE_ID as EMPLOYEE1_0_0_, employeede0_.STREET as STREET0_0_, employeede0_.CITY as CITY0_0_, employeede0_.STATE as STATE0_0_, employeede0_.COUNTRY as COUNTRY0_0_ from EMPLOYEEDETAIL employeede0_ where employeede0_.EMPLOYEE_ID=?
Nina , Mayers, San Francisco

That’s All Folks

Today we saw how to write Hibernate program and implements One-to-one relationship mapping using XML mappings. We used Maven to generate Java project and added Hibernate dependencies into it.

Download Source

Hibernate-One-to-one-tutorial-XML-Mapping.zip (9 kb)

Hibernate Maven MySQL Hello World example (XML Mapping)

Viral Patel — Tue, 08 Nov 2011 06:33:39 +0000

In this tutorial, we will try to write a small hello world program using Hibernate, MySQL and Maven. We will create a Java project using Maven and will then try to add Hibernate on it.

Hibernate Tutorial Series

Following are the tools and technologies used in this project.

Java JDK 5 or above
Eclipse IDE 3.2 or above
Maven 3.0 or above
Hibernate 3.0 or above
MySQL 5.0 or above

1. Database Creation

For this tutorial, we will create a simple table “employe” in MySQL. Use following script to create the table.

CREATE TABLE `employee` (
	`id` BIGINT(10) NOT NULL AUTO_INCREMENT,
	`firstname` VARCHAR(50) NULL DEFAULT NULL,
	`lastname` VARCHAR(50) NULL DEFAULT NULL,
	`birth_date` DATE NOT NULL,
	`cell_phone` VARCHAR(15) NOT NULL,
	PRIMARY KEY (`id`)
)
COLLATE='latin1_swedish_ci'
ENGINE=InnoDB
ROW_FORMAT=DEFAULT
AUTO_INCREMENT=606

Thus, following will be the connection string to connect with MySQL.

Connection URL:	jdbc:mysql://localhost:3306/tutorial
DB Username:	root
DB Password:

2. Generate Maven Java project compatible with Eclipse

Open a command prompt and execute following code to generate a Maven Java project.

mvn archetype:generate \
	-DgroupId=net.viralpatel.hibernate \
	-DartifactId=HibernateHelloWorldXML \
	-DarchetypeArtifactId=maven-archetype-quickstart \
	-DinteractiveMode=false

Once you execute above command, a project “HibernateHelloWorldXML” is created. Note that this is a Java project which already has folder structures compatible to Maven.

Once this is done, we will convert it to be compatible with Eclipse. For that executes following command on command prompt.

mvn eclipse:eclipse

3. Import project in Eclipse

Open Eclipse and import the above Java project.

File > Import... > General > Existing Projects into Workspace > Choose above Java project

Once imported, the folder structure will look like following:

Important:

In case you get following error after importing project in Eclipse:

If you are getting this Hibernate Maven Repo error, then you need to define M2_REPO environment variable in eclipse pointing to your local maven repository.

Goto Window > Preferences… > Java > Build Path > Classpath Variables > Define new variable M2_REPO pointing to your local maven repository.

Once you will define this variable and rebuild the project, the above error will go.

4. Add Hibernate Dependency to Maven pom.xml

Add following dependencies to Maven pom.xml.


  4.0.0
  net.viralpatel.hibernate
  HibernateHelloWorldXML
  jar
  1.0-SNAPSHOT
  HibernateHelloWorldXML
  http://maven.apache.org
  
    
      mysql
      mysql-connector-java
      5.1.10
    
    
      org.hibernate
      hibernate
      3.2.6.ga
    
    
      junit
      junit
      3.8.1
      test

Once we have added these dependencies, we will execute following command so that maven will download required Jar files and add the same to eclipse classpath.

mvn eclipse:eclipse

The above step is not mandatory. If you have Maven plugin for Eclipse installed in your IDE (Latest eclipse comes with this plugin built-in) you can just enable Maven dependencies by doing
Right click on project > Maven > Enable Dependency Management.

5. Add Hibernate Configuration XML

Now our project setup is ready. We will add following Hibernate configuration xml file in /src/main/resources folder. Note that this folder is not present in your project structure.

Create a source folder:
Right click on Project > New > Source Folder > Give folder name “/src/main/resources/” and click Finish.

Copy following file in your project.

File: /src/main/resources/hibernate.cfg.xml





    
        
        com.mysql.jdbc.Driver
        jdbc:mysql://localhost:3306/tutorial
        root
        

        
        1

        
        org.hibernate.dialect.MySQLDialect

        
        thread

        
        org.hibernate.cache.NoCacheProvider

        
        false

        validate

One thing we need to make sure in Eclipse is that the Java build path must reflect **/*.xml.
Right click on project > Properties > Java Build Path > Source > Add **/*.xml as follow:

6. Add Java source code

File: /src/main/java/net/viralpatel/hibernate/Employee.java

package net.viralpatel.hibernate;

import java.sql.Date;

public class Employee {

	private Long id;

	private String firstname;

	private String lastname;

	private Date birthDate;

	private String cellphone;

	public Employee() {

	}

	public Employee(String firstname, String lastname, Date birthdate, String phone) {
		this.firstname = firstname;
		this.lastname = lastname;
		this.birthDate = birthdate;
		this.cellphone = phone;

	}

	// Getter and Setter methods

}

Above is the Employee POJO class that we will use to fetch data from Employee table. This Java class will be mapped by Hiberate with Employee table. Note that we have define two constructors first default and second with arguements. The second constructor is optional. But note that you must define a default (No-arguement) constructor in your mapping class.

File: /src/main/java/net/viralpatel/hibernate/HibernateUtil.java

package net.viralpatel.hibernate;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

    private static final SessionFactory sessionFactory = buildSessionFactory();

    private static SessionFactory buildSessionFactory() {
        try {
            // Create the SessionFactory from hibernate.cfg.xml
            return new Configuration()
            		.configure()
                    .buildSessionFactory();
        } catch (Throwable ex) {
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

As discussed in previous article Introduction to Hibernate framework, we have to create SessionFactory instance in order to communicate with Database in Hibernate. We will use a Utility class called HibernateUtil to instantiate SessionFactory.

File: /src/main/java/net/viralpatel/hibernate/Employee.hbm.xml

7. CRUD operations in Hibernate

Let us see the basic CRUD operation in Hibernate. We will use Employee table for this.

7.1 Writing (Create) data in Hibernate

Following is the code snippet that insert a row in database.

private static Employee save(Employee employee) {
	SessionFactory sf = HibernateUtil.getSessionFactory();
	Session session = sf.openSession();
	session.beginTransaction();

	Long id = (Long) session.save(employee);
	employee.setId(id);

	session.getTransaction().commit();

	session.close();

	return employee;
}

...
...
...

// Call the save() method to insert a record in database.
System.out.println("******* WRITE *******");
Employee empl = new Employee("Jack", "Bauer", new Date(System.currentTimeMillis()), "911");
empl = save(empl);

7.2 Reading (Read) data in Hibernate

Below code snippet demos read functionality in Hibernate. Note that there are two methods one to list all the employees and other to read details about just one.

private static List list() {
	SessionFactory sf = HibernateUtil.getSessionFactory();
	Session session = sf.openSession();

	List employees = session.createQuery("from Employee").list();
	session.close();
	return employees;
}
private static Employee read(Long id) {
	SessionFactory sf = HibernateUtil.getSessionFactory();
	Session session = sf.openSession();

	Employee employee = (Employee) session.get(Employee.class, id);
	session.close();
	return employee;
}

7.3 Updating (Update) data in Hibernate

Following is the code snippet to update a record in Hibernate.

private static Employee update(Employee employee) {
	SessionFactory sf = HibernateUtil.getSessionFactory();
	Session session = sf.openSession();

	session.beginTransaction();

	session.merge(employee);

	session.getTransaction().commit();

	session.close();
	return employee;

}

7.4 Remove (Delete) data in Hibernate

Following is code snippet to remove a record in Hibernate.

private static void delete(Employee employee) {
	SessionFactory sf = HibernateUtil.getSessionFactory();
	Session session = sf.openSession();

	session.beginTransaction();

	session.delete(employee);

	session.getTransaction().commit();

	session.close();
}

We have created a file Main.java which will test all these functionality. Following is the complete source code of Main.java.
File: /src/main/java/net/viralpatel/hibernate/Main.java

package net.viralpatel.hibernate;

import java.sql.Date;
import java.util.List;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

public class Main {

	public static void main(String[] args) {

		// Read
		System.out.println("******* READ *******");
		List employees = list();
		System.out.println("Total Employees: " + employees.size());

		// Write
		System.out.println("******* WRITE *******");
		Employee empl = new Employee("Jack", "Bauer", new Date(System.currentTimeMillis()), "911");
		empl = save(empl);
		empl = read(empl.getId());
		System.out.printf("%d %s %s \n", empl.getId(), empl.getFirstname(), empl.getLastname());

		// Update
		System.out.println("******* UPDATE *******");
		Employee empl2 = read(1l); // read employee with id 1
		System.out.println("Name Before Update:" + empl2.getFirstname());
		empl2.setFirstname("James");
		update(empl2);	// save the updated employee details

		empl2 = read(1l); // read again employee with id 1
		System.out.println("Name Aftere Update:" + empl2.getFirstname());

		// Delete
		System.out.println("******* DELETE *******");
		delete(empl);
		Employee empl3 = read(empl.getId());
		System.out.println("Object:" + empl3);
	}

	private static List list() {
		SessionFactory sf = HibernateUtil.getSessionFactory();
		Session session = sf.openSession();

		List employees = session.createQuery("from Employee").list();
		session.close();
		return employees;
	}
	private static Employee read(Long id) {
		SessionFactory sf = HibernateUtil.getSessionFactory();
		Session session = sf.openSession();

		Employee employee = (Employee) session.get(Employee.class, id);
		session.close();
		return employee;
	}
	private static Employee save(Employee employee) {
		SessionFactory sf = HibernateUtil.getSessionFactory();
		Session session = sf.openSession();

		session.beginTransaction();

		Long id = (Long) session.save(employee);
		employee.setId(id);

		session.getTransaction().commit();

		session.close();

		return employee;
	}

	private static Employee update(Employee employee) {
		SessionFactory sf = HibernateUtil.getSessionFactory();
		Session session = sf.openSession();

		session.beginTransaction();

		session.merge(employee);

		session.getTransaction().commit();

		session.close();
		return employee;

	}

	private static void delete(Employee employee) {
		SessionFactory sf = HibernateUtil.getSessionFactory();
		Session session = sf.openSession();

		session.beginTransaction();

		session.delete(employee);

		session.getTransaction().commit();

		session.close();
	}

}

8. Final project structure

Once you have created all these source files, your project structure should look like following. Note that we have removed the default App.java and AppTest.java generated by Maven as we dont these files.

9. Execute project

Execute the Main.java class and see output.

******* READ *******
Total Employees: 200
******* WRITE *******
201 Jack Bauer
******* UPDATE *******
Name Before Update:Paula
Name Aftere Update:James
******* DELETE *******
Object:null

That’s All Folks

Today we saw how to write our first Hibernate hello world example using XML Configuration. We used Maven to generate Java project and added Hibernate dependencies into it. Also we saw how to do different CRUD operations in Hibernate.

Download Source

HibernateHelloWorldXML.zip (8 kb)

Full-Text Search using MySQL: Full-Text Search Capabilities

Viral Patel — Wed, 22 Apr 2009 13:15:36 +0000

Have you ever thought how does the search functionality is implemented in all the websites! Most of the internet blogs and websites are powered by MySQL database. MySQL provides a wonderful way (Full-text Search) of implementing a little search engine in your website. All you have to do is to have MySQL 4.x and above. MySQL provides full text search capabilities that we can use to implement search functionality.

First let us setup a sample table for our example. We will create a table called Article.

CREATE TABLE articles (
    id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,
    title VARCHAR(200),
    body TEXT,
    FULLTEXT (title,body)
);

Also add some sample data in this table. Execute following insert query.

INSERT INTO articles (title,body) VALUES
    ('MySQL Tutorial','DBMS stands for DataBase ...'),
    ('How To Use MySQL Well','After you went through a ...'),
    ('Optimizing MySQL','In this tutorial we will show ...'),
    ('1001 MySQL Tricks','1. Never run mysqld as root. 2. ...'),
    ('MySQL vs. YourSQL','In the following database comparison ...'),
    ('MySQL Security','When configured properly, MySQL ...');

Once the sample data is ready in our table, we can start with our full-text search functionality.

Natural Language Full-Text Searches

Try to execute following Select query on our sample table.

SELECT * FROM articles
    WHERE MATCH (title,body) AGAINST ('database');

You will be able to see following result:

  5        MySQL vs. YourSQL        In the following database comparison ...
  1        MySQL Tutorial               DBMS stands for DataBase ...

In above sql query we used MATCH (title,body) AGAINST (‘database’) to select all the records by performing a full text search on columns title and body.

You can modify this query and create your own version to perform full-text search in your own database.

Boolean Full-Text Searches

It may happen that you want to specify certain keywords in your search criteria. Also you may want to ignore certain keywords. Boolean Full-Text Search can used to perform a full text search for such requirements.

Check the following Select query.

SELECT * FROM articles WHERE MATCH (title,body)
     AGAINST ('+MySQL -YourSQL' IN BOOLEAN MODE);

If you notice the above Select query, we have added IN BOOLEAN MODE in against(). This query will fetch all the records which has MySQL keyword but not YourSQL keyword. Notice the + and – that we have specified before the keywords!

In implementing this feature, MySQL uses what is sometimes referred to as implied Boolean logic, in which:
+ stands for AND
- stands for NOT
[no operator] implies OR

Following are few examples for the boolean search criteria.

‘apple banana’
Find rows that contain at least one of the two words.

‘+apple +juice’
Find rows that contain both words.

‘+apple macintosh’
Find rows that contain the word “apple”, but rank rows higher if they also contain “macintosh”.

‘+apple -macintosh’
Find rows that contain the word “apple” but not “macintosh”.

‘+apple ~macintosh’
Find rows that contain the word “apple”, but if the row also contains the word “macintosh”, rate it lower than if row does not. This is “softer” than a search for ‘+apple -macintosh’, for which the presence of “macintosh” causes the row not to be returned at all.

‘+apple +(>turnover
Find rows that contain the words “apple” and “turnover”, or “apple” and “strudel” (in any order), but rank “apple turnover” higher than “apple strudel”.

Restrictions

The Full-text searches are supported for MyISAM tables only. As of MySQL 4.1, the use of multiple character sets within a single table is supported. However, all columns in a FULLTEXT index must use the same character set and collation. The MATCH() column list must match exactly the column list in some FULLTEXT index definition for the table, unless this MATCH() is IN BOOLEAN MODE. Boolean-mode searches can be done on non-indexed columns, although they are likely to be slow.

Generating Tag cloud with PHP and MySQL

Vimal Patel — Mon, 16 Mar 2009 05:27:54 +0000

The basic idea this time is to present a way to form a tag cloud from user input text and text entered in the past. A tag cloud is a visual depiction of user-generated tags, or simply the word content of a site, used typically to describe the content of web sites.
for this we will create an HTML form that will accept user text & also allow user to see tag cloud generated from mysql database which contains the text entered in the past.
'; echo '
Input your text here:
'; echo ''; echo ''; ?>

OR

see the current tag cloud here
'; echo ''; echo ''; ?>
The entered text will be tokenized into single words with php function strtok(), each of which will have its frequency counted and the pair will go into an array. This array will then be stored into a mysql database, we can optionally keep a coloumn in the mysql database table to store links if any for future expansion of this project.
1) tag_id —- int,primary key,auto increament
2) keyword — varchar(20),unique
3) weight — int
4) link — varchar(256).
Next make a php file and name it tag_cloud_gen.php . The php code written in following lines just make an array ‘$words’ which has keyword in lower case & its frequency association from input text. The pairs from the array are then feed into the mysql database ‘tagcloud_db’ which has a table callet ‘tags’ whose columns are listed above. On encountering error the mysql _errrno() returns error number. While feeding the word array to the tags table duplication may occour, because of the previous entries, so we check whether this is the case by comparing the number returned to ’1062′ which indicates duplicate field present in the table (the keyword coloumn of table has unique constraint). On encountering this we simply update the mysql database to include the count of this input word/tag too.
0) $tok=strtolower($tok); $words=array(); $words[$tok]=1; while ($tok !== false) { echo "Word=$tok
"; $tok = strtok(" \t,;.\'\"!&-`\n\r"); if(strlen($tok)>0) { $tok=strtolower($tok); if($words[$tok]>=1){ $words[$tok]=$words[$tok] + 1; } else { $words[$tok]=1; } } } print_r($words); echo '

'; /** * now enter the above array of word and corresponding count values into the database table * in case the keyword already exist in the table then update the database table using the function 'update_database_entry(...)' */ $table="tagcloud_db"; mysql_select_db($table,$connection); foreach($words as $keyword=>$weight){ $query="INSERT INTO `tagcloud_db`.`tags` (keyword,weight,link) values ('".$keyword."',".$weight.",'NA')"; if(!mysql_query($query,$connection)){ if(mysql_errno($connection)==1062){ update_database_entry($connection,$table,$keyword,$weight); } } } mysql_close($connection); ?>
Make anether file and name it style.css . Put the following code in it.
HTML, BODY { padding: 0; border: 0px none; font-family: Verdana; font-weight: none; } .tags_div { padding: 3px; border: 1px solid #A8A8C3; background-color: white; width: 500px; -moz-border-radius: 5px; } H1 { font-size: 16px; font-weight: none; } A:link { color: #676F9D; text-decoration: none; } A:hover { text-decoration: none; background-color: #4F5AA1; color: white; }
This will make our tag cloud look pretty, save it as style.css .
again make a new php file and name it show_tag_cloud.php .
In the php code that follows we connect to mysql database, fetch back all the tags, its weight and link.
Then it calculates the size for each tag using its weight & minimum assumed size for tags, it also associates each tag the link retrieved from the database or with a google link if no link was there i.e. ‘NA’
Tag Cloud Generator
Tag Cloud using php and mysql
$weight ) { $x = round(($weight * 100) / $max_count) * $factor; $font_size = $starting_font_size + $x.'px'; if($words_link[$tag]=='NA') echo "".$tag."".$tag_separator; else echo "".$tag."".$tag_separator; } ?>

now put them all in your webserver’s root directory and watch the results. Each query will give you new results over time as the database grows.
a sample output from my tag cloug looks like this:
This tag cloud was generated using the following data:
tag_id;keyword;weight;link
“1″;”vimal”;”7″;”www.vimalkumarpatel.blogspot.com”
“2″;”scet”;”5″;”NA”
“3″;”engg”;”2″;”NA”
“4″;”0″;”1″;”NA”
“7″;”google”;”5″;”NA”
“8″;”cool”;”2″;”NA”
“9″;”orkut”;”3″;”NA”
Related Posts
Create 3D tag cloud using jsTagCloud jQuery plugin
Twitter like N min/sec ago timestamp in PHP/MySQL
Oracle buying Sun Microsystems: What will happen to MySQL!
How To Reset MySQL Autoincrement Column
Hibernate Many To Many Annotation Mapping Tutorial
Hibernate Many To Many XML Mapping Tutorial
Hibernate One To Many XML Mapping Tutorial

MARIA, An extended MyISAM engine for MySQL

Gaurav Patel — Sat, 24 Jan 2009 12:30:07 +0000

Let us talk about Maria.. no no not Maria Sharapova, its new version of MyISAM engine for MySQL which is claimed to be crash safe and provides more concurrency. It aims at becoming fully transactional (ACID). Following are the features of Maria.
Features
ACID (Atomicity, Consistency, Isolation, Durability)
Commit/Rollback
Concurrent selects (via MVCC)
Row locking
Group commit
Although Maria itselft is released, but not part of MySQL’s binaries yet.
There are some really good faqs on Monty’s blog (Developer of Maria), although the content is huge, I have taken few useful FAQ about Maria and copied here. Take a look.
Frequently Asked Question (FAQ) about Maria.
1. How does Maria 1.0 Compare to MyISAM ?
Maria 1.0 is basically a crash-safe non transactional version of MyISAM.
Maria supports all aspects of MyISAM, except as noted below. This includes external and internal check/repair/compressing of rows, different row formats, different index compress formats, maria_check etc. After a normal shutdown one can copy Maria files between servers.
Advantages of Maria (Compared to MyISAM)
Data and indexes are crash safe.
On a crash, changes will be rolled back to state of the start of a statement or a last LOCK TABLES commands.
Maria can replay almost everything from the log. (Including create/drop/rename/truncate tables). Therefore, you make a backup of Maria by just copying the log. The things that can’t be replayed (yet) are:
Batch INSERT into an empty table (This includes LOAD DATA INFILE, SELECT … INSERT and INSERT (many rows))
ALTER TABLE. Note that .frm tables are NOT recreated!
LOAD INDEX can skip index blocks for unwanted indexes
Supports all MyISAM row formats + new PAGE format where data is stored in pages. (default size is 8K)
When using PAGE format (default) row data is cached by page cache.
Maria has unit tests of most parts
Supports both crash-safe (soon to be transactional) and not transactional tables. (Non-transactional tables are not logged and rows uses less space): CREATE TABLE foo (…) TRANSACTIONAL=0|1 ENGINE=Maria
PAGE is the only crash-safe/transactional row format.
PAGE format should give a notable speed improvement on systems which have bad data caching. (For example windows).
Differences between Maria and MyISAM:
Maria uses BIG (1G by default) log files.
Maria has a log control file (maria_log_control) and log files ( maria_log.???????). The log files can be automatically purged when not needed or purged on demand (after backup).
Maria uses 8K pages by default (MyISAM uses 1K). This makes Maria a bit faster when using keys of fixed size, but slower when using variable-length packed keys (until we add a directory to index pages)
Disadvantages of Maria (compared to MyISAM), that will be fixed soon
Maria 1.0 has one writer or many readers. (MyISAM can have one inserter and many readers when using concurrent inserts).
Maria doesn’t support INSERT DELAYED.
Maria does not support multiple key caches.
Disadvantages of Maria (compared to MyISAM), that will be fixed in later releases
Storage of very small rows.
MERGE tables don’t support Maria (should be very easy to add later).
Differences that are not likely to be fixed.
Maria data pages in block format have an overhead of 10 bytes/page and 5 bytes/row. Transaction and multiple concurrent-writer support will use an extra overhead of 7 bytes for new rows, 14 bytes for deleted rows and 0 bytes for old compacted rows.
No external locking (MyISAM has external locking, but is not much used)
Maria has one page size for both index and data (defined when Maria is used the first time). MyISAM supports different page sizes per index.
Index number requires one extra byte per index page.
Maria doesn’t support MySQL internal RAID (disabled in MyISAM too, it’s a deprecated feature)
Minimum data file size for PAGE format is 16K (with 8K pages)
2. What is the differences between the MySQL-5.1-Maria release and the normal MySQL-5.1 release ?
Maria is compiled in by default and required to be ‘in use’ when mysqld is started.
Internal on-disk tables are in Maria table format instead of MyISAM table format. This should speed up some GROUP BY and DISTINCT queries because Maria has better caching than MyISAM.
New options to CREATE TABLE:
TRANSACTIONAL= 0 | 1 ; Transactional means crash-safe for Maria <>
PAGE_CHECKSUM= 0 | 1 ; If index and data should use page checksums for extra safety.
TABLE_CHECKSUM= 0 | 1 ; Same as CHECKSUM in MySQL 5.1
ROW_FORMAT=PAGE ; The new cacheable row format for Maria tables. Default row format for Maria tables and only row format that can be used if TRANSACTIONAL=1. To emulate MyISAM, use ROW_FORMAT=FIXED or ROW_FORMAT=DYNAMIC
CHECKSUM TABLE now ignores values in NULL fields. This makes CHECKSUM TABLE faster and fixes some cases where same table definition could give different checksum values depending on row format. The disadvantage is that the value is now different compared to other MySQL installations. The new checksum calculation is fixed for all table engines that uses the default way to calculate and MyISAM which does the calculation internally. Note: Old MyISAM tables with internal checksum will return the same checksum as before. To fix them to calculate according to new rules you have to do an ALTER TABLE. You can use the old ways to calculate checksums by using the option –old to mysqld or set the system variable ‘@@old’ to 1 when you do CHECKSUM TABLE … EXTENDED;
At startup Maria will check the Maria logs and automatically recover the tables from last checkpoint if mysqld was not taken down correctly.
There are some improvements to DBUG code to make its execution faster when debug is compiled in but not used.
3. Why is the engine called Maria ?
A funny answer!! Monty, the creator of MySQL, named MySQL after his first child ‘My’. His second child, Max, gave his name to MaxDB and the MySQL-Max distributions. His third and youngest child is named Maria…!!!
4. What is goal of Maria in current (MySQL 5.1-Maria) release ?
To make a crash-safe alternative to MyISAM. That is, when mysqld restarts after a crash occurs, Maria will recover all tables to the state as of the start of a statement or at the start of a previous LOCK TABLES.
5. What is ultimate goal of Maria?
To create a new, ACID and multi-version concurrency Control (MVCC), transactional storage engine that can function as the default non-transactional an the default transactional storage engine for MySQL.
To be a MyISAM replacement. This is possible because Maria can also be run in non-transactional mode, supports all row formats as MyISAM, and supports or will support all major features of MyISAM.
Maria to be standard part of MySQL 6.X
6. Where can I find documentation and help about Maria ?
Documentation about Maria can be found at: http://forge.mysql.com/wiki/Maria_Docs
7. Why do you use the TRANSACTIONAL keyword now when Maria is not yet transactional ?
In the current development phase Maria tables created with TRANSACTIONAL=1 are crashsafe and atomic but not transactional because changes in Maria tables can’t be rolled back with the ROLLBACK command. As we will make Maria tables fully transactional in a relatively short time frame we think it’s better to use the TRANSACTIONAL keyword already now so that applications don’t need to be changed later.
Tables marked with TRANSACTIONAL=1 will for each Maria release get more and more transactional aspects and when we reach Maria 2.0 they will be fully transactional in the traditional sense.
8. How can I create a MyISAM like (non-transactional) table in Maria ?
Example:
CREATE TABLE t1 (a int) ROW_FORMAT=FIXED TRANSACTIONAL=0 PAGE_CHECKSUM=0; CREATE TABLE t2 (a int) ROW_FORMAT=DYNAMIC TRANSACTIONAL=0 PAGE_CHECKSUM=0; SHOW CREATE TABLE t1; SHOW CREATE TABLE t2;
Note that the rows are not cached in the page cache for FIXED or DYNAMIC format. If you want to have the data cached (something MyISAM doesn’t support) you should use ROW_FORMAT=PAGE:
CREATE TABLE t3 (a int) ROW_FORMAT=PAGE TRANSACTIONAL=0 PAGE_CHECKSUM=0; SHOW CREATE TABLE t1;
You can use PAGE_CHECKSUM=1 also for non-transactional tables; This puts a page checksums on all index pages. It also puts a checksum on data pages if you use ROW_FORMAT=PAGE.
Related Posts
Full-Text Search using MySQL: Full-Text Search Capabilities
How To Reset MySQL Autoincrement Column
Hibernate Many To Many Annotation Mapping Tutorial
Hibernate Many To Many XML Mapping Tutorial
Hibernate One To Many XML Mapping Tutorial
Hibernate One To One Annotation Mapping Tutorial
Hibernate One To One Mapping Tutorial (XML Mapping)

MySQL Database Backup using mysqldump command.

Viral Patel — Tue, 20 Jan 2009 07:28:03 +0000

Since its release in 1995, MySQL has became one of the most commonly used database in Internet world. A lot of small and medium businesses uses MySQL as their backend db. Its popularity for use with web applications is closely tied to the popularity of PHP, which is often combined with MySQL. Wikipedia runs on MediaWiki software, which is written in PHP and uses a MySQL database. Several high-traffic web sites use MySQL for its data storage and logging of user data, including Flickr, Facebook, Wikipedia, Google, Nokia and YouTube.
MySQL provide a great command line utility to take backup of your MySQL database and restore it. mysqldump command line utility is available with MySQL installation (bin directory) that can be used to achieve this.
1. Getting backup of a MySQL database using mysqldump.
Use following command line for taking backup of your MySQL database using mysqldump utility.
mysqldump –-user [user name] –-password=[password] [database name] > [dump file] or mysqldump –u[user name] –p[password] [database name] > [dump file]
Example:
mysqldump –-user root –-password=myrootpassword db_test > db_test.sql or mysqldump –uroot –pmyrootpassword db_test > db_test.sql
2. Backup multiple databases in MySQL.
mysqldump –u[user name] –p[password] [database name 1] [database name 2] .. > [dump file]
Example:
mysqldump –-user root –-password=myrootpassword db_test db_second db_third > db_test.sql
3. Backup all databases in MySQL.
shell> mysqldump –u[user name] –p[password] –all-databases > [dump file]
4. Backup a specific table in MySQL.
shell> mysqldump --user [username] --password=[password] [database name] [table name] \ > /tmp/sugarcrm_accounts_contacts.sql
Example:
shell> mysqldump --user root --password=myrootpassword db_test customers \ > db_test_customers.sql
5. Restoring MySQL database.
The mysqldump utility is used only to take the MySQL dump. To restore the database from the dump file that you created in previous step, use mysql command.
shell> mysql --u [username] --password=[password] [database name] < [dump file]
Example:
shell> mysql --user root --password=myrootpassword new_db < db_test.sql
Do you know the other uses of mysqldump utility? Comment on this post.
Related Posts
How To Reset MySQL Autoincrement Column
How to: Reset MySQL root password
Get Autoincrement value after INSERT query in MySQL
MySQL Change root Password
Hibernate Many To Many Annotation Mapping Tutorial
Hibernate Many To Many XML Mapping Tutorial
Hibernate One To Many XML Mapping Tutorial

How to: Reset MySQL root password

Gaurav Patel — Fri, 19 Dec 2008 03:52:44 +0000

Resetting the root password of a MySQL database is trivial if you know the current password if you don’t it is a little trickier. Thankfully it isn’t too difficult to fix, and here we’ll show one possible way of doing so.
If you’ve got access to the root account already, because you know the password, you can change it easily:
gaurav@gaurav:~$ mysql --user=root --pass mysql Enter password: mysql> update user set Password=PASSWORD('new-password-here') WHERE User='root'; Query OK, 2 rows affected (0.04 sec) Rows matched: 2 Changed: 2 Warnings: 0 mysql> flush privileges; Query OK, 0 rows affected (0.02 sec) mysql> exit Bye
Forget the MySQL root password?
However if you don’t know the current password this approach will not work – you need to login to run any commands and without the password you’ll not be able to login!
Thankfully there is a simple solution to this problem also, we just need to start MySQL with a flag to tell it to ignore any username/password restrictions which might be in place. Once that is done you can successfully update the stored details.
First of all you will need to ensure that your database is stopped:
root@gaurav:~# /etc/init.d/mysql stop Now you should start up the database in the background, via the mysqld_safe command: root@gaurav:~# /usr/bin/mysqld_safe --skip-grant-tables & [1] 4271 Starting mysqld daemon with databases from /var/lib/mysql mysqld_safe[6763]: started
Here you can see the new job (number “1″) has started and the server is running with the process ID (PID) of 4271.
Now that the server is running with the –skip-grant-tables flag you can connect to it without a password and complete the job:
root@gaurav:~$ mysql --user=root mysql Enter password: mysql> update user set Password=PASSWORD('new-password-here') WHERE User='root'; Query OK, 2 rows affected (0.04 sec) Rows matched: 2 Changed: 2 Warnings: 0 mysql> flush privileges; Query OK, 0 rows affected (0.02 sec) mysql> exit Bye
Now that you’ve done that you just need to stop the server, so that you can go back to running a secure MySQL server with password restrictions in place. First of all bring the server you started into the foreground by typing “fg”, then kill it by pressing “Ctrl+C” afterward.
This will now allow you to start the server:
root@gaurav:~# /etc/init.d/mysql start Starting MySQL database server: mysqld. Checking for corrupt, not cleanly closed and upgrade needing tables..
Now everything should be done and you should have regained access to your MySQL database(s); you should verify this by connecting with your new password:
root@gaurav:~# mysql --user=root --pass=new-password-here Welcome to the MySQL monitor. Commands end with ; or \g. Your MySQL connection id is 5 to server version: 5.0.24a-Debian_4-log Type 'help;' or '\h' for help. Type '\c' to clear the buffer. mysql> exit Bye
That was easy Isn’t it?
Related Posts
How To Reset MySQL Autoincrement Column
How to execute a command prompt command & view output in Java
MySQL Database Backup using mysqldump command.
Get Autoincrement value after INSERT query in MySQL
MySQL Change root Password
Hibernate Many To Many Annotation Mapping Tutorial
Hibernate Many To Many XML Mapping Tutorial

Problem with comparison of float or double column in MySQL

Gaurav Patel — Sun, 07 Dec 2008 07:14:56 +0000

Problem with comparison of float or double column in MySQL
I had a problem in comparing the number with decimal point with a float column in MySql. After some investigation I came to know that, in most of the computer architecture, the value of floating point numbers is stored as approximation. So if you compare the 21.40 with the given column, it actually compare the value with 21.3999999999999986 !! So, if you are comparing FLOAT or DOUBLE columns with numbers that have decimals, you can’t use equality (=) comparisons of MySql.
Converting the float to double also won’t solve the problem. Then I tried to use ‘like’ of MySql to comparison and it worked for some case. But, in MySql if you use ‘like’, it converts (or cast) the values in string, it won’t match the 21.4 with 21.40 .
Then I converted the column type to ‘Decimal’ and that was worked for me. As Decimal type, in MySql, doesn’t use the floating point unit of CPU, the arithmetic calculation might take more time compare to the Float or Double. Here you have to compromise with the speed to get accuracy.
Related Posts
How To Reset MySQL Autoincrement Column
Hibernate Many To Many Annotation Mapping Tutorial
Hibernate Many To Many XML Mapping Tutorial
Hibernate One To Many XML Mapping Tutorial
Hibernate One To One Annotation Mapping Tutorial
Hibernate One To One Mapping Tutorial (XML Mapping)
Hibernate Hello World example using Annotation

Get Autoincrement value after INSERT query in MySQL

Viral Patel — Tue, 02 Dec 2008 11:24:17 +0000

Lot of time we have requirement to update two tables simultaneously. Say for example, we have two tables CUSTOMER_DETAILS and CUSTOMER_ADDRESS. While adding a row in CUSTOMER_DETAILS, few details like address is first written in CUSTOMER_ADDRESS and its reference is added in CUSTOMER_DETAILS table. Now if ADD_ID is a primary key in CUSTOMER_ADDRESS table and if it is an auto increment field than how to add this key as a foreign key in CUSTOMER_DETAILS table?
Well, check following queries:
INSERT INTO CUSTOMER_ADDRESS (ADD_ID, ADD_TEXT) VALUES(NULL, 'some address value'); INSERT INTO CUSTOMER_DETAILS (NAME, ADD_ID, GENDER, PHONE_NO) VALUES ('James Bond', LAST_INSERT_ID(), 'MALE', 007);
Now when the first query will get executed, address details will be added in CUSTOMER_ADDRESS table and the ADD_ID will be updated based on autoincrement field as we passed NULL in its place. Just after the completion of first query, we want to add custormer details in CUSTOMER_DETAILS table where we will need the ADD_ID that we just added in CUSTOMER_ADDRESS. Now note that we have used LAST_INSERT_ID() function to retrieve the latest autoincrement ID that was used in CUSTOMER_ADDRESS table.
Thus, LAST_INSERT_ID() can be used to fetch latest autoincrement id being used in any INSERT query that was just got executed.
Also, you can fetch the recently added autoincrement ID by using following SELECT query:
SELECT LAST_INSERT_ID();
Related Posts
How To Reset MySQL Autoincrement Column
Hibernate Hello World example using Annotation
MySQL Database Backup using mysqldump command.
How to: Reset MySQL root password
Creating orkut style status update div-textbox using jQuery.
Creating ZIP and JAR Files in Java
MySQL Change root Password