package fr.ifremer.quadrige3.synchro.service.data;
   
   /*-
    * #%L
    * Quadrige3 Core :: Quadrige3 Synchro Core
    * $Id:$
    * $HeadURL:$
    * %%
    * Copyright (C) 2017 Ifremer
   * %%
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Affero General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU Affero General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   * #L%
   */
  
  import com.google.common.collect.*;
  import fr.ifremer.common.synchro.SynchroTechnicalException;
  import fr.ifremer.common.synchro.config.SynchroConfiguration;
  import fr.ifremer.common.synchro.dao.DaoFactory;
  import fr.ifremer.common.synchro.dao.SynchroTableDao;
  import fr.ifremer.common.synchro.meta.SynchroDatabaseMetadata;
  import fr.ifremer.common.synchro.meta.SynchroTableMetadata;
  import fr.ifremer.common.synchro.service.*;
  import fr.ifremer.common.synchro.type.ProgressionModel;
  import fr.ifremer.quadrige3.core.config.QuadrigeConfiguration;
  import fr.ifremer.quadrige3.core.dao.ObjectTypes;
  import fr.ifremer.quadrige3.core.dao.system.synchronization.SynchronizationStatus;
  import fr.ifremer.quadrige3.core.dao.technical.Assert;
  import fr.ifremer.quadrige3.core.dao.technical.Daos;
  import fr.ifremer.quadrige3.core.dao.technical.Dates;
  import fr.ifremer.quadrige3.core.dao.technical.hibernate.ConfigurationHelper;
  import fr.ifremer.quadrige3.core.exception.QuadrigeTechnicalException;
  import fr.ifremer.quadrige3.synchro.meta.DatabaseColumns;
  import fr.ifremer.quadrige3.synchro.meta.data.DataSynchroTables;
  import fr.ifremer.quadrige3.synchro.service.AbstractSynchroDatabaseConfiguration;
  import fr.ifremer.quadrige3.synchro.service.SynchroDirection;
  import oracle.jdbc.OracleConnection;
  import org.apache.commons.collections4.CollectionUtils;
  import org.apache.commons.collections4.MapUtils;
  import org.apache.commons.io.IOUtils;
  import org.apache.commons.lang3.StringUtils;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  import org.hibernate.dialect.Dialect;
  import org.postgis.PGgeometry;
  import org.postgresql.PGConnection;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.context.annotation.Lazy;
  import org.springframework.stereotype.Service;
  
  import javax.sql.DataSource;
  import java.io.File;
  import java.sql.Connection;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.sql.Timestamp;
  import java.util.*;
  
  import static org.nuiton.i18n.I18n.t;
  
  /**
   * <p>
   * DataSynchroServiceImpl class.
   * </p>
   *
   */
  @Service("dataSynchroService")
  @Lazy
  public class DataSynchroServiceImpl
  	extends SynchroServiceImpl<DataSynchroDatabaseConfiguration, DataSynchroContext>
  	implements DataSynchroService {
  
  	private static final Log log = LogFactory.getLog(DataSynchroServiceImpl.class);
  
  	private static final boolean DISABLE_INTEGRITY_CONSTRAINTS = false;
  	private static final boolean ALLOW_MISSING_OPTIONAL_COLUMN = true;
  	private static final boolean ALLOW_ADDITIONAL_MANDATORY_COLUMN_IN_SOURCE_SCHEMA = false;
  	private static final boolean KEEP_WHERE_CLAUSE_ON_QUERIES_BY_FKS = true;
  
  	private final int exportUpdateDateDelayInSecond;
  
  	/**
  	 * <p>
  	 * Constructor for DataSynchroServiceImpl.
  	 * </p>
  	 *
  	 * @param dataSource
  	 *            a {@link javax.sql.DataSource} object.
  	 * @param config
 	 *            a {@link fr.ifremer.common.synchro.config.SynchroConfiguration} object.
 	 */
 	@Autowired
 	public DataSynchroServiceImpl(DataSource dataSource, SynchroConfiguration config) {
 		super(dataSource, config,
 				DISABLE_INTEGRITY_CONSTRAINTS,
 				ALLOW_MISSING_OPTIONAL_COLUMN,
 				ALLOW_ADDITIONAL_MANDATORY_COLUMN_IN_SOURCE_SCHEMA,
 				KEEP_WHERE_CLAUSE_ON_QUERIES_BY_FKS);
 		exportUpdateDateDelayInSecond = QuadrigeConfiguration.getInstance().getExportDataUpdateDateDelayInSecond();
 	}
 
 	/**
 	 * <p>
 	 * Constructor for DataSynchroServiceImpl.
 	 * </p>
 	 */
 	public DataSynchroServiceImpl() {
 		super(DISABLE_INTEGRITY_CONSTRAINTS,
 				ALLOW_MISSING_OPTIONAL_COLUMN,
 				ALLOW_ADDITIONAL_MANDATORY_COLUMN_IN_SOURCE_SCHEMA,
 				KEEP_WHERE_CLAUSE_ON_QUERIES_BY_FKS);
 		exportUpdateDateDelayInSecond = QuadrigeConfiguration.getInstance().getExportDataUpdateDateDelayInSecond();
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public DataSynchroContext createSynchroContext(File sourceDbDirectory, SynchroDirection direction, int userId) {
 		Assert.notNull(sourceDbDirectory);
 		Assert.isTrue(sourceDbDirectory.isDirectory());
 		return createSynchroContext(sourceDbDirectory, direction, userId, null, true, true);
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public DataSynchroContext createSynchroContext(File sourceDbDirectory, SynchroDirection direction, int userId,
 			Timestamp lastSynchronizationDate) {
 		return createSynchroContext(sourceDbDirectory, direction, userId, lastSynchronizationDate, true, true);
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public DataSynchroContext createSynchroContext(File sourceDbDirectory, SynchroDirection direction, int userId,
 			Timestamp lastSynchronizationDate, boolean enableDelete, boolean enableInsertUpdate) {
 
 		DataSynchroContext context = super.createSynchroContext(sourceDbDirectory, DataSynchroTables.getImportTablesIncludes());
 		// Make sure q2 connection properties are always used
 		context.getTarget().putAllProperties(QuadrigeConfiguration.getInstance().getConnectionProperties());
 		context.setDirection(direction);
 		context.setUserId(userId);
 		context.setLastSynchronizationDate(lastSynchronizationDate);
 		context.setEnableDelete(enableDelete);
 		context.setEnableInsertOrUpdate(enableInsertUpdate);
 		initContext(context);
 		return context;
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public DataSynchroContext createSynchroContext(Properties sourceConnectionProperties, SynchroDirection direction, int userId) {
 		return createSynchroContext(sourceConnectionProperties, direction, userId, null, true, true);
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public DataSynchroContext createSynchroContext(Properties sourceConnectionProperties, SynchroDirection direction, int userId,
 			Timestamp lastSynchronizationDate) {
 		return createSynchroContext(sourceConnectionProperties, direction, userId, lastSynchronizationDate, true, true);
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public DataSynchroContext createSynchroContext(Properties sourceConnectionProperties, SynchroDirection direction, int userId,
 			Timestamp lastSynchronizationDate, boolean enableDelete, boolean enableInsertUpdate) {
 		Assert.notNull(sourceConnectionProperties);
 
 		DataSynchroContext context = super.createSynchroContext(sourceConnectionProperties, DataSynchroTables.getImportTablesIncludes());
 		// Make sure q2 connection properties are always used
 		context.getTarget().putAllProperties(QuadrigeConfiguration.getInstance().getConnectionProperties());
 		context.setDirection(direction);
 		context.setUserId(userId);
 		context.setLastSynchronizationDate(lastSynchronizationDate);
 		context.setEnableDelete(enableDelete);
 		context.setEnableInsertOrUpdate(enableInsertUpdate);
 		initContext(context);
 		return context;
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public void prepare(DataSynchroContext synchroContext) {
 		Assert.isInstanceOf(DataSynchroContext.class, synchroContext,
 				String.format("The context must be a instance of %s", DataSynchroContext.class.getName()));
 
 		SynchroResult result = synchroContext.getResult();
 		SynchroDirection direction = synchroContext.getDirection();
 
 		DataSynchroDatabaseConfiguration target = synchroContext.getTarget();
 		DataSynchroDatabaseConfiguration source = synchroContext.getSource();
 
 		// If server DB -> Temp DB
 		if (direction == SynchroDirection.IMPORT_SERVER2TEMP) {
 
 			// Ignore some not used columns, on measurement tables
 			source.excludeMeasurementUnusedColumns();
 
 			// Set target database as mirror AND temporary
 			target.setIsMirrorDatabase(true);
 
 			// Ignore some not used columns
 			target.excludeUnusedColumns();
 
 			// Disable integrity constraints
 			{
 				disableIntegrityConstraints(target.getConnectionProperties(), result);
 				if (!result.isSuccess()) {
 					return;
 				}
 
 				// No need to check unicity of input rows (server rows are safe)
 				source.setCheckUniqueConstraintBetweenInputRows(false);
 				target.setCheckUniqueConstraintBetweenInputRows(false);
 			}
 
 			// Compute the default period, if need
 			if (synchroContext.getDataEndDate() == null) {
 				fillDefaultDataPeriod(synchroContext);
 			}
 
 			// Compute the default PK restriction, if need
 			if (synchroContext.getPkIncludes() == null) {
 				fillDefaultPkIncludes(synchroContext);
 			}
 
 			// Set photo directory from configuration for the source
 			if (source.getDbPhotoDirectory() == null) {
 				source.setDbPhotoDirectory(QuadrigeConfiguration.getInstance().getDbPhotoDirectory());
 			}
 		}
 
 		// If Temp DB -> Local DB
 		else if (direction == SynchroDirection.IMPORT_TEMP2LOCAL) {
 
 			// Set target database as not a Mirror
 			target.setIsMirrorDatabase(false);
 
 			// No need to check unicity of input rows (rows come from server and are safe)
 			source.setCheckUniqueConstraintBetweenInputRows(false);
 			target.setCheckUniqueConstraintBetweenInputRows(false);
 
             // Set photo directory from configuration for the target
 			if (target.getDbPhotoDirectory() == null) {
 				target.setDbPhotoDirectory(QuadrigeConfiguration.getInstance().getDbPhotoDirectory());
 			}
 		}
 
 		// If server DB -> Local DB
 		if (direction == SynchroDirection.IMPORT_NO_TEMP) {
 			// TODO : add implement
 			throw new QuadrigeTechnicalException("Direction IMPORT_NO_TEMP not implemented yet for Data tables");
 		}
 
 		// If local -> temporary database
 		else if (direction == SynchroDirection.EXPORT_LOCAL2TEMP) {
 
 			// Set target database as mirror AND temporary
 			target.setIsMirrorDatabase(true);
 
 			// Disable integrity constraints
 			{
 				disableIntegrityConstraints(target.getConnectionProperties(), result);
 				if (!result.isSuccess()) {
 					return;
 				}
 			}
 
 			// No need to check unicity of input rows (will be done on temp->server)
 			source.setCheckUniqueConstraintBetweenInputRows(false);
 			target.setCheckUniqueConstraintBetweenInputRows(false);
 
             // Set photo directory from configuration for the source
 			if (source.getDbPhotoDirectory() == null) {
 				source.setDbPhotoDirectory(QuadrigeConfiguration.getInstance().getDbPhotoDirectory());
 			}
 		}
 
 		// If Temp DB -> server DB
 		else if (direction == SynchroDirection.EXPORT_TEMP2SERVER) {
 
 			// Ignore some not used columns
 			source.setFullMetadataEnable(true);
 			source.excludeUnusedColumns();
 
 			// Set target database as not a Mirror
 			target.setIsMirrorDatabase(false);
 			target.setFullMetadataEnable(false);
 
 			// Fill system timestamp into context, and copy it to source
 			fillSystemTimestampWithDelay(result, target);
 			source.setSystemTimestamp(target.getSystemTimestamp());
 
             // Always set photo directory from configuration for the target
 			if (target.getDbPhotoDirectory() == null) {
 				target.setDbPhotoDirectory(QuadrigeConfiguration.getInstance().getDbPhotoDirectory());
 			}
 		}
 
 		// If Local DB -> file
 		else if (direction == SynchroDirection.EXPORT_LOCAL2FILE) {
 
 			// Set target database as a Mirror
 			target.setIsMirrorDatabase(true);
 		}
 
 		// If file -> Local DB
 		else if (direction == SynchroDirection.IMPORT_FILE2LOCAL) {
 
 			// Set target database as a NOT a mirror (to avoid constraints disabling)
 			target.setIsMirrorDatabase(false);
 		}
 
 		super.prepare(synchroContext);
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public void synchronize(DataSynchroContext synchroContext) {
 		Assert.isInstanceOf(DataSynchroContext.class, synchroContext,
 				String.format("The context must be a instance of %s", DataSynchroContext.class.getName()));
 
 		SynchroResult result = synchroContext.getResult();
 		List<Multimap<String, String>> pkIncludesListForBatch = null;
 
 		DataSynchroDatabaseConfiguration target = synchroContext.getTarget();
 		DataSynchroDatabaseConfiguration source = synchroContext.getSource();
 
 		// If server DB -> temp DB
 		if (synchroContext.getDirection() == SynchroDirection.IMPORT_SERVER2TEMP) {
 
 			// Enable protected columns
 			target.removeColumnExclude(target.getColumnSynchronizationStatus());
 			target.removeColumnExclude(target.getColumnRemoteId());
 
 			// Disable integrity constraints
 			{
 				disableIntegrityConstraints(synchroContext.getTarget().getConnectionProperties(), result);
 				if (!result.isSuccess()) {
 					return;
 				}
 			}
 
 			// Use Batch (Mantis #42337)
 			if (synchroContext.isEnableInsertOrUpdate()
 					&& (synchroContext.getPkIncludes() == null || synchroContext.getPkIncludes().isEmpty())) {
 				pkIncludesListForBatch = computePkIncludesListForBatch(result, synchroContext, true);
 			}
 
 		}
 
 		// If temp DB -> server DB
 		else if (synchroContext.getDirection() == SynchroDirection.EXPORT_TEMP2SERVER) {
 
 			// Enable protected columns
 			source.removeColumnExclude(source.getColumnSynchronizationStatus());
 			source.removeColumnExclude(source.getColumnRemoteId());
 		}
 
 		// If Temp DB -> Local DB
 		else if (synchroContext.getDirection() == SynchroDirection.IMPORT_TEMP2LOCAL) {
 
 			// Use batch (split import - see mantis #30765)
 			// only if:
 			// - insert/update are enable
 			// - pk filter not already exists
 			if (synchroContext.isEnableInsertOrUpdate()
 					&& (synchroContext.getPkIncludes() == null || synchroContext.getPkIncludes().isEmpty())) {
 				pkIncludesListForBatch = computePkIncludesListForBatch(result, synchroContext, false);
 			}
 		}
 
 		boolean synchronizeUsingBatch = CollectionUtils.isNotEmpty(pkIncludesListForBatch);
 
 		// Synchronize all
 		if (!synchronizeUsingBatch
 				|| !synchroContext.isEnableInsertOrUpdate()) {
 			super.synchronize(synchroContext);
 		}
 
 		// Synchronize using batch (see mantis #30765)
 		else {
 			synchronizeUsingBatch(synchroContext, pkIncludesListForBatch);
 		}
 	}
 
 	/* -- Internal methods -- */
 
 	/** {@inheritDoc} */
 	@Override
 	protected void prepareRootTable(
 			DaoFactory sourceDaoFactory,
 			DaoFactory targetDaoFactory,
 			SynchroTableMetadata table,
 			DataSynchroContext context,
 			SynchroResult result) throws SQLException {
 
 		// Prepare from super class (insert and update)
 		if (context.isEnableInsertOrUpdate()) {
 			super.prepareRootTable(sourceDaoFactory,
 					targetDaoFactory,
 					table,
 					context,
 					result);
 
 			// if SURVEY has update, evaluate photo quantity
 			if (table.getName().toUpperCase().equals(DataSynchroTables.SURVEY.name())
 					&& context.isEnablePhoto()
 					&& result.getNbRows(DataSynchroTables.SURVEY.name()) > 0
 					&& result.getNbRows(DataSynchroTables.PHOTO.name()) == 0) {
 				preparePhotoTable(sourceDaoFactory, context, result);
 			}
 		}
 
 		// Add deleted items
 		if (context.isEnableDelete()) {
 			prepareDeletedRootTable(sourceDaoFactory,
 					targetDaoFactory,
 					table,
 					context,
 					result);
 		}
 	}
 
 	/**
 	 * Count number of row to delete, for the given table
 	 *
 	 * @param sourceDaoFactory
 	 *            a {@link fr.ifremer.common.synchro.dao.DaoFactory} object.
 	 * @param targetDaoFactory
 	 *            a {@link fr.ifremer.common.synchro.dao.DaoFactory} object.
 	 * @param table
 	 *            a {@link fr.ifremer.common.synchro.meta.SynchroTableMetadata} object.
 	 * @param context
 	 *            a {@link fr.ifremer.common.synchro.service.SynchroContext} object.
 	 * @param result
 	 *            a {@link fr.ifremer.common.synchro.service.SynchroResult} object.
 	 * @throws java.sql.SQLException
 	 *             if any.
 	 */
 	protected void prepareDeletedRootTable(
 			DaoFactory sourceDaoFactory,
 			DaoFactory targetDaoFactory,
 			SynchroTableMetadata table,
 			DataSynchroContext context,
 			SynchroResult result) throws SQLException {
 
 		String tableName = table.getName();
 		Set<String> objectTypeFks = ObjectTypes.getObjectTypeFromTableName(tableName);
 
 		if (CollectionUtils.isEmpty(objectTypeFks)) {
 			return;
 		}
 
 		SynchroTableDao dihSourceDao = sourceDaoFactory.getSourceDao(DataSynchroTables.DELETED_ITEM_HISTORY.name());
 
 		List<List<Object>> columnValues = Lists.newArrayListWithCapacity(objectTypeFks.size());
 		for (String objectTypeFk : objectTypeFks) {
 			columnValues.add(ImmutableList.of(objectTypeFk));
 		}
 
 		// Read rows of DELETED_ITEM_HISTORY (from the temp DB)
 		Map<String, Object> bindings = createSelectBindingsForTable(context, DataSynchroTables.DELETED_ITEM_HISTORY.name());
 		long count = dihSourceDao.countDataByFks(
 				ImmutableSet.of(DatabaseColumns.OBJECT_TYPE_CD.name()),
 				columnValues,
 				bindings
 				);
 		if (count > 0) {
 			result.addRows(tableName, (int) count);
 		}
 	}
 
 	protected void preparePhotoTable(
 			DaoFactory sourceDaoFactory,
 			DataSynchroContext context,
 			SynchroResult result) throws SQLException {
 
 		SynchroTableDao surveySourceDao = sourceDaoFactory.getSourceDao(DataSynchroTables.SURVEY.name());
 		SynchroTableDao photoSourceDao = sourceDaoFactory.getSourceDao(DataSynchroTables.PHOTO.name());
 
 		// Gets survey Pks
 		Map<String, Object> bindings = createSelectBindingsForTable(context, DataSynchroTables.SURVEY.name());
 		List<List<Object>> surveyPks = new ArrayList<>();
 		try (ResultSet resultSet = surveySourceDao.getData(bindings)) {
 			while (resultSet.next()) surveyPks.add(surveySourceDao.getPk(resultSet));
 		}
 
 		// Count photo to prepare
 		long photoCount = photoSourceDao.countDataByFks(
 				ImmutableSet.of(DatabaseColumns.SURVEY_ID.name()),
 				surveyPks,
 				new HashMap<>()
 				);
 
 		result.addRows(DataSynchroTables.PHOTO.name(), (int) photoCount);
 
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	protected Map<String, Object> createDefaultSelectBindings(DataSynchroContext context) {
 
 		Map<String, Object> bindings = super.createDefaultSelectBindings(context);
 
 		// Fill with the current person_fk (need for Dao and insert into TempQueryParemeter)
 		bindings.put("userId", context.getUserId());
 
 		// Fill the period (using in interceptor queries - see SurveyInterceptor)
 		if (context.getDataStartDate() != null) {
 			bindings.put("startDate", new Timestamp(context.getDataStartDate().getTime()));
 		}
 		// (endDate could be null - see Mantis #27242)
 		if (context.getDataEndDate() != null) {
 			bindings.put("endDate", new Timestamp(context.getDataEndDate().getTime()));
 		}
 
 		return bindings;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 *
 	 * Override the default method, to disable this binding: <br/>
 	 * <code>bindings.put(SynchroTableMetadata.UPDATE_DATE_BINDPARAM, context.getResult().getUpdateDate(tableName))</code>
 	 */
 	@Override
 	protected Map<String, Object> createSelectBindingsForTable(DataSynchroContext context, String tableName) {
 		// Get defaults binding from context
 		Map<String, Object> bindings = Maps.newHashMap(getSelectBindings(context));
 
 		Timestamp lastSynchronizationDate = context.getLastSynchronizationDate();
 		boolean notEmptyTargetTable = (context.getResult().getUpdateDate(tableName) != null);
 		boolean enableUpdateDateFilter = (lastSynchronizationDate != null)
 				&& (context.getTarget().isMirrorDatabase() || notEmptyTargetTable);
 
 		if (enableUpdateDateFilter) {
 			bindings.put(SynchroTableMetadata.UPDATE_DATE_BINDPARAM, lastSynchronizationDate);
 		}
 
 		return bindings;
 	}
 
 	/**
 	 * <p>
 	 * fillSystemTimestampWithDelay.
 	 * </p>
 	 *
 	 * @param result
 	 *            a {@link fr.ifremer.common.synchro.service.SynchroResult} object.
 	 * @param databaseConfiguration
 	 *            a {@link fr.ifremer.common.synchro.service.SynchroDatabaseConfiguration} object.
 	 */
 	protected void fillSystemTimestampWithDelay(SynchroResult result, SynchroDatabaseConfiguration databaseConfiguration) {
 
 		result.getProgressionModel().setMessage(t("quadrige3.synchro.synchronizeData.initSystemTimestamp"));
 		if (log.isInfoEnabled()) {
 			log.info(t("quadrige3.synchro.synchronizeData.initSystemTimestamp"));
 		}
 
 		Connection connection = null;
 		try {
 			connection = createConnection(databaseConfiguration);
 			Dialect dialect = databaseConfiguration.getDialect();
 			Timestamp currentTimestamp = Daos.getDatabaseCurrentTimestamp(connection, dialect);
 
 			// Add a delay, to allow concurrent importation to re-import this data later
 			Dates.addSeconds(currentTimestamp, exportUpdateDateDelayInSecond);
 
 			if (log.isDebugEnabled()) {
 				log.debug(String.format("Current timestamp: %s", currentTimestamp));
 			}
 
 			databaseConfiguration.setSystemTimestamp(currentTimestamp);
 		} catch (QuadrigeTechnicalException | SQLException e) {
 			result.setError(e);
 		} finally {
 			closeSilently(connection);
 		}
 	}
 
 	/**
 	 * <p>
 	 * fillDefaultDataPeriod.
 	 * </p>
 	 *
 	 * @param dataSynchroContext
 	 *            a {@link fr.ifremer.quadrige3.synchro.service.data.DataSynchroContext} object.
 	 */
 	protected void fillDefaultDataPeriod(DataSynchroContext dataSynchroContext) {
 		int nbYearDataHistory = QuadrigeConfiguration.getInstance().getImportNbYearDataHistory();
 
 		// Compute the start date : X years ago, starting at January 1th
 		Date dataStartDate = Dates.addYears(new Date(), -1 * nbYearDataHistory);
 		dataStartDate = Dates.truncate(dataStartDate, Calendar.YEAR);
 		dataSynchroContext.setDataStartDate(dataStartDate);
 
 		// Compute the end : last hour of the day
 		Date dataEndDate = Dates.lastSecondOfTheDay(new Date());
 		dataSynchroContext.setDataEndDate(dataEndDate);
 	}
 
 	/**
 	 * <p>
 	 * fillDefaultPkIncludes.
 	 * </p>
 	 *
 	 * @param dataSynchroContext
 	 *            a {@link fr.ifremer.quadrige3.synchro.service.data.DataSynchroContext} object.
 	 */
 	protected void fillDefaultPkIncludes(DataSynchroContext dataSynchroContext) {
 		String confProperty = QuadrigeConfiguration.getInstance().getImportDataPkIncludes();
 		Multimap<String, String> pkIncludes = ConfigurationHelper.getMultimap(confProperty);
 		dataSynchroContext.setPkIncludes(pkIncludes);
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	protected List<SynchroTableOperation> getRootOperations(
 			DaoFactory sourceDaoFactory,
 			DaoFactory targetDaoFactory,
 			SynchroDatabaseMetadata dbMeta,
 			DataSynchroContext context) throws SQLException {
 		List<SynchroTableOperation> result = Lists.newArrayList();
 
 		// Add delete items history operation - if enable in context
 		// NOTE : deletion should be done BEFORE insertion (to avoid duplication error)
 		if (context.isEnableDelete()
 				&& (context.getDirection() == SynchroDirection.EXPORT_TEMP2SERVER
 				|| context.getDirection() == SynchroDirection.IMPORT_TEMP2LOCAL)) {
 
 			Collection<SynchroTableOperation> deletedItemOperations = getDeleteOperations(sourceDaoFactory, targetDaoFactory, dbMeta, context);
 			result.addAll(deletedItemOperations);
 		}
 
 		// Add default operations (insert/update) - if enable in context
 		if (context.isEnableInsertOrUpdate()) {
 			Collection<SynchroTableOperation> defaultOperations = super.getRootOperations(sourceDaoFactory, targetDaoFactory, dbMeta, context);
 			result.addAll(defaultOperations);
 		}
 
 		return result;
 	}
 
 	private Collection<SynchroTableOperation> getDeleteOperations(
 			DaoFactory sourceDaoFactory,
 			DaoFactory targetDaoFactory,
 			SynchroDatabaseMetadata dbMeta,
 			DataSynchroContext context) throws SQLException {
 		Assert.isTrue(dbMeta.getConfiguration().isFullMetadataEnable());
 
 		Deque<SynchroTableOperation> result = Queues.newArrayDeque();
 
 		boolean shouldDeleteUsingRemoteId = (context.getDirection() == SynchroDirection.IMPORT_TEMP2LOCAL);
 		SynchroTableDao dihSourceDao = sourceDaoFactory.getSourceDao(DataSynchroTables.DELETED_ITEM_HISTORY.name());
 		DataSynchroDatabaseConfiguration target = context.getTarget();
 		Set<String> includedDataTables = DataSynchroTables.getImportTablesIncludes();
 		if (CollectionUtils.isEmpty(includedDataTables)) {
 			return result;
 		}
 
 		// use a map of operation by table name to avoid large amount of operation of single delete, prefer one operation with many deletes
 		Map<String, SynchroTableOperation> operationByTableName = new HashMap<>();
 
 		// Read rows of DELETED_ITEM_HISTORY (from the temp DB)
 		Map<String, Object> bindings = createSelectBindingsForTable(context, DataSynchroTables.DELETED_ITEM_HISTORY.name());
 		ResultSet dihResultSet = dihSourceDao.getData(bindings);
 
 		List<Object> dihIdsToRemove = Lists.newArrayList();
 
 		try {
 			dihResultSet = dihSourceDao.getData(bindings);
 
 			while (dihResultSet.next()) {
 
 				long dihId = dihResultSet.getLong(DatabaseColumns.DEL_ITEM_HIST_ID.name());
 				String objectType = dihResultSet.getString(DatabaseColumns.OBJECT_TYPE_CD.name());
 				String tableName = ObjectTypes.getTableNameFromObjectType(objectType);
 
 				boolean isDataTable = StringUtils.isNotBlank(tableName)
 						&& includedDataTables.contains(tableName.toUpperCase());
 
 				if (isDataTable) {
 					SynchroTableDao targetDao = targetDaoFactory.getSourceDao(tableName);
 					SynchroTableMetadata table = targetDao.getTable();
 
 					String objectCode = dihResultSet.getString(DatabaseColumns.OBJECT_CD.name());
 					String objectId = dihResultSet.getString(DatabaseColumns.OBJECT_ID.name());
 
 					// Delete by a PK (id or code)
 					if (StringUtils.isNotBlank(objectCode) || StringUtils.isNotBlank(objectId)) {
 						List<Object> pk = StringUtils.isNotBlank(objectCode)
 								? ImmutableList.of(objectCode)
 								: ImmutableList.of(objectId);
 
 						boolean hasChildTables = targetDao.getTable().hasChildJoins();
 
 						// get existing operation or create a new one
 						SynchroTableOperation operation = operationByTableName.get(tableName);
 						if (operation == null) {
 							operation = new SynchroTableOperation(tableName, context);
 							operationByTableName.put(tableName, operation);
 							operation.setEnableProgress(true);
 							result.add(operation);
 						}
 
 						// If import to local DB : object_id = table's remote_id
 						if (shouldDeleteUsingRemoteId) {
 							if (table.getColumnIndex(target.getColumnRemoteId()) != -1) {
 								operation.addChildrenToDeleteFromOneColumn(tableName, target.getColumnRemoteId(), pk);
 
 								// Make sure DIH is deleted, if exported from this local DB
 								dihIdsToRemove.add(dihId);
 							}
 							else if (log.isWarnEnabled()) {
 								// This should never happen !
 								log.warn(String
 										.format("[%s] Found deleted items on table [%s] (pk: [%s]) but no column [%s] exists on this table. Skipping this deleted items.",
 												DataSynchroTables.DELETED_ITEM_HISTORY.name(),
 												tableName,
 												SynchroTableMetadata.toPkStr(pk),
 												target.getColumnRemoteId()
 										));
 							}
 
 							// Children table should NOT be add here - mantis #23799
 							// This is done later, inside method SynchroServiceImpl.synchronizeChildrenToDeletes()
 						}
 
 						// If export to server DB : object_id = table's id
 						else {
 							operation.addMissingDelete(pk);
 
 							// If has children, add child deletion to result
 							if (hasChildTables) {
 								addDeleteChildrenToDeque(table, ImmutableList.of(pk), result, context);
 							}
 						}
 					}
 				}
 			}
 		} finally {
 			Daos.closeSilently(dihResultSet);
 		}
 
 		if (CollectionUtils.isNotEmpty(dihIdsToRemove)) {
 			SynchroTableOperation operation = new SynchroTableOperation(DataSynchroTables.DELETED_ITEM_HISTORY.name(), context);
 			operation.addChildrenToDeleteFromOneColumn(DataSynchroTables.DELETED_ITEM_HISTORY.name(), target.getColumnRemoteId(),
 					dihIdsToRemove);
 			result.add(operation);
 		}
 
 		return result;
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	protected void resolveTableRow(SynchroTableMetadata table,
 			RejectedRow reject,
 			RejectedRow.ResolveStrategy rejectStrategy,
 			DaoFactory daoFactory,
 			SynchroTableOperation operation,
 			DataSynchroContext context,
 			SynchroResult result) {
 
 		// Execute default implementation
 		super.resolveTableRow(
 				table,
 				reject,
 				rejectStrategy,
 				daoFactory,
 				operation,
 				context,
 				result
 				);
 
 		DataSynchroDatabaseConfiguration target = context.getTarget();
 
 		boolean hasSynchronizationStatus = table.getColumnNames().contains(target.getColumnSynchronizationStatus());
 
 		// Add a special case for Exportation :
 		// when keep local data : make sure all entity will be re-export,
 		// by changing synchronizaton_status to READ_TO_SYNC
 		if (hasSynchronizationStatus
 				&& context.getDirection().isExport()
 				&& reject.cause == RejectedRow.Cause.BAD_UPDATE_DATE
 				&& rejectStrategy == RejectedRow.ResolveStrategy.KEEP_LOCAL) {
 
 			operation.addMissingColumnUpdate(
 					target.getColumnSynchronizationStatus(),
 					reject.targetPkStr,
 					SynchronizationStatus.READY_TO_SYNCHRONIZE.getValue());
 		}
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	protected void detachRows(
 			SynchroTableDao targetDao,
 			List<List<Object>> pks,
 			DataSynchroContext context,
 			SynchroResult result,
 			Deque<SynchroTableOperation> pendingOperations)
 			throws SQLException {
 
 		// Call default implementation
 		super.detachRows(targetDao, pks, context, result, pendingOperations);
 
 		// Then override to reset remote_id:
 
 		DataSynchroDatabaseConfiguration target = context.getTarget();
 		SynchroTableMetadata table = targetDao.getTable();
 		boolean hasSynchronizationStatus = table.getColumnNames().contains(target.getColumnSynchronizationStatus());
 		boolean hasRemoteId = table.getColumnNames().contains(target.getColumnRemoteId());
 		if (!hasSynchronizationStatus && !hasRemoteId) {
 			return;
 		}
 
 		String tableName = table.getName();
 		String tablePrefix = table.getTableLogPrefix() + " - " + result.getNbRows(tableName);
 		String readyToSynchronize = SynchronizationStatus.READY_TO_SYNCHRONIZE.getValue();
 		int countR = 0;
 
 		// For each pk to detach: reset remote_id
 		if (hasRemoteId) {
 			for (List<Object> pk : pks) {
 				targetDao.executeUpdateColumn(target.getColumnRemoteId(), pk, null);
 				countR++;
 				reportProgress(result, targetDao, countR, tablePrefix);
 			}
 		}
 
 		// For each pk to detach: set synchronization_status to READY_TO_SYNC
 		// (in case the status was SYNC)
 		if (hasSynchronizationStatus) {
 			for (List<Object> pk : pks) {
 				targetDao.executeUpdateColumn(target.getColumnSynchronizationStatus(), pk, readyToSynchronize);
 				countR++;
 				reportProgress(result, targetDao, countR, tablePrefix);
 			}
 		}
 
 		if (countR == 0) {
 			return;
 		}
 
 		targetDao.flush();
 
 		result.addTableName(tableName);
 		result.addUpdates(tableName, countR);
 
 		if (log.isInfoEnabled()) {
 			log.info(String.format("%s done: %s (detachment: %s)", tablePrefix, countR, countR));
 		}
 
 		if (targetDao.getCurrentOperation().isEnableProgress()) {
 			result.getProgressionModel().increments(countR % batchSize);
 		}
 
 	}
 
 	/* -- internal methods -- */
 
 	/**
 	 * <p>
 	 * initContext.
 	 * </p>
 	 *
 	 * @param context
 	 *            a {@link fr.ifremer.common.synchro.service.SynchroContext} object.
 	 */
 	protected void initContext(DataSynchroContext context) {
 
 		// Set update date
 		context.getSource().setColumnUpdateDate(DatabaseColumns.UPDATE_DT.name().toLowerCase());
 		context.getTarget().setColumnUpdateDate(DatabaseColumns.UPDATE_DT.name().toLowerCase());
 
 		DataSynchroDatabaseConfiguration source = context.getSource();
 		DataSynchroDatabaseConfiguration target = context.getTarget();
 
 		// Set the column remote_id name
 		source.setColumnRemoteId(DatabaseColumns.REMOTE_ID.name().toLowerCase());
 		target.setColumnRemoteId(DatabaseColumns.REMOTE_ID.name().toLowerCase());
 
 		// Set the column synchronization_status name
 		source.setColumnSynchronizationStatus(DatabaseColumns.SYNCHRONIZATION_STATUS.name().toLowerCase());
 		target.setColumnSynchronizationStatus(DatabaseColumns.SYNCHRONIZATION_STATUS.name().toLowerCase());
 
 		// Set allowed missing mandatory columns for measurements (par_cd, matrix_id, fraction_id, method_id and unit_id removed from model)
 		Multimap<String, String> allowedMissingMandatoryColumns = ArrayListMultimap.create();
 		List<String> pmfmColumns = ImmutableList.of(
 				DatabaseColumns.PAR_CD.name().toUpperCase(),
 				DatabaseColumns.MATRIX_ID.name().toUpperCase(),
 				DatabaseColumns.FRACTION_ID.name().toUpperCase(),
 				DatabaseColumns.METHOD_ID.name().toUpperCase(),
 				DatabaseColumns.UNIT_ID.name().toUpperCase()
 		);
 		allowedMissingMandatoryColumns.putAll(DataSynchroTables.MEASUREMENT.name().toUpperCase(), pmfmColumns);
 		allowedMissingMandatoryColumns.putAll(DataSynchroTables.TAXON_MEASUREMENT.name().toUpperCase(), pmfmColumns);
 		allowedMissingMandatoryColumns.putAll(DataSynchroTables.MEASUREMENT_FILE.name().toUpperCase(), pmfmColumns);
 		setAllowedMissingMandatoryColumns(allowedMissingMandatoryColumns);
 
 		// Set TEMP_QUERY_PARAMETER generated on Postgresql
 		if (Daos.isPostgresqlDatabase(context.getSource().getJdbcUrl())) {
 			context.getSource().setTempQueryParameterGenerated(config.isTempQueryParameterGenerated());
 		}
 		if (Daos.isPostgresqlDatabase(context.getTarget().getJdbcUrl())) {
 			context.getTarget().setTempQueryParameterGenerated(config.isTempQueryParameterGenerated());
 		}
 
 	}
 
 	/**
 	 * Check if a split is need, for import (see mantis #30765)
 	 *
 	 * @param resultAfterPrepare
 	 *            a {@link SynchroResult} object.
 	 * @param context
 	 *            a {@link SynchroContext} object.
 	 * @param useTargetMetadata useTargetMetadata
 	 * @return a {@link java.util.List} object.
 	 */
 	protected List<Multimap<String, String>> computePkIncludesListForBatch(SynchroResult resultAfterPrepare,
 																		   DataSynchroContext context, boolean useTargetMetadata) {
 		int maxRootRowCount = QuadrigeConfiguration.getInstance().getImportDataMaxRootRowCount();
 		if (MapUtils.isEmpty(resultAfterPrepare.getUpdateDateHits())
 				|| maxRootRowCount <= 0 /* Skip if disable */
 				|| resultAfterPrepare.getTotalRows() <= maxRootRowCount) {
 			return null;
 		}
 
 		Assert.notNull(context);
 		if (log.isDebugEnabled()) {
 			log.debug(String.format("Compute PKs to import, by batch of %s rows", maxRootRowCount));
 		}
 
 		SynchroDatabaseConfiguration source = context.getSource();
 		Assert.notNull(source);
 
 		Connection sourceConnection = null;
 		DaoFactory sourceDaoFactory = null;
 		SynchroDatabaseMetadata dbMeta = null;
 		ResultSet dataToUpdate = null;
 
 		try {
 
 			Set<String> tableNames = resultAfterPrepare.getUpdateDateHits().keySet();
 			Assert.notEmpty(tableNames);
 
 			// List of table to ignore for batch
 			List<String> tableNamesToIgnore = ImmutableList.of(DataSynchroTables.DELETED_ITEM_HISTORY.name().toUpperCase());
 			List<String> ignoredTableNames = new ArrayList<>();
 			for (String tableName: tableNames) {
 				if (tableNamesToIgnore.contains(tableName.toUpperCase())) {
 					ignoredTableNames.add(tableName);
 				}
 			}
 			tableNames.removeAll(ignoredTableNames);
 
 			List<Multimap<String, String>> result = Lists.newArrayList();
 
 			// create source Connection
 			sourceConnection = createConnection(source);
 
 			log.debug("Loading source database metadata...");
 			if (useTargetMetadata) {
 				SynchroDatabaseConfiguration target = context.getTarget();
 				Assert.notNull(target);
 				Connection targetConnection = createConnection(target);
 				boolean isFullMetadataEnable = target.isFullMetadataEnable();
 				target.setFullMetadataEnable(true);
 				dbMeta = loadDatabaseMetadata(
 						targetConnection,
 						target,
 						tableNames);
 				target.setFullMetadataEnable(isFullMetadataEnable);
 			} else {
 				boolean isFullMetadataEnable = source.isFullMetadataEnable();
 				source.setFullMetadataEnable(true);
 				dbMeta = loadDatabaseMetadata(
 						sourceConnection,
 						source,
 						tableNames);
 				source.setFullMetadataEnable(isFullMetadataEnable);
 			}
 
 			// Create DAO factories
 			sourceDaoFactory = newDaoFactory(sourceConnection, source, dbMeta);
 
 			// For each table found during preparation phase
 			Multimap<String, String> currentBatch = ArrayListMultimap.create();
 			int currentBatchSize = 0;
 			for (String tableName : tableNames) {
 
 				SynchroTableDao sourceDao = sourceDaoFactory.getSourceDao(tableName);
 
 				Map<String, Object> bindings = createSelectBindingsForTable(context, tableName);
 				dataToUpdate = sourceDao.getData(bindings);
 
 				while (dataToUpdate.next()) {
 
 					String pkStr = SynchroTableMetadata.toPkStr(sourceDao.getPk(dataToUpdate));
 
 					// If current batch is full: add it to result list
 					if (currentBatchSize == maxRootRowCount) {
 						result.add(currentBatch);
 						currentBatch = ArrayListMultimap.create();
 						currentBatchSize = 0;
 					}
 
 					currentBatch.put(tableName, pkStr);
 					currentBatchSize++;
 				}
 
 				// Close the result set
 				Daos.closeSilently(dataToUpdate);
 				dataToUpdate = null;
 			}
 
 			// Add last batch to result
 			if (currentBatchSize > 0) {
 				result.add(currentBatch);
 			}
 
 			// Then add ignored table names
 			for (String tableName : ignoredTableNames) {
 
 				currentBatch = ArrayListMultimap.create();
 
 				SynchroTableDao sourceDao = sourceDaoFactory.getSourceDao(tableName);
 				Map<String, Object> bindings = createSelectBindingsForTable(context, tableName);
 				dataToUpdate = sourceDao.getData(bindings);
 
 				while (dataToUpdate.next()) {
 					String pkStr = SynchroTableMetadata.toPkStr(sourceDao.getPk(dataToUpdate));
 					currentBatch.put(tableName, pkStr);
 				}
 
 				result.add(currentBatch);
 
 				// Close the result set
 				Daos.closeSilently(dataToUpdate);
 				dataToUpdate = null;
 			}
 
 
 			return result;
 
 		} catch (Exception e) {
 			if (log.isDebugEnabled()) {
 				log.debug(e);
 			}
 			throw new SynchroTechnicalException(e);
 		} finally {
 			Daos.closeSilently(dataToUpdate);
 			IOUtils.closeQuietly(sourceDaoFactory);
 			closeSilently(dbMeta);
 			closeSilently(sourceConnection);
 		}
 	}
 
 	/**
 	 * <p>
 	 * synchronizeUsingBatch.
 	 * </p>
 	 *
 	 * @param synchroContext
 	 *            a {@link fr.ifremer.common.synchro.service.SynchroContext} object.
 	 * @param pkIncludesListForBatch
 	 *            a {@link java.util.List} object.
 	 */
 	protected void synchronizeUsingBatch(DataSynchroContext synchroContext,
 			List<Multimap<String, String>> pkIncludesListForBatch) {
 
 		SynchroResult result = synchroContext.getResult();
 
 		boolean savedEnableDelete = synchroContext.isEnableDelete();
 		boolean currentBatchEnableDelete = savedEnableDelete;
 
 		// Init the progression model (only total, because message will be delegate to a child progression model)
 		ProgressionModel mainProgressionModel = result.getProgressionModel();
 		int mainTotal = 0;
 		for (Multimap<String, String> currentBatchPkIncludes : pkIncludesListForBatch) {
 			mainTotal += currentBatchPkIncludes.size();
 		}
 		mainProgressionModel.setTotal(mainTotal);
 
 		// Clear result (will be updated after each batch, by calling 'addAll()')
 		result.clear();
 
 		for (Multimap<String, String> currentBatchPkIncludes : pkIncludesListForBatch) {
 
 			// Update the context to process only PK included in the current batch
 			SynchroResult currentBatchResult = new SynchroResult(result.getLocalUrl(), result.getRemoteUrl());
 			for (String tableName : currentBatchPkIncludes.keySet()) {
 				currentBatchResult.setUpdateDate(tableName, null);
 				currentBatchResult.addRows(tableName, currentBatchPkIncludes.get(tableName).size());
 			}
 			synchroContext.setResult(currentBatchResult);
 			synchroContext.setPkIncludes(currentBatchPkIncludes);
 			synchroContext.setEnableDelete(currentBatchEnableDelete);
 
 			int batchProgressionModelOffset = mainProgressionModel.getCurrent();
 			addProgressionListeners(mainProgressionModel,
 					currentBatchResult.getProgressionModel(),
 					batchProgressionModelOffset);
 
 			// Call synchronize
 			super.synchronize(synchroContext);
 
 			// Add the current result to the final result
 			result.addAll(currentBatchResult);
 
 			// Update progression model
 			// progressionModel.setCurrent(batchProgressionModelOffset + currentBatchResult.getTotalRows());
 
 			// If error, then store this error into final result, and stop iteration
 			if (!currentBatchResult.isSuccess()) {
 				result.setError(currentBatchResult.getError());
 				break;
 			}
 
 			// Disable deletions import, for the next iteration
 			// because all deletions processed during the first iteration
 			currentBatchEnableDelete = false;
 
 			// Do an intermediate commit (+free memory)
 			try {
 				commitAndFreeMemory(synchroContext.getTarget());
 			} catch (SQLException e) {
 				result.setError(e);
 				break;
 			}
 		}
 
 		// Update progression model
 		mainProgressionModel.setCurrent(mainProgressionModel.getTotal());
 
 		// Restore the context: result and configuration (pkIncludes and enableDelete)
 		synchroContext.setResult(result);
 		synchroContext.setPkIncludes(null);
 		synchroContext.setEnableDelete(savedEnableDelete);
 	}
 
 	/**
 	 * Remap batch progression model to the main progression model
 	 *
 	 * @param mainProgressionModel
 	 *            a {@link fr.ifremer.common.synchro.type.ProgressionModel} object.
 	 * @param batchProgressionModel progression model
 	 * @param batchProgressionModelOffset
 	 *            a int.
 	 */
 	protected void addProgressionListeners(
 			final ProgressionModel mainProgressionModel,
 			final ProgressionModel batchProgressionModel,
 			final int batchProgressionModelOffset) {
 		// Listen 'current' attribute changes
 		batchProgressionModel.addPropertyChangeListener(ProgressionModel.PROPERTY_CURRENT,
 				evt -> {
                     Integer current = (Integer) evt.getNewValue();
                     mainProgressionModel.setCurrent(batchProgressionModelOffset + current);
                 });
 
 		// Listen message changes
 		batchProgressionModel.addPropertyChangeListener(ProgressionModel.PROPERTY_MESSAGE,
 				evt -> {
                     String message = (String) evt.getNewValue();
                     mainProgressionModel.setMessage(message);
                 });
 	}
 
 	/**
 	 * THis method will do an intermediate commit on current connection.
 	 * If HsqlDB, will compact the database.
 	 * At the end, GC is calling
 	 *
 	 * @param dbConfig
 	 *            a {@link fr.ifremer.common.synchro.service.SynchroDatabaseConfiguration} object.
 	 * @throws java.sql.SQLException
 	 *             if any.
 	 */
 	protected void commitAndFreeMemory(SynchroDatabaseConfiguration dbConfig) throws SQLException {
 		// Do an intermediate commit
 		Connection connection = null;
 		try {
 			connection = createConnection(dbConfig);
 			connection.commit();
 			System.gc();
 		} finally {
 			closeSilently(connection);
 		}
 	}
 
 	@Override
 	protected Connection createConnection(SynchroDatabaseConfiguration databaseConfiguration) throws SQLException {
 		Connection connection = super.createConnection(databaseConfiguration);
 
 		// Enable auto-commit on HSQLDB temporary database, on export
 		SynchroDirection synchroDirection = null;
 		// Get synchro direction to enable only on temp db (Mantis #47548)
 		if (databaseConfiguration instanceof AbstractSynchroDatabaseConfiguration) {
 			synchroDirection = ((AbstractSynchroDatabaseConfiguration) databaseConfiguration).getDirection();
 		}
 		if ((synchroDirection == SynchroDirection.IMPORT_SERVER2TEMP || synchroDirection == SynchroDirection.EXPORT_LOCAL2TEMP)
 				&& !databaseConfiguration.isRollbackOnly() && Daos.isHsqlFileDatabase(databaseConfiguration.getJdbcUrl()) && databaseConfiguration.isTarget()) {
 			connection.setAutoCommit(true);
 		}
 
 		// For Oracle connection, propagate synonym parameter
 		if (Daos.isOracleDatabase(databaseConfiguration.getJdbcUrl()) && databaseConfiguration.isSynonymsEnable()) {
 			((OracleConnection) Daos.unwrapConnection(connection)).setIncludeSynonyms(true);
 		}
 
 		// For Postgreql, register postgis geometry type
 		if (Daos.isPostgresqlDatabase(databaseConfiguration.getJdbcUrl())) {
 			((PGConnection) Daos.unwrapConnection(connection)).addDataType(String.format("\"%s\".\"geometry\"", QuadrigeConfiguration.getInstance().getPostgisSchema()), PGgeometry.class);
 		}
 
 		// Set timezone - mantis #36465
 		Daos.setTimezone(connection, QuadrigeConfiguration.getInstance().getDbTimezone());
 
 		return connection;
 	}
 
 	@Override
 	protected DataSynchroDatabaseConfiguration newSynchroDatabaseConfiguration(DataSynchroContext context, Properties sourceConnectionProperties, boolean isTarget) {
 		return new DataSynchroDatabaseConfiguration(context, sourceConnectionProperties, isTarget);
 	}
 
 	@Override
 	protected DataSynchroContext newSynchroContext() {
 		return new DataSynchroContext();
 	}
 }