com.jk.db.dynamic.analyzer.AbstractDataBaseAnaylazer Maven / Gradle / Ivy
The newest version!
/*
* Copyright 2002-2016 Jalal Kiswani.
*
* Licensed 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 com.jk.db.dynamic.analyzer;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import javax.sql.rowset.CachedRowSet;
import com.jk.db.dataaccess.plain.JKPlainDataAccess;
import com.jk.db.datasource.JKDataSource;
import com.jk.db.datasource.JKDataSourceFactory;
import com.jk.exceptions.JKDataAccessException;
import com.jk.exceptions.handler.JKExceptionUtil;
import com.jk.logging.JKLogger;
import com.jk.logging.JKLoggerFactory;
import com.jk.metadata.db.meta.FieldMeta;
import com.jk.metadata.db.meta.ForiegnKeyFieldMeta;
import com.jk.metadata.db.meta.IdFieldMeta;
import com.jk.metadata.db.meta.EntityMeta;
/**
* The Class AbstractDataBaseAnaylazer.
*
* @author Jalal Kiswani
*/
public abstract class AbstractDataBaseAnaylazer implements DataBaseAnalayzer {
JKLogger logger=JKLoggerFactory.getLogger(getClass());
/**
* The main method.
*
* @param args
* the arguments
* @throws JKDataAccessException
* the JK data access exception
* @throws SQLException
* the SQL exception
*/
public static void main(final String[] args) throws JKDataAccessException, SQLException {
// final AbstractDataBaseAnaylazer a = (AbstractDataBaseAnaylazer)
// JKDataSourceFactory.getDataSource().getDatabaseAnasyaler();
}
private DatabaseMetaData meta;
private final JKDataSource dataSource;
private JKPlainDataAccess dao;
/**
* Instantiates a new abstract data base anaylazer.
*/
public AbstractDataBaseAnaylazer() {
this(JKDataSourceFactory.getDefaultDataSource());
}
/**
* Instantiates a new abstract data base anaylazer.
*
* @param dataSource
* the data source
*/
public AbstractDataBaseAnaylazer(final JKDataSource dataSource) {
this.dataSource = dataSource;
final Connection connection = dataSource.getQueryConnection();
try {
this.meta = connection.getMetaData();
this.dao = JKDataSourceFactory.getPlainDataAccess();
} catch (Exception e) {
JKExceptionUtil.handle(e);
} finally {
dataSource.close(connection);
}
}
protected abstract String buildEmptyRowQuery(String databaseName, String tableName);
/*
* (non-Javadoc)
*
* @see com.jk.db.dynamic.meta.generator.DataBaseAnalayzer#getCatalogsName()
*/
@Override
public List getCatalogsName() {
try {
final ResultSet rs = this.meta.getCatalogs();
final ArrayList catalogNames = new ArrayList();
final int counter = 1;
while (rs.next()) {
// for (int i = 0; i < rs.getMetaData().getColumnCount(); i++) {
catalogNames.add(rs.getString("TABLE_CAT"));
// }
}
rs.close();
return catalogNames;
} catch (Exception e) {
JKExceptionUtil.handle(e);
return null;
}
}
/*
* (non-Javadoc)
*
* @see
* com.jk.db.dynamic.meta.generator.DataBaseAnalayzer#getDatabasesName()
*/
// /////////////////////////////////////////////////////////////////////////////////////
@Override
public List getDatabasesName() {
return getCatalogsName();
}
/**
*
* @param databaseName
* @param tableName
* @return @
* @throws SQLException
*/
private ArrayList getForiegnKeys(final String databaseName, final String tableName) throws SQLException {
final ResultSet rs = getImportedKeys(this.meta, databaseName, tableName);
final ArrayList fields = new ArrayList();
while (rs.next()) {
final ForiegnKeyFieldMeta field = new ForiegnKeyFieldMeta();
field.setName(rs.getString("FKCOLUMN_NAME"));
field.setReferenceTable(rs.getString("PKTABLE_NAME"));
field.setReferenceField(rs.getString("PKCOLUMN_NAME"));
fields.add(field);
}
rs.close();
return fields;
}
/**
*
* @param databaseName
* @param tableName
* @return
* @throws SQLException
* @ @throws
* JKDataAccessException
*/
private IdFieldMeta getIdField(final String databaseName, final String tableName) throws JKDataAccessException, SQLException {
final ResultSet rs = getPrimaryKeysFromMeta(this.meta, databaseName, tableName);
try {
if (rs.next()) {
final IdFieldMeta id = new IdFieldMeta();
id.setName(rs.getString("COLUMN_NAME"));
final boolean autoIncrement = isAutoIncrement(databaseName, tableName);
id.setAutoIncrement(autoIncrement);
return id;
}
return null;
} finally {
rs.close();
}
}
// ///////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
* (non-Javadoc)
*
* @see com.fs.commons.dao.dynamic.meta.generator.DataBaseAnaylser1#
* getDyanmicMeta (java.lang.String)
*/
// @Override
// public Hashtable getDyanmicMeta(String databaseName)
// , DaoException {
// ArrayList tables = getTablesMeta(databaseName);
// Hashtable hash = new Hashtable();
// for (TableMeta tableMeta : tables) {
// hash.put(tableMeta.getTableName(), tableMeta);
// }
// return hash;
// }
// //////////////////////////////////////////////////////////////////////////
protected ResultSet getImportedKeys(final DatabaseMetaData meta, final String databaseName, final String tableName) throws SQLException {
return meta.getImportedKeys(databaseName, null, tableName);
}
// //////////////////////////////////////////////////////////////////////////////////////////
protected ResultSet getPrimaryKeysFromMeta(final DatabaseMetaData meta, final String databaseName, final String tableName) throws SQLException {
return meta.getPrimaryKeys(databaseName, null, tableName);
}
/*
* (non-Javadoc)
* TODO : check me
* @see com.jk.db.dynamic.meta.generator.DataBaseAnalayzer#getSchemas()
*/
// /////////////////////////////////////////////////////////////////////////////////////
@Override
public List getSchemas() {
try {
final ResultSet rs = this.meta.getSchemas();
final ArrayList schemaNames = new ArrayList();
while (rs.next()) {
// for (int i = 0; i < rs.getMetaData().getColumnCount(); i++) {
schemaNames.add(rs.getString("TABLE_SCHEM"));
// }
}
rs.close();
return schemaNames;
} catch (Exception e) {
JKExceptionUtil.handle(e);
return null;
}
}
// //////////////////////////////////////////////////////////////////////////////
protected EntityMeta getTable(final String tableName) {
return getTable(this.dataSource.getDatabaseName(), tableName);
}
// //////////////////////////////////////////////////////////////////////////////
protected EntityMeta getTable(final String databaseName, final String tableName) {
// System.out.println("Fetching table : " + tableName);
final EntityMeta meta = new EntityMeta();
meta.setTableName(tableName);
// meta.setIdField(getIdField(databaseName, tableName));
loadFields(databaseName, meta);
return meta;
}
protected ResultSet getTableColumnsFromMeta(final DatabaseMetaData meta, final String database, final String tableName) throws SQLException {
return meta.getColumns(database, null, tableName, null);
}
/*
* (non-Javadoc)
*
* @see com.jk.db.dynamic.meta.generator.DataBaseAnalayzer#getTablesMeta()
*/
@Override
public ArrayList getEntitiesMetadata() {
return getEntitiesMetadata(this.dataSource.getDatabaseName());
}
/*
* (non-Javadoc)
*
* @see
* com.jk.db.dynamic.meta.generator.DataBaseAnalayzer#getTablesMeta(java.
* lang.String)
*/
@Override
public ArrayList getEntitiesMetadata(final String databaseName) {
try {
final ResultSet rs = loadTableNamesFromMeta(this.meta, databaseName);
final ArrayList tables = new ArrayList();
while (rs.next()) {
final String tableType = rs.getString("TABLE_TYPE");
if (tableType.toUpperCase().equals("TABLE")) {
final String tableName = rs.getString("TABLE_NAME");
final EntityMeta meta = getTable(databaseName, tableName);
tables.add(meta);
}
}
rs.close();
return tables;
} catch (Exception e) {
JKExceptionUtil.handle(e);
return null;
}
}
// //////////////////////////////////////////////////////////////////////////////////////
protected boolean isAutoIncrement(final String databaseName, final String tableName) throws JKDataAccessException, SQLException {
final String emptyRowQuery = buildEmptyRowQuery(databaseName, tableName);
logger.debug("Executing : (" + emptyRowQuery + ") to check isAutoIncrement...");
final CachedRowSet rowSet = this.dao.executeQueryAsCachedRowSet(emptyRowQuery);
final boolean autoIncrement = rowSet.getMetaData().isAutoIncrement(1);
return autoIncrement;
}
/*
* (non-Javadoc)
*
* @see
* com.jk.db.dynamic.meta.generator.DataBaseAnalayzer#isTableExist(java.lang
* .String)
*/
// /////////////////////////////////////////////////////////////////////////////////////
@Override
public boolean isEntityExist(final String tableName) {
final ArrayList tables = getEntitiesMetadata(this.dataSource.getDatabaseName());
for (final EntityMeta tableMeta : tables) {
if (tableMeta.getTableName().trim().equalsIgnoreCase(tableName)) {
return true;
}
}
return false;
}
// ///////////////////////////////////////////////////////////////////////////////////////////////////////////
/*
* (non-Javadoc)
*
* @see
* com.fs.commons.dao.dynamic.meta.generator.DataBaseAnaylser1#getFields
* (java.lang.String, java.lang.String)
*/
// @Override
protected void loadFields(final String database, final EntityMeta tableMeta) {
try {
IdFieldMeta idField = getIdField(database, tableMeta.getTableName());
tableMeta.setIdField(idField);
final ArrayList foriegnFields = getForiegnKeys(database, tableMeta.getTableName());
for (final ForiegnKeyFieldMeta foriegnKeyFieldMeta : foriegnFields) {
foriegnKeyFieldMeta.setParentTable(tableMeta);
}
final ResultSet rs = getTableColumnsFromMeta(this.meta, database, tableMeta.getTableName());
while (rs.next()) {
final String fieldName = rs.getString("COLUMN_NAME");
// System.out.println("Processing field : "+fieldName);
FieldMeta fieldMeta;
boolean newField = true;
// the following check is used for primary keys and foreign keys
// which is already added to the list
if ((fieldMeta = tableMeta.getField(fieldName, true)) != null) {
newField = false;
} else {
if (idField == null) {
idField = new IdFieldMeta();
idField.setAutoIncrement(true);
tableMeta.setIdField(idField);
fieldMeta = idField;
newField = false;
} else {
fieldMeta = new FieldMeta();
}
fieldMeta.setName(fieldName);
fieldMeta.setParentTable(tableMeta);
int index;
if ((index = foriegnFields.indexOf(fieldMeta)) != -1) {
fieldMeta = foriegnFields.get(index);
}
}
final int type = rs.getInt("DATA_TYPE");
final int nullable = rs.getInt("NULLABLE");
final String defaultValue = rs.getString("COLUMN_DEF");
final int maxLength = rs.getInt("COLUMN_SIZE");
// int decimalDigits=rs.getInt("DECIMAL_DIGITS");
fieldMeta.setMaxLength(maxLength);
fieldMeta.setType(type);
fieldMeta.setRequired(nullable == 0 ? true : false);
if (defaultValue != null && !defaultValue.equals("null")) {
fieldMeta.setDefaultValue(defaultValue);
}
if (newField) {
tableMeta.addField(fieldMeta);
}
}
rs.close();
} catch (Exception e) {
JKExceptionUtil.handle(e);
}
}
// /////////////////////////////////////////////////////////////////////////////////////
protected ResultSet loadTableNamesFromMeta(final DatabaseMetaData meta, final String dbName) throws SQLException {
return meta.getTables(dbName, null, null, new String[] { "TABLE" });
}
/*
* (non-Javadoc)
*
* @see
* com.jk.db.dynamic.meta.generator.DataBaseAnalayzer#getDefaultCatalog()
*/
@Override
public String getDefaultCatalog() {
try {
return dataSource.getQueryConnection().getCatalog();
} catch (JKDataAccessException | SQLException e) {
JKExceptionUtil.handle(e);
return null;
}
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy