Metacat

// No copyright, no warranty; use as you will.

// Written by Ronald Bourret, Technical University of Darmstadt, 1998-9

import de.tudarmstadt.ito.xmldbms.Map;

import de.tudarmstadt.ito.xmldbms.mapfactories.MapFactory_DTD;

import java.io.File;

import java.io.FileOutputStream;

import java.io.OutputStream;

import java.sql.Connection;

import java.sql.DriverManager;

import java.util.Hashtable;

import oracle.xml.parser.XMLParser;

import org.xml.sax.InputSource;

import org.xml.sax.Parser;

/**

 * This application generates a map and a file of CREATE TABLE statements

 * from an input document. The input document can be a DTD, DDML document,

 * or XML document that has a DTD (including referencing an external DTD).

 * The document type is determined from the extension: .dtd for DTDs and

 * .ddm for DDML documents; everything else is assumed to be an XML document.

 * The documents have the same base name as the input document, but uses

 * extensions of .map and .sql.

 *

 * <P>The command line syntax for this application is:</P>

 * <PRE>

 *    java GenerateMap <input-file>

 * </PRE>

 */

public class GenerateMap

{

   static final byte[] RETURN = System.getProperty("line.separator").getBytes();

   public static void main (String[] argv)

   {

      try

      {

         if (argv.length != 1)

         {

            System.out.println("\nUsage: java GenerateMap <input-file>\n");

            return;

         }

         generateMap(argv[0]);

      }

      catch (Exception e)

      {

         e.printStackTrace();

      }

   }

   static void generateMap(String filename)

      throws Exception

   {

      Map              map;

      String           basename;

      InputSource      src;

      // Create an InputSource over the schema/DTD file.

      src = new InputSource(getFileURL(filename));

      // Get the basename of the file.

      basename = getBasename(filename);

      // Create and serialize the Map, then create the CREATE TABLE statements.

      map = createMap(src, filename);

      serializeMap(map, basename);

      createStatements(map, basename);

   }

   static Map createMap(InputSource src, String filename)

      throws Exception

   {

      MapFactory_DTD factory = new MapFactory_DTD();

      String         ext = getExtension(filename);

      Hashtable      namespaceURIs = null;

      // Determine the document type from its extension: .DDM for DDML and .DTD

      // for external subsets. Everything else is assumed to be an XML document

      // containing a DTD. Based on the document type, call the appropriate

      // functions to generate the Map.

      // If you are converting from a DTD and there are namespace prefixes

      // in that DTD, you need to declare them here, putting each one in

      // the namespaceURIs hashtable with the prefix as the key and the

      // namespace URI as the value. For example, the following

      // commented-out lines state that the DDML prefix corresponds to

      // the http://www.purl.org/NET/ddml/v1 URI. Note that the default

      // namespace can be declared by adding an empty string ("") as a key.

//      namespaceURIs = new Hashtable();

//      namespaceURIs.put("DDML", "http://www.purl.org/NET/ddml/v1");

      if (ext.equals("DDM"))

      {

         // DDML Document.

         // Note that this is hard-coded to use the Oracle version 1 parser.

         return factory.createMapFromSchema(src, MapFactory_DTD.SCHEMA_DDML, true, new XMLParser());

      }

      else if (ext.equals("DTD"))

      {

         // External subset (DTD)

         return factory.createMapFromDTD(src, MapFactory_DTD.DTD_EXTERNAL, true, namespaceURIs);

      }

      else

      {

         // Assume we have an XML document containing a DTD.

         return factory.createMapFromDTD(src, MapFactory_DTD.DTD_XMLDOCUMENT, true, namespaceURIs);

      }

   }

   static void serializeMap(Map map, String basename)

      throws Exception

   {

      FileOutputStream mapFile;

      // Serialize the map to a mapping document with the same base name.

      mapFile = new FileOutputStream(basename + ".map");

      map.serialize(mapFile, true, 3);

      mapFile.close();

   }

   static void createStatements(Map map, String basename)

      throws Exception

   {

      FileOutputStream sqlFile;

      String[]         createStrings;

      String           url = "jdbc:odbc:xmldbms",

                       driver = "sun.jdbc.odbc.JdbcOdbcDriver";

      Connection       conn;

      // Connect to the database and pass the JDBC Connection to the

      // Map object. The Map object needs this to retrieve information

      // about how to construct the CREATE TABLE statements.

      Class.forName(driver);

      conn = DriverManager.getConnection(url);

      map.setConnection(conn);

      // Create the output file.

      sqlFile = new FileOutputStream(basename + ".sql");

      // Get the CREATE TABLE strings from the Map object and write them to

      // the output file.

      createStrings = map.getCreateTableStrings();

      for (int i = 0; i < createStrings.length; i++)

      {

         sqlFile.write(createStrings[i].getBytes());

         sqlFile.write(RETURN);

      }

      // Close the output file.

      sqlFile.close();

   }

   static String getFileURL(String fileName)

   {

      File   file;

      String path, separator;

      // Construct a file URL for the file.

      file = new File(fileName);

      return "file:///" + file.getAbsolutePath();

   }

   static String getBasename(String filename)

   {

      int    period;

      // Get the basename of the file.

      period = filename.lastIndexOf('.', filename.length());

      if (period == -1)

      {

         return filename;

      }

      else

      {

         return filename.substring(0, period);

      }

   }

   static String getExtension(String filename)

   {

      int    period;

      // Get the file extension.

      period = filename.lastIndexOf('.', filename.length());

      if (period == -1)

      {

         return "";

      }

      else

      {

         return filename.substring(period + 1, filename.length()).toUpperCase();

      }

   }

}