empire-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From doeb...@apache.org
Subject svn commit: r683173 [4/10] - in /incubator/empire-db/trunk/core/Empire-db: ./ .settings/ bin/ lib/ src/ src/META-INF/ src/org/ src/org/apache/ src/org/apache/empire/ src/org/apache/empire/commons/ src/org/apache/empire/data/ src/org/apache/empire/data/...
Date Wed, 06 Aug 2008 08:47:43 GMT
Added: incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBCommandExpr.java
URL: http://svn.apache.org/viewvc/incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBCommandExpr.java?rev=683173&view=auto
==============================================================================
--- incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBCommandExpr.java (added)
+++ incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBCommandExpr.java Wed Aug  6 01:47:37 2008
@@ -0,0 +1,531 @@
+/*
+ * ESTEAM Software GmbH
+ */
+package org.apache.empire.db;
+
+// java
+import java.sql.Connection;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import org.apache.empire.commons.Errors;
+import org.apache.empire.commons.Options;
+import org.apache.empire.data.DataType;
+import org.w3c.dom.Element;
+
+
+/**
+ * This abstract class handles the creation of the SQL-Commands.
+ * There are inner classes to construct different SQL-Commands.
+ * <P>
+ * 
+ * @author ESTEAM software <A TARGET="esteam" HREF="http://www.esteam.de">www.esteam.de</A>
+ */
+public abstract class DBCommandExpr extends DBExpr
+{
+    // Internal Classes
+    protected static class DBCmdQuery extends DBRowSet
+    {
+        private DBCommandExpr cmd;
+
+        /**
+         * Creates a new DBCmdQueryObject
+         */
+        public DBCmdQuery(DBCommandExpr cmd, DBColumnExpr[] colList)
+        { // Set the column expressions
+            super(cmd.getDatabase());
+            this.cmd = cmd;
+            // Add Expressions to vector
+            for (int i = 0; i < colList.length; i++)
+                columns.add(colList[i].getUpdateColumn());
+        }
+
+        /** Not applicable - returns null */
+        @Override
+        public String getName()
+        {
+            return null;
+        }
+
+        /** Not applicable - returns null */
+        @Override
+        public String getAlias()
+        {
+            return null;
+        }
+
+        /**
+         * @see org.apache.empire.db.DBExpr#addReferencedColumns(Set)
+         */
+        @Override
+        public void addReferencedColumns(Set<DBColumn> list)
+        {
+            list.addAll(columns);
+        }
+
+        /**
+         * Creates the SQL-Command adds the select statement into the SQL-Command.
+         * 
+         * @param buf the SQL-Command
+         * @param context the current SQL-Command context
+         */
+        @Override
+        public void addSQL(StringBuilder buf, long context)
+        {
+            buf.append("(");
+            buf.append(cmd.getSelect());
+            buf.append(")");
+        }
+
+        /**
+         * Prints the error message: ERR_NOTSUPPORTED.
+         * 
+         * @return null
+         */
+        @Override
+        public DBColumn[] getKeyColumns()
+        {
+            error(Errors.NotSupported, "getKeyColumns");
+            return null;
+        }
+
+        /**
+         * Prints the error message: ERR_NOTSUPPORTED.
+         * 
+         * @return null
+         */
+        @Override
+        public Object[] getRecordKey(DBRecord rec)
+        {
+            error(Errors.NotSupported, "getRecordKey");
+            return null;
+        }
+
+        /** Returns the error message: ERR_NOTSUPPORTED */
+        @Override
+        public boolean initRecord(DBRecord rec, Object[] keyValues)
+        {
+            return error(Errors.NotSupported, "initRecord");
+        }
+
+        /** Returns the error message: ERR_NOTSUPPORTED */
+        @Override
+        public boolean createRecord(DBRecord rec, Connection conn)
+        {
+            return error(Errors.NotSupported, "addRecord");
+        }
+
+        /** Returns the error message: ERR_NOTSUPPORTED */
+        @Override
+        public boolean readRecord(DBRecord rec, Object[] keys, Connection conn)
+        {
+            return error(Errors.NotSupported, "getRecord");
+        }
+
+        /** Returns the error message: ERR_NOTSUPPORTED */
+        @Override
+        public boolean updateRecord(DBRecord rec, Connection conn)
+        {
+            return error(Errors.NotSupported, "updateRecord");
+        }
+
+        /** Returns the error message: ERR_NOTSUPPORTED */
+        @Override
+        public boolean deleteRecord(Object[] keys, Connection conn)
+        {
+            return error(Errors.NotSupported, "deleteRecord");
+        }
+    }
+
+    /**
+     * This class wrapps a column of sql command in a special command column object. 
+     * @author ESTEAM
+     */
+    protected static class DBCmdColumn extends DBColumn
+    {
+        private DBColumnExpr expr;
+
+        /**
+         * Constructs a new DBCmdColumn object set the specified parameters to this object
+         */
+        public DBCmdColumn(DBRowSet query, DBColumnExpr expr)
+        { // call base
+            super(query, expr.getName());
+            // set Expression
+            this.expr = expr;
+        }
+
+        /**
+         * create the SQL-Command set the expression name to the SQL-Command
+         * 
+         * @param buf the SQL-Command
+         * @param context the current SQL-Command context
+         */
+        @Override
+        public void addSQL(StringBuilder buf, long context)
+        { // append UNQUALIFIED name only!
+            buf.append(expr.getName());
+        }
+
+        /**
+         * Returns the data type of the DBColumnExpr object.
+         * 
+         * @return the data type
+         */
+        @Override
+        public DataType getDataType()
+        {
+            return expr.getDataType();
+        }
+
+        /**
+         * Not applicable - always returns 0.
+         */
+        @Override
+        public double getSize()
+        {
+            return 0;
+        }
+
+        /**
+         * Not applicable - always returns true
+         */
+        @Override
+        public boolean isReadOnly()
+        {
+            return true; // expr.isReadOnly();
+        }
+
+        /**
+         * Checks whether the column is mandatory.
+         * 
+         * @return true if the column is mandatory or false otherwise
+         */
+        @Override
+        public boolean isRequired()
+        {
+            return false;
+        }
+
+        /**
+         * Get Attributes of underlying table column.
+         */
+        @Override
+        public Object getAttribute(String name)
+        {
+            if (attributes != null && attributes.containsKey(name))
+                return attributes.get(name);
+            // Otherwise ask expression
+            DBColumn column = expr.getUpdateColumn();
+            if (column!=null)
+                return column.getAttribute(name);
+            return null;
+        }
+
+        /**
+         * Get Options of underlying table column.
+         */
+        @Override
+        public Options getOptions()
+        {
+            if (options != null)
+                return options;
+            // Otherwise ask expression
+            DBColumn column = expr.getUpdateColumn();
+            if (column!=null)
+                return column.getOptions();
+            return null;
+        }
+
+        /**
+         * Not applicable - always returns true.
+         */
+        @Override
+        public boolean checkValue(Object value)
+        {
+            return true;
+        }
+
+        /**
+         * Adds the expression definition to the xml element.
+         */
+        @Override
+        public Element addXml(Element parent, long flags)
+        {
+            return expr.addXml(parent, flags);
+        }
+
+    }
+
+    protected static class DBOrderByInfo extends DBExpr
+    {
+        public DBColumnExpr expr;
+        public boolean      desc;
+
+        /**
+         * Construct a new DBOrderByInfo object set the specified
+         * parameters to this object.
+         */
+        public DBOrderByInfo(DBColumnExpr expr, boolean desc)
+        {
+            this.expr = expr;
+            this.desc = desc;
+        }
+
+        /** Returns the current database object */
+        @Override
+        public DBDatabase getDatabase()
+        {
+            return expr.getDatabase();
+        }
+
+        /**
+         * @see org.apache.empire.db.DBExpr#addColumns(List)
+         */
+        @Override
+        public void addReferencedColumns(Set<DBColumn> list)
+        {
+            expr.addReferencedColumns(list);
+        }
+
+        /**
+         * Creates the SQL-Command set "DESC" command after the order by statement.
+         * 
+         * @param buf the SQL-Command
+         * @param context the current SQL-Command context
+         */
+        @Override
+        public void addSQL(StringBuilder buf, long context)
+        { // Set SQL-Order By
+            expr.addSQL(buf, context);
+            if (desc)
+                buf.append(" DESC");
+        }
+    }
+
+    // Members
+    protected DBCmdQuery          cmdQuery = null;
+    protected List<DBOrderByInfo> orderBy  = null;
+
+    /** Constructs an empty DBCommandExpr object */
+    public DBCommandExpr()
+    {
+        // Default Construtor
+    }
+
+    // get Select SQL
+    public abstract boolean isValid();
+
+    public abstract boolean getSelect(StringBuilder buf);
+
+    public abstract DBColumnExpr[] getSelectExprList();
+
+    public DBColumnExpr getCmdColumn(DBColumnExpr col)
+    {
+        // Check the Instance of col
+        if ((col instanceof DBCmdColumn))
+        { // Check Owner
+            DBCmdColumn c = (DBCmdColumn) col;
+            if (c.getRowSet() == cmdQuery)
+                return col; // it's aready a command column
+            // extract the expression
+            col = c.expr;
+        }
+        // Check if we already have a Command Query
+        if (cmdQuery == null)
+            cmdQuery = new DBCmdQuery(this, getSelectExprList());
+        // create a command column
+        return new DBCmdColumn(cmdQuery, col);
+    }
+
+    public DBColumnExpr getCmdColumn(int i)
+    {
+        DBColumnExpr[] list = getSelectExprList();
+        if (i >= list.length)
+            return null;
+        return getCmdColumn(list[i]);
+    }
+
+    /**
+     * returns an SQL select command for querying records.
+     * @return the SQL-Command
+     */
+    public String getSelect()
+    {
+        StringBuilder buf = new StringBuilder();
+        if (getSelect(buf) == false)
+        {
+            log.error(getErrorMessage());
+            return null;
+        }
+        return buf.toString();
+    }
+
+    /**
+     * Internally used to build a string from a list of database expressions
+     * @param buf the sql target buffer
+     * @param list list of database objects
+     * @param context the sql command context
+     * @param separator string to use as separator between list items
+     */
+    protected void addListExpr(StringBuilder buf, List<? extends DBExpr> list, long context, String separator)
+    {
+        for (int i = 0; i < list.size(); i++)
+        { // Selectfelder zusammenbauen
+            if (i > 0)
+                buf.append(separator);
+            list.get(i).addSQL(buf, context);
+        }
+    }
+
+    /**
+     * Creates the SQL-Command.
+     * 
+     * @param buf the SQL-Command
+     * @param context the current SQL-Command context
+     */
+    @Override
+    public void addSQL(StringBuilder buf, long context)
+    {
+        buf.append("(");
+        buf.append(getSelect());
+        buf.append(")");
+    }
+
+    /**
+     * Constructs a new DBCombinedCmd object with this object,
+     * the key word= "UNION" and the selected DBCommandExpr.
+     * 
+     * @see org.apache.empire.db.DBCombinedCmd
+     * @param other the secend DBCommandExpr
+     * @return the new DBCombinedCmd object
+     */
+    // Combinations
+    public DBCommandExpr union(DBCommandExpr other)
+    {
+        return new DBCombinedCmd(this, "UNION", other);
+    }
+
+    /**
+     * Constructs a new DBCombinedCmd object with this object,
+     * the key word= "INTERSECT" and the selected DBCommandExpr.
+     * 
+     * @param other the secend DBCommandExpr
+     * @return the new DBCombinedCmd object
+     */
+    public DBCommandExpr intersect(DBCommandExpr other)
+    {
+        return new DBCombinedCmd(this, "INTERSECT", other);
+    }
+
+    /**
+     * Clears the list of order by expressions.
+     */
+    public void clearOrderBy()
+    {
+        orderBy = null;
+    }
+
+    /**
+     * Creates a new DBOrderByInfo object and add it to the Vector 'orderBy'.
+     * 
+     * @param expr the DBColumnExpr object
+     * @param desc if true, the results from select statement will sort top down
+     */
+    public void orderBy(DBColumnExpr expr, boolean desc)
+    {
+        if (orderBy == null)
+            orderBy = new ArrayList<DBOrderByInfo>();
+        // Add order by excpression
+        orderBy.add(new DBOrderByInfo(expr, desc));
+    }
+
+    /**
+     * This helper function calls the method orderBy(DBColumnExpr, boolean)
+     * and sets the second parameter to false,creates a new
+     * DBOrderByInfo object and adds it to the Vector 'orderBy'.
+     * 
+     * @see org.apache.empire.db.DBCommandExpr#orderBy(DBColumnExpr, boolean)
+     */
+    public void orderBy(DBColumnExpr expr)
+    {
+        orderBy(expr, false);
+    }
+
+    /**
+     * Create the insert into SQL-Command which copies data
+     * from a select statement to a destination table.
+     * 
+     * @return the insert into SQL-Command
+     */
+    protected String getInsertInto(DBTable table, DBColumnExpr[] select, List<DBColumnExpr> columns)
+    {
+        if (select == null)
+        { // invalid Object
+            error(Errors.ObjectNotValid, getClass().getName());
+            return null;
+        }
+        StringBuilder buf = new StringBuilder("INSERT INTO ");
+        table.addSQL(buf, CTX_FULLNAME);
+        // destination columns
+        if (columns != null && columns.size() > 0)
+        { // Check Count
+            if (columns.size() != select.length)
+            {
+                error(Errors.InvalidArg, columns, "columns");
+                return null;
+            }
+            // Append Names
+            buf.append(" (");
+            addListExpr(buf, columns, CTX_NAME, ", ");
+            buf.append(")");
+        }
+        // append select statement
+        buf.append("\r\n");
+        getSelect(buf);
+        // done
+        return buf.toString();
+    }
+
+    /**
+     * Create the insert into SQL-Command which copies
+     * data from a select statement to a destination table.
+     * 
+     * @return the insert into SQL-Command
+     */
+    public final String getInsertInto(DBTable table, List<DBColumnExpr> columns)
+    {
+        return getInsertInto(table, getSelectExprList(), columns);
+    }
+
+    /**
+     * Create the insert into SQL-Command which copies
+     * data from a select statement to a destination table.
+     * 
+     * @return the insert into SQL-Command
+     */
+    public final String getInsertInto(DBTable table)
+    {
+        DBColumnExpr[] select = getSelectExprList();
+        if (select == null || select.length < 1)
+        {
+            error(Errors.ObjectNotValid, getClass().getName());
+            return null;
+        }
+        // Match Columns
+        List<DBColumnExpr> inscols = new ArrayList<DBColumnExpr>(select.length);
+        for (int i = 0; i < select.length; i++)
+        {
+            DBColumnExpr expr = select[i];
+            DBColumn col = table.getColumn(expr.getName());
+            if (col == null)
+            { // Cannot find a match for that name
+                log.warn("InsertInto: Column " + expr.getName() + " not found!");
+                col = table.getColumn(i);
+            }
+            inscols.add(col);
+        }
+        return getInsertInto(table, select, inscols);
+    }
+}

Added: incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBDatabase.java
URL: http://svn.apache.org/viewvc/incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBDatabase.java?rev=683173&view=auto
==============================================================================
--- incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBDatabase.java (added)
+++ incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBDatabase.java Wed Aug  6 01:47:37 2008
@@ -0,0 +1,1112 @@
+/*
+ * ESTEAM Software GmbH
+ */
+package org.apache.empire.db;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.empire.commons.Errors;
+import org.apache.empire.commons.ObjectUtils;
+import org.apache.empire.commons.Options;
+import org.apache.empire.data.DataType;
+import org.apache.empire.db.expr.column.DBValueExpr;
+
+
+/**
+ * This abstract class is the applicaton's interface for a particular database schema.
+ * <P>
+ * It provides access to the various database objects such als tables, views and relations.
+ * <P>
+ * It also provides methods to execute DQL and DML SQL-commands.
+ * <P>
+ * @author ESTEAM software <A TARGET="esteam" HREF="http://www.esteam.de">www.esteam.de </A>
+ */
+public abstract class DBDatabase extends DBObject
+{
+    /**
+     * This class represents the database systems current date and time.
+     * <P>
+     * There is no need to use this class directly.<BR>
+     * Instead you can use the constant {@link DBDatabase#SYSDATE}
+     */
+    public static final class DBSystemDate 
+    {   
+        // System Date Class for internal use
+        private DBSystemDate() 
+        { 
+            /* no instances */ 
+        }
+        @Override
+        public String toString()
+        {   return "sysdate";
+        }
+    }
+    
+    // Database specific date
+    public static final DBSystemDate SYSDATE  = new DBSystemDate();
+    
+    public static final String EMPTY_STRING = "\0"; // will be replaced by ''
+
+    // Logger
+    private static final Log log = LogFactory.getLog(DBDatabase.class);
+
+    /** the database schema * */
+    protected String           schema    = null; // database schema name
+    protected String           linkName  = null; // database link name
+    protected List<DBTable>    tables    = new ArrayList<DBTable>();
+    protected List<DBRelation> relations = new ArrayList<DBRelation>();
+    protected List<DBView>     views     = new ArrayList<DBView>();
+    protected DBDatabaseDriver driver    = null;
+
+    /**
+     * Constructs a new DBDatabase object set the variable 'schema' = null.
+     */
+    public DBDatabase()
+    {
+        this.schema = null;
+    }
+
+    /**
+     * Constructs a new DBDatabase object and sets the specified schema object.
+     * 
+     * @param schema the database schema
+     */
+    public DBDatabase(String schema)
+    {
+        this.schema = schema;
+    }
+
+    /**
+     * Constructs a new DBDatabase object and sets the specified schema object.
+     * 
+     * @param schema the database schema
+     * @param linkName the database link name
+     */
+    public DBDatabase(String schema, String linkName)
+    {
+        this.schema = schema;
+        this.linkName = linkName;
+    }
+
+    // ------------------------------
+    // -- Database methods --
+    // ------------------------------
+
+    /**
+     * Returns the driver for this database.
+     * 
+     * @return Returns the driver for this database
+     */
+    public DBDatabaseDriver getDriver()
+    {
+        return driver;
+    }
+
+    /**
+     * Sets the database driver for this database. <br>
+     * ------ DO NOT CALL DIRECTLY! ------- <br>
+     * This function is called internally by DBDatabaseDriver:openDatabase()
+     */
+    public boolean open(DBDatabaseDriver driver, Connection conn)
+    {
+        // Close Database if already open
+        if (isOpen())
+            close(conn);
+        // Attach to driver
+        if (driver.attachDatabase(this, conn)==false)
+            return error(driver);
+        // set new driver
+        this.driver = driver;
+        return success();
+    }
+
+    /**
+     * closes this database object by detaching it from the driver
+     * this is a shortcut for calling
+     *  getDriver().closeDatabase(db, conn) 
+     */
+    public void close(Connection conn)
+    {
+        if (driver != null)
+            driver.detachDatabase(this, conn);
+        // No diver
+        this.driver = null;
+    }
+
+    /**
+     * Creates a DDL Script for creating all database objects on the target database.<BR>
+     * This function may be called even if the database has not been previously opened.<BR>
+     * <P>
+     * Once the database is open you can use getDriver().getDLLCommand()
+     * to create, alter or delete other database objects<BR>
+     * <P>
+     * @param driver The driver for which to create a DDL Script
+     * @return the DLL script for creating the entire database schema
+     */
+    public synchronized boolean getCreateDDLScript(DBDatabaseDriver driver, DBSQLScript script)
+    {
+        DBDatabaseDriver prevDriver = this.driver;
+        try {
+            // Set driver
+            if (this.driver!=null && this.driver!=driver && driver!=null)
+            {   // The database belongs to a different driver
+                return error(Errors.Internal, "The database is attached to a different driver.");
+            }
+            // Temporarily change driver
+            if (this.driver== null)
+                this.driver = driver;
+            // Get DDL Command
+            if (driver.getDDLScript(DBCmdType.CREATE, this, script)==false)
+            {   // DDL-creation failed 
+                return error(driver);
+            }
+            return success();
+            
+        } finally {
+            this.driver = prevDriver; 
+        }
+    }
+    
+    /**
+     * @see org.apache.empire.db.DBObject#getDatabase()
+     */
+    @Override
+    public DBDatabase getDatabase()
+    {
+        return this;
+    }
+
+    /**
+     * Returns the schema for SQL statements.
+     * 
+     * @return the schema
+     */
+    public String getSchema()
+    {
+        return schema;
+    }
+
+    /**
+     * Sets the schema for SQL statements.
+     */
+    public boolean setSchema(String schema)
+    {   // Database must not be open so far
+        if (driver != null)
+            return error(Errors.NoAccess);
+        // Set Schema 
+        this.schema = schema;
+        return success();
+    }
+
+    /**
+     * Returns the schema-prefix for SQL statements e.g. "SCHEMA."
+     * or empty string if no schema is defined.
+     * 
+     * @return the schema-prefix
+     */
+    public String getSchemaPrefix()
+    {
+        if (schema == null)
+        {
+            return "";
+        }
+        return schema + ".";
+    }
+
+    /**
+     * Returns the database link name.
+     * 
+     * @return the name of the database link
+     */
+    public String getLinkName()
+    {
+        return linkName;
+    }
+
+    /**
+     * Sets the name of the database link used to identify objects.
+     * 
+     * @param linkName the database link name
+     */
+    public boolean setLinkName(String linkName)
+    {   // Database must not be open so far
+        if (driver != null)
+            return error(Errors.NoAccess);
+        // Set Link 
+        this.linkName = linkName;
+        return success();
+    }
+
+    /**
+     * Returns the full qualified object name including schema prefix
+     * and database link postfix (if any).
+     * 
+     * @param name the object's name
+     * 
+     * @return the qualified object name
+     */
+    public String getQualifiedName(String name)
+    {
+        StringBuilder buf = new StringBuilder();
+        appendQualifiedName(buf, name);
+        return buf.toString();
+    }
+    
+    /**
+     * Adds a full qualified object name including schema prefix
+     * and database link postfix (if any).
+     * to the string buffer suppield
+     * 
+     * @param buf the string buffer to which to append the qualified object name
+     * @param name the object's name
+     */
+    public void appendQualifiedName(StringBuilder buf, String name)
+    {
+        // Schema
+        if (schema != null && driver!=null)
+        { // Add Schema
+            buf.append(schema);
+            buf.append(".");
+        }
+        buf.append(name);
+        // Database Link
+        if (linkName!=null && driver!=null)
+        { // Add Schema
+            buf.append(driver.getSQLPhrase(DBDatabaseDriver.SQL_DATABASE_LINK));
+            buf.append(linkName);
+        }
+    }
+    
+    /**
+     * Creates and returns a value object for the database systems
+     * current date and time.
+     * 
+     * @return a DBValueExpr object
+     */
+    public DBValueExpr getSystemDateExpr()
+    {
+        return new DBValueExpr(this, SYSDATE, DataType.DATETIME);
+    }
+
+    /**
+     * Creates and returns a value object for the given string value.
+     * 
+     * @param value the String value
+     * @return the new DBValueExpr object
+     */
+    public DBValueExpr getValueExpr(String value)
+    {
+        return new DBValueExpr(this, value, DataType.TEXT);
+    }
+
+    /**
+     * Creates and returns a value object for the given boolean value.
+     * 
+     * @param value the Boolean value
+     * @return the new DBValueExpr object
+     */
+    public DBValueExpr getValueExpr(boolean value)
+    {
+        return new DBValueExpr(this, value, DataType.BOOL);
+    }
+
+    /**
+     * Creates and returns a value object for the given integer value.
+     * 
+     * @param value the int value
+     * @return the new DBValueExpr object
+     */
+    public DBValueExpr getValueExpr(int value)
+    {
+        return new DBValueExpr(this, new Integer(value), DataType.INTEGER);
+    }
+
+    /**
+     * Creates and returns a value object for the given long value.
+     * 
+     * @param value the long value
+     * @return the new DBValueExpr object
+     */
+    public DBValueExpr getValueExpr(long value)
+    {
+        return new DBValueExpr(this, new Long(value), DataType.INTEGER);
+    }
+
+    /**
+     * Creates and returns a value object for the given value.
+     * 
+     * @param value the value
+     * @param dataType the database systems data type used for this value
+     * @return the new DBValueExpr object
+     */
+    public DBValueExpr getValueExpr(Object value, DataType dataType)
+    {
+        return new DBValueExpr(this, value, dataType);
+    }
+
+    /**
+     * Adds a DBTable object to list of database tables.<BR>
+     * There is usually no need to call this function directly 
+     * since it is internally called from the DBTable's constructor.
+     * <P> 
+     * @param table the DBTable object
+     * @return true if successful
+     */
+    public boolean addTable(DBTable table)
+    { // find column by name
+        if (table == null || table.getDatabase() != this)
+            return error(Errors.InvalidArg, table, "table");
+        if (tables.contains(table)==true)
+            return error(Errors.ItemExists, table.getName());
+        // Check for second instances
+        DBTable existing = getTable(table.getName()); 
+        if (existing!=null)
+        {   // Check classes
+            if (existing.getClass().equals(table.getClass()))
+                return success(); // Ingore other instances 
+            // Table exists with different class
+            return error(Errors.ItemExists, table.getName());
+        }
+        // add now
+        tables.add(table);
+        return true;
+    }
+
+    /**
+     * Returns the tables which has been defined in the database.
+     * 
+     * @return db tables.
+     */
+    public List<DBTable> getTables()
+    {
+        return tables;
+    }
+
+    /**
+     * Finds a DBTable object by name.
+     * <P>
+     * @param name the name of the table
+     * @return the located DBTable object
+     */
+    public DBTable getTable(String name)
+    { // find table by name
+        for (int i = 0; i < tables.size(); i++)
+        { // search for the table
+            DBTable tab = tables.get(i);
+            if (tab.getName().equalsIgnoreCase(name))
+                return tab;
+        }
+        return null;
+    }
+
+    /**
+     * Adds a foreign key relation to the database.
+     * <P>
+     * @param reference a reference for a source and target column pair
+     * @return true if the relations was successfully created.
+     */
+    public final boolean addRelation(DBRelation.DBReference reference)
+    {
+        String table = reference.getSourceColumn().getRowSet().getName();
+        String col1 = reference.getSourceColumn().getName();
+        // Create Relation Name
+        String name = table.substring(0, Math.min(table.length(), 14)) + "_" + col1.substring(0, Math.min(col1.length(), 12))
+        			  + "_FK";
+        return addReleation(name, new DBRelation.DBReference[] { reference });
+    }
+
+    /**
+     * Add a foreign key relation to the database.
+     * 
+     * @param ref1 a reference for a source and target column pair
+     * @param ref2 a reference for a source and target column pair
+     * @return true if the relations was successfully created.
+     */
+    public final boolean addRelation(DBRelation.DBReference ref1, DBRelation.DBReference ref2)
+    {
+        String table = ref1.getSourceColumn().getRowSet().getName();
+        String col1 = ref1.getSourceColumn().getName();
+        String col2 = ref2.getSourceColumn().getName();
+        // Create Relation Name
+        String name = table.substring(0, Math.min(table.length(), 9))
+                    + "_" + col1.substring(0, Math.min(col1.length(), 9))
+                    + "_" + col2.substring(0, Math.min(col2.length(), 9)) + "_FK";
+        return addReleation(name, new DBRelation.DBReference[] { ref1, ref2 });
+    }
+
+    /**
+     * Adds a foreign key relation to the database.
+     * 
+     * @param references a list of source and target column pairs
+     * @return true if the relations was successfully created.
+     */
+    public boolean addReleation(String name, DBRelation.DBReference[] references)
+    {
+        // Add a Relation
+        DBRelation relation = new DBRelation(this, name, references);
+        if (relations.contains(relation))
+            return error(Errors.ItemExists, name); // Itemn already exists
+        // Add Reference column to table
+        for (DBRelation.DBReference ref : references)
+        {   // add the reference column
+            DBRowSet rset = ref.getSourceColumn().getRowSet();
+            rset.addColumnReference(ref.getSourceColumn(), ref.getTargetColumn());
+        }
+        // OK
+        relations.add(relation);
+        return true;
+    }
+
+    /**
+     * Returns the tables which has been defined in the database.
+     * 
+     * @return db tables.
+     */
+    public List<DBRelation> getRelations()
+    {
+        return relations;
+    }
+
+    /**
+     * Adds a DBView object to list of database views.<BR>
+     * There is usually no need to call this function directly 
+     * since it is internally called from the DBView's constructor.
+     * <P> 
+     * @param view the DBView object
+     * @return true if successful
+     */
+    public boolean addView(DBView view)
+    { // find column by name
+        if (view == null || view.getDatabase() != this)
+            return error(Errors.InvalidArg, view, "view");
+        if (views.contains(view) == true)
+            return error(Errors.ItemExists, view.getName());
+        // add now
+        views.add(view);
+        return true;
+    }
+
+    /**
+     * Returns the tables which has been defined in the database.
+     * 
+     * @return db tables.
+     */
+    public List<DBView> getViews()
+    {
+        return views;
+    }
+
+    /**
+     * Finds a DBView object by name.
+     * 
+     * @param name the name of the view
+     * @return the located DBTable object
+     */
+    public DBView getView(String name)
+    { // find table by name
+        for (int i = 0; i < views.size(); i++)
+        { // search for the table
+            DBView view = views.get(i);
+            if (view.getName().equalsIgnoreCase(name))
+                return view;
+        }
+        return null;
+    }
+
+    /**
+     * Indicates whether the database has been opened.
+     * 
+     * @return The name of the encoding or null if a single byte encoding is used.
+     */
+    public boolean isOpen()
+    {
+        return (driver != null);
+    }
+
+    /**
+     * @return true if the database has been opened or false otherwise 
+     */
+    protected boolean checkOpen()
+    {
+        if (driver == null)
+            return error(DBErrors.DatabaseNotOpen);
+        return success();
+    }
+    
+    /**
+     * Creates a new Command object for this database
+     * 
+     * @return the command obejct.
+     */
+    public DBCommand createCommand()
+    {
+        if (checkOpen()==false)
+            return null;
+        return driver.createCommand(this);
+    }
+
+    /**
+     * Returns a timestamp that is used for record updates.
+     * 
+     * @return the current date and time.
+     */
+    public java.sql.Timestamp getUpdateTimestamp(Connection conn)
+    {
+        // Default implementation
+        if (checkOpen()==false)
+            return null;
+        // Ask driver
+        return driver.getUpdateTimestamp(conn);
+    }
+
+    // Sequences
+    public Object getNextSequenceValue(String seqName, Connection conn)
+    {
+        // Default implementation
+        if (checkOpen()==false)
+            return null;
+        // Ask driver
+        return driver.getNextSequenceValue(this, seqName, 1, conn);
+    }
+
+    /**
+     * Returns the value of the first row/column of a sql-query as an object.
+     * 
+     * @param sqlCmd the SQL-Command
+     * @param conn a valid connection to the database.
+     * @exception java.sql.SQLException if a database access error occurs
+     * @return the first column in the current row as a Java object
+     */
+
+    public Object querySingleValue(String sqlCmd, Connection conn)
+    {
+        ResultSet rs = null;
+        try
+        {	// Check Open
+            if (checkOpen()==false)
+                return null;
+            // Debug
+            long start = System.currentTimeMillis();
+            if (log.isDebugEnabled())
+                log.debug("executing: " + sqlCmd);
+            // Get the next Value
+            rs = driver.executeQuery(sqlCmd, null, false, conn);
+            if (rs == null)
+            { // Error
+                error(driver);
+                return null;
+            }
+            // Check Result
+            if (rs.next() == false)
+            {
+                //log.warn("querySingleValue returned no result : Stack", new Exception("Just to show the stack"));
+                log.debug("querySingleValue returned no result");
+                error(DBErrors.QueryNoResult, sqlCmd);
+                return null;
+            }
+            // No Value
+            clearError();
+            Object result = rs.getObject(1);
+            if (log.isDebugEnabled())
+	            log.debug("querySingleValue complete in " + String.valueOf(System.currentTimeMillis() - start) + " ms -> value="
+	                        + String.valueOf(result));
+            return result;
+        } catch (SQLException e) 
+        {
+            log.error("querySingleValue exception: " + e.toString());
+            error(DBErrors.QueryFailed, e);
+            return null;
+        } finally
+        { // Cleanup
+            closeResultSet(rs);
+        }
+    }
+
+    /**
+     * Returns the value of the first row/column of a sql-query as an int.
+     * 
+     * @param sqlCmd the SQL statement
+     * @param defVal the default value if no value was returned by the database
+     * @param conn a valid connection to the database.
+     * @return the result as a int value, if no result the int value 0
+     */
+    public int querySingleInt(String sqlCmd, int defVal, Connection conn)
+    { 
+        Object value = querySingleValue(sqlCmd, conn);
+        return ((value != null) ? Integer.parseInt(value.toString()) : defVal);
+    }
+
+    /**
+     * Returns the value of the first row/column of a sql-query as an int.
+     * 
+     * @param sqlCmd the SQL statement
+     * @param conn a valid connection to the database.
+     * @return the result as a int value, if no result the int value 0
+     */
+    public final int querySingleInt(String sqlCmd, Connection conn)
+    { 
+        return querySingleInt(sqlCmd, 0, conn);
+    }
+    
+    /**
+     * Returns the value of the first row/column of a sql-query as a long.
+     * 
+     * @param sqlCmd the SQL statement
+     * @param conn a valid connection to the database.
+     * @return the result as a long value, if no result the long value 0
+     */
+    public long querySingleLong(String sqlCmd, long defVal, Connection conn)
+    { 
+        Object value = querySingleValue(sqlCmd, conn);
+        return ((value != null) ? Long.parseLong(value.toString()) : defVal);
+    }
+
+    /**
+     * Returns the value of the first row/column of a sql-query as a long.
+     * 
+     * @param sqlCmd the SQL statement
+     * @param conn a valid connection to the database.
+     * @return the result as a long value, if no result the long value 0
+     */
+    public final long querySingleLong(String sqlCmd, Connection conn)
+    { 
+        return querySingleLong(sqlCmd, 0, conn);
+    }
+    
+    /**
+     * Returns the value of the first row/column of a sql-query as a double.
+     * 
+     * @param sqlCmd the SQL statement
+     * @param conn a valid connection to the database.
+     * @return the result as a long value, if no result the long value 0
+     */
+    public double querySingleDouble(String sqlCmd, double defVal, Connection conn)
+    { 
+        Object value = querySingleValue(sqlCmd, conn);
+        return ((value != null) ? Double.parseDouble(value.toString()) : defVal);
+    }
+
+    /**
+     * Returns the value of the first row/column of a sql-query as a double.
+     * 
+     * @param sqlCmd the SQL statement
+     * @param conn a valid connection to the database.
+     * @return the result as a long value, if no result the long value 0
+     */
+    public final double querySingleDouble(String sqlCmd, Connection conn)
+    { 
+        return querySingleDouble(sqlCmd, 0.0, conn);
+    }
+    
+    /**
+     * Returns the value of the first row/column of a sql-query as a string.
+     * 
+     * @param sqlCmd the SQL statement
+     * @param defVal the default value if no value was returned by the database
+     * @param conn a valid connection to the database.
+     * @return the result as a String object, if no result a emtpy String
+     */
+    public String querySingleString(String sqlCmd, String defVal, Connection conn)
+    { 
+        Object value = querySingleValue(sqlCmd, conn);
+        return ((value != null) ? value.toString() : defVal);
+    }
+    
+    /**
+     * Returns the value of the first row/column of a sql-query as a string.
+     * 
+     * @param sqlCmd the SQL statement
+     * @param conn a valid connection to the database.
+     * @return the result as a String object, if no result a emtpy String
+     */
+    public final String querySingleString(String sqlCmd, Connection conn)
+    { 
+        return querySingleString(sqlCmd, "", conn);
+    }
+    
+    /**
+     * Returns a one dimensional array from an sql query.
+     * The array is filled with the values of the first column.
+     * 
+     * @param sqlCmd the SQL statement
+     * @param conn a valid connection to the database.
+     * @return a list of the values of the first column of an sql query 
+     */
+    public <T> List<T> querySimpleList(Class<T> c, String sqlCmd, Connection conn)
+    {   // Execute the  Statement
+        if (checkOpen()==false)
+            return null;
+        // Debug
+        ResultSet rs = null;
+        try
+        {	// Check Open
+            if (checkOpen()==false)
+                return null;
+            // Debug
+            long start = System.currentTimeMillis();
+            if (log.isInfoEnabled())
+                log.info("executing: " + sqlCmd);
+            // Get the next Value
+            rs = driver.executeQuery(sqlCmd, null, false, conn);
+            if (rs == null)
+            { // Error
+                error(driver);
+                return null;
+            }
+            // Check Result
+            List<T> result = new ArrayList<T>();
+            while (rs.next())
+            {
+                T item = ObjectUtils.convert(c, rs.getObject(1));
+                result.add(item);
+            }
+            // No Value
+            if (log.isInfoEnabled())
+                log.info("querySimpleList retured "+String.valueOf(result.size())+" items. Query completed in " + String.valueOf(System.currentTimeMillis() - start) + " ms");
+            clearError();
+            return result;
+        } catch (ClassCastException e) 
+        {   
+            log.error("querySingleValue cast exception: ", e);
+            error(Errors.Exception, e);
+            return null;
+        } catch (SQLException e) 
+        {
+            log.error("querySimpleList exception: ", e);
+            error(DBErrors.QueryFailed, e);
+            return null;
+        } finally
+        { // Cleanup
+            closeResultSet(rs);
+        }
+    }
+
+    /**
+     * Returns a one dimensional array from an sql query.
+     * The array is filled with the values of the first column.
+     * 
+     * @param sqlCmd the SQL statement
+     * @param conn a valid connection to the database.
+     * @return a list of values of type Object 
+     */
+    public List<Object> querySimpleList(String sqlCmd, Connection conn)
+    {   // Execute the  Statement
+        return querySimpleList(Object.class, sqlCmd, conn);
+    }
+    
+    /**
+     * Returns a list of key value pairs from an sql query.
+     * The opton list is filled with the values of the first and second column.
+     * 
+     * @param sqlCmd the SQL statement
+     * @param conn a valid connection to the database.
+     * @return an Options object containing a set a of values and their corresponding names 
+     */
+    public Options queryOptionList(String sqlCmd, Connection conn)
+    {   // Execute the  Statement
+        if (checkOpen()==false)
+            return null;
+        // Debug
+        ResultSet rs = null;
+        try
+        {   // Check Open
+            if (checkOpen()==false)
+                return null;
+            // Debug
+            long start = System.currentTimeMillis();
+            if (log.isInfoEnabled())
+                log.info("executing: " + sqlCmd);
+            // Get the next Value
+            rs = driver.executeQuery(sqlCmd, null, false, conn);
+            if (rs == null)
+            { // Error
+                error(driver);
+                return null;
+            }
+            if (rs.getMetaData().getColumnCount()<2)
+            {   // Not enough columns
+                error(Errors.InvalidArg, sqlCmd, "sqlCmd");
+                return null;
+            }
+            // Check Result
+            Options result = new Options();
+            while (rs.next())
+            {
+                Object value = rs.getObject(1);
+                String text  = rs.getString(2);
+                result.add(value, text, true);
+            }
+            // No Value
+            if (log.isInfoEnabled())
+                log.info("queryOptionList retured "+String.valueOf(result.size())+" items. Query completed in " + String.valueOf(System.currentTimeMillis() - start) + " ms");
+            clearError();
+            return result;
+        } catch (SQLException e) 
+        {
+            error(DBErrors.QueryFailed, e);
+            return null;
+        } finally
+        { // Cleanup
+            closeResultSet(rs);
+        }
+    }
+
+    /**
+     * Returns a list Object-Arrays holding the result of a query.
+     * This function should only be used for small lists.
+     * 
+     * @param sqlCmd the SQL statement
+     * @param conn a valid connection to the database.
+     * @return a list of object arrays 
+     */
+    public List<Object[]> queryObjectList(String sqlCmd, Connection conn)
+    {   // Execute the  Statement
+        if (checkOpen()==false)
+            return null;
+        // Debug
+        ResultSet rs = null;
+        try
+        {   // Check Open
+            if (checkOpen()==false)
+                return null;
+            // Debug
+            long start = System.currentTimeMillis();
+            if (log.isInfoEnabled())
+                log.info("executing: " + sqlCmd);
+            // Get the next Value
+            rs = driver.executeQuery(sqlCmd, null, false, conn);
+            if (rs == null)
+            { // Error
+                error(driver);
+                return null;
+            }
+            // Read List
+            int colCount = rs.getMetaData().getColumnCount(); 
+            List<Object[]> result = new ArrayList<Object[]>();
+            while (rs.next())
+            {
+                Object[] item = new Object[colCount];
+                for (int i=0; i<colCount; i++)
+                {   // Read from Resultset
+                    item[i] = rs.getObject(i+1);
+                }
+                result.add(item);
+            }
+            // No Value
+            if (log.isInfoEnabled())
+                log.info("queryObjectList retured "+String.valueOf(result.size())+" items. Query completed in " + String.valueOf(System.currentTimeMillis() - start) + " ms");
+            clearError();
+            return result;
+        } catch (SQLException e) 
+        {
+            error(DBErrors.QueryFailed, e);
+            return null;
+        } finally
+        { // Cleanup
+            closeResultSet(rs);
+        }
+    }
+    
+    /**
+     * Executes an update, insert or delete SQL-Statement.<BR>
+     * We recommend to use a DBCommand object in order to build the sqlCmd.<BR>
+     * <P>
+     * @param sqlCmd the SQL-Command
+     * @param sqlParams a list of objects to replace sql parameters
+     * @param conn a valid connection to the database.
+     * @return the row count for insert, update or delete or 0 for SQL statements that return nothing
+     */
+    public int executeSQL(String sqlCmd, Object[] sqlParams, Connection conn)
+    {
+        try 
+        {
+            // check driver
+            if (checkOpen()==false)
+                return -1;
+            // Debug
+            if (log.isInfoEnabled())
+                log.info("Executing: " + sqlCmd);
+            // execute SQL
+            long start = System.currentTimeMillis();
+            int affected = driver.executeSQL(sqlCmd, sqlParams, conn);
+            // Log
+            if (log.isInfoEnabled())
+	            log.info("executeSQL affected " + String.valueOf(affected) + " Records / " + (System.currentTimeMillis() - start) + "ms");
+            // number of affected records
+            if (affected < 0)
+            {
+                error(driver);
+                return -1;
+            }
+            // Return number of affected records
+            return affected;
+            
+	    } catch (SQLException sqle) 
+        { 	// Error
+	        error(sqle);
+	        return -1;
+	    }    
+    }
+
+    /**
+     * Executes an update, insert or delete SQL-Statement.<BR>
+     * We recommend to use a DBCommand object in order to build the sqlCmd.<BR>
+     * <P>
+     * @param sqlCmd the SQL-Command
+     * @param conn a valid connection to the database.
+     * @return the row count for insert, update or delete or 0 for SQL statements that return nothing
+     */
+    public final int executeSQL(String sqlCmd, Connection conn)
+    {
+        return executeSQL(sqlCmd, null, conn); 
+    }
+    
+    /**
+     * Executes a select SQL-Statement and returns a resulset containing the query results.<BR>
+     * This function returns a JDBC ResultSet.<BR>
+     * Insteam of using this function directly you should use a DBReader object instead.<BR>
+     * <P>
+     * @param sqlCmd the SQL-Command
+     * @param sqlParams a list of parameters for parameter queries (may depend on driver)
+     * @param scrollable true if the reader should be scrollable or false if not
+     * @param conn a valid connection to the database.
+     * @return the JDBC ResutSet
+     */
+    public ResultSet executeQuery(String sqlCmd, Object[] sqlParams, boolean scrollable, Connection conn)
+    {
+        try
+        {   // check driver
+            if (checkOpen()==false)
+                return null;
+            // Debug
+            if (log.isDebugEnabled())
+    	        log.debug("Executing: " + sqlCmd);
+            // Execute the Statement
+            long start = System.currentTimeMillis();
+            ResultSet rs = driver.executeQuery(sqlCmd, sqlParams, scrollable, conn);
+            if (rs == null)
+            {   error(driver);
+                return null;
+            }
+            // Debug
+            if (log.isDebugEnabled())
+                log.debug("executeQuery successful in " + String.valueOf(System.currentTimeMillis() - start) + " ms");
+            // Return number of affected records
+            success();
+            return rs;
+
+        } catch (SQLException e) 
+        {   // SQL Query failed!
+            log.error("execute query exception! sql = " + sqlCmd);
+            error(DBErrors.QueryFailed, e);
+            return null; 
+        }
+    }
+
+    /**
+     * Makes all changes made since the previous commit/rollback
+     * permanent and releases any database locks currently held by the
+     * Connection.
+     * <P>
+     * @param conn a valid database connection
+     * @exception java.sql.SQLException if a database access error occurs
+     * @return true if successful
+     */
+    public boolean commit(Connection conn)
+    {
+        try
+        {   // Check arguement
+            if (conn==null)
+                return error(Errors.InvalidArg, null, "conn");
+            // Commit
+            conn.commit();
+            return true;
+        } catch (SQLException sqle) 
+        { 
+            // Commit failed!
+            return error(sqle);
+        }
+    }
+
+    /**
+     * Discards all changes made since the previous commit/rollback
+     * and releases any database locks currently held by this
+     * Connection.
+     * <P>
+     * @param conn a valid database connection
+     * @exception java.sql.SQLException if a database access error occurs
+     * @return true if successful
+     */
+    public boolean rollback(Connection conn)
+    {
+        try
+        {   // Check arguement
+            if (conn==null)
+                return error(Errors.InvalidArg, null, "conn");
+            // Rollback
+            log.info("Database rollback issued!");
+            conn.rollback();
+            return true;
+        } catch (SQLException sqle) 
+        {
+            return error(sqle);
+        }
+    }
+
+    /**
+     * Convenience function for closing a JDBC Resultset<BR>
+     * Use it instead of stmt.close()<BR> 
+     * <P>
+     * @param stmt a Statement object
+     */
+    public void closeStatement(Statement stmt)
+    {
+        try
+        { // Statement close
+            if (stmt != null)
+                stmt.close();
+            // done
+            success();
+        } catch (SQLException sqle)
+        {
+            error(sqle);
+        }
+    }
+
+    /**
+     * Convenience function for closing a JDBC Resultset<BR>
+     * Use it instead of rset.close() and stmt.close()<BR> 
+     * <P>
+     * @param rset a ResultSet object
+     * @exception java.sql.SQLException if a database access error occurs
+     */
+    public void closeResultSet(ResultSet rset)
+    {
+        try
+        { 	// check ResultSet
+            if (rset == null)
+                return; // nothing to do
+            // close Resutlset
+            Statement stmt = rset.getStatement();
+            rset.close();
+            // check Statement
+            if (stmt == null)
+                return;
+            // close Statement
+            stmt.close();
+            success();
+            
+        } catch (SQLException sqle) 
+        {
+            error(sqle);
+        }
+    }
+
+}
\ No newline at end of file

