internal virtual bool SetResultException(QueryTalkException ex)
{
if (AsyncStatus != AsyncStatus.Canceled)
{
_exception = ex;
if (Result == null)
{
Result = new Result(Connectable, ex);
}
else
{
Result.Exception = ex;
}
return(true);
}
else
{
if (Result == null)
{
Result = new Result(Connectable);
}
Result.AsyncStatus = AsyncStatus.Canceled;
}
return(false);
}
internal ByArgument(System.String arg)
: base(arg)
{
if (String.IsNullOrEmpty(arg))
{
arg = null;
}
if (CheckNull(Arg(() => arg, arg)))
{
if (arg.Split(new char[] { Text.DotChar }).Length > 2)
{
chainException = new QueryTalkException(this,
QueryTalkExceptionType.InvalidColumnIdentifier,
String.Format("identifier = {0}", arg),
Text.Method.Identifier);
return;
}
var pair = new AliasColumnPair(arg);
_alias = pair.Alias;
_column = pair.Column;
if (_column != null)
{
JoinType = Wall.ByType.NonMappedColumn;
}
else
{
JoinType = Wall.ByType.Alias;
}
}
SetArgType(arg);
}
/// <summary>
/// Represents a column in the select statement.
/// </summary>
/// <param name="arg">Is an aliased column.</param>
public Column(ColumnAsChainer arg)
: this(arg as Chainer)
{
CheckNullAndThrow(Arg(() => arg, arg));
SetArgType(arg);
if (arg.Exception == null)
{
if (arg.Prev is Identifier)
{
// check if more than 2-parts
if ((arg.Prev as Identifier).NumberOfParts > 2)
{
chainException = new QueryTalkException(this, QueryTalkExceptionType.InvalidColumnIdentifier,
String.Format("identifier = {0} AS {1}",
arg.Prev.ToString(),
Filter.Delimit(arg.Name ?? "")));
}
}
}
else
{
TryTakeException(arg.Exception);
if (arg.IsUndefined)
{
chainException.Extra = Text.Free.AliasNullExtra;
}
}
if (arg != null)
{
_columnName = ((IColumnName)arg).ColumnName;
}
}
internal ByArgument(Identifier arg)
: base(arg)
{
CtorBody(arg);
SetArgType(arg);
if (chainException == null)
{
// identifier should consist of alias and column.
if (arg.NumberOfParts != 2)
{
chainException = new QueryTalkException(this,
QueryTalkExceptionType.InvalidByIdentifier,
String.Format("identifier = {0}", arg),
Text.Method.Identifier);
return;
}
_alias = arg.Part1;
_column = arg.Part2;
if (_column != null)
{
JoinType = Wall.ByType.NonMappedColumn;
}
else
{
JoinType = Wall.ByType.Alias;
}
}
}
internal static string BuildSequence <T>(IEnumerable <T> scalarCollection, out QueryTalkException exception)
{
exception = null;
if (scalarCollection == null || scalarCollection.Count() == 0)
{
exception = new QueryTalkException("Expression.BuildSequence", QueryTalkExceptionType.CollectionNullOrEmpty,
String.Format("element type = {0}", typeof(T)), Text.Method.In);
return(null);
}
Type type;
QueryTalkException exclr;
if (Mapping.CheckClrCompliance(typeof(T), out type, out exclr) != Mapping.ClrTypeMatch.ClrMatch)
{
throw exclr;
}
StringBuilder sql = Text.GenerateSql(200);
int i = 0;
foreach (T item in scalarCollection)
{
if (i++ > 0)
{
sql.Append(Text.Comma);
}
sql.Append(Mapping.BuildUnchecked(item));
}
return(sql.ToString());
}
// conditionally throws an exception
internal static void TryThrow(this QueryTalkException exception, string method = null)
{
if (exception != null)
{
exception.Method = method ?? exception.Method;
throw exception;
}
}
internal static string Concatenate(
GroupingArgument[] arguments,
BuildContext buildContext,
BuildArgs buildArgs,
bool isEnclosed)
{
// check
if (arguments == null || arguments.Length == 0)
{
return("()");
}
return(String.Join(Text.CommaWithSpace,
arguments.Select(argument =>
{
if (argument.IsUndefined())
{
var exception = new QueryTalkException(
"GroupingArgument.Concatenate",
QueryTalkExceptionType.ArgumentNull,
String.Format("column = undefined"));
buildContext.TryTakeException(exception);
return null;
}
if (argument.Exception != null)
{
buildContext.TryTakeException(argument.Exception);
return null;
}
string sql = argument.Build(buildContext, buildArgs);
if (argument.Exception != null)
{
buildContext.TryTakeException(argument.Exception);
return null;
}
if (buildContext.Exception != null)
{
return null;
}
buildContext.TryTake(argument);
if (sql == "[]")
{
return "()";
}
else
{
return isEnclosed ?
String.Format("({0})", sql) : sql;
}
}).ToArray()));
}
// conditionally assigns a "from" exception to the build context
internal static bool TryTakeException(this BuildContext buildContext, QueryTalkException exception, string method = null)
{
// exception
if (buildContext != null &&
exception != null)
{
buildContext.Exception = exception;
buildContext.Exception.Method = method ?? buildContext.Exception.Method;
return(true);
}
return(false);
}
// attention:
// If root object is accessed through the BuildContext object, use buildContext.TryGetVariable method instead.
internal Variable TryGetVariable(
string variableName,
out QueryTalkException exception,
Variable.SearchType searchType = Variable.SearchType.Any)
{
exception = null;
if (variableName == null)
{
exception = Variable.InvalidVariableException(variableName,
QueryTalkExceptionType.ArgumentNull);
return(null);
}
Variable param;
Variable variable;
// try get param
param = AllParams.Where(p => p.Name.EqualsCS(variableName))
.FirstOrDefault();
// try get non-param
variable = _variables.Where(v => v.Name.EqualsCS(variableName))
.FirstOrDefault();
if (searchType == Variable.SearchType.Any)
{
return(param ?? variable);
}
if (searchType == Variable.SearchType.Inliner &&
(param == null || param.DT.IsNotInliner()))
{
exception = Variable.InvalidVariableException(variableName,
QueryTalkExceptionType.InlinerNotFound);
return(null);
}
// param/variable should exists
if (searchType != Variable.SearchType.Any && (param == null && variable == null))
{
exception = Variable.InvalidVariableException(variableName,
QueryTalkExceptionType.ParamOrVariableNotDeclared);
return(null);
}
return(param ?? variable);
}
internal Expression(Operator op, ScalarArgument arg1, string collectionSql, QueryTalkException exception)
: this(null, true)
{
if (exception != null)
{
chainException = exception;
chainException.Extra = Text.Free.ExpressionNullExtra;
return;
}
arg1 = arg1 ?? Designer.Null;
Arguments = new[] { arg1 };
var list = collectionSql;
CheckNull(Arg(() => list, list));
TryTake(arg1);
TryTakeException(exception);
Build = (buildContext, buildArgs) =>
{
if (buildContext.TryTakeException(chainException))
{
return(null);
}
if (!CheckConcatenator(buildContext, arg1))
{
return(null);
}
arg1.RootSubject = ((ISemantic)this).RootSubject;
var sql = BuildBinaryExpression(
op,
(arg1 as Chainer).Build(buildContext, buildArgs),
collectionSql);
buildContext.TryTakeException(chainException);
return(sql);
};
}
internal void SetClrException(
System.Exception ex,
string exceptionCreator,
Connectable connectable,
string method)
{
if (connectable.AsyncCanceled)
{
AsyncStatus = AsyncStatus.Canceled;
Result = new Result(connectable);
Result.AsyncStatus = AsyncStatus.Canceled;
return;
}
QueryTalkException exception = new QueryTalkException(exceptionCreator, QueryTalkExceptionType.ClrException, ((IName)connectable).Name,
method, null);
exception.ClrException = ex;
SetResultException(exception);
}
internal static string Concatenate(
OrderedColumnArgument[] arguments,
BuildContext buildContext,
BuildArgs buildArgs)
{
return(String.Join(Text.CommaWithSpace,
arguments.Select(argument =>
{
if (argument.IsUndefined())
{
var exception = new QueryTalkException("OrderedColumnArgument",
QueryTalkExceptionType.ArgumentNull,
"column = undefined");
buildContext.TryTakeException(exception);
return null;
}
if (argument.Exception != null)
{
buildContext.TryTakeException(argument.Exception);
return null;
}
var sql = argument.Build(buildContext, buildArgs);
if (argument.Exception != null)
{
buildContext.TryTakeException(argument.Exception);
return null;
}
if (buildContext.Exception != null)
{
return null;
}
buildContext.TryTake(argument);
return sql;
}).ToArray()));
}
internal Result(Connectable connectable, QueryTalkException ex)
: this(connectable, (IEnumerable <dynamic>)null)
{
Exception = ex;
}
// returns first cell of the first row
/// <summary>
/// Returns the value of the first cell of the resultset table.
/// </summary>
/// <typeparam name="TValue">The type of the value.</typeparam>
public TValue ToValue <TValue>()
{
PropertyInfo property = null;
try
{
if (TableType == typeof(DataTable))
{
if (DataTable.AsEnumerable().Count() > 0)
{
return((TValue)DataTable.Rows[0][0]);
}
else
{
throw new QueryTalkException("ResultSet.ToValue<TValue>", QueryTalkExceptionType.EmptyResultset,
null, Text.Method.ToValue, "data class = DataTable");
}
}
else
{
if (Count > 0)
{
var properties = TableType.GetProperties();
if (properties.Length == 0)
{
throw new QueryTalkException("ResultSet.ToValue<TValue>", QueryTalkExceptionType.EmptyResultset,
null, Text.Method.ToValue, String.Format("data class = {0}", TableType));
}
property = properties[0];
if (property.GetGetMethod() == null)
{
throw new QueryTalkException("ResultSet.ToValue<TValue>", QueryTalkExceptionType.NonAccessableProperty,
null, Text.Method.ToValue, String.Format("data class = {0}{1} property = {2}",
TableType, Environment.NewLine, property.Name));
}
var value = property.GetValue(this.First(), null);
return((value != null) ? (TValue)value : default(TValue));
}
else
{
throw new QueryTalkException("ResultSet.ToValue<TValue>", QueryTalkExceptionType.EmptyResultset,
null, Text.Method.ToValue, String.Format("data class = {0}", TableType));
}
}
}
catch (QueryTalkException)
{
throw;
}
catch (System.InvalidCastException)
{
throw new QueryTalkException("ResultSet.ToValue<TValue>", QueryTalkExceptionType.InvalidCast,
null, Text.Method.ToValue, String.Format("returning type = {0}{1} value type = {2}",
typeof(TValue), Environment.NewLine, property.PropertyType));
}
catch (System.Exception ex)
{
var exception = new QueryTalkException("ResultSet.ToValue<TValue>", QueryTalkExceptionType.ClrException,
null, Text.Method.ToValue, String.Format("returning type = {0}", typeof(TValue)));
exception.ClrException = ex;
throw exception;
}
}
private static void ThrowNotClrCompliantException(QueryTalkException exception, Type classType)
{
exception.Extra = String.Format("A property with a non-compliant type belongs to a class {0}. This class cannot be converted to the DataTable object.", classType);
throw exception;
}
// Builds argument with critical check if the argument is bound to a certain param.
internal void BuildArgument(Designer root, string paramName)
{
// check if a param with the given param name exists
Variable param = root.TryGetVariable(paramName, out chainException, Variable.SearchType.Param);
if (chainException != null)
{
chainException.Method = Text.Method.Pass;
return;
}
// check: argument is null/NULL
if (QueryTalk.Value.IsNull(Value))
{
if (IsPassedVariable || !param.ParamNullCheck(out chainException))
{
chainException.Method = Text.Method.Pass;
chainException.Arguments = String.Format("param = {0}", paramName);
return;
}
}
// store param data
ParamName = paramName;
_dt = param.DT;
DataType = param.DataType;
IsParamOutput = param.IsOutput;
IsParameterized = param.IsParameterized;
// clear parameterized value on param
if (IsParameterized)
{
param.ClearParameterizedValue();
}
// udt: store compiled SQL
if (param.DT.IsNameType())
{
NameTypeSql = param.NameType.Sql;
}
// table variable/temp table/bulk table: cannot be passed as variable
if (DT.IsVTB())
{
// bulk table
if (DT == Wall.DT.BulkTable)
{
if (Value.GetType() != typeof(DataTable))
{
chainException = new QueryTalkException("Param.BuildArgument", QueryTalkExceptionType.InvalidTableArgument,
String.Format(
"bulk table = {0}{1} argument type = {2}{3} required type = {4}",
ParamName, Environment.NewLine, ArgType, Environment.NewLine, typeof(DataTable)),
Text.Method.Pass);
return;
}
else
{
return;
}
}
// table variable/temp table
if (Value.GetType() != typeof(View))
{
chainException = new QueryTalkException("Param.BuildArgument", QueryTalkExceptionType.InvalidTableArgument,
String.Format(
"param = {0}{1} argument type = {2}{3} required type = {4}",
ParamName, Environment.NewLine, ArgType, Environment.NewLine, typeof(View)),
Text.Method.Pass);
return;
}
}
// finish if argument has been passed as variable
if (IsPassedVariable)
{
Sql = Original.ToString();
return;
}
// argument type check
if (!CheckType(param, Value, out chainException))
{
chainException.Method = Text.Method.Pass;
return;
}
// Here the check has passed. Argument is properly bound to its param.
// Now build the SQL output.
// value
if (DT.IsDataType() || DT.IsNameType())
{
if (ArgType == typeof(View))
{
Sql = ((View)Original).Sql;
}
else if (ArgType == typeof(DataTable))
{
Sql = null;
}
else if (ArgType == typeof(OutputVar))
{
Sql = ((OutputVar)Original).Value;
}
// common type
else
{
Sql = Mapping.BuildUnchecked(Value, out chainException);
}
}
// inline
else
{
// table
if (DT == DT.InTable)
{
if (IsPassedVariable)
{
Sql = (string)Value;
}
// Identifier (build by Build method)
else
{
}
}
// sql
else if (DT == DT.InSql)
{
if (IsPassedVariable)
{
Sql = (string)Value;
}
else
{
Sql = _string;
}
}
// other inline types must be built by the Build method
else
{
}
}
}
// Check argument type and prepare exception object if the check fails.
internal bool CheckType(Variable param, object value, out QueryTalkException exception)
{
exception = null;
#region Table-value param
if (DT.IsTable())
{
// check null: #temp table & bulk table are allowed to be passed a null value (in the inner call)
// Note: table variable param cannot be used in inner calls => raise an exception
if (QueryTalk.Value.IsNull(value))
{
throw new QueryTalkException("Param.ArgumentCheck",
QueryTalkExceptionType.ParamArgumentNull,
String.Format("param = {0}", ParamName),
Text.Method.Pass);
}
// check type match
if (!Mapping.TableParamMapping[DT].Contains(ArgType))
{
exception = new QueryTalkException("Param.ArgumentCheck",
QueryTalkExceptionType.ParamArgumentTypeMismatch,
String.Format(
"param = {0}{1} argument type = {2}{3} required type(s) = {4}",
ParamName, Environment.NewLine,
ArgType, Environment.NewLine,
String.Join(", ", Mapping.TableParamMapping[DT]
.Select(a => a.FullName).ToArray())),
Text.Method.Pass);
return(false);
}
// check View: should store data values only.
if (ArgType == typeof(View))
{
// if a view does not origin from a CLR collection
if (!((View)value).IsValidDataView)
{
exception = new QueryTalkException(
"Param.ArgumentCheck",
QueryTalkExceptionType.InvalidDataView,
String.Format("param = {0}", ParamName));
return(false);
}
return(true);
}
}
#endregion
// it's ok if value is null
if (QueryTalk.Value.IsNull(value))
{
return(true);
}
// type check
if (!Mapping.CheckArgument(param, ArgType, out exception))
{
if (DT.IsInliner())
{
exception.Arguments = String.Format(
"param = {0}{1} param type = {2}{3} argument = {4}{5} argument type = {6}{7} required type(s) = {8}",
param.Name, Environment.NewLine,
Text.Free.InlinerType + "." + param.DT.ToInliner(), Environment.NewLine,
value.ToReport(), Environment.NewLine,
ArgType, Environment.NewLine,
String.Join(", ", Mapping.InlineMapping[param.DT]
.Select(a => a.FullName).ToArray()));
}
else
{
exception.Arguments = String.Format(
"param = {0}{1} param type = {2}{3} argument = {4}{5} argument type = {6}{7} required type = {8}",
param.Name, Environment.NewLine,
param.DT.ToString().ToLower(), Environment.NewLine,
value.ToReport(), Environment.NewLine,
ArgType, Environment.NewLine,
Mapping.SqlMapping[param.DT].ClrType
);
}
return(false);
}
return(true);
}