public void Execute(ref RemoteParamData paramsValue, ProcessCallInfo callInfo)
{
foreach (ClientBatch batch in _clientBatches)
{
batch.Execute(ref paramsValue, callInfo);
}
}
public void Execute(DataParams paramsValue)
{
RemoteParamData localParamsValue = _script._process.DataParamsToRemoteParamData(paramsValue);
_batch.Execute(ref localParamsValue, _script._process.GetProcessCallInfo());
_script._process.RemoteParamDataToDataParams(paramsValue, localParamsValue);
}
/// <summary> Opens a remote, server-side cursor based on the prepared statement this plan represents. </summary>
/// <returns> An <see cref="IRemoteServerCursor"/> instance for the prepared statement. </returns>
public IRemoteServerCursor Open(ref RemoteParamData paramsValue, out ProgramStatistics executeTime, ProcessCallInfo callInfo)
{
_process.ProcessCallInfo(callInfo);
try
{
DataParams localParamsValue = _process.RemoteParamDataToDataParams(paramsValue);
IServerCursor serverCursor = ServerExpressionPlan.Open(localParamsValue);
RemoteServerCursor cursor = new RemoteServerCursor(this, (ServerCursor)serverCursor);
try
{
cursor.Open();
_process.DataParamsToRemoteParamData(localParamsValue, ref paramsValue);
executeTime = ServerExpressionPlan.ProgramStatistics;
return(cursor);
}
catch
{
Close(cursor, _process.EmptyCallInfo());
throw;
}
}
catch (Exception E)
{
throw WrapException(E);
}
}
public IServerCursor OpenCursor(string expression, DataParams paramsValue)
{
#if LOGCACHEEVENTS
FSession.FServer.FInternalServer.LogMessage(String.Format("Thread {0} opening cursor '{1}'.", Thread.CurrentThread.GetHashCode(), AExpression));
#endif
RemoteParamData localParamsValue = DataParamsToRemoteParamData(paramsValue);
IRemoteServerExpressionPlan plan;
IRemoteServerCursor cursor;
PlanDescriptor descriptor;
ProgramStatistics executeTime;
LocalExpressionPlan localPlan;
LocalCursor localCursor;
if (ProcessInfo.FetchAtOpen && (ProcessInfo.FetchCount > 1))
{
Guid[] bookmarks;
RemoteFetchData fetchData;
cursor = _process.OpenCursor(expression, ref localParamsValue, out plan, out descriptor, out executeTime, GetProcessCallInfo(), GetProcessCleanupInfo(), out bookmarks, ProcessInfo.FetchCount, out fetchData);
RemoteParamDataToDataParams(paramsValue, localParamsValue);
localPlan = new LocalExpressionPlan(this, plan, descriptor, paramsValue, executeTime);
localCursor = new LocalCursor(localPlan, cursor);
localCursor.ProcessFetchData(fetchData, bookmarks, true);
}
else
{
cursor = _process.OpenCursor(expression, ref localParamsValue, out plan, out descriptor, out executeTime, GetProcessCallInfo(), GetProcessCleanupInfo());
RemoteParamDataToDataParams(paramsValue, localParamsValue);
localPlan = new LocalExpressionPlan(this, plan, descriptor, paramsValue, executeTime);
localCursor = new LocalCursor(localPlan, cursor);
}
return(localCursor);
}
public IRemoteServerCursor Open(ref RemoteParamData paramsValue, out ProgramStatistics executeTime, out Guid[] bookmarks, int count, out RemoteFetchData fetchData, ProcessCallInfo callInfo)
{
IRemoteServerCursor serverCursor = Open(ref paramsValue, out executeTime, callInfo);
fetchData = serverCursor.Fetch(out bookmarks, count, true, _process.EmptyCallInfo());
return(serverCursor);
}
public void Execute(string statement, DataParams paramsValue)
{
RemoteParamData paramData = DataParamsToRemoteParamData(paramsValue);
_process.Execute(statement, ref paramData, GetProcessCallInfo(), GetProcessCleanupInfo());
RemoteParamDataToDataParams(paramsValue, paramData);
}
// OpenCursor
public IRemoteServerCursor OpenCursor
(
string expression,
ref RemoteParamData paramsValue,
out IRemoteServerExpressionPlan plan,
out PlanDescriptor planDescriptor,
out ProgramStatistics executeTime,
ProcessCallInfo callInfo,
RemoteProcessCleanupInfo cleanupInfo,
out Guid[] bookmarks,
int count,
out RemoteFetchData fetchData
)
{
ProcessCallInfo(callInfo);
plan = PrepareExpression(expression, paramsValue.Params, null, out planDescriptor, cleanupInfo);
try
{
IRemoteServerCursor cursor = plan.Open(ref paramsValue, out executeTime, EmptyCallInfo());
fetchData = cursor.Fetch(out bookmarks, count, true, EmptyCallInfo());
return(cursor);
}
catch
{
UnprepareExpression(plan);
plan = null;
throw;
}
}
public void RemoteParamDataToDataParams(DataParams paramsValue, RemoteParamData remoteParams)
{
if ((paramsValue != null) && (paramsValue.Count > 0))
{
Schema.RowType rowType = new Schema.RowType();
foreach (DataParam param in paramsValue)
{
rowType.Columns.Add(new Schema.Column(param.Name, param.DataType));
}
using (Row row = new Row(this.ValueManager, rowType))
{
row.ValuesOwned = false;
row.AsPhysical = remoteParams.Data.Data;
for (int index = 0; index < paramsValue.Count; index++)
{
if (paramsValue[index].Modifier != Modifier.In)
{
if (row.HasValue(index))
{
paramsValue[index].Value = DataValue.CopyValue(_internalProcess.ValueManager, row[index]);
}
else
{
paramsValue[index].Value = null;
}
}
}
}
}
}
public void DataParamsToRemoteParamData(DataParams paramsValue, ref RemoteParamData remoteParams)
{
if (paramsValue != null)
{
Schema.RowType rowType = new Schema.RowType();
for (int index = 0; index < paramsValue.Count; index++)
{
rowType.Columns.Add(new Schema.Column(paramsValue[index].Name, paramsValue[index].DataType));
}
Row row = new Row(_serverProcess.ValueManager, rowType);
try
{
row.ValuesOwned = false;
for (int index = 0; index < paramsValue.Count; index++)
{
row[index] = paramsValue[index].Value;
}
remoteParams.Data.Data = row.AsPhysical;
}
finally
{
row.Dispose();
}
}
}
public IRemoteServerCursor Open(ref RemoteParamData paramsValue, out ProgramStatistics executeTime, out Guid[] bookmarks, int count, out RemoteFetchData fetchData, ProcessCallInfo callInfo)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginOpenPlanCursorWithFetch(PlanHandle, callInfo, paramsValue, count, null, null);
result.AsyncWaitHandle.WaitOne();
CursorWithFetchResult cursorResult = channel.EndOpenPlanCursorWithFetch(result);
executeTime = cursorResult.ExecuteTime;
_programStatistics = executeTime;
paramsValue.Data = cursorResult.ParamData;
bookmarks = cursorResult.Bookmarks;
fetchData = cursorResult.FetchData;
return(new ClientCursor(this, cursorResult.CursorDescriptor));
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public IRemoteServerCursor OpenCursor(string expression, ref RemoteParamData paramsValue, out IRemoteServerExpressionPlan plan, out PlanDescriptor planDescriptor, out ProgramStatistics executeTime, ProcessCallInfo callInfo, RemoteProcessCleanupInfo cleanupInfo, out Guid[] bookmarks, int count, out RemoteFetchData fetchData)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginOpenCursorWithFetch(ProcessHandle, GetCleanupInfo(cleanupInfo), callInfo, expression, paramsValue, count, null, null);
result.AsyncWaitHandle.WaitOne();
DirectCursorWithFetchResult cursorResult = channel.EndOpenCursorWithFetch(result);
paramsValue.Data = cursorResult.ParamData;
planDescriptor = cursorResult.PlanDescriptor;
executeTime = cursorResult.ExecuteTime;
bookmarks = cursorResult.Bookmarks;
fetchData = cursorResult.FetchData;
plan = new ClientExpressionPlan(this, planDescriptor);
return(new ClientCursor((ClientExpressionPlan)plan, cursorResult.CursorDescriptor));
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public void Execute(DataParams paramsValue)
{
RemoteParamData localParamsValue = ((LocalProcess)_process).DataParamsToRemoteParamData(paramsValue);
_script.Execute(ref localParamsValue, _process.GetProcessCallInfo());
((LocalProcess)_process).RemoteParamDataToDataParams(paramsValue, localParamsValue);
}
/// <summary>Executes the prepared statement this plan represents.</summary>
public void Execute(DataParams paramsValue)
{
RemoteParamData localParamsValue = _process.DataParamsToRemoteParamData(paramsValue);
_plan.Execute(ref localParamsValue, out _programStatistics, _process.GetProcessCallInfo());
_programStatisticsCached = false;
_process.RemoteParamDataToDataParams(paramsValue, localParamsValue);
}
// Execute
public void Execute(string statement, ref RemoteParamData paramsValue, ProcessCallInfo callInfo, RemoteProcessCleanupInfo cleanupInfo)
{
ProcessCallInfo(callInfo);
DataParams localParamsValue = RemoteParamsToDataParams(paramsValue.Params);
_serverProcess.Execute(statement, localParamsValue);
DataParamsToRemoteParamData(localParamsValue, ref paramsValue);
}
public IDataValue Evaluate(DataParams paramsValue)
{
RemoteParamData localParamsValue = _process.DataParamsToRemoteParamData(paramsValue);
byte[] result = _plan.Evaluate(ref localParamsValue, out _programStatistics, _process.GetProcessCallInfo());
_programStatisticsCached = false;
_process.RemoteParamDataToDataParams(paramsValue, localParamsValue);
return(result == null ? null : DataValue.FromPhysical(_process.ValueManager, DataType, result, 0));
}
public void Execute(ref RemoteParamData paramsValue, ProcessCallInfo callInfo)
{
_process.ProcessCallInfo(callInfo);
foreach (RemoteServerBatch batch in _batches)
{
batch.Execute(ref paramsValue, _process.EmptyCallInfo());
}
}
public void Execute(ref RemoteParamData paramsValue, ProcessCallInfo callInfo)
{
ProgramStatistics executeTime;
if (IsExpression())
{
((IRemoteServerExpressionPlan)Prepare(paramsValue.Params)).Evaluate(ref paramsValue, out executeTime, callInfo);
}
else
{
((IRemoteServerStatementPlan)Prepare(paramsValue.Params)).Execute(ref paramsValue, out executeTime, callInfo);
}
}
public void Execute(ref RemoteParamData paramsValue, out ProgramStatistics executeTime, ProcessCallInfo callInfo)
{
_process.ProcessCallInfo(callInfo);
try
{
DataParams localParamsValue = _process.RemoteParamDataToDataParams(paramsValue);
ServerStatementPlan.Execute(localParamsValue);
_process.DataParamsToRemoteParamData(localParamsValue, ref paramsValue);
executeTime = ServerStatementPlan.ProgramStatistics;
}
catch (Exception E)
{
throw WrapException(E);
}
}
public void Execute(ref RemoteParamData paramsValue, ProcessCallInfo callInfo)
{
_script.Process.ProcessCallInfo(callInfo);
try
{
RemoteParam[] localParamsValue = new RemoteParam[paramsValue.Params == null ? 0 : paramsValue.Params.Length];
for (int index = 0; index < (paramsValue.Params == null ? 0 : paramsValue.Params.Length); index++)
{
localParamsValue[index].Name = paramsValue.Params[index].Name;
localParamsValue[index].TypeName = paramsValue.Params[index].TypeName;
localParamsValue[index].Modifier = paramsValue.Params[index].Modifier;
}
if (IsExpression())
{
PlanDescriptor planDescriptor;
IRemoteServerExpressionPlan plan = PrepareExpression(localParamsValue, out planDescriptor);
try
{
ProgramStatistics programStatistics;
plan.Close(plan.Open(ref paramsValue, out programStatistics, _script.Process.EmptyCallInfo()), _script.Process.EmptyCallInfo());
// TODO: Provide a mechanism for determining whether or not an expression should be evaluated or opened through the remoting CLI.
}
finally
{
UnprepareExpression(plan);
}
}
else
{
PlanDescriptor planDescriptor;
IRemoteServerStatementPlan plan = PrepareStatement(localParamsValue, out planDescriptor);
try
{
ProgramStatistics programStatistics;
plan.Execute(ref paramsValue, out programStatistics, callInfo);
}
finally
{
UnprepareStatement(plan);
}
}
}
catch (Exception E)
{
throw WrapException(E);
}
}
public void Execute(string statement, ref RemoteParamData paramsValue, ProcessCallInfo callInfo, RemoteProcessCleanupInfo cleanupInfo)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginExecuteStatement(ProcessHandle, GetCleanupInfo(cleanupInfo), callInfo, statement, paramsValue, null, null);
result.AsyncWaitHandle.WaitOne();
ExecuteResult executeResult = channel.EndExecuteStatement(result);
paramsValue.Data = executeResult.ParamData;
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public DataParams RemoteParamDataToDataParams(RemoteParamData paramsValue)
{
if ((paramsValue.Params != null) && (paramsValue.Params.Length > 0))
{
DataParams localParamsValue = new DataParams();
Schema.RowType rowType = new Schema.RowType();
for (int index = 0; index < paramsValue.Params.Length; index++)
{
rowType.Columns.Add(new Schema.Column(paramsValue.Params[index].Name, (Schema.ScalarType)_serverProcess.ServerSession.Server.Catalog[paramsValue.Params[index].TypeName]));
}
Row row = new Row(_serverProcess.ValueManager, rowType);
try
{
row.ValuesOwned = false;
row.AsPhysical = paramsValue.Data.Data;
for (int index = 0; index < paramsValue.Params.Length; index++)
{
if (row.HasValue(index))
{
localParamsValue.Add(new DataParam(row.DataType.Columns[index].Name, row.DataType.Columns[index].DataType, RemoteModifierToModifier(paramsValue.Params[index].Modifier), DataValue.CopyValue(_serverProcess.ValueManager, row[index])));
}
else
{
localParamsValue.Add(new DataParam(row.DataType.Columns[index].Name, row.DataType.Columns[index].DataType, RemoteModifierToModifier(paramsValue.Params[index].Modifier), null));
}
}
return(localParamsValue);
}
finally
{
row.Dispose();
}
}
else
{
return(null);
}
}
public void Execute(ref RemoteParamData paramsValue, out ProgramStatistics executeTime, ProcessCallInfo callInfo)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginExecutePlan(PlanHandle, callInfo, paramsValue, null, null);
result.AsyncWaitHandle.WaitOne();
ExecuteResult executeResult = channel.EndExecutePlan(result);
executeTime = executeResult.ExecuteTime;
paramsValue.Data = executeResult.ParamData;
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
public RemoteParamData DataParamsToRemoteParamData(DataParams paramsValue)
{
int paramCount = paramsValue != null ? paramsValue.Count : 0;
if (paramCount > 0)
{
Schema.RowType rowType = new Schema.RowType();
if (paramsValue != null)
{
foreach (DataParam param in paramsValue)
{
rowType.Columns.Add(new Schema.Column(param.Name, param.DataType));
}
}
using (Row row = new Row(this.ValueManager, rowType))
{
row.ValuesOwned = false;
RemoteParamData localParamsValue = new RemoteParamData();
localParamsValue.Params = new RemoteParam[paramCount];
for (int index = 0; index < paramCount; index++)
{
localParamsValue.Params[index].Name = paramsValue[index].Name;
localParamsValue.Params[index].TypeName = paramsValue[index].DataType.Name;
localParamsValue.Params[index].Modifier = ModifierToRemoteModifier(paramsValue[index].Modifier);
if (paramsValue[index].Value != null)
{
row[index] = paramsValue[index].Value;
}
}
EnsureOverflowReleased(row);
localParamsValue.Data.Data = row.AsPhysical;
return(localParamsValue);
}
}
else // optimization
{
return(new RemoteParamData());
}
}
public IDataValue Evaluate(string expression, DataParams paramsValue)
{
#if USECOLLAPSEDEVALUATECALLS
#if LOGCACHEEVENTS
FSession.FServer.FInternalServer.LogMessage(String.Format("Thread {0} evaluating expression '{1}'.", Thread.CurrentThread.GetHashCode(), AExpression));
#endif
RemoteParamData localParamsValue = DataParamsToRemoteParamData(AParams);
IRemoteServerExpressionPlan plan;
PlanDescriptor planDescriptor;
ProgramStatistics executeTime;
byte[] result = FProcess.Evaluate(AExpression, ref localParamsValue, out plan, out planDescriptor, out executeTime, GetProcessCallInfo(), GetProcessCleanupInfo());
RemoteParamDataToDataParams(AParams, localParamsValue);
#if LOGCACHEEVENTS
FSession.FServer.FInternalServer.LogMessage(String.Format("Thread {0} expression evaluated.", Thread.CurrentThread.GetHashCode()));
#endif
LocalExpressionPlan localPlan = new LocalExpressionPlan(this, plan, planDescriptor, AParams);
try
{
return(result == null ? null : DataValue.FromPhysical(this.ValueManager, localPlan.DataType, result, 0));
}
finally
{
UnprepareExpression(localPlan);
}
#else
IServerExpressionPlan localPlan = PrepareExpression(expression, paramsValue);
try
{
return(localPlan.Evaluate(paramsValue));
}
finally
{
UnprepareExpression(localPlan);
}
#endif
}
public byte[] Evaluate(string expression, ref RemoteParamData paramsValue, out IRemoteServerExpressionPlan plan, out PlanDescriptor planDescriptor, out ProgramStatistics executeTime, ProcessCallInfo callInfo, RemoteProcessCleanupInfo cleanupInfo)
{
try
{
var channel = GetServiceInterface();
IAsyncResult result = channel.BeginEvaluateExpression(ProcessHandle, GetCleanupInfo(cleanupInfo), callInfo, expression, paramsValue, null, null);
result.AsyncWaitHandle.WaitOne();
DirectEvaluateResult evaluateResult = channel.EndEvaluateExpression(result);
paramsValue.Data = evaluateResult.ParamData;
planDescriptor = evaluateResult.PlanDescriptor;
executeTime = evaluateResult.ExecuteTime;
plan = new ClientExpressionPlan(this, planDescriptor);
return(evaluateResult.Result);
}
catch (FaultException <DataphorFault> fault)
{
throw DataphorFaultUtility.FaultToException(fault.Detail);
}
catch (CommunicationException ce)
{
ReportCommunicationError();
throw new ServerException(ServerException.Codes.CommunicationFailure, ErrorSeverity.Environment, ce);
}
}
/// <summary>Opens a server-side cursor based on the prepared statement this plan represents.</summary>
/// <returns>An <see cref="IServerCursor"/> instance for the prepared statement.</returns>
public IServerCursor Open(DataParams paramsValue)
{
RemoteParamData localParamsValue = ((LocalProcess)_process).DataParamsToRemoteParamData(paramsValue);
IRemoteServerCursor serverCursor;
LocalCursor cursor;
if (_process.ProcessInfo.FetchAtOpen && (_process.ProcessInfo.FetchCount > 1) && Supports(CursorCapability.Bookmarkable))
{
Guid[] bookmarks;
RemoteFetchData fetchData;
serverCursor = _plan.Open(ref localParamsValue, out _programStatistics, out bookmarks, _process.ProcessInfo.FetchCount, out fetchData, _process.GetProcessCallInfo());
_programStatisticsCached = false;
cursor = new LocalCursor(this, serverCursor);
cursor.ProcessFetchData(fetchData, bookmarks, true);
}
else
{
serverCursor = _plan.Open(ref localParamsValue, out _programStatistics, _process.GetProcessCallInfo());
_programStatisticsCached = false;
cursor = new LocalCursor(this, serverCursor);
}
((LocalProcess)_process).RemoteParamDataToDataParams(paramsValue, localParamsValue);
return(cursor);
}
// OpenCursor
public IRemoteServerCursor OpenCursor
(
string expression,
ref RemoteParamData paramsValue,
out IRemoteServerExpressionPlan plan,
out PlanDescriptor planDescriptor,
out ProgramStatistics executeTime,
ProcessCallInfo callInfo,
RemoteProcessCleanupInfo cleanupInfo
)
{
ProcessCallInfo(callInfo);
plan = PrepareExpression(expression, paramsValue.Params, null, out planDescriptor, cleanupInfo);
try
{
return(plan.Open(ref paramsValue, out executeTime, EmptyCallInfo()));
}
catch
{
UnprepareExpression(plan);
plan = null;
throw;
}
}
public byte[] Evaluate(ref RemoteParamData paramsValue, out ProgramStatistics executeTime, ProcessCallInfo callInfo)
{
_process.ProcessCallInfo(callInfo);
try
{
DataParams localParamsValue = _process.RemoteParamDataToDataParams(paramsValue);
IDataValue tempValue = ServerExpressionPlan.Evaluate(localParamsValue);
_process.DataParamsToRemoteParamData(localParamsValue, ref paramsValue);
executeTime = ServerExpressionPlan.ProgramStatistics;
if (tempValue == null)
{
return(null);
}
if (ServerExpressionPlan.DataType.Equivalent(tempValue.DataType))
{
return(tempValue.AsPhysical);
}
return(tempValue.CopyAs(ServerExpressionPlan.DataType).AsPhysical);
}
catch (Exception E)
{
throw WrapException(E);
}
}
