public void UnprepareStatement(IServerStatementPlan plan)
{
try
{
_script.Process.UnprepareStatement(plan);
}
catch (Exception E)
{
throw _script.Process.ServerSession.WrapException(E);
}
}
public void UnprepareStatement(IServerStatementPlan plan)
{
try
{
_batch.UnprepareStatement(((LocalStatementPlan)plan).RemotePlan);
}
catch
{
// ignore exceptions here
}
((LocalStatementPlan)plan).Dispose();
}
public static void Execute(Program program, string statement, DataParams dataParams)
{
IServerStatementPlan plan = ((IServerProcess)program.ServerProcess).PrepareStatement(statement, dataParams);
try
{
plan.CheckCompiled();
plan.Execute(dataParams);
}
finally
{
((IServerProcess)program.ServerProcess).UnprepareStatement(plan);
}
}
/// <summary> Unprepares a statement plan. </summary>
/// <param name="plan"> A reference to a plan object returned from a call to PrepareStatement. </param>
public void UnprepareStatement(IServerStatementPlan plan)
{
try
{
// The plan will be unprepared on the next prepare call
ReportCleanup(((LocalStatementPlan)plan).RemotePlan);
//FProcess.UnprepareStatement(((LocalStatementPlan)APlan).RemotePlan);
}
catch
{
// ignore exceptions here
}
((LocalStatementPlan)plan).Dispose();
}
protected override void InternalDelete()
{
if (_deleteStatement == String.Empty)
{
base.InternalDelete();
}
else
{
DAE.Runtime.DataParams paramsValue = GetParamsFromRow(_buffer[_activeOffset].Row, "Old.");
IServerStatementPlan plan = _process.PrepareStatement(_deleteStatement, paramsValue);
try
{
plan.Execute(paramsValue);
}
finally
{
_process.UnprepareStatement(plan);
}
}
}
/// <summary>Executes the given statement using the utility process.</summary>
public void Execute(IServerProcess process, string statement, DAE.Runtime.DataParams paramsValue)
{
CheckActive();
if (process == null)
{
process = UtilityProcess;
}
IServerStatementPlan plan = process.PrepareStatement(statement, paramsValue);
try
{
plan.Execute(paramsValue);
}
finally
{
process.UnprepareStatement(plan);
}
}
public void Execute(DataParams paramsValue)
{
try
{
if (IsExpression())
{
IServerExpressionPlan plan = PrepareExpression(paramsValue);
try
{
if (plan.DataType is Schema.TableType)
{
plan.Close(plan.Open(paramsValue));
}
else
{
DataValue.DisposeValue(this.Script.Process.ValueManager, plan.Evaluate(paramsValue));
}
}
finally
{
UnprepareExpression(plan);
}
}
else
{
IServerStatementPlan plan = PrepareStatement(paramsValue);
try
{
plan.Execute(paramsValue);
}
finally
{
UnprepareStatement(plan);
}
}
}
catch (Exception E)
{
throw _script.Process.ServerSession.WrapException(E);
}
}
protected override void InternalUpdate(IRow row)
{
if (_updateStatement == String.Empty)
{
base.InternalUpdate(row);
}
else
{
DAE.Runtime.DataParams paramsValue = GetParamsFromRow(_originalRow, "Old.");
GetParamsFromRow(row, paramsValue, "New.");
IServerStatementPlan plan = _process.PrepareStatement(_updateStatement, paramsValue);
try
{
plan.Execute(paramsValue);
}
finally
{
_process.UnprepareStatement(plan);
}
}
}
public void Prepare()
{
_resultPanel.Clear();
PrepareForExecute();
var result = new StringBuilder();
var errors = new ErrorList();
try
{
using (var statusForm = new StatusForm(Strings.ProcessingQuery))
{
bool attemptExecute = true;
try
{
DateTime startTime = DateTime.Now;
try
{
IServerScript script;
IServerProcess process =
DataSession.ServerSession.StartProcess(
new ProcessInfo(DataSession.ServerSession.SessionInfo));
try
{
script = process.PrepareScript(GetTextToExecute());
try
{
if (ScriptExecutionUtility.ConvertParserErrors(script.Messages, errors))
{
foreach (IServerBatch batch in script.Batches)
{
if (batch.IsExpression())
{
IServerExpressionPlan plan = batch.PrepareExpression(null);
try
{
attemptExecute &=
ScriptExecutionUtility.ConvertCompilerErrors(plan.Messages,
errors);
if (attemptExecute)
{
result.AppendFormat
(
Strings.PrepareSuccessful,
new object[]
{
plan.PlanStatistics.PrepareTime.ToString(),
plan.PlanStatistics.CompileTime.ToString(),
plan.PlanStatistics.OptimizeTime.ToString(),
plan.PlanStatistics.BindingTime.ToString()
}
);
result.Append("\r\n");
}
}
finally
{
batch.UnprepareExpression(plan);
}
}
else
{
IServerStatementPlan plan = batch.PrepareStatement(null);
try
{
attemptExecute &=
ScriptExecutionUtility.ConvertCompilerErrors(plan.Messages,
errors);
if (attemptExecute)
{
result.AppendFormat
(
Strings.PrepareSuccessful,
new object[]
{
plan.PlanStatistics.PrepareTime.ToString(),
plan.PlanStatistics.CompileTime.ToString(),
plan.PlanStatistics.OptimizeTime.ToString(),
plan.PlanStatistics.BindingTime.ToString()
}
);
result.Append("\r\n");
}
}
finally
{
batch.UnprepareStatement(plan);
}
}
AppendResultPanel(result.ToString());
result.Length = 0;
}
}
}
finally
{
process.UnprepareScript(script);
}
}
finally
{
DataSession.ServerSession.StopProcess(process);
}
}
finally
{
TimeSpan elapsed = DateTime.Now - startTime;
_executionTimeStatus.Text = elapsed.ToString();
}
if (attemptExecute)
{
SetStatus(Strings.ScriptPrepareSuccessful);
}
else
{
SetStatus(Strings.ScriptPrepareFailed);
}
}
catch (Exception exception)
{
SetStatus(Strings.ScriptFailed);
errors.Add(exception);
}
}
}
finally
{
ProcessErrors(errors);
}
}
public NativeResult Execute(string statement, NativeParam[] paramsValue, NativeExecutionOptions options)
{
IServerScript script = _process.PrepareScript(statement);
try
{
if (script.Batches.Count != 1)
{
throw new ArgumentException("Execution statement must contain one, and only one, batch.");
}
IServerBatch batch = script.Batches[0];
DataParams dataParams = NativeMarshal.NativeParamsToDataParams((Server.ServerProcess)_process, paramsValue);
NativeResult result = new NativeResult();
result.Params = paramsValue;
if (batch.IsExpression())
{
IServerExpressionPlan expressionPlan = batch.PrepareExpression(dataParams);
try
{
if (expressionPlan.DataType is Schema.TableType)
{
if (options != NativeExecutionOptions.SchemaOnly)
{
IServerCursor cursor = expressionPlan.Open(dataParams);
try
{
result.Value = NativeMarshal.ServerCursorToNativeValue(_process, cursor);
}
finally
{
expressionPlan.Close(cursor);
}
}
else
{
result.Value = NativeMarshal.TableVarToNativeTableValue(_process, expressionPlan.TableVar);
}
}
else
{
if (options != NativeExecutionOptions.SchemaOnly)
{
using (IDataValue tempValue = expressionPlan.Evaluate(dataParams))
{
result.Value = NativeMarshal.DataValueToNativeValue(_process, tempValue);
}
}
else
{
result.Value = NativeMarshal.DataTypeToNativeValue(_process, expressionPlan.DataType);
}
}
}
finally
{
batch.UnprepareExpression(expressionPlan);
}
}
else
{
IServerStatementPlan statementPlan = batch.PrepareStatement(dataParams);
try
{
if (options != NativeExecutionOptions.SchemaOnly)
{
statementPlan.Execute(dataParams);
}
}
finally
{
batch.UnprepareStatement(statementPlan);
}
}
if (options != NativeExecutionOptions.SchemaOnly)
{
NativeMarshal.SetNativeOutputParams(_process, result.Params, dataParams);
}
return(result);
}
finally
{
_process.UnprepareScript(script);
}
}
public static string Copy(Program program, TableNode sourceTable, TableNode targetTable, GenerateStatementHandler generateStatement)
{
Statement targetStatement =
generateStatement
(
sourceTable,
targetTable,
(Expression)targetTable.EmitStatement(Alphora.Dataphor.DAE.Language.D4.EmitMode.ForCopy)
);
Schema.Key displaySourceKey = program.FindClusteringKey(sourceTable.TableVar);
StringBuilder result = new StringBuilder();
long succeededUpdateCount = 0;
long failedUpdateCount = 0;
bool maxResultLengthMessageWritten = false;
// Start a new process so that we don't mess with the transaction context of this one
ProcessInfo info = new ProcessInfo(program.ServerProcess.ServerSession.SessionInfo);
info.UseImplicitTransactions = false;
IServerProcess targetProcess = ((IServerSession)program.ServerProcess.ServerSession).StartProcess(info);
try
{
Program targetProgram = new Program((ServerProcess)targetProcess);
targetProgram.Code = targetTable;
targetProgram.Start(null);
try
{
// Have the target program use the main program's context
Stack oldTargetContext = targetProgram.SwitchContext(program.Stack);
try
{
info.DefaultIsolationLevel = IsolationLevel.Browse;
IServerProcess sourceProcess = ((IServerSession)program.ServerProcess.ServerSession).StartProcess(info);
try
{
Program sourceProgram = new Program((ServerProcess)sourceProcess);
sourceProgram.Code = sourceTable;
sourceProgram.Start(null);
try
{
// Have the source program use the main program's context
Stack oldSourceContext = sourceProgram.SwitchContext(program.Stack);
try
{
ITable source = (ITable)sourceTable.Execute(sourceProgram);
try
{
source.Open();
// TODO: IBAS Project #26790 - allow cross-process row copies for streamed types
// There is a MarshalRow call in the LocalProcess, would that solve this problem?
using (Row row = new Row(targetProcess.ValueManager, sourceTable.DataType.CreateRowType()))
{
DataParams paramsValue = new DataParams();
paramsValue.Add(new DataParam("ASourceRow", row.DataType, DAE.Language.Modifier.Const, row));
IServerStatementPlan target = targetProcess.PrepareStatement(new D4TextEmitter().Emit(targetStatement), paramsValue);
try
{
target.CheckCompiled();
while (source.Next())
{
row.ClearValues();
targetProcess.BeginTransaction(IsolationLevel.Isolated);
try
{
source.Select(row);
target.Execute(paramsValue);
targetProcess.CommitTransaction();
succeededUpdateCount++;
}
catch (Exception exception)
{
failedUpdateCount++;
targetProcess.RollbackTransaction();
if (result.Length < 100000)
{
result.Append(KeyValuesToString(displaySourceKey, row) + " - " + exception.Message + "\r\n");
}
else
{
if (!maxResultLengthMessageWritten)
{
result.Append(Strings.Get("MaxResultLengthExceeded"));
maxResultLengthMessageWritten = true;
}
}
}
// Yield in case our process is aborted.
program.CheckAborted();
}
}
finally
{
targetProcess.UnprepareStatement(target);
}
}
}
finally
{
source.Close();
}
}
finally
{
sourceProgram.SwitchContext(oldSourceContext); // Don't let the source program cleanup the main context
}
}
finally
{
sourceProgram.Stop(null);
}
}
finally
{
((IServerSession)program.ServerProcess.ServerSession).StopProcess(sourceProcess);
}
result.AppendFormat(Strings.Get("Results"), succeededUpdateCount, failedUpdateCount);
return(result.ToString());
}
finally
{
targetProgram.SwitchContext(oldTargetContext); // Don't let the target program cleanup the main context
}
}
finally
{
targetProgram.Stop(null);
}
}
finally
{
((IServerSession)program.ServerProcess.ServerSession).StopProcess(targetProcess);
}
}
public static void ExecuteScript(IServerProcess process, string script, ScriptExecuteOption options, out ErrorList errors, out TimeSpan timeElapsed, ReportScriptProgressHandler reportScriptProgress, DebugLocator locator)
{
StringBuilder result = new StringBuilder();
errors = new ErrorList();
timeElapsed = TimeSpan.Zero;
bool attemptExecute = true;
DateTime startTime = DateTime.Now;
try
{
IServerScript localScript = process.PrepareScript(script, locator);
try
{
if (ConvertParserErrors(localScript.Messages, errors))
{
foreach (IServerBatch batch in localScript.Batches)
{
PlanStatistics statistics = null;
try
{
if (batch.IsExpression())
{
IServerExpressionPlan plan = batch.PrepareExpression(null);
try
{
attemptExecute &= ConvertCompilerErrors(plan.Messages, errors);
if (attemptExecute)
{
int rowCount = ReadResult(result, plan);
AppendStatistics(result, options, plan.PlanStatistics, plan.ProgramStatistics, rowCount);
statistics = plan.PlanStatistics;
}
}
finally
{
batch.UnprepareExpression(plan);
}
}
else
{
IServerStatementPlan plan = batch.PrepareStatement(null);
try
{
attemptExecute &= ConvertCompilerErrors(plan.Messages, errors);
if (attemptExecute)
{
plan.Execute(null);
AppendStatistics(result, options, plan.PlanStatistics, plan.ProgramStatistics, -1);
statistics = plan.PlanStatistics;
}
}
finally
{
batch.UnprepareStatement(plan);
}
}
}
finally
{
if (reportScriptProgress != null)
{
reportScriptProgress(statistics, result.ToString());
}
result.Length = 0;
}
} // foreach batch...
} // if (no parser errors)...
}
finally
{
process.UnprepareScript(localScript);
}
}
catch (Exception exception)
{
errors.Add(exception);
}
timeElapsed = DateTime.Now - startTime;
}
private DataFhirServerResult Execute(IServerProcess process, string statement, DataParam[] paramsValue)
{
IServerScript script = process.PrepareScript(statement);
try
{
if (script.Batches.Count != 1)
{
throw new ArgumentException("Execution statement must contain one, and only one, batch.");
}
IServerBatch batch = script.Batches[0];
DataParams dataParams = DataFhirMarshal.ParamsArrayToDataParams(process, paramsValue);
DataFhirServerResult result = new DataFhirServerResult();
result.Params = paramsValue;
if (batch.IsExpression())
{
IServerExpressionPlan expressionPlan = batch.PrepareExpression(dataParams);
try
{
if (expressionPlan.DataType is TableType)
{
IServerCursor cursor = expressionPlan.Open(dataParams);
try
{
result.Value = DataFhirMarshal.ServerCursorToValue(process, cursor);
}
finally
{
expressionPlan.Close(cursor);
}
}
else
{
using (IDataValue tempValue = expressionPlan.Evaluate(dataParams))
{
result.Value = DataFhirMarshal.DataValueToValue(process, tempValue);
}
}
}
finally
{
batch.UnprepareExpression(expressionPlan);
}
}
else
{
IServerStatementPlan statementPlan = batch.PrepareStatement(dataParams);
try
{
statementPlan.Execute(dataParams);
}
finally
{
batch.UnprepareStatement(statementPlan);
}
}
//DotNetMarshal.SetNativeOutputParams(process, result.Params, dataParams);
return(result);
}
finally
{
process.UnprepareScript(script);
}
}
