empire-db/src/main/java/org/apache/empire/dbms/oracle/OracleDataDictionnary.java - empire-db - Git at Google

 /*
  * 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<String, HashMap<String, ColumnInfo>> dictionnary = new HashMap<String, HashMap<String, ColumnInfo>>();

     private Map<String, DataType[]> dataTypeMapping    = null;

     /**
      * Defines mapping of the Empire-db data types with the oracle data types.
      */
     public OracleDataDictionnary() {
         dataTypeMapping = new HashMap<String, DataType[]>();
         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<String, HashMap<String, ColumnInfo>> 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<String, ColumnInfo> columns = new HashMap<String, ColumnInfo>();

         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<DBTable> 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<String> 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<DBView> 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<String> 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.");
             }
         }
     }

 }
	/*
	* 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<String, HashMap<String, ColumnInfo>> dictionnary = new HashMap<String, HashMap<String, ColumnInfo>>();

	private Map<String, DataType[]> dataTypeMapping = null;

	/**
	* Defines mapping of the Empire-db data types with the oracle data types.
	*/
	public OracleDataDictionnary() {
	dataTypeMapping = new HashMap<String, DataType[]>();
	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<String, HashMap<String, ColumnInfo>> 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<String, ColumnInfo> columns = new HashMap<String, ColumnInfo>();

	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<DBTable> 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<String> 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<DBView> 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<String> 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.");
	}
	}
	}

	}