diff --git a/.classpath b/.classpath
index ab8de05..c03a842 100644
--- a/.classpath
+++ b/.classpath
@@ -34,6 +34,5 @@
 	<classpathentry kind="lib" path="lib/build-only/junit-3.8.2.jar"/>
 	<classpathentry kind="lib" path="lib/stax-api-1.0.1.jar"/>
 	<classpathentry kind="lib" path="lib/log4j-1.2.8.jar"/>
-	<classpathentry kind="lib" path="lib/commons-betwixt-0.8.jar"/>
 	<classpathentry kind="output" path="target/classes"/>
 </classpath>
diff --git a/lib/commons-betwixt-0.8.jar b/lib/commons-betwixt-0.8.jar
deleted file mode 100644
index ab00040..0000000
--- a/lib/commons-betwixt-0.8.jar
+++ /dev/null
Binary files differ
diff --git a/src/java/org/apache/ddlutils/io/DataWriter.java b/src/java/org/apache/ddlutils/io/DataWriter.java
index 8d5d9d6..b90b06c 100644
--- a/src/java/org/apache/ddlutils/io/DataWriter.java
+++ b/src/java/org/apache/ddlutils/io/DataWriter.java
@@ -20,7 +20,6 @@
  */
 
 import java.io.OutputStream;
-import java.io.PrintWriter;
 import java.io.Writer;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -29,10 +28,6 @@
 import java.util.List;
 import java.util.Map;
 
-import javax.xml.stream.XMLOutputFactory;
-import javax.xml.stream.XMLStreamException;
-import javax.xml.stream.XMLStreamWriter;
-
 import org.apache.commons.beanutils.DynaBean;
 import org.apache.commons.codec.binary.Base64;
 import org.apache.commons.logging.Log;
@@ -51,27 +46,17 @@
  * 
  * @version $Revision: 289996 $
  */
