public static ITable[] Execute(IDatabaseConnection connection, SqlQuery query) { // StatementTree caching // Substitute all parameter substitutions in the statement tree. // TODO: IExpressionPreparer preparer = new QueryPreparer(query); // Create a new parser and set the parameters... IEnumerable <Statement> statements; string commandText = query.Text; try { lock (SqlParser) { SqlParser.ReInit(new StreamReader(new MemoryStream(Encoding.Unicode.GetBytes(commandText)), Encoding.Unicode)); SqlParser.Reset(); // Parse the statement. statements = SqlParser.SequenceOfStatements(); } } catch (ParseException e) { var tokens = SqlParser.token_source.tokenHistory; throw new SqlParseException(e, commandText, tokens); } List <ITable> results = new List <ITable>(); foreach (Statement parsedStatement in statements) { var statement = parsedStatement; // TODO: statement = statement.PrepareExpressions(preparer); // Convert the StatementTree to a statement object statement.Query = query; DatabaseQueryContext context = new DatabaseQueryContext(connection); // Prepare the statement statement = statement.PrepareStatement(context); // Evaluate the SQL statement. results.Add(statement.Evaluate(context)); } return(results.ToArray()); }
/// <summary> /// Looks up the query plan in the given context. /// </summary> /// <param name="context"></param> /// <returns> /// Returns the <see cref="IQueryPlanNode"/> that resolves to the view. /// </returns> public virtual IQueryPlanNode CreateViewChildNode(IQueryContext context) { DatabaseQueryContext db = (DatabaseQueryContext)context; return(db.CreateViewQueryPlanNode(tableName)); }
/// <summary> /// Forms a command plan <see cref="IQueryPlanNode"/> from the given /// <see cref="TableSelectExpression"/> and <see cref="TableExpressionFromSet"/>. /// </summary> /// <param name="db"></param> /// <param name="expression">Describes the <i>SELECT</i> command /// (or sub-command).</param> /// <param name="fromSet">Used to resolve expression references.</param> /// <param name="orderBy">A list of <see cref="ByColumn"/> objects /// that represent an optional <i>ORDER BY</i> clause. If this is null /// or the list is empty, no ordering is done.</param> /// <returns></returns> public static IQueryPlanNode FormQueryPlan(IDatabaseConnection db, TableSelectExpression expression, TableExpressionFromSet fromSet, IList <ByColumn> orderBy) { IQueryContext context = new DatabaseQueryContext(db); // ----- Resolve the SELECT list // If there are 0 columns selected, then we assume the result should // show all of the columns in the result. bool doSubsetColumn = (expression.Columns.Count != 0); // What we are selecting var columnSet = BuildColumnSet(expression, fromSet); // Prepare the column_set, columnSet.Prepare(context); ResolveOrderByRefs(columnSet, orderBy); // ----- // Set up plans for each table in the from clause of the command. For // sub-queries, we recurse. var tablePlanner = SetupPlanners(db, fromSet); // ----- // The WHERE and HAVING clauses FilterExpression whereClause = expression.Where; FilterExpression havingClause = expression.Having; whereClause = PrepareJoins(tablePlanner, expression, fromSet, whereClause); // Prepare the WHERE and HAVING clause, qualifies all variables and // prepares sub-queries. whereClause = PrepareSearchExpression(db, fromSet, whereClause); havingClause = PrepareSearchExpression(db, fromSet, havingClause); // Any extra Aggregate functions that are part of the HAVING clause that // we need to add. This is a list of a name followed by the expression // that contains the aggregate function. var extraAggregateFunctions = new List <Expression>(); if (havingClause != null && havingClause.Expression != null) { Expression newHavingClause = FilterHavingClause(havingClause.Expression, extraAggregateFunctions, context); havingClause = new FilterExpression(newHavingClause); } // Any GROUP BY functions, ObjectName[] groupByList; IList <Expression> groupByFunctions; var gsz = ResolveGroupBy(expression, fromSet, context, out groupByList, out groupByFunctions); // Resolve GROUP MAX variable to a reference in this from set ObjectName groupmaxColumn = ResolveGroupMax(expression, fromSet); // ----- // Now all the variables should be resolved and correlated variables set // up as appropriate. // If nothing in the FROM clause then simply evaluate the result of the // select if (fromSet.SetCount == 0) { return(EvaluateSingle(columnSet)); } // Plan the where clause. The returned node is the plan to evaluate the // WHERE clause. IQueryPlanNode node = tablePlanner.PlanSearchExpression(whereClause); Expression[] defFunList; string[] defFunNames; var fsz = MakeupFunctions(columnSet, extraAggregateFunctions, out defFunList, out defFunNames); node = PlanGroup(node, columnSet, groupmaxColumn, gsz, groupByList, groupByFunctions, fsz, defFunNames, defFunList); // The result column list List <SelectColumn> selectColumns = columnSet.SelectedColumns; int sz = selectColumns.Count; // Evaluate the having clause if necessary if (havingClause != null && havingClause.Expression != null) { // Before we evaluate the having expression we must substitute all the // aliased variables. Expression havingExpr = havingClause.Expression; havingExpr = SubstituteAliasedVariables(havingExpr, selectColumns); havingClause = new FilterExpression(havingExpr); PlanTableSource source = tablePlanner.SingleTableSource; source.UpdatePlan(node); node = tablePlanner.PlanSearchExpression(havingClause); } // Do we have a composite select expression to process? IQueryPlanNode rightComposite = null; if (expression.NextComposite != null) { TableSelectExpression compositeExpr = expression.NextComposite; // Generate the TableExpressionFromSet hierarchy for the expression, TableExpressionFromSet compositeFromSet = GenerateFromSet(compositeExpr, db); // Form the right plan rightComposite = FormQueryPlan(db, compositeExpr, compositeFromSet, null); } // Do we do a final subset column? ObjectName[] aliases = null; if (doSubsetColumn) { // Make up the lists ObjectName[] subsetVars = new ObjectName[sz]; aliases = new ObjectName[sz]; for (int i = 0; i < sz; ++i) { SelectColumn scol = selectColumns[i]; subsetVars[i] = scol.InternalName.Clone(); aliases[i] = scol.Alias.Clone(); } // If we are distinct then add the DistinctNode here if (expression.Distinct) { node = new DistinctNode(node, subsetVars); } // Process the ORDER BY? // Note that the ORDER BY has to occur before the subset call, but // after the distinct because distinct can affect the ordering of the // result. if (rightComposite == null && orderBy != null) { node = PlanForOrderBy(node, orderBy, fromSet, selectColumns); } // Rename the columns as specified in the SELECT node = new SubsetNode(node, subsetVars, aliases); } else { // Process the ORDER BY? if (rightComposite == null && orderBy != null) { node = PlanForOrderBy(node, orderBy, fromSet, selectColumns); } } // Do we have a composite to merge in? if (rightComposite != null) { // For the composite node = new CompositeNode(node, rightComposite, expression.CompositeFunction, expression.IsCompositeAll); // Final order by? if (orderBy != null) { node = PlanForOrderBy(node, orderBy, fromSet, selectColumns); } // Ensure a final subset node if (!(node is SubsetNode) && aliases != null) { node = new SubsetNode(node, aliases, aliases); } } return(node); }