com.jk.data.dynamic.dataaccess.JKDynamicDataAccess Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jk-framework-data Show documentation
Show all versions of jk-framework-data Show documentation
This contains a set of API's that ease the database programming with Java, in both: JDBC and JPA Persisitnce).
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.sql.PreparedStatement;
//import java.sql.ResultSet;
//import java.sql.SQLException;
//import java.util.ArrayList;
//import java.util.HashMap;
//import java.util.List;
//import java.util.Map;
//import java.util.Set;
//import java.util.Vector;
//
//import com.jk.db.test.dataaccess.core.JKDataAccessImpl;
//import com.jk.db.test.dataaccess.core.JKFinder;
//import com.jk.db.test.dataaccess.core.JKUpdater;
//import com.jk.db.test.datasource.JKDataSource;
//import com.jk.db.test.dynamic.query.MetaDataSqlBuilder;
//import com.jk.db.test.exceptions.JKRecordNotFoundException;
//import com.jk.metadata.core.Field;
//import com.jk.metadata.core.EntityMetadata;
//import com.jk.metadata.core.Record;
//import com.jk.metadata.core.FieldMetadata;
//import com.jk.metadata.core.ForiegnKeyFieldMetaData;
//import com.jk.metadata.triggers.EntityTrigger;
//import com.jk.metadata.util.EntityMetaDataRepository;
//import com.jk.util.JK;
//import com.jk.util.annotations.ScopeType;
//import com.jk.util.exceptions.JKDataAccessException;
//import com.jk.util.logging.JKLogger;
//import com.jk.util.logging.JKLoggerFactory;
//
//// TODO: Auto-generated Javadoc
///**
// * The Class DynamicDao.
// *
// * @author Jalal Kiswani
// */
//public class JKDynamicDataAccess extends JKDataAccessImpl {
//
// /** The logger. */
// JKLogger logger = JKLoggerFactory.getLogger(getClass());
//
// /** The table meta. */
// protected final EntityMetadata entityMeta;
//
// /** The sql builder. */
// protected MetaDataSqlBuilder sqlBuilder;
//
// /**
// * Instantiates a new dynamic dao.
// *
// * @param entityMetaName the table meta typeName
// */
// // //////////////////////////////////////////////////////////////
// public JKDynamicDataAccess(final String entityMetaName, JKDataSource dataSource) {
// this(EntityMetaDataRepository.getDefaultInstance().getEntityMeta(entityMetaName), dataSource);
// logger.trace(entityMetaName);
// }
//
// /**
// * Instantiates a new dynamic dao.
// *
// * @param entityMeta the table meta
// */
// // //////////////////////////////////////////////////////////////
// public JKDynamicDataAccess(final EntityMetadata entityMeta, JKDataSource dataSource) {
// super(dataSource);
// this.entityMeta = entityMeta;
//// if (entityMeta.getScope() == ScopeType.APPLICATION) {
//// setEnableMultiTenant(false);
//// }
// this.sqlBuilder = new MetaDataSqlBuilder(entityMeta);
// }
//
// // // //////////////////////////////////////////////////////////////
// // protected void addDeleteAudit(final Record record) {
// // logger.trace(record.toString());
// // final JKAudit audit = createAudit(record,
// // JKAuditType.AUDIT_DELETE_RECORD);
// //// addAudit(audit);
// // }
// //
// // // //////////////////////////////////////////////////////////////
// // protected void addInsertAudit(final Record record) {
// // logger.trace(record.toString());
// // final JKAuditType aUDIT_ADD_RECORD = JKAuditType.AUDIT_ADD_RECORD;
// // final JKAudit audit = createAudit(record, aUDIT_ADD_RECORD);
// //// addAudit(audit);
// // }
// //
// // // //////////////////////////////////////////////////////////////
// // protected void addUpdateAudit(final Record oldRecord, final Record
// // newRecord) {
// // logger.trace(oldRecord == null ? newRecord.toString() :
// // oldRecord.toString());
// // final JKAudit audit = createAudit(newRecord,
// // JKAuditType.AUDIT_UPDATE_RECORD);
// // audit.setOldValue(oldRecord.toString(true));
// //// addAudit(audit);
// // }
// //
// /**
// * Call after add event on triggers.
// *
// * @param record the record
// */
//// // //////////////////////////////////////////////////////////////
//// protected void callAfterAddEventOnTriggers(final Record record) {
//// final ArrayList triggers = this.entityMeta.getTriggers();
//// for (int i = 0; i < triggers.size(); i++) {
//// triggers.get(i).afterAdd(record);
//// }
//// }
//
// /**
// * Call after delete event on triggers.
// *
// * @param record the record
// */
//// // //////////////////////////////////////////////////////////////
//// protected void callAfterDeleteEventOnTriggers(final Record record) {
//// final ArrayList triggers = this.entityMeta.getTriggers();
//// for (int i = 0; i < triggers.size(); i++) {
//// triggers.get(i).afterDelete(record);
//// }
//// }
//
// /**
// * Call after find event on triggers.
// *
// * @param record the record
// */
//// protected void callAfterFindEventOnTriggers(final Record record) {
//// final ArrayList triggers = this.entityMeta.getTriggers();
//// for (int i = 0; i < triggers.size(); i++) {
//// triggers.get(i).afterFind(record);
//// }
//// }
//
//// /**
//// * Call after update event on triggers.
//// *
//// * @param oldRecord the old record
//// * @param newRecord the new record
//// */
//// // //////////////////////////////////////////////////////////////
//// protected void callAfterUpdateEventOnTriggers(final Record oldRecord, final Record newRecord) {
//// final ArrayList triggers = this.entityMeta.getTriggers();
//// for (int i = 0; i < triggers.size(); i++) {
//// triggers.get(i).afterUpdate(oldRecord, newRecord);
//// }
//// }
//
//// /**
//// * Call before add event on triggers.
//// *
//// * @param record the record
//// */
//// // //////////////////////////////////////////////////////////////
//// protected void callBeforeAddEventOnTriggers(final Record record) {
//// final ArrayList triggers = this.entityMeta.getTriggers();
//// for (int i = 0; i < triggers.size(); i++) {
//// triggers.get(i).beforeAdd(record);
//// }
//// }
////
//// /**
//// * Call before delete event on triggers.
//// *
//// * @param record the record
//// */
//// // //////////////////////////////////////////////////////////////
//// protected void callBeforeDeleteEventOnTriggers(final Record record) {
//// final ArrayList triggers = this.entityMeta.getTriggers();
//// for (int i = 0; i < triggers.size(); i++) {
//// triggers.get(i).beforeDelete(record);
//// }
//// }
//
//// /**
//// * Call before update event on triggers.
//// *
//// * @param oldRecord the old record
//// * @param newRecord the new record
//// */
//// // //////////////////////////////////////////////////////////////
//// protected void callBeforeUpdateEventOnTriggers(final Record oldRecord, final Record newRecord) {
//// final ArrayList triggers = this.entityMeta.getTriggers();
//// for (int i = 0; i < triggers.size(); i++) {
//// triggers.get(i).beforeUpdate(oldRecord, newRecord);
//// }
//// }
//
// /**
// * Clone details.
// *
// * @param sourceIdValue the source id value
// * @param targetIdValue the target id value
// */
// // ///////////////////////////////////////////////////////////////////////////////////////
// public void cloneDetails(final Object sourceIdValue, final Object targetIdValue) {
// // TODO : refactor this method to be extarced to facade and avoid direct
// // calls from UI
// final List detailFields = this.entityMeta.getDetailFields();
//// final JKSession session = getDataSource().createSession();
//// boolean commit = false;
// try {
// for (final ForiegnKeyFieldMetaData foriegnKeyFieldMetaData : detailFields) {
// final JKDynamicDataAccess detailDao = JKDynamicDataAccessFactory.createDynamicDao(foriegnKeyFieldMetaData.getParentEntity());
// // Find detaile record for the original id
// final List detailRecords = detailDao.findByFieldValue(foriegnKeyFieldMetaData.getName(), sourceIdValue);
// // iterate over the records , change the id to the new id , and
// // reset the primary key
// for (final Record detailRecord : detailRecords) {
// detailRecord.setIdValue(null);
// detailRecord.setFieldValue(foriegnKeyFieldMetaData.getName(), targetIdValue);
// detailDao.insertRecord(detailRecord);
// }
// }
//// commit = true;
// } finally {
//// session.close(commit);
// }
// }
//
// // /**
// // * Creates the audit.
// // *
// // * @param record
// // * the record
// // * @param auditType
// // * the audit type
// // * @return the JK audit
// // */
// // // //////////////////////////////////////////////////////////////
// // public JKAudit createAudit(final Record record, final JKAuditType
// // auditType) {
// // final JKAudit audit = new JKAudit();
// // audit.setAuditType(auditType);
// // audit.setBusinessRecordId(record.getIdValueAsInteger());
// // audit.setTableName(record.getTableMeta().getTableName());
// // audit.setNewValue(record.toString(true));
// // if (new Boolean(System.getProperty("fs.security.audit.gui", "true"))) {
// // audit.setGui(record.getGui());
// // }
// // return audit;
// // }
//
// /**
// * Creates the empty record.
// *
// * @return the record
// */
// // //////////////////////////////////////////////////////////////
// public Record createEmptyRecord() {
// return createEmptyRecord(true);
// }
//
// /**
// * Creates the empty record.
// *
// * @param setDefaultValues the set default values
// * @return the entity record
// */
// public Record createEmptyRecord(final boolean setDefaultValues) {
// return this.entityMeta.createEmptyRecord(setDefaultValues);
// }
//
// /**
// * Creates the empty record.
// *
// * @param setDefaultValues the set default values
// * @param defaults the defaults
// * @return the record
// */
// // //////////////////////////////////////////////////////////////
// public Record createEmptyRecord(final boolean setDefaultValues, final Record defaults) {
// return this.entityMeta.createEmptyRecord(setDefaultValues, defaults);
// }
//
// /**
// * Delete all records.
// */
// // //////////////////////////////////////////////////////////////
// public void deleteAllRecords() {
// logger.trace("deleteAllRecords for tablemeta : ", entityMeta);
// final JKUpdater updater = new JKEntityUpdater(this.entityMeta) {
//
// @Override
// public String getStatement() {
// return JKDynamicDataAccess.this.sqlBuilder.buildDelete();
// }
//
// @Override
// public void setParamters(final PreparedStatement ps) throws SQLException {
// }
// };
// executeUpdate(updater);
// }
//
// /**
// * Delete by fields values.
// *
// * @param fieldNameToValue the field typeName to value
// */
// public void deleteByFieldsValues(final HashMap fieldNameToValue) {
// logger.trace(fieldNameToValue.toString());
// final Record filterRecord = this.entityMeta.createEmptyRecord();
// final Set keySet = fieldNameToValue.keySet();
// for (final String fieldName : keySet) {
// filterRecord.setFieldValue(fieldName, fieldNameToValue.get(fieldName));
// }
// final List lstRecords = lstRecords(filterRecord);
// for (final Record record : lstRecords) {
// deleteRecord(record);
// }
//
// }
//
// /**
// * Delete by field value.
// *
// * @param fieldName the field typeName
// * @param value the value
// */
// // //////////////////////////////////////////////////////////////
// public void deleteByFieldValue(final String fieldName, final Object value) {
// logger.trace(fieldName, " = ", value);
// final Record record = createEmptyRecord(false);
// record.setFieldValue(fieldName, value);
// deleteRecord(record.getField(fieldName), false);
// }
//
// /**
// * Delete record.
// *
// * @param field the field
// */
// // //////////////////////////////////////////////////////////////
// public void deleteRecord(final Field field) {
// logger.trace(field.toString());
// deleteRecord(field, true);
// }
//
// /**
// * Delete record.
// *
// * @param field the field
// * @param addAudit the add audit
// */
// // //////////////////////////////////////////////////////////////
// public void deleteRecord(final Field field, final boolean addAudit) {
// logger.trace(field, " , add audit : ", addAudit);
// final JKUpdater updater = new JKEntityUpdater(this.entityMeta) {
//
// @Override
// public String getStatement() {
// return JKDynamicDataAccess.this.sqlBuilder.buildDelete(field);
// }
//
// @Override
// public void setParamters(final PreparedStatement ps) throws SQLException {
// }
// };
// Record record = null;
// if (addAudit) {
// record = findRecord(field.getValueAsInteger());
// }
// executeUpdate(updater);
// // if (addAudit) {
// // addDeleteAudit(record);
// // }
// }
//
// /**
// * Delete record.
// *
// * @param recordId the record id
// */
// // //////////////////////////////////////////////////////////////
// public void deleteRecord(final Object recordId) {
// final Record record = createEmptyRecord(false);
// record.setIdValue(recordId);
// deleteRecord(record);
// }
//
// /**
// * Delete record.
// *
// * @param record the record
// */
// // //////////////////////////////////////////////////////////////
// public void deleteRecord(final Record record) {
//// callBeforeDeleteEventOnTriggers(record);
// deleteRecord(record.getIdField());
//// callAfterDeleteEventOnTriggers(record);
// }
//
// /**
// * Delete records.
// *
// * @param filter the filter
// */
// /*
// * @param filter
// *
// * @throws DaoException
// */
// public void deleteRecords(final Record filter) {
// final List findRecord = lstRecords(filter);
// for (final Record record : findRecord) {
// deleteRecord(record);
// }
// }
//
// /**
// * Find by field value.
// *
// * @param fieldName the field typeName
// * @param value the value
// * @return the list
// */
// // //////////////////////////////////////////////////////////////
// public List findByFieldValue(final String fieldName, final Object value) {
// final Record filterRecord = this.entityMeta.createEmptyRecord();
// filterRecord.setFieldValue(fieldName, value);
// return lstRecords(filterRecord);
// }
//
// /**
// * Find record.
// *
// * @param id the id
// * @return the record
// */
// // //////////////////////////////////////////////////////////////
// public Record findRecord(final Object id) {
// final JKFinder finder = new JKEntityFinder(this.entityMeta) {
//
// @Override
// public String getQuery() {
// return sqlBuilder.buildFindById(id.toString());
// }
//
// @Override
// public Object populate(final ResultSet rs) throws SQLException {
// return readRecord(rs, JKDynamicDataAccess.this.entityMeta);
// }
//
// @Override
// public void setParamters(final PreparedStatement ps) throws SQLException {
// }
// };
// final Record record = (Record) findRecord(finder);
//// callAfterFindEventOnTriggers(record);
// return record;
// }
//
// /**
// * Find record.
// *
// * @param filter the filter
// * @return the record
// */
// // //////////////////////////////////////////////////////////////
// public Record findOneRecordByExample(final Record filter) {
// final JKFinder finder = new JKEntityFinder(this.entityMeta) {
// @Override
// public String getQuery() {
// return JKDynamicDataAccess.this.sqlBuilder.buildFindByFilter(filter);
// }
//
// @Override
// public Object populate(final ResultSet rs) throws SQLException, JKRecordNotFoundException, JKDataAccessException {
// return readRecord(rs, JKDynamicDataAccess.this.entityMeta);
// }
//
// @Override
// public void setParamters(final PreparedStatement ps) throws SQLException {
// }
// };
// return (Record) findRecord(finder);
// }
//
// /**
// * Find by example.
// *
// * @param filter the filter
// * @return the list
// */
// // //////////////////////////////////////////////////////////////
// public List findByExample(final Record filter) {
// final JKFinder finder = new JKEntityFinder(this.entityMeta) {
// @Override
// public String getQuery() {
// return JKDynamicDataAccess.this.sqlBuilder.buildFindByFilter(filter);
// }
//
// @Override
// public Object populate(final ResultSet rs) throws SQLException, JKRecordNotFoundException, JKDataAccessException {
// return readRecord(rs, JKDynamicDataAccess.this.entityMeta);
// }
//
// @Override
// public void setParamters(final PreparedStatement ps) throws SQLException {
// }
// };
// return getList(finder);
// }
//
// /**
// * Find by filter.
// *
// * @param filter the filter
// * @return the list
// */
// // //////////////////////////////////////////////////////////////
// public List findByFilter(final List filter) {
// // filter list should have the condition in the sql statement
// final JKFinder finder = new JKEntityFinder(this.entityMeta) {
// @Override
// public String getQuery() {
// return JKDynamicDataAccess.this.sqlBuilder.buildFindByFilter(filter);
// }
//
// @Override
// public Object populate(final ResultSet rs) throws SQLException, JKRecordNotFoundException, JKDataAccessException {
// return readRecord(rs, JKDynamicDataAccess.this.entityMeta);
// }
//
// @Override
// public void setParamters(final PreparedStatement ps) throws SQLException {
// }
// };
// return getList(finder);
// }
//
// /**
// * Find record by field value.
// *
// * @param fieldNameToValue the field typeName to value
// * @return the record
// */
// public Record findRecordByFieldValue(final HashMap fieldNameToValue) {
// final Record filterRecord = this.entityMeta.createEmptyRecord();
// for (final String fieldName : fieldNameToValue.keySet()) {
// filterRecord.setFieldValue(fieldName, fieldNameToValue.get(fieldName));
// }
// return findOneRecordByExample(filterRecord);
// }
//
// /**
// * Find record by field value.
// *
// * @param fieldName the field typeName
// * @param value the value
// * @return the record
// */
// // //////////////////////////////////////////////////////////////
// public Record findRecordByFieldValue(final String fieldName, final Object value) {
// final Record filterRecord = this.entityMeta.createEmptyRecord();
// filterRecord.setFieldValue(fieldName, value);
// return findOneRecordByExample(filterRecord);
// }
//
// /**
// * Gets the assigned values query.
// *
// * @param field1Id the field 1 id
// * @return the assigned values query
// */
// public String getAssignedValuesQuery(final int field1Id) {
// final StringBuffer buf = new StringBuffer();
// final List list = this.entityMeta.getDetailFields();
// final ForiegnKeyFieldMetaData field1 = list.get(0);
// final ForiegnKeyFieldMetaData field2 = list.get(1);
// final EntityMetadata refTable = EntityMetaDataRepository.getDefaultInstance().getEntityMeta(field2.getReferenceEntityName());
// // buf.append(refTable.getShortReportSql());
// String sql = refTable.getShortQuery();
// sql += sql.toUpperCase().contains("WHERE") ? " AND " : " WHERE ";
// buf.append(sql);
// buf.append(field2.getReferenceField() + " IN (");
// buf.append(" SELECT " + field2.getName() + " FROM " + field2.getParentEntity().getName());
// buf.append(" WHERE " + field1.getName() + " = " + field1Id);
// buf.append(")");
// return buf.toString();
// }
//
// /**
// * Gets the first record in table.
// *
// * @return the first record in table
// */
// // //////////////////////////////////////////////////////////////
// public Record getFirstRecordInTable() {
// logger.trace("First record");
// final List r = lstRecords();
// if (r.size() > 0) {
// return r.get(0);
// }
// return null;
// }
//
// /**
// * Gets the not assigned values query.
// *
// * @param field1Id the field 1 id
// * @return the not assigned values query
// */
// public String getNotAssignedValuesQuery(final int field1Id) {
// final StringBuffer buf = new StringBuffer();
// final List list = this.entityMeta.getDetailFields();
// final ForiegnKeyFieldMetaData field1 = list.get(0);
// final ForiegnKeyFieldMetaData field2 = list.get(1);
// final EntityMetadata refTable = EntityMetaDataRepository.getDefaultInstance().getEntityMeta(field2.getReferenceEntityName());
// String sql = refTable.getShortQuery();
// sql += sql.toUpperCase().contains("WHERE") ? " AND " : " WHERE ";
// buf.append(sql);
// buf.append(field2.getReferenceField() + " NOT IN (");
// buf.append(" SELECT " + field2.getName() + " FROM " + field2.getParentEntity().getName());
// buf.append(" WHERE " + field1.getName() + " = " + field1Id);
// buf.append(")");
// return buf.toString();
// }
//
// /**
// * Gets the sql builder.
// *
// * @return the sql builder
// */
// // //////////////////////////////////////////////////////////////
// public MetaDataSqlBuilder getSqlBuilder() {
// return this.sqlBuilder;
// }
//
// /**
// * Gets the table meta.
// *
// * @return the table meta
// */
// public EntityMetadata getEntityMeta() {
// return this.entityMeta;
// }
//
// /**
// * Insert record.
// *
// * @param record the record
// * @return the string
// */
// // //////////////////////////////////////////////////////////////
// public int insertRecord(final Record record) {
//// callBeforeAddEventOnTriggers(record);
// final JKUpdater updater = new JKEntityUpdater(this.entityMeta) {
// @Override
// public String getStatement() {
// return JKDynamicDataAccess.this.sqlBuilder.buildInsert(record);
// }
//
// @Override
// public void setParamters(final PreparedStatement ps) throws SQLException {
// logger.debug("Set paramters on entity ({})", record.getFieldsValues());
// JKDynamicDataAccess.this.setParamters(record, ps, true);
// }
// };
// final int id = executeUpdate(updater);
// if (record.getIdValueAsInteger() == 0) {
// // this could be false in case of not being aurto increment
// record.setIdValue(id);
// }
// record.setNewRecord(false);
//// callAfterAddEventOnTriggers(record);
// // addInsertAudit(record);
// return id;
// }
//
// /**
// * Insert records.
// *
// * @param records the records
// */
// // //////////////////////////////////////////////////////////////
// public void insertRecords(final List records) {
// if (records.size() > 0) {
// final String insert = this.sqlBuilder.buildFatInsert(records);
// execute(insert);
// }
// }
//
// /**
// * Checks if is id exists.
// *
// * @param id the id
// * @return true, if is id exists
// */
// // //////////////////////////////////////////////////////////////
// public boolean isIdExists(final Object id) {
// try {
// findRecord(id.toString());
// return true;
// } catch (final JKRecordNotFoundException e) {
// // just each the exception
// return false;
// } catch (final JKDataAccessException e) {
// throw e;
// }
// }
//
// /**
// * Lst records.
// *
// * @return the list
// */
// // //////////////////////////////////////////////////////////////
// public List lstRecords() {
// logger.trace("lstRecords : ", entityMeta.getName());
// return lstRecords(createEmptyRecord(false));
// }
//
// /**
// * Lst records.
// *
// * @param filter the filter
// * @return the list
// */
// // //////////////////////////////////////////////////////////////
// public List lstRecords(final Record filter) {
// logger.debug("lstRecords with filter ({})", filter.toString());
// final JKFinder finder = new JKEntityFinder(this.entityMeta) {
// @Override
// public String getQuery() {
// return sqlBuilder.buildFindByFilter(filter);
// }
//
// @Override
// public Object populate(final ResultSet rs) throws SQLException {
// return readRecord(rs, JKDynamicDataAccess.this.entityMeta);
// }
//
// @Override
// public void setParamters(final PreparedStatement ps) throws SQLException {
// }
// };
// return getList(finder);
// }
//
// /**
// * Lst records by report sql.
// *
// * @return the list
// */
// // //////////////////////////////////////////////////////////////
// public List lstRecordsByReportSql() {
// final JKFinder finder = new JKEntityFinder(this.entityMeta) {
//
// @Override
// public String getQuery() {
// return JKDynamicDataAccess.this.entityMeta.getFullQuery();
// }
//
// @Override
// public Object populate(final ResultSet rs) throws SQLException, JKRecordNotFoundException, JKDataAccessException {
// return readRecord(rs, JKDynamicDataAccess.this.entityMeta);
// }
//
// @Override
// public void setParamters(final PreparedStatement ps) throws SQLException {
// }
// };
// return getList(finder);
// }
//
// /**
// * Save record.
// *
// * @param record the record
// * @return true, if successful
// */
// // //////////////////////////////////////////////////////////////
// public boolean saveRecord(final Record record) {
// logger.trace("saveRecord() :", record.toString(true));
// if (record.isNewRecord() && record.isModified()) {
// logger.trace("insert()");
// insertRecord(record);
// return true;
// } else if (!record.isNewRecord() && record.isDeleted()) {
// logger.trace("deleteRecord()");
// deleteRecord(record);
// return true;
// } else if (record.isModified()) {
// logger.trace("updateRecord()");
// updateRecord(record);
// return true;
// }
// // nothing updated
// logger.error("No operation to dine");
// return false;
// }
//
// /**
// * Save records.
// *
// * @param records the records
// */
// // //////////////////////////////////////////////////////////////
// public void saveRecords(final List records) {
// final JKDataAccessException allExceptions = new JKDataAccessException();
// for (final Record record : records) {
// try {
// saveRecord(record);
// } catch (final JKDataAccessException e) {
// allExceptions.add(e);
// }
// }
// }
//
// /**
// * Update record.
// *
// * @param record the record
// */
// // //////////////////////////////////////////////////////////////
// public void updateRecord(final Record record) {
// final JKUpdater updater = new JKEntityUpdater(this.entityMeta) {
//
// @Override
// public String getStatement() {
// return JKDynamicDataAccess.this.sqlBuilder.buildUpdate(record);
// }
//
// @Override
// public void setParamters(final PreparedStatement ps) throws SQLException {
// logger.debug("Set paramters on entity on update({})", record.getFieldsValues());
// JKDynamicDataAccess.this.setParamters(record, ps, false);
// }
// };
// final Record oldRecord = findRecord(record.getIdValue());
//// callBeforeUpdateEventOnTriggers(oldRecord, record);
// executeUpdate(updater);
//// callAfterUpdateEventOnTriggers(oldRecord, record);
// // addUpdateAudit(oldRecord, record);
// }
//
// // private Session getSession() throws DaoException {
// // Session session = tableMeta.getDataSource().createSession();
// // setSession(session);
// // return session;
// // }
// /**
// * Read record.
// *
// * @param rs the rs
// * @param tableMeta the table meta
// * @return the entity record
// * @throws SQLException the SQL exception
// */
// // //////////////////////////////////////////////////////////////////////////////////////
// protected Record readRecord(final ResultSet rs, final EntityMetadata tableMeta) throws SQLException {
// logger.trace("read record");
// final Record record = tableMeta.createEmptyRecord();
// record.setIdValue(rs.getObject(tableMeta.getIdField().getName()));
// logger.trace("Id value ", record.getIdValue());
// // Field idField = record.getIdField();
// // idField.setValue(rs.getString(idField.getMeta().getName()));
// final List fields = record.getFields();
// for (int i = 0; i < fields.size(); i++) {
// final Field field = fields.get(i);
// // the field could be ignored from database
//// if (field.isIncludeInPersisitnce()) {
// final Object value = readResult(rs, field);
// // Object value = rs.getObject(field.getMeta().getName());
// if (value != null) {
// field.setValue(value);
// }
//// }
// }
// record.setNewRecord(false);
// return record;
// }
//
// /**
// * Read result.
// *
// * @param rs the rs
// * @param field the field
// * @return the object
// * @throws SQLException the SQL exception
// */
// // //////////////////////////////////////////////////////////////////////////////////////
// protected Object readResult(final ResultSet rs, final Field field) throws SQLException {
// return getDataSource().getDatabaseType().readResult(rs, field.getMeta().getType(), field.getFieldName());
// }
//
// /**
// * Sets the paramter.
// *
// * @param ps the ps
// * @param index the index
// * @param field the field
// * @throws SQLException the SQL exception
// */
// // //////////////////////////////////////////////////////////////////////////////////////
// protected void setParamter(final PreparedStatement ps, final int index, final Field field) throws SQLException {
// // System.out.println(field.getMeta().getName()+" - "+field.getValue());
// // System.out.println(index + "=" +
// // field.getValueObject()+" type:"+field.getMeta().getType());
// final Object value = field.getValueObject();
// if (value == null || value.toString().equals("")) {
// ps.setObject(index, null);
// return;
// }
// getDataSource().getDatabaseType().setParameter(ps, index, field.getMeta().getType(), field.getValueObject());
//// switch (field.getMeta().getTypeCode()) {
//// case Types.LONGVARBINARY:
//// case Types.BINARY:
//// final byte[] data = (byte[]) field.getValueObject();
//// ps.setBinaryStream(index, new ByteArrayInputStream(data), data.length);
//// break;
////
//// case Types.BOOLEAN:
//// case Types.TINYINT:
//// case Types.BIT:
//// // add support for tiny integers represented as numbers
//// ps.setInt(index, field.getValueAsBoolean() ? 1 : 0);
//// break;
//// case Types.DECIMAL:
//// ps.setDouble(index, field.getValueAsDouble());
//// break;
//// case Types.DATE:
//// ps.setDate(index, new java.sql.Date(((Date) field.getValueObject()).getTime()));
//// break;
//// case Types.TIME:
//// ps.setTime(index, new Time(((Date) field.getValueObject()).getTime()));
//// break;
//// case Types.VARCHAR:
//// case Types.LONGVARCHAR:
//// ps.setString(index, field.getValueObject().toString());
//// break;
//// case Types.INTEGER:
//// ps.setInt(index, field.getValueAsInteger());
//// break;
//// default:
//// // String value=fixStringValue(field.getValue());
//// ps.setObject(index, value);
//// }
// }
//
// /**
// * Sets the paramters.
// *
// * @param record the record
// * @param ps the ps
// * @param includeId the include id
// * @throws SQLException the SQL exception
// */
// // //////////////////////////////////////////////////////////////////////////////////////
// protected void setParamters(final Record record, final PreparedStatement ps, final boolean includeId) throws SQLException {
// int counter = 1;
// if (includeId && record.getIdValueAsInteger() != 0) {
// setParamter(ps, counter++, record.getIdField());
// }
// final List fields = record.getFields();
// for (int i = 0; i < fields.size(); i++) {
// Field field = fields.get(i);
//// if (field.isIncludeInPersisitnce()) {
// try {
// setParamter(ps, counter++, field);
// } catch (final Exception e) {
// final FieldMetadata meta = field.getMeta();
// throw new SQLException("Field " + meta.getName() + " Failed to set paramter with value :" + field.getValueObject() + " with type :"
// + meta.getType(), e);
// }
//// }
// }
// }
//
// /**
// * Adds the column.
// *
// * @param tableName the table typeName
// * @param columnName the column typeName
// * @param typeName the type typeName
// * @param required the required
// */
// public void addColumn(String tableName, String columnName, String typeName, boolean required) {
// StringBuffer buf = new StringBuffer();
// buf.append("ALTER TABLE ").append(tableName).append(JK.NEW_LINE);
// buf.append("ADD COLUMN ").append(columnName).append(" ").append(typeName).append(" ");
// if (required) {
// buf.append("NOT NULL;");
// }
// try {
// executeUpdate(buf.toString());
// } catch (JKRecordNotFoundException e) {
// // it is safe to eat the exception
// JK.fixMe("find better aproach for this");
// }
// }
//
// public void updateFields(EntityMetadata meta, int id, Map map) {
// StringBuffer buf = new StringBuffer();
// buf.append("UPDATE ").append(meta.getName()).append(JK.NEW_LINE);
// buf.append("SET ").append(JK.NEW_LINE);
//
// Set keys = map.keySet();
// int count = 0;
// for (String key : keys) {
// if (count++ > 0) {
// buf.append(" , ");
// }
// buf.append(key).append(" = ? ");
// }
// buf.append(JK.NEW_LINE);
// buf.append(" WHERE id = ? ");
//
// List list = new Vector<>();
// list.addAll(map.values());
// list.add(id);
//
// executeUpdate(buf.toString(), list.toArray());
// }
//
// /**
// * Adds the audit.
// *
// * @param audit the audit
// */
// // // //////////////////////////////////////////////////////////////////////
// // public void addAudit(final JKAudit audit) {
// // logger.trace("Audit : ", audit.toString());
// // final JKUpdater updater = new JKUpdater() {
// //
// // @Override
// // public String getQuery() {
// // return "INSERT INTO sec_audits
// // (audit_id,user_record_id,audit_date,audit_type_id,record_id,record_name,old_value,new_value,description,gui)
// // VALUES(?,?,?,?,?,?,?,?,?,?)";
// // }
// //
// // @Override
// // public void setParamters(final PreparedStatement ps) throws SQLException,
// // JKDataAccessException {
// // int counter = 1;
// // ps.setLong(counter++, getNextId("sec_audits", "audit_id"));
// // ps.setInt(counter++, audit.getUser().getUserRecordId());
// // ps.setTimestamp(counter++, new Timestamp(getSystemDate().getTime()));
// // ps.setInt(counter++, audit.getAuditType().getAuditType());
// // ps.setObject(counter++, audit.getBusinessRecordId());
// // ps.setString(counter++, audit.getTableName());
// // ps.setString(counter++, audit.getOldValue());
// // ps.setString(counter++, audit.getNewValue());
// // ps.setString(counter++, audit.getDescription());
// // ps.setString(counter++, audit.getGui());
// // }
// // };
// // executeUpdate(updater);
// // }
//
//}