-public class DataWriter
+public class DataWriter extends PrettyPrintingXmlWriter
 {
     /** String values with a size not bigger than this value will be written to attributes;
         if their size is longer, then a sub element is generated instead. */ 
     private static final int MAX_ATTRIBUTE_LENGTH = 255;
-    /** The indentation string. */
-    private static final String INDENT_STRING = "  ";
 
     /** Our log. */
     private final Log _log = LogFactory.getLog(DataWriter.class);
 
     /** The converters. */
     private ConverterConfiguration _converterConf = new ConverterConfiguration();
-    /** The output stream. */
-    private PrintWriter _output;
-    /** The xml writer. */
-    private XMLStreamWriter _writer;
-    /** The output encoding. */
-    private String _encoding;
-    /** Whether we're pretty-printing. */
-    private boolean _prettyPrinting = true;
 
     /**
      * Creates a data writer instance using UTF-8 encoding.
@@ -91,26 +76,7 @@
      */
     public DataWriter(OutputStream output, String encoding) throws DataWriterException
     {
-        _output = new PrintWriter(output);
-        if ((encoding == null) || (encoding.length() == 0))
-        {
-            _encoding = "UTF-8";
-        }
-        else
-        {
-            _encoding = encoding;
-        }
-
-        try
-        {
-            XMLOutputFactory factory = XMLOutputFactory.newInstance();
-
-            _writer  = factory.createXMLStreamWriter(output, _encoding);
-        }
-        catch (XMLStreamException ex)
-        {
-            throw new DataWriterException(ex);
-        }
+        super(output, encoding);
     }
 
     /**
@@ -122,38 +88,15 @@
      */
     public DataWriter(Writer output, String encoding) throws DataWriterException
     {
-        _output   = new PrintWriter(output);
-        _encoding = encoding;
-        try
-        {
-            XMLOutputFactory factory = XMLOutputFactory.newInstance();
-
-            _writer = factory.createXMLStreamWriter(_output);
-        }
-        catch (XMLStreamException ex)
-        {
-            throw new DataWriterException(ex);
-        }
+        super(output, encoding);
     }
 
     /**
-     * Determines whether the output shall be pretty-printed.
-     *
-     * @return <code>true</code> if the output is pretty-printed
+     * {@inheritDoc}
      */
-    public boolean isPrettyPrinting()
+    protected void throwException(Exception baseEx) throws DdlUtilsXMLException
     {
-        return _prettyPrinting;
-    }
-
-    /**
-     * Specifies whether the output shall be pretty-printed.
-     *
-     * @param prettyPrinting <code>true</code> if the output is pretty-printed
-     */
-    public void setPrettyPrinting(boolean prettyPrinting)
-    {
-        _prettyPrinting = prettyPrinting;
+        throw new DataWriterException(baseEx);
     }
 
     /**
@@ -167,83 +110,25 @@
     }
 
     /**
-     * Prints a newline if we're pretty-printing.
+     * Writes the start of the XML document, including the start of the outermost
+     * XML element (<code>data</code>).
      */
-    private void printlnIfPrettyPrinting() throws DataWriterException
+    public void writeDocumentStart() throws DdlUtilsXMLException
     {
-        if (_prettyPrinting)
-        {
-            try
-            {
-                _writer.writeCharacters("\n");
-            }
-            catch (XMLStreamException ex)
-            {
-                throw new DataWriterException(ex);
-            }
-        }
+        super.writeDocumentStart();
+        writeElementStart(null, "data");
+        printlnIfPrettyPrinting();
     }
 
     /**
-     * Prints the indentation if we're pretty-printing.
-     * 
-     * @param level The indentation level
+     * Writes the end of the XML document, including the end of the outermost
+     * XML element (<code>data</code>).
      */
-    private void indentIfPrettyPrinting(int level) throws DataWriterException
+    public void writeDocumentEnd() throws DdlUtilsXMLException
     {
-        if (_prettyPrinting)
-        {
-            try
-            {
-                for (int idx = 0; idx < level; idx++)
-                {
-                    _writer.writeCharacters(INDENT_STRING);
-                }
-            }
-            catch (XMLStreamException ex)
-            {
-                throw new DataWriterException(ex);
-            }
-        }
-    }
-
-    /**
-     * Writes the start of the XML document, i.e. the "<?xml?>" section and the start of the
-     * root node.
-     */
-    public void writeDocumentStart() throws DataWriterException
-    {
-        try
-        {
-            _writer.writeStartDocument(_encoding, "1.0");
-            printlnIfPrettyPrinting();
-            _writer.writeStartElement("data");
-            printlnIfPrettyPrinting();
-        }
-        catch (XMLStreamException ex)
-        {
-            throw new DataWriterException(ex);
-        }
-    }
-
-    /**
-     * Writes the end of the XML document, i.e. end of the root node.
-     */
-    public void writeDocumentEnd() throws DataWriterException
-    {
-        try
-        {
-            _writer.writeEndElement();
-            printlnIfPrettyPrinting();
-            _writer.writeEndDocument();
-            _writer.flush();
-            _writer.close();
-            _output.close();
-        }
-        catch (XMLStreamException ex)
-        {
-            throw new DataWriterException(ex);
-        }
+        writeElementEnd();
+        printlnIfPrettyPrinting();
+        super.writeDocumentEnd();
     }
 
     /**
@@ -260,7 +145,7 @@
         try
         {
             indentIfPrettyPrinting(1);
-            _writer.writeStartElement(table.getName());
+            writeElementStart(null, table.getName());
             for (int idx = 0; idx < table.getColumnCount(); idx++)
             {
                 Column           column      = table.getColumn(idx);
@@ -290,7 +175,7 @@
                     }
                     else
                     {
-                        _writer.writeAttribute(column.getName(), valueAsText);
+                        writeAttribute(null, column.getName(), valueAsText);
                     }
                 }
             }
@@ -305,7 +190,7 @@
 
                     printlnIfPrettyPrinting();
                     indentIfPrettyPrinting(2);
-                    _writer.writeStartElement(entry.getKey().toString());
+                    writeElementStart(null, entry.getKey().toString());
 
                     // if the content contains special characters, we have to apply base64 encoding to it
                     // if the content is too short, then it has to contain special characters (otherwise
@@ -316,14 +201,14 @@
 
                     if (writeBase64Encoded)
                     {
-                        _writer.writeAttribute(DatabaseIO.BASE64_ATTR_NAME, "true");
-                        _writer.writeCData(new String(Base64.encodeBase64(content.getBytes())));
+                        writeAttribute(null, DatabaseIO.BASE64_ATTR_NAME, "true");
+                        writeCData(new String(Base64.encodeBase64(content.getBytes())));
                     }
                     else
                     {
                         if (cutPoints.isEmpty())
                         {
-                            _writer.writeCData(content);
+                            writeCData(content);
                         }
                         else
                         {
@@ -333,28 +218,24 @@
                             {
                                 int curPos = ((Integer)cutPointIt.next()).intValue();
 
-                                _writer.writeCData(content.substring(lastPos, curPos));
+                                writeCData(content.substring(lastPos, curPos));
                                 lastPos = curPos;
                             }
                             if (lastPos < content.length())
                             {
-                                _writer.writeCData(content.substring(lastPos));
+                                writeCData(content.substring(lastPos));
                             }
                         }
                     }
 
-                    _writer.writeEndElement();
+                    writeElementEnd();
                 }
                 printlnIfPrettyPrinting();
                 indentIfPrettyPrinting(1);
             }
-            _writer.writeEndElement();
+            writeElementEnd();
             printlnIfPrettyPrinting();
         }
-        catch (XMLStreamException ex)
-        {
-            throw new DataWriterException(ex);
-        }
         catch (ConversionException ex)
         {
             throw new DataWriterException(ex);
diff --git a/src/java/org/apache/ddlutils/io/DataWriterException.java b/src/java/org/apache/ddlutils/io/DataWriterException.java
index 4294fa1..e29bff2 100644
--- a/src/java/org/apache/ddlutils/io/DataWriterException.java
+++ b/src/java/org/apache/ddlutils/io/DataWriterException.java
@@ -19,14 +19,13 @@
  * under the License.
  */
 
-import org.apache.commons.lang.exception.NestableRuntimeException;
 
 /**
  * Exception generated by the {@link org.apache.ddlutils.io.DataWriter}.
  * 
  * @version $Revision: 289996 $
  */
-public class DataWriterException extends NestableRuntimeException
+public class DataWriterException extends DdlUtilsXMLException
 {
     /** Unique id for serialization purposes. */
     private static final long serialVersionUID = 6254759931565130848L;
diff --git a/src/java/org/apache/ddlutils/io/DatabaseIO.java b/src/java/org/apache/ddlutils/io/DatabaseIO.java
index d1557c6..5e296b9 100644
--- a/src/java/org/apache/ddlutils/io/DatabaseIO.java
+++ b/src/java/org/apache/ddlutils/io/DatabaseIO.java
@@ -19,9 +19,9 @@
  * under the License.
  */
 
-import java.beans.IntrospectionException;
 import java.io.BufferedWriter;
 import java.io.File;
+import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.OutputStream;
@@ -29,13 +29,23 @@
 import java.io.Reader;
 import java.io.Writer;
 
-import org.apache.commons.betwixt.io.BeanReader;
-import org.apache.commons.betwixt.io.BeanWriter;
-import org.apache.commons.betwixt.strategy.HyphenatedNameMapper;
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+
+import org.apache.commons.lang.StringUtils;
 import org.apache.ddlutils.DdlUtilsException;
+import org.apache.ddlutils.model.Column;
 import org.apache.ddlutils.model.Database;
+import org.apache.ddlutils.model.ForeignKey;
+import org.apache.ddlutils.model.Index;
+import org.apache.ddlutils.model.IndexColumn;
+import org.apache.ddlutils.model.NonUniqueIndex;
+import org.apache.ddlutils.model.Reference;
+import org.apache.ddlutils.model.Table;
+import org.apache.ddlutils.model.UniqueIndex;
 import org.xml.sax.InputSource;
-import org.xml.sax.SAXException;
 
 /**
  * This class provides functions to read and write database models from/to XML.
@@ -48,11 +58,62 @@
         element uses Base64 encoding. */
     public static final String BASE64_ATTR_NAME = "base64";
 
+    /** The namespace used by DdlUtils. */
+    public static final String DDLUTILS_NAMESPACE = "http://db.apache.org/torque/";
+
+    /** Qualified name of the column element. */
+    public static final QName QNAME_ELEMENT_COLUMN        = new QName(DDLUTILS_NAMESPACE, "column");
+    /** Qualified name of the database element. */
+    public static final QName QNAME_ELEMENT_DATABASE      = new QName(DDLUTILS_NAMESPACE, "database");
+    /** Qualified name of the foreign-key element. */
+    public static final QName QNAME_ELEMENT_FOREIGN_KEY   = new QName(DDLUTILS_NAMESPACE, "foreign-key");
+    /** Qualified name of the index element. */
+    public static final QName QNAME_ELEMENT_INDEX         = new QName(DDLUTILS_NAMESPACE, "index");
+    /** Qualified name of the index-column element. */
+    public static final QName QNAME_ELEMENT_INDEX_COLUMN  = new QName(DDLUTILS_NAMESPACE, "index-column");
+    /** Qualified name of the reference element. */
+    public static final QName QNAME_ELEMENT_REFERENCE     = new QName(DDLUTILS_NAMESPACE, "reference");
+    /** Qualified name of the table element. */
+    public static final QName QNAME_ELEMENT_TABLE         = new QName(DDLUTILS_NAMESPACE, "table");
+    /** Qualified name of the unique element. */
+    public static final QName QNAME_ELEMENT_UNIQUE        = new QName(DDLUTILS_NAMESPACE, "unique");
+    /** Qualified name of the unique-column element. */
+    public static final QName QNAME_ELEMENT_UNIQUE_COLUMN = new QName(DDLUTILS_NAMESPACE, "unique-column");
+
+    /** Qualified name of the autoIncrement attribute. */
+    public static final QName QNAME_ATTRIBUTE_AUTO_INCREMENT    = new QName(DDLUTILS_NAMESPACE, "autoIncrement");
+    /** Qualified name of the default attribute. */
+    public static final QName QNAME_ATTRIBUTE_DEFAULT           = new QName(DDLUTILS_NAMESPACE, "default");
+    /** Qualified name of the defaultIdMethod attribute. */
+    public static final QName QNAME_ATTRIBUTE_DEFAULT_ID_METHOD = new QName(DDLUTILS_NAMESPACE, "defaultIdMethod");
+    /** Qualified name of the description attribute. */
+    public static final QName QNAME_ATTRIBUTE_DESCRIPTION       = new QName(DDLUTILS_NAMESPACE, "description");
+    /** Qualified name of the foreign attribute. */
+    public static final QName QNAME_ATTRIBUTE_FOREIGN           = new QName(DDLUTILS_NAMESPACE, "foreign");
+    /** Qualified name of the foreignTable attribute. */
+    public static final QName QNAME_ATTRIBUTE_FOREIGN_TABLE     = new QName(DDLUTILS_NAMESPACE, "foreignTable");
+    /** Qualified name of the javaName attribute. */
+    public static final QName QNAME_ATTRIBUTE_JAVA_NAME         = new QName(DDLUTILS_NAMESPACE, "javaName");
+    /** Qualified name of the local attribute. */
+    public static final QName QNAME_ATTRIBUTE_LOCAL             = new QName(DDLUTILS_NAMESPACE, "local");
+    /** Qualified name of the name attribute. */
+    public static final QName QNAME_ATTRIBUTE_NAME              = new QName(DDLUTILS_NAMESPACE, "name");
+    /** Qualified name of the primaryKey attribute. */
+    public static final QName QNAME_ATTRIBUTE_PRIMARY_KEY       = new QName(DDLUTILS_NAMESPACE, "primaryKey");
+    /** Qualified name of the required attribute. */
+    public static final QName QNAME_ATTRIBUTE_REQUIRED          = new QName(DDLUTILS_NAMESPACE, "required");
+    /** Qualified name of the size attribute. */
+    public static final QName QNAME_ATTRIBUTE_SIZE              = new QName(DDLUTILS_NAMESPACE, "size");
+    /** Qualified name of the type attribute. */
+    public static final QName QNAME_ATTRIBUTE_TYPE              = new QName(DDLUTILS_NAMESPACE, "type");
+    /** Qualified name of the version attribute. */
+    public static final QName QNAME_ATTRIBUTE_VERSION           = new QName(DDLUTILS_NAMESPACE, "version");
+
     /** Whether to validate the XML. */
     private boolean _validateXml = true;
     /** Whether to use the internal dtd that comes with DdlUtils. */
     private boolean _useInternalDtd = true;
-
+    
     /**
      * Returns whether XML is validated upon reading it.
      * 
@@ -94,66 +155,6 @@
     }
 
     /**
-     * Returns the commons-betwixt mapping file as an {@link org.xml.sax.InputSource} object.
-     * Per default, this will be classpath resource under the path <code>/mapping.xml</code>.
-     *  
-     * @return The input source for the mapping
-     */
-    protected InputSource getBetwixtMapping()
-    {
-        return new InputSource(getClass().getResourceAsStream("/mapping.xml"));
-    }
-    
-    /**
-     * Returns a new bean reader configured to read database models.
-     * 
-     * @return The reader
-     */
-    protected BeanReader getReader() throws IntrospectionException, SAXException, IOException
-    {
-        BeanReader reader = new BeanReader();
-
-        reader.getXMLIntrospector().getConfiguration().setAttributesForPrimitives(true);
-        reader.getXMLIntrospector().getConfiguration().setWrapCollectionsInElement(false);
-        reader.getXMLIntrospector().getConfiguration().setElementNameMapper(new HyphenatedNameMapper());
-        reader.setValidating(isValidateXml());
-        if (isUseInternalDtd())
-        {
-            reader.setEntityResolver(new LocalEntityResolver());
-        }
-        reader.registerMultiMapping(getBetwixtMapping());
-
-        return reader;
-    }
-
-    /**
-     * Returns a new bean writer configured to writer database models.
-     * 
-     * @param output The target output writer
-     * @return The writer
-     */
-    protected BeanWriter getWriter(Writer output) throws DdlUtilsException
-    {
-        try
-        {
-            BeanWriter writer = new BeanWriter(output);
-    
-            writer.getXMLIntrospector().register(getBetwixtMapping());
-            writer.getXMLIntrospector().getConfiguration().setAttributesForPrimitives(true);
-            writer.getXMLIntrospector().getConfiguration().setWrapCollectionsInElement(false);
-            writer.getXMLIntrospector().getConfiguration().setElementNameMapper(new HyphenatedNameMapper());
-            writer.getBindingConfiguration().setMapIDs(false);
-            writer.enablePrettyPrint();
-    
-            return writer;
-        }
-        catch (Exception ex)
-        {
-            throw new DdlUtilsException(ex);
-        }
-    }
-
-    /**
      * Reads the database model contained in the specified file.
      * 
      * @param filename The model file name
@@ -161,18 +162,14 @@
      */
     public Database read(String filename) throws DdlUtilsException
     {
-        Database model = null;
-
         try
         {
-            model = (Database)getReader().parse(filename);
+            return read(new FileReader(filename));
         }
-        catch (Exception ex)
+        catch (IOException ex)
         {
             throw new DdlUtilsException(ex);
         }
-        model.initialize();
-        return model;
     }
 
     /**
@@ -183,18 +180,14 @@
      */
     public Database read(File file) throws DdlUtilsException
     {
-        Database model = null;
-
         try
         {
-            model = (Database)getReader().parse(file);
+            return read(new FileReader(file));
         }
-        catch (Exception ex)
+        catch (IOException ex)
         {
             throw new DdlUtilsException(ex);
         }
-        model.initialize();
-        return model;
     }
 
     /**
@@ -205,18 +198,14 @@
      */
     public Database read(Reader reader) throws DdlUtilsException
     {
-        Database model = null;
-
         try
         {
-            model = (Database)getReader().parse(reader);
+            return read(getXMLInputFactory().createXMLStreamReader(reader));
         }
-        catch (Exception ex)
+        catch (XMLStreamException ex)
         {
             throw new DdlUtilsException(ex);
         }
-        model.initialize();
-        return model;
     }
 
     /**
@@ -227,27 +216,563 @@
      */
     public Database read(InputSource source) throws DdlUtilsException
     {
+        try
+        {
+            return read(getXMLInputFactory().createXMLStreamReader(source.getCharacterStream()));
+        }
+        catch (XMLStreamException ex)
+        {
+            throw new DdlUtilsException(ex);
+        }
+    }
+
+    /**
+     * Creates a new, initialized XML input factory object.
+     * 
+     * @return The factory object
+     */
+    private XMLInputFactory getXMLInputFactory()
+    {
+        XMLInputFactory factory = XMLInputFactory.newInstance();
+
+        factory.setProperty("javax.xml.stream.isCoalescing",     Boolean.TRUE);
+        factory.setProperty("javax.xml.stream.isNamespaceAware", Boolean.TRUE);
+        return factory;
+    }
+
+    /**
+     * Reads the database model from the given XML stream reader.
+     * 
+     * @param xmlReader The reader
+     * @return The database model
+     */
+    private Database read(XMLStreamReader xmlReader) throws DdlUtilsException
+    {
         Database model = null;
 
         try
         {
-            model = (Database)getReader().parse(source);
+            while (xmlReader.getEventType() != XMLStreamReader.START_ELEMENT)
+            {
+                if (xmlReader.next() == XMLStreamReader.END_DOCUMENT)
+                {
+                    return null;
+                }
+            }
+            if (isSameAs(xmlReader.getName(), QNAME_ELEMENT_DATABASE))
+            {
+                model = readDatabaseElement(xmlReader);
+            }
         }
-        catch (Exception ex)
+        catch (IOException ex)
         {
             throw new DdlUtilsException(ex);
         }
-        model.initialize();
+        catch (XMLStreamException ex)
+        {
+            throw new DdlUtilsException(ex);
+        }
+        if (model != null)
+        {
+            model.initialize();
+        }
         return model;
     }
 
     /**
+     * Reads a database element from the XML stream reader.
+     * 
+     * @param xmlReader The reader
+     * @return The database object
+     */
+    private Database readDatabaseElement(XMLStreamReader xmlReader) throws XMLStreamException, IOException
+    {
+        Database model = new Database();
+
+        for (int idx = 0; idx < xmlReader.getAttributeCount(); idx++)
+        {
+            QName attrQName = xmlReader.getAttributeName(idx);
+
+            if (isSameAs(attrQName, QNAME_ATTRIBUTE_NAME))
+            {
+                model.setName(xmlReader.getAttributeValue(idx));
+            }
+            else if (isSameAs(attrQName, QNAME_ATTRIBUTE_DEFAULT_ID_METHOD))
+            {
+                model.setIdMethod(xmlReader.getAttributeValue(idx));
+            }
+            else if (isSameAs(attrQName, QNAME_ATTRIBUTE_VERSION))
+            {
+                model.setVersion(xmlReader.getAttributeValue(idx));
+            }
+        }
+        readTableElements(xmlReader, model);
+        consumeRestOfElement(xmlReader);
+        return model;
+    }
+
+    /**
+     * Reads table elements from the XML stream reader and adds them to the given
+     * database model.
+     * 
+     * @param xmlReader The reader
+     * @param model     The database model to add the table objects to
+     */
+    private void readTableElements(XMLStreamReader xmlReader, Database model) throws XMLStreamException, IOException
+    {
+        int eventType = XMLStreamReader.START_ELEMENT;
+
+        while (eventType != XMLStreamReader.END_ELEMENT)
+        {
+            eventType = xmlReader.nextTag();
+            if (eventType == XMLStreamReader.START_ELEMENT)
+            {
+                if (isSameAs(xmlReader.getName(), QNAME_ELEMENT_TABLE)) {
+                    model.addTable(readTableElement(xmlReader));
+                }
+                else {
+                    readOverElement(xmlReader);
+                }
+            }
+        }
+    }
+
+    /**
+     * Reads a table element from the XML stream reader.
+     * 
+     * @param xmlReader The reader
+     * @return The table object
+     */
+    private Table readTableElement(XMLStreamReader xmlReader) throws XMLStreamException, IOException
+    {
+        Table table = new Table();
+
+        for (int idx = 0; idx < xmlReader.getAttributeCount(); idx++)
+        {
+            QName attrQName = xmlReader.getAttributeName(idx);
+
+            if (isSameAs(attrQName, QNAME_ATTRIBUTE_NAME))
+            {
+                table.setName(xmlReader.getAttributeValue(idx));
+            }
+            else if (isSameAs(attrQName, QNAME_ATTRIBUTE_DESCRIPTION))
+            {
+                table.setDescription(xmlReader.getAttributeValue(idx));
+            }
+        }
+        readTableSubElements(xmlReader, table);
+        consumeRestOfElement(xmlReader);
+        return table;
+    }
+
+    /**
+     * Reads table sub elements (column, foreign key, index) from the XML stream reader and adds
+     * them to the given table.
+     * 
+     * @param xmlReader The reader
+     * @param table     The table
+     */
+    private void readTableSubElements(XMLStreamReader xmlReader, Table table) throws XMLStreamException, IOException
+    {
+        int eventType = XMLStreamReader.START_ELEMENT;
+
+        while (eventType != XMLStreamReader.END_ELEMENT)
+        {
+            eventType = xmlReader.nextTag();
+            if (eventType == XMLStreamReader.START_ELEMENT)
+            {
+                QName elemQName = xmlReader.getName();
+
+                if (isSameAs(elemQName, QNAME_ELEMENT_COLUMN))
+                {
+                    table.addColumn(readColumnElement(xmlReader));
+                }
+                else if (isSameAs(elemQName, QNAME_ELEMENT_FOREIGN_KEY))
+                {
+                    table.addForeignKey(readForeignKeyElement(xmlReader));
+                }
+                else if (isSameAs(elemQName, QNAME_ELEMENT_INDEX))
+                {
+                    table.addIndex(readIndexElement(xmlReader));
+                }
+                else if (isSameAs(elemQName, QNAME_ELEMENT_UNIQUE))
+                {
+                    table.addIndex(readUniqueElement(xmlReader));
+                }
+                else {
+                    readOverElement(xmlReader);
+                }
+            }
+        }
+    }
+
+    /**
+     * Reads a column element from the XML stream reader.
+     * 
+     * @param xmlReader The reader
+     * @return The column object
+     */
+    private Column readColumnElement(XMLStreamReader xmlReader) throws XMLStreamException, IOException
+    {
+        Column column = new Column();
+
+        for (int idx = 0; idx < xmlReader.getAttributeCount(); idx++)
+        {
+            QName attrQName = xmlReader.getAttributeName(idx);
+
+            if (isSameAs(attrQName, QNAME_ATTRIBUTE_NAME))
+            {
+                column.setName(xmlReader.getAttributeValue(idx));
+            }
+            else if (isSameAs(attrQName, QNAME_ATTRIBUTE_PRIMARY_KEY))
+            {
+                column.setPrimaryKey(getAttributeValueAsBoolean(xmlReader, idx));
+            }
+            else if (isSameAs(attrQName, QNAME_ATTRIBUTE_REQUIRED))
+            {
+                column.setRequired(getAttributeValueAsBoolean(xmlReader, idx));
+            }
+            else if (isSameAs(attrQName, QNAME_ATTRIBUTE_TYPE))
+            {
+                column.setType(xmlReader.getAttributeValue(idx));
+            }
+            else if (isSameAs(attrQName, QNAME_ATTRIBUTE_SIZE))
+            {
+                column.setSize(xmlReader.getAttributeValue(idx));
+            }
+            else if (isSameAs(attrQName, QNAME_ATTRIBUTE_DEFAULT))
+            {
+                column.setDefaultValue(xmlReader.getAttributeValue(idx));
+            }
+            else if (isSameAs(attrQName, QNAME_ATTRIBUTE_AUTO_INCREMENT))
+            {
+                column.setAutoIncrement(getAttributeValueAsBoolean(xmlReader, idx));
+            }
+            else if (isSameAs(attrQName, QNAME_ATTRIBUTE_DESCRIPTION))
+            {
+                column.setDescription(xmlReader.getAttributeValue(idx));
+            }
+            else if (isSameAs(attrQName, QNAME_ATTRIBUTE_JAVA_NAME))
+            {
+                column.setJavaName(xmlReader.getAttributeValue(idx));
+            }
+        }
+        consumeRestOfElement(xmlReader);
+        return column;
+    }
+
+    /**
+     * Reads a foreign key element from the XML stream reader.
+     * 
+     * @param xmlReader The reader
+     * @return The foreign key object
+     */
+    private ForeignKey readForeignKeyElement(XMLStreamReader xmlReader) throws XMLStreamException, IOException
+    {
+        ForeignKey foreignKey = new ForeignKey();
+
+        for (int idx = 0; idx < xmlReader.getAttributeCount(); idx++)
+        {
+            QName attrQName = xmlReader.getAttributeName(idx);
+
+            if (isSameAs(attrQName, QNAME_ATTRIBUTE_FOREIGN_TABLE))
+            {
+                foreignKey.setForeignTableName(xmlReader.getAttributeValue(idx));
+            }
+            else if (isSameAs(attrQName, QNAME_ATTRIBUTE_NAME))
+            {
+                foreignKey.setName(xmlReader.getAttributeValue(idx));
+            }
+        }
+        readReferenceElements(xmlReader, foreignKey);
+        consumeRestOfElement(xmlReader);
+        return foreignKey;
+    }
+
+    /**
+     * Reads reference elements from the XML stream reader and adds them to the given
+     * foreign key.
+     * 
+     * @param xmlReader  The reader
+     * @param foreignKey The foreign key
+     */
+    private void readReferenceElements(XMLStreamReader xmlReader, ForeignKey foreignKey) throws XMLStreamException, IOException
+    {
+        int eventType = XMLStreamReader.START_ELEMENT;
+
+        while (eventType != XMLStreamReader.END_ELEMENT)
+        {
+            eventType = xmlReader.nextTag();
+            if (eventType == XMLStreamReader.START_ELEMENT)
+            {
+                QName elemQName = xmlReader.getName();
+
+                if (isSameAs(elemQName, QNAME_ELEMENT_REFERENCE))
+                {
+                    foreignKey.addReference(readReferenceElement(xmlReader));
+                }
+                else {
+                    readOverElement(xmlReader);
+                }
+            }
+        }
+    }
+
+    /**
+     * Reads a reference element from the XML stream reader.
+     * 
+     * @param xmlReader The reader
+     * @return The reference object
+     */
+    private Reference readReferenceElement(XMLStreamReader xmlReader) throws XMLStreamException, IOException
+    {
+        Reference reference = new Reference();
+
+        for (int idx = 0; idx < xmlReader.getAttributeCount(); idx++)
+        {
+            QName attrQName = xmlReader.getAttributeName(idx);
+
+            if (isSameAs(attrQName, QNAME_ATTRIBUTE_LOCAL))
+            {
+                reference.setLocalColumnName(xmlReader.getAttributeValue(idx));
+            }
+            else if (isSameAs(attrQName, QNAME_ATTRIBUTE_FOREIGN))
+            {
+                reference.setForeignColumnName(xmlReader.getAttributeValue(idx));
+            }
+        }
+        consumeRestOfElement(xmlReader);
+        return reference;
+    }
+
+    /**
+     * Reads an index element from the XML stream reader.
+     * 
+     * @param xmlReader The reader
+     * @return The index object
+     */
+    private Index readIndexElement(XMLStreamReader xmlReader) throws XMLStreamException, IOException
+    {
+        Index index = new NonUniqueIndex();
+
+        for (int idx = 0; idx < xmlReader.getAttributeCount(); idx++)
+        {
+            QName attrQName = xmlReader.getAttributeName(idx);
+
+            if (isSameAs(attrQName, QNAME_ATTRIBUTE_NAME))
+            {
+                index.setName(xmlReader.getAttributeValue(idx));
+            }
+        }
+        readIndexColumnElements(xmlReader, index);
+        consumeRestOfElement(xmlReader);
+        return index;
+    }
+
+    /**
+     * Reads an unique index element from the XML stream reader.
+     * 
+     * @param xmlReader The reader
+     * @return The unique index object
+     */
+    private Index readUniqueElement(XMLStreamReader xmlReader) throws XMLStreamException, IOException
+    {
+        Index index = new UniqueIndex();
+
+        for (int idx = 0; idx < xmlReader.getAttributeCount(); idx++)
+        {
+            QName attrQName = xmlReader.getAttributeName(idx);
+
+            if (isSameAs(attrQName, QNAME_ATTRIBUTE_NAME))
+            {
+                index.setName(xmlReader.getAttributeValue(idx));
+            }
+        }
+        readUniqueColumnElements(xmlReader, index);
+        consumeRestOfElement(xmlReader);
+        return index;
+    }
+
+    /**
+     * Reads index column elements from the XML stream reader and adds them to the given
+     * index object.
+     * 
+     * @param xmlReader The reader
+     * @param index     The index object
+     */
+    private void readIndexColumnElements(XMLStreamReader xmlReader, Index index) throws XMLStreamException, IOException
+    {
+        int eventType = XMLStreamReader.START_ELEMENT;
+
+        while (eventType != XMLStreamReader.END_ELEMENT)
+        {
+            eventType = xmlReader.nextTag();
+            if (eventType == XMLStreamReader.START_ELEMENT)
+            {
+                QName elemQName = xmlReader.getName();
+
+                if (isSameAs(elemQName, QNAME_ELEMENT_INDEX_COLUMN))
+                {
+                    index.addColumn(readIndexColumnElement(xmlReader));
+                }
+                else {
+                    readOverElement(xmlReader);
+                }
+            }
+        }
+    }
+
+    /**
+     * Reads unique index column elements from the XML stream reader and adds them to the given
+     * index object.
+     * 
+     * @param xmlReader The reader
+     * @param index     The index object
+     */
+    private void readUniqueColumnElements(XMLStreamReader xmlReader, Index index) throws XMLStreamException, IOException
+    {
+        int eventType = XMLStreamReader.START_ELEMENT;
+
+        while (eventType != XMLStreamReader.END_ELEMENT)
+        {
+            eventType = xmlReader.nextTag();
+            if (eventType == XMLStreamReader.START_ELEMENT)
+            {
+                QName elemQName = xmlReader.getName();
+
+                if (isSameAs(elemQName, QNAME_ELEMENT_UNIQUE_COLUMN))
+                {
+                    index.addColumn(readIndexColumnElement(xmlReader));
+                }
+                else {
+                    readOverElement(xmlReader);
+                }
+            }
+        }
+    }
+
+    /**
+     * Reads an index column element from the XML stream reader.
+     * 
+     * @param xmlReader The reader
+     * @return The index column object
+     */
+    private IndexColumn readIndexColumnElement(XMLStreamReader xmlReader) throws XMLStreamException, IOException
+    {
+        IndexColumn indexColumn = new IndexColumn();
+
+        for (int idx = 0; idx < xmlReader.getAttributeCount(); idx++)
+        {
+            QName attrQName = xmlReader.getAttributeName(idx);
+
+            if (isSameAs(attrQName, QNAME_ATTRIBUTE_NAME))
+            {
+                indexColumn.setName(xmlReader.getAttributeValue(idx));
+            }
+            else if (isSameAs(attrQName, QNAME_ATTRIBUTE_SIZE))
+            {
+                indexColumn.setSize(xmlReader.getAttributeValue(idx));
+            }
+        }
+        consumeRestOfElement(xmlReader);
+        return indexColumn;
+    }
+
+    /**
+     * Compares the given qnames. This specifically ignores the namespace
+     * uri of the other qname if the namespace of the current element is
+     * empty.
+     * 
+     * @param curElemQName The qname of the current element
+     * @param qName        The qname to compare to
+     * @return <code>true</code> if they are the same
+     */
+    private boolean isSameAs(QName curElemQName, QName qName)
+    {
+        if (StringUtils.isEmpty(curElemQName.getNamespaceURI()))
+        {
+            return qName.getLocalPart().equals(curElemQName.getLocalPart());
+        }
+        else
+        {
+            return qName.equals(curElemQName);
+        }
+    }
+
+    /**
+     * Returns the value of the indicated attribute of the current element as a boolean.
+     * If the value is not a valid boolean, then an exception is thrown.
+     * 
+     * @param xmlReader    The xml reader
+     * @param attributeIdx The index of the attribute
+     * @return The attribute's value as a boolean
+     */
+    private boolean getAttributeValueAsBoolean(XMLStreamReader xmlReader, int attributeIdx) throws DdlUtilsException
+    {
+        String value = xmlReader.getAttributeValue(attributeIdx);
+
+        if ("true".equalsIgnoreCase(value))
+        {
+            return true;
+        }
+        else if ("false".equalsIgnoreCase(value))
+        {
+            return false;
+        }
+        else
+        {
+            throw new DdlUtilsException("Illegal boolean value '" + value +"' for attribute " + xmlReader.getAttributeLocalName(attributeIdx));
+        }
+    }
+
+    /**
+     * Consumes the rest of the current element. This assumes that the current XML stream
+     * event type is not START_ELEMENT.
+     * 
+     * @param reader The xml reader
+     */
+    private void consumeRestOfElement(XMLStreamReader reader) throws XMLStreamException
+    {
+        int eventType = reader.getEventType();
+
+        while ((eventType != XMLStreamReader.END_ELEMENT) && (eventType != XMLStreamReader.END_DOCUMENT))
+        {
+            eventType = reader.nextTag();
+        }
+    }
+
+    /**
+     * Reads over the current element. This assumes that the current XML stream event type is
+     * START_ELEMENT.
+     *  
+     * @param reader The xml reader
+     */
+    private void readOverElement(XMLStreamReader reader) throws XMLStreamException
+    {
+        int depth = 1;
+
+        while (depth > 0)
+        {
+            int eventType = reader.nextTag();
+
+            if (eventType == XMLStreamReader.START_ELEMENT)
+            {
+                depth++;
+            }
+            else if (eventType == XMLStreamReader.END_ELEMENT)
+            {
+                depth--;
+            }
+        }
+    }
+
+    /**
      * Writes the database model to the specified file.
      * 
      * @param model    The database model
      * @param filename The model file name
      */
-    public void write(Database model, String filename) throws DdlUtilsException
+    public void write(Database model, String filename) throws DdlUtilsXMLException
     {
         try
         {
@@ -276,44 +801,222 @@
 
     /**
      * Writes the database model to the given output stream. Note that this method
-     * does not flush the stream.
+     * does not flush or close the stream.
      * 
      * @param model  The database model
      * @param output The output stream
      */
-    public void write(Database model, OutputStream output) throws DdlUtilsException
+    public void write(Database model, OutputStream output) throws DdlUtilsXMLException
     {
-        write(model, getWriter(new OutputStreamWriter(output)));
+        write(model, new OutputStreamWriter(output));
     }
 
     /**
      * Writes the database model to the given output writer. Note that this method
-     * does not flush the writer.
+     * does not flush or close the writer.
      * 
      * @param model  The database model
      * @param output The output writer
      */
-    public void write(Database model, Writer output) throws DdlUtilsException
+    public void write(Database model, Writer output) throws DdlUtilsXMLException
     {
-        write(model, getWriter(output));
+        PrettyPrintingXmlWriter xmlWriter = new PrettyPrintingXmlWriter(output, "UTF-8");
+
+        xmlWriter.setDefaultNamespace(DDLUTILS_NAMESPACE);
+        xmlWriter.writeDocumentStart();
+        writeDatabaseElement(model, xmlWriter);
+        xmlWriter.writeDocumentEnd();
     }
 
     /**
-     * Internal method that writes the database model using the given bean writer.
+     * Writes the database model to the given XML writer.
      * 
-     * @param model  The database model
-     * @param writer The bean writer
+     * @param model     The database model
+     * @param xmlWriter The XML writer
      */
-    private void write(Database model, BeanWriter writer) throws DdlUtilsException
+    private void writeDatabaseElement(Database model, PrettyPrintingXmlWriter xmlWriter) throws DdlUtilsXMLException
     {
-        try
+        writeElementStart(xmlWriter, QNAME_ELEMENT_DATABASE);
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_NAME,              model.getName());
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_DEFAULT_ID_METHOD, model.getIdMethod());
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_VERSION,           model.getVersion());
+        if (model.getTableCount() > 0)
         {
-            writer.writeXmlDeclaration("<?xml version=\"1.0\"?>\n<!DOCTYPE database SYSTEM \"" + LocalEntityResolver.DTD_PREFIX + "\">");
-            writer.write(model);
+            xmlWriter.printlnIfPrettyPrinting();
+            for (int idx = 0; idx < model.getTableCount(); idx++)
+            {
+                writeTableElement(model.getTable(idx), xmlWriter);
+            }
         }
-        catch (Exception ex)
+        writeElementEnd(xmlWriter);
+    }
+
+    /**
+     * Writes the table object to the given XML writer.
+     * 
+     * @param table     The table object
+     * @param xmlWriter The XML writer
+     */
+    private void writeTableElement(Table table, PrettyPrintingXmlWriter xmlWriter) throws DdlUtilsXMLException
+    {
+        xmlWriter.indentIfPrettyPrinting(1);
+        writeElementStart(xmlWriter, QNAME_ELEMENT_TABLE);
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_NAME,        table.getName());
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_DESCRIPTION, table.getDescription());
+        if ((table.getColumnCount() > 0) || (table.getForeignKeyCount() > 0) || (table.getIndexCount() > 0))
         {
-            throw new DdlUtilsException(ex);
+            xmlWriter.printlnIfPrettyPrinting();
+            for (int idx = 0; idx < table.getColumnCount(); idx++)
+            {
+                writeColumnElement(table.getColumn(idx), xmlWriter);
+            }
+            for (int idx = 0; idx < table.getForeignKeyCount(); idx++)
+            {
+                writeForeignKeyElement(table.getForeignKey(idx), xmlWriter);
+            }
+            for (int idx = 0; idx < table.getIndexCount(); idx++)
+            {
+                writeIndexElement(table.getIndex(idx), xmlWriter);
+            }
+            xmlWriter.indentIfPrettyPrinting(1);
         }
