com.jk.data.dynamic.dataaccess.JKDynamicDataAccessFactory Maven / Gradle / Ivy
package com.jk.data.dynamic.dataaccess;
///*
// * Copyright 2002-2018 Jalal Kiswani.
// * E-mail: [email protected]
// *
// * 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.test.dynamic.dataaccess;
//
//import java.util.HashMap;
//import java.util.Map;
//
//import org.hibernate.dialect.Database;
//
//import com.jk.db.test.datasource.JKDataSource;
//import com.jk.db.test.datasource.JKDataSourceFactory;
//import com.jk.db.test.dynamic.vendors.h2.H2DynamicDataAccess;
//import com.jk.db.test.dynamic.vendors.mysql.MySqlDynamicDataAccess;
//import com.jk.db.test.dynamic.vendors.oracle.OracleDynamicDao;
//import com.jk.metadata.core.EntityMetadata;
//import com.jk.metadata.core.FieldMetadata;
//import com.jk.metadata.exceptions.EntityMetaNotFoundException;
//import com.jk.metadata.importers.DataBaseImporter;
//import com.jk.metadata.util.EntityMetaDataRepository;
//import com.jk.util.JK;
//import com.jk.util.logging.JKLogger;
//import com.jk.util.logging.JKLoggerFactory;
//
//// TODO: Auto-generated Javadoc
///**
// * A factory for creating DynamicDao objects.
// */
//public class JKDynamicDataAccessFactory {
// static Map cache = new HashMap<>();
//
// /** The logger. */
// static JKLogger logger = JKLoggerFactory.getLogger(JKDynamicDataAccessFactory.class);
//
// /** The database analayzer. */
// private static DataBaseImporter databaseAnalayzer;
//
// /**
// * Creates a new JKDynamicDataAccess object.
// *
// * @param tableMetaName the table meta typeName
// * @return the JK dynamic data access
// */
// public static JKDynamicDataAccess createDynamicDao(final String tableMetaName) {
// return createDynamicDao(tableMetaName, true);
// }
//
// /**
// * Creates a new DynamicDao object.
// *
// * @param tableMetaName the table meta typeName
// * @param createIfNotExists the create if not exists
// * @return the dynamic dao
// */
// public static JKDynamicDataAccess createDynamicDao(final String tableMetaName, boolean createIfNotExists) {
// logger.debug("Create dynamic dao for entityMetadata ({})", tableMetaName);
// EntityMetadata entityMeta = EntityMetaDataRepository.getDefaultInstance().getEntityMeta(tableMetaName);
// if (entityMeta == null && createIfNotExists) {
// JK.fixMe("check me");
//// JK.error("Metadata not found (%s)",tableMetaName);
// logger.debug("EntityMetadata not found, trying to to import it");
// entityMeta = EntityMetaDataRepository.getDefaultInstance().importEntity(tableMetaName);
// }
// if (entityMeta == null) {
// JK.throww(new EntityMetaNotFoundException());
// }
// return createDynamicDao(entityMeta);
// }
//
// /**
// * Creates a new DynamicDao object.
// *
// * @param entityMetadata the entity meta data
// * @return the dynamic dao
// */
// public static JKDynamicDataAccess createDynamicDao(final EntityMetadata entityMetadata) {
// final JKDataSource dataSource = JKDataSourceFactory.getDefaultDataSource();
// return createDynamicDao(entityMetadata, dataSource);
// }
//
// public static JKDynamicDataAccess createDynamicDao(final EntityMetadata entityMetadata, final JKDataSource dataSource) {
// switch (dataSource.getDatabaseType()) {
// case ORACLE:
// return new OracleDynamicDao(entityMetadata,dataSource);
// case H2:
// return new H2DynamicDataAccess(entityMetadata,dataSource);
// case MYSQL:
// return new MySqlDynamicDataAccess(entityMetadata,dataSource);
// default:
// return new JKDynamicDataAccess(entityMetadata,dataSource);
// }
// }
//
//// /**
//// * Gets the database analayzer.
//// *
//// * @return the database analayzer
//// */
//// public static DataBaseImporter getDatabaseAnalayzer() {
//// if (databaseAnalayzer == null) {
//// final JKDataSource dataSource = JKDataSourceFactory.getDefaultDataSource();
//// databaseAnalayzer = getDatabaseAnalayzer(dataSource);
//// }
//// return databaseAnalayzer;
//// }
//
//// /**
//// * Gets the database analayzer.
//// *
//// * @param dataSource the data source
//// * @return the database analayzer
//// */
//// public static DataBaseImporter getDatabaseAnalayzer(JKDataSource dataSource) {
//// switch (dataSource.getDatabaseType()) {
//// case ORACLE:
//// return new OracleDatabaseAnalayzer(dataSource);
//// case MYSQL:
//// return new MySqlDatabaseAnalayzer(dataSource);
//// default:
//// return new DataBaseAnaylazer(dataSource);
//// }
////
//// }
//
//// /**
//// * Creates a new JKDynamicDataAccess object.
//// *
//// * @param clas the clas
//// * @return the JK dynamic data access
//// */
//// public static JKDynamicDataAccess createDynamicDao(Class clas) {
////
//// return createDynamicDao(clas, true);
//// }
//
//// /**
//// * Creates a new JKDynamicDataAccess object.
//// *
//// * @param clas the clas
//// * @param syncTable the sync table
//// * @return the JK dynamic data access
//// */
//// public static JKDynamicDataAccess createDynamicDao(Class clas, boolean syncTable) {
////// JKDynamicDataAccess instance = cache.get(clas.getName());
////// if (instance == null) {
//// logger.debug("createDynamicDao for class {}", clas.getName());
//// EntityMetadata entityMetadata = EntityMetaDataRepository.getDefaultInstance().getEntityMetaForClass(clas, true);
//// JKDynamicDataAccess dataAccess = createDynamicDao(entityMetadata);
//// JK.fixMe("cache dataaccess for performance");
//// if (syncTable) {
//// syncEntityWithDatabase(entityMetadata, dataAccess);
//// }
//// JKDynamicDataAccess instance = dataAccess;
////// cache.put(clas.getName(), instance);
////// }
//// return instance;
//// }
//
//// /**
//// * Sync entity with database.
//// *
//// * @param entityMetadata the entity meta data
//// * @param dataAccess the data access
//// */
//// public static void syncEntityWithDatabase(EntityMetadata entityMetadata, JKDynamicDataAccess dataAccess) {
//// // to avoid recursion from foreign keys
//// if (entityMetadata.isSynced()) {
//// return;
//// }
//// if (!JK.isTestContext()) {
//// logger.debug("Entity is set to synced");
//// entityMetadata.setSynced(true);
//// }
//// logger.trace("process Sync table for entity {}", entityMetadata.getName());
//// DefaultSqlExporter export = new DefaultSqlExporter(getDatabase());
//// Map desc = dataAccess.describeTable(entityMetadata.getName());
//// logger.trace("database table desc {}", desc);
//// if (desc.size() == 0) {
//// // table doesnot exists
//// String sql = export.export(entityMetadata);
//// logger.info("Table for entity doesnot exists, create one using :{} \t{} ", JK.NEW_LINE,
//// sql.replaceAll(JK.NEW_LINE, JK.NEW_LINE.concat("\t")));
//// dataAccess.execute(sql);
//// // create structur for relations as well
//// List fieldList = entityMetadata.getForeignKeyFields();
//// for (ForiegnKeyFieldMetaData fk : fieldList) {
//// logger.debug("Syncing FK {}", fk.getName());
//// if (fk.isIncludeInPersistence()) {
//// EntityMetadata fkEntityMetaData = EntityMetaDataRepository.getDefaultInstance().getEntityMeta(fk.getReferenceEntityName());
//// syncEntityWithDatabase(fkEntityMetaData, dataAccess);
//// }
//// }
////
//// } else {
//// logger.trace("table exists for enitiy, checking for for field changes");
//// for (FieldMetadata field : entityMetadata.getFieldList()) {
//// if (field.isIncludeInPersistence()) {
//// if (desc.get(field.getName()) == null) {
//// logger.debug("Column {} doesnot exists in entity {} creating it.", field.getName(), entityMetadata.getName());
//// JK.fixMe("this doesnot handle the foriegn key case");
//// dataAccess.addColumn(entityMetadata.getName(), field.getName(), getSqlType(field), field.isRequired());
//// }
//// }
//// }
//// }
//// }
//
// /**
// * Gets the sql type.
// *
// * @param field the field
// * @return the sql type
// */
// public static String getSqlType(FieldMetadata field) {
// final JKDataSource dataSource = JKDataSourceFactory.getDefaultDataSource();
// return dataSource.getDatabaseType().dialect().getTypeName(field.getTypeCode(), field.getMaxLength(), field.getPrecision(), field.getScale());
// }
//
// /**
// * Gets the database.
// *
// * @return the database
// */
// public static Database getDatabase() {
// final JKDataSource dataSource = JKDataSourceFactory.getDefaultDataSource();
// return Database.valueOf(dataSource.getDatabaseType().toString());
// }
//
//} © 2015 - 2025 Weber Informatics LLC | Privacy Policy