private static int MakeupFunctions(PreparedQuerySelectColumns columnSet, IList<SqlExpression> aggregateFunctions, out SqlExpression[] defFunList, out string[] defFunNames)
{
// Make up the functions list,
var functionsList = columnSet.FunctionColumns.ToList();
int fsz = functionsList.Count;
var completeFunList = new List<object>();
for (int i = 0; i < fsz; ++i) {
var scol = functionsList[i];
completeFunList.Add(scol.Expression);
completeFunList.Add(scol.InternalName.Name);
}
for (int i = 0; i < aggregateFunctions.Count; ++i) {
completeFunList.Add(aggregateFunctions[i]);
completeFunList.Add("HAVINGAGG_" + (i + 1));
}
int fsz2 = completeFunList.Count / 2;
defFunList = new SqlExpression[fsz2];
defFunNames = new string[fsz2];
for (int i = 0; i < fsz2; ++i) {
defFunList[i] = (SqlExpression)completeFunList[i * 2];
defFunNames[i] = (string)completeFunList[(i * 2) + 1];
}
return fsz;
}
public WhileLoopStatement(SqlExpression conditionExpression)
{
if (conditionExpression == null)
throw new ArgumentNullException("conditionExpression");
ConditionExpression = conditionExpression;
}
public override SqlExpression Visit(SqlExpression expression)
{
if (expression is QueryReferenceExpression)
VisitQueryReference((QueryReferenceExpression) expression);
return base.Visit(expression);
}
public void JoinAt(int betweenIndex, JoinType joinType, SqlExpression onExpression)
{
var planLeft = tablePlans[betweenIndex];
var planRight = tablePlans[betweenIndex + 1];
planLeft.RightJoin(planRight, joinType, onExpression);
planRight.LeftJoin(planLeft, joinType, onExpression);
}
public string ToSqlString(SqlExpression expression)
{
rootQuery = expression is SqlQueryExpression;
Visit(expression);
return builder.ToString();
}
public JoinNode(IQueryPlanNode left, IQueryPlanNode right, ObjectName leftColumnName, SqlExpressionType @operator, SqlExpression rightExpression)
: base(left, right)
{
LeftColumnName = leftColumnName;
Operator = @operator;
RightExpression = rightExpression;
}
public SimpleSelectNode(IQueryPlanNode child, ObjectName columnName, SqlExpressionType op, SqlExpression expression)
: base(child)
{
ColumnName = columnName;
OperatorType = op;
Expression = expression;
}
public SetPasswordAction(SqlExpression passwordExpression)
{
if (passwordExpression == null)
throw new ArgumentNullException("passwordExpression");
PasswordExpression = passwordExpression;
}
public InvokeArgument(string name, SqlExpression value)
{
if (value == null)
throw new ArgumentNullException("value");
Name = name;
Value = value;
}
/// <summary>
/// Constructs a new <see cref="SelectColumn"/> for the given
/// expression and aliased with the given name.
/// </summary>
/// <param name="expression">The <see cref="Expression"/> used for select
/// a column within a <c>SELECT</c> statement.</param>
/// <param name="alias">The name to alias the resulted expression.</param>
public SelectColumn(SqlExpression expression, string alias)
{
if (expression == null)
throw new ArgumentNullException("expression");
Expression = expression;
Alias = alias;
}
public ExpressionReference(SqlExpression expression, string @alias)
{
if (expression == null)
throw new ArgumentNullException("expression");
Alias = alias;
Expression = expression;
}
public GroupNode(IQueryPlanNode child, ObjectName[] columnNames, ObjectName groupMaxColumn, SqlExpression[] functions, string[] names)
: base(child)
{
ColumnNames = columnNames;
GroupMaxColumn = groupMaxColumn;
Functions = functions;
Names = names;
}
internal CheckViolationException(ObjectName tableName, string constraintName, SqlExpression expression,
ConstraintDeferrability deferrability)
: base(SystemErrorCodes.CheckViolation, FormatMessage(tableName, constraintName, expression, deferrability))
{
TableName = tableName;
ConstraintName = constraintName;
CheckExpression = expression;
Deferrability = deferrability;
}
internal JoinPart(JoinType joinType, SqlQueryExpression subQuery, SqlExpression onExpression)
{
if (subQuery == null)
throw new ArgumentNullException("subQuery");
OnExpression = onExpression;
JoinType = joinType;
SubQuery = subQuery;
}
internal JoinPart(JoinType joinType, ObjectName tableName, SqlExpression onExpression)
{
if (tableName == null)
throw new ArgumentNullException("tableName");
OnExpression = onExpression;
JoinType = joinType;
TableName = tableName;
}
public FunctionTable(ITable table, SqlExpression[] functionList, string[] columnNames, IRequest queryContext)
: base(queryContext.Context)
{
// Make sure we are synchronized over the class.
lock (typeof(FunctionTable)) {
uniqueId = uniqueKeySeq;
++uniqueKeySeq;
}
uniqueId = (uniqueId & 0x0FFFFFFF) | 0x010000000;
context = queryContext;
ReferenceTable = table;
varResolver = table.GetVariableResolver();
varResolver = varResolver.ForRow(0);
// Create a DataTableInfo object for this function table.
funTableInfo = new TableInfo(FunctionTableName);
expList = new SqlExpression[functionList.Length];
expInfo = new byte[functionList.Length];
// Create a new DataColumnInfo for each expression, and work out if the
// expression is simple or not.
for (int i = 0; i < functionList.Length; ++i) {
var expr = functionList[i];
// Examine the expression and determine if it is simple or not
if (expr.IsConstant() && !expr.HasAggregate(context)) {
// If expression is a constant, solve it
var result = expr.Evaluate(context, null);
if (result.ExpressionType != SqlExpressionType.Constant)
throw new InvalidOperationException();
expr = result;
expList[i] = expr;
expInfo[i] = 1;
} else {
// Otherwise must be dynamic
expList[i] = expr;
expInfo[i] = 0;
}
// Make the column info
funTableInfo.AddColumn(columnNames[i], expr.ReturnType(context, varResolver));
}
// Make sure the table info isn't changed from this point on.
funTableInfo = funTableInfo.AsReadOnly();
// routine tables are the size of the referring table.
rowCount = table.RowCount;
// Set schemes to 'blind search'.
SetupIndexes(DefaultIndexTypes.BlindSearch);
}
public SelectIntoStatement(SqlQueryExpression queryExpression, SqlExpression reference)
{
if (queryExpression == null)
throw new ArgumentNullException("queryExpression");
if (reference == null)
throw new ArgumentNullException("reference");
QueryExpression = queryExpression;
Reference = reference;
}
internal SqlAssignExpression(SqlExpression reference, SqlExpression valueExpression)
{
if (reference == null)
throw new ArgumentNullException("reference");
if (valueExpression == null)
throw new ArgumentNullException("valueExpression");
ValueExpression = valueExpression;
Reference = reference;
}
public CreateUserStatement(string userName, SqlExpression password)
{
if (password == null)
throw new ArgumentNullException("password");
if (String.IsNullOrEmpty(userName))
throw new ArgumentNullException("userName");
UserName = userName;
Password = password;
}
public SqlColumnAssignment(string columnName, SqlExpression expression)
{
if (expression == null)
throw new ArgumentNullException("expression");
if (String.IsNullOrEmpty(columnName))
throw new ArgumentNullException("columnName");
ColumnName = columnName;
Expression = expression;
}
public override void VisitBinaryExpression(SqlBinaryExpressionNode expressionNode)
{
var left = Build(expressionNode.Left);
var right = Build(expressionNode.Right);
var op = expressionNode.Operator;
var expType = GetBinaryExpressionType(op);
outputExpression = SqlExpression.Binary(left, expType, right);
}
public SetStatement(string settingName, SqlExpression valueExpression)
{
if (String.IsNullOrEmpty(settingName))
throw new ArgumentNullException("settingName");
if (valueExpression == null)
throw new ArgumentNullException("valueExpression");
SettingName = settingName;
ValueExpression = valueExpression;
}
/// <summary>
/// Visits a given SQL expression.
/// </summary>
/// <param name="expression">The <see cref="SqlExpression"/> to visit.</param>
/// <returns>
/// Returns an instance of <see cref="SqlExpression"/> as result of the visit.
/// </returns>
public virtual SqlExpression Visit(SqlExpression expression)
{
if (expression == null)
return null;
var expressionType = expression.ExpressionType;
switch (expressionType) {
case SqlExpressionType.Add:
case SqlExpressionType.Subtract:
case SqlExpressionType.Divide:
case SqlExpressionType.Multiply:
case SqlExpressionType.Modulo:
case SqlExpressionType.And:
case SqlExpressionType.Or:
case SqlExpressionType.XOr:
case SqlExpressionType.Equal:
case SqlExpressionType.NotEqual:
case SqlExpressionType.Like:
case SqlExpressionType.NotLike:
case SqlExpressionType.GreaterThan:
case SqlExpressionType.GreaterOrEqualThan:
case SqlExpressionType.SmallerThan:
case SqlExpressionType.SmallerOrEqualThan:
case SqlExpressionType.Is:
case SqlExpressionType.IsNot:
return VisitBinary((SqlBinaryExpression) expression);
case SqlExpressionType.Negate:
case SqlExpressionType.Not:
case SqlExpressionType.UnaryPlus:
return VisitUnary((SqlUnaryExpression) expression);
case SqlExpressionType.Cast:
return VisitCast((SqlCastExpression) expression);
case SqlExpressionType.Reference:
return VisitReference((SqlReferenceExpression) expression);
case SqlExpressionType.VariableReference:
return VisitVariableReference((SqlVariableReferenceExpression) expression);
case SqlExpressionType.Assign:
return VisitAssign((SqlAssignExpression) expression);
case SqlExpressionType.FunctionCall:
return VisitFunctionCall((SqlFunctionCallExpression) expression);
case SqlExpressionType.Constant:
return VisitConstant((SqlConstantExpression) expression);
case SqlExpressionType.Conditional:
return VisitConditional((SqlConditionalExpression) expression);
case SqlExpressionType.Query:
return VisitQuery((SqlQueryExpression) expression);
case SqlExpressionType.Tuple:
return VisitTuple((SqlTupleExpression) expression);
case SqlExpressionType.All:
case SqlExpressionType.Any:
return VisitQuantified((SqlQuantifiedExpression) expression);
default:
return expression.Accept(this);
}
}
public static ExecuteResult Execute(this IRoutine routine, SqlExpression[] args, IQueryContext context, IVariableResolver resolver, IGroupResolver group)
{
var request = new Invoke(routine.FullName, args);
if (context != null &&
!context.UserCanExecuteFunction(request))
throw new InvalidOperationException();
var executeContext = new ExecuteContext(request, routine, resolver, group, context);
return routine.Execute(executeContext);
}
internal SqlConditionalExpression(SqlExpression testExpression, SqlExpression trueExpression, SqlExpression falsExpression)
{
if (testExpression == null)
throw new ArgumentNullException("testExpression");
if (trueExpression == null)
throw new ArgumentNullException("trueExpression");
TrueExpression = trueExpression;
TestExpression = testExpression;
FalseExpression = falsExpression;
}
public ConditionStatement(SqlExpression condition, SqlStatement[] trueStatements, SqlStatement[] falseStatements)
{
if (condition == null)
throw new ArgumentNullException("condition");
if (trueStatements == null)
throw new ArgumentNullException("trueStatements");
ConditionExpression = condition;
TrueStatements = trueStatements;
FalseStatements = falseStatements;
}
public static IFunction ResolveFunction(this FunctionProvider resolver, IQuery context, string name, params DataObject[] args)
{
var exps = new SqlExpression[0];
if (args != null && args.Length > 0) {
exps = new SqlExpression[args.Length];
for (int i = 0; i < args.Length; i++) {
exps[i] = SqlExpression.Constant(args[i]);
}
}
return resolver.ResolveFunction(context, name, exps);
}
internal SqlQuantifiedExpression(SqlExpressionType type, SqlExpression value)
{
if (type != SqlExpressionType.All &&
type != SqlExpressionType.Any)
throw new ArgumentException("Invalid quantified type");
if (value == null)
throw new ArgumentNullException("value");
this.type = type;
ValueExpression = value;
}
internal SqlBinaryExpression(SqlExpression left, SqlExpressionType expressionType, SqlExpression right)
{
if (left == null)
throw new ArgumentNullException("left");
if (right == null)
throw new ArgumentNullException("right");
this.expressionType = expressionType;
Left = left;
Right = right;
}
public FetchStatement(string cursorName, FetchDirection direction, SqlExpression offsetExpression)
{
if (offsetExpression != null) {
if (direction != FetchDirection.Absolute &&
direction != FetchDirection.Relative)
throw new ArgumentException("Cannot specify an offset for a FETCH that is not RELATIVE or ABSOLUTE");
}
CursorName = cursorName;
Direction = direction;
OffsetExpression = offsetExpression;
}