+        writeElementEnd(xmlWriter);
+    }
+
+    /**
+     * Writes the column object to the given XML writer.
+     * 
+     * @param column    The column object
+     * @param xmlWriter The XML writer
+     */
+    private void writeColumnElement(Column column, PrettyPrintingXmlWriter xmlWriter) throws DdlUtilsXMLException
+    {
+        xmlWriter.indentIfPrettyPrinting(2);
+        writeElementStart(xmlWriter, QNAME_ELEMENT_COLUMN);
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_NAME,           column.getName());
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_PRIMARY_KEY,    String.valueOf(column.isPrimaryKey()));
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_REQUIRED,       String.valueOf(column.isRequired()));
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_TYPE,           column.getType());
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_SIZE,           column.getSize());
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_DEFAULT,        column.getDefaultValue());
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_AUTO_INCREMENT, String.valueOf(column.isAutoIncrement()));
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_DESCRIPTION,    column.getDescription());
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_JAVA_NAME,      column.getJavaName());
+        writeElementEnd(xmlWriter);
+    }
+
+    /**
+     * Writes the foreign key object to the given XML writer.
+     * 
+     * @param foreignKey The foreign key object
+     * @param xmlWriter  The XML writer
+     */
+    private void writeForeignKeyElement(ForeignKey foreignKey, PrettyPrintingXmlWriter xmlWriter) throws DdlUtilsXMLException
+    {
+        xmlWriter.indentIfPrettyPrinting(2);
+        writeElementStart(xmlWriter, QNAME_ELEMENT_FOREIGN_KEY);
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_FOREIGN_TABLE, foreignKey.getForeignTableName());
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_NAME,          foreignKey.getName());
+        if (foreignKey.getReferenceCount() > 0)
+        {
+            xmlWriter.printlnIfPrettyPrinting();
+            for (int idx = 0; idx < foreignKey.getReferenceCount(); idx++)
+            {
+                writeReferenceElement(foreignKey.getReference(idx), xmlWriter);
+            }
+            xmlWriter.indentIfPrettyPrinting(2);
+        }
+        writeElementEnd(xmlWriter);
+    }
+
+    /**
+     * Writes the reference object to the given XML writer.
+     * 
+     * @param reference The reference object
+     * @param xmlWriter The XML writer
+     */
+    private void writeReferenceElement(Reference reference, PrettyPrintingXmlWriter xmlWriter) throws DdlUtilsXMLException
+    {
+        xmlWriter.indentIfPrettyPrinting(3);
+        writeElementStart(xmlWriter, QNAME_ELEMENT_REFERENCE);
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_LOCAL,   reference.getLocalColumnName());
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_FOREIGN, reference.getForeignColumnName());
+        writeElementEnd(xmlWriter);
+    }
+
+    /**
+     * Writes the index object to the given XML writer.
+     * 
+     * @param index     The index object
+     * @param xmlWriter The XML writer
+     */
+    private void writeIndexElement(Index index, PrettyPrintingXmlWriter xmlWriter) throws DdlUtilsXMLException
+    {
+        xmlWriter.indentIfPrettyPrinting(2);
+        writeElementStart(xmlWriter, index.isUnique() ? QNAME_ELEMENT_UNIQUE : QNAME_ELEMENT_INDEX);
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_NAME, index.getName());
+        if (index.getColumnCount() > 0)
+        {
+            xmlWriter.printlnIfPrettyPrinting();
+            for (int idx = 0; idx < index.getColumnCount(); idx++)
+            {
+                writeIndexColumnElement(index.getColumn(idx), index.isUnique(), xmlWriter);
+            }
+            xmlWriter.indentIfPrettyPrinting(2);
+        }
+        writeElementEnd(xmlWriter);
+    }
+
+    /**
+     * Writes the index column object to the given XML writer.
+     * 
+     * @param indexColumn The index column object
+     * @param isUnique    Whether the index that the index column belongs to, is unique
+     * @param xmlWriter   The XML writer
+     */
+    private void writeIndexColumnElement(IndexColumn indexColumn, boolean isUnique, PrettyPrintingXmlWriter xmlWriter) throws DdlUtilsXMLException
+    {
+        xmlWriter.indentIfPrettyPrinting(3);
+        writeElementStart(xmlWriter, isUnique ? QNAME_ELEMENT_UNIQUE_COLUMN : QNAME_ELEMENT_INDEX_COLUMN);
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_NAME, indexColumn.getName());
+        writeAttribute(xmlWriter, QNAME_ATTRIBUTE_SIZE, indexColumn.getSize());
+        writeElementEnd(xmlWriter);
+    }
+
+    /**
+     * Writes the start of the specified XML element to the given XML writer.
+     * 
+     * @param xmlWriter The xml writer
+     * @param qName     The qname of the XML element
+     */
+    private void writeElementStart(PrettyPrintingXmlWriter xmlWriter, QName qName) throws DdlUtilsXMLException
+    {
+        xmlWriter.writeElementStart(null, qName.getLocalPart());
+    }
+
+    /**
+     * Writes an attribute to the given XML writer.
+     * 
+     * @param xmlWriter The xml writer
+     * @param qName     The qname of the attribute
+     * @param value     The value; if empty, then nothing is written
+     */
+    private void writeAttribute(PrettyPrintingXmlWriter xmlWriter, QName qName, String value) throws DdlUtilsXMLException
+    {
+        if (!StringUtils.isEmpty(value))
+        {
+            xmlWriter.writeAttribute(null, qName.getLocalPart(), value);
+        }
+    }
+
+    /**
+     * Writes the end of the current XML element to the given XML writer.
+     * 
+     * @param xmlWriter The xml writer
+     */
+    private void writeElementEnd(PrettyPrintingXmlWriter xmlWriter) throws DdlUtilsXMLException
+    {
+        xmlWriter.writeElementEnd();
+        xmlWriter.printlnIfPrettyPrinting();
     }
 }
diff --git a/src/java/org/apache/ddlutils/io/DdlUtilsXMLException.java b/src/java/org/apache/ddlutils/io/DdlUtilsXMLException.java
new file mode 100644
index 0000000..7dba914
--- /dev/null
+++ b/src/java/org/apache/ddlutils/io/DdlUtilsXMLException.java
@@ -0,0 +1,72 @@
+package org.apache.ddlutils.io;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import org.apache.ddlutils.DdlUtilsException;
+
+/**
+ * Base class for exceptions generated by DdlUtils when handling XML.
+ * 
+ * @version $Revision: $
+ */
+public class DdlUtilsXMLException extends DdlUtilsException
+{
+    /** Unique id for serialization purposes. */
+    private static final long serialVersionUID = 3464139163788952051L;
+
+    /**
+     * Creates a new exception object.
+     */
+    public DdlUtilsXMLException()
+    {
+        super();
+    }
+
+    /**
+     * Creates a new exception object.
+     * 
+     * @param message The exception message
+     */
+    public DdlUtilsXMLException(String message)
+    {
+        super(message);
+    }
+
+    /**
+     * Creates a new exception object.
+     * 
+     * @param baseEx The base exception
+     */
+    public DdlUtilsXMLException(Throwable baseEx)
+    {
+        super(baseEx);
+    }
+
+    /**
+     * Creates a new exception object.
+     * 
+     * @param message The exception message
+     * @param baseEx  The base exception
+     */
+    public DdlUtilsXMLException(String message, Throwable baseEx)
+    {
+        super(message, baseEx);
+    }
+}
diff --git a/src/java/org/apache/ddlutils/io/PrettyPrintingXmlWriter.java b/src/java/org/apache/ddlutils/io/PrettyPrintingXmlWriter.java
new file mode 100644
index 0000000..145ba9e
--- /dev/null
+++ b/src/java/org/apache/ddlutils/io/PrettyPrintingXmlWriter.java
@@ -0,0 +1,318 @@
+package org.apache.ddlutils.io;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.io.Writer;
+
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamWriter;
+
+/**
+ * Helper class that writes XML data with or without pretty printing.
+ * 
+ * @version $Revision: $
+ */
+public class PrettyPrintingXmlWriter
+{
+    /** The indentation string. */
+    private static final String INDENT_STRING = "  ";
+
+    /** The output stream. */
+    private PrintWriter _output;
+    /** The xml writer. */
+    private XMLStreamWriter _writer;
+    /** The output encoding. */
+    private String _encoding;
+    /** Whether we're pretty-printing. */
+    private boolean _prettyPrinting = true;
+
+    /**
+     * Creates a xml writer instance using UTF-8 encoding.
+     * 
+     * @param output The target to write the data XML to
+     */
+    public PrettyPrintingXmlWriter(OutputStream output) throws DdlUtilsXMLException
+    {
+        this(output, null);
+    }
+
+    /**
+     * Creates a xml writer instance.
+     * 
+     * @param output   The target to write the data XML to
+     * @param encoding The encoding of the XML file
+     */
+    public PrettyPrintingXmlWriter(OutputStream output, String encoding) throws DdlUtilsXMLException
+    {
+        _output = new PrintWriter(output);
+        if ((encoding == null) || (encoding.length() == 0))
+        {
+            _encoding = "UTF-8";
+        }
+        else
+        {
+            _encoding = encoding;
+        }
+
+        try
+        {
+            XMLOutputFactory factory = XMLOutputFactory.newInstance();
+
+            _writer  = factory.createXMLStreamWriter(output, _encoding);
+        }
+        catch (XMLStreamException ex)
+        {
+            throwException(ex);
+        }
+    }
+
+    /**
+     * Creates a xml writer instance using the specified writer. Note that the writer
+     * needs to be configured using the specified encoding.
+     * 
+     * @param output   The target to write the data XML to
+     * @param encoding The encoding of the writer
+     */
+    public PrettyPrintingXmlWriter(Writer output, String encoding) throws DdlUtilsXMLException
+    {
+        _output   = new PrintWriter(output);
+        _encoding = encoding;
+        try
+        {
+            XMLOutputFactory factory = XMLOutputFactory.newInstance();
+
+            _writer = factory.createXMLStreamWriter(_output);
+        }
+        catch (XMLStreamException ex)
+        {
+            throwException(ex);
+        }
+    }
+
+    /**
+     * Rethrows the given exception, wrapped in a {@link DdlUtilsXMLException}. This
+     * method allows subclasses to throw their own subclasses of this exception.
+     * 
+     * @param baseEx The original exception
+     * @throws DdlUtilsXMLException The wrapped exception
+     */
+    protected void throwException(Exception baseEx) throws DdlUtilsXMLException
+    {
+        throw new DdlUtilsXMLException(baseEx);
+    }
+
+    /**
+     * Determines whether the output shall be pretty-printed.
+     *
+     * @return <code>true</code> if the output is pretty-printed
+     */
+    public boolean isPrettyPrinting()
+    {
+        return _prettyPrinting;
+    }
+
+    /**
+     * Specifies whether the output shall be pretty-printed.
+     *
+     * @param prettyPrinting <code>true</code> if the output is pretty-printed
+     */
+    public void setPrettyPrinting(boolean prettyPrinting)
+    {
+        _prettyPrinting = prettyPrinting;
+    }
+
+    /**
+     * Sets the default namespace.
+     * 
+     * @param uri The namespace uri
+     */
+    public void setDefaultNamespace(String uri) throws DdlUtilsXMLException
+    {
+        try
+        {
+            _writer.setDefaultNamespace(uri);
+        }
+        catch (XMLStreamException ex)
+        {
+            throwException(ex);
+        }
+    }
+    
+    /**
+     * Prints a newline if we're pretty-printing.
+     */
+    public void printlnIfPrettyPrinting() throws DdlUtilsXMLException
+    {
+        if (_prettyPrinting)
+        {
+            try
+            {
+                _writer.writeCharacters("\n");
+            }
+            catch (XMLStreamException ex)
+            {
+                throwException(ex);
+            }
+        }
+    }
+
+    /**
+     * Prints the indentation if we're pretty-printing.
+     * 
+     * @param level The indentation level
+     */
+    public void indentIfPrettyPrinting(int level) throws DdlUtilsXMLException
+    {
+        if (_prettyPrinting)
+        {
+            try
+            {
+                for (int idx = 0; idx < level; idx++)
+                {
+                    _writer.writeCharacters(INDENT_STRING);
+                }
+            }
+            catch (XMLStreamException ex)
+            {
+                throwException(ex);
+            }
+        }
+    }
+
+    /**
+     * Writes the start of the XML document, i.e. the "<?xml?>" section and the start of the
+     * root node.
+     */
+    public void writeDocumentStart() throws DdlUtilsXMLException
+    {
+        try
+        {
+            _writer.writeStartDocument(_encoding, "1.0");
+            printlnIfPrettyPrinting();
+        }
+        catch (XMLStreamException ex)
+        {
+            throwException(ex);
+        }
+    }
+
+    /**
+     * Writes the end of the XML document, i.e. end of the root node.
+     */
+    public void writeDocumentEnd() throws DdlUtilsXMLException
+    {
+        try
+        {
+            _writer.writeEndDocument();
+            _writer.flush();
+            _writer.close();
+        }
+        catch (XMLStreamException ex)
+        {
+            throwException(ex);
+        }
+    }
+
+    /**
+     * Writes the start of the indicated XML element.
+     * 
+     * @param namespaceUri The namespace uri, can be <code>null</code>
+     * @param localPart    The local part of the element's qname
+     */
+    public void writeElementStart(String namespaceUri, String localPart) throws DdlUtilsXMLException
+    {
+        try
+        {
+            if (namespaceUri == null)
+            {
+                _writer.writeStartElement(localPart);
+            }
+            else
+            {
+                _writer.writeStartElement(namespaceUri, localPart);
+            }
+        }
+        catch (XMLStreamException ex)
+        {
+            throwException(ex);
+        }
+    }
+
+    /**
+     * Writes the end of the current XML element.
+     */
+    public void writeElementEnd() throws DdlUtilsXMLException
+    {
+        try
+        {
+            _writer.writeEndElement();
+        }
+        catch (XMLStreamException ex)
+        {
+            throwException(ex);
+        }
+    }
+
+    /**
+     * Writes an XML attribute.
+     * 
+     * @param namespaceUri The namespace uri, can be <code>null</code>
+     * @param localPart    The local part of the attribute's qname
+     * @param value        The value; if <code>null</code> then no attribute is written
+     */
+    public void writeAttribute(String namespaceUri, String localPart, String value) throws DdlUtilsXMLException
+    {
+        try
+        {
+            if (namespaceUri == null)
+            {
+                _writer.writeAttribute(localPart, value);
+            }
+            else
+            {
+                _writer.writeAttribute(namespaceUri, localPart, value);
+            }
+        }
+        catch (XMLStreamException ex)
+        {
+            throwException(ex);
+        }
+    }
+
+    /**
+     * Writes a CDATA segment.
+     * 
+     * @param data The data to write
+     */
+    public void writeCData(String data) throws DdlUtilsXMLException
+    {
+        try
+        {
+            _writer.writeCData(data);
+        }
+        catch (XMLStreamException ex)
+        {
+            throwException(ex);
+        }
+    }
+}
diff --git a/src/java/org/apache/ddlutils/model/CascadeActionEnum.java b/src/java/org/apache/ddlutils/model/CascadeActionEnum.java
new file mode 100644
index 0000000..22ed94b
--- /dev/null
+++ b/src/java/org/apache/ddlutils/model/CascadeActionEnum.java
@@ -0,0 +1,125 @@
+package org.apache.ddlutils.model;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.lang.enums.ValuedEnum;
+
+/**
+ * Represents the different cascade actions for {@link ForeignKey#onDelete} and
+ * {@link ForeignKey#onUdate}.
+ * 
+ * @version $Revision: $
+ */
+public class CascadeActionEnum extends ValuedEnum
+{
+    /** The integer value for the enum value for a cascading change. */
+    public static final int VALUE_CASCADE  = 1;
+    /** The integer value for the enum value for a set-null change. */
+    public static final int VALUE_SETNULL  = 2;
+    /** The integer value for the enum value for a restrict change. */
+    public static final int VALUE_RESTRICT = 3;
+    /** The integer value for the enum value for no-change. */
+    public static final int VALUE_NONE     = 4;
+
+    /** The enum value for a cascade action which directs the database to change the value
+        of local column to the new value of the referenced column when it changes. */
+    public static final CascadeActionEnum CASCADE  = new CascadeActionEnum("cascade",  VALUE_CASCADE);
+    /** The enum value for a cascade action which directs the database to set the local
+        column to null when the referenced column changes. */
+    public static final CascadeActionEnum SETNULL  = new CascadeActionEnum("setnull",  VALUE_SETNULL);
+    /** The enum value for a cascade action which directs the database to restrict the change
+        changes to the referenced column. The interpretation of this is database-dependent. */
+    public static final CascadeActionEnum RESTRICT = new CascadeActionEnum("restrict", VALUE_RESTRICT);
+    /** The enum value for a cascade action which directs the database to take do nothing
+        to the local column when the value of the referenced column changes. */
+    public static final CascadeActionEnum NONE     = new CascadeActionEnum("none",     VALUE_NONE);
+
+    /** Version id for this class as relevant for serialization. */
+    private static final long serialVersionUID = -6378050861446415790L;
+
+    /**
+     * Creates a new enum object.
+     * 
+     * @param defaultTextRep The textual representation
+     * @param value          The corresponding integer value
+     */
+    private CascadeActionEnum(String defaultTextRep, int value)
+    {
+        super(defaultTextRep, value);
+    }
+
+    /**
+     * Returns the enum value that corresponds to the given textual
+     * representation.
+     * 
+     * @param defaultTextRep The textual representation
+     * @return The enum value
+     */
+    public static CascadeActionEnum getEnum(String defaultTextRep)
+    {
+        return (CascadeActionEnum)getEnum(CascadeActionEnum.class, defaultTextRep);
+    }
+    
+    /**
+     * Returns the enum value that corresponds to the given integer
+     * representation.
+     * 
+     * @param intValue The integer value
+     * @return The enum value
+     */
+    public static CascadeActionEnum getEnum(int intValue)
+    {
+        return (CascadeActionEnum)getEnum(CascadeActionEnum.class, intValue);
+    }
+
+    /**
+     * Returns the map of enum values.
+     * 
+     * @return The map of enum values
+     */
+    public static Map getEnumMap()
+    {
+        return getEnumMap(CascadeActionEnum.class);
+    }
+
+    /**
+     * Returns a list of all enum values.
+     * 
+     * @return The list of enum values
+     */
+    public static List getEnumList()
+    {
+        return getEnumList(CascadeActionEnum.class);
+    }
+
+    /**
+     * Returns an iterator of all enum values.
+     * 
+     * @return The iterator
+     */
+    public static Iterator iterator()
+    {
+        return iterator(CascadeActionEnum.class);
+    }
+}
diff --git a/src/java/org/apache/ddlutils/model/ForeignKey.java b/src/java/org/apache/ddlutils/model/ForeignKey.java
index 3db04be..3d3fc82 100644
--- a/src/java/org/apache/ddlutils/model/ForeignKey.java
+++ b/src/java/org/apache/ddlutils/model/ForeignKey.java
@@ -39,6 +39,10 @@
     private Table _foreignTable;
     /** The name of the foreign table. */
     private String _foreignTableName;