Added: incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBDatabaseDriver.java
URL: http://svn.apache.org/viewvc/incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBDatabaseDriver.java?rev=683173&view=auto
==============================================================================
--- incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBDatabaseDriver.java (added)
+++ incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBDatabaseDriver.java Wed Aug  6 01:47:37 2008
@@ -0,0 +1,560 @@
+/*
+ * ESTEAM Software GmbH, 13.12.2004
+ */
+package org.apache.empire.db;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.text.DateFormat;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.empire.commons.ErrorObject;
+import org.apache.empire.commons.Errors;
+import org.apache.empire.commons.ObjectUtils;
+import org.apache.empire.commons.StringUtils;
+import org.apache.empire.data.DataType;
+
+
+/**
+ * @author ESTEAM software <A TARGET="esteam" HREF="http://www.esteam.de">www.esteam.de </A>
+ * 
+ */
+public abstract class DBDatabaseDriver extends ErrorObject
+{
+    // sql-phrases
+    public static final int SQL_NULL_VALUE       = 1;   // Oracle: null
+    public static final int SQL_RENAME_COLUMN    = 2;   // Oracle: AS
+    public static final int SQL_PARAMETER        = 3;   // Oracle: ?
+    public static final int SQL_CONCAT_EXPR      = 4;   // Oracle: ||
+    public static final int SQL_RENAME_TABLE     = 5;   // Oracle: AS
+    public static final int SQL_DATABASE_LINK    = 6;   // Oracle: @
+    // data types
+    public static final int SQL_BOOLEAN_TRUE     = 10;  // Oracle: "'Y'"      SQL: "1"
+    public static final int SQL_BOOLEAN_FALSE    = 11;  // Oracle: "'N'"      SQL: "0"
+    public static final int SQL_CURRENT_DATE     = 20;  // Oracle: "sysdate"
+    public static final int SQL_DATE_PATTERN     = 21;  // "yyyy.MM.dd"
+    public static final int SQL_DATE_TEMPLATE    = 22;  // Oracle: "TO_DATE('{0}', 'YYYY-MM-DD')"
+    public static final int SQL_CURRENT_DATETIME = 25;  // Oracle: "sysdate"
+    public static final int SQL_DATETIME_PATTERN = 26;  // "yyyy.MM.dd HH:mm:ss"
+    public static final int SQL_DATETIME_TEMPLATE= 27;  // Oracle: "TO_DATE('{0}', 'YYYY-MM-DD HH24:MI:SS')"
+    // functions
+    public static final int SQL_FUNC_COALESCE    = 100; // Oracle: nvl(?, {0})
+    public static final int SQL_FUNC_SUBSTRING   = 101; // Oracle: substr(?,{0})
+    public static final int SQL_FUNC_SUBSTRINGEX = 102; // Oracle: substr(?,{0},{1})
+    public static final int SQL_FUNC_REPLACE     = 103; // Oracle: replace(?,{0},{1})
+    public static final int SQL_FUNC_REVERSE     = 104; // Oracle: reverse(?) 
+    public static final int SQL_FUNC_STRINDEX    = 105; // Oracle: instr(?, {0})
+    public static final int SQL_FUNC_STRINDEXFROM= 106; // Oracle: instr(?, {0}, {1}) 
+    public static final int SQL_FUNC_LENGTH      = 107; // Oracle: length(?,{0})
+    public static final int SQL_FUNC_UPPER       = 110; // Oracle: upper(?)
+    public static final int SQL_FUNC_LOWER       = 111; // Oracle: lower(?)
+    public static final int SQL_FUNC_TRIM        = 112; // Oracle: trim(?)
+    public static final int SQL_FUNC_LTRIM       = 113; // Oracle: ltrim(?)
+    public static final int SQL_FUNC_RTRIM       = 114; // Oracle: rtrim(?)
+    public static final int SQL_FUNC_ESCAPE      = 119; // Oracle: ? escape '{0}'
+    // Numeric
+    public static final int SQL_FUNC_ABS         = 120; // Oracle: abs(?,{0})
+    public static final int SQL_FUNC_ROUND       = 121; // Oracle: round(?, {0})
+    public static final int SQL_FUNC_TRUNC       = 122; // Oracle: trunc(?, {0})
+    public static final int SQL_FUNC_FLOOR       = 123; // Oracle: floor(?)
+    public static final int SQL_FUNC_CEILING     = 124; // Oracle: ceil(?)
+    // Date
+    public static final int SQL_FUNC_DAY         = 132; // MS SQL month(?)
+    public static final int SQL_FUNC_MONTH       = 133; // MS SQL month(?)
+    public static final int SQL_FUNC_YEAR        = 134; // MS SQL year (?)
+    // Aggregation
+    public static final int SQL_FUNC_SUM         = 140; // Oracle: sum(?)
+    public static final int SQL_FUNC_COUNT       = 141; // Oracle: count(?)
+    public static final int SQL_FUNC_MAX         = 142; // Oracle: max(?)
+    public static final int SQL_FUNC_MIN         = 143; // Oracle: min(?)
+    public static final int SQL_FUNC_AVG         = 144; // Oracle: avg(?)
+    // Decode
+    public static final int SQL_FUNC_DECODE      = 150; // Oracle: "decode(? {0})" SQL: "case ?{0} end"
+    public static final int SQL_FUNC_DECODE_SEP  = 151; // Oracle: ","             SQL: " "
+    public static final int SQL_FUNC_DECODE_PART = 152; // Oracle: "{0}, {1}"      SQL: "when {0} then {1}"
+    public static final int SQL_FUNC_DECODE_ELSE = 153; // Oracle: "{0}"           SQL: "else {0}"
+
+    // Logger
+    protected static Log log = LogFactory.getLog(DBDatabaseDriver.class);
+    
+    // Flag wether or not to set column defaults when crating dll statements
+    protected boolean ddlColumnDefaults = false;
+    
+    // DBSeqTable
+    public static class DBSeqTable extends DBTable
+    {
+        public DBColumn C_SEQNAME;
+        public DBColumn C_SEQVALUE;
+        public DBColumn C_TIMESTAMP;
+
+        /**
+         * Constructor
+         */
+        public DBSeqTable(String tableName, DBDatabase db)
+        {
+            super(tableName, db);
+            // Add all Colums
+            C_SEQNAME   = addColumn("SeqName",  DataType.TEXT,      40, true);
+            C_SEQVALUE  = addColumn("SeqValue", DataType.INTEGER,    0, true);
+            C_TIMESTAMP = addColumn("SeqTime",  DataType.DATETIME,   0, true);
+            // Primary Key
+            setPrimaryKey(new DBColumn[] { C_SEQNAME });
+        }
+
+        // Overridables
+        public Object getNextValue(String SeqName, long minValue, Connection conn)
+        {
+            DBDatabaseDriver driver = db.getDriver();
+            // Create a Command
+            Statement stmt = null;
+            try
+            {   // The select Statement
+                DBCommand cmd = driver.createCommand(db);
+                cmd.select(C_SEQVALUE);
+                cmd.select(C_TIMESTAMP);
+                cmd.where (C_SEQNAME.is(SeqName));
+                String selectCmd = cmd.getSelect();
+                // Get the next Value
+                long seqValue = 0;
+                while (seqValue == 0)
+                {
+                    stmt = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
+                    // Query existing value
+                    ResultSet rs = stmt.executeQuery(selectCmd);
+                    if (rs.next())
+                    { // Read the Sequence Value
+                        seqValue = Math.max(rs.getLong(1) + 1, minValue);
+                        java.sql.Timestamp current = rs.getTimestamp(2);
+                        db.closeResultSet(rs);
+                        // Update existing Record
+                        cmd.clear();
+                        cmd.set(C_SEQVALUE.to(seqValue));
+                        cmd.set(C_TIMESTAMP.to(DBDatabase.SYSDATE));
+                        cmd.where(C_SEQNAME.is(SeqName));
+                        cmd.where(C_TIMESTAMP.is(current));
+                        if (db.executeSQL(cmd.getUpdate(), null, conn) < 1)
+                            seqValue = 0; // Try again
+                    } 
+                    else
+                    { // Close Reader
+                        db.closeResultSet(rs);
+                        // neu angelegen!
+                        seqValue = minValue;
+                        log.warn("warn: Sequence '" + SeqName
+                                       + "' does not exist! Creating sequence with start-value of " + seqValue);
+                        // Add a new Sequence
+                        cmd.clear();
+                        cmd.set(C_SEQNAME.to(SeqName));
+                        cmd.set(C_SEQVALUE.to(seqValue));
+                        cmd.set(C_TIMESTAMP.to(DBDatabase.SYSDATE));
+                        if (db.executeSQL(cmd.getInsert(), null, conn) < 1)
+                            seqValue = 0; // Try again
+                    }
+                    // concurreny problem?
+                    if (seqValue == 0)
+                        log.warn("Failed to increment sequence '" + SeqName + "'. Trying again!");
+                    // close
+                    db.closeStatement(stmt);
+                    cmd.clear();
+                    rs = null;
+                }
+                return new Long(seqValue);
+            } catch (Exception e) 
+            {
+                log.error("getNextValue exception: " + e.toString());
+                error(e);
+                return null;
+            } finally
+            { // Cleanup
+                db.closeStatement(stmt);
+            }
+        }
+    }
+
+    /**
+     * This function creates a DBCommand derived object this database
+     * @param db the database for which to create a command object for
+     * @return a DBCommand object
+     */
+    public abstract DBCommand createCommand(DBDatabase db);
+
+    /**
+     * Returns whether or not a particular feature is supported by this driver
+     * @param type type of requrested feature. @see DBDriverFeature
+     * @return true if the features is supported or false otherwise
+     */
+    public abstract boolean isSupported(DBDriverFeature type);
+    
+    /**
+     * Returns an sql phrase template for this database system.<br>
+     * Templates for sql function expressions must contain a '?' character which will be 
+     * replaced by the current column expression.<br>
+     * If other parameters are necessary the template must contain placeholders like {0}, {1} etc. 
+     * @param phrase the identifier of the phrase  
+     * @return the phrase template
+     */
+    public abstract String getSQLPhrase(int phrase);
+
+    /**
+     * Returns a data type convertion phrase template for this driver<br>
+     * The returned template must contain a '?' which will be replaced by a column expression.
+     * @param destType the target data type
+     * @param srcType the source data type
+     * @param format additional formatting information (optional) 
+     * @return the data conversion phrase template
+     */
+    public abstract String getConvertPhrase(DataType destType, DataType srcType, Object format);
+
+    /**
+     * Returns the next value of a named sequence The numbers are used for fields of type DBExpr.DT_AUTOINC.<BR>
+     * If a driver supports this function it must return true for isSupported(DBDriverFeature.SEQUENCES).
+     * 
+     * @param db the database
+     * @param SeqName the name of the sequence
+     * @param minValue the minmum value of the sequence
+     * @param conn a valid database connection
+     * @return a new unique sequence value or null if an error occurred
+     */
+    public abstract Object getNextSequenceValue(DBDatabase db, String SeqName, int minValue, Connection conn);
+
+    /**
+     * Returns the value of an AutoIncrement field for the last inserted record.<BR>
+     * This function is only used for databases that do not support sequences.<BR>
+     * Hence getNextSequenceValue() must return 'null'
+     * @param db the database
+     * @param conn a valid database connection
+     * @return the id of the last inserted record null if this feature is not supported
+     */
+    public Object getPostInsertAutoIncValue(DBDatabase db, Connection conn)
+    {
+        error(Errors.NotSupported);
+        return null; 
+    }
+    
+    /**
+     * Prepares an sql statement by setting the supplied objects as parameters.
+     * 
+     * @param pstmt the prepared statement
+     * @param sqlParams list of objects
+     */
+    protected void prepareStatement(PreparedStatement pstmt, Object[] sqlParams)
+    	throws SQLException
+	{
+        for (int i=0; i<sqlParams.length; i++)
+        {
+            if(sqlParams[i] instanceof DBBlobData)
+            {
+                // handling for blobs
+                DBBlobData blobData = (DBBlobData)sqlParams[i];
+                pstmt.setBinaryStream(i + 1, blobData.getInputStream(), blobData.getLength());
+            }
+            else if(sqlParams[i] instanceof DBClobData)
+            {
+                // handling for clobs
+                DBClobData clobData = (DBClobData)sqlParams[i];
+                pstmt.setCharacterStream(i + 1, clobData.getReader(), clobData.getLength());
+            }
+            else
+            {
+                pstmt.setObject(i + 1, sqlParams[i]);
+            }
+        }
+	}
+
+    /**
+     * Extracts native error message of an sqlExeption.
+     * 
+     * @param e the SQLException
+     * @return the error message of the database 
+     */
+    public String extractErrorMessage(SQLException e)
+    {
+        return e.getMessage();
+    }
+    
+    /**
+     * <P>
+     * Reads a sinlge column value from the given JDBC ResultSet and returns a value object of desired data type.<BR> 
+     * See {@link DBExpr#getValueClass(DataType)} for java class type mapping.
+     * <P>
+     * This gives the driver the oportunity to change the value
+     * i.e. to simulate missing data types with other types.
+     * <P>
+     * @param rset the sql Resultset with the current data row
+     * @param columnIndex one based column Index of the desired column
+     * @param dataType the required data type
+     * @return the value of the Column 
+     */
+    public Object getResultValue(ResultSet rset, int columnIndex, DataType dataType)
+        throws SQLException
+    {
+        // Check for character large object
+        if (dataType == DataType.DATETIME)
+        { // Get Timestamp (do not use getObject()!) 
+            return rset.getTimestamp(columnIndex);
+        } 
+        else if (dataType == DataType.CLOB)
+        { // Get character large object
+            java.sql.Clob clob = rset.getClob(columnIndex);
+            return ((clob != null) ? clob.getSubString(1, (int) clob.length()) : null);
+        } 
+        else if (dataType == DataType.BLOB)
+        { // Get bytes of a binary large object
+            java.sql.Blob blob = rset.getBlob(columnIndex);
+            return ((blob != null) ? blob.getBytes(1, (int) blob.length()) : null);
+        } 
+        // Default
+        return rset.getObject(columnIndex);
+    }
+    
+    /**
+     * Executes the select, update or delete SQL-Command with a Statement object.
+     * 
+     * @param sqlCmd the SQL-Command
+     * @param sqlParams array of sql command parameters used for prepared statements (Optional).
+     * @param conn a valid connection to the database.
+     * @return the row count for insert, update or delete or 0 for SQL statements that return nothing
+     */
+    public int executeSQL(String sqlCmd, Object[] sqlParams, Connection conn)
+        throws SQLException
+    {   // Execute the Statement
+        Statement stmt = null;
+        try
+        {
+            if (sqlParams!=null)
+            {
+                PreparedStatement pstmt = conn.prepareStatement(sqlCmd);
+	            stmt = pstmt;
+	            prepareStatement(pstmt, sqlParams);
+                return pstmt.executeUpdate(); 
+            }
+            else
+            {   // Execute a simple statement
+                stmt = conn.createStatement();
+                return stmt.executeUpdate(sqlCmd);
+            }
+        } finally
+        { // Close
+            close(stmt);
+        }
+    }
+
+    // executeQuery
+    public ResultSet executeQuery(String sqlCmd, Object[] sqlParams, boolean scrollable, Connection conn)
+        throws SQLException
+    {
+        Statement stmt = null;
+        try
+        {   // Set scroll type
+            int type = (scrollable ? ResultSet.TYPE_SCROLL_INSENSITIVE
+                                   : ResultSet.TYPE_FORWARD_ONLY);
+            // Create an execute a query statement
+	        if (sqlParams!=null)
+	        {	// Use prepared statment
+	            PreparedStatement pstmt = conn.prepareStatement(sqlCmd, type, ResultSet.CONCUR_READ_ONLY);
+	            stmt = pstmt;
+	            prepareStatement(pstmt, sqlParams);
+	            return pstmt.executeQuery();
+	        }
+	        {	// Use simple statment
+	            stmt = conn.createStatement(type, ResultSet.CONCUR_READ_ONLY);
+	            return stmt.executeQuery(sqlCmd);
+	        }
+        } catch(SQLException e) 
+        {
+            // close statement (if not null)
+            close(stmt);
+            throw e;
+        }
+    }
+
+    // close
+    protected void close(Statement stmt)
+    {
+        try
+        { // Statement close
+            if (stmt != null)
+                stmt.close();
+        } catch (SQLException sqle) 
+        {
+            log.error("close statement:" + sqle.toString());
+        }
+    }
+
+    // helper for Date and DateTime Strings
+    protected String getDateTimeString(Object value, int sqlTemplate, int sqlPattern, int sqlCurrentDate)
+    {
+        // is it a sysdate expression
+        if (DBDatabase.SYSDATE.equals(value))
+            return getSQLPhrase(sqlCurrentDate);
+        // Format the date (ymd)
+        String datetime = value.toString(); 
+        SimpleDateFormat sqlFormat = new SimpleDateFormat(getSQLPhrase(sqlPattern));
+        if ((value instanceof Date)==false)
+        {   // Convert String to Date
+            try
+            {
+                DateFormat source = DateFormat.getDateInstance(DateFormat.SHORT);
+                Date dt = source.parse(value.toString());
+               datetime = sqlFormat.format(dt);
+            } catch (ParseException e)
+            {
+                log.error("Date parsing error ", e);
+            }
+        }
+        else
+        {   // Format the date as string
+            datetime = sqlFormat.format((Date)value);
+        }
+        // Now Build String
+        String template = getSQLPhrase(sqlTemplate);
+        return StringUtils.replace(template, "{0}", datetime);
+    }
+    
+    /**
+     * Creates a sql string for a given value. 
+     * Text will be enclosed in single quotes and existing single quotes will be doubled.
+     * Empty strings are treated as null.
+     * Syntax of Date, Datetime and Boolean values are vendor specific.
+     * 
+     * @param value the value which is inserted to the new String
+     * @param type the sql data type of the supplied value
+     * @return the sql string representing this value
+     */
+    public String getValueString(Object value, DataType type)
+    { 
+        if (ObjectUtils.isEmpty(value))
+        {
+            return getSQLPhrase(SQL_NULL_VALUE);
+        }
+        // set string buffer
+        switch (type)
+        {
+            case DATE:
+                return getDateTimeString(value, SQL_DATE_TEMPLATE, SQL_DATE_PATTERN, SQL_CURRENT_DATE);
+            case DATETIME:
+                // System date is special case
+                if (!DBDatabase.SYSDATE.equals(value) && value.toString().length()<=10)
+                    return getDateTimeString(value, SQL_DATE_TEMPLATE, SQL_DATE_PATTERN, SQL_CURRENT_DATETIME);
+                // Vollständiges Date-Time Object mit Zeit 
+                return getDateTimeString(value, SQL_DATETIME_TEMPLATE, SQL_DATETIME_PATTERN, SQL_CURRENT_DATETIME);
+            case TEXT:
+            case CHAR:
+            case CLOB:
+            {   // Text value
+                StringBuilder valBuf = new StringBuilder();
+                valBuf.append("'");
+                if (DBDatabase.EMPTY_STRING.equals(value)==false)
+                    appendTextValue(valBuf, value.toString());
+                valBuf.append("'");
+                return valBuf.toString();
+            }
+            case BOOL:
+            {   // Get Boolean value   
+                boolean boolVal = false;
+                if (value instanceof Boolean)
+                {   boolVal = ((Boolean) value).booleanValue();
+                } 
+                else
+                { // Boolean from String
+                    String strVal = value.toString();
+                    boolVal = strVal.equals("1") |
+                              strVal.equalsIgnoreCase("true") |
+                              strVal.equalsIgnoreCase("y");
+                }
+                return getSQLPhrase((boolVal) ? SQL_BOOLEAN_TRUE : SQL_BOOLEAN_FALSE);
+            }
+            default:
+                return value.toString();
+        }
+    }
+
+    /**
+     * Called when a database is opened
+     */
+    protected boolean attachDatabase(DBDatabase db, Connection conn)
+    {
+        return success();
+    }
+
+    /**
+     * Called when a database is closed
+     */
+    protected void detachDatabase(DBDatabase db, Connection conn)
+    {
+        // Override to implement closing behaviour
+    }
+
+    /**
+     * Checks the database whether or not it is consistent with the description.
+     */
+    public boolean checkDatabase(DBDatabase db, String owner, Connection conn)
+    {
+    	return error(Errors.NotImplemented, "checkDatabase");
+    }
+    
+    /**
+     * gets an SQL command for creating, modifying or deleting objects in the database (tables, columns, constraints, etc.)
+     */
+    public boolean getDDLScript(DBCmdType type, DBObject dbo, DBSQLScript script)
+    {
+        return error(Errors.NotSupported, "getDDLScript");
+    }
+    
+    /**
+     * @return true if column default values are created with dll statements or false if not
+     */
+    public boolean isDDLColumnDefaults()
+    {
+        return ddlColumnDefaults;
+    }
+
+    /**
+     * Set true if column default values should be included in DDL Statements  
+     * @param enable true if dll statements should include column default values or false if not
+     */
+    public void setDDLColumnDefaults(boolean enable)
+    {
+        ddlColumnDefaults = enable;
+    }
+
+    /**
+     * Returns a timestamp that is used for record updates.
+     * 
+     * @return the current date and time.
+     */
+    public java.sql.Timestamp getUpdateTimestamp(Connection conn)
+    {
+        // Default implementation
+        java.util.Date date = new java.util.Date();
+        return new java.sql.Timestamp(date.getTime());
+    }
+
+    /** this helper function doubles up single quotes for SQL */
+    protected void appendTextValue(StringBuilder buf, String value)
+    {
+        if (value.indexOf('\'') >= 0)
+        { // a routine to double up single quotes for SQL
+            int len = value.length();
+            for (int i = 0; i < len; i++)
+            {
+                if (value.charAt(i) == '\'')
+                    buf.append("''");
+                else
+                    buf.append(value.charAt(i));
+            }
+        } 
+        else
+        {
+            buf.append(value);
+        }
+    }
+
+}
\ No newline at end of file

Added: incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBDriverFeature.java
URL: http://svn.apache.org/viewvc/incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBDriverFeature.java?rev=683173&view=auto
==============================================================================
--- incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBDriverFeature.java (added)
+++ incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBDriverFeature.java Wed Aug  6 01:47:37 2008
@@ -0,0 +1,15 @@
+/*
+ * ESTEAM Software GmbH, 04.04.2008
+ */
+package org.apache.empire.db;
+
+/**
+ * This enum is used with the DBDatabaseDriver::isSupported method to query database driver capabilities.
+ *
+ * @author ESTEAM software <A TARGET="esteam" HREF="http://www.esteam.de">www.esteam.de </A>
+ */
+public enum DBDriverFeature {
+    // Support Flags used by DBDatabaseDriver::isSupported()
+    CREATE_SCHEMA,
+    SEQUENCES,    
+}

Added: incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBErrors.java
URL: http://svn.apache.org/viewvc/incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBErrors.java?rev=683173&view=auto
==============================================================================
--- incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBErrors.java (added)
+++ incubator/empire-db/trunk/core/Empire-db/src/org/apache/empire/db/DBErrors.java Wed Aug  6 01:47:37 2008
@@ -0,0 +1,57 @@
+/*
+ * ESTEAM Software GmbH, 14.07.2007
+ */
+package org.apache.empire.db;
+
+import org.apache.empire.commons.ErrorType;
+
+/**
+ * This class contains the definition of database specific errors.
+ * <P>
+ * For more informations see {@link org.apache.empire.commons.Errors}
+ * @author ESTEAM software <A TARGET="esteam" HREF="http://www.esteam.de">www.esteam.de </A>
+ */
+public class DBErrors
+{
+    // Database
+    public static final ErrorType DatabaseNotOpen        = new ErrorType("error.db.databasenotopen",
+                                                                         "the database has not been opened.");
+    public static final ErrorType ConnecitonInvalid      = new ErrorType("error.db.connectioninvalid",
+                                                                         "the database connection is not valid");
+    public static final ErrorType SQLException           = new ErrorType("error.db.sqlexception",
+                                                                         "The database operation failed. Native error is {0}.");
+    public static final ErrorType ObjectNotFound         = new ErrorType("error.db.objectnotfound",
+                                                                         "an object of type {0} named {1} does not exists or is inaccessible.");
+    public static final ErrorType ObjectCreationFailed   = new ErrorType("error.db.objectcreationfailed",
+                                                                         "error creating the {0} of name {1}.");
+    public static final ErrorType NoPrimaryKey           = new ErrorType("error.db.noprimarykey",
+                                                                         "No primary key is defined for {0}");
+    // Query errors
+    public static final ErrorType QueryFailed            = new ErrorType("error.db.queryfailed",
+                                                                         "The query failed. Native error is {0}.");
+    public static final ErrorType QueryNoResult          = new ErrorType("error.db.querynoresult",
+                                                                         "No records found for query {0}");
+    // Record errors
+    public static final ErrorType RecordInvalidKey       = new ErrorType("error.db.recordinvalidkey", "Invalid record key {0}");
+    public static final ErrorType RecordNotFound         = new ErrorType("error.db.recordnotfound",
+                                                                         "The record {0} does not exist. It might have been deleted by another user.");
+    public static final ErrorType RecordUpdateFailed     = new ErrorType("error.db.recordupatefailed",
+                                                                         "Updating the record {0} failed. It might have been changed or deleted by another user.");
+    public static final ErrorType RecordUpdateInvalid    = new ErrorType("error.db.recordupateinvalid",
+                                                                         "Updating the record {0} failed. The given record key is ambiguous.");
+    public static final ErrorType RecordDeleteFailed     = new ErrorType("error.db.recorddeletefailed",
+                                                                         "Deleting the record {0} failed. The record might have been deleted already by another user.");
+    // Field errors
+    public static final ErrorType FieldIsReadOnly        = new ErrorType("error.db.fieldisreadonly",
+                                                                         "The field {0} is read only.");
+    public static final ErrorType FieldValueTooLong      = new ErrorType("error.db.fieldvaluetoolong",
+                                                                         "The value supplied for field {0} is too long. The maximum number of characters is {1}.");
+    public static final ErrorType FieldNotNull           = new ErrorType("error.db.fieldnotnull",
+                                                                         "The value for field {0} must not be null.");
+    public static final ErrorType FieldNotNumeric        = new ErrorType("error.db.fieldnotnumeric",
+                                                                         "The field value supplied for field {0} is not numeric.");
+    public static final ErrorType FieldInvalidDateFormat = new ErrorType("error.db.fieldinvaliddateformat",
+                                                                         "The date supplied for field {0} is not valid.");
+    public static final ErrorType FieldInvalidValue      = new ErrorType("error.db.fieldinvalidvalue",
+                                                                         "The value for field {0} is invalid.");
+}



Mime
View raw message