private static bool ParameterizationCriteria(BuildContext buildContext, Parameterization p = Parameterization.None)
{
if (buildContext == null)
{
return(false);
}
if (p == Parameterization.Param)
{
return(true);
}
var root = buildContext.Root;
return
(Admin.IsValueParameterizationOn
&&
(root.CompilableType.IsProcOrSnipOrMapper() ||
(root.CompilableType == Compilable.ObjectType.View &&
(buildContext.ParamRoot.CompilableType.IsProcOrSnipOrMapper()))
)
&&
// do not parameterize non-parameterizable arguments (DeclareChainer, SetChainer, RaiserrorChainer)
!(buildContext.Current is INonParameterizable));
}
internal virtual void BuildParameterizations(IDictionary <Type, Parameterization> result, Type type, IList <Exception> errors)
{
if (type == typeof(object))
{
return;
}
BuildParameterizations(result, type.BaseType, errors);
SuiteClasses annotation = type.getAnnotation(typeof(SuiteClasses));
if (annotation != null)
{
foreach (Type test in annotation.value())
{
if (!result.ContainsKey(test))
{
try
{
result[test] = new Parameterization(this, test.GetConstructor(type));
}
catch (InitializationError failure)
{
((IList <Exception>)errors).AddRange(failure.Causes);
}
catch (NoSuchMethodException e)
{
errors.Add(e);
}
}
}
}
}
public Record(string name, double min, double max, bool computed, Parameterization param)
{
ReadableName = name;
MinimumValue = min;
MaximumValue = max;
Computed = computed;
Params = param;
}
public static Interval GetReasonableInterval(this Parameterization parameterization)
{
if (parameterization.Bounds.Start == null)
{
return(Interval.Create(-1000, 1000));
}
return(Interval.Create(parameterization.Bounds.Start.Value, parameterization.Bounds.End.Value));
}
internal Value(System.TimeSpan value, Parameterization p = Parameterization.Value)
: base(value)
{
Original = value;
_clrType = typeof(System.TimeSpan);
_hashCode = GetCrossTypeHashCode(_clrType, value.GetHashCode());
Build = (buildContext, buildArgs) =>
{
return((p != Parameterization.None) ? (value.Parameterize(buildContext, p) ?? Mapping.BuildCast(value)) : Mapping.BuildCast(value));
};
}
public Record(string name, bool computed, Parameterization param)
{
ReadableName = name;
Computed = computed;
Params = param;
Prefab = Prefabs.NoPrefab;
MinimumValue = 0.0;
MaximumValue = 1.0;
EnumerationValues = new HashSet <string>();
}
internal Value(object value, Parameterization p, DataType dataType = null)
: base(value)
{
if (value == null)
{
SetAsNull();
return;
}
Original = value;
var clrType = value.GetType();
if (Mapping.CheckClrCompliance(clrType, out _clrType, out chainException) != Mapping.ClrTypeMatch.ClrMatch)
{
TryThrow();
}
DebugValue = value;
if (_clrType == typeof(DBNull) || _clrType == typeof(System.Object))
{
SetAsNull();
return;
}
_hashCode = GetCrossTypeHashCode(_clrType, value.GetHashCode());
Build = (buildContext, buildArgs) =>
{
string sql = null;
if (p != Parameterization.None)
{
sql = value.Parameterize(buildContext, dataType, p);
}
if (sql == null)
{
if (dataType != null)
{
sql = String.Format("{0}({1} AS {2})", Text.Cast, Mapping.Build(value, dataType), dataType.Build());
}
else
{
sql = Mapping.BuildUnchecked(value, out chainException);
}
}
return(sql);
};
}
internal Value(System.Int32 value, Parameterization p = Parameterization.Value)
: base(value)
{
Original = value;
_clrType = typeof(System.Int32);
_hashCode = GetCrossTypeHashCode(_clrType, value.GetHashCode());
Build = (buildContext, buildArgs) =>
{
// literal:
return((p != Parameterization.None) ?
(value.Parameterize(buildContext, p) ?? Mapping.Build(value, Mapping.DefaultInt32Type)) :
Mapping.Build(value, Mapping.DefaultInt32Type));
};
}
internal Value(System.DateTime value, Parameterization p = Parameterization.Value, DataType dataType = null)
: base(value)
{
Original = value;
_clrType = typeof(System.DateTime);
_hashCode = GetCrossTypeHashCode(_clrType, value.GetHashCode());
dataType = dataType ?? Mapping.DefaultDateTimeType;
// build
Build = (buildContext, buildArgs) =>
{
return((p != Parameterization.None) ?
(value.Parameterize(buildContext, dataType, p) ??
Mapping.BuildCast(value, dataType)) : Mapping.BuildCast(value, dataType));
};
}
internal Value(System.Byte[] value, Parameterization p = Parameterization.Value)
: base(value)
{
Original = value;
_clrType = typeof(System.Byte[]);
// use Binary type for byte[] hash code calculation
_hashCode = GetCrossTypeHashCode(_clrType, new System.Data.Linq.Binary(value).GetHashCode());
Build = (buildContext, buildArgs) =>
{
// literal:
return((p != Parameterization.None) ?
(value.Parameterize(buildContext, p) ?? Mapping.Build(value, Mapping.DefaultBinaryType)) :
Mapping.Build(value, Mapping.DefaultBinaryType));
};
}
internal Value(System.String value, Parameterization p = Parameterization.Value, DataType dataType = null)
: base(value)
{
Original = value;
_clrType = typeof(System.String);
if (dataType == null)
{
dataType = Mapping.DefaultStringType;
}
if (value != null)
{
_hashCode = GetCrossTypeHashCode(_clrType, value.GetHashCode());
}
Build = (buildContext, buildArgs) =>
{
string sql = null;
if (p != Parameterization.None)
{
sql = value.Parameterize(buildContext, dataType, p);
}
if (sql == null)
{
// literal:
sql = Mapping.Build(value, dataType);
// if node contains concatenator than all string values should be escaped twice
if (buildContext.Current.IsQuery)
{
if (buildContext.Current.Query.Master.IsConcatenated)
{
sql = Filter.Escape(sql);
}
}
}
return(sql);
};
}
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));
}
// 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);
}
