internal static string Parameterize(this System.DateTime value, BuildContext buildContext, DataType dataType, Parameterization p = Parameterization.Value)
{
if (!ParameterizationCriteria(buildContext, p))
{
return(null);
}
var argument = new ParameterArgument(new Value(value, p, dataType));
return(Parameterize(argument, buildContext, p));
}
internal static string Parameterize(this System.Byte[] value, BuildContext buildContext, Parameterization p = Parameterization.Value)
{
if (!ParameterizationCriteria(buildContext, p))
{
return(null);
}
var argument = new ParameterArgument(value);
return(Parameterize(argument, buildContext, p));
}
internal Expression(string arg)
: base(null)
{
Build = (buildContext, buildArgs) =>
{
QueryTalkException exception;
var variable = buildContext.TryGetVariable(arg, out exception);
if (variable.IsInliner())
{
if (variable.DT != DT.InExpression)
{
buildContext.TryTakeException(variable.DT.InvalidInlinerException(GetType().Name,
variable.Name, _inliners));
return(null);
}
string arg2 = variable.Name;
if (buildArgs.Executable != null)
{
ParameterArgument argument = buildArgs.Executable.GetInlinerArgument(arg2);
if (argument.Value != null)
{
arg2 = argument.Build(buildContext, buildArgs);
}
else
{
buildContext.TryTakeException(new QueryTalkException(this,
QueryTalkExceptionType.InlinerArgumentNull,
String.Format("{0} = null", arg2)));
return(null);
}
}
return(arg2.ToString());
}
else if (variable.IsConcatenator())
{
buildContext.TryTakeException(InvalidConcatenationException(variable.Name));
return(null);
}
// non-existing variable or expression string
else
{
// note: non-existing variable will pass the test => the server will throw an error
CheckExpressionString(arg);
return(arg);
}
};
}
// create the parameter from the inline value argument
private static string Parameterize(ParameterArgument argument, BuildContext buildContext, Parameterization p = Parameterization.Value)
{
QueryTalkException exception;
var root = buildContext.ConcatRoot;
// infer param from argument
var param = Variable.InferParam(root, argument, out exception);
TryThrow(exception);
root.TryAddParamOrThrow(param, true);
argument.BuildArgument(root, param.Name);
TryThrow(argument.Exception);
if (p == Parameterization.Value)
{
param.SetParameterizedValue(argument);
}
return(param.Name);
}
/// <summary>
/// Represents a column in the select statement.
/// </summary>
/// <param name="arg">Is a column identifier.</param>
public Column(System.String arg)
: base(arg)
{
SetArgType(arg);
_isVariable = Variable.Detect(arg);
Build = (buildContext, buildArgs) =>
{
if (buildContext == null)
{
return(Filter.Delimit(arg));
}
;
string sql;
Variable variable = TryGetVariable(buildContext);
if (variable.IsInliner())
{
if (!_inliners.Contains(variable.DT))
{
buildContext.TryTakeException(variable.DT.InvalidInlinerException(GetType().Name,
variable.Name, _inliners));
return(null);
}
string arg2 = variable.Name;
if (buildArgs.Executable != null)
{
ParameterArgument inlinerArgument = buildArgs.Executable.GetInlinerArgument(variable.Name);
if (inlinerArgument.Value != null)
{
if (inlinerArgument.Value is System.String)
{
_columnName = (System.String)inlinerArgument.Value;
return(Filter.DelimitColumnMultiPart((string)inlinerArgument.Value, out chainException));
}
else if (inlinerArgument.Value is Column)
{
_columnName = ((Column)inlinerArgument.Value).ColumnName;
return(((Column)inlinerArgument.Value).Build(buildContext, buildArgs));
}
// Column[]
else
{
var columns = (Column[])inlinerArgument.Value;
return(Column.Concatenate(columns, buildContext, buildArgs, null, null, false));
}
}
else
{
buildContext.TryTakeException(new QueryTalkException(this, QueryTalkExceptionType.InlinerArgumentNull,
String.Format("{0} = null", arg2)));
return(null);
}
}
return(arg2);
}
else
{
if (ProcessVariable(buildContext, buildArgs, out sql, variable))
{
return(sql);
}
}
if (buildContext.IsCurrentStringAsValue)
{
return(buildContext.BuildString(arg));
}
sql = Filter.DelimitMultiPartOrParam(arg, IdentifierType.ColumnOrParam, out chainException, out _columnName);
buildContext.TryTakeException(chainException);
return(sql);
};
}
/// <summary>
/// Initializes a new instance of the TableArgument class.
/// </summary>
/// <param name="arg">An argument to convert.</param>
public TableArgument(System.String arg)
: base(arg)
{
SetArgType(arg);
if (CheckNull(Arg(() => arg, arg)))
{
Sql = Filter.DelimitTableMultiPart(arg, out chainException);
}
Build = (buildContext, buildArgs) =>
{
buildContext.TryTakeException(chainException);
TryThrow();
string sql;
Variable variable = TryGetVariable(buildContext);
if (variable.IsInliner())
{
string arg2 = variable.Name;
// check inliner type
if (variable.DT != DT.InTable)
{
buildContext.TryTakeException(variable.DT.InvalidInlinerException(GetType().Name,
arg2, _inliners));
return(null);
}
if (buildArgs.Executable != null)
{
ParameterArgument argument = buildArgs.Executable.GetInlinerArgument(arg2);
if (argument.Value != null)
{
if (argument.Value is System.String)
{
arg2 = Filter.DelimitMultiPartOrParam((string)argument.Value, IdentifierType.Table, out chainException);
}
// Identifier
else
{
arg2 = ((Identifier)argument.Value).Build(buildContext, buildArgs);
}
}
else
{
buildContext.TryTakeException(new QueryTalkException(this,
QueryTalkExceptionType.InlinerArgumentNull,
String.Format("{0} = null", arg2)));
return(null);
}
}
return(arg2);
}
if (ProcessVariable(buildContext, buildArgs, out sql))
{
Sql = sql;
}
else
{
Sql = Filter.DelimitMultiPartOrParam(arg, IdentifierType.Table, out chainException);
buildContext.TryTakeException(chainException);
}
return(Sql);
};
}
internal Table(System.String arg)
: base(arg)
{
SetArgType(arg);
Build = (buildContext, buildArgs) =>
{
string sql;
Variable variable = TryGetVariable(buildContext);
if (variable.IsInliner())
{
string arg2 = variable.Name;
if (variable.DT != DT.InTable)
{
buildContext.TryTakeException(variable.DT.InvalidInlinerException(GetType().Name,
arg2, _inliners));
return(null);
}
if (buildArgs.Executable != null)
{
// get param argument
ParameterArgument argument = buildArgs.Executable.GetInlinerArgument(arg2);
if (argument.Value != null)
{
if (argument.Value is System.String)
{
arg2 = Filter.DelimitTableMultiPart((string)argument.Value, out chainException);
}
else if (argument.Value is View)
{
arg2 = Filter.Enclose(arg2);
}
else
{
arg2 = argument.Build(buildContext, buildArgs);
}
}
else
{
buildContext.TryTakeException(new QueryTalkException(this,
QueryTalkExceptionType.InlinerArgumentNull,
String.Format("{0} = null", arg2)));
return(null);
}
}
return(arg2);
}
else
{
if (ProcessVariable(buildContext, buildArgs, out sql, variable))
{
return(sql);
}
// specific (existing) variable checks
if (variable != null && variable.VariableType.IsParamOrSqlVariable())
{
// variable should be a table
if (!variable.DT.IsTable())
{
buildContext.TryTakeException(CreateException(QueryTalkExceptionType.TableVariableMissing, arg));
return(null);
}
// check concatenation with non-udt table variable (NOT ALLOWED)
if (buildContext.Current.Query.Master.IsConcatenated)
{
if (variable.NameType == null)
{
buildContext.TryTakeException(CreateException(QueryTalkExceptionType.TableVariableDisallowed, arg));
return(null);
}
}
}
}
// default
sql = Filter.DelimitMultiPartOrParam(arg, IdentifierType.Table, out chainException);
buildContext.TryTakeException(chainException);
return(sql);
};
}
/// <summary>
/// Specifies that the parameter is optional.
/// </summary>
/// <param name="prev">A predecessor object.</param>
/// <param name="defaultValue">Is a default value assigned to the parameter in case that a parameter argument is not passed. All optional parameters have to be declared at the end of the parameter declaration.</param>
public static ParamOptionalChainer Optional(this IParamOptional prev, ParameterArgument defaultValue)
{
return(new ParamOptionalChainer((Chainer)prev, defaultValue));
}
// for functions only
internal static string Parameterize(this View view, BuildContext buildContext)
{
var argument = new ParameterArgument(view);
return(Parameterize(argument, buildContext, Parameterization.Value));
}
