Works only for postgres

generates tables,sequences, functions,indexes, fk, views, schemas, db dump

code:

/**
 * Copyright Isocra Ltd 2004
 * You can use, modify and freely distribute this file as long as you credit Isocra Ltd.
 * There is no explicit or implied guarantee of functionality associated with this file, use it at your own risk.
 */

import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.HashSet;
import java.util.Properties;
import java.util.Set;

/**
 * This class connects to a database and dumps all the tables and contents out to stdout in the form of
 * a set of SQL executable statements
 */
public class db2sql {

    /** Dump the whole database to an SQL string */
    public static Strings dumpDB(Properties props) {
        String driverClassName = props.getProperty("driver.class");
        String driverURL = props.getProperty("driver.url");
        // Default to not having a quote character
        String columnNameQuote = props.getProperty("columnName.quoteChar", "");
        DatabaseMetaData dbMetaData = null;
        Connection dbConn = null;
        try {
            Class.forName(driverClassName);
            dbConn = DriverManager.getConnection(driverURL, props);
            dbMetaData = dbConn.getMetaData();
        }
        catch( Exception e ) {
            System.err.println("Unable to connect to database: "+e);
            return null;
        }
        try {
        	Strings strings = new Strings();
            Set schemas = new HashSet();
            String catalog = props.getProperty("catalog");
            String schema = props.getProperty("schemaPattern");
            String tables = props.getProperty("tableName");
            String[] types = {"VIEW","TABLE"};
            ResultSet rs = dbMetaData.getTables(catalog, schema, tables, types);
            if (! rs.next()) {
                System.err.println("Unable to find any tables matching: catalog="+catalog+" schema="+schema+" tables="+tables);
                rs.close();
            } else {
                // Right, we have some tables, so we can go to work.
                // the details we have are
                // TABLE_CAT String => table catalog (may be null)
                // TABLE_SCHEM String => table schema (may be null)
                // TABLE_NAME String => table name
                // TABLE_TYPE String => table type. Typical types are "TABLE", "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", "LOCAL TEMPORARY", "ALIAS", "SYNONYM".
                // REMARKS String => explanatory comment on the table
                // TYPE_CAT String => the types catalog (may be null)
                // TYPE_SCHEM String => the types schema (may be null)
                // TYPE_NAME String => type name (may be null)
                // SELF_REFERENCING_COL_NAME String => name of the designated "identifier" column of a typed table (may be null)
                // REF_GENERATION String => specifies how values in SELF_REFERENCING_COL_NAME are created. Values are "SYSTEM", "USER", "DERIVED". (may be null)
                // We will ignore the schema and stuff, because people might want to import it somewhere else
                // We will also ignore any tables that aren't of type TABLE for now.
                // We use a do-while because we've already caled rs.next to see if there are any rows
                do {
                    String tableName = rs.getString("TABLE_NAME");
                    String tableType = rs.getString("TABLE_TYPE");
                    String tableSchema = rs.getString("TABLE_SCHEM");
                    String fullTableName = tableSchema+"."+tableName;
                    schemas.add(tableSchema);
                    if ("TABLE".equalsIgnoreCase(tableType)) {
                    	strings.initResult.append("\n\n-- "+fullTableName);
                    	strings.initResult.append("\nCREATE TABLE "+fullTableName+" (\n");
                        ResultSet tableMetaData = dbMetaData.getColumns(null, null, tableName, "%");
                        boolean firstLine = true;
                        while (tableMetaData.next()) {
                            if (firstLine) {
                                firstLine = false;
                            } else {
                                // If we're not the first line, then finish the previous line with a comma
                            	strings.initResult.append(",\n");
                            }
                            String columnName = tableMetaData.getString("COLUMN_NAME");
                            String columnType = tableMetaData.getString("TYPE_NAME");
                            // WARNING: this may give daft answers for some types on some databases (eg JDBC-ODBC link)
                            String decimalDigits = tableMetaData.getString("DECIMAL_DIGITS");
                            String columnSize = tableMetaData.getString("COLUMN_SIZE");
                            String columnPrecision;

                            if(columnType.equals("varchar") ){
                            	columnPrecision = " ("+columnSize+")";
                            }else if(columnType.equals("numeric") || columnType.equals("decimal")){
                            	if(Integer.parseInt(columnSize) >1000)
                            		columnSize="1000";
                            	columnPrecision=" ("+columnSize+", "+decimalDigits+" )";

                            }else
                            	columnPrecision = "";

                            String nullable = tableMetaData.getString("IS_NULLABLE");
                            String defaultValue = tableMetaData.getString("COLUMN_DEF");
                            if(defaultValue == null)
                            	defaultValue ="";
                            else
                            	defaultValue =" DEFAULT "+defaultValue;

                            if(columnType.equalsIgnoreCase("SERIAL")){
                            	defaultValue="";
                            	columnSize="";
                            }
                            String nullString = "NULL";
                            if ("NO".equalsIgnoreCase(nullable)) {
                                nullString = "NOT NULL";
                            }
                            strings.initResult.append("    "+columnNameQuote+columnName+columnNameQuote+" "+columnType+columnPrecision+""+" "+nullString+ defaultValue);
                        }
                        tableMetaData.close();

                        // Now we need to put the primary key constraint
                        Set pkNames = new HashSet();
                        try {
                            ResultSet primaryKeys = dbMetaData.getPrimaryKeys(catalog, schema, tableName);
                            // What we might get:
                            // TABLE_CAT String => table catalog (may be null)
                            // TABLE_SCHEM String => table schema (may be null)
                            // TABLE_NAME String => table name
                            // COLUMN_NAME String => column name
                            // KEY_SEQ short => sequence number within primary key
                            // PK_NAME String => primary key name (may be null)
                            String primaryKeyName = null;
                            StringBuffer primaryKeyColumns = new StringBuffer();
                            while (primaryKeys.next()) {
                                String thisKeyName = primaryKeys.getString("PK_NAME");
                                pkNames.add(thisKeyName);
                                if ((thisKeyName != null && primaryKeyName == null)
                                        || (thisKeyName == null && primaryKeyName != null)
                                        || (thisKeyName != null && ! thisKeyName.equals(primaryKeyName))
                                        || (primaryKeyName != null && ! primaryKeyName.equals(thisKeyName))) {
                                    // the keynames aren't the same, so output all that we have so far (if anything)
                                    // and start a new primary key entry
                                    if (primaryKeyColumns.length() > 0) {
                                        // There's something to output
                                    	strings.initResult.append(",\n CONSTRAINT "+primaryKeyName+" PRIMARY KEY ");

                                    	strings.initResult.append("("+primaryKeyColumns.toString()+")");
                                    }
                                    // Start again with the new name
                                    primaryKeyColumns = new StringBuffer();
                                    primaryKeyName = thisKeyName;
                                }
                                // Now append the column
                                if (primaryKeyColumns.length() > 0) {
                                    primaryKeyColumns.append(", ");
                                }
                                primaryKeyColumns.append(primaryKeys.getString("COLUMN_NAME"));
                            }
                            if (primaryKeyColumns.length() > 0) {
                                // There's something to output
                            	strings.initResult.append(",\n    CONSTRAINT "+primaryKeyName+" PRIMARY KEY ");
                            	strings.initResult.append(" ("+primaryKeyColumns.toString()+")");
                            }
                        } catch (SQLException e) {
                            // NB you will get this exception with the JDBC-ODBC link because it says
                            // [Microsoft][ODBC Driver Manager] Driver does not support this function
                            System.err.println("Unable to get primary keys for table "+tableName+" because "+e);
                        }
                        strings.initResult.append("\n);\n");
                        //and FK
                        try{
                        	ResultSet exportedKeys = dbMetaData.getExportedKeys(catalog, tableSchema, tableName);

//                        	PKTABLE_CAT String => primary key table catalog (may be null)
//                        	PKTABLE_SCHEM String => primary key table schema (may be null)
//                        	PKTABLE_NAME String => primary key table name
//                        	PKCOLUMN_NAME String => primary key column name
//                        	FKTABLE_CAT String => foreign key table catalog (may be null) being exported (may be null)
//                        	FKTABLE_SCHEM String => foreign key table schema (may be null) being exported (may be null)
//                        	FKTABLE_NAME String => foreign key table name being exported
//                        	FKCOLUMN_NAME String => foreign key column name being exported
//                        	KEY_SEQ short => sequence number within foreign key( a value of 1 represents the first column of the foreign key, a value of 2 would represent the second column within the foreign key).
//                        	UPDATE_RULE short => What happens to foreign key when primary is updated:
//                        	importedNoAction - do not allow update of primary key if it has been imported
//                        	importedKeyCascade - change imported key to agree with primary key update
//                        	importedKeySetNull - change imported key to NULL if its primary key has been updated
//                        	importedKeySetDefault - change imported key to default values if its primary key has been updated
//                        	importedKeyRestrict - same as importedKeyNoAction (for ODBC 2.x compatibility)
//                        	DELETE_RULE short => What happens to the foreign key when primary is deleted.
//                        	importedKeyNoAction - do not allow delete of primary key if it has been imported
//                        	importedKeyCascade - delete rows that import a deleted key
//                        	importedKeySetNull - change imported key to NULL if its primary key has been deleted
//                        	importedKeyRestrict - same as importedKeyNoAction (for ODBC 2.x compatibility)
//                        	importedKeySetDefault - change imported key to default if its primary key has been deleted
//                        	FK_NAME String => foreign key name (may be null)
//                        	PK_NAME String => primary key name (may be null)
//                        	DEFERRABILITY short => can the evaluation of foreign key constraints be deferred until commit
//                        	importedKeyInitiallyDeferred - see SQL92 for definition
//                        	importedKeyInitiallyImmediate - see SQL92 for definition
//                        	importedKeyNotDeferrable - see SQL92 for definition 

                        while(exportedKeys.next()){
                        	String fkName = exportedKeys.getString("FK_NAME");
                        	String fKColumnName = exportedKeys.getString("FKCOLUMN_NAME");
                        	String pKColumnName = exportedKeys.getString("PKCOLUMN_NAME");
                        	String fKTableFullName = exportedKeys.getString("FKTABLE_SCHEM")+"."+exportedKeys.getString("FKTABLE_NAME");

                        	strings.fkREsult.append("\n--fk for "+fKTableFullName+"\n");
                        	strings.fkREsult.append("\nALTER TABLE "+fKTableFullName+"\n");
                        	strings.fkREsult.append(" ADD CONSTRAINT "+fkName + " FOREIGN KEY ("+ fKColumnName+  ")\n");
                        	strings.fkREsult.append(" REFERENCES "+fullTableName +"("+ pKColumnName+  ") \n");
                        	strings.fkREsult.append("     ON UPDATE NO ACTION\n");
                        	strings.fkREsult.append("     ON DELETE RESTRICT;\n");
                        }
                        exportedKeys.close();
                        }catch(Exception e){
                        	System.out.println(e);
                        }
                      //and INDEX
                        try{
	                        ResultSet indexInfo = dbMetaData.getIndexInfo(catalog, tableSchema, tableName, false, false);
//	                        TABLE_CAT String => table catalog (may be null)
//	                        TABLE_SCHEM String => table schema (may be null)
//	                        TABLE_NAME String => table name
//	                        NON_UNIQUE boolean => Can index values be non-unique. false when TYPE is tableIndexStatistic
//	                        INDEX_QUALIFIER String => index catalog (may be null); null when TYPE is tableIndexStatistic
//	                        INDEX_NAME String => index name; null when TYPE is tableIndexStatistic
//	                        TYPE short => index type:
//	                        tableIndexStatistic - this identifies table statistics that are returned in conjuction with a table's index descriptions
//	                        tableIndexClustered - this is a clustered index
//	                        tableIndexHashed - this is a hashed index
//	                        tableIndexOther - this is some other style of index
//	                        ORDINAL_POSITION short => column sequence number within index; zero when TYPE is tableIndexStatistic
//	                        COLUMN_NAME String => column name; null when TYPE is tableIndexStatistic
//	                        ASC_OR_DESC String => column sort sequence, "A" => ascending, "D" => descending, may be null if sort sequence is not supported; null when TYPE is tableIndexStatistic
//	                        CARDINALITY int => When TYPE is tableIndexStatistic, then this is the number of rows in the table; otherwise, it is the number of unique values in the index.
//	                        PAGES int => When TYPE is tableIndexStatisic then this is the number of pages used for the table, otherwise it is the number of pages used for the current index.
//	                        FILTER_CONDITION String => Filter condition, if any. (may be null) 

	                        //TODO if index unique and if something else than btree
	                        String indexComment = "\n--index for  "+fullTableName+"\n";
	                        boolean hasIndex = false;
	                        String indexPreviousName = null;
	                        String columnNames="";
	                        StringBuilder tempIndexResult = new StringBuilder();

	                        while(indexInfo.next()){
	                        	String indexName = indexInfo.getString("INDEX_NAME");
	                        	if(!pkNames.contains(indexName)){
	                        		if(hasIndex == false){
	                        			tempIndexResult.append(indexComment);
	                        			hasIndex = true;
	                        		}
	                        		String columnName = indexInfo.getString("COLUMN_NAME");

	                        		if(indexName.equals(indexPreviousName)){
	                        			tempIndexResult = new StringBuilder();
	                        			columnNames = columnNames+", "+ columnName;
	                        			tempIndexResult.append(" CREATE INDEX "+indexName);
	                        			tempIndexResult.append("  ON "+fullTableName);
	                        			tempIndexResult.append("  USING btree ("+columnNames+") ; \n");

	                        		}else{
	                        			strings.indexResult.append(""+tempIndexResult);

	                        			tempIndexResult = new StringBuilder();
			                        	columnNames = columnName;
			                        	tempIndexResult.append(" CREATE INDEX "+indexName);
			                        	tempIndexResult.append("  ON "+fullTableName);
			                        	tempIndexResult.append("  USING btree ("+columnName+") ; \n");
	                        		}
	                        		indexPreviousName = indexName;
	                        	}

	                        }
	                        strings.indexResult.append(""+tempIndexResult);

	                        indexInfo.close();
                        }catch(Exception e){
                        	System.out.println(e);
                        }

                        try{
                        	//TODO doesnt work well because of unknown grants
	                        ResultSet grants = dbMetaData.getTablePrivileges(catalog, null, tableName);

//	                        TABLE_CAT String => table catalog (may be null)
//	                        TABLE_SCHEM String => table schema (may be null)
//	                        TABLE_NAME String => table name
//	                        GRANTOR String => grantor of access (may be null)
//	                        GRANTEE String => grantee of access
//	                        PRIVILEGE String => name of access (SELECT, INSERT, UPDATE, REFRENCES, ...)
//	                        IS_GRANTABLE String => "YES" if grantee is permitted to grant to others; "NO" if not; null if unknown 

	                        strings.grantResult.append("\n-- grants on "+fullTableName+"\n");
	                        while(grants.next()){

	                        	String privileges = grants.getString("PRIVILEGE");

	                        	String grantee = grants.getString("GRANTEE");

	                        	strings.grantResult.append(" GRANT "+privileges+ " ON "+fullTableName+ " TO "+grantee+ ";\n");

	                        }
	                        grants.close();
                        }catch(Exception e){
                        	System.out.println(e);
                        }

                        // Right, we have a table, so we can go and dump it
                        dumpTable(dbConn, strings.insertResult, fullTableName);

                    }
                    else if("VIEW".equalsIgnoreCase(tableType)){

                    	strings.viewResult.append("\nCREATE VIEW "+fullTableName+" \n(\n");
                    	strings.viewResult.append("");
                    	boolean firstLine = true;
                    	ResultSet tableMetaData = dbMetaData.getColumns(null, null, tableName, "%");
                    	while(tableMetaData.next()){
                            if (firstLine) {
                                firstLine = false;
                            } else {
                                // If we're not the first line, then finish the previous line with a comma
                            	strings.viewResult.append(",\n");
                            }
                            String columnName = tableMetaData.getString("COLUMN_NAME");
                            strings.viewResult.append("   "+columnName);
                    	}

                    	strings.viewResult.append("\n)\nAS\n ");

                    	ResultSet executeQuery = dbConn.prepareCall(
                    			" SELECT * FROM pg_views " +
                    			" WHERE viewname = '"+tableName+"'")
                    			.executeQuery();
                    	executeQuery.next();
                    	strings.viewResult.append(executeQuery.getString("definition"));

                    }

                } while (rs.next());
                rs.close();
            }
            //functions
            try{
            	//TODO if more than 3 arguments on function ... it fails.
            String functionDataString =
            " SELECT r.* ,"+
			" (CASE WHEN pronargs = 0 THEN '' "+
			"       WHEN pronargs = 1 THEN (SELECT typname FROM pg_type WHERE oid = proargtypes [0]) "+
			"       WHEN pronargs = 2 THEN (SELECT typname FROM pg_type WHERE oid = proargtypes [0]) || ', ' ||(SELECT typname FROM pg_type WHERE oid = proargtypes [1]) "+
			"       WHEN pronargs = 3 THEN (SELECT typname FROM pg_type WHERE oid = proargtypes [0]) || ', ' ||(SELECT typname FROM pg_type WHERE oid = proargtypes [1]) || ', ' ||(SELECT typname FROM pg_type WHERE oid = proargtypes [2])"+
			"       ELSE 'exception' "+
			" 			  END) as args"+
			" FROM"+
			" (SELECT r.routine_schema sname, "+
			"    r.routine_name AS fname,"+
			"    r.security_type,"+
			"    r.routine_definition as data,"+
			"    r.external_language AS language,"+
			"    r.data_type AS return_type"+
			" FROM information_schema.routines r"+
			" WHERE r.specific_schema  'information_schema' AND r.specific_schema 'pg_catalog'"+
			" ) as r, pg_proc p"+
			" WHERE  p.proname = r.fname";
            ResultSet functionColumns = dbConn.prepareCall(functionDataString)
        			.executeQuery();

            while(functionColumns.next()){
            	String funSchema = functionColumns.getString("sname");
            	String funName = functionColumns.getString("fname");
            	String args = functionColumns.getString("args");
            	String returnType = functionColumns.getString("return_type");
            	String security = functionColumns.getString("security_type");
            	String pllanguage = functionColumns.getString("language");
            	String fData = functionColumns.getString("data").replaceAll("'", "''");

            	strings.functionResult.append("CREATE OR REPLACE FUNCTION "+funSchema+"."+funName+"("+args+") RETURNS "+returnType+"\n SECURITY "+security+" " +
            			" LANGUAGE "+pllanguage+ " AS '"+fData+" ' ;\n");

            }
            }catch(Exception e){
            	System.err.println(e);
            }

            //sequences
            try{

            ResultSet sequences = dbConn.prepareCall("select sequence_name,sequence_schema from information_schema.sequences s ")
        			.executeQuery();

            while(sequences.next()){
            	String sSchema = sequences.getString("sequence_schema");
            	String sName = sequences.getString("sequence_name");

            	ResultSet query = dbConn.prepareCall("select start_value, increment_by from "+sSchema+"."+sName).executeQuery();
            	query.next();
            	String startValue = query.getString("start_value");
            	String incrementBy = query.getString("increment_by");

            	strings.sequenceResult.append("\nCREATE SEQUENCE "+sSchema+"."+sName+" \n");
            	strings.sequenceResult.append("START WITH "+startValue+" INCREMENT by "+incrementBy+"; \n");

            }
            }catch(Exception e){
            	System.err.println(e);
            }

            dbConn.close();

            for(String s :schemas){
            	strings.schemaResult.append("CREATE SCHEMA "+s+";\n");
            }

            return strings;
        } catch (SQLException e) {
            e.printStackTrace();  //To change body of catch statement use Options | File Templates.
        }
        return null;
    }

