org.apache.empire.dbms.oracle.OracleDataDictionnary Maven / Gradle / Ivy
The newest version!
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.empire.dbms.oracle;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.apache.empire.data.DataType;
import org.apache.empire.db.DBColumn;
import org.apache.empire.db.DBTable;
import org.apache.empire.db.DBView;
public class OracleDataDictionnary {
/**
* Immutable column info helper class
*/
public class ColumnInfo {
private final String dataType;
private final int charLength;
private final int dataLength;
private final int dataPrecision;
private final int dataScale;
private final String nullable;
public ColumnInfo(String dataType, int charLength, int dataLength, int dataPrecision, int dataScale, String nullable)
{
super();
this.dataType = dataType;
this.charLength = charLength;
this.dataLength = dataLength;
this.dataPrecision = dataPrecision;
this.dataScale = dataScale;
this.nullable = nullable;
}
public int getCharLength()
{
return charLength;
}
public int getDataLength()
{
return dataLength;
}
public int getDataPrecision()
{
return dataPrecision;
}
public int getDataScale()
{
return dataScale;
}
public String getDataType()
{
return dataType;
}
public String getNullable()
{
return nullable;
}
}
protected static final Logger log = LoggerFactory.getLogger(OracleDataDictionnary.class);
private final HashMap> dictionnary = new HashMap>();
private Map dataTypeMapping = null;
/**
* Defines mapping of the Empire-db data types with the oracle data types.
*/
public OracleDataDictionnary() {
dataTypeMapping = new HashMap();
dataTypeMapping.put("VARCHAR2", new DataType[] { DataType.VARCHAR });
dataTypeMapping.put("CHAR", new DataType[] { DataType.CHAR, DataType.BOOL });
dataTypeMapping.put("NUMBER", new DataType[] { DataType.DECIMAL, DataType.FLOAT,
DataType.INTEGER, DataType.AUTOINC, DataType.BOOL });
dataTypeMapping.put("DATE", new DataType[] { DataType.DATE, DataType.DATETIME });
dataTypeMapping.put("TIMESTAMP",new DataType[] { DataType.TIMESTAMP });
dataTypeMapping.put("CLOB", new DataType[] { DataType.CLOB });
dataTypeMapping.put("BLOB", new DataType[] { DataType.BLOB });
}
public HashMap> getDictionnary() {
return dictionnary;
}
public void fillDataDictionnary(String tableName, String columnName, String dataType, int charLength, int dataLength, int dataPrecision, int dataScale, String nullable) {
ColumnInfo colInfo = new ColumnInfo(dataType, charLength, dataLength, dataPrecision, dataScale, nullable);
HashMap columns = new HashMap();
if(dictionnary.containsKey(tableName)) {
columns = dictionnary.get(tableName);
}
columns.put(columnName, colInfo);
dictionnary.put(tableName, columns);
}
/**
* Checks if the ORACLE datatype can be mapped with a DBTable data type.
*
* @param dbDatatype ORACLE datatype
* @param colDataType DBTableColumn datatype
* @return true if the type can be mapped, false otherwise
*/
private boolean checkMapping(String dbDatatype, DataType colDataType)
{
DataType[] colTypes = dataTypeMapping.get(dbDatatype);
if(colTypes == null)
{
log.warn("MAPPING NOT DEFINED FOR " + dbDatatype + " -> " + colDataType);
return false;
}
for (int i = 0; i < colTypes.length; i++)
{
if (colTypes[i] == colDataType)
return true;
}
return false;
}
/*
* Checks a DBTableColumn definition. The set attributes must fint to the overgiven db attributes.
*
* @param col Column to check
* @param dbDataType Datatype of db column
* @param dbDataLength Datalength of db column
* @param dbDataPrecision Data precision of db column
* @param dbDataScale Data scale of db column
* @param dbRequired Is nullable of the db column
* @return true if the column definition fits, false otherwise
private boolean checkColumnDefinition(DBColumn col, String dbDataType, int dbDataLength, int dbDataPrecision,
int dbDataScale, boolean dbRequired)
{
// FUTURE find a way to check the precision for numbers
boolean result = true;
DataType colDataType = col.getDataType();
int size = (int) col.getSize();
// check if the column data type can be mapped with the db column data type
if (checkMapping(dbDataType, colDataType) == false)
{
log.warn("WRONG DATATYPE \t\t\t\t\t\t: [" + col.getRowSet().getName() + "][" + col.getName() + "] -> DB : ["
+ dbDataType + "]" + "[" + dbDataLength + "]");
result = false;
}
// check if the column is required and if the column is defined as required
if (dbRequired && col.isRequired() == false)
{
log.warn("COLUMN IS REQUIRED \t\t\t\t\t: [" + col.getRowSet().getName() + "][" + col.getName() + "]");
result = false;
}
else if (dbRequired == false && col.isRequired() == true)
{
log.warn("COLUMN IS NOT REQUIRED \t\t\t\t: [" + col.getRowSet().getName() + "][" + col.getName() + "]");
result = false;
}
// check the data length if the column is a varchar2
if (dbDataType.equals("VARCHAR2") && (dbDataLength != size))
{
log.warn("WRONG COLUMN SIZE \t\t\t\t\t: [" + col.getRowSet().getName() + "][" + col.getName() + "] -> DB : ["
+ dbDataType + "][" + dbDataLength + "]");
result = false;
}
return result;
}
*/
private void checkColumn(DBColumn column, ColumnInfo colInfo)
{
if(checkMapping(colInfo.getDataType(), column.getDataType()) == false) {
log.warn("WRONG DATA TYPE: \t" + column.getFullName() + " is set to " + column.getDataType() +
" instead of " + colInfo.getDataType());
}
if(colInfo.getDataType().equals("VARCHAR2") && (column.getSize() != colInfo.getCharLength())) {
log.warn("WRONG COLUMN SIZE: \t" + column.getFullName() + " is set to " + (int)column.getSize() +
" instead of " + colInfo.getCharLength());
}
if(column.isRequired() != colInfo.getNullable().equals("N")) {
log.warn("WRONG NULLABLE FLAG: \t" + column.getFullName() + " is set to " + column.isRequired() +
" instead of " + colInfo.getNullable().equals("N"));
}
}
public void checkDBTableDefinition(List dbTables) {
// go through all tables defined in the Java code
for(DBTable currentTable: dbTables) {
String dbTableName = currentTable.getName();
// check if the table name is in the data dictionnary
if(this.dictionnary.containsKey(dbTableName)) {
// go through all columns of the table
for(DBColumn currentColumn : currentTable.getColumns()) {
Collection dictColumns = this.dictionnary.get(dbTableName).keySet();
// check if the column name is in the data dictionnary
if(dictColumns.contains(currentColumn.getName())) {
// go through all columns of the table in the data dictionnary
for(String dictColumn : dictColumns) {
// compare the columnnames
if(currentColumn.getName().equals(dictColumn)) {
ColumnInfo colInfo = this.dictionnary.get(currentTable.getName()).get(dictColumn);
checkColumn(currentColumn, colInfo);
}
}
}
else {
log.warn("MISSING COLUMN: \t" + currentColumn.getFullName() + " does not exist in database");
}
}
}
else {
log.warn("MISSING TABLE: \t" + currentTable.getName() + " does not exist in database");
}
}
}
public void checkDBViewDefinition(List dbViews) {
// go through all views defined in the Java code
for(DBView currentView: dbViews) {
String dbviewName = currentView.getName();
// check if the view name is in the data dictionnary
if(this.dictionnary.containsKey(dbviewName)) {
// go through all columns of the table
for(DBColumn currentColumn : currentView.getColumns()) {
Collection dictColumns = this.dictionnary.get(dbviewName).keySet();
// check if the column name is in the data dictionnary
if(dictColumns.contains(currentColumn.getName())) {
// go through all columns of the view in the data dictionnary
for(String dictColumn : dictColumns) {
// compare the columnnames
if(currentColumn.getName().equals(dictColumn)) {
ColumnInfo colInfo = this.dictionnary.get(currentView.getName()).get(dictColumn);
if(checkMapping(colInfo.getDataType(), currentColumn.getDataType()) == false) {
log.warn("WRONG DATA TYPE: \t" + currentColumn.getFullName() + " is set to " + currentColumn.getDataType() +
" instead of " + colInfo.getDataType());
}
}
}
}
else {
log.warn("MISSING COLUMN: \t" + currentColumn.getFullName() + " does not exist in database.");
}
}
}
else {
log.warn("MISSING VIEW: \t" + currentView.getName() + " does not exist in database.");
}
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy