IStatement IPreparableStatement.Prepare(IRequest request)
{
var tableName = request.Query.ResolveTableName(TableName);
if (!request.Query.TableExists(tableName))
{
throw new ObjectNotFoundException(tableName);
}
var queryExp = new SqlQueryExpression(new SelectColumn[] { SelectColumn.Glob("*") });
queryExp.FromClause.AddTable(tableName.FullName);
queryExp.WhereExpression = WhereExpression;
var queryInfo = new QueryInfo(request, queryExp);
if (Limit > 0)
{
queryInfo.Limit = new QueryLimit(Limit);
}
var queryPlan = request.Query.Context.QueryPlanner().PlanQuery(queryInfo);
return(new Prepared(tableName, queryPlan));
}
/// <summary>
/// Visits the specified SQL query expression.
/// </summary>
/// <param name="sqlQueryExpression">The SQL query expression.</param>
/// <returns>
/// Returns processed value from espression.
/// </returns>
string ISqlVisitor <string> .Visit(SqlQueryExpression sqlQueryExpression)
{
Func <string, string, string> JoinStrings = (a, b) => a + ", " + b;
StringBuilder builder = new StringBuilder();
string topSection = sqlQueryExpression.Limit > 0 ? $"TOP {sqlQueryExpression.Limit}" : "";
builder.AppendLine(
$"SELECT { topSection } {sqlQueryExpression.Select.Select(Visit).Aggregate(JoinStrings)}");
builder.AppendLine($"FROM {Visit(sqlQueryExpression.From)}");
if (sqlQueryExpression.Where != null)
{
builder.AppendLine($"WHERE {Visit(sqlQueryExpression.Where)}");
}
if (sqlQueryExpression.GroupBy?.Any() ?? false)
{
builder.AppendLine($"GROUP BY {sqlQueryExpression.GroupBy.Select(Visit).Aggregate(JoinStrings)}");
}
if (sqlQueryExpression.Having != null)
{
builder.AppendLine($"HAVING {Visit(sqlQueryExpression.Having)}");
}
if (sqlQueryExpression.OrderBy?.Any() ?? false)
{
builder.AppendLine($"ORDER BY {sqlQueryExpression.OrderBy.Select(Visit).Aggregate(JoinStrings)}");
}
return(builder.ToString());
}
public static ITable ExecuteCreateView(this IQuery query, string viewName, IEnumerable <string> columnNames,
SqlQueryExpression queryExpression)
{
var statement = new CreateViewStatement(viewName, columnNames, queryExpression);
return(statement.Execute(query));
}
public static int DeleteFrom(this IQuery context, ObjectName tableName, SqlQueryExpression query, int limit)
{
IQueryPlanNode plan;
try {
var planValue = query.EvaluateToConstant(context, null);
if (planValue == null)
{
throw new InvalidOperationException();
}
if (!(planValue.Type is QueryType))
{
throw new InvalidOperationException();
}
plan = ((SqlQueryObject)planValue.Value).QueryPlan;
} catch (QueryException) {
throw;
} catch (SecurityException) {
throw;
} catch (Exception ex) {
throw new InvalidOperationException(String.Format("Could not delete from table '{0}': unable to form the delete set.", tableName), ex);
}
var deleteSet = plan.Evaluate(context);
return(context.DeleteFrom(tableName, deleteSet, limit));
}
private QuerySelectColumns BuildSelectColumns(SqlQueryExpression expression, QueryExpressionFrom queryFrom)
{
var selectColumns = new QuerySelectColumns(queryFrom);
foreach (var column in expression.SelectColumns)
{
// Is this a glob? (eg. Part.* )
if (column.IsGlob)
{
// Find the columns globbed and add to the 'selectedColumns' result.
if (column.IsAll)
{
selectColumns.SelectAllColumnsFromAllSources();
}
else
{
// Otherwise the glob must be of the form '[table name].*'
selectColumns.SelectAllColumnsFromSource(column.TableName);
}
}
else
{
// Otherwise must be a standard column reference.
selectColumns.SelectSingleColumn(column);
}
}
return(selectColumns);
}
public static int DeleteFrom(this IQuery context, ObjectName tableName, SqlExpression expression, int limit)
{
if (expression is SqlQueryExpression)
{
return(context.DeleteFrom(tableName, (SqlQueryExpression)expression, limit));
}
var table = context.GetMutableTable(tableName);
if (table == null)
{
throw new ObjectNotFoundException(tableName);
}
var queryExpression = new SqlQueryExpression(new List <SelectColumn> {
SelectColumn.Glob("*")
});
queryExpression.FromClause.AddTable(tableName.Name);
queryExpression.WhereExpression = expression;
var planExpression = queryExpression.Evaluate(context, null);
var plan = (SqlQueryObject)((SqlConstantExpression)planExpression).Value.Value;
var deleteSet = plan.QueryPlan.Evaluate(context);
return(context.DeleteFrom(tableName, deleteSet, limit));
}
public SqlQueryExpression Build()
{
var query = new SqlQueryExpression(items.Select(x => x.Build()));
if (querySources.Count > 0)
{
foreach (var source in querySources)
{
source.BuildIn(query);
}
}
query.Distinct = distinct;
if (groupByExpressions.Count > 0)
{
query.GroupBy = groupByExpressions.AsEnumerable();
}
if (groupMax != null)
{
query.GroupMax = groupMax;
}
if (filterType == WhereFilter)
{
query.WhereExpression = filterExpression;
}
else if (filterType == HavingFilter)
{
query.HavingExpression = filterExpression;
}
return(query);
}
/// <inheritdoc/>
public override void Visit(SqlQueryExpression node)
{
using (context.EnterScope(node)) {
bool needOpeningParenthesis = false;
bool needClosingParenthesis = false;
context.Output.AppendText(translator.Translate(context, node, QueryExpressionSection.Entry));
if (needOpeningParenthesis)
{
context.Output.AppendText("(");
}
node.Left.AcceptVisitor(this);
if (needClosingParenthesis)
{
context.Output.AppendText(")");
}
context.Output.AppendText(translator.Translate(node.NodeType));
context.Output.AppendText(translator.Translate(context, node, QueryExpressionSection.All));
if (needOpeningParenthesis)
{
context.Output.AppendText("(");
}
node.Right.AcceptVisitor(this);
if (needClosingParenthesis)
{
context.Output.AppendText(")");
}
context.Output.AppendText(translator.Translate(context, node, QueryExpressionSection.Exit));
}
}
protected override SqlStatement PrepareStatement(IRequest context)
{
var tableName = context.Access().ResolveTableName(TableName);
if (!context.Access().TableExists(tableName))
{
throw new ObjectNotFoundException(tableName);
}
var queryExpression = new SqlQueryExpression(new[] { SelectColumn.Glob("*") });
queryExpression.FromClause.AddTable(tableName.FullName);
queryExpression.WhereExpression = WherExpression;
var queryFrom = QueryExpressionFrom.Create(context, queryExpression);
var queryPlan = context.Query.Context.QueryPlanner().PlanQuery(new QueryInfo(context, queryExpression));
var columns = new List <SqlAssignExpression>();
foreach (var assignment in Assignments)
{
var columnName = ObjectName.Parse(assignment.ColumnName);
var refName = queryFrom.ResolveReference(columnName);
var expression = assignment.Expression.Prepare(queryFrom.ExpressionPreparer);
var assign = SqlExpression.Assign(SqlExpression.Reference(refName), expression);
columns.Add(assign);
}
return(new Prepared(tableName, queryPlan, columns.ToArray(), Limit));
}
/// <summary>Visits the children of the <see cref="T:System.Linq.Expressions.UnaryExpression" />.</summary>
/// <returns>The modified expression, if it or any subexpression was modified; otherwise, returns the original expression.</returns>
/// <param name="node">The expression to visit.</param>
protected override Expression VisitUnary(UnaryExpression node)
{
var unconverted = node.Unconvert();
if (unconverted != node)
{
return(base.Visit(unconverted));
}
SqlQueryExpression operand = null;
Visit(node.Operand);
operand = Retrieve();
if (node.NodeType == ExpressionType.Not && node.Type == typeof(bool) && operand is SqlColumnReference)
{
var cr = operand as SqlColumnReference;
var result = WrapAloneBoolean(cr, true);
Return(result);
return(node);
}
Return(new SqlUnaryExpression()
{
Operand = operand, Operator = node.NodeType.ToSqlOperator()
});
return(node);
}
internal Prepared(ObjectName viewName, SqlQueryExpression queryExpression, IQueryPlanNode queryPlan, bool replaceIfExists)
{
ViewName = viewName;
QueryPlan = queryPlan;
ReplaceIfExists = replaceIfExists;
QueryExpression = queryExpression;
}
public SqlQueryExpression Build()
{
var query = new SqlQueryExpression(items.Select(x => x.Build()));
if (querySources.Count > 0) {
foreach (var source in querySources) {
source.BuildIn(query);
}
}
query.Distinct = distinct;
if (groupByExpressions.Count > 0) {
query.GroupBy = groupByExpressions.AsEnumerable();
}
if (groupMax != null)
query.GroupMax = groupMax;
if (filterType == WhereFilter) {
query.WhereExpression = filterExpression;
} else if (filterType == HavingFilter) {
query.HavingExpression = filterExpression;
}
return query;
}
public MemoryDbDataReader.ResultBatch Execute(RawData rawData, Dictionary <string, Table> tables,
SqlQueryExpression expression,
SqlOrderByClause orderByClause = null)
{
switch (expression)
{
case SqlBinaryQueryExpression binaryQueryExpression:
{
var commandLeft = new MemoryDbCommand(_Command);
var rawDataLeft = new RawData(commandLeft);
var batchLeft = Execute(rawDataLeft, tables, binaryQueryExpression.Left);
var commandRight = new MemoryDbCommand(_Command);
var rawDataRight = new RawData(commandRight);
var batchRight = Execute(rawDataRight, tables, binaryQueryExpression.Right);
var batch = MergeBatches(batchLeft, batchRight, binaryQueryExpression.Operator);
if (orderByClause != null)
{
var resultRawData = new RawData(_Command, batch);
new QueryResultBuilder(resultRawData).AddOrderedResultRows(batch, orderByClause.Items);
}
return(batch);
}
case SqlQuerySpecification sqlQuery:
{
return(Execute(tables, rawData, sqlQuery, orderByClause));
}
default:
throw new NotImplementedException($"Query expressions of type {expression} are currently not implemented.");
}
}
protected override SqlStatement PrepareStatement(IRequest context)
{
var tableName = context.Access().ResolveTableName(TableName);
if (!context.Access().TableExists(tableName))
{
throw new ObjectNotFoundException(tableName);
}
var queryExp = new SqlQueryExpression(new SelectColumn[] { SelectColumn.Glob("*") });
queryExp.FromClause.AddTable(tableName.FullName);
queryExp.WhereExpression = WhereExpression;
var queryInfo = new QueryInfo(context, queryExp);
if (Limit > 0)
{
queryInfo.Limit = new QueryLimit(Limit);
}
var queryPlan = context.Query.Context.QueryPlanner().PlanQuery(queryInfo);
return(new Prepared(tableName, queryPlan));
}
private JoinPart(JoinType joinType, ObjectName tableName, SqlQueryExpression query, SqlExpression onExpression)
{
JoinType = joinType;
TableName = tableName;
Query = query;
OnExpression = onExpression;
}
private void PrepareJoins(QueryTablePlanner tablePlanner, SqlQueryExpression queryExpression, QueryExpressionFrom queryFrom, ref SqlExpression searchExpression)
{
var fromClause = queryExpression.FromClause;
bool allInner = true;
for (int i = 0; i < fromClause.JoinPartCount; i++)
{
var joinPart = fromClause.GetJoinPart(i);
if (joinPart.JoinType != JoinType.Inner)
{
allInner = false;
}
}
for (int i = 0; i < fromClause.JoinPartCount; i++)
{
var joinPart = fromClause.GetJoinPart(i);
var joinType = joinPart.JoinType;
var onExpression = joinPart.OnExpression;
if (allInner)
{
// If the whole join set is inner joins then simply move the on
// expression (if there is one) to the WHERE clause.
if (searchExpression != null && onExpression != null)
{
searchExpression = SqlExpression.And(searchExpression, onExpression);
}
else if (searchExpression == null)
{
searchExpression = onExpression;
}
}
else
{
// Not all inner joins,
if (joinType == JoinType.Inner && onExpression == null)
{
// Regular join with no ON expression, so no preparation necessary
}
else
{
// Either an inner join with an ON expression, or an outer join with
// ON expression
if (onExpression == null)
{
throw new InvalidOperationException(String.Format("Join of type {0} requires ON expression.", joinType));
}
// Resolve the on_expression
onExpression = onExpression.Prepare(queryFrom.ExpressionPreparer);
// And set it in the planner
tablePlanner.JoinAt(i, joinType, onExpression);
}
}
}
}
internal JoinPart(JoinType joinType, SqlQueryExpression query, SqlExpression onExpression)
: this(joinType, null, query, onExpression)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
}
public override string Translate(SqlCompilerContext context, SqlQueryExpression node, QueryExpressionSection section)
{
if (node.All && section == QueryExpressionSection.All && (node.NodeType == SqlNodeType.Except || node.NodeType == SqlNodeType.Intersect))
{
return(string.Empty);
}
return(base.Translate(context, node, section));
}
public virtual void Visit(SqlQueryExpression node)
{
VisitInternal(node.Left);
VisitInternal(node.Right);
foreach (ISqlQueryExpression expression in node)
{
VisitInternal(expression);
}
}
internal FromTableSubQuerySource(bool caseInsensitive, string uniqueKey, SqlQueryExpression queryExpression,
QueryExpressionFrom fromSet, ObjectName alias)
{
UniqueName = uniqueKey;
QueryExpression = queryExpression;
QueryFrom = fromSet;
AliasName = alias;
IgnoreCase = caseInsensitive;
}
public ISelectStatementBuilder Query(SqlQueryExpression expression)
{
if (expression == null)
{
throw new ArgumentNullException("expression");
}
queryExpression = expression;
return(this);
}
public SelectStatement(SqlQueryExpression queryExpression, IEnumerable <SortColumn> orderBy)
{
if (queryExpression == null)
{
throw new ArgumentNullException("queryExpression");
}
QueryExpression = queryExpression;
OrderBy = orderBy;
}
public void Visit(SqlQueryExpression node)
{
if (node.Left != null)
{
Visit(node.Left);
}
if (node.Right != null)
{
Visit(node.Right);
}
}
public override void Visit(SqlQueryExpression node)
{
using (context.EnterScope(node)) {
context.Output.AppendText(translator.Translate(context, node, QueryExpressionSection.Entry));
node.Left.AcceptVisitor(this);
context.Output.AppendText(translator.Translate(node.NodeType));
context.Output.AppendText(translator.Translate(context, node, QueryExpressionSection.All));
node.Right.AcceptVisitor(this);
context.Output.AppendText(translator.Translate(context, node, QueryExpressionSection.Exit));
}
}
public static ICursor Select(this IRequest request, params SqlExpression[] args)
{
if (args == null || args.Length == 0)
{
throw new ArgumentNullException("args");
}
var columns = args.Select(x => new SelectColumn(x));
var query = new SqlQueryExpression(columns);
return(request.Select(query));
}
public void DeclareInsensitiveCursor()
{
var query = new SqlQueryExpression(new [] { new SelectColumn(SqlExpression.Constant("*")) });
query.FromClause = new FromClause();
query.FromClause.AddTable("test_table");
Assert.DoesNotThrow(() => Query.DeclareInsensitiveCursor("c1", query));
var exists = Query.ObjectExists(DbObjectType.Cursor, new ObjectName("c1"));
Assert.IsTrue(exists);
}
private SqlQueryExpression PrepareQuery(SqlExpression[] args)
{
SqlQueryExpression query = CursorInfo.QueryExpression;
if (CursorInfo.Parameters.Count > 0)
{
var cursorArgs = BuildArgs(CursorInfo.Parameters, args);
var preparer = new CursorArgumentPreparer(cursorArgs);
query = query.Prepare(preparer) as SqlQueryExpression;
}
return(query);
}
public SelectIntoStatement(SqlQueryExpression queryExpression, SqlExpression reference)
{
if (queryExpression == null)
{
throw new ArgumentNullException("queryExpression");
}
if (reference == null)
{
throw new ArgumentNullException("reference");
}
QueryExpression = queryExpression;
Reference = reference;
}
protected virtual string Visit(SqlQueryExpression sqe)
{
if (sqe is SqlBinaryExpression x1)
{
return(VisitBinary(x1));
}
if (sqe is SqlColumnReference x2)
{
return(VisitColumnReference(x2));
}
if (sqe is SqlEmptyExpression x3)
{
return(VisitEmpty(x3));
}
if (sqe is SqlInExpression x4)
{
return(VisitIn(x4));
}
if (sqe is SqlObjectParameter x5)
{
return(VisitObjectParameter(x5));
}
if (sqe is SqlQueryLiteralExpression x6)
{
return(VisitLiteral(x6));
}
if (sqe is SqlNullExpression x7)
{
return(VisitNull(x7));
}
if (sqe is SqlBooleanExpression x8)
{
return(VisitBoolean(x8));
}
if (sqe is SqlTableReference x9)
{
return(VisitTableReference(x9));
}
if (sqe is SqlTernaryExpression x10)
{
return(VisitTernary(x10));
}
if (sqe is SqlUnaryExpression x11)
{
return(VisitUnary(x11));
}
throw new Exception("Unknown expression type");
}
public InsertSelectStatement(ObjectName tableName, IEnumerable <string> columnNames, SqlQueryExpression queryExpression)
{
if (tableName == null)
{
throw new ArgumentNullException("tableName");
}
if (queryExpression == null)
{
throw new ArgumentNullException("queryExpression");
}
TableName = tableName;
ColumnNames = columnNames;
QueryExpression = queryExpression;
}
public CreateViewStatement(string viewName, IEnumerable <string> columnNames, SqlQueryExpression queryExpression)
{
if (viewName == null)
{
throw new ArgumentNullException("viewName");
}
if (queryExpression == null)
{
throw new ArgumentNullException("queryExpression");
}
ViewName = viewName;
ColumnNames = columnNames;
QueryExpression = queryExpression;
}
public void BuildIn(SqlQueryExpression query)
{
sourceBuilder.BuildIn(query);
query.FromClause.Join(sourceJoinType, joinExpression);
}
public void BuildIn(SqlQueryExpression query)
{
if (sourceType == TableSource) {
query.FromClause.AddTable(aliasName, sourceTableName.ToString());
} else if (sourceType == QuerySource) {
var subQuery = sourceQuery.Build();
query.FromClause.AddSubQuery(aliasName, subQuery);
} else if (sourceType == UnknownSource) {
throw new InvalidOperationException("Unknown source type");
}
if (joinBuilder != null)
joinBuilder.BuildIn(query);
}
