/// <summary>
/// Executes the scalar function returning the value of a specified type.
/// </summary>
/// <typeparam name="T">The type of a value to return.</typeparam>
/// <param name="client">A client assembly.</param>
/// <param name="arguments">Are the arguments to pass.</param>
protected T GoFunc <T>(System.Reflection.Assembly client, params ParameterArgument[] arguments)
{
return(PublicInvoker.Call <T>(() =>
{
var root = Mapper.GetRoot();
DbMapping.CreateParams(root, this);
var parameters = String.Join(",", root.AllParams.Select(p => p.Name).ToArray());
// build
string sql = Text.GenerateSql(100)
.NewLine(Text.Select).S()
.Append(Map.Name.Sql)
.EncloseLeft()
.Append(parameters)
.EncloseRight()
.Append(Text._As_)
.Append(Text.LeftSquareBracket)
.Append(Text.SingleColumnName)
.Append(Text.RightSquareBracket)
.Terminate()
.ToString();
Mapper.SetSql(sql);
var cpass = new PassChainer(Mapper, arguments);
var connectable = Reader.GetConnectable(client, cpass);
return Reader.LoadTable <Row <T> >(connectable, null, true).ToValue <T>();
}));
}
private void BodyMethod(IExecutable iexecutable, string returnVariable)
{
ReturnVariable = returnVariable;
_innerObject = iexecutable as Chainer;
if (iexecutable is Compilable)
{
Executable = new Executable((Compilable)iexecutable);
}
else if (iexecutable is DbProcedure)
{
var dbProc = (DbProcedure)iexecutable;
dbProc.BuildProc(null);
var cpass = new PassChainer(dbProc);
Executable = cpass.Executable;
_innerObject = cpass;
}
// PassChainer
else
{
Executable = ((Chainer)iexecutable).Executable;
}
Executable.Inner = true; // important!
Executable.ArgumentsCriticalCheck(false);
TryThrow(Executable.Exception);
}
/// <summary>
/// Executes a stored procedure or SQL batch.
/// </summary>
/// <param name="procOrBatch">Is a stored procedure or SQL batch.</param>
public Result ExecGo(ExecArgument procOrBatch)
{
return(PublicInvoker.Call <Result>(Assembly.GetCallingAssembly(), (ca) =>
{
var cpass = PassChainer.Create(_root, procOrBatch);
var connectable = Reader.GetConnectable(ca, cpass, this);
return Reader.LoadAll(connectable);
}));
}
internal static ExecChainer Create(
Chainer prev,
ExecArgument executable,
string returnValueToVariable,
ParameterArgument[] arguments)
{
if (executable.Exception != null)
{
executable.Exception.ObjectName = prev.GetRoot().Name;
executable.Exception.Arguments = "executable = null";
executable.Exception.Method = Text.Method.Exec;
throw executable.Exception;
}
QueryTalkException exception;
var root = prev.GetRoot();
Variable inliner = null;
if (executable.Original is System.String)
{
inliner = root.TryGetVariable((string)executable.Original,
out exception, Variable.SearchType.Inliner);
}
exception = null;
// stored procedure, SQL batch, mapped stored procedure
if (inliner == null)
{
var cpass = PassChainer.Create(new InternalRoot(), executable);
return(new ExecChainer((Chainer)prev, cpass, returnValueToVariable));
}
// inliner: stored procedure, procedure, SQL
else
{
if (inliner.DT == DT.InProcedure)
{
return(new ExecChainer(prev, inliner, returnValueToVariable, arguments));
}
else if (inliner.DT == DT.InStoredProcedure)
{
return(new ExecChainer(prev, inliner, returnValueToVariable, arguments));
}
else if (inliner.DT == DT.InSql)
{
return(new ExecChainer(prev, inliner, returnValueToVariable, arguments));
}
else
{
exception = inliner.DT.InvalidInlinerException(typeof(ExecChainer).ToString(),
inliner.Name, _inliners);
exception.ObjectName = root.Name;
exception.Method = Text.Method.Exec;
throw exception;
}
}
}
/// <summary>
/// Executes a stored procedure or SQL batch asynchronously.
/// </summary>
/// <param name="procOrBatch">Is a stored procedure or SQL batch.</param>
/// <param name="onCompleted">A delegate method that is called when the asynchronous operation completes.</param>
/// <returns>The object of the asynchronous operation.</returns>
public Async ExecGoAsync(ExecArgument procOrBatch, Action <Result> onCompleted = null)
{
return(PublicInvoker.Call <Async>(Assembly.GetCallingAssembly(), (ca) =>
{
var cpass = PassChainer.Create(_root, procOrBatch);
var connectable = Reader.GetConnectable(ca, cpass, this);
connectable.OnAsyncCompleted = onCompleted;
return Reader.LoadAllAsync(connectable);
}));
}
/// <summary>
/// Executes the procedure returning a strongly typed result set.
/// </summary>
/// <param name="client">A client assembly.</param>
/// <param name="arguments">Are the arguments to pass.</param>
protected Result <T> Go <T>(Assembly client, params ParameterArgument[] arguments)
{
return(PublicInvoker.Call <Result <T> >(() =>
{
BuildProc(arguments);
var cpass = new PassChainer(Mapper, arguments);
var connectable = Reader.GetConnectable(client, this, cpass);
return Reader.LoadTable <T>(connectable, null);
}));
}
private static SubResult ProcessPackage_UpdateRows <T>(
Assembly client,
IEnumerable <T> package,
NodeMap map,
ConnectBy connectBy,
Nullable <bool> identityInsert)
where T : DbRow
{
List <ParameterArgument> args = new List <ParameterArgument>();
args.Add(ViewConverter.ConvertDbRowData(package, false, true)); // #Rows
args.Add(map.Name); // @Table
args.Add(map.GetColumnsForUpdate(2)); // @SourceColumns
args.Add(map.GetColumnsForUpdate(null)); // @TargetColumns
args.Add(map.BuildSelfRelationWithOriginalValues(1, 2).E()); // @OnUpdate
args.Add(map.BuildSelfRelation(1, 2).E()); // @OnSelect
args.Add(map.GetColumns(1, 2)); // @AllColumns (with RowID)
PassChainer cpass = _updateRowsProc.Pass(args.ToArray());
cpass.SetRootMap(map.ID); // important!
var connectable = Reader.GetConnectable(client, cpass, connectBy);
var result = connectable.Go();
var data = result.Table2.ToList();
var computedIndexes = map.SortedComputedColumns.Select(a => a.ID.ColumnZ).ToArray();
var hasComputedColumns = computedIndexes.Length > 0;
var i = 0;
var count = result.RowCount;
var updated = result.Table1.ToList();
foreach (var row in package)
{
if (i >= count)
{
break;
}
if (((IRow)row).RowID == updated[i].RowID)
{
if (hasComputedColumns)
{
PropertyAccessor.SetValues(row, PropertyAccessor.GetValues(data[i], Text.Reserved.QtRowIDColumnName),
computedIndexes);
}
row.SetStatus(DbRowStatus.Loaded);
++i;
}
}
return(new SubResult(true, result.ReturnValue));
}
/// <summary>
/// Executes a stored procedure or SQL batch asynchronously.
/// </summary>
/// <typeparam name="T">The type of the result set that is returned by the execution.</typeparam>
/// <param name="procOrBatch">Is a stored procedure or SQL batch.</param>
/// <param name="onCompleted">A delegate method that is called when the asynchronous operation completes.</param>
/// <returns>The object of the asynchronous operation.</returns>
public Async <Result <T> > ExecGoAsync <T>(ExecArgument procOrBatch, Action <Result <T> > onCompleted = null)
{
return(PublicInvoker.Call <Async <Result <T> > >(Assembly.GetCallingAssembly(), (ca) =>
{
var cpass = PassChainer.Create(_root, procOrBatch);
var connectable = Reader.GetConnectable(ca, cpass, this);
connectable.OnAsyncCompleted = onCompleted;
if (typeof(T) == typeof(DataTable))
{
return Reader.LoadDataTableAsync <T>(connectable);
}
else
{
return Reader.LoadTableAsync <T>(connectable, null);
}
}));
}
private static SubResult ProcessPackage_DeleteRows <T>(
Assembly client,
IEnumerable <T> package,
NodeMap map,
ConnectBy connectBy,
Nullable <bool> identityInsert)
where T : DbRow
{
List <ParameterArgument> args = new List <ParameterArgument>();
args.Add(ViewConverter.ConvertDbRowData(package, false, true)); // #Rows
args.Add(map.Name); // @Table
args.Add(map.BuildSelfRelationWithOriginalValues(1, 2).E()); // @On
PassChainer cpass = _deleteRowsProc.Pass(args.ToArray());
cpass.SetRootMap(map.ID); // important!
var connectable = Reader.GetConnectable(client, cpass, connectBy);
var result = connectable.Go();
var i = 0;
var count = result.RowCount;
var deleted = result.ToList();
foreach (var row in package)
{
if (i >= count)
{
break;
}
if (((IRow)row).RowID == deleted[i].RowID)
{
row.SetStatus(DbRowStatus.Deleted);
++i;
}
}
return(new SubResult(true, result.ReturnValue));
}
/// <summary>
/// Executes a stored procedure or SQL batch.
/// </summary>
/// <typeparam name="T">The type of the result set that is returned by the execution.</typeparam>
/// <param name="procOrBatch">Is a stored procedure or SQL batch.</param>
public Result <T> ExecGo <T>(ExecArgument procOrBatch)
{
return(PublicInvoker.Call <Result <T> >(Assembly.GetCallingAssembly(), (ca) =>
{
var cpass = PassChainer.Create(_root, procOrBatch);
var connectable = Reader.GetConnectable(ca, cpass, this);
Result <T> result;
if (typeof(T) == typeof(DataTable))
{
result = Reader.LoadDataTable <T>(connectable);
}
else
{
result = Reader.LoadTable <T>(connectable, null);
}
return result;
}));
}
// inliner: procedure, snippet, stored procedure
private ExecChainer(
Chainer prev,
Variable inliner,
string returnValueToVariable,
params ParameterArgument[] arguments) : base(prev)
{
Build = (buildContext, buildArgs) =>
{
ParameterArgument inlinerArgument = buildArgs.Executable.GetInlinerArgument(inliner.Name);
if (inlinerArgument.Value == null)
{
buildContext.TryTakeException(new QueryTalkException(this,
QueryTalkExceptionType.InlinerArgumentNull,
String.Format("{0} = null", inliner.Name)));
return(null);
}
if (inliner.DT == DT.InProcedure)
{
if (inlinerArgument.DT != DT.InProcedure)
{
buildContext.TryTakeException(inliner.DT.InvalidInlinerException(GetType().Name,
inliner.Name, _procInliners));
return(null);
}
PassChainer cpass;
if (inlinerArgument.ArgType == typeof(PassChainer))
{
cpass = (PassChainer)inlinerArgument.Original;
}
// inliner variable
else
{
var proc = (Procedure)inlinerArgument.Original;
cpass = new PassChainer(proc, arguments);
}
BodyMethod(cpass, returnValueToVariable);
return(BuildExecProc(buildContext, buildArgs));
}
else if (inliner.DT == DT.InStoredProcedure)
{
if (inlinerArgument.DT != DT.InStoredProcedure)
{
buildContext.TryTakeException(inliner.DT.InvalidInlinerException(GetType().Name,
inliner.Name, _sprocInliners));
return(null);
}
PassChainer cpass;
if (inlinerArgument.ArgType == typeof(PassChainer))
{
cpass = (PassChainer)inlinerArgument.Original;
}
else if (inlinerArgument.ArgType == typeof(ExecArgument))
{
cpass = PassChainer.Create(new InternalRoot(), (ExecArgument)inlinerArgument.Original);
}
// inliner variable
else
{
var execArgument = ((string)inlinerArgument.Original).Pass(arguments);
cpass = PassChainer.Create(new InternalRoot(), execArgument);
}
BodyMethod(cpass, returnValueToVariable);
return(BuildExecProc(buildContext, buildArgs));
}
else
{
if (inlinerArgument.DT != DT.InSql)
{
buildContext.TryTakeException(inliner.DT.InvalidInlinerException(GetType().Name,
inliner.Name, _sqlInliners));
return(null);
}
PassChainer cpass;
if (inlinerArgument.ArgType == typeof(ExecArgument))
{
cpass = PassChainer.Create(new InternalRoot(), (ExecArgument)inlinerArgument.Original);
}
// inliner variable
else
{
var execArgument = ((string)inlinerArgument.Original).Pass(arguments);
cpass = PassChainer.Create(new InternalRoot(), execArgument);
}
BodyMethod(cpass, null);
return(BuildExecProc(buildContext, buildArgs));
}
};
}
/// <summary>
/// Sets the argument's type.
/// </summary>
/// <param name="arg">Is an argument.</param>
protected internal void SetArgType(PassChainer arg)
{
ArgType = typeof(PassChainer);
SetDebugValue(arg, DebugSetter.Arg);
}
