This is an automated email from the ASF dual-hosted git repository.
doebele pushed a commit to branch version3
in repository https://gitbox.apache.org/repos/asf/empire-db.git
The following commit(s) were added to refs/heads/version3 by this push:
new 86bd841 EMPIREDB-362 Improved DBModelChecker
86bd841 is described below
commit 86bd841cd0a26f140c061979a711d66f5125c4d7
Author: Rainer Döbele <[email protected]>
AuthorDate: Mon Jan 24 22:33:37 2022 +0100
EMPIREDB-362 Improved DBModelChecker
---
.../empire-db-example-advanced/config.xml | 2 +-
.../empire/samples/db/advanced/SampleAdvApp.java | 8 +-
.../src/main/java/org/apache/empire/db/DBView.java | 2 +-
.../empire/db/validation/DBModelChecker.java | 289 +++++++++++++++------
.../empire/db/validation/DBModelErrorHandler.java | 10 +-
.../empire/db/validation/DBModelErrorLogger.java | 12 +
.../java/org/apache/empire/dbms/DBMSHandler.java | 2 +-
.../org/apache/empire/dbms/DBMSHandlerBase.java | 5 +-
.../apache/empire/dbms/hsql/DBMSHandlerHSql.java | 12 +
.../empire/dbms/oracle/DBMSHandlerOracle.java | 23 +-
.../empire/dbms/oracle/OracleDBModelChecker.java | 24 +-
.../empire/dbms/sqlserver/DBMSHandlerMSSQL.java | 17 +-
.../empire/dbms/sqlserver/MSSqlDBModelChecker.java | 23 +-
13 files changed, 302 insertions(+), 127 deletions(-)
diff --git a/empire-db-examples/empire-db-example-advanced/config.xml
b/empire-db-examples/empire-db-example-advanced/config.xml
index 75a4dd9..13b8688 100644
--- a/empire-db-examples/empire-db-example-advanced/config.xml
+++ b/empire-db-examples/empire-db-example-advanced/config.xml
@@ -104,7 +104,7 @@
<!-- Empire-db driver configuration -->
<dbmsHandlerClass>org.apache.empire.dbms.oracle.DBMSHandlerOracle</dbmsHandlerClass>
<dbmsHandlerProperites>
- <!-- no properties -->
+ <schemaName>DBSAMPLEADV</schemaName>
</dbmsHandlerProperites>
</properties-oracle>
diff --git
a/empire-db-examples/empire-db-example-advanced/src/main/java/org/apache/empire/samples/db/advanced/SampleAdvApp.java
b/empire-db-examples/empire-db-example-advanced/src/main/java/org/apache/empire/samples/db/advanced/SampleAdvApp.java
index 5efd6c3..3d7c85f 100644
---
a/empire-db-examples/empire-db-example-advanced/src/main/java/org/apache/empire/samples/db/advanced/SampleAdvApp.java
+++
b/empire-db-examples/empire-db-example-advanced/src/main/java/org/apache/empire/samples/db/advanced/SampleAdvApp.java
@@ -20,7 +20,6 @@ package org.apache.empire.samples.db.advanced;
import java.sql.Connection;
import java.sql.DriverManager;
-import java.text.MessageFormat;
import java.util.Date;
import java.util.HashMap;
@@ -334,15 +333,14 @@ public class SampleAdvApp
private static void checkDataModel()
{
- DBModelChecker modelChecker = context.getDbms().createModelChecker();
+ DBModelChecker modelChecker = context.getDbms().createModelChecker(db);
// Check data model
log.info("Checking DataModel for {} using {}",
db.getClass().getSimpleName(), modelChecker.getClass().getSimpleName());
// dbo schema
DBModelErrorLogger logger = new DBModelErrorLogger();
- modelChecker.checkModel(db, context.getConnection(), "DBSAMPLEADV",
logger);
+ modelChecker.checkModel(context.getConnection(), logger);
// show result
- String msg = MessageFormat.format("Data model check done. Found {0}
errors and {1} warnings.", logger.getErrorCount(), logger.getWarnCount());
- System.out.println(msg);
+ log.info("Data model check done. Found {} errors and {} warnings.",
logger.getErrorCount(), logger.getWarnCount());
}
/**
diff --git a/empire-db/src/main/java/org/apache/empire/db/DBView.java
b/empire-db/src/main/java/org/apache/empire/db/DBView.java
index dd73d5b..fa9ec5b 100644
--- a/empire-db/src/main/java/org/apache/empire/db/DBView.java
+++ b/empire-db/src/main/java/org/apache/empire/db/DBView.java
@@ -297,7 +297,7 @@ public abstract class DBView extends DBRowSet
*
* @param col a view column object
*/
- void addColumn(DBViewColumn col)
+ protected void addColumn(DBViewColumn col)
{ // find column by name
if (col == null || col.getRowSet() != this)
throw new InvalidArgumentException("col", col);
diff --git
a/empire-db/src/main/java/org/apache/empire/db/validation/DBModelChecker.java
b/empire-db/src/main/java/org/apache/empire/db/validation/DBModelChecker.java
index c696396..2b27dae 100644
---
a/empire-db/src/main/java/org/apache/empire/db/validation/DBModelChecker.java
+++
b/empire-db/src/main/java/org/apache/empire/db/validation/DBModelChecker.java
@@ -30,28 +30,99 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import org.apache.empire.commons.StringUtils;
import org.apache.empire.data.DataType;
import org.apache.empire.db.DBColumn;
+import org.apache.empire.db.DBCommandExpr;
import org.apache.empire.db.DBDatabase;
import org.apache.empire.db.DBRelation;
import org.apache.empire.db.DBRelation.DBReference;
+import org.apache.empire.db.DBRowSet;
import org.apache.empire.db.DBTable;
import org.apache.empire.db.DBTableColumn;
import org.apache.empire.db.DBView;
+import org.apache.empire.exceptions.InternalException;
+import org.apache.empire.exceptions.InvalidArgumentException;
+import org.apache.empire.exceptions.NotSupportedException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class DBModelChecker
{
- private static final Logger log =
LoggerFactory.getLogger(DBModelChecker.class);
+ private static final Logger log =
LoggerFactory.getLogger(DBModelChecker.class);
+ /**
+ * The remote Database
+ * This will be populated by the ModelChecker
+ */
private static class RemoteDatabase extends DBDatabase
{
- // *Deprecated* private static final long serialVersionUID = 1L;
+ /*
+ * Will be dynamically populated
+ */
+ }
+
+ private static class RemoteView extends DBView
+ {
+ public RemoteView(String name, DBDatabase db)
+ {
+ super(name, db);
+ }
+
+ public DBColumn addColumn(String columnName, DataType dataType, double
size, boolean dummy)
+ {
+ return super.addColumn(columnName, dataType, size);
+ }
+
+ @Override
+ public DBCommandExpr createCommand()
+ {
+ throw new NotSupportedException(this, "createCommand");
+ }
}
- private final Map<String, DBTable> tableMap = new HashMap<String,
DBTable>();
- private final DBDatabase remoteDb = new RemoteDatabase();
+ protected final DBDatabase db; // the database to check
+ protected final String catalog;
+ protected final String schemaPattern;
+
+ protected final String remoteName;
+ protected DBDatabase remoteDb = null; /* will be recreated on every call
to checkModel */
+
+ protected final Map<String, DBRowSet> tableMap = new HashMap<String,
DBRowSet>();
+
+ /**
+ * Creates a new Model Checker
+ * @param catalog
+ * @param schemaPattern
+ */
+ public DBModelChecker(DBDatabase db, String catalog, String schemaPattern)
+ {
+ this.db = db;
+ this.catalog = catalog;
+ this.schemaPattern = schemaPattern;
+ // set origin
+ StringBuilder b = new StringBuilder();
+ if (StringUtils.isNotEmpty(catalog))
+ b.append(catalog);
+ if (StringUtils.isNotEmpty(schemaPattern))
+ { if (b.length()>0)
+ b.append(".");
+ b.append(schemaPattern);
+ }
+ if (b.length()==0)
+ b.append("[Unknown]");
+ this.remoteName = b.toString();
+ }
+
+ /**
+ * Returns the RemoteDatabase
+ * Only available after checkModel() is called
+ * @return the remote Database
+ */
+ public DBDatabase getRemoteDatabase()
+ {
+ return remoteDb;
+ }
/**
* This method is used to check the database model
@@ -66,59 +137,59 @@ public class DBModelChecker
* The {@link DBModelErrorHandler} implementation that is
called whenever an error
* occurs
*/
- public synchronized void checkModel(DBDatabase db, Connection conn, String
dbSchema, DBModelErrorHandler handler)
+ public synchronized void checkModel(Connection conn, DBModelErrorHandler
handler)
{
try
- {
+ { // the chandler
+ if (handler==null && db!=null)
+ throw new InvalidArgumentException("handler", handler);
+
+ // create remote db instance
+ remoteDb = new RemoteDatabase();
+
DatabaseMetaData dbMeta = conn.getMetaData();
-
- // collect tables & views
- int count = collectTables(dbMeta, dbSchema);
- log.info("{} tables and views added for schema {}", count,
dbSchema);
-
- // Collect all columns
- count = collectColumns(dbMeta, dbSchema);
- log.info("{} columns added for schema {}", count, dbSchema);
-
- // Collect PKs
- count = collectPrimaryKeys(dbMeta, dbSchema);
- log.info("{} primary keys added for schema {}", count, dbSchema);
-
- // Collect FKs
- count = collectForeignKeys(dbMeta, dbSchema);
- log.info("{} foreign keys added for schema {}", count, dbSchema);
-
- // check Tables
- for (DBTable table : db.getTables())
- {
- checkTable(table, handler);
- }
-
- // check Views
- for (DBView view : db.getViews())
- {
- checkView(view, conn, handler);
- }
+ populateRemoteDatabase(dbMeta);
+
+ // if db is null then populate only
+ if (db==null)
+ return;
+
+ // now check the database
+ checkDatabase(handler);
}
catch (SQLException e)
{
- e.printStackTrace();
+ log.error("checkModel failed for {}", remoteName);
+ throw new InternalException(e);
}
}
- /*
- * overridables
- */
- protected String getMetaCatalog(String dbSchema)
- {
- return null;
- }
-
- protected String getMetaSchemaPattern(String dbSchema)
+ protected void populateRemoteDatabase(DatabaseMetaData dbMeta)
+ throws SQLException
{
- return dbSchema;
+ // collect tables & views
+ int count = collectTablesAndViews(dbMeta, null);
+ log.info("{} tables and views added for schema \"{}\"", count,
remoteName);
+
+ // Collect all columns
+ count = collectColumns(dbMeta);
+ log.info("{} columns added for schema \"{}\"", count, remoteName);
+
+ // Collect PKs
+ count = collectPrimaryKeys(dbMeta);
+ log.info("{} primary keys added for schema \"{}\"", count, remoteName);
+
+ // Collect FKs
+ count = collectForeignKeys(dbMeta);
+ log.info("{} foreign keys added for schema \"{}\"", count, remoteName);
}
-
+
+ /**
+ * Checks if the tableName belongs to a system or hidden table
+ * @param tableName the table name
+ * @param tableMeta the table meta
+ * @return true if the table is hidden or false otherwise
+ */
protected boolean isSystemTable(String tableName, ResultSet tableMeta)
{ // system tables containing a '$' symbol (required for Oracle!)
return (tableName.indexOf('$') >= 0);
@@ -130,22 +201,27 @@ public class DBModelChecker
* @param dbSchema
* @throws SQLException
*/
- protected int collectTables(DatabaseMetaData dbMeta, String dbSchema)
+ protected int collectTablesAndViews(DatabaseMetaData dbMeta, String
tablePattern)
throws SQLException
{
- ResultSet dbTables = dbMeta.getTables(getMetaCatalog(dbSchema),
getMetaSchemaPattern(dbSchema), null, new String[] { "TABLE", "VIEW" });
+ tableMap.clear();
+ ResultSet dbTables = dbMeta.getTables(catalog, schemaPattern,
tablePattern, new String[] { "TABLE", "VIEW" });
try {
// ResultSet dbTables = dbMeta.getTables("PATOOL", "DBO", null,
new String[] { "TABLE", "VIEW" });
int count = 0;
while (dbTables.next())
{
String tableName = dbTables.getString("TABLE_NAME");
+ String tableType = dbTables.getString("TABLE_TYPE");
if (isSystemTable(tableName, dbTables))
{ // ignore system table
DBModelChecker.log.info("Ignoring system table " +
tableName);
continue;
}
- addTable(tableName);
+ if ("VIEW".equalsIgnoreCase(tableType))
+ addView(tableName);
+ else
+ addTable(tableName);
count++;
}
return count;
@@ -157,13 +233,13 @@ public class DBModelChecker
/**
* collects column information from database meta data for each table
*/
- protected int collectColumns(DatabaseMetaData dbMeta, String dbSchema)
+ protected int collectColumns(DatabaseMetaData dbMeta)
throws SQLException
{
int count = 0;
- for (DBTable t : getTables())
+ for (DBRowSet t : getTables())
{
- ResultSet dbColumns = dbMeta.getColumns(getMetaCatalog(dbSchema),
getMetaSchemaPattern(dbSchema), t.getName(), null);
+ ResultSet dbColumns = dbMeta.getColumns(catalog, schemaPattern,
t.getName(), null);
try {
while (dbColumns.next())
{ // add the column
@@ -180,16 +256,16 @@ public class DBModelChecker
/**
* collects column information from database meta data for whole schema
*/
- protected int collectColumns(DatabaseMetaData dbMeta, String dbSchema,
String tablePattern)
+ protected int collectColumns(DatabaseMetaData dbMeta, String tablePattern)
throws SQLException
{
- ResultSet dbColumns = dbMeta.getColumns(getMetaCatalog(dbSchema),
getMetaSchemaPattern(dbSchema), tablePattern, null);
+ ResultSet dbColumns = dbMeta.getColumns(catalog, schemaPattern,
tablePattern, null);
try {
int count = 0;
while (dbColumns.next())
{
String tableName = dbColumns.getString("TABLE_NAME");
- DBTable t = getTable(tableName);
+ DBRowSet t = getTable(tableName);
if (t == null)
{ log.error("Table not found: {}", tableName);
continue;
@@ -209,14 +285,18 @@ public class DBModelChecker
* @param dbSchema
* @throws SQLException
*/
- protected int collectPrimaryKeys(DatabaseMetaData dbMeta, String dbSchema)
+ protected int collectPrimaryKeys(DatabaseMetaData dbMeta)
throws SQLException
{
int count = 0;
- for (DBTable t : getTables())
+ for (DBRowSet rs : getTables())
{
+ if (!(rs instanceof DBTable))
+ continue; // not a table
+ // read pk
+ DBTable t = (DBTable)rs;
List<String> pkCols = new ArrayList<String>();
- ResultSet primaryKeys =
dbMeta.getPrimaryKeys(getMetaCatalog(dbSchema), getMetaSchemaPattern(dbSchema),
t.getName());
+ ResultSet primaryKeys = dbMeta.getPrimaryKeys(catalog,
schemaPattern, t.getName());
try {
while (primaryKeys.next())
{
@@ -243,13 +323,14 @@ public class DBModelChecker
* collects foreign key information from database meta data
* @throws SQLException
*/
- protected int collectForeignKeys(DatabaseMetaData dbMeta, String dbSchema)
+ protected int collectForeignKeys(DatabaseMetaData dbMeta)
throws SQLException
{
int count = 0;
- for (DBTable t : getTables())
+ for (DBRowSet t : getTables())
{
- count += collectForeignKeys(dbMeta, dbSchema, t.getName());
+ if (t instanceof DBTable)
+ count += collectForeignKeys(dbMeta, t.getName());
}
return count;
}
@@ -258,10 +339,10 @@ public class DBModelChecker
* collects foreign key information from database meta data
* @throws SQLException
*/
- protected int collectForeignKeys(DatabaseMetaData dbMeta, String dbSchema,
String tablePattern)
+ protected int collectForeignKeys(DatabaseMetaData dbMeta, String
tablePattern)
throws SQLException
{
- ResultSet foreignKeys =
dbMeta.getImportedKeys(getMetaCatalog(dbSchema),
getMetaSchemaPattern(dbSchema), tablePattern);
+ ResultSet foreignKeys = dbMeta.getImportedKeys(catalog, schemaPattern,
tablePattern);
try {
int count = 0;
while (foreignKeys.next())
@@ -305,22 +386,38 @@ public class DBModelChecker
}
}
- protected void checkTable(DBTable table, DBModelErrorHandler handler)
+ protected void checkDatabase(DBModelErrorHandler handler)
{
- DBTable remoteTable = getTable(table.getName());
+ // check Tables
+ for (DBTable table : db.getTables())
+ {
+ checkTable(table, handler);
+ }
- if (remoteTable == null)
+ // check Views
+ for (DBView view : db.getViews())
{
+ checkView(view, handler);
+ }
+ }
+
+ protected void checkTable(DBTable table, DBModelErrorHandler handler)
+ {
+ DBRowSet remoteTable = getTable(table.getName());
+ if (remoteTable == null)
+ { // Not found
handler.itemNotFound(table);
return;
}
-
+ if (!(remoteTable instanceof DBTable))
+ { // Not a DBTable
+ handler.objectTypeMismatch(remoteTable, table.getName(),
DBTable.class);
+ return;
+ }
// Check primary Key
- checkPrimaryKey(table, remoteTable, handler);
-
+ checkPrimaryKey(table, (DBTable)remoteTable, handler);
// check foreign keys
- checkForeignKeys(table, remoteTable, handler);
-
+ checkForeignKeys(table, (DBTable)remoteTable, handler);
// Check Columns
for (DBColumn column : table.getColumns())
{
@@ -418,16 +515,18 @@ public class DBModelChecker
}
- protected void checkView(DBView view, Connection conn, DBModelErrorHandler
handler)
+ protected void checkView(DBView view, DBModelErrorHandler handler)
{
- DBTable remoteView = getTable(view.getName());
-
+ DBRowSet remoteView = getTable(view.getName());
if (remoteView == null)
{
handler.itemNotFound(view);
return;
}
-
+ if (!(remoteView instanceof DBView))
+ {
+ handler.objectTypeMismatch(remoteView, view.getName(),
DBView.class);
+ }
for (DBColumn column : view.getColumns())
{
DBColumn remoteColumn = remoteView.getColumn(column.getName());
@@ -616,12 +715,12 @@ public class DBModelChecker
/*
* internal methods
*/
- protected final Collection<DBTable> getTables()
+ protected final Collection<DBRowSet> getTables()
{
return this.tableMap.values();
}
- protected final DBTable getTable(String tableName)
+ protected final DBRowSet getTable(String tableName)
{
return this.tableMap.get(tableName.toUpperCase());
}
@@ -631,12 +730,17 @@ public class DBModelChecker
this.tableMap.put(tableName.toUpperCase(), new DBTable(tableName,
this.remoteDb));
}
+ protected void addView(String viewName)
+ {
+ this.tableMap.put(viewName.toUpperCase(), new RemoteView(viewName,
this.remoteDb));
+ }
+
protected void addRelation(String relName, DBReference... references)
{
this.remoteDb.addRelation(relName, references);
}
- protected DBTableColumn addColumn(DBTable t, ResultSet rs)
+ protected DBColumn addColumn(DBRowSet t, ResultSet rs)
throws SQLException
{
String name = rs.getString("COLUMN_NAME");
@@ -709,16 +813,29 @@ public class DBModelChecker
// some AUTOINC meta data to the column to be used by
// the ParserUtil and ultimately the template.
// DBModelChecker.log.info("\tCOLUMN:\t" + name + " (" +
empireType + ")");
- DBTableColumn col = t.addColumn(name, empireType, colSize, required,
defaultValue);
-
- // We still need to know the base data type for this AUTOINC
- // because the Record g/setters need to know this, right?
- // So, let's add it as meta data every time the column is AUTOINC
- // and reference it in the template.
- if (empireType.equals(DataType.AUTOINC))
+ DBColumn col;
+ if (t instanceof DBTable)
{
- col.setAttribute("AutoIncDataType", originalType);
+ col = ((DBTable)t).addColumn(name, empireType, colSize, required,
defaultValue);
+ // We still need to know the base data type for this AUTOINC
+ // because the Record g/setters need to know this, right?
+ // So, let's add it as meta data every time the column is AUTOINC
+ // and reference it in the template.
+ if (empireType.equals(DataType.AUTOINC))
+ {
+ col.setAttribute("AutoIncDataType", originalType);
+ }
+ }
+ else if (t instanceof RemoteView)
+ {
+ col = ((RemoteView)t).addColumn(name, empireType, colSize, false);
+ }
+ else
+ { // Unknown type
+ log.error("Unknown Object Type {}", t.getClass().getName());
+ col = null;
}
+ // done
return col;
}
diff --git
a/empire-db/src/main/java/org/apache/empire/db/validation/DBModelErrorHandler.java
b/empire-db/src/main/java/org/apache/empire/db/validation/DBModelErrorHandler.java
index 722526f..e7942a0 100644
---
a/empire-db/src/main/java/org/apache/empire/db/validation/DBModelErrorHandler.java
+++
b/empire-db/src/main/java/org/apache/empire/db/validation/DBModelErrorHandler.java
@@ -25,7 +25,6 @@ import org.apache.empire.db.DBObject;
public interface DBModelErrorHandler
{
-
/**
* This method is called when an object (e. g. table or column) is missing
in
* the database.
@@ -36,6 +35,15 @@ public interface DBModelErrorHandler
void itemNotFound(DBObject dbo);
/**
+ * This method is called when an object (e. g. table or column) is missing
in
+ * the database.
+ *
+ * @param dbo
+ * The missing object
+ */
+ void objectTypeMismatch(DBObject object, String name, Class<?>
expectedType);
+
+ /**
* This method is called when a column in a primary key of the Empire-db
definition
* is missing in the database
*
diff --git
a/empire-db/src/main/java/org/apache/empire/db/validation/DBModelErrorLogger.java
b/empire-db/src/main/java/org/apache/empire/db/validation/DBModelErrorLogger.java
index 8331ce9..e6a889b 100644
---
a/empire-db/src/main/java/org/apache/empire/db/validation/DBModelErrorLogger.java
+++
b/empire-db/src/main/java/org/apache/empire/db/validation/DBModelErrorLogger.java
@@ -90,6 +90,18 @@ public class DBModelErrorLogger implements
DBModelErrorHandler
}
/**
+ * handle objectTypeMismatch errors
+ */
+ @Override
+ public void objectTypeMismatch(DBObject object, String name, Class<?>
expectedType)
+ {
+ // log
+ DBModelErrorLogger.log.error("The oboject \"{}\" type of {} does not
match the expected type of {}.", name, object.getClass().getSimpleName(),
expectedType.getSimpleName());
+ // increase count
+ errorCount++;
+ }
+
+ /**
* handle columnTypeMismatch errors
*/
@Override
diff --git a/empire-db/src/main/java/org/apache/empire/dbms/DBMSHandler.java
b/empire-db/src/main/java/org/apache/empire/dbms/DBMSHandler.java
index 3afa9a7..14f015c 100644
--- a/empire-db/src/main/java/org/apache/empire/dbms/DBMSHandler.java
+++ b/empire-db/src/main/java/org/apache/empire/dbms/DBMSHandler.java
@@ -241,7 +241,7 @@ public interface DBMSHandler
* Creates a DataModelChecker instance of this DBMSHandler
* @return
*/
- DBModelChecker createModelChecker();
+ DBModelChecker createModelChecker(DBDatabase db);
/**
* Extracts native error message of an sqlExeption.
diff --git
a/empire-db/src/main/java/org/apache/empire/dbms/DBMSHandlerBase.java
b/empire-db/src/main/java/org/apache/empire/dbms/DBMSHandlerBase.java
index 9e3cfbc..70f1ff5 100644
--- a/empire-db/src/main/java/org/apache/empire/dbms/DBMSHandlerBase.java
+++ b/empire-db/src/main/java/org/apache/empire/dbms/DBMSHandlerBase.java
@@ -705,10 +705,11 @@ public abstract class DBMSHandlerBase implements
DBMSHandler
* @return
*/
@Override
- public DBModelChecker createModelChecker()
+ public DBModelChecker createModelChecker(DBDatabase db)
{
+ log.warn("A general and possibly untested DBModelChecker is used for
DBMSHandler {}. Please override to inklude DBMS specific features.",
getClass().getSimpleName());
// the default model checker
- return new DBModelChecker();
+ return new DBModelChecker(db, null, null);
}
/**
diff --git
a/empire-db/src/main/java/org/apache/empire/dbms/hsql/DBMSHandlerHSql.java
b/empire-db/src/main/java/org/apache/empire/dbms/hsql/DBMSHandlerHSql.java
index 6a40833..c2b1b87 100644
--- a/empire-db/src/main/java/org/apache/empire/dbms/hsql/DBMSHandlerHSql.java
+++ b/empire-db/src/main/java/org/apache/empire/dbms/hsql/DBMSHandlerHSql.java
@@ -32,6 +32,7 @@ import org.apache.empire.db.DBObject;
import org.apache.empire.db.DBSQLScript;
import org.apache.empire.db.DBTableColumn;
import org.apache.empire.db.exceptions.QueryNoResultException;
+import org.apache.empire.db.validation.DBModelChecker;
import org.apache.empire.dbms.DBMSHandler;
import org.apache.empire.dbms.DBMSHandlerBase;
import org.apache.empire.dbms.DBMSFeature;
@@ -292,6 +293,17 @@ public class DBMSHandlerHSql extends DBMSHandlerBase
// forward request
ddlGenerator.getDDLScript(type, dbo, script);
}
+
+ /**
+ * Creates a DataModelChecker instance of this DBMSHandler
+ * @return
+ */
+ @Override
+ public DBModelChecker createModelChecker(DBDatabase db)
+ {
+ // the default model checker
+ return new DBModelChecker(db, "PUBLIC", "PUBLIC");
+ }
}
diff --git
a/empire-db/src/main/java/org/apache/empire/dbms/oracle/DBMSHandlerOracle.java
b/empire-db/src/main/java/org/apache/empire/dbms/oracle/DBMSHandlerOracle.java
index 06d9b6b..44a3ccc 100644
---
a/empire-db/src/main/java/org/apache/empire/dbms/oracle/DBMSHandlerOracle.java
+++
b/empire-db/src/main/java/org/apache/empire/dbms/oracle/DBMSHandlerOracle.java
@@ -46,11 +46,12 @@ import org.apache.empire.db.exceptions.EmpireSQLException;
import org.apache.empire.db.exceptions.QueryNoResultException;
import org.apache.empire.db.expr.column.DBValueExpr;
import org.apache.empire.db.validation.DBModelChecker;
+import org.apache.empire.dbms.DBMSFeature;
import org.apache.empire.dbms.DBMSHandler;
import org.apache.empire.dbms.DBMSHandlerBase;
-import org.apache.empire.dbms.DBMSFeature;
import org.apache.empire.dbms.DBSqlPhrase;
import org.apache.empire.exceptions.InvalidArgumentException;
+import org.apache.empire.exceptions.InvalidPropertyException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -76,6 +77,8 @@ public class DBMSHandlerOracle extends DBMSHandlerBase
private BooleanType booleanType = BooleanType.NUMBER;
private DBDDLGenerator<?> ddlGenerator = null; // lazy creation
+
+ private String schemaName;
/**
* Constructor for the Oracle database dbms.<br>
@@ -111,6 +114,16 @@ public class DBMSHandlerOracle extends DBMSHandlerBase
log.info("DBDatabaseDriverOracle Boolean Type set to " + booleanType);
}
+ public String getSchemaName()
+ {
+ return schemaName;
+ }
+
+ public void setSchemaName(String schemaName)
+ {
+ this.schemaName = schemaName;
+ }
+
/**
* Returns whether or not a particular feature is supported by this dbms
* @param type type of requested feature. @see DBMSFeature
@@ -518,10 +531,14 @@ public class DBMSHandlerOracle extends DBMSHandlerBase
* @return
*/
@Override
- public DBModelChecker createModelChecker()
+ public DBModelChecker createModelChecker(DBDatabase db)
{
+ // detect schemaPattern
+ String schemaPattern = (db!=null ?
StringUtils.coalesce(db.getSchema(), this.schemaName) : this.schemaName);
+ if (StringUtils.isEmpty(schemaPattern))
+ throw new InvalidPropertyException("schemaName", null);
// the default model checker
- return new OracleDBModelChecker();
+ return new OracleDBModelChecker(db, schemaPattern);
}
}
diff --git
a/empire-db/src/main/java/org/apache/empire/dbms/oracle/OracleDBModelChecker.java
b/empire-db/src/main/java/org/apache/empire/dbms/oracle/OracleDBModelChecker.java
index 2e1f2b0..902fd81 100644
---
a/empire-db/src/main/java/org/apache/empire/dbms/oracle/OracleDBModelChecker.java
+++
b/empire-db/src/main/java/org/apache/empire/dbms/oracle/OracleDBModelChecker.java
@@ -18,7 +18,6 @@
*/
package org.apache.empire.dbms.oracle;
-import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
@@ -29,6 +28,7 @@ import org.apache.empire.db.validation.DBModelChecker;
import org.apache.empire.db.validation.DBModelErrorHandler;
import org.apache.empire.dbms.DBMSHandler;
import org.apache.empire.dbms.oracle.DBMSHandlerOracle.BooleanType;
+import org.apache.empire.exceptions.InvalidArgumentException;
import org.apache.empire.exceptions.InvalidPropertyException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -41,11 +41,11 @@ public class OracleDBModelChecker extends DBModelChecker
private static final Logger log =
LoggerFactory.getLogger(OracleDBModelChecker.class);
private BooleanType booleanType = BooleanType.NUMBER;
-
- @Override
- public void checkModel(DBDatabase db, Connection conn, String dbSchema,
DBModelErrorHandler handler)
+
+ public OracleDBModelChecker(DBDatabase db, String schemaName)
{
- // Get boolean type from dbms
+ super(db, null, schemaName);
+ // Detect boolean type
DBMSHandler dbms = db.getDbms();
if (dbms instanceof DBMSHandlerOracle)
{
@@ -53,31 +53,29 @@ public class OracleDBModelChecker extends DBModelChecker
}
else
{ // Illegal DBMSHandler
- log.warn("The database is not attached to a DBMSHandlerOracle");
+ log.error("The database is not attached to a DBMSHandlerOracle");
+ throw new InvalidArgumentException("db", db);
}
- // check now
- super.checkModel(db, conn, dbSchema, handler);
-
}
/**
* collects all column information at once
*/
@Override
- protected int collectColumns(DatabaseMetaData dbMeta, String dbSchema)
+ protected int collectColumns(DatabaseMetaData dbMeta)
throws SQLException
{
- return super.collectColumns(dbMeta, dbSchema, null);
+ return super.collectColumns(dbMeta, null);
}
/**
* collects all foreign keys at once
*/
@Override
- protected int collectForeignKeys(DatabaseMetaData dbMeta, String dbSchema)
+ protected int collectForeignKeys(DatabaseMetaData dbMeta)
throws SQLException
{
- return super.collectForeignKeys(dbMeta, dbSchema, null);
+ return super.collectForeignKeys(dbMeta, null);
}
@Override
diff --git
a/empire-db/src/main/java/org/apache/empire/dbms/sqlserver/DBMSHandlerMSSQL.java
b/empire-db/src/main/java/org/apache/empire/dbms/sqlserver/DBMSHandlerMSSQL.java
index bea87ff..fd59293 100644
---
a/empire-db/src/main/java/org/apache/empire/dbms/sqlserver/DBMSHandlerMSSQL.java
+++
b/empire-db/src/main/java/org/apache/empire/dbms/sqlserver/DBMSHandlerMSSQL.java
@@ -43,6 +43,7 @@ import org.apache.empire.dbms.DBMSFeature;
import org.apache.empire.dbms.DBMSHandler;
import org.apache.empire.dbms.DBMSHandlerBase;
import org.apache.empire.dbms.DBSqlPhrase;
+import org.apache.empire.exceptions.InvalidPropertyException;
import org.apache.empire.exceptions.NotSupportedException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -541,10 +542,22 @@ public class DBMSHandlerMSSQL extends DBMSHandlerBase
* @return
*/
@Override
- public DBModelChecker createModelChecker()
+ public DBModelChecker createModelChecker(DBDatabase db)
{
+ // detect catalog
+ String catalog = (db!=null ? StringUtils.coalesce(db.getSchema(),
this.databaseName) : this.databaseName);
+ if (StringUtils.isEmpty(catalog))
+ throw new InvalidPropertyException("databaseName", null);
+ // dtect schema
+ String schema = "DBO";
+ int schemaSep = catalog.indexOf('.');
+ if (schemaSep>0)
+ { // split catalog and schema
+ catalog = catalog.substring(schemaSep);
+ schema = catalog.substring(schemaSep+1);
+ }
// the default model checker
- return new MSSqlDBModelChecker();
+ return new MSSqlDBModelChecker(db, catalog, schema);
}
}
diff --git
a/empire-db/src/main/java/org/apache/empire/dbms/sqlserver/MSSqlDBModelChecker.java
b/empire-db/src/main/java/org/apache/empire/dbms/sqlserver/MSSqlDBModelChecker.java
index 5935ccf..916cb1e 100644
---
a/empire-db/src/main/java/org/apache/empire/dbms/sqlserver/MSSqlDBModelChecker.java
+++
b/empire-db/src/main/java/org/apache/empire/dbms/sqlserver/MSSqlDBModelChecker.java
@@ -21,6 +21,8 @@ package org.apache.empire.dbms.sqlserver;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
+import org.apache.empire.commons.StringUtils;
+import org.apache.empire.db.DBDatabase;
import org.apache.empire.db.validation.DBModelChecker;
/**
@@ -30,27 +32,24 @@ import org.apache.empire.db.validation.DBModelChecker;
*/
public class MSSqlDBModelChecker extends DBModelChecker
{
-
- @Override
- protected String getMetaCatalog(String dbSchema)
- {
- return dbSchema;
- }
-
- @Override
- protected String getMetaSchemaPattern(String dbSchema)
+ /**
+ * create a MSSqlDBModelChecker
+ * @param db the database
+ * @param catalog the catalog
+ */
+ public MSSqlDBModelChecker(DBDatabase db, String catalog, String schema)
{
- return "DBO";
+ super(db, catalog, StringUtils.coalesce(schema, "DBO"));
}
/**
* collects all column information at once
*/
@Override
- protected int collectColumns(DatabaseMetaData dbMeta, String dbSchema)
+ protected int collectColumns(DatabaseMetaData dbMeta)
throws SQLException
{
- return super.collectColumns(dbMeta, dbSchema, null);
+ return super.collectColumns(dbMeta, null);
}
}
