/// <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);
}
