private void ConvertExpressionConstantsNotation(SQLExpressionItem expression)
{
Debug.Assert(expression != null);
List <AstNodeBase> astNodes = new List <AstNodeBase>();
// get all children (and grand[grand...]children) AST nodes as a flat list
expression.GetMyChildrenRecursive(astNodes);
// add expression node itself to AST nodes list
// (to check is the given expression is constant itself)
astNodes.Add(expression);
// remove all items from the list except TSQLExpressionConstant
for (int i = astNodes.Count - 1; i >= 0; i--)
{
if (!(astNodes[i] is SQLExpressionConstant))
{
astNodes.RemoveAt(i);
}
}
// for each item in the list
for (int i = 0; i < astNodes.Count; i++)
{
ConvertConstantNotation((SQLExpressionConstant)astNodes[i]);
}
}
private void ReplaceWhereAccess(UnionSubQuery unionSubQuery, string newWhereStr)
{
// parse and prepare new WHERE expression
SQLExpressionItem newWhere = ParseExpressionAccess(newWhereStr);
if (newWhere != null)
{
FixupExpression(unionSubQuery, newWhere);
ConvertExpressionConstantsNotation(newWhere);
}
// defer SQL updates
unionSubQuery.BeginUpdate();
try
{
// clear old WHERE expression
ClearWhere(unionSubQuery);
// load new WHERE expression (if exists)
if (newWhere != null)
{
unionSubQuery.QueryColumnList.LoadConditionFromAST(newWhere, ConditionType.Where);
}
}
finally
{
// enable SQL updates
unionSubQuery.EndUpdate();
}
}
private void FixupExpression(QueryElement queryContext, SQLExpressionItem expression)
{
Debug.Assert(expression != null);
List <SQLWithClauseItem> listCTE = new List <SQLWithClauseItem>();
List <SQLFromSource> listFromSources = new List <SQLFromSource>();
// fix up names in raw AST in given context
queryContext.GatherPrepareAndFixupContext(listCTE, listFromSources, true);
expression.PrepareAndFixupRecursive(listCTE, listFromSources);
}
private void DumpExpression(StringBuilder stringBuilder, string indent, SQLExpressionItem expression)
{
const string cIndentInc = " ";
string newIndent = indent + cIndentInc;
if (expression == null) // NULL reference protection
{
stringBuilder.AppendLine(indent + "--nil--" + "<br />");
}
else if (expression is SQLExpressionBrackets)
{
// Expression is actually the brackets query structure node.
// Create the "brackets" tree node and load content of
// the brackets as children of the node.
stringBuilder.AppendLine(indent + "()" + "<br />");
DumpExpression(stringBuilder, newIndent, ((SQLExpressionBrackets)expression).LExpression);
}
else if (expression is SQLExpressionOr)
{
// Expression is actually the "OR" query structure node.
// Create the "OR" tree node and load all items of
// the "OR" collection as children of the tree node.
stringBuilder.AppendLine(indent + "OR" + "<br />");
for (int i = 0; i < ((SQLExpressionOr)expression).Count; i++)
{
DumpExpression(stringBuilder, newIndent, ((SQLExpressionOr)expression)[i]);
}
}
else if (expression is SQLExpressionAnd)
{
// Expression is actually the "AND" query structure node.
// Create the "AND" tree node and load all items of
// the "AND" collection as children of the tree node.
stringBuilder.AppendLine(indent + "AND" + "<br />");
for (int i = 0; i < ((SQLExpressionAnd)expression).Count; i++)
{
DumpExpression(stringBuilder, newIndent, ((SQLExpressionAnd)expression)[i]);
}
}
else if (expression is SQLExpressionNot)
{
// Expression is actually the "NOT" query structure node.
// Create the "NOT" tree node and load content of
// the "NOT" operator as children of the tree node.
stringBuilder.AppendLine(indent + "NOT" + "<br />");
DumpExpression(stringBuilder, newIndent, ((SQLExpressionNot)expression).LExpression);
}
else if (expression is SQLExpressionOperatorBinary)
{
// Expression is actually the "BINARY OPERATOR" query structure node.
// Create a tree node containing the operator value and
// two leaf nodes with the operator arguments.
string s = ((SQLExpressionOperatorBinary)expression).OperatorObj.OperatorName;
stringBuilder.AppendLine(indent + s + "<br />");
// left argument of the binary operator
DumpExpression(stringBuilder, newIndent, ((SQLExpressionOperatorBinary)expression).LExpression);
// right argument of the binary operator
DumpExpression(stringBuilder, newIndent, ((SQLExpressionOperatorBinary)expression).RExpression);
}
else
{
// other type of AST nodes - out as a text
string s = expression.GetSQL(expression.SQLContext.SQLGenerationOptionsForServer);
stringBuilder.AppendLine(indent + s + "<br />");
}
}
public void DumpWhereInfo(StringBuilder stringBuilder, SQLExpressionItem where)
{
DumpExpression(stringBuilder, "", where);
}
private void AppendWhere(UnionSubQuery unionSubQuery, string newWhereStr)
{
SQLExpressionAnd resultWhere;
// parse and prepare new WHERE expression
SQLExpressionItem newWhere = ParseExpression(newWhereStr);
// if there are no new expression - nothing to do
if (newWhere == null)
{
return;
}
// extract old WHERE expression
SQLExpressionItem oldWhere = unionSubQuery.QueryColumnList.GetConditionTree(new[] { ConditionType.Where });
// normalize old WHERE expression
if (oldWhere != null)
{
oldWhere.RestoreColumnPrefixRecursive(true);
}
// simplify old WHERE expression
if (oldWhere != null)
{
// if old WHERE is a collection of ORed or ANDed expressions
// with only one expression in the list - remove the external list
while (oldWhere is SQLExpressionLogicalCollection &&
((SQLExpressionLogicalCollection)oldWhere).Count == 1)
{
using (SQLExpressionLogicalCollection tmp = (SQLExpressionLogicalCollection)oldWhere)
{
oldWhere = tmp.Extract(0);
}
}
}
// combine old and new WHERE expressions
resultWhere = new SQLExpressionAnd(queryBuilder1.SQLContext);
if (oldWhere != null)
{
resultWhere.Add(oldWhere);
}
resultWhere.Add(newWhere);
// fix up combined WHERE expression
FixupExpression(unionSubQuery, resultWhere);
// defer SQL updates
unionSubQuery.BeginUpdate();
try
{
// clear old WHERE expression
ClearWhere(unionSubQuery);
// load new WHERE expression (if exists)
unionSubQuery.QueryColumnList.LoadConditionFromAST(resultWhere, ConditionType.Where);
}
finally
{
// enable SQL updates
unionSubQuery.EndUpdate();
}
}