	/** dump this particular table to the string buffer */
    private static void dumpTable(Connection dbConn, StringBuilder result, String tableName) {
        try {
            // First we output the create table stuff
            PreparedStatement stmt = dbConn.prepareStatement("SELECT * FROM "+tableName);
            ResultSet rs = stmt.executeQuery();
            ResultSetMetaData metaData = rs.getMetaData();
            int columnCount = metaData.getColumnCount();

            // Now we can output the actual data
            result.append("\n\n-- Data for "+tableName+"\n");
            while (rs.next()) {
                result.append("INSERT INTO "+tableName+" VALUES (");
                for (int i=0; i 0) {
                        result.append(", ");
                    }
                    Object value = rs.getObject(i+1);
                    if (value == null) {
                        result.append("NULL");
                    } else {
                        String outputValue = value.toString();
                        outputValue = outputValue.replaceAll("'","\\'");
                        result.append("'"+outputValue+"'");
                    }
                }
                result.append(");\n");
            }
            rs.close();
            stmt.close();
        } catch (SQLException e) {
            System.err.println("Unable to dump table "+tableName+" because: "+e);
        }
    }

    /** Main method takes arguments for connection to JDBC etc. */
    public static void main(String[] args) {

        if (args.length != 1) {
           System.err.println("usage: db2sql ");
        }
        // Right so there's one argument, we assume it's a property file
        // so lets open it
        Properties props = new Properties();
        try {
            props.load(new FileInputStream(args[0]));

            Strings strings = dumpDB(props);

            try{

			System.out.println(strings.schemaResult.toString());
			System.out.println(strings.initResult.toString());
			System.out.println(strings.functionResult.toString());
			System.out.println(strings.viewResult.toString());
			System.out.println(strings.insertResult.toString());
			System.out.println(strings.indexResult.toString());
			System.out.println(strings.fkREsult.toString());
			System.out.println(strings.sequenceResult.toString());
			/*

            	  FileWriter fstream = new FileWriter("dump_database.txt");
            	  BufferedWriter out = new BufferedWriter(fstream);
            	  out.write(strings.schemaResult.toString());
            	  out.write(strings.initResult.toString());
            	  out.write(strings.functionResult.toString());
            	  out.write(strings.viewResult.toString());
            	  out.write(strings.insertResult.toString());
            	  out.write(strings.indexResult.toString());
            	  out.write(strings.fkREsult.toString());
            	  out.write(strings.sequenceResult.toString());
            	  //Close the output stream
            	  out.close();
            	  }catch (Exception e){//Catch exception if any
            	  System.err.println("Error: " + e.getMessage());
            	  }
            */

        } catch (IOException e) {
            System.err.println("Unable to open property file: "+args[0]+" exception: "+e);
        }

    }
}
class Strings{
	StringBuilder schemaResult = new StringBuilder();
	StringBuilder initResult = new StringBuilder();
	StringBuilder functionResult = new StringBuilder();
	StringBuilder viewResult = new StringBuilder();
	StringBuilder fkREsult = new StringBuilder();
	StringBuilder indexResult = new StringBuilder();
	StringBuilder insertResult = new StringBuilder();
	StringBuilder grantResult = new StringBuilder();
	StringBuilder sequenceResult = new StringBuilder();

}

Please help on what i must do

You do need the properties file (unless you want to hard-code the values in to the Java). You can call the properties file (a simple text file) whatever you like and then pass it as a parameter to the program when you run it.

is it possible to run your code: http://www.isocra.com/articles/db2sql.java without using the properties file?
i want to copy the database, tables, and its data and convert it to mysql

PS:
Sorry the name mix up…