internal void BuildParamAppendix(BuildArgs buildArgs)
{
_paramDeclaration = new StringBuilder();
_paramAssignment = new StringBuilder();
if (Admin.IsValueParameterizationOn && !buildArgs.IsTesting)
{
_rootCompilable.ImplicitParams.ForEach(param =>
{
_arguments.Add(param.ParameterizedValue);
});
}
// return value
_paramDeclaration.Append(Text.Reserved.ReturnValueInnerParam).S()
.Append(Text.Free.EnclosedInt).S().Append(Text.Output);
_paramAssignment.Append(Text.Reserved.ReturnValueInnerParam)
.Append(Text._Equal_)
.Append(Text.Reserved.ReturnValueOuterParam).S()
.Append(Text.Output);
// auto add arguments of optional params (if not passed)
_rootCompilable.ExplicitParams.Where(param => param.IsOptional).ToList()
.ForEach(param =>
{
if (!CheckArgumentByName(param.Name))
{
_arguments.Add(param.Default);
}
});
// exclude inline params, table variable, temp tables and bulk tables
bool paramSeparator = false;
_arguments.Where(argument => argument.DT.IsNotInliner() &&
!argument.DT.IsVTB())
.ToList()
.ForEach(argument =>
{
// param declaration
_paramDeclaration.NewLine(Text.Comma);
_paramDeclaration
.Append(argument.ParamName)
.Append(Text._As_)
.Append(GetParamDeclaration(argument, true, false));
string declarationOutput = String.Empty;
if (argument.IsParamOutput)
{
declarationOutput = Text.OneSpace + Text.Output;
}
_paramDeclaration.Append(declarationOutput);
// marks the beginning of client params
if (!paramSeparator && argument.ParamName != Text.Reserved.ReturnValueInnerParam)
{
_paramAssignment.NewLine()
.NewLine(Text.Free.Params);
paramSeparator = true;
}
_paramAssignment.NewLine(Text.Comma);
// argument is a variable:
// note:
// variables can only be passed in the inner call, otherwise they are treated as string values
if (argument.IsPassedVariable && _inner)
{
_paramAssignment.Append(argument.ParamName)
.Append(Text.Equal)
.Append(argument.Value);
}
// argument is a value:
else
{
_paramAssignment.Append(argument.ParamName)
.Append(Text.Equal);
if (argument.Original is View)
{
// note: inner table param has the same name as outer table param
_paramAssignment.Append(argument.ParamName);
}
else if (argument.IsOutput)
{
_paramAssignment.Append(argument.ParamName)
.Append(Text.Underscore)
.Append(Text.Output);
}
else
{
// the test value has the advantage over the regular value
if (argument.TestValue != null)
{
Testing.AppendTestValue(_paramAssignment, argument);
}
else
{
if (argument.DataType != null)
{
_paramAssignment.Append(Mapping.Build(argument.Value, argument.DataType));
}
else
{
_paramAssignment.Append(Mapping.BuildUnchecked(argument.Value));
}
}
}
}
string assignmentOutput = String.Empty;
if (argument.IsOutput)
{
assignmentOutput = Text.OneSpace + Text.Output;
}
_paramAssignment.Append(assignmentOutput);
});
if (chainException != null)
{
TryThrow(Text.Method.Pass);
}
}
// build the most outer SQL wrapper
internal string BuildOutputWrapper(string execSql)
{
var root = Executable.Compilable.GetRoot();
var outputArguments = ParameterArgument.GetOutputArguments(Executable.Arguments);
var sql = Text.GenerateSql(1000).Append(Text.Free.QueryTalkCode);
// after: drop temp tables
var sqlAfter = Text.GenerateSql(100);
sqlAfter.Append(DropTempTables());
if (root.IsEmbeddedTryCatch)
{
sqlAfter
.NewLine(Text.EndTry)
.NewLine(Text.BeginCatch)
.NewLine(Text.Free.RaiserrorS)
.NewLine(Text.EndCatch).Terminate();
}
sql.Append(Text.Declare).S().Append(Text.Reserved.ReturnValueOuterParam)
.Append(Text._As_).Append(Text.Free.EnclosedInt).Terminate().S()
.Append(Text.Set).S().Append(Text.Reserved.ReturnValueOuterParam).Append(Text._Equal_)
.Append(Text.Zero).Terminate();
// TRY outer wrapper
if (root.IsEmbeddedTryCatch)
{
sql.NewLine(Text.BeginTry);
}
// output arguments
string outputValues = String.Empty;
foreach (var argument in outputArguments)
{
// param in outer wrapper that holds the outer reference
string paramOuterName = String.Format("{0}{1}{2}", argument.ParamName, Text.Underscore, Text.Output);
// before
sql.NewLine(Text.Declare).S()
.Append(paramOuterName).Append(Text._As_)
.Append(Executable.GetParamDeclaration(argument, false, true))
.Terminate().S()
.Append(Text.Set).S().Append(paramOuterName).Append(Text._Equal_);
if (argument.TestValue != null)
{
Testing.AppendTestValue(sql, argument);
}
else
{
sql.Append(Mapping.BuildUnchecked(argument.Value));
}
sql.TerminateSingle();
// after: return output values
outputValues = Text.GenerateSql(100)
.NewLineIndent(Text.Comma)
.Append(paramOuterName)
.Append(Text._As_)
.Append(Filter.Delimit(paramOuterName))
.ToString();
}
// append last sql code: return value + output values
sqlAfter
.NewLine(Text.Select).S()
.Append(Text.Free.ReturnValue)
.Append(Text._As_)
.Append(Text.Reserved.ReturnValueColumnName)
.Append(outputValues);
TryThrow(Text.Method.Pass);
sql.NewLine(execSql)
.Append(sqlAfter.ToString())
.TerminateSingle();
return(sql.ToString());
}
