private void BuildBody(StringBuilder sql, string bodyWrappedAndEscaped)
{
sql.NewLine(Text.Free.ExecSpExecutesql_N)
.NewLine(Text.Declare).S().Append(Text.Reserved.ReturnValueOuterParam).Append(Text._As_)
.Append(Text.Free.EnclosedInt).Terminate()
.NewLine(Text.Declare).S().Append(Text.Reserved.ConcatVar).Append(Text._As_)
.Append(Text.Free.EnclosedNVarcharMax).Terminate();
if (!Compilable.GetRoot().IsEmbeddedTransaction)
{
sql.NewLine();
}
sql
.Append(bodyWrappedAndEscaped)
.Append(TerminateBody(bodyWrappedAndEscaped));
if (!Compilable.GetRoot().IsEmbeddedTransaction)
{
sql.NewLine();
}
sql
.NewLine(Text.SingleQuote)
.Append(Text.Free.CommaNSingleQuote)
.Append(_paramDeclaration)
.Append(Text.SingleQuote)
.NewLine(Text.Comma)
.Append(_paramAssignment)
.TerminateSingle()
.NewLine();
}
internal static Connectable GetConnectable(Assembly client, Chainer prev, ConnectionData connectionData)
{
if (prev is Connectable)
{
return((Connectable)prev);
}
Connectable connectable;
Compilable compilable = null;
Executable executable = null;
if (prev is Compilable)
{
compilable = (Compilable)prev;
executable = new Executable(compilable);
}
else if (prev is IExecutable)
{
executable = ((Chainer)prev).Executable;
}
else if (prev is Connectable)
{
connectable = (Connectable)prev;
connectable.SetTimeout(connectionData.CommandTimeout);
}
// root:
else
{
compilable = new Procedure(prev);
executable = new Executable(compilable);
}
connectable = new Connectable(client, executable, connectionData);
return(connectable);
}
internal Executable(Compilable compilable)
: base(null)
{
_compilable = compilable;
_rootCompilable = compilable.GetRoot();
Build = (buildContext, buildArgs) =>
{
var sql = new StringBuilder();
// in case of inlining
if (buildArgs.Executable != null)
{
_inlineCaller = buildArgs.Executable;
}
if (buildArgs.TestBody != null)
{
_body = buildArgs.TestBody;
}
else
{
_body = compilable.Build(buildContext, new BuildArgs(this));
}
string bodyWrapped = _body;
// for stored procedures
if (_compilable.CompilableType == Compilable.ObjectType.StoredProc)
{
bodyWrapped = BuildStoredProc();
}
BuildParamAppendix(buildArgs);
string bodyWrappedAndEscaped = Filter.Escape(bodyWrapped);
BuildTableValuedParams(sql);
BuildBody(sql, bodyWrappedAndEscaped);
_sql = sql.ToString();
return(_sql);
};
}
internal PassChainer(Chainer prev, ParameterArgument[] arguments)
: this(prev)
{
Compilable compilable = (Compilable)prev;
var root = GetRoot();
if (arguments == null)
{
arguments = new ParameterArgument[] { Designer.Null };
}
// check arguments-params count match
int argumentsCount = arguments.Count();
int explicitParamsCount = root.ExplicitParams.Count;
if (!root.ParamCountCheck(argumentsCount))
{
ThrowArgumentCountMismatch(explicitParamsCount, argumentsCount);
}
// check each argument
int i = 0;
Array.ForEach(arguments, argument =>
{
if (argument != null && argument.Exception != null)
{
if (argument.Exception.Arguments == null && i < root.ExplicitParams.Count)
{
argument.Exception.Arguments = String.Format("param = {0}", root.ExplicitParams[i].Name);
}
TryThrow(argument.Exception);
}
++i;
});
Executable = new Executable(compilable, arguments);
}
internal Executable(Compilable compilable, ParameterArgument[] arguments)
: this(compilable)
{
AddArguments(arguments);
TryThrow(Text.Method.Pass);
}
// ctor for mapper
internal BuildContext(Mapper creator)
{
_creator = creator;
Current = creator; // mapper is THE ONLY chain object in Navigation Querying
}
// regular ctor
internal BuildContext(Compilable creator, Designer paramRoot = null)
{
_creator = creator;
_paramRoot = paramRoot;
}
