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.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.apache.commons.collections.map.ListOrderedMap;
import org.apache.ddlutils.DdlUtilsException;
import org.apache.ddlutils.Platform;
import org.apache.ddlutils.model.Column;
import org.apache.ddlutils.model.Database;
import org.apache.ddlutils.model.Table;
/**
* Provides basic live database data <-> XML functionality.
*
* @version $Revision: $
*/
public class DatabaseDataIO
{
/** The converters to use for converting between data and its XML representation. */
private ArrayList _converters = new ArrayList();
/** Whether we should continue when an error was detected. */
private boolean _failOnError = true;
/** Whether foreign key order shall be followed when inserting data into the database. */
private boolean _ensureFKOrder = true;
/** Whether we should use batch mode. */
private boolean _useBatchMode;
/** The maximum number of objects to insert in one batch. */
private Integer _batchSize;
/** Whether DdlUtils should search for the schema of the tables. @deprecated */
private boolean _determineSchema;
/** The schema pattern for finding tables when reading data from a live database. @deprecated */
private String _schemaPattern;
/**
* Registers a converter.
*
* @param converterRegistration The registration info
*/
public void registerConverter(DataConverterRegistration converterRegistration)
{
_converters.add(converterRegistration);
}
/**
* Determines whether data io is stopped when an error happens.
*
* @return Whether io is stopped when an error was detected (true by default)
*/
public boolean isFailOnError()
{
return _failOnError;
}
/**
* Specifies whether data io shall be stopped when an error happens.
*
* @param failOnError Whether io should stop when an error was detected
*/
public void setFailOnError(boolean failOnError)
{
_failOnError = failOnError;
}
/**
* Determines whether batch mode is used for inserting data into the database.
*
* @return <code>true</code> if batch mode is used
*/
public boolean getUseBatchMode()
{
return _useBatchMode;
}
/**
* Specifies whether batch mode should be used for inserting data into the database.
*
* @param useBatchMode <code>true</code> if batch mode shall be used
*/
public void setUseBatchMode(boolean useBatchMode)
{
_useBatchMode = useBatchMode;
}
/**
* Returns the batch size override.
*
* @return The batch size if different from the default, <code>null</code> otherwise
*/
public Integer getBatchSize()
{
return _batchSize;
}
/**
* Sets the batch size to be used by this object.
*
* @param batchSize The batch size if different from the default, or <code>null</code> if
* the default shall be used
*/
public void setBatchSize(Integer batchSize)
{
_batchSize = batchSize;
}
/**
* Determines whether the sink delays the insertion of beans so that the beans referenced by it
* via foreignkeys are already inserted into the database.
*
* @return <code>true</code> if beans are inserted after its foreignkey-references
*/
public boolean isEnsureFKOrder()
{
return _ensureFKOrder;
}
/**
* Specifies whether the sink shall delay the insertion of beans so that the beans referenced by it
* via foreignkeys are already inserted into the database.<br/>
* Note that you should careful with setting <code>haltOnErrors</code> to false as this might
* result in beans not inserted at all. The sink will then throw an appropriate exception at the end
* of the insertion process (method {@link DataSink#end()}).
*
* @param ensureFKOrder <code>true</code> if beans shall be inserted after its foreignkey-references
*/
public void setEnsureFKOrder(boolean ensureFKOrder)
{
_ensureFKOrder = ensureFKOrder;
}
/**
* Specifies whether DdlUtils should try to find the schema of the tables when reading data
* from a live database.
*
* @param determineSchema Whether to try to find the table's schemas
* @deprecated Will be removed once proper schema support is in place
*/
public void setDetermineSchema(boolean determineSchema)
{
_determineSchema = determineSchema;
}
/**
* Sets the schema pattern to find the schemas of tables when reading data from a live database.
*
* @param schemaPattern The schema pattern
* @deprecated Will be removed once proper schema support is in place
*/
public void setSchemaPattern(String schemaPattern)
{
_schemaPattern = schemaPattern;
}
/**
* Registers the converters at the given configuration.
*
* @param converterConf The converter configuration
*/
private void registerConverters(ConverterConfiguration converterConf) throws DdlUtilsException
{
for (Iterator it = _converters.iterator(); it.hasNext();)
{
DataConverterRegistration registrationInfo = (DataConverterRegistration)it.next();
if (registrationInfo.getTypeCode() != Integer.MIN_VALUE)
{
converterConf.registerConverter(registrationInfo.getTypeCode(),
registrationInfo.getConverter());
}
else
{
if ((registrationInfo.getTable() == null) || (registrationInfo.getColumn() == null))
{
throw new DdlUtilsException("Please specify either the jdbc type or a table/column pair for which the converter shall be defined");
}
converterConf.registerConverter(registrationInfo.getTable(),
registrationInfo.getColumn(),
registrationInfo.getConverter());
}
}
}
/**
* Returns a data writer instance configured to write to the indicated file
* in the specified encoding.
*
* @param path The path to the output XML data file
* @param xmlEncoding The encoding to use for writing the XML
* @return The writer
*/
public DataWriter getConfiguredDataWriter(String path, String xmlEncoding) throws DdlUtilsException
{
try
{
DataWriter writer = new DataWriter(new FileOutputStream(path), xmlEncoding);
registerConverters(writer.getConverterConfiguration());
return writer;
}
catch (IOException ex)
{
throw new DdlUtilsException(ex);
}
}
/**
* Returns a data writer instance configured to write to the given output stream
* in the specified encoding.
*
* @param output The output stream
* @param xmlEncoding The encoding to use for writing the XML
* @return The writer
*/
public DataWriter getConfiguredDataWriter(OutputStream output, String xmlEncoding) throws DdlUtilsException
{
DataWriter writer = new DataWriter(output, xmlEncoding);
registerConverters(writer.getConverterConfiguration());
return writer;
}
/**
* Returns a data writer instance configured to write to the given output writer
* in the specified encoding.
*
* @param output The output writer; needs to be configured with the specified encoding
* @param xmlEncoding The encoding to use for writing the XML
* @return The writer
*/
public DataWriter getConfiguredDataWriter(Writer output, String xmlEncoding) throws DdlUtilsException
{
DataWriter writer = new DataWriter(output, xmlEncoding);
registerConverters(writer.getConverterConfiguration());
return writer;
}
/**
* Writes the data contained in the database to which the given platform is connected, as XML
* to the given output stream (which won't be closed by this method).
*
* @param platform The platform; needs to be connected to a live database
* @param path The path of the output file
* @param xmlEncoding The encoding to use for the XML
*/
public void writeDataToXML(Platform platform, String path, String xmlEncoding) throws DdlUtilsException
{
writeDataToXML(platform, getConfiguredDataWriter(path, xmlEncoding));
}
/**
* Writes the data contained in the database to which the given platform is connected, as XML
* to the given output stream (which won't be closed by this method).
*
* @param platform The platform; needs to be connected to a live database
* @param model The model for which to retrieve and write the data
* @param path The path of the output file
* @param xmlEncoding The encoding to use for the XML
*/
public void writeDataToXML(Platform platform, Database model, String path, String xmlEncoding)
{
writeDataToXML(platform, model, getConfiguredDataWriter(path, xmlEncoding));
}
/**
* Writes the data contained in the database to which the given platform is connected, as XML
* to the given output stream (which won't be closed by this method).
*
* @param platform The platform; needs to be connected to a live database
* @param output The output stream
* @param xmlEncoding The encoding to use for the XML
*/
public void writeDataToXML(Platform platform, OutputStream output, String xmlEncoding)
{
writeDataToXML(platform, getConfiguredDataWriter(output, xmlEncoding));
}
/**
* Writes the data contained in the database to which the given platform is connected, as XML
* to the given output stream (which won't be closed by this method).
*
* @param platform The platform; needs to be connected to a live database
* @param model The model for which to retrieve and write the data
* @param output The output stream
* @param xmlEncoding The encoding to use for the XML
*/
public void writeDataToXML(Platform platform, Database model, OutputStream output, String xmlEncoding)
{
writeDataToXML(platform, model, getConfiguredDataWriter(output, xmlEncoding));
}
/**
* Writes the data contained in the database to which the given platform is connected, as XML
* to the given output writer (which won't be closed by this method).
*
* @param platform The platform; needs to be connected to a live database
* @param output The output writer (which needs to be openend with the specified encoding)
* @param xmlEncoding The encoding to use for the XML
*/
public void writeDataToXML(Platform platform, Writer output, String xmlEncoding)
{
writeDataToXML(platform, getConfiguredDataWriter(output, xmlEncoding));
}
/**
* Writes the data contained in the database to which the given platform is connected, as XML
* to the given output writer (which won't be closed by this method).
*
* @param platform The platform; needs to be connected to a live database
* @param model The model for which to retrieve and write the data
* @param output The output writer (which needs to be openend with the specified encoding)
* @param xmlEncoding The encoding to use for the XML
*/
public void writeDataToXML(Platform platform, Database model, Writer output, String xmlEncoding)
{
writeDataToXML(platform, model, getConfiguredDataWriter(output, xmlEncoding));
}
/**
* Writes the data contained in the database to which the given platform is connected, as XML
* to the given data writer.
*
* @param platform The platform; needs to be connected to a live database
* @param writer The data writer
*/
public void writeDataToXML(Platform platform, DataWriter writer)
{
writeDataToXML(platform, platform.readModelFromDatabase("unnamed"), writer);
}
/**
* Writes the data contained in the database to which the given platform is connected, as XML
* to the given data writer.
*
* @param platform The platform; needs to be connected to a live database
* @param model The model for which to retrieve and write the data
* @param writer The data writer
*/
public void writeDataToXML(Platform platform, Database model, DataWriter writer)
{
registerConverters(writer.getConverterConfiguration());
// TODO: An advanced algorithm could be employed here that writes individual
// objects related by foreign keys, in the correct order
List tables = sortTables(model.getTables());
writer.writeDocumentStart();
for (Iterator it = tables.iterator(); it.hasNext();)
{
writeDataForTableToXML(platform, model, (Table)it.next(), writer);
}
writer.writeDocumentEnd();
}
/**
* Sorts the given table according to their foreign key order.
*
* @param tables The tables
* @return The sorted tables
*/
private List sortTables(Table[] tables)
{
ArrayList result = new ArrayList();
HashSet processed = new HashSet();
ListOrderedMap pending = new ListOrderedMap();
for (int idx = 0; idx < tables.length; idx++)
{
Table table = tables[idx];
if (table.getForeignKeyCount() == 0)
{
result.add(table);
processed.add(table);
}
else
{
HashSet waitedFor = new HashSet();
for (int fkIdx = 0; fkIdx < table.getForeignKeyCount(); fkIdx++)
{
Table waitedForTable = table.getForeignKey(fkIdx).getForeignTable();
if (!table.equals(waitedForTable))
{
waitedFor.add(waitedForTable);
}
}
pending.put(table, waitedFor);
}
}
HashSet newProcessed = new HashSet();
while (!processed.isEmpty() && !pending.isEmpty())
{
newProcessed.clear();
for (Iterator it = pending.entrySet().iterator(); it.hasNext();)
{
Map.Entry entry = (Map.Entry)it.next();
Table table = (Table)entry.getKey();
HashSet waitedFor = (HashSet)entry.getValue();
waitedFor.removeAll(processed);
if (waitedFor.isEmpty())
{
it.remove();
result.add(table);
newProcessed.add(table);
}
}
processed.clear();
HashSet tmp = processed;
processed = newProcessed;
newProcessed = tmp;
}
// the remaining are within circular dependencies
for (Iterator it = pending.keySet().iterator(); it.hasNext();)
{
result.add(it.next());
}
return result;
}
/**
* Writes the data contained in a single table to XML.
*
* @param platform The platform
* @param model The database model
* @param table The table
* @param writer The data writer
*/
private void writeDataForTableToXML(Platform platform, Database model, Table table, DataWriter writer)
{
Table[] tables = { table };
StringBuffer query = new StringBuffer();
query.append("SELECT ");
Connection connection = null;
String schema = null;
if (_determineSchema)
{
try
{
// TODO: Remove this once we have full support for schemas
connection = platform.borrowConnection();
schema = platform.getModelReader().determineSchemaOf(connection, _schemaPattern, tables[0]);
}
catch (SQLException ex)
{
// ignored
}
finally
{
if (connection != null)
{
try
{
connection.close();
}
catch (SQLException ex)
{
// ignored
}
}
}
}
Column[] columns = tables[0].getColumns();
for (int columnIdx = 0; columnIdx < columns.length; columnIdx++)
{
if (columnIdx > 0)
{
query.append(",");
}
if (platform.isDelimitedIdentifierModeOn())
{
query.append(platform.getPlatformInfo().getDelimiterToken());
}
query.append(columns[columnIdx].getName());
if (platform.isDelimitedIdentifierModeOn())
{
query.append(platform.getPlatformInfo().getDelimiterToken());
}
}
query.append(" FROM ");
if (platform.isDelimitedIdentifierModeOn())
{
query.append(platform.getPlatformInfo().getDelimiterToken());
}
if (schema != null)
{
query.append(schema);
query.append(".");
}
query.append(tables[0].getName());
if (platform.isDelimitedIdentifierModeOn())
{
query.append(platform.getPlatformInfo().getDelimiterToken());
}
writer.write(platform.query(model, query.toString(), tables));
}
/**
* Returns a data reader instance configured for the given platform (which needs to
* be connected to a live database) and model.
*
* @param platform The database
* @param model The model
* @return The data reader
*/
public DataReader getConfiguredDataReader(Platform platform, Database model) throws DdlUtilsException
{
DataToDatabaseSink sink = new DataToDatabaseSink(platform, model);
DataReader reader = new DataReader();
sink.setHaltOnErrors(_failOnError);
sink.setEnsureForeignKeyOrder(_ensureFKOrder);
sink.setUseBatchMode(_useBatchMode);
if (_batchSize != null)
{
sink.setBatchSize(_batchSize.intValue());
}
reader.setModel(model);
reader.setSink(sink);
registerConverters(reader.getConverterConfiguration());
return reader;
}
/**
* Reads the data from the specified files and writes it to the database to which the given
* platform is connected.
*
* @param platform The platform, must be connected to a live database
* @param files The XML data files
*/
public void writeDataToDatabase(Platform platform, String[] files) throws DdlUtilsException
{
writeDataToDatabase(platform, platform.readModelFromDatabase("unnamed"), files);
}
/**
* Reads the data from the given input streams and writes it to the database to which the given
* platform is connected.
*
* @param platform The platform, must be connected to a live database
* @param inputs The input streams for the XML data
*/
public void writeDataToDatabase(Platform platform, InputStream[] inputs) throws DdlUtilsException
{
writeDataToDatabase(platform, platform.readModelFromDatabase("unnamed"), inputs);
}
/**
* Reads the data from the given input readers and writes it to the database to which the given
* platform is connected.
*
* @param platform The platform, must be connected to a live database
* @param inputs The input readers for the XML data
*/
public void writeDataToDatabase(Platform platform, Reader[] inputs) throws DdlUtilsException
{
writeDataToDatabase(platform, platform.readModelFromDatabase("unnamed"), inputs);
}
/**
* Reads the data from the indicated files and writes it to the database to which the given
* platform is connected. Only data that matches the given model will be written.
*
* @param platform The platform, must be connected to a live database
* @param model The model to which to constrain the written data
* @param files The XML data files
*/
public void writeDataToDatabase(Platform platform, Database model, String[] files) throws DdlUtilsException
{
DataReader dataReader = getConfiguredDataReader(platform, model);
dataReader.getSink().start();
for (int idx = 0; (files != null) && (idx < files.length); idx++)
{
writeDataToDatabase(dataReader, files[idx]);
}
dataReader.getSink().end();
}
/**
* Reads the data from the given input streams and writes it to the database to which the given
* platform is connected. Only data that matches the given model will be written.
*
* @param platform The platform, must be connected to a live database
* @param model The model to which to constrain the written data
* @param inputs The input streams for the XML data
*/
public void writeDataToDatabase(Platform platform, Database model, InputStream[] inputs) throws DdlUtilsException
{
DataReader dataReader = getConfiguredDataReader(platform, model);
dataReader.getSink().start();
for (int idx = 0; (inputs != null) && (idx < inputs.length); idx++)
{
writeDataToDatabase(dataReader, inputs[idx]);
}
dataReader.getSink().end();
}
/**
* Reads the data from the given input readers and writes it to the database to which the given
* platform is connected. Only data that matches the given model will be written.
*
* @param platform The platform, must be connected to a live database
* @param model The model to which to constrain the written data
* @param inputs The input readers for the XML data
*/
public void writeDataToDatabase(Platform platform, Database model, Reader[] inputs) throws DdlUtilsException
{
DataReader dataReader = getConfiguredDataReader(platform, model);
dataReader.getSink().start();
for (int idx = 0; (inputs != null) && (idx < inputs.length); idx++)
{
writeDataToDatabase(dataReader, inputs[idx]);
}
dataReader.getSink().end();
}
/**
* Reads the data from the specified files and writes it to the database via the given data reader.
* Note that the sink that the data reader is configured with, won't be started or ended by
* this method. This has to be done by the code using this method.
*
* @param dataReader The data reader
* @param files The XML data files
*/
public void writeDataToDatabase(DataReader dataReader, String[] files) throws DdlUtilsException
{
for (int idx = 0; (files != null) && (idx < files.length); idx++)
{
writeDataToDatabase(dataReader, files[idx]);
}
}
/**
* Reads the data from the given input stream and writes it to the database via the given data reader.
* Note that the input stream won't be closed by this method. Note also that the sink that the data
* reader is configured with, won't be started or ended by this method. This has to be done by the
* code using this method.
*
* @param dataReader The data reader
* @param inputs The input streams for the XML data
*/
public void writeDataToDatabase(DataReader dataReader, InputStream[] inputs) throws DdlUtilsException
{
for (int idx = 0; (inputs != null) && (idx < inputs.length); idx++)
{
writeDataToDatabase(dataReader, inputs[idx]);
}
}
/**
* Reads the data from the given input stream and writes it to the database via the given data reader.
* Note that the input stream won't be closed by this method. Note also that the sink that the data
* reader is configured with, won't be started or ended by this method. This has to be done by the
* code using this method.
*
* @param dataReader The data reader
* @param inputs The input readers for the XML data
*/
public void writeDataToDatabase(DataReader dataReader, Reader[] inputs) throws DdlUtilsException
{
for (int idx = 0; (inputs != null) && (idx < inputs.length); idx++)
{
writeDataToDatabase(dataReader, inputs[idx]);
}
}
/**
* Reads the data from the indicated XML file and writes it to the database via the given data reader.
* Note that the sink that the data reader is configured with, won't be started or ended by this method.
* This has to be done by the code using this method.
*
* @param dataReader The data reader
* @param path The path to the XML data file
*/
public void writeDataToDatabase(DataReader dataReader, String path) throws DdlUtilsException
{
try
{
dataReader.parse(path);
}
catch (Exception ex)
{
throw new DdlUtilsException(ex);
}
}
/**
* Reads the data from the given input stream and writes it to the database via the given data reader.
* Note that the input stream won't be closed by this method. Note also that the sink that the data
* reader is configured with, won't be started or ended by this method. This has to be done by the
* code using this method.
*
* @param dataReader The data reader
* @param input The input stream for the XML data
*/
public void writeDataToDatabase(DataReader dataReader, InputStream input) throws DdlUtilsException
{
try
{
dataReader.parse(input);
}
catch (Exception ex)
{
throw new DdlUtilsException(ex);
}
}
/**
* Reads the data from the given input stream and writes it to the database via the given data reader.
* Note that the input stream won't be closed by this method. Note also that the sink that the data
* reader is configured with, won't be started or ended by this method. This has to be done by the
* code using this method.
*
* @param dataReader The data reader
* @param input The input reader for the XML data
*/
public void writeDataToDatabase(DataReader dataReader, Reader input) throws DdlUtilsException
{
try
{
dataReader.parse(input);
}
catch (Exception ex)
{
throw new DdlUtilsException(ex);
}
}
}