+    /** The action to perform when the value of the referenced column changes. */
+    private CascadeActionEnum _onUpdate = CascadeActionEnum.NONE;
+    /** The action to perform when the referenced row is deleted. */
+    private CascadeActionEnum _onDelete = CascadeActionEnum.NONE;
     /** The references between local and remote columns. */
     private ListOrderedSet _references = new ListOrderedSet();
     /** Whether this foreign key has an associated auto-generated index. */
@@ -130,6 +134,56 @@
     }
 
     /**
+     * Returns the action for this foreignkey for when the referenced row is deleted.
+     * 
+     * @return The action
+     */
+    public CascadeActionEnum getOnDelete()
+    {
+        return _onDelete;
+    }
+
+    /**
+     * Sets the action for this foreignkey for when the referenced row is deleted.
+     * 
+     * @param onDelete The action
+     * @throws NullPointerException If <code>onDelete</code> is null
+     */
+    public void setOnDelete(CascadeActionEnum onDelete) throws NullPointerException
+    {
+        if (onDelete == null)
+        {
+            throw new NullPointerException("The onDelete action cannot be null");
+        }
+        _onDelete = onDelete;
+    }
+
+    /**
+     * Returns the action for this foreignkey for when the referenced row is changed.
+     * 
+     * @return The action
+     */
+    public CascadeActionEnum getOnUpdate()
+    {
+        return _onUpdate;
+    }
+
+    /**
+     * Sets the action for this foreignkey for when the referenced row is changed.
+     * 
+     * @param onUpdate The action
+     * @throws NullPointerException If <code>onUdate</code> is null
+     */
+    public void setOnUpdate(CascadeActionEnum onUpdate) throws NullPointerException
+    {
+        if (onUpdate == null)
+        {
+            throw new NullPointerException("The onUpdate action cannot be null");
+        }
+        _onUpdate = onUpdate;
+    }
+
+    /**
      * Returns the number of references.
      * 
      * @return The number of references
diff --git a/src/test/org/apache/ddlutils/io/TestDatabaseIO.java b/src/test/org/apache/ddlutils/io/TestDatabaseIO.java
index 17d56f5..e84ddff 100644
--- a/src/test/org/apache/ddlutils/io/TestDatabaseIO.java
+++ b/src/test/org/apache/ddlutils/io/TestDatabaseIO.java
@@ -22,13 +22,11 @@
 import java.io.StringReader;
 import java.io.StringWriter;
 import java.sql.Types;
-import java.util.Arrays;
 
 import junit.framework.TestCase;
 
 import org.apache.commons.lang.StringUtils;
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.apache.ddlutils.model.CascadeActionEnum;
 import org.apache.ddlutils.model.Column;
 import org.apache.ddlutils.model.Database;
 import org.apache.ddlutils.model.ForeignKey;
@@ -37,17 +35,15 @@
 import org.apache.ddlutils.model.ModelException;
 import org.apache.ddlutils.model.Reference;
 import org.apache.ddlutils.model.Table;
+import org.apache.ddlutils.model.TypeMap;
 
 /**
- * Tests the database reading/writing via the {@link org.apache.ddlutils.io.DatabaseIO} class.
+ * Tests the database XML reading/writing via the {@link org.apache.ddlutils.io.DatabaseIO} class.
  * 
  * @version $Revision: 289996 $
  */
 public class TestDatabaseIO extends TestCase
 {
-    /** The log for the tests. */
-    private final Log _log = LogFactory.getLog(TestDatabaseIO.class);
-
     /**
      * Reads the database model from the given string.
      * 
@@ -78,9 +74,426 @@
     }
 
     /**
-     * Tests a simple database model.
+     * Asserts the data in a table object.
+     * 
+     * @param name                    The expected name
+     * @param description             The expected description
+     * @param numColumns              The expected number of columns
+     * @param numPrimaryKeyColumns    The expected number of primary key columns
+     * @param numAutoIncrementColumns The expected number of auto increment columns
+     * @param numForeignKeys          The expected number of foreign keys
+     * @param numIndexes              The expected number of indexes
+     * @param table                   The table
      */
-    public void testSimple() throws Exception
+    private void assertEquals(String name,
+                              String description,
+                              int    numColumns,
+                              int    numPrimaryKeyColumns,
+                              int    numAutoIncrementColumns,
+                              int    numForeignKeys,
+                              int    numIndexes,
+                              Table  table)
+    {
+        assertEquals(name, table.getName());
+        assertEquals(description, table.getDescription());
+        assertEquals(numColumns, table.getColumnCount());
+        assertEquals(numPrimaryKeyColumns, table.getPrimaryKeyColumns().length);
+        assertEquals(numAutoIncrementColumns, table.getAutoIncrementColumns().length);
+        assertEquals(numForeignKeys, table.getForeignKeyCount());
+        assertEquals(numIndexes, table.getIndexCount());
+    }
+
+    /**
+     * Asserts the data in a column object.
+     * 
+     * @param name            The expected name
+     * @param typeCode        The exected JDBC type code
+     * @param size            The expected size value
+     * @param scale           The expected scale value
+     * @param defaultValue    The expected default value
+     * @param description     The expected description
+     * @param javaName        The expected java name
+     * @param isPrimaryKey    The expected primary key status
+     * @param isRequired      The expected required satus
+     * @param isAutoIncrement The expected auto increment status
+     * @param column          The column
+     */
+    private void assertEquals(String  name,
+                              int     typeCode,
+                              int     size,
+                              int     scale,
+                              String  defaultValue,
+                              String  description,
+                              String  javaName,
+                              boolean isPrimaryKey,
+                              boolean isRequired,
+                              boolean isAutoIncrement,
+                              Column  column)
+    {
+        assertEquals(name, column.getName());
+        assertEquals(TypeMap.getJdbcTypeName(typeCode), column.getType());
+        assertEquals(typeCode, column.getTypeCode());
+        assertEquals(size, column.getSizeAsInt());
+        assertEquals(size, column.getPrecisionRadix());
+        assertEquals(scale, column.getScale());
+        if ((size <= 0) && (scale <= 0)) {
+            assertNull(column.getSize());
+        }
+        else if (scale == 0) {
+            assertEquals("" + size, column.getSize());
+        }
+        else {
+            assertEquals("" + size + "," + scale, column.getSize());
+        }
+        assertEquals(defaultValue, column.getDefaultValue());
+        assertEquals(description, column.getDescription());
+        assertEquals(javaName, column.getJavaName());
+        assertEquals(isPrimaryKey, column.isPrimaryKey());
+        assertEquals(isRequired, column.isRequired());
+        assertEquals(isAutoIncrement, column.isAutoIncrement());
+    }
+
+    /**
+     * Asserts data in a foreign key object.
+     * 
+     * @param name            The expected name
+     * @param onUpdate        The expected onUpdate action
+     * @param onDelete        The expected onDelete action
+     * @param referencedTable The expected referenced table
+     * @param numReferences   The expected number of references
+     * @param foreignKey      The foreign key
+     */
+    private void assertEquals(String            name,
+                              CascadeActionEnum onUpdate,
+                              CascadeActionEnum onDelete,
+                              Table             referencedTable,
+                              int               numReferences,
+                              ForeignKey        foreignKey)
+    {
+        assertEquals(name, foreignKey.getName());
+        assertEquals(onUpdate, foreignKey.getOnUpdate());
+        assertEquals(onDelete, foreignKey.getOnDelete());
+        assertEquals(referencedTable, foreignKey.getForeignTable());
+        assertEquals(referencedTable.getName(), foreignKey.getForeignTableName());
+        assertEquals(numReferences, foreignKey.getReferenceCount());
+    }
+
+    /**
+     * Asserts data in a reference object.
+     * 
+     * @param localColumn   The expected local column
+     * @param foreignColumn The expected foreign column
+     * @param ref           The reference
+     */
+    private void assertEquals(Column localColumn, Column foreignColumn, Reference ref)
+    {
+        assertEquals(localColumn, ref.getLocalColumn());
+        assertEquals(localColumn.getName(), ref.getLocalColumnName());
+        assertEquals(foreignColumn, ref.getForeignColumn());
+        assertEquals(foreignColumn.getName(), ref.getForeignColumnName());
+    }
+
+    /**
+     * Asserts data in an index object.
+     * 
+     * @param name       The expected name
+     * @param isUnique   The expected unique status
+     * @param numColumns The expected number of columns
+     * @param index      The index
+     */
+    private void assertEquals(String name, boolean isUnique, int numColumns, Index index)
+    {
+        assertEquals(name, index.getName());
+        assertEquals(isUnique, index.isUnique());
+        assertEquals(numColumns, index.getColumnCount());
+    }
+
+    /**
+     * Asserts data in an index column object.
+     * 
+     * @param column      The expected column
+     * @param size        The expected size value 
+     * @param indexColumn The index column
+     */
+    private void assertEquals(Column column, String size, IndexColumn indexColumn)
+    {
+        assertEquals(column, indexColumn.getColumn());
+        assertEquals(column.getName(), indexColumn.getName());
+        assertEquals(size, indexColumn.getSize());
+    }
+
+    /**
+     * Asserts that the given database model, written to XML, is equal to the given
+     * expected XML.
+     * 
+     * @param expectedXml The expected XML
+     * @param model       The database model
+     */
+    private void assertEquals(String expectedXml, Database model)
+    {
+        assertEquals(expectedXml, writeModel(model));
+    }
+
+    /**
+     * Tests an XML document without a database element.
+     */
+    public void testNoDatabaseElement()
+    {
+        assertNull(readModel("<data-base></data-base>"));
+    }
+
+    /**
+     * Tests that an exception is generated when the database element has no name attribute.
+     */
+    public void testDatabaseWithoutName()
+    {
+        try
+        {
+            readModel(
+                "<database>\n" +
+                "  <table name='TestTable'>\n" +
+                "    <column name='id'\n" +
+                "            type='INTEGER'\n" +
+                "            primaryKey='true'\n" +
+                "            required='true'/>\n" +
+                "  </table>\n" +
+                "</database>");
+
+            fail();
+        }
+        catch (ModelException ex)
+        {}
+    }
+
+    /**
+     * Tests a database model without tables.
+     */
+    public void testNoTables() throws Exception
+    {
+        Database model = readModel(
+            "<database name='test'>\n" +
+            "</database>");
+
+        assertEquals("test",
+                     model.getName());
+        assertEquals(0,
+                     model.getTableCount());
+
+        assertEquals(
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\" />\n",
+            model);
+    }
+
+    /**
+     * Tests a database model with a table without columns.
+     */
+    public void testTableWithoutColumns() throws Exception
+    {
+        Database model = readModel(
+            "<database name='test'>\n" +
+            "  <table name='SomeTable'\n" +
+            "         description='Some table'>\n" +
+            "  </table>\n" +
+            "</database>");
+
+        assertEquals("test", model.getName());
+        assertEquals(1, model.getTableCount());
+        assertEquals("SomeTable", "Some table", 0, 0, 0, 0, 0,
+                     model.getTable(0));
+
+        assertEquals(
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"SomeTable\" description=\"Some table\" />\n" +
+            "</database>\n",
+            model);
+    }
+
+    /**
+     * Tests that an exception is generated when the table element has no name attribute.
+     */
+    public void testTableWithoutName()
+    {
+        try
+        {
+            readModel(
+                "<database name='test'>\n" +
+                "  <table>\n" +
+                "    <column name='id'\n" +
+                "            type='INTEGER'\n" +
+                "            primaryKey='true'\n" +
+                "            required='true'/>\n" +
+                "  </table>\n" +
+                "</database>");
+
+            fail();
+        }
+        catch (ModelException ex)
+        {}
+    }
+
+    /**
+     * Tests a database model with a table with a single column.
+     */
+    public void testSingleColumn() throws Exception
+    {
+        Database model = readModel(
+            "<database name='test'>\n" +
+            "  <table name='SomeTable'\n" +
+            "         description='Some table'>\n" +
+            "    <column name='ID'\n" +
+            "            type='INTEGER'/>\n" +
+            "  </table>\n" +
+            "</database>");
+
+        assertEquals("test", model.getName());
+        assertEquals(1, model.getTableCount());
+        
+        Table table = model.getTable(0);
+
+        assertEquals("SomeTable", "Some table", 1, 0, 0, 0, 0,
+                     table);
+        assertEquals("ID", Types.INTEGER, 0, 0, null, null, null, false, false, false,
+                     table.getColumn(0));
+
+        assertEquals(
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"SomeTable\" description=\"Some table\">\n" +
+            "    <column name=\"ID\" primaryKey=\"false\" required=\"false\" type=\"INTEGER\" autoIncrement=\"false\" />\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
+    }
+
+    /**
+     * Tests that an exception is generated when the column element has no name attribute.
+     */
+    public void testColumnWithoutName()
+    {
+        try
+        {
+            readModel(
+                "<database name='test'>\n" +
+                "  <table name='TestTable'>\n" +
+                "    <column type='INTEGER'\n" +
+                "            primaryKey='true'\n" +
+                "            required='true'/>\n" +
+                "  </table>\n" +
+                "</database>");
+
+            fail();
+        }
+        catch (ModelException ex)
+        {}
+    }
+
+    /**
+     * Tests that an exception is generated when the column element has no type attribute.
+     */
+    public void testColumnWithoutType()
+    {
+        try
+        {
+            readModel(
+                "<database name='test'>\n" +
+                "  <table name='TestTable'>\n" +
+                "    <column name='id'\n" +
+                "            primaryKey='true'\n" +
+                "            required='true'/>\n" +
+                "  </table>\n" +
+                "</database>");
+
+            fail();
+        }
+        catch (ModelException ex)
+        {}
+    }
+
+    /**
+     * Tests a database model columns of all possible datatypes.
+     */
+    public void testColumnTypes() throws Exception
+    {
+        StringBuffer modelXml = new StringBuffer();
+        int[]        types    = TypeMap.getSuportedJdbcTypes();
+
+        modelXml.append("<database name='test'>\n");
+        modelXml.append("  <table name='SomeTable'\n");
+        modelXml.append("         description='Some table'>\n");
+        for (int idx = 0; idx < types.length; idx++)
+        {
+            modelXml.append("    <column name='ID");
+            modelXml.append(idx);
+            modelXml.append("' type='");
+            modelXml.append(TypeMap.getJdbcTypeName(types[idx]));
+            modelXml.append("'/>\n");
+        }
+        modelXml.append("  </table>\n");
+        modelXml.append("</database>");
+
+        Database model = readModel(modelXml.toString());
+
+        assertEquals("test", model.getName());
+        assertEquals(1, model.getTableCount());
+        
+        Table table = model.getTable(0);
+
+        assertEquals("SomeTable", "Some table", types.length, 0, 0, 0, 0,
+                     table);
+
+        for (int idx = 0; idx < types.length; idx++)
+        {
+            assertEquals("ID" + idx, types[idx], 0, 0, null, null, null, false, false, false,
+                         table.getColumn(idx));
+        }
+
+        modelXml.setLength(0);
+        modelXml.append("<?xml version='1.0' encoding='UTF-8'?>\n");
+        modelXml.append("<database name=\"test\">\n");
+        modelXml.append("  <table name=\"SomeTable\" description=\"Some table\">\n");
+        for (int idx = 0; idx < types.length; idx++)
+        {
+            modelXml.append("    <column name=\"ID");
+            modelXml.append(idx);
+            modelXml.append("\" primaryKey=\"false\" required=\"false\" type=\"");
+            modelXml.append(TypeMap.getJdbcTypeName(types[idx]));
+            modelXml.append("\" autoIncrement=\"false\" />\n");
+        }
+        modelXml.append("  </table>\n");
+        modelXml.append("</database>\n");
+
+        assertEquals(modelXml.toString(), model);
+    }
+
+    /**
+     * Tests an illegal column type.
+     */
+    public void testColumnWithIllegalType()
+    {
+        try
+        {
+            readModel(
+                "<database name='test'>\n" +
+                "  <table name='TestTable'>\n" +
+                "    <column name='id'\n" +
+                "            type='illegal'\n" +
+                "            primaryKey='true'\n" +
+                "            required='true'/>\n" +
+                "  </table>\n" +
+                "</database>");
+
+            fail();
+        }
+        catch (ModelException ex)
+        {}
+    }
+
+    /**
+     * Tests a database model with a table with a primary key column.
+     */
+    public void testPrimaryKeyColumn() throws Exception
     {
         Database model = readModel(
             "<database name='test'>\n" +
@@ -88,61 +501,290 @@
             "         description='Some table'>\n" +
             "    <column name='ID'\n" +
             "            type='INTEGER'\n" +
-            "            primaryKey='true'\n" +
-            "            required='true'\n" +
-            "            description='The primary key'\n" +
-            "            javaName='javaId'/>\n" +
+            "            primaryKey='true'/>\n" +
             "  </table>\n" +
             "</database>");
 
-        assertEquals("test",
-                     model.getName());
-        assertEquals(1,
-                     model.getTableCount());
+        assertEquals("test", model.getName());
+        assertEquals(1, model.getTableCount());
         
         Table table = model.getTable(0);
 
-        assertEquals("SomeTable",
-                     table.getName());
-        assertEquals("Some table",
-                     table.getDescription());
-        assertEquals(0, table.getAutoIncrementColumns().length);
-        assertEquals(1,
-                     table.getColumnCount());
-        assertEquals(0,
-                     table.getForeignKeyCount());
-        assertEquals(0,
-                     table.getIndexCount());
+        assertEquals("SomeTable", "Some table", 1, 1, 0, 0, 0,
+                     table);
 
         Column column = table.getColumn(0);
 
-        assertEquals("ID",
-                     column.getName());
-        assertEquals("INTEGER",
-                     column.getType());
-        assertEquals(Types.INTEGER,
-                     column.getTypeCode());
-        assertTrue(column.isPrimaryKey());
-        assertTrue(column.isRequired());
-        assertFalse(column.isAutoIncrement());
-        assertNull(column.getDefaultValue());
-        assertEquals("The primary key",
-                     column.getDescription());
-        assertEquals("javaId", column.getJavaName());
+        assertEquals("ID", Types.INTEGER, 0, 0, null, null, null, true, false, false,
+                     column);
+
+        assertEquals(column, table.getPrimaryKeyColumns()[0]);
+        
         assertEquals(
-            "<?xml version=\"1.0\"?>\n<!DOCTYPE database SYSTEM \"" + LocalEntityResolver.DTD_PREFIX + "\">\n" +
-            "  <database name=\"test\">\n" +
-            "    <table name=\"SomeTable\" description=\"Some table\">\n" +
-            "      <column name=\"ID\" primaryKey=\"true\" required=\"true\" type=\"INTEGER\" autoIncrement=\"false\" description=\"The primary key\" javaName=\"javaId\"/>\n" +
-            "    </table>\n" +
-            "  </database>\n",
-            writeModel(model));
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"SomeTable\" description=\"Some table\">\n" +
+            "    <column name=\"ID\" primaryKey=\"true\" required=\"false\" type=\"INTEGER\" autoIncrement=\"false\" />\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
     }
 
     /**
-     * Tests a database model containing a foreignkey.
+     * Tests a database model with a table with a required column.
      */
-    public void testForeignkey() throws Exception
+    public void testRequiredColumn() throws Exception
+    {
+        Database model = readModel(
+            "<database name='test'>\n" +
+            "  <table name='SomeTable'\n" +
+            "         description='Some table'>\n" +
+            "    <column name='ID'\n" +
+            "            type='INTEGER'\n" +
+            "            required='true'/>\n" +
+            "  </table>\n" +
+            "</database>");
+
+        assertEquals("test", model.getName());
+        assertEquals(1, model.getTableCount());
+        
+        Table table = model.getTable(0);
+
+        assertEquals("SomeTable", "Some table", 1, 0, 0, 0, 0,
+                     table);
+        assertEquals("ID", Types.INTEGER, 0, 0, null, null, null, false, true, false,
+                     table.getColumn(0));
+
+        assertEquals(
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"SomeTable\" description=\"Some table\">\n" +
+            "    <column name=\"ID\" primaryKey=\"false\" required=\"true\" type=\"INTEGER\" autoIncrement=\"false\" />\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
+    }
+
+    /**
+     * Tests a database model with a table with an autoincrement column.
+     */
+    public void testAutoIncrementColumn() throws Exception
+    {
+        Database model = readModel(
+            "<database name='test'>\n" +
+            "  <table name='SomeTable'\n" +
+            "         description='Some table'>\n" +
+            "    <column name='ID'\n" +
+            "            type='INTEGER'\n" +
+            "            autoIncrement='true'/>\n" +
+            "  </table>\n" +
+            "</database>");
+
+        assertEquals("test", model.getName());
+        assertEquals(1, model.getTableCount());
+        
+        Table table = model.getTable(0);
+
+        assertEquals("SomeTable", "Some table", 1, 0, 1, 0, 0,
+                     table);
+
+        Column column = table.getColumn(0);
+
+        assertEquals("ID", Types.INTEGER, 0, 0, null, null, null, false, false, true,
+                     column);
+
+        assertEquals(column, table.getAutoIncrementColumns()[0]);
+
+        assertEquals(
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"SomeTable\" description=\"Some table\">\n" +
+            "    <column name=\"ID\" primaryKey=\"false\" required=\"false\" type=\"INTEGER\" autoIncrement=\"true\" />\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
+    }
+
+    /**
+     * Tests a database model with a table with a column with a size spec.
+     */
+    public void testColumnWithSize1() throws Exception
+    {
+        Database model = readModel(
+            "<database name='test'>\n" +
+            "  <table name='SomeTable'\n" +
+            "         description='Some table'>\n" +
+            "    <column name='ID'\n" +
+            "            type='VARCHAR'\n" +
+            "            size='20'/>\n" +
+            "  </table>\n" +
+            "</database>");
+
+        assertEquals("test", model.getName());
+        assertEquals(1, model.getTableCount());
+        
+        Table table = model.getTable(0);
+
+        assertEquals("SomeTable", "Some table", 1, 0, 0, 0, 0,
+                     table);
+        assertEquals("ID", Types.VARCHAR, 20, 0, null, null, null, false, false, false,
+                     table.getColumn(0));
+
+        assertEquals(
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"SomeTable\" description=\"Some table\">\n" +
+            "    <column name=\"ID\" primaryKey=\"false\" required=\"false\" type=\"VARCHAR\" size=\"20\" autoIncrement=\"false\" />\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
+    }
+
+    /**
+     * Tests a database model with a table with a column with a size spec.
+     */
+    public void testColumnWithSize2() throws Exception
+    {
+        Database model = readModel(
+            "<database name='test'>\n" +
+            "  <table name='SomeTable'\n" +
+            "         description='Some table'>\n" +
+            "    <column name='ID'\n" +
+            "            type='DECIMAL'\n" +
+            "            size='10,3'/>\n" +
+            "  </table>\n" +
+            "</database>");
+
+        assertEquals("test", model.getName());
+        assertEquals(1, model.getTableCount());
+        
+        Table table = model.getTable(0);
+
+        assertEquals("SomeTable", "Some table", 1, 0, 0, 0, 0,
+                     table);
+        assertEquals("ID", Types.DECIMAL, 10, 3, null, null, null, false, false, false,
+                     table.getColumn(0));
+
+        assertEquals(
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"SomeTable\" description=\"Some table\">\n" +
+            "    <column name=\"ID\" primaryKey=\"false\" required=\"false\" type=\"DECIMAL\" size=\"10,3\" autoIncrement=\"false\" />\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
+    }
+
+    /**
+     * Tests a database model with a table with a column with a description.
+     */
+    public void testColumnWithDescription() throws Exception
+    {
+        Database model = readModel(
+            "<database name='test'>\n" +
+            "  <table name='SomeTable'\n" +
+            "         description='Some table'>\n" +
+            "    <column name='ID'\n" +
+            "            type='INTEGER'\n" +
+            "            description='Foo'/>\n" +
+            "  </table>\n" +
+            "</database>");
+
+        assertEquals("test", model.getName());
+        assertEquals(1, model.getTableCount());
+        
+        Table table = model.getTable(0);
+
+        assertEquals("SomeTable", "Some table", 1, 0, 0, 0, 0,
+                     table);
+        assertEquals("ID", Types.INTEGER, 0, 0, null, "Foo", null, false, false, false,
+                     table.getColumn(0));
+
+        assertEquals(
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"SomeTable\" description=\"Some table\">\n" +
+            "    <column name=\"ID\" primaryKey=\"false\" required=\"false\" type=\"INTEGER\" autoIncrement=\"false\" description=\"Foo\" />\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
+    }
+
+    /**
+     * Tests a database model with a table with a column with a default.
+     */
+    public void testColumnWithDefault() throws Exception
+    {
+        Database model = readModel(
+            "<database name='test'>\n" +
+            "  <table name='SomeTable'\n" +
+            "         description='Some table'>\n" +
+            "    <column name='ID'\n" +
+            "            type='VARCHAR'\n" +
+            "            size='32'\n" +
+            "            default='Test string'/>\n" +
+            "  </table>\n" +
+            "</database>");
+
+        assertEquals("test", model.getName());
+        assertEquals(1, model.getTableCount());
+        
+        Table table = model.getTable(0);
+
+        assertEquals("SomeTable", "Some table", 1, 0, 0, 0, 0,
+                     table);
+        assertEquals("ID", Types.VARCHAR, 32, 0, "Test string", null, null, false, false, false,
+                     table.getColumn(0));
+
+        assertEquals(
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"SomeTable\" description=\"Some table\">\n" +
+            "    <column name=\"ID\" primaryKey=\"false\" required=\"false\" type=\"VARCHAR\" size=\"32\" default=\"Test string\" autoIncrement=\"false\" />\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
+    }
+
+    /**
+     * Tests a database model with a table with a column with a java name.
+     */
+    public void testColumnWithJavaName() throws Exception
+    {
+        Database model = readModel(
+            "<database name='test'>\n" +
+            "  <table name='SomeTable'\n" +
+            "         description='Some table'>\n" +
+            "    <column name='ID'\n" +
+            "            type='DOUBLE'\n" +
+            "            javaName='testString'/>\n" +
+            "  </table>\n" +
+            "</database>");
+
+        assertEquals("test", model.getName());
+        assertEquals(1, model.getTableCount());
+        
+        Table table = model.getTable(0);
+
+        assertEquals("SomeTable", "Some table", 1, 0, 0, 0, 0,
+                     table);
+        assertEquals("ID", Types.DOUBLE, 0, 0, null, null, "testString", false, false, false,
+                     table.getColumn(0));
+
+        assertEquals(
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"SomeTable\" description=\"Some table\">\n" +
+            "    <column name=\"ID\" primaryKey=\"false\" required=\"false\" type=\"DOUBLE\" autoIncrement=\"false\" javaName=\"testString\" />\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
+    }
+
+    /**
+     * Tests a database model containing a single foreignkey.
+     */
+    public void testSingleForeignkey() throws Exception
     {
         Database model = readModel(
             "<database name='test'>\n" +
@@ -167,117 +809,612 @@
             "  </table>\n" +
             "</database>");
 
-        assertEquals("test",
-                     model.getName());
-        assertEquals(2,
-                     model.getTableCount());
+        assertEquals("test", model.getName());
+        assertEquals(2, model.getTableCount());
 
         Table someTable = model.getTable(0);
 
-        assertEquals("SomeTable",
-                     someTable.getName());
-        assertEquals("Some table",
-                     someTable.getDescription());
-        assertEquals(0, someTable.getAutoIncrementColumns().length);
-        assertEquals(1,
-                     someTable.getColumnCount());
-        assertEquals(0,
-                     someTable.getForeignKeyCount());
-        assertEquals(0,
-                     someTable.getIndexCount());
+        assertEquals("SomeTable", "Some table", 1, 1, 0, 0, 0,
+                     someTable);
 
         Column pkColumn = someTable.getColumn(0);
 
-        assertEquals("ID",
-                     pkColumn.getName());
-        assertEquals("VARCHAR",
-                     pkColumn.getType());
-        assertEquals(Types.VARCHAR,
-                     pkColumn.getTypeCode());
-        assertEquals(16,
-                     pkColumn.getSizeAsInt());
-        assertTrue(pkColumn.isPrimaryKey());
-        assertTrue(pkColumn.isRequired());
-        assertFalse(pkColumn.isAutoIncrement());
-        assertNull(pkColumn.getDefaultValue());
-        assertEquals("The primary key",
-                     pkColumn.getDescription());
+        assertEquals("ID", Types.VARCHAR, 16, 0, null, "The primary key", null, true, true, false,
+                     pkColumn);
 
         Table anotherTable = model.getTable(1);
 
-        assertEquals("AnotherTable",
-                     anotherTable.getName());
-        assertEquals("And another table",
-                     anotherTable.getDescription());
-        assertEquals(0, anotherTable.getAutoIncrementColumns().length);
-        assertEquals(1,
-                     anotherTable.getColumnCount());
-        assertEquals(1,
-                     anotherTable.getForeignKeyCount());
-        assertEquals(0,
-                     anotherTable.getIndexCount());
+        assertEquals("AnotherTable", "And another table", 1, 0, 0, 1, 0,
+                     anotherTable);
 
         Column fkColumn = anotherTable.getColumn(0);
 
-        assertEquals("Some_ID",
-                     fkColumn.getName());
-        assertEquals("VARCHAR",
-                     fkColumn.getType());
-        assertEquals(Types.VARCHAR,
-                     fkColumn.getTypeCode());
-        assertEquals(16,
-                     fkColumn.getSizeAsInt());
-        assertFalse(fkColumn.isPrimaryKey());
-        assertFalse(fkColumn.isRequired());
-        assertFalse(fkColumn.isAutoIncrement());
-        assertEquals("The foreign key",
-                     fkColumn.getDescription());
+        assertEquals("Some_ID", Types.VARCHAR, 16, 0, null, "The foreign key", null, false, false, false,
+                     fkColumn);
 
         ForeignKey fk = anotherTable.getForeignKey(0);
 
-        assertNull(fk.getName());
-        assertEquals(someTable,
-                     fk.getForeignTable());
-        assertEquals(someTable.getName(),
-                     fk.getForeignTableName());
-        assertEquals(1,
-                     fk.getReferenceCount());
-
-        Reference ref = fk.getFirstReference();
-
-        assertEquals(fkColumn,
-                     ref.getLocalColumn());
-        assertEquals("Some_ID",
-                     ref.getLocalColumnName());
-        assertEquals(pkColumn,
-                     ref.getForeignColumn());
-        assertEquals("ID",
-                     ref.getForeignColumnName());
+        assertEquals(null, CascadeActionEnum.NONE, CascadeActionEnum.NONE, someTable, 1, fk);
+        assertEquals(fkColumn, pkColumn, fk.getFirstReference());
 
         assertEquals(
-            "<?xml version=\"1.0\"?>\n<!DOCTYPE database SYSTEM \"" + LocalEntityResolver.DTD_PREFIX + "\">\n" +
-            "  <database name=\"test\">\n" +
-            "    <table name=\"SomeTable\" description=\"Some table\">\n" +
-            "      <column name=\"ID\" primaryKey=\"true\" required=\"true\" type=\"VARCHAR\" size=\"16\" autoIncrement=\"false\" description=\"The primary key\"/>\n" +
-            "    </table>\n" +
-            "    <table name=\"AnotherTable\" description=\"And another table\">\n" +
-            "      <column name=\"Some_ID\" primaryKey=\"false\" required=\"false\" type=\"VARCHAR\" size=\"16\" autoIncrement=\"false\" description=\"The foreign key\"/>\n" +
-            "      <foreign-key foreignTable=\"SomeTable\">\n" +
-            "        <reference local=\"Some_ID\" foreign=\"ID\"/>\n" +
-            "      </foreign-key>\n" +
-            "    </table>\n" +
-            "  </database>\n",
-            writeModel(model));
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"SomeTable\" description=\"Some table\">\n" +
+            "    <column name=\"ID\" primaryKey=\"true\" required=\"true\" type=\"VARCHAR\" size=\"16\" autoIncrement=\"false\" description=\"The primary key\" />\n" +
+            "  </table>\n" +
+            "  <table name=\"AnotherTable\" description=\"And another table\">\n" +
+            "    <column name=\"Some_ID\" primaryKey=\"false\" required=\"false\" type=\"VARCHAR\" size=\"16\" autoIncrement=\"false\" description=\"The foreign key\" />\n" +
+            "    <foreign-key foreignTable=\"SomeTable\">\n" +
+            "      <reference local=\"Some_ID\" foreign=\"ID\" />\n" +
+            "    </foreign-key>\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
     }
 
     /**
-     * Tests a database model with indices.
+     * Tests a database model containing a foreignkey with two references.
      */
-    public void testIndices1() throws Exception
+    public void testForeignkeyWithTwoReferences() throws Exception
     {
         Database model = readModel(
             "<database name='test'>\n" +
-            "  <table name='TableWidthIndex'>\n" +
+            "  <table name='SomeTable'\n" +
+            "         description='Some table'>\n" +
+            "    <column name='ID'\n" +
+            "            type='VARCHAR'\n" +
+            "            size='16'\n" +
+            "            primaryKey='true'\n" +
+            "            required='true'\n" +
+            "            description='The primary key'/>\n" +
+            "    <column name='VALUE1'\n" +
+            "            type='INTEGER'\n" +
+            "            required='false'\n" +
+            "            description='A value'/>\n" +
+            "    <column name='VALUE2'\n" +
+            "            type='DOUBLE'\n" +
+            "            required='false'\n" +
+            "            description='Another value'/>\n" +
+            "  </table>\n" +
+            "  <table name='AnotherTable'\n" +
+            "         description='And another table'>\n" +
+            "    <column name='Some_ID'\n" +
+            "            type='VARCHAR'\n" +
+            "            size='16'\n" +
+            "            description='The foreign key'/>\n" +
+            "    <column name='Some_Value'\n" +
+            "            type='DOUBLE'/>\n" +
+            "    <foreign-key foreignTable='SomeTable'>\n" +
+            "       <reference local='Some_ID' foreign='ID'/>\n" +
+            "       <reference local='Some_Value' foreign='VALUE2'/>\n" +
+            "    </foreign-key>\n" +
+            "  </table>\n" +
+            "</database>");
+
+        assertEquals("test", model.getName());
+        assertEquals(2, model.getTableCount());
+
+        Table someTable = model.getTable(0);
+
+        assertEquals("SomeTable", "Some table", 3, 1, 0, 0, 0,
+                     someTable);
+        assertEquals("ID", Types.VARCHAR, 16, 0, null, "The primary key", null, true, true, false,
+                     someTable.getColumn(0));
+
+        Table anotherTable = model.getTable(1);
+
+        assertEquals("AnotherTable", "And another table", 2, 0, 0, 1, 0,
+                     anotherTable);
+        assertEquals("Some_ID", Types.VARCHAR, 16, 0, null, "The foreign key", null, false, false, false,
+                     anotherTable.getColumn(0));
+
+        ForeignKey fk = anotherTable.getForeignKey(0);
+
+        assertEquals(null, CascadeActionEnum.NONE, CascadeActionEnum.NONE, someTable, 2, fk);
+        assertEquals(anotherTable.getColumn(0), someTable.getColumn(0), fk.getReference(0));
+        assertEquals(anotherTable.getColumn(1), someTable.getColumn(2), fk.getReference(1));
+
+        assertEquals(
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"SomeTable\" description=\"Some table\">\n" +
+            "    <column name=\"ID\" primaryKey=\"true\" required=\"true\" type=\"VARCHAR\" size=\"16\" autoIncrement=\"false\" description=\"The primary key\" />\n" +
+            "    <column name=\"VALUE1\" primaryKey=\"false\" required=\"false\" type=\"INTEGER\" autoIncrement=\"false\" description=\"A value\" />\n" +
+            "    <column name=\"VALUE2\" primaryKey=\"false\" required=\"false\" type=\"DOUBLE\" autoIncrement=\"false\" description=\"Another value\" />\n" +
+            "  </table>\n" +
+            "  <table name=\"AnotherTable\" description=\"And another table\">\n" +
+            "    <column name=\"Some_ID\" primaryKey=\"false\" required=\"false\" type=\"VARCHAR\" size=\"16\" autoIncrement=\"false\" description=\"The foreign key\" />\n" +
+            "    <column name=\"Some_Value\" primaryKey=\"false\" required=\"false\" type=\"DOUBLE\" autoIncrement=\"false\" />\n" +
+            "    <foreign-key foreignTable=\"SomeTable\">\n" +
+            "      <reference local=\"Some_ID\" foreign=\"ID\" />\n" +
+            "      <reference local=\"Some_Value\" foreign=\"VALUE2\" />\n" +
+            "    </foreign-key>\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
+    }
+
+    /**
+     * Tests a foreign key without references.
+     */
+    public void testForeignKeyWithoutReferences()
+    {
+        try
+        {
+            readModel(
+                "<database name='test'>\n" +
+                "  <table name='SomeTable'\n" +
+                "         description='Some table'>\n" +
+                "    <column name='ID'\n" +
+                "            type='VARCHAR'\n" +
+                "            size='16'\n" +
+                "            primaryKey='true'\n" +
+                "            required='true'\n" +
+                "            description='The primary key'/>\n" +
+                "  </table>\n" +
+                "  <table name='AnotherTable'\n" +
+                "         description='And another table'>\n" +
+                "    <column name='Some_ID'\n" +
+                "            type='VARCHAR'\n" +
+                "            size='16'\n" +
+                "            description='The foreign key'/>\n" +
+                "    <foreign-key foreignTable='SomeTable'>\n" +
+                "    </foreign-key>\n" +
+                "  </table>\n" +
+                "</database>");
+
+            fail();
+        }
+        catch (ModelException ex)
+        {}
+    }
+
+    /**
+     * Tests a database model containing a named foreignkey.
+     */
+    public void testNamedForeignkey() throws Exception
+    {
+        Database model = readModel(
+            "<database name='test'>\n" +
+            "  <table name='SomeTable'\n" +
+            "         description='Some table'>\n" +
+            "    <column name='ID'\n" +
+            "            type='VARCHAR'\n" +
+            "            size='16'\n" +
+            "            primaryKey='true'\n" +
+            "            required='true'\n" +
+            "            description='The primary key'/>\n" +
+            "  </table>\n" +
+            "  <table name='AnotherTable'\n" +
+            "         description='And another table'>\n" +
+            "    <column name='Some_ID'\n" +
+            "            type='VARCHAR'\n" +
+            "            size='16'\n" +
+            "            description='The foreign key'/>\n" +
+            "    <foreign-key name='The foreignkey' foreignTable='SomeTable'>\n" +
+            "       <reference local='Some_ID' foreign='ID'/>\n" +
+            "    </foreign-key>\n" +
+            "  </table>\n" +
+            "</database>");
+
+        assertEquals("test", model.getName());
+        assertEquals(2, model.getTableCount());
+
+        Table someTable = model.getTable(0);
+
+        assertEquals("SomeTable", "Some table", 1, 1, 0, 0, 0,
+                     someTable);
+        assertEquals("ID", Types.VARCHAR, 16, 0, null, "The primary key", null, true, true, false,
+                     someTable.getColumn(0));
+
+        Table anotherTable = model.getTable(1);
+
+        assertEquals("AnotherTable", "And another table", 1, 0, 0, 1, 0,
+                     anotherTable);
+        assertEquals("Some_ID", Types.VARCHAR, 16, 0, null, "The foreign key", null, false, false, false,
+                     anotherTable.getColumn(0));
+
+        ForeignKey fk = anotherTable.getForeignKey(0);
+
+        assertEquals("The foreignkey", CascadeActionEnum.NONE, CascadeActionEnum.NONE, someTable, 1, fk);
+        assertEquals(anotherTable.getColumn(0), someTable.getColumn(0), fk.getReference(0));
+
+        assertEquals(
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"SomeTable\" description=\"Some table\">\n" +
+            "    <column name=\"ID\" primaryKey=\"true\" required=\"true\" type=\"VARCHAR\" size=\"16\" autoIncrement=\"false\" description=\"The primary key\" />\n" +
+            "  </table>\n" +
+            "  <table name=\"AnotherTable\" description=\"And another table\">\n" +
+            "    <column name=\"Some_ID\" primaryKey=\"false\" required=\"false\" type=\"VARCHAR\" size=\"16\" autoIncrement=\"false\" description=\"The foreign key\" />\n" +
+            "    <foreign-key foreignTable=\"SomeTable\" name=\"The foreignkey\">\n" +
+            "      <reference local=\"Some_ID\" foreign=\"ID\" />\n" +
+            "    </foreign-key>\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
+    }
+
+    /**
+     * Tests a foreign key referencing a non-existing table.
+     */
+    public void testForeignKeyReferencingUndefinedTable()
+    {
+        try
+        {
+            readModel(
+                "<database name='test'>\n" +
+                "  <table name='SomeTable'\n" +
+                "         description='Some table'>\n" +
+                "    <column name='ID'\n" +
+                "            type='VARCHAR'\n" +
+                "            size='16'\n" +
+                "            primaryKey='true'\n" +
+                "            required='true'\n" +
+                "            description='The primary key'/>\n" +
+                "  </table>\n" +
+                "  <table name='AnotherTable'\n" +
+                "         description='And another table'>\n" +
+                "    <column name='Some_ID'\n" +
+                "            type='VARCHAR'\n" +
+                "            size='16'\n" +
+                "            description='The foreign key'/>\n" +
+                "    <foreign-key foreignTable='TheTable'>\n" +
+                "       <reference local='Some_ID' foreign='ID'/>\n" +
+                "    </foreign-key>\n" +
+                "  </table>\n" +
+                "</database>");
+
+            fail();
+        }
+        catch (ModelException ex)
+        {}
+    }
+
+    /**
+     * Tests a foreign key using a non-existing column in the local table.
+     */
+    public void testForeignKeyUsingUndefinedColumn()
+    {
+        try
+        {
+            readModel(
+                "<database name='test'>\n" +
+                "  <table name='SomeTable'\n" +
+                "         description='Some table'>\n" +
+                "    <column name='ID'\n" +
+                "            type='VARCHAR'\n" +
+                "            size='16'\n" +
+                "            primaryKey='true'\n" +
+                "            required='true'\n" +
+                "            description='The primary key'/>\n" +
+                "  </table>\n" +
+                "  <table name='AnotherTable'\n" +
+                "         description='And another table'>\n" +
+                "    <column name='Some_ID'\n" +
+                "            type='VARCHAR'\n" +
+                "            size='16'\n" +
+                "            description='The foreign key'/>\n" +
+                "    <foreign-key foreignTable='SomeTable'>\n" +
+                "       <reference local='ID' foreign='ID'/>\n" +
+                "    </foreign-key>\n" +
+                "  </table>\n" +
+                "</database>");
+
+            fail();
+        }
+        catch (ModelException ex)
+        {}
+    }
+
+    /**
+     * Tests a foreign key referencing a non-existing column in the foreign table.
+     */
+    public void testForeignKeyReferencingUndefinedColumn()
+    {
+        try
+        {
+            readModel(
+                "<database name='test'>\n" +
+                "  <table name='SomeTable'\n" +
+                "         description='Some table'>\n" +
+                "    <column name='ID'\n" +
+                "            type='VARCHAR'\n" +
+                "            size='16'\n" +
+                "            primaryKey='true'\n" +
+                "            required='true'\n" +
+                "            description='The primary key'/>\n" +
+                "  </table>\n" +
+                "  <table name='AnotherTable'\n" +
+                "         description='And another table'>\n" +
+                "    <column name='Some_ID'\n" +
+                "            type='VARCHAR'\n" +
+                "            size='16'\n" +
+                "            description='The foreign key'/>\n" +
+                "    <foreign-key foreignTable='SomeTable'>\n" +
+                "       <reference local='Some_ID' foreign='TheID'/>\n" +
+                "    </foreign-key>\n" +
+                "  </table>\n" +
+                "</database>");
+
+            fail();
+        }
+        catch (ModelException ex)
+        {}
+    }
+
+    /**
+     * Tests a foreign key without a local column.
+     */
+    public void testForeignKeyWithoutLocalColumn()
+    {
+        try
+        {
+            readModel(
+                "<database name='test'>\n" +
+                "  <table name='SomeTable'\n" +
+                "         description='Some table'>\n" +
+                "    <column name='ID'\n" +
+                "            type='VARCHAR'\n" +
+                "            size='16'\n" +
+                "            primaryKey='true'\n" +
+                "            required='true'\n" +
+                "            description='The primary key'/>\n" +
+                "  </table>\n" +
+                "  <table name='AnotherTable'\n" +
+                "         description='And another table'>\n" +
+                "    <column name='Some_ID'\n" +
+                "            type='VARCHAR'\n" +
+                "            size='16'\n" +
+                "            description='The foreign key'/>\n" +
+                "    <foreign-key foreignTable='SomeTable'>\n" +
+                "       <reference foreign='ID'/>\n" +
+                "    </foreign-key>\n" +
+                "  </table>\n" +
+                "</database>");
+
+            fail();
+        }
+        catch (ModelException ex)
+        {}
+    }
+
+    /**
+     * Tests a foreign key without a remote column.
+     */
+    public void testForeignKeyWithoutRemoteColumn()
+    {
+        try
+        {
+            readModel(
+                "<database name='test'>\n" +
+                "  <table name='SomeTable'\n" +
+                "         description='Some table'>\n" +
+                "    <column name='ID'\n" +
+                "            type='VARCHAR'\n" +
+                "            size='16'\n" +
+                "            primaryKey='true'\n" +
+                "            required='true'\n" +
+                "            description='The primary key'/>\n" +
+                "  </table>\n" +
+                "  <table name='AnotherTable'\n" +
+                "         description='And another table'>\n" +
+                "    <column name='Some_ID'\n" +
+                "            type='VARCHAR'\n" +
+                "            size='16'\n" +
+                "            description='The foreign key'/>\n" +
+                "    <foreign-key foreignTable='SomeTable'>\n" +
+                "       <reference local='Some_ID'/>\n" +
+                "    </foreign-key>\n" +
+                "  </table>\n" +
+                "</database>");
+
+            fail();
+        }
+        catch (ModelException ex)
+        {}
+    }
+
+    /**
+     * Tests a database model containing two foreignkeys.
+     */
+    public void testTwoForeignkeys() throws Exception
+    {
+        Database model = readModel(
+            "<database name='test'>\n" +
+            "  <table name='SomeTable'\n" +
+            "         description='Some table'>\n" +
+            "    <column name='ID'\n" +
+            "            type='VARCHAR'\n" +
+            "            size='16'\n" +
+            "            primaryKey='true'\n" +
+            "            required='true'\n" +
+            "            description='The primary key'/>\n" +
+            "    <column name='VALUE1'\n" +
+            "            type='INTEGER'\n" +
+            "            required='false'\n" +
+            "            description='A value'/>\n" +
+            "    <column name='VALUE2'\n" +
+            "            type='DOUBLE'\n" +
+            "            required='false'\n" +
+            "            description='Another value'/>\n" +
+            "  </table>\n" +
+            "  <table name='AnotherTable'\n" +
+            "         description='And another table'>\n" +
+            "    <column name='Some_ID'\n" +
+            "            type='VARCHAR'\n" +
+            "            size='16'\n" +
+            "            description='The foreign key'/>\n" +
+            "    <column name='Some_Value'\n" +
+            "            type='DOUBLE'/>\n" +
+            "    <foreign-key foreignTable='SomeTable'>\n" +
+            "       <reference local='Some_ID' foreign='ID'/>\n" +
+            "    </foreign-key>\n" +
+            "    <foreign-key foreignTable='SomeTable'>\n" +
+            "       <reference local='Some_Value' foreign='VALUE2'/>\n" +
+            "    </foreign-key>\n" +
+            "  </table>\n" +
+            "</database>");
+
+        assertEquals("test", model.getName());
+        assertEquals(2, model.getTableCount());
+
+        Table someTable = model.getTable(0);
+
+        assertEquals("SomeTable", "Some table", 3, 1, 0, 0, 0,
+                     someTable);
+        assertEquals("ID", Types.VARCHAR, 16, 0, null, "The primary key", null, true, true, false,
+                     someTable.getColumn(0));
+
+        Table anotherTable = model.getTable(1);
+
+        assertEquals("AnotherTable", "And another table", 2, 0, 0, 2, 0,
+                     anotherTable);
+        assertEquals("Some_ID", Types.VARCHAR, 16, 0, null, "The foreign key", null, false, false, false,
+                     anotherTable.getColumn(0));
+
+        ForeignKey fk = anotherTable.getForeignKey(0);
+
+        assertEquals(null, CascadeActionEnum.NONE, CascadeActionEnum.NONE, someTable, 1, fk);
+        assertEquals(anotherTable.getColumn(0), someTable.getColumn(0), fk.getReference(0));
+
+        fk = anotherTable.getForeignKey(1);
+
+        assertEquals(null, CascadeActionEnum.NONE, CascadeActionEnum.NONE, someTable, 1, fk);
+        assertEquals(anotherTable.getColumn(1), someTable.getColumn(2), fk.getReference(0));
+
+        assertEquals(
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"SomeTable\" description=\"Some table\">\n" +
+            "    <column name=\"ID\" primaryKey=\"true\" required=\"true\" type=\"VARCHAR\" size=\"16\" autoIncrement=\"false\" description=\"The primary key\" />\n" +
+            "    <column name=\"VALUE1\" primaryKey=\"false\" required=\"false\" type=\"INTEGER\" autoIncrement=\"false\" description=\"A value\" />\n" +
+            "    <column name=\"VALUE2\" primaryKey=\"false\" required=\"false\" type=\"DOUBLE\" autoIncrement=\"false\" description=\"Another value\" />\n" +
+            "  </table>\n" +
+            "  <table name=\"AnotherTable\" description=\"And another table\">\n" +
+            "    <column name=\"Some_ID\" primaryKey=\"false\" required=\"false\" type=\"VARCHAR\" size=\"16\" autoIncrement=\"false\" description=\"The foreign key\" />\n" +
+            "    <column name=\"Some_Value\" primaryKey=\"false\" required=\"false\" type=\"DOUBLE\" autoIncrement=\"false\" />\n" +
+            "    <foreign-key foreignTable=\"SomeTable\">\n" +
+            "      <reference local=\"Some_ID\" foreign=\"ID\" />\n" +
+            "    </foreign-key>\n" +
+            "    <foreign-key foreignTable=\"SomeTable\">\n" +
+            "      <reference local=\"Some_Value\" foreign=\"VALUE2\" />\n" +
+            "    </foreign-key>\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
+    }
+
+    /**
+     * Tests a database model containing two foreignkeys with the same name.
+     */
+    public void testTwoForeignkeysWithSameName() throws Exception
+    {
+        try
+        {
+            readModel(
+                "<database name='test'>\n" +
+                "  <table name='SomeTable'\n" +
+                "         description='Some table'>\n" +
+                "    <column name='ID'\n" +
+                "            type='VARCHAR'\n" +
+                "            size='16'\n" +
+                "            primaryKey='true'\n" +
+                "            required='true'\n" +
+                "            description='The primary key'/>\n" +
+                "    <column name='VALUE1'\n" +
+                "            type='INTEGER'\n" +
+                "            required='false'\n" +
+                "            description='A value'/>\n" +
+                "    <column name='VALUE2'\n" +
+                "            type='DOUBLE'\n" +
+                "            required='false'\n" +
+                "            description='Another value'/>\n" +
+                "  </table>\n" +
+                "  <table name='AnotherTable'\n" +
+                "         description='And another table'>\n" +
+                "    <column name='Some_ID'\n" +
+                "            type='VARCHAR'\n" +
+                "            size='16'\n" +
+                "            description='The foreign key'/>\n" +
+                "    <column name='Some_Value'\n" +
+                "            type='DOUBLE'/>\n" +
+                "    <foreign-key name='The foreignkey' foreignTable='SomeTable'>\n" +
+                "       <reference local='Some_ID' foreign='ID'/>\n" +
+                "    </foreign-key>\n" +
+                "    <foreign-key name='The foreignkey' foreignTable='SomeTable'>\n" +
+                "       <reference local='Some_Value' foreign='VALUE2'/>\n" +
+                "    </foreign-key>\n" +
+                "  </table>\n" +
+                "</database>");
+
+            fail();
+        }
+        catch (ModelException ex)
+        {}
+    }
+
+    /**
+     * Tests a database model with an index.
+     */
+    public void testSingleIndex() throws Exception
+    {
+        Database model = readModel(
+            "<database name='test'>\n" +
+            "  <table name='TableWithIndex'>\n" +
+            "    <column name='id'\n" +
+            "            type='DOUBLE'\n" +
+            "            primaryKey='true'\n" +
+            "            required='true'/>\n" +
+            "    <column name='value'\n" +
+            "            type='SMALLINT'\n" +
+            "            default='1'/>\n" +
+            "    <index>\n" +
+            "      <index-column name='value'/>\n" +
+            "    </index>\n" +
+            "  </table>\n" +
+            "</database>");
+
+        assertEquals("test", model.getName());
+        assertEquals(1, model.getTableCount());
+        
+        Table table = model.getTable(0);
+
+        assertEquals("TableWithIndex", null, 2, 1, 0, 0, 1,
+                     table);
+        assertEquals("id", Types.DOUBLE, 0, 0, null, null, null, true, true, false,
+                     table.getColumn(0));
+        assertEquals("value", Types.SMALLINT, 0, 0, "1", null, null, false, false, false,
+                     table.getColumn(1));
+
+        Index index = table.getIndex(0);
+
+        assertEquals(null, false, 1, index);
+        assertEquals(table.getColumn(1), null, index.getColumn(0));
+
+        assertEquals(
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"TableWithIndex\">\n" +
+            "    <column name=\"id\" primaryKey=\"true\" required=\"true\" type=\"DOUBLE\" autoIncrement=\"false\" />\n" +
+            "    <column name=\"value\" primaryKey=\"false\" required=\"false\" type=\"SMALLINT\" default=\"1\" autoIncrement=\"false\" />\n" +
+            "    <index>\n" +
+            "      <index-column name=\"value\" />\n" +
+            "    </index>\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
+    }
+
+    /**
+     * Tests a database model with an index with two columns.
+     */
+    public void testIndexWithTwoColumns() throws Exception
+    {
+        Database model = readModel(
+            "<database name='test'>\n" +
+            "  <table name='TableWithIndex'>\n" +
             "    <column name='id'\n" +
             "            type='DOUBLE'\n" +
             "            primaryKey='true'\n" +
@@ -288,9 +1425,6 @@
             "    <column name='value'\n" +
             "            type='SMALLINT'\n" +
             "            default='1'/>\n" +
-            "    <index name='test index'>\n" +
-            "      <index-column name='value'/>\n" +
-            "    </index>\n" +
             "    <index>\n" +
             "      <index-column name='when'/>\n" +
             "      <index-column name='id'/>\n" +
@@ -298,128 +1432,440 @@
             "  </table>\n" +
             "</database>");
 
-        assertEquals("test",
-                     model.getName());
-        assertEquals(1,
-                     model.getTableCount());
+        assertEquals("test", model.getName());
+        assertEquals(1, model.getTableCount());
         
         Table table = model.getTable(0);
 
-        assertEquals("TableWidthIndex",
-                     table.getName());
-        assertNull(table.getDescription());
-        assertEquals(0, table.getAutoIncrementColumns().length);
-        assertEquals(3,
-                     table.getColumnCount());
-        assertEquals(0,
-                     table.getForeignKeyCount());
-        assertEquals(2,
-                     table.getIndexCount());
-
-        Column column = table.getColumn(0);
-
-        assertEquals("id",
-                     column.getName());
-        assertEquals("DOUBLE",
-                     column.getType());
-        assertEquals(Types.DOUBLE,
-                     column.getTypeCode());
-        assertTrue(column.isPrimaryKey());
-        assertTrue(column.isRequired());
-        assertFalse(column.isAutoIncrement());
-        assertNull(column.getDefaultValue());
-        assertNull(column.getDefaultValue());
-        assertNull(column.getDescription());
-
-        column = table.getColumn(1);
-
-        assertEquals("when",
-                     column.getName());
-        assertEquals("TIMESTAMP",
-                     column.getType());
-        assertEquals(Types.TIMESTAMP,
-                     column.getTypeCode());
-        assertFalse(column.isPrimaryKey());
-        assertTrue(column.isRequired());
-        assertFalse(column.isAutoIncrement());
-        assertNull(column.getDefaultValue());
-        assertNull(column.getDescription());
-
-        column = table.getColumn(2);
-
-        assertEquals("value",
-                     column.getName());
-        assertEquals("SMALLINT",
-                     column.getType());
-        assertEquals(Types.SMALLINT,
-                     column.getTypeCode());
-        assertFalse(column.isPrimaryKey());
-        assertFalse(column.isRequired());
-        assertFalse(column.isAutoIncrement());
-        assertEquals("1",
-                     column.getDefaultValue());
-        assertNull(column.getDescription());
+        assertEquals("TableWithIndex", null, 3, 1, 0, 0, 1,
+                     table);
+        assertEquals("id", Types.DOUBLE, 0, 0, null, null, null, true, true, false,
+                     table.getColumn(0));
+        assertEquals("when", Types.TIMESTAMP, 0, 0, null, null, null, false, true, false,
+                     table.getColumn(1));
+        assertEquals("value", Types.SMALLINT, 0, 0, "1", null, null, false, false, false,
+                     table.getColumn(2));
 
         Index index = table.getIndex(0);
 
-        assertEquals("test index",
-                     index.getName());
-        assertFalse(index.isUnique());
-        assertEquals(1,
-                     index.getColumnCount());
-
-        IndexColumn indexColumn = index.getColumn(0);
-
-        assertEquals("value",
-                     indexColumn.getName());
-        assertNull(indexColumn.getSize());
-
-        index = table.getIndex(1);
-
-        assertNull(index.getName());
-        assertFalse(index.isUnique());
-        assertEquals(2,
-                     index.getColumnCount());
-
-        indexColumn = index.getColumn(0);
-
-        assertEquals("when",
-                     indexColumn.getName());
-        assertNull(indexColumn.getSize());
-
-        indexColumn = index.getColumn(1);
-
-        assertEquals("id",
-                     indexColumn.getName());
-        assertNull(indexColumn.getSize());
+        assertEquals(null, false, 2, index);
+        assertEquals(table.getColumn(1), null, index.getColumn(0));
+        assertEquals(table.getColumn(0), null, index.getColumn(1));
 
         assertEquals(
-            "<?xml version=\"1.0\"?>\n<!DOCTYPE database SYSTEM \"" + LocalEntityResolver.DTD_PREFIX + "\">\n" +
-            "  <database name=\"test\">\n" +
-            "    <table name=\"TableWidthIndex\">\n" +
-            "      <column name=\"id\" primaryKey=\"true\" required=\"true\" type=\"DOUBLE\" autoIncrement=\"false\"/>\n" +
-            "      <column name=\"when\" primaryKey=\"false\" required=\"true\" type=\"TIMESTAMP\" autoIncrement=\"false\"/>\n" +
-            "      <column name=\"value\" primaryKey=\"false\" required=\"false\" type=\"SMALLINT\" default=\"1\" autoIncrement=\"false\"/>\n" +
-            "      <index name=\"test index\">\n" +
-            "        <index-column name=\"value\"/>\n" +
-            "      </index>\n" +
-            "      <index>\n" +
-            "        <index-column name=\"when\"/>\n" +
-            "        <index-column name=\"id\"/>\n" +
-            "      </index>\n" +
-            "    </table>\n" +
-            "  </database>\n",
-            writeModel(model));
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"TableWithIndex\">\n" +
+            "    <column name=\"id\" primaryKey=\"true\" required=\"true\" type=\"DOUBLE\" autoIncrement=\"false\" />\n" +
+            "    <column name=\"when\" primaryKey=\"false\" required=\"true\" type=\"TIMESTAMP\" autoIncrement=\"false\" />\n" +
+            "    <column name=\"value\" primaryKey=\"false\" required=\"false\" type=\"SMALLINT\" default=\"1\" autoIncrement=\"false\" />\n" +
+            "    <index>\n" +
+            "      <index-column name=\"when\" />\n" +
+            "      <index-column name=\"id\" />\n" +
+            "    </index>\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
+    }
+
+    /**
+     * Tests a database model with an index with a name.
+     */
+    public void testIndexWithName() throws Exception
+    {
+        Database model = readModel(
+            "<database name='test'>\n" +
+            "  <table name='TableWithIndex'>\n" +
+            "    <column name='id'\n" +
+            "            type='DOUBLE'\n" +
+            "            primaryKey='true'\n" +
+            "            required='true'/>\n" +
+            "    <column name='value'\n" +
+            "            type='SMALLINT'\n" +
+            "            default='1'/>\n" +
+            "    <index name='The Index'>\n" +
+            "      <index-column name='value'/>\n" +
+            "    </index>\n" +
+            "  </table>\n" +
+            "</database>");
+
+        assertEquals("test", model.getName());
+        assertEquals(1, model.getTableCount());
+        
+        Table table = model.getTable(0);
+
+        assertEquals("TableWithIndex", null, 2, 1, 0, 0, 1,
+                     table);
+        assertEquals("id", Types.DOUBLE, 0, 0, null, null, null, true, true, false,
+                     table.getColumn(0));
+        assertEquals("value", Types.SMALLINT, 0, 0, "1", null, null, false, false, false,
+                     table.getColumn(1));
+
+        Index index = table.getIndex(0);
+
+        assertEquals("The Index", false, 1, index);
+        assertEquals(table.getColumn(1), null, index.getColumn(0));
+
+        assertEquals(
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"TableWithIndex\">\n" +
+            "    <column name=\"id\" primaryKey=\"true\" required=\"true\" type=\"DOUBLE\" autoIncrement=\"false\" />\n" +
+            "    <column name=\"value\" primaryKey=\"false\" required=\"false\" type=\"SMALLINT\" default=\"1\" autoIncrement=\"false\" />\n" +
+            "    <index name=\"The Index\">\n" +
+            "      <index-column name=\"value\" />\n" +
+            "    </index>\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
+    }
+
+    /**
+     * Tests a database model with an index without index columns.
+     */
+    public void testIndexWithoutColumns() throws Exception
+    {
+        try
+        {
+            readModel(
+                "<database name='test'>\n" +
+                "  <table name='TableWithIndex'>\n" +
+                "    <column name='id'\n" +
+                "            type='DOUBLE'\n" +
+                "            primaryKey='true'\n" +
+                "            required='true'/>\n" +
+                "    <column name='value'\n" +
+                "            type='SMALLINT'\n" +
+                "            default='1'/>\n" +
+                "    <index>\n" +
+                "    </index>\n" +
+                "  </table>\n" +
+                "</database>");
+
+            fail();
+        }
+        catch (ModelException ex)
+        {}
+    }
+
+    /**
+     * Tests a database model with an index with an index column that references an undefined column.
+     */
+    public void testIndexWithUndefinedColumns() throws Exception
+    {
+        try
+        {
+            readModel(
+                "<database name='test'>\n" +
+                "  <table name='TableWithIndex'>\n" +
+                "    <column name='id'\n" +
+                "            type='DOUBLE'\n" +
+                "            primaryKey='true'\n" +
+                "            required='true'/>\n" +
+                "    <column name='value'\n" +
+                "            type='SMALLINT'\n" +
+                "            default='1'/>\n" +
+                "    <index>\n" +
+                "      <index-column name='theValue'/>\n" +
+                "    </index>\n" +
+                "  </table>\n" +
+                "</database>");
+
+            fail();
+        }
+        catch (ModelException ex)
+        {}
+    }
+
+    /**
+     * Tests a database model with an index with an index column that has no name.
+     */
+    public void testIndexWithNoNameColumn() throws Exception
+    {
+        try
+        {
+            readModel(
+                "<database name='test'>\n" +
+                "  <table name='TableWithIndex'>\n" +
+                "    <column name='id'\n" +
+                "            type='DOUBLE'\n" +
+                "            primaryKey='true'\n" +
+                "            required='true'/>\n" +
+                "    <column name='value'\n" +
+                "            type='SMALLINT'\n" +
+                "            default='1'/>\n" +
+                "    <index>\n" +
+                "      <index-column/>\n" +
+                "    </index>\n" +
+                "  </table>\n" +
+                "</database>");
+
+            fail();
+        }
+        catch (ModelException ex)
+        {}
+    }
+
+
+    /**
+     * Tests a database model with an unique index.
+     */
+    public void testSingleUniqueIndex() throws Exception
+    {
+        Database model = readModel(
+            "<database name='test'>\n" +
+            "  <table name='TableWithIndex'>\n" +
+            "    <column name='id'\n" +
+            "            type='DOUBLE'\n" +
+            "            primaryKey='true'\n" +
+            "            required='true'/>\n" +
+            "    <column name='value'\n" +
+            "            type='SMALLINT'\n" +
+            "            default='1'/>\n" +
+            "    <unique>\n" +
+            "      <unique-column name='value'/>\n" +
+            "    </unique>\n" +
+            "  </table>\n" +
+            "</database>");
+
+        assertEquals("test", model.getName());
+        assertEquals(1, model.getTableCount());
+        
+        Table table = model.getTable(0);
+
+        assertEquals("TableWithIndex", null, 2, 1, 0, 0, 1,
+                     table);
+        assertEquals("id", Types.DOUBLE, 0, 0, null, null, null, true, true, false,
+                     table.getColumn(0));
+        assertEquals("value", Types.SMALLINT, 0, 0, "1", null, null, false, false, false,
+                     table.getColumn(1));
+
+        Index index = table.getIndex(0);
+
+        assertEquals(null, true, 1, index);
+        assertEquals(table.getColumn(1), null, index.getColumn(0));
+
+        assertEquals(
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"TableWithIndex\">\n" +
+            "    <column name=\"id\" primaryKey=\"true\" required=\"true\" type=\"DOUBLE\" autoIncrement=\"false\" />\n" +
+            "    <column name=\"value\" primaryKey=\"false\" required=\"false\" type=\"SMALLINT\" default=\"1\" autoIncrement=\"false\" />\n" +
+            "    <unique>\n" +
+            "      <unique-column name=\"value\" />\n" +
+            "    </unique>\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
+    }
+
+    /**
+     * Tests a database model with an unique index with two columns.
+     */
+    public void testUniqueIndexWithTwoColumns() throws Exception
+    {
+        Database model = readModel(
+            "<database name='test'>\n" +
+            "  <table name='TableWithIndex'>\n" +
+            "    <column name='id'\n" +
+            "            type='DOUBLE'\n" +
+            "            primaryKey='true'\n" +
+            "            required='true'/>\n" +
+            "    <column name='when'\n" +
+            "            type='TIMESTAMP'\n" +
+            "            required='true'/>\n" +
+            "    <column name='value'\n" +
+            "            type='SMALLINT'\n" +
+            "            default='1'/>\n" +
+            "    <unique>\n" +
+            "      <unique-column name='when'/>\n" +
+            "      <unique-column name='id'/>\n" +
+            "    </unique>\n" +
+            "  </table>\n" +
+            "</database>");
+
+        assertEquals("test", model.getName());
+        assertEquals(1, model.getTableCount());
+        
+        Table table = model.getTable(0);
+
+        assertEquals("TableWithIndex", null, 3, 1, 0, 0, 1,
+                     table);
+        assertEquals("id", Types.DOUBLE, 0, 0, null, null, null, true, true, false,
+                     table.getColumn(0));
+        assertEquals("when", Types.TIMESTAMP, 0, 0, null, null, null, false, true, false,
+                     table.getColumn(1));
+        assertEquals("value", Types.SMALLINT, 0, 0, "1", null, null, false, false, false,
+                     table.getColumn(2));
+
+        Index index = table.getIndex(0);
+
+        assertEquals(null, true, 2, index);
+        assertEquals(table.getColumn(1), null, index.getColumn(0));
+        assertEquals(table.getColumn(0), null, index.getColumn(1));
+
+        assertEquals(
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"TableWithIndex\">\n" +
+            "    <column name=\"id\" primaryKey=\"true\" required=\"true\" type=\"DOUBLE\" autoIncrement=\"false\" />\n" +
+            "    <column name=\"when\" primaryKey=\"false\" required=\"true\" type=\"TIMESTAMP\" autoIncrement=\"false\" />\n" +
+            "    <column name=\"value\" primaryKey=\"false\" required=\"false\" type=\"SMALLINT\" default=\"1\" autoIncrement=\"false\" />\n" +
+            "    <unique>\n" +
+            "      <unique-column name=\"when\" />\n" +
+            "      <unique-column name=\"id\" />\n" +
+            "    </unique>\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
+    }
+
+    /**
+     * Tests a database model with an unique index with a name.
+     */
+    public void testUniqueIndexWithName() throws Exception
+    {
+        Database model = readModel(
+            "<database name='test'>\n" +
+            "  <table name='TableWithIndex'>\n" +
+            "    <column name='id'\n" +
+            "            type='DOUBLE'\n" +
+            "            primaryKey='true'\n" +
+            "            required='true'/>\n" +
+            "    <column name='value'\n" +
+            "            type='SMALLINT'\n" +
+            "            default='1'/>\n" +
+            "    <unique name='The Index'>\n" +
+            "      <unique-column name='value'/>\n" +
+            "    </unique>\n" +
+            "  </table>\n" +
+            "</database>");
+
+        assertEquals("test", model.getName());
+        assertEquals(1, model.getTableCount());
+        
+        Table table = model.getTable(0);
+
+        assertEquals("TableWithIndex", null, 2, 1, 0, 0, 1,
+                     table);
+        assertEquals("id", Types.DOUBLE, 0, 0, null, null, null, true, true, false,
+                     table.getColumn(0));
+        assertEquals("value", Types.SMALLINT, 0, 0, "1", null, null, false, false, false,
+                     table.getColumn(1));
+
+        Index index = table.getIndex(0);
+
+        assertEquals("The Index", true, 1, index);
+        assertEquals(table.getColumn(1), null, index.getColumn(0));
+
+        assertEquals(
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"TableWithIndex\">\n" +
+            "    <column name=\"id\" primaryKey=\"true\" required=\"true\" type=\"DOUBLE\" autoIncrement=\"false\" />\n" +
+            "    <column name=\"value\" primaryKey=\"false\" required=\"false\" type=\"SMALLINT\" default=\"1\" autoIncrement=\"false\" />\n" +
+            "    <unique name=\"The Index\">\n" +
+            "      <unique-column name=\"value\" />\n" +
+            "    </unique>\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
+    }
+
+    /**
+     * Tests a database model with an unique index without index columns.
+     */
+    public void testUniqueIndexWithoutColumns() throws Exception
+    {
+        try
+        {
+            readModel(
+                "<database name='test'>\n" +
+                "  <table name='TableWithIndex'>\n" +
+                "    <column name='id'\n" +
+                "            type='DOUBLE'\n" +
+                "            primaryKey='true'\n" +
+                "            required='true'/>\n" +
+                "    <column name='value'\n" +
+                "            type='SMALLINT'\n" +
+                "            default='1'/>\n" +
+                "    <unique>\n" +
+                "    </unique>\n" +
+                "  </table>\n" +
+                "</database>");
+
+            fail();
+        }
+        catch (ModelException ex)
+        {}
+    }
+
+    /**
+     * Tests a database model with an unique index with an index column that references an undefined column.
+     */
+    public void testUniqueIndexWithUndefinedColumns() throws Exception
+    {
+        try
+        {
+            readModel(
+                "<database name='test'>\n" +
+                "  <table name='TableWithIndex'>\n" +
+                "    <column name='id'\n" +
+                "            type='DOUBLE'\n" +
+                "            primaryKey='true'\n" +
+                "            required='true'/>\n" +
+                "    <column name='value'\n" +
+                "            type='SMALLINT'\n" +
+                "            default='1'/>\n" +
+                "    <unique>\n" +
+                "      <unique-column name='theValue'/>\n" +
+                "    </unique>\n" +
+                "  </table>\n" +
+                "</database>");
+
+            fail();
+        }
+        catch (ModelException ex)
+        {}
+    }
+
+    /**
+     * Tests a database model with an unique index with an index column that has no name.
+     */
+    public void testUniqueIndexWithNoNameColumn() throws Exception
+    {
+        try
+        {
+            readModel(
+                "<database name='test'>\n" +
+                "  <table name='TableWithIndex'>\n" +
+                "    <column name='id'\n" +
+                "            type='DOUBLE'\n" +
+                "            primaryKey='true'\n" +
+                "            required='true'/>\n" +
+                "    <column name='value'\n" +
+                "            type='SMALLINT'\n" +
+                "            default='1'/>\n" +
+                "    <unique>\n" +
+                "      <unique-column/>\n" +
+                "    </unique>\n" +
+                "  </table>\n" +
+                "</database>");
+
+            fail();
+        }
+        catch (ModelException ex)
+        {}
     }
 
     /**
      * Tests a database model with indices, both uniques and non-uniques.
      */
-    public void testIndices2() throws Exception
+    public void testMixedIndexes() throws Exception
     {
         Database model = readModel(
             "<database name='test'>\n" +
-            "  <table name='TableWidthIndices'>\n" +
+            "  <table name='TableWithIndexes'>\n" +
             "    <column name='id'\n" +
             "            type='SMALLINT'\n" +
             "            primaryKey='false'\n" +
@@ -436,97 +1882,44 @@
             "  </table>\n" +
             "</database>");
 
-        assertEquals("test",
-                     model.getName());
-        assertEquals(1,
-                     model.getTableCount());
+        assertEquals("test", model.getName());
+        assertEquals(1, model.getTableCount());
         
         Table table = model.getTable(0);
 
-        assertEquals("TableWidthIndices",
-                     table.getName());
-        assertNull(table.getDescription());
-        assertEquals(2,
-                     table.getColumnCount());
-        assertEquals(0,
-                     table.getForeignKeyCount());
-        assertEquals(2,
-                     table.getIndexCount());
-
-        Column column = table.getColumn(0);
-
-        assertEquals("id",
-                     column.getName());
-        assertEquals("SMALLINT",
-                     column.getType());
-        assertEquals(Types.SMALLINT,
-                     column.getTypeCode());
-        assertFalse(column.isPrimaryKey());
-        assertTrue(column.isRequired());
-        assertTrue(column.isAutoIncrement());
-        assertNull(column.getDefaultValue());
-        assertNull(column.getDefaultValue());
-        assertNull(column.getDescription());
-        
-        assertEquals(1, table.getAutoIncrementColumns().length);
-        assertEquals(column, table.getAutoIncrementColumns()[0]);
-
-        column = table.getColumn(1);
-
-        assertEquals("when",
-                     column.getName());
-        assertEquals("DATE",
-                     column.getType());
-        assertEquals(Types.DATE,
-                     column.getTypeCode());
-        assertFalse(column.isPrimaryKey());
-        assertFalse(column.isRequired());
-        assertFalse(column.isAutoIncrement());
-        assertNull(column.getDefaultValue());
-        assertNull(column.getDescription());
+        assertEquals("TableWithIndexes", null, 2, 0, 1, 0, 2,
+                     table);
+        assertEquals("id", Types.SMALLINT, 0, 0, null, null, null, false, true, true,
+                     table.getColumn(0));
+        assertEquals("when", Types.DATE, 0, 0, null, null, null, false, false, false,
+                     table.getColumn(1));
+        assertEquals(table.getColumn(0), table.getAutoIncrementColumns()[0]);
 
         Index index = table.getIndex(0);
 
-        assertEquals("important column",
-                     index.getName());
-        assertTrue(index.isUnique());
-        assertEquals(1,
-                     index.getColumnCount());
-
-        IndexColumn indexColumn = index.getColumn(0);
-
-        assertEquals("id",
-                     indexColumn.getName());
-        assertNull(indexColumn.getSize());
+        assertEquals("important column", true, 1, index);
+        assertEquals(table.getColumn(0), null, index.getColumn(0));
 
         index = table.getIndex(1);
 
-        assertNull(index.getName());
-        assertFalse(index.isUnique());
-        assertEquals(1,
-                     index.getColumnCount());
-
-        indexColumn = index.getColumn(0);
-
-        assertEquals("when",
-                     indexColumn.getName());
-        assertNull(indexColumn.getSize());
+        assertEquals(null, false, 1, index);
+        assertEquals(table.getColumn(1), null, index.getColumn(0));
 
         assertEquals(
-            "<?xml version=\"1.0\"?>\n<!DOCTYPE database SYSTEM \"" + LocalEntityResolver.DTD_PREFIX + "\">\n" +
-            "  <database name=\"test\">\n" +
-            "    <table name=\"TableWidthIndices\">\n" +
-            "      <column name=\"id\" primaryKey=\"false\" required=\"true\" type=\"SMALLINT\" autoIncrement=\"true\"/>\n" +
-            "      <column name=\"when\" primaryKey=\"false\" required=\"false\" type=\"DATE\" autoIncrement=\"false\"/>\n" +
-            "      <unique name=\"important column\">\n" +
-            "        <unique-column name=\"id\"/>\n" +
-            "      </unique>\n" +
-            "      <index>\n" +
-            "        <index-column name=\"when\"/>\n" +
-            "      </index>\n" +
-            "    </table>\n" +
-            "  </database>\n",
-            writeModel(model));
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"TableWithIndexes\">\n" +
+            "    <column name=\"id\" primaryKey=\"false\" required=\"true\" type=\"SMALLINT\" autoIncrement=\"true\" />\n" +
+            "    <column name=\"when\" primaryKey=\"false\" required=\"false\" type=\"DATE\" autoIncrement=\"false\" />\n" +
+            "    <unique name=\"important column\">\n" +
+            "      <unique-column name=\"id\" />\n" +
+            "    </unique>\n" +
+            "    <index>\n" +
+            "      <index-column name=\"when\" />\n" +
+            "    </index>\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
     }
 
     /**
@@ -605,356 +1998,116 @@
             "  </table>\n" +
             "</database>");
 
-        assertEquals("test",
-                     model.getName());
-        assertEquals(3,
-                     model.getTableCount());
+        assertEquals("test", model.getName());
+        assertEquals(3, model.getTableCount());
 
         // table A
 
         Table table = model.getTable(0);
 
-        assertEquals("A",
-                     table.getName());
-        assertEquals("Table A",
-                     table.getDescription());
-        assertEquals(3,
-                     table.getColumnCount());
-        assertEquals(1,
-                     table.getForeignKeyCount());
-        assertEquals(1,
-                     table.getIndexCount());
-
-        Column column = table.getColumn(0);
-
-        assertEquals("id",
-                     column.getName());
-        assertEquals("INTEGER",
-                     column.getType());
-        assertEquals(Types.INTEGER,
-                     column.getTypeCode());
-        assertNull(column.getSize());
-        assertEquals(0,
-                     column.getSizeAsInt());
-        assertTrue(column.isPrimaryKey());
-        assertTrue(column.isRequired());
-        assertTrue(column.isAutoIncrement());
-        assertNull(column.getDefaultValue());
-        assertEquals("The primary key of table A",
-                     column.getDescription());
-        assertEquals(1, table.getAutoIncrementColumns().length);
-        assertEquals(column,
-                     table.getAutoIncrementColumns()[0]);
-
-        column = table.getColumn(1);
-
-        assertEquals("parentId",
-                     column.getName());
-        assertEquals("INTEGER",
-                     column.getType());
-        assertEquals(Types.INTEGER,
-                     column.getTypeCode());
-        assertNull(column.getSize());
-        assertEquals(0,
-                     column.getSizeAsInt());
-        assertFalse(column.isPrimaryKey());
-        assertFalse(column.isRequired());
-        assertFalse(column.isAutoIncrement());
-        assertNull(column.getDefaultValue());
-        assertEquals("The field for the foreign key parent",
-                     column.getDescription());
-
-        column = table.getColumn(2);
-
-        assertEquals("name",
-                     column.getName());
-        assertEquals("VARCHAR",
-                     column.getType());
-        assertEquals(Types.VARCHAR,
-                     column.getTypeCode());
-        assertEquals("32",
-                     column.getSize());
-        assertEquals(32,
-                     column.getSizeAsInt());
-        assertFalse(column.isPrimaryKey());
-        assertTrue(column.isRequired());
-        assertFalse(column.isAutoIncrement());
-        assertNull(column.getDefaultValue());
-        assertEquals("The name",
-                     column.getDescription());
+        assertEquals("A", "Table A", 3, 1, 1, 1, 1,
+                     table);
+        assertEquals("id", Types.INTEGER, 0, 0, null, "The primary key of table A", null, true, true, true,
+                     table.getColumn(0));
+        assertEquals("parentId", Types.INTEGER, 0, 0, null, "The field for the foreign key parent", null, false, false, false,
+                     table.getColumn(1));
+        assertEquals("name", Types.VARCHAR, 32, 0, null, "The name", null, false, true, false,
+                     table.getColumn(2));
+        assertEquals(table.getColumn(0), table.getAutoIncrementColumns()[0]);
 
         ForeignKey fk = table.getForeignKey(0);
 
-        assertEquals("parent",
-                     fk.getName());
-        assertEquals(table,
-                     fk.getForeignTable());
-        assertEquals("A",
-                     fk.getForeignTableName());
-        assertEquals(1,
-                     fk.getReferenceCount());
-
-        Reference ref = fk.getFirstReference();
-
-        assertEquals(table.getColumn(1),
-                     ref.getLocalColumn());
-        assertEquals("parentId",
-                     ref.getLocalColumnName());
-        assertEquals(table.getColumn(0),
-                     ref.getForeignColumn());
-        assertEquals("id",
-                     ref.getForeignColumnName());
+        assertEquals("parent", CascadeActionEnum.NONE, CascadeActionEnum.NONE, table, 1, fk);
+        assertEquals(table.getColumn(1), table.getColumn(0), fk.getFirstReference());
 
         Index index = table.getIndex(0);
 
-        assertNull(index.getName());
-        assertTrue(index.isUnique());
-        assertEquals(1,
-                     index.getColumnCount());
-
-        IndexColumn indexColumn = index.getColumn(0);
-
-        assertEquals("name",
-                     indexColumn.getName());
-        assertNull(indexColumn.getSize());
+        assertEquals(null, true, 1, index);
+        assertEquals(table.getColumn(2), null, index.getColumn(0));
 
         // table B
         
         table = model.getTable(1);
 
-        assertEquals("B",
-                     table.getName());
-        assertEquals("Table B",
-                     table.getDescription());
-        assertEquals(0, table.getAutoIncrementColumns().length);
-        assertEquals(3,
-                     table.getColumnCount());
-        assertEquals(2,
-                     table.getForeignKeyCount());
-        assertEquals(1,
-                     table.getIndexCount());
-
-        column = table.getColumn(0);
-
-        assertEquals("id",
-                     column.getName());
-        assertEquals("TIMESTAMP",
-                     column.getType());
-        assertEquals(Types.TIMESTAMP,
-                     column.getTypeCode());
-        assertNull(column.getSize());
-        assertEquals(0,
-                     column.getSizeAsInt());
-        assertTrue(column.isPrimaryKey());
-        assertTrue(column.isRequired());
-        assertFalse(column.isAutoIncrement());
-        assertNull(column.getDefaultValue());
-        assertEquals("The primary key of table B",
-                     column.getDescription());
-
-        column = table.getColumn(1);
-
-        assertEquals("aid",
-                     column.getName());
-        assertEquals("INTEGER",
-                     column.getType());
-        assertEquals(Types.INTEGER,
-                     column.getTypeCode());
-        assertNull(column.getSize());
-        assertEquals(0,
-                     column.getSizeAsInt());
-        assertFalse(column.isPrimaryKey());
-        assertFalse(column.isRequired());
-        assertFalse(column.isAutoIncrement());
-        assertNull(column.getDefaultValue());
-        assertEquals("The field for the foreign key towards A",
-                     column.getDescription());
-
-        column = table.getColumn(2);
-
-        assertEquals("cid",
-                     column.getName());
-        assertEquals("CHAR",
-                     column.getType());
-        assertEquals(Types.CHAR,
-                     column.getTypeCode());
-        assertEquals("32",
-                     column.getSize());
-        assertEquals(32,
-                     column.getSizeAsInt());
-        assertFalse(column.isPrimaryKey());
-        assertFalse(column.isRequired());
-        assertFalse(column.isAutoIncrement());
-        assertNull(column.getDefaultValue());
-        assertEquals("The field for the foreign key towards C",
-                     column.getDescription());
+        assertEquals("B", "Table B", 3, 1, 0, 2, 1,
+                     table);
+        assertEquals("id", Types.TIMESTAMP, 0, 0, null, "The primary key of table B", null, true, true, false,
+                     table.getColumn(0));
+        assertEquals("aid", Types.INTEGER, 0, 0, null, "The field for the foreign key towards A", null, false, false, false,
+                     table.getColumn(1));
+        assertEquals("cid", Types.CHAR, 32, 0, null, "The field for the foreign key towards C", null, false, false, false,
+                     table.getColumn(2));
 
         fk = table.getForeignKey(0);
 
-        assertNull(fk.getName());
-        assertEquals(model.getTable(0),
-                     fk.getForeignTable());
-        assertEquals("A",
-                     fk.getForeignTableName());
-        assertEquals(1,
-                     fk.getReferenceCount());
-
-        ref = fk.getFirstReference();
-
-        assertEquals(table.getColumn(1),
-                     ref.getLocalColumn());
-        assertEquals("aid",
-                     ref.getLocalColumnName());
-        assertEquals(model.getTable(0).getColumn(0),
-                     ref.getForeignColumn());
-        assertEquals("id",
-                     ref.getForeignColumnName());
+        assertEquals(null, CascadeActionEnum.NONE, CascadeActionEnum.NONE, model.getTable(0), 1, fk);
+        assertEquals(table.getColumn(1), model.getTable(0).getColumn(0), fk.getFirstReference());
 
         fk = table.getForeignKey(1);
 
-        assertNull(fk.getName());
-        assertEquals(model.getTable(2),
-                     fk.getForeignTable());
-        assertEquals("C",
-                     fk.getForeignTableName());
-        assertEquals(1,
-                     fk.getReferenceCount());
-
-        ref = fk.getFirstReference();
-
-        assertEquals(table.getColumn(2),
-                     ref.getLocalColumn());
-        assertEquals("cid",
-                     ref.getLocalColumnName());
-        assertEquals(model.getTable(2).getColumn(0),
-                     ref.getForeignColumn());
-        assertEquals("id",
-                     ref.getForeignColumnName());
+        assertEquals(null, CascadeActionEnum.NONE, CascadeActionEnum.NONE, model.getTable(2), 1, fk);
+        assertEquals(table.getColumn(2), model.getTable(2).getColumn(0), fk.getFirstReference());
 
         index = table.getIndex(0);
 
-        assertNull(index.getName());
-        assertFalse(index.isUnique());
-        assertEquals(2,
-                     index.getColumnCount());
-
-        indexColumn = index.getColumn(0);
-
-        assertEquals("aid",
-                     indexColumn.getName());
-        assertNull(indexColumn.getSize());
-
-        indexColumn = index.getColumn(1);
-
-        assertEquals("cid",
-                     indexColumn.getName());
-        assertNull(indexColumn.getSize());
+        assertEquals(null, false, 2, index);
+        assertEquals(table.getColumn(1), null, index.getColumn(0));
+        assertEquals(table.getColumn(2), null, index.getColumn(1));
 
         // table C
 
         table = model.getTable(2);
 
-        assertEquals("C",
-                     table.getName());
-        assertEquals("Table C",
-                     table.getDescription());
-        assertEquals(0, table.getAutoIncrementColumns().length);
-        assertEquals(2,
-                     table.getColumnCount());
-        assertEquals(0,
-                     table.getForeignKeyCount());
-        assertEquals(1,
-                     table.getIndexCount());
-
-        column = table.getColumn(0);
-
-        assertEquals("id",
-                     column.getName());
-        assertEquals("CHAR",
-                     column.getType());
-        assertEquals(Types.CHAR,
-                     column.getTypeCode());
-        assertEquals("32",
-                     column.getSize());
-        assertEquals(32,
-                     column.getSizeAsInt());
-        assertTrue(column.isPrimaryKey());
-        assertTrue(column.isRequired());
-        assertFalse(column.isAutoIncrement());
-        assertNull(column.getDefaultValue());
-        assertEquals("The primary key of table C",
-                     column.getDescription());
-
-        column = table.getColumn(1);
-
-        assertEquals("text",
-                     column.getName());
-        assertEquals("LONGVARCHAR",
-                     column.getType());
-        assertEquals(Types.LONGVARCHAR,
-                     column.getTypeCode());
-        assertNull(column.getSize());
-        assertEquals(0,
-                     column.getSizeAsInt());
-        assertFalse(column.isPrimaryKey());
-        assertFalse(column.isRequired());
-        assertFalse(column.isAutoIncrement());
-        assertNull(column.getDefaultValue());
-        assertEquals("The text",
-                     column.getDescription());
+        assertEquals("C", "Table C", 2, 1, 0, 0, 1,
+                     table);
+        assertEquals("id", Types.CHAR, 32, 0, null, "The primary key of table C", null, true, true, false,
+                     table.getColumn(0));
+        assertEquals("text", Types.LONGVARCHAR, 0, 0, null, "The text", null, false, false, false,
+                     table.getColumn(1));
 
         index = table.getIndex(0);
 
-        assertEquals("byText",
-                     index.getName());
-        assertFalse(index.isUnique());
-        assertEquals(1,
-                     index.getColumnCount());
-
-        indexColumn = index.getColumn(0);
-
-        assertEquals("text",
-                     indexColumn.getName());
-        assertNull(indexColumn.getSize());
+        assertEquals("byText", false, 1, index);
+        assertEquals(table.getColumn(1), null, index.getColumn(0));
 
         assertEquals(
-            "<?xml version=\"1.0\"?>\n<!DOCTYPE database SYSTEM \"" + LocalEntityResolver.DTD_PREFIX + "\">\n" +
-            "  <database name=\"test\">\n" +
-            "    <table name=\"A\" description=\"Table A\">\n" +
-            "      <column name=\"id\" primaryKey=\"true\" required=\"true\" type=\"INTEGER\" autoIncrement=\"true\" description=\"The primary key of table A\"/>\n" +
-            "      <column name=\"parentId\" primaryKey=\"false\" required=\"false\" type=\"INTEGER\" autoIncrement=\"false\" description=\"The field for the foreign key parent\"/>\n" +
-            "      <column name=\"name\" primaryKey=\"false\" required=\"true\" type=\"VARCHAR\" size=\"32\" autoIncrement=\"false\" description=\"The name\"/>\n" +
-            "      <foreign-key foreignTable=\"A\" name=\"parent\">\n" +
-            "        <reference local=\"parentId\" foreign=\"id\"/>\n" +
-            "      </foreign-key>\n" +
-            "      <unique>\n" +
-            "        <unique-column name=\"name\"/>\n" +
-            "      </unique>\n" +
-            "    </table>\n" +
-            "    <table name=\"B\" description=\"Table B\">\n" +
-            "      <column name=\"id\" primaryKey=\"true\" required=\"true\" type=\"TIMESTAMP\" autoIncrement=\"false\" description=\"The primary key of table B\"/>\n" +
-            "      <column name=\"aid\" primaryKey=\"false\" required=\"false\" type=\"INTEGER\" autoIncrement=\"false\" description=\"The field for the foreign key towards A\"/>\n" +
-            "      <column name=\"cid\" primaryKey=\"false\" required=\"false\" type=\"CHAR\" size=\"32\" autoIncrement=\"false\" description=\"The field for the foreign key towards C\"/>\n" +
-            "      <foreign-key foreignTable=\"A\">\n" +
-            "        <reference local=\"aid\" foreign=\"id\"/>\n" +
-            "      </foreign-key>\n" +
-            "      <foreign-key foreignTable=\"C\">\n" +
-            "        <reference local=\"cid\" foreign=\"id\"/>\n" +
-            "      </foreign-key>\n" +
-            "      <index>\n" +
-            "        <index-column name=\"aid\"/>\n" +
-            "        <index-column name=\"cid\"/>\n" +
-            "      </index>\n" +
-            "    </table>\n" +
-            "    <table name=\"C\" description=\"Table C\">\n" +
-            "      <column name=\"id\" primaryKey=\"true\" required=\"true\" type=\"CHAR\" size=\"32\" autoIncrement=\"false\" description=\"The primary key of table C\"/>\n" +
-            "      <column name=\"text\" primaryKey=\"false\" required=\"false\" type=\"LONGVARCHAR\" autoIncrement=\"false\" description=\"The text\"/>\n" +
-            "      <index name=\"byText\">\n" +
-            "        <index-column name=\"text\"/>\n" +
-            "      </index>\n" +
-            "    </table>\n" +
-            "  </database>\n",
-            writeModel(model));
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"A\" description=\"Table A\">\n" +
+            "    <column name=\"id\" primaryKey=\"true\" required=\"true\" type=\"INTEGER\" autoIncrement=\"true\" description=\"The primary key of table A\" />\n" +
+            "    <column name=\"parentId\" primaryKey=\"false\" required=\"false\" type=\"INTEGER\" autoIncrement=\"false\" description=\"The field for the foreign key parent\" />\n" +
+            "    <column name=\"name\" primaryKey=\"false\" required=\"true\" type=\"VARCHAR\" size=\"32\" autoIncrement=\"false\" description=\"The name\" />\n" +
+            "    <foreign-key foreignTable=\"A\" name=\"parent\">\n" +
+            "      <reference local=\"parentId\" foreign=\"id\" />\n" +
+            "    </foreign-key>\n" +
+            "    <unique>\n" +
+            "      <unique-column name=\"name\" />\n" +
+            "    </unique>\n" +
+            "  </table>\n" +
+            "  <table name=\"B\" description=\"Table B\">\n" +
+            "    <column name=\"id\" primaryKey=\"true\" required=\"true\" type=\"TIMESTAMP\" autoIncrement=\"false\" description=\"The primary key of table B\" />\n" +
+            "    <column name=\"aid\" primaryKey=\"false\" required=\"false\" type=\"INTEGER\" autoIncrement=\"false\" description=\"The field for the foreign key towards A\" />\n" +
+            "    <column name=\"cid\" primaryKey=\"false\" required=\"false\" type=\"CHAR\" size=\"32\" autoIncrement=\"false\" description=\"The field for the foreign key towards C\" />\n" +
+            "    <foreign-key foreignTable=\"A\">\n" +
+            "      <reference local=\"aid\" foreign=\"id\" />\n" +
+            "    </foreign-key>\n" +
+            "    <foreign-key foreignTable=\"C\">\n" +
+            "      <reference local=\"cid\" foreign=\"id\" />\n" +
+            "    </foreign-key>\n" +
+            "    <index>\n" +
+            "      <index-column name=\"aid\" />\n" +
+            "      <index-column name=\"cid\" />\n" +
+            "    </index>\n" +
+            "  </table>\n" +
+            "  <table name=\"C\" description=\"Table C\">\n" +
+            "    <column name=\"id\" primaryKey=\"true\" required=\"true\" type=\"CHAR\" size=\"32\" autoIncrement=\"false\" description=\"The primary key of table C\" />\n" +
+            "    <column name=\"text\" primaryKey=\"false\" required=\"false\" type=\"LONGVARCHAR\" autoIncrement=\"false\" description=\"The text\" />\n" +
+            "    <index name=\"byText\">\n" +
+            "      <index-column name=\"text\" />\n" +
+            "    </index>\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
     }
 
     /**
@@ -985,52 +2138,6 @@
     }
 
     /**
-     * Tests that an exception is generated when the database element has no name attribute.
-     */
-    public void testDatabaseWithoutName()
-    {
-        try
-        {
-            readModel(
-                "<database>\n" +
-                "  <table name='TestTable'>\n" +
-                "    <column name='id'\n" +
-                "            type='INTEGER'\n" +
-                "            primaryKey='true'\n" +
-                "            required='true'/>\n" +
-                "  </table>\n" +
-                "</database>");
-
-            fail();
-        }
-        catch (ModelException ex)
-        {}
-    }
-
-    /**
-     * Tests that an exception is generated when the table element has no name attribute.
-     */
-    public void testTableWithoutName()
-    {
-        try
-        {
-            readModel(
-                "<database name='test'>\n" +
-                "  <table>\n" +
-                "    <column name='id'\n" +
-                "            type='INTEGER'\n" +
-                "            primaryKey='true'\n" +
-                "            required='true'/>\n" +
-                "  </table>\n" +
-                "</database>");
-
-            fail();
-        }
-        catch (ModelException ex)
-        {}
-    }
-
-    /**
      * Tests that an exception is generated when two table elements have the same value in their name attributes.
      */
     public void testTwoTablesWithTheSameName()
@@ -1060,28 +2167,6 @@
     }
 
     /**
-     * Tests that an exception is generated when the column element has no name attribute.
-     */
-    public void testColumnWithoutName()
-    {
-        try
-        {
-            readModel(
-                "<database name='test'>\n" +
-                "  <table name='TestTable'>\n" +
-                "    <column type='INTEGER'\n" +
-                "            primaryKey='true'\n" +
-                "            required='true'/>\n" +
-                "  </table>\n" +
-                "</database>");
-
-            fail();
-        }
-        catch (ModelException ex)
-        {}
-    }
-
-    /**
      * Tests that an exception is generated when two column elements within the same table
      * element have the same value in their name attributes.
      */
@@ -1108,28 +2193,6 @@
     }
 
     /**
-     * Tests that an exception is generated when the column element has no type attribute.
-     */
-    public void testColumnWithoutType()
-    {
-        try
-        {
-            readModel(
-                "<database name='test'>\n" +
-                "  <table name='TestTable'>\n" +
-                "    <column name='id'\n" +
-                "            primaryKey='true'\n" +
-                "            required='true'/>\n" +
-                "  </table>\n" +
-                "</database>");
-
-            fail();
-        }
-        catch (ModelException ex)
-        {}
-    }
-
-    /**
      * Tests that an exception is generated when the a unique index references an undefined column.
      */
     public void testUndefinedUniqueColumn()
@@ -1272,7 +2335,6 @@
                 "  <index name='NotATable'/>\n" +
                 "</database>");
 
-        _log.debug("Table : " + Arrays.asList(database.getTables()));
         assertEquals(0, database.getTableCount());
     }
 
@@ -1287,70 +2349,30 @@
             "    <column name='intField'\n" +
             "            type='BOOLEANINT'/>\n" +
             "    <column name='charField'\n" +
-            "            type='BOOLEANCHAR'/>\n" +
+            "            type='BOOLEANCHAR' />\n" +
             "  </table>\n" +
             "</database>");
 
-        assertEquals("test",
-                     model.getName());
-        assertEquals(1,
-                     model.getTableCount());
+        assertEquals("test", model.getName());
+        assertEquals(1, model.getTableCount());
         
         Table table = model.getTable(0);
 
-        assertEquals("SomeTable",
-                     table.getName());
-        assertNull(table.getDescription());
-        assertEquals(0, table.getAutoIncrementColumns().length);
-        assertEquals(2,
-                     table.getColumnCount());
-        assertEquals(0,
-                     table.getForeignKeyCount());
-        assertEquals(0,
-                     table.getIndexCount());
-
-        Column column = table.getColumn(0);
-
-        assertEquals("intField",
-                     column.getName());
-        assertEquals("TINYINT",
-                     column.getType());
-        assertEquals(Types.TINYINT,
-                     column.getTypeCode());
-        assertFalse(column.isPrimaryKey());
-        assertFalse(column.isRequired());
-        assertFalse(column.isAutoIncrement());
-        assertNull(column.getDefaultValue());
-        assertNull(column.getDescription());
-
-        column = table.getColumn(1);
-
-        assertEquals("charField",
-                     column.getName());
-        assertEquals("CHAR",
-                     column.getType());
-        assertEquals(Types.CHAR,
-                     column.getTypeCode());
-        assertFalse(column.isPrimaryKey());
-        assertFalse(column.isRequired());
-        assertFalse(column.isAutoIncrement());
-        assertNull(column.getDefaultValue());
-        assertNull(column.getDescription());
+        assertEquals("SomeTable", null, 2, 0, 0, 0, 0,
+                     table);
+        assertEquals("intField", Types.TINYINT, 0, 0, null, null, null, false, false, false,
+                     table.getColumn(0));
+        assertEquals("charField", Types.CHAR, 0, 0, null, null, null, false, false, false,
+                     table.getColumn(1));
 
         assertEquals(
-            "<?xml version=\"1.0\"?>\n<!DOCTYPE database SYSTEM \"" + LocalEntityResolver.DTD_PREFIX + "\">\n" +
-            "  <database name=\"test\">\n" +
-            "    <table name=\"SomeTable\">\n" +
-            "      <column name=\"intField\" primaryKey=\"false\" required=\"false\" type=\"TINYINT\" autoIncrement=\"false\"/>\n" +
-            "      <column name=\"charField\" primaryKey=\"false\" required=\"false\" type=\"CHAR\" autoIncrement=\"false\"/>\n" +
-            "    </table>\n" +
-            "  </database>\n",
-            writeModel(model));
+            "<?xml version='1.0' encoding='UTF-8'?>\n" +
+            "<database name=\"test\">\n" +
+            "  <table name=\"SomeTable\">\n" +
+            "    <column name=\"intField\" primaryKey=\"false\" required=\"false\" type=\"TINYINT\" autoIncrement=\"false\" />\n" +
+            "    <column name=\"charField\" primaryKey=\"false\" required=\"false\" type=\"CHAR\" autoIncrement=\"false\" />\n" +
+            "  </table>\n" +
+            "</database>\n",
+            model);
     }
-
-    // TODO: Tests that include:
-    // * foreign key references undefined table
-    // * foreign key references undefined local column
-    // * foreign key references undefined foreign column
-    // * two foreign keys with the same name
 }