/// <summary> /// open local tables /// </summary> /// <returns></returns> private GatewayResult OpenTables() { GatewayResult retVal = new GatewayResult(); foreach (DataSourceReference dataSourceRef in Task.DataSourceReferences) { if (dataSourceRef.IsLocal) { String fileName; if (dataSourceRef.NameExpression > 0) { Task.EvaluateExpressionAsUnicode(dataSourceRef.NameExpression, out fileName); } else { fileName = dataSourceRef.DataSourceDefinition.Name; } //create gw open command GatewayCommandFileOpen fileOpenCommand = GatewayCommandsFactory.CreateFileOpenCommand(fileName, dataSourceRef.DataSourceDefinition, dataSourceRef.Access, ClientManager.Instance.LocalManager); retVal = fileOpenCommand.Execute(); if (!retVal.Success) { break; } } } return(retVal); }
/// <summary> /// Fetch /// </summary> /// <returns></returns> internal GatewayResult CursorFetch() { //vew_fetch_rng GatewayCommandBase cursorCommand = GatewayCommandsFactory.CreateCursorFetchCommand(CurrentCursor, LocalDataviewManager.LocalManager); return(cursorCommand.Execute()); }
/// <summary> /// Prepare and Open runtime cursor /// </summary> /// <param name="runtimeCursor"></param> private void PrepareAndOpenCursor(RuntimeCursor runtimeCursor, bool openTransaction) { GatewayResult result = null; runtimeCursor.CursorDefinition.StartPosition = new DbPos(true); runtimeCursor.CursorDefinition.CurrentPosition = new DbPos(true); result = GatewayCommandsFactory.CreateCursorPrepareCommand(runtimeCursor, ClientManager.Instance.LocalManager).Execute(); if (result.Success) { if (openTransaction) { result = GatewayCommandsFactory.CreateGatewayCommandOpenTransaction(ClientManager.Instance.LocalManager).Execute(); } if (result.Success) { result = GatewayCommandsFactory.CreateCursorOpenCommand(runtimeCursor, ClientManager.Instance.LocalManager).Execute(); } } if (!result.Success) { throw new DataSourceConversionFailedException(runtimeCursor.CursorDefinition.DataSourceDefinition.Name, result.ErrorDescription); } }
/// <summary> /// open transaction /// if there is no transaction opened already then /// open and save it info on ClientManager.Instance.CurrentLocalTransactionOpened /// else /// if (transaction that was opend is in my parent task) /// OK /// else /// failed !!! /// /// </summary> internal override ReturnResultBase Execute() { ReturnResultBase returnResultBase = new GatewayResult(); Transaction transaction = DataviewManager.Transaction.OwnerTask.DataviewManager.LocalDataviewManager.Transaction; if (!transaction.isOpened()) { // need to open in the gateway only if no opend before if (TaskTransactionManager.LocalOpenedTransactionsCount == 0) { returnResultBase = GatewayCommandsFactory.CreateGatewayCommandOpenTransaction(LocalManager).Execute(); } if (returnResultBase.Success) { transaction.Opened = true; TaskTransactionManager.LocalOpenedTransactionsCount++; //transaction.OwnerTask.TaskTransactionManager.SetCurrentOpenTransactionAsLocalTransaction(); //Debug.WriteLine("Open Transaction on task--> " + LocalDataviewManager.CurrentOpenTransaction.OwnerTask); } //else //{ // // check if the open transaction is in the parent task // if (!transaction.OwnerTask.isDescendentOf(LocalDataviewManager.CurrentOpenTransaction.OwnerTask)) // returnResultBase = new ReturnResult(MsgInterface.FMERROR_STR_TRANS_OPEN_FAILED); //} } return(returnResultBase); }
/// <summary> /// /// </summary> /// <returns></returns> internal override ReturnResultBase Execute() { GatewayResult gatewayResult = new GatewayResult(); Transaction transaction = DataviewManager.Transaction.OwnerTask.DataviewManager.LocalDataviewManager.Transaction; // closeclose the transaction only if there is transaction that open if (TaskTransactionManager.LocalOpenedTransactionsCount > 0) { gatewayResult = CloseTransactionInGateway(); if (gatewayResult.Success) { //Debug.WriteLine("Commit Transaction on task--> " + LocalDataviewManager.CurrentOpenTransaction.OwnerTask); transaction.Opened = false; TaskTransactionManager.LocalOpenedTransactionsCount--; // there is tasks that in local transaction, we must open the transaction again if (TaskTransactionManager.LocalOpenedTransactionsCount > 0) { gatewayResult = GatewayCommandsFactory.CreateGatewayCommandOpenTransaction(LocalManager).Execute(); } } else { gatewayResult.ErrorCode = GatewayErrorCode.TransactionCommit; } } return(gatewayResult); }
/// <summary> /// Convert DataSource from old DataSourceDefinition to new DataSourceDefinition. It create temporaryDataSource definition and perform all operations /// on temporary DataSourcedefinition and return it. /// </summary> /// <param name="fromDataSourceDefinition"></param> /// <param name="toDataSourceDefinition"></param> /// <returns>Temporary DataSourceDefinition</returns> private DataSourceDefinition ConvertDataSource(DataSourceDefinition fromDataSourceDefinition, DataSourceDefinition toDataSourceDefinition) { Logger.Instance.WriteSupportToLog("convertDataSource():>>>> ", true); Logger.Instance.WriteSupportToLog(String.Format("convertDataSource(): converting table {0}", fromDataSourceDefinition.Name), true); GatewayResult result = null; string temporaryTableName = GetTemporaryTableName(fromDataSourceDefinition.Id); DataSourceDefinition temporaryDataSourceDefinition = (DataSourceDefinition)toDataSourceDefinition.Clone(); temporaryDataSourceDefinition.Name = temporaryTableName; // In order to genearte temporary key name for the temporary dbh set magic key mask on the keys. for (int keyIndex = 0; keyIndex < temporaryDataSourceDefinition.Keys.Count; keyIndex++) { DBKey key = temporaryDataSourceDefinition.Keys[keyIndex]; key.SetMask(KeyMasks.MagicKeyMask); } // Delete temporary table, if exists result = GatewayCommandsFactory.CreateFileDeleteCommand(temporaryTableName, temporaryDataSourceDefinition, ClientManager.Instance.LocalManager).Execute(); if (!result.Success && result.ErrorCode != GatewayErrorCode.FileNotExist) { throw new DataSourceConversionFailedException(fromDataSourceDefinition.Name, result.ErrorDescription); } // Open source and temporary table temporaryDataSourceDefinition.SetMask(DbhMask.CheckExistMask); result = GatewayCommandsFactory.CreateFileOpenCommand(temporaryTableName, temporaryDataSourceDefinition, Access.Write, ClientManager.Instance.LocalManager).Execute(); if (result.Success) { result = GatewayCommandsFactory.CreateFileOpenCommand(fromDataSourceDefinition.Name, fromDataSourceDefinition, Access.Read, ClientManager.Instance.LocalManager).Execute(); } if (!result.Success) { throw new DataSourceConversionFailedException(fromDataSourceDefinition.Name, result.ErrorDescription); } //Convert values of source table and insert it into temporary table ConvertAndInsertValues(fromDataSourceDefinition, temporaryDataSourceDefinition); //Close source and temporary table result = GatewayCommandsFactory.CreateFileCloseCommand(temporaryDataSourceDefinition, ClientManager.Instance.LocalManager).Execute(); if (result.Success) { GatewayCommandsFactory.CreateFileCloseCommand(fromDataSourceDefinition, ClientManager.Instance.LocalManager).Execute(); } if (!result.Success) { throw new DataSourceConversionFailedException(fromDataSourceDefinition.Name, result.ErrorDescription); } Logger.Instance.WriteSupportToLog("convertDataSource():<<<< ", true); return(temporaryDataSourceDefinition); }
/// <summary> /// Checks if correspondng table of data source is exist at backend /// </summary> /// <param name="dataSourceDefinition"></param> /// <returns>returns true if table exists</returns> private bool IsTableExist(DataSourceDefinition dataSourceDefinition) { GatewayCommandFileExist fileExistCommand = GatewayCommandsFactory.CreateFileExistCommand(dataSourceDefinition.Name, dataSourceDefinition, ClientManager.Instance.LocalManager); GatewayResult result = fileExistCommand.Execute(); return(result.Success); }
/// <summary> /// Execute DbDisConnect gateway command. /// </summary> /// <returns></returns> internal override ReturnResultBase Execute() { GatewayResult result = new GatewayResult(); GatewayCommandDbDisconnect dbDisconnectCommand = GatewayCommandsFactory.CreateGatewayCommandDbDisconnect(LocalDataviewManager.LocalManager, dataBaseName); result = dbDisconnectCommand.Execute(); return(result); }
internal GatewayResult CloseDataSource() { var dataSourceRef = DataSourceViewDefinition.TaskDataSource; string fileName = dataSourceRef.DataSourceDefinition.Name; var command = GatewayCommandsFactory.CreateFileCloseCommand(dataSourceRef.DataSourceDefinition, this.LocalDataviewManager.LocalManager); var retVal = command.Execute(); return(retVal); }
/// <summary> /// Execute SQL command /// </summary> /// <returns></returns> internal override ReturnResultBase Execute() { GatewayResult result = new GatewayResult(); GatewayCommandSQLExecute gatewaySqlExecuteCommand = GatewayCommandsFactory.CreateGatewayCommandSQLExecute(LocalDataviewManager.LocalManager, dataBaseName, sqlStatement, storageAttributes, sqlExecuteCommand.DbFields); result = gatewaySqlExecuteCommand.Execute(); sqlExecuteCommand.statementReturnedValues = gatewaySqlExecuteCommand.statementReturnedValues; return(result); }
/// <summary> /// Execute File delete gateway command. /// </summary> /// <returns></returns> internal override ReturnResultBase Execute() { ReturnResultBase result = new ReturnResult(); bool exist = false; int dataSourceNumber = clientDbDelCommand.DataSourceNumber; string dataSourceName = clientDbDelCommand.DataSourceName; DataSourceDefinition dataSourceDefintion = ClientManager.Instance.LocalManager.ApplicationDefinitions.DataSourceDefinitionManager.GetDataSourceDefinition(Task.getCtlIdx(), dataSourceNumber); //If Wrong Data Source Number is Given if (dataSourceDefintion == null) { Logger.Instance.WriteExceptionToLog("ClientDbDel - Invalid Data Source Number"); result = new ReturnResult(MsgInterface.STR_CLIENT_DB_DEL_OPERATION_FAILED); } else { if (string.IsNullOrEmpty(dataSourceName)) { dataSourceName = dataSourceDefintion.Name; } //Check for Table exist or not. if (dataSourceDefintion.CheckExist == 'N') { exist = true; } else { GatewayCommandFileExist dbFileExistCommand = GatewayCommandsFactory.CreateFileExistCommand(dataSourceName, dataSourceDefintion, LocalDataviewManager.LocalManager); result = dbFileExistCommand.Execute(); exist = result.Success; } //If Table exists then go for file delete operation. if (exist) { GatewayCommandFileDelete dbDeleteCommand = GatewayCommandsFactory.CreateFileDeleteCommand(dataSourceName, dataSourceDefintion, LocalDataviewManager.LocalManager); if (!dbDeleteCommand.Execute().Success) { Logger.Instance.WriteExceptionToLog("ClientDbDel - Cannot delete Table"); result = new ReturnResult(MsgInterface.STR_CLIENT_DB_DEL_OPERATION_FAILED); } } else { Logger.Instance.WriteExceptionToLog(string.Format("ClientDbDel - {0}", result.ErrorDescription)); result = new ReturnResult(MsgInterface.STR_CLIENT_DB_DEL_OPERATION_FAILED); } } return(result); }
/// <summary> /// open cursor /// </summary> /// <param name="reverse"></param> /// <param name="startPosition"></param> /// <param name="useLocate">If this is the 1st access to the table, locate values should be considered. /// if not - use only ranges</param> /// <returns></returns> internal GatewayResult OpenCursor(bool reverse, DbPos startPosition, BoudariesFlags boundariesFlag) { CurrentCursor.CursorDefinition.SetFlagValue(CursorProperties.DirReversed, reverse); CurrentCursor.CursorDefinition.StartPosition = startPosition; // build the RangeData list CurrentCursor.RuntimeCursorData.Ranges = RangeBuilder.Build(boundariesFlag); GatewayCommandBase cursorCommand = GatewayCommandsFactory.CreateCursorOpenCommand(CurrentCursor, LocalDataviewManager.LocalManager); //String r = CurrentCursor.Serialize(); return(cursorCommand.Execute()); }
public void Execute() { Logger.Instance.WriteSupportToLog("DeleteCommand.Execute():>>>>> ", true); Logger.Instance.WriteSupportToLog(string.Format("DeleteCommand.Execute(): deleting table {0}", dataSourceDefinition.Name), true); GatewayCommandFileDelete fileDeleteCommand = GatewayCommandsFactory.CreateFileDeleteCommand(dataSourceDefinition.Name, dataSourceDefinition, ClientManager.Instance.LocalManager); GatewayResult result = fileDeleteCommand.Execute(); if (!result.Success && result.ErrorCode != GatewayErrorCode.FileNotExist) { throw new DataSourceConversionFailedException(dataSourceDefinition.Name, result.ErrorDescription); } Logger.Instance.WriteSupportToLog("DeleteCommand.Execute():<<<< ", true); }
/// <summary> /// Fetech the values from source datasource, convert fetched values and insert values in destination dataSource. /// </summary> /// <param name="fromDataSourceDefinition"></param> /// <param name="toDataSourceDefinition"></param> private void ConvertAndInsertValues(DataSourceDefinition fromDataSourceDefinition, DataSourceDefinition toDataSourceDefinition) { GatewayResult result = null; MainCursorBuilder cursorBuilder = new MainCursorBuilder(null); RuntimeCursor fromRuntimeCursor = cursorBuilder.Build(fromDataSourceDefinition, Access.Read); RuntimeCursor toRuntimeCursor = cursorBuilder.Build(toDataSourceDefinition, Access.Write); //Prepare and open source and destnation runtime cursor. PrepareAndOpenCursor(fromRuntimeCursor, true); PrepareAndOpenCursor(toRuntimeCursor, false); //Create fetch command GatewayCommandFetch fetchCommand = GatewayCommandsFactory.CreateCursorFetchCommand(fromRuntimeCursor, ClientManager.Instance.LocalManager); while (true) { //Fetch record from source table result = fetchCommand.Execute(); if (!result.Success) { if (result.ErrorCode == GatewayErrorCode.NoRecord) { break; } else { throw new DataSourceConversionFailedException(fromDataSourceDefinition.Name, result.ErrorDescription); } } //Convert values of fields of source table. ConvertFields(fromDataSourceDefinition, toDataSourceDefinition, fromRuntimeCursor.RuntimeCursorData.CurrentValues, toRuntimeCursor.RuntimeCursorData.CurrentValues); for (int i = 0; i < toDataSourceDefinition.Fields.Count; i++) { toRuntimeCursor.CursorDefinition.IsFieldUpdated[i] = true; } //Insert converted values into temporary table. result = GatewayCommandsFactory.CreateCursorInsertCommand(toRuntimeCursor, ClientManager.Instance.LocalManager).Execute(); } // release and close source and destnation runtime cursor. ReleaseAndCloseCursor(fromRuntimeCursor, true); ReleaseAndCloseCursor(toRuntimeCursor, false); }
public void Execute() { Logger.Instance.WriteSupportToLog("RenameCommand.Execute():>>>>> ", true); Logger.Instance.WriteSupportToLog(string.Format("RenameCommand.Execute(): renaming table {0} to {1}", fromDataSourceDefinition.Name, toDataSourceDefinition.Name), true); GatewayCommandFileRename fileRenameCommand = GatewayCommandsFactory.CreateFileRenameCommand(fromDataSourceDefinition, toDataSourceDefinition, ClientManager.Instance.LocalManager); GatewayResult result = fileRenameCommand.Execute(); if (!result.Success) { throw new DataSourceConversionFailedException(toDataSourceDefinition.Name, result.ErrorDescription); } Logger.Instance.WriteSupportToLog("RenameCommand.Execute():<<<< ", true); }
private void CloseTables() { foreach (DataSourceReference dataSourceRef in Task.DataSourceReferences) { if (dataSourceRef.IsLocal) { //create gw close command GatewayCommandFileClose fileCloseCommand = GatewayCommandsFactory.CreateFileCloseCommand(dataSourceRef.DataSourceDefinition, LocalManager); fileCloseCommand.Execute(); } } if (TaskViews != null) { TaskViews.CloseTables(); } }
/// <summary> /// insert cursor /// </summary> /// <param name="pos"></param> /// <returns></returns> internal GatewayResult InsertRecord(IRecord record) { GatewayResult result = CheckTransactionValidation(); if (result.Success) { UpdateRuntimeCursor(record, true); GatewayCommandCursorInsertRecord cursorCommand = GatewayCommandsFactory.CreateCursorInsertCommand(CurrentCursor, LocalDataviewManager.LocalManager); result = cursorCommand.Execute(); if (result.Success && !IgnorePositionCache) { PositionCache.Set(GetPositionId(record), CurrentPosition); } } return(result); }
/// <summary> /// prepare cursor /// </summary> internal virtual GatewayResult Prepare() { CurrentCursor.CursorDefinition.Key = DataSourceViewDefinition.DbKey; //TODO:Range //tsk_crsr_fill_sql_range (vew_main->main.crsr); //if (CTX->ctl_tsk_.tskr->SQLRange_exp != 0 && !AS400File) // tsk_crsr_fill_magic_sql_range(vew_main->main.crsr); //TODO CurrentCursor.CursorDefinition.StartPosition = new DbPos(true); CurrentCursor.CursorDefinition.CurrentPosition = new DbPos(true);;//set to new position ? //create fm PrepareCursor operation GatewayCommandPrepare cursorCommand = GatewayCommandsFactory.CreateCursorPrepareCommand(CurrentCursor, LocalDataviewManager.LocalManager); return(cursorCommand.Execute()); }
/// <summary> /// Close and Relaese runtime cursor. /// </summary> /// <param name="runtimeCursor"></param> private void ReleaseAndCloseCursor(RuntimeCursor runtimeCursor, bool closeTransaction) { GatewayResult result = null; result = GatewayCommandsFactory.CreateCursorCloseCommand(runtimeCursor, ClientManager.Instance.LocalManager).Execute(); if (result.Success) { if (closeTransaction) { result = GatewayCommandsFactory.CreateGatewayCommandCloseTransaction(ClientManager.Instance.LocalManager).Execute(); } if (result.Success) { result = GatewayCommandsFactory.CreateCursorReleaseCommand(runtimeCursor, ClientManager.Instance.LocalManager).Execute(); } } if (!result.Success) { throw new DataSourceConversionFailedException(runtimeCursor.CursorDefinition.DataSourceDefinition.Name, result.ErrorDescription); } }
/// <summary> /// /// </summary> /// <returns></returns> internal override ReturnResultBase Execute() { GatewayResult gatewayResult = new GatewayResult(); Transaction ownerTransaction = null; if (TaskTransactionManager.LocalOpenedTransactionsCount > 0) { gatewayResult = RollbaclTransactionInGateway(); if (gatewayResult.Success) { if (DataviewManager.Transaction != null) { ownerTransactionTask = DataviewManager.Transaction.OwnerTask; ownerTransaction = ownerTransactionTask.DataviewManager.LocalDataviewManager.Transaction; //1. calculate the current task , the task that was execute the rollback transaction (Command.taskgTag) //Debug.WriteLine("Commit Transaction on task--> " + LocalDataviewManager.CurrentOpenTransaction.OwnerTask); ownerTransactionTask.CancelAndRefreshCurrentRecordAfterRollback(); } GatewayCommandBase transactionCommand = GatewayCommandsFactory.CreateGatewayCommandOpenTransaction(LocalManager); gatewayResult = transactionCommand.Execute(); //2. Close\refresh all tasks that are under the current transaction switch (Command.Rollback) { case RollbackEventCommand.RollbackType.CANCEL: MGDataCollection.Instance.ForEachTask(new TaskDelegate(CancelAndRefreshCurrentRecordAfterRollback), ownerTransactionTask); MGDataCollection.Instance.ForEachTask(new TaskDelegate(ViewRefreshAfterRollback), ownerTransactionTask); break; case RollbackEventCommand.RollbackType.ROLLBACK: { // fixed bug#294247 rollback the value in StopExecution bool saveStopExec = ClientManager.Instance.EventsManager.GetStopExecutionFlag(); StopExecWasUpdated = false; MGDataCollection.Instance.ForEachTask(new TaskDelegate(CancelAndRefreshCurrentRecordAfterRollback), null); MGDataCollection.Instance.ForEachTask(new TaskDelegate(ViewRefreshAfterRollback), null); if (ownerTransactionTask != null) { ownerTransactionTask.AbortDirectTasks(); } if (StopExecWasUpdated) { ClientManager.Instance.EventsManager.setStopExecution(saveStopExec); } } break; default: break; } } else { gatewayResult.ErrorCode = GatewayErrorCode.TransactionAbort; } } return(gatewayResult); }
/// <summary> /// /// </summary> /// <returns></returns> internal GatewayResult CloseCursor() { GatewayCommandBase cursorCommand = GatewayCommandsFactory.CreateCursorCloseCommand(CurrentCursor, LocalDataviewManager.LocalManager); return(cursorCommand.Execute()); }
/// <summary> /// Update dataview to DataSource. /// </summary> private ReturnResultBase UpdateDataViewToDataSource() { bool transactionOpened = false; string error = string.Empty; string dataSourceName = ClientManager.Instance.getEnvParamsTable().translate(updateDataViewToDataSourceCommand.DestDataSourceName); if (string.IsNullOrEmpty(dataSourceName)) { dataSourceName = destinationDataSourceDefinition.Name; } GatewayResult result = GatewayCommandsFactory.CreateFileExistCommand(dataSourceName, destinationDataSourceDefinition, ClientManager.Instance.LocalManager).Execute(); bool insertMode = !result.Success; if (!insertMode) { uniqueKey = GetUniqueKey(); if (uniqueKey == null) { error = "DataViewToDataSource - When using the DataViewtoDataSource function, a unique index must be defined in the destination data source ."; Logger.Instance.WriteExceptionToLog(error); ClientManager.Instance.ErrorToBeWrittenInServerLog = error; return(new ReturnResult(MsgInterface.STR_DATAVIEW_TO_DATASOURCE_OPERATION_FAILED)); } else if (!CheckDestinationColumnListContainUniqueKeyColumns()) { error = "DataViewToDataSource - When using the DataViewtoDataSource function, all the segments of the unique index must be selected."; Logger.Instance.WriteExceptionToLog(error); ClientManager.Instance.ErrorToBeWrittenInServerLog = error; return(new ReturnResult(MsgInterface.STR_DATAVIEW_TO_DATASOURCE_OPERATION_FAILED)); } } result = GatewayCommandsFactory.CreateFileOpenCommand(dataSourceName, destinationDataSourceDefinition, Access.Write, ClientManager.Instance.LocalManager).Execute(); if (result.Success) { //Build the runtime cursor. MainCursorBuilder cursorBuilder = new MainCursorBuilder(null); RuntimeCursor destinationRuntimeCursor = cursorBuilder.Build(destinationDataSourceDefinition, Access.Write); destinationRuntimeCursor.CursorDefinition.StartPosition = new DbPos(true); destinationRuntimeCursor.CursorDefinition.CurrentPosition = new DbPos(true); // Prepare the cursor. result = GatewayCommandsFactory.CreateCursorPrepareCommand(destinationRuntimeCursor, ClientManager.Instance.LocalManager).Execute(); if (result.Success) { //If tansaction is not open then open the transaction. if (TaskTransactionManager.LocalOpenedTransactionsCount == 0) { result = GatewayCommandsFactory.CreateGatewayCommandOpenTransaction(ClientManager.Instance.LocalManager).Execute(); transactionOpened = true; } if (result.Success) { SetDataToRuntimeParser(); RecordForDataViewToDataSource record = GetRecord(); while (record != null) { BuildCurrentValues(destinationRuntimeCursor, record); result = GatewayCommandsFactory.CreateCursorInsertCommand(destinationRuntimeCursor, ClientManager.Instance.LocalManager, true).Execute(); if (!result.Success) { if (result.ErrorCode == GatewayErrorCode.DuplicateKey) { if (!insertMode) { //Build the ranges using unique key segments value. BuildRanges(record, destinationRuntimeCursor); //Open the cursor and apply the ranges. result = GatewayCommandsFactory.CreateCursorOpenCommand(destinationRuntimeCursor, ClientManager.Instance.LocalManager, true).Execute(); if (result.Success) { //Fetch the record result = GatewayCommandsFactory.CreateCursorFetchCommand(destinationRuntimeCursor, ClientManager.Instance.LocalManager).Execute(); BuildCurrentValues(destinationRuntimeCursor, record); //If record found, that means record with same key value exists, so update the current record with destination record. if (result.Success) { result = GatewayCommandsFactory.CreateGatewayCommandCursorUpdateRecord(destinationRuntimeCursor, ClientManager.Instance.LocalManager, true).Execute(); } else { if (!string.IsNullOrEmpty(ClientManager.Instance.ErrorToBeWrittenInServerLog)) { ClientManager.Instance.ErrorToBeWrittenInServerLog += "\r\n"; } ClientManager.Instance.ErrorToBeWrittenInServerLog += result.ErrorDescription; } //Close the cursor. GatewayCommandsFactory.CreateCursorCloseCommand(destinationRuntimeCursor, ClientManager.Instance.LocalManager).Execute(); } else { if (!string.IsNullOrEmpty(ClientManager.Instance.ErrorToBeWrittenInServerLog)) { ClientManager.Instance.ErrorToBeWrittenInServerLog += "\r\n"; } ClientManager.Instance.ErrorToBeWrittenInServerLog += result.ErrorDescription; } } else { if (!string.IsNullOrEmpty(ClientManager.Instance.ErrorToBeWrittenInServerLog)) { ClientManager.Instance.ErrorToBeWrittenInServerLog += "\r\n"; } ClientManager.Instance.ErrorToBeWrittenInServerLog += result.ErrorDescription; record = GetRecord(); continue; } } else { if (!string.IsNullOrEmpty(ClientManager.Instance.ErrorToBeWrittenInServerLog)) { ClientManager.Instance.ErrorToBeWrittenInServerLog += "\r\n"; } ClientManager.Instance.ErrorToBeWrittenInServerLog += result.ErrorDescription; break; } } record = GetRecord(); } //If transaction is opened , then close the transaction. If any error occurs then abort the transation else do commit. if (transactionOpened) { GatewayCommandCloseTransaction closeTransactionCommand = GatewayCommandsFactory.CreateGatewayCommandCloseTransaction(ClientManager.Instance.LocalManager); if (result.Success) { closeTransactionCommand.TransactionModes = TransactionModes.Commit; } else { closeTransactionCommand.TransactionModes = TransactionModes.Abort; } closeTransactionCommand.Execute(); } //Release the cursor and close the file. GatewayCommandsFactory.CreateCursorReleaseCommand(destinationRuntimeCursor, ClientManager.Instance.LocalManager).Execute(); GatewayCommandsFactory.CreateFileCloseCommand(destinationDataSourceDefinition, ClientManager.Instance.LocalManager).Execute(); } else { ClientManager.Instance.ErrorToBeWrittenInServerLog = result.ErrorDescription; } } else { ClientManager.Instance.ErrorToBeWrittenInServerLog = result.ErrorDescription; } } else { ClientManager.Instance.ErrorToBeWrittenInServerLog = result.ErrorDescription; } return(result); }