/// <summary>
/// Initializes a query expression ast node.
/// </summary>
/// <param name="selectClause">select clause</param>
/// <param name="fromClause">from clasuse</param>
/// <param name="whereClause">optional where clause</param>
/// <param name="groupByClause">optional group by clause</param>
/// <param name="havingClause">optional having clause</param>
/// <param name="orderByClause">optional order by clause</param>
internal QueryExpr(
SelectClause selectClause,
FromClause fromClause,
Node whereClause,
GroupByClause groupByClause,
HavingClause havingClause,
OrderByClause orderByClause)
{
_selectClause = selectClause;
_fromClause = fromClause;
_whereClause = whereClause;
_groupByClause = groupByClause;
_havingClause = havingClause;
_orderByClause = orderByClause;
}
internal QueryExpr(
SelectClause selectClause,
FromClause fromClause,
Node whereClause,
GroupByClause groupByClause,
HavingClause havingClause,
OrderByClause orderByClause)
{
this._selectClause = selectClause;
this._fromClause = fromClause;
this._whereClause = whereClause;
this._groupByClause = groupByClause;
this._havingClause = havingClause;
this._orderByClause = orderByClause;
}
public string BuildSQL(string condition, string having, params string[] sorts)
{
string sqlstr = SelectClause + " " + FromClause;
if (condition != null && condition.Trim().Length > 0)
{
if (WhereClause == null || WhereClause.Trim().Length <= 0)
{
sqlstr += " where " + condition;
}
else
{
sqlstr += " where ( " + condition + " ) and ( " + WhereClause + " )";
}
}
else if (WhereClause != null && WhereClause.Trim().Length > 0)
{
sqlstr += " where " + WhereClause;
}
if (GroupByList != null && GroupByList.Trim().Length > 0)
{
sqlstr += " group by " + GroupByList;
if (having != null && having.Trim().Length > 0)
{ //用户指定了条件并且有分组,则用户指定条件合并到HAVING子句中
if (HavingClause == null || HavingClause.Trim().Length <= 0)
{
sqlstr += " having " + having;
}
else
{
sqlstr += " having ( " + having + " ) and ( " + HavingClause + " )";
}
}
else if (HavingClause != null && HavingClause.Trim().Length > 0)
{
sqlstr += " having " + HavingClause;
}
}
if (sorts.Length > 0)
{
sqlstr += " " + string.Join(",", sorts);
}
else if (OrderByList != null && OrderByList.Trim().Length > 0)
{
sqlstr += " order by " + OrderByList;
}
return(sqlstr);
}
public void AddHavingClauses()
{
Column column1 = new Column("Column1");
Column column2 = new Column("Column2");
StringLiteralValue stringLiteralValue1 = new StringLiteralValue("Value1");
StringLiteralValue stringLiteralValue2 = new StringLiteralValue("Value2");
ComparisonPredicate comparisonPredicate1 = new ComparisonPredicate(column1, ComparisonPredicateType.Equals, stringLiteralValue1);
ComparisonPredicate comparisonPredicate2 = new ComparisonPredicate(column2, ComparisonPredicateType.Equals, stringLiteralValue2);
HavingClause havingClause1 = new HavingClause(comparisonPredicate1);
HavingClause havingClause2 = new HavingClause(comparisonPredicate2);
HavingClauses havingClauses = new HavingClauses(havingClause1, BooleanOperatorType.And, havingClause2);
Assert.AreEqual(havingClause1, havingClauses.LeftClause);
Assert.AreEqual(BooleanOperatorType.And, havingClauses.OperatorType);
Assert.AreEqual(havingClause2, havingClauses.RightClause);
}
/// <summary>
/// Generates the SQL text for the whole query.
/// </summary>
/// <param name="sb">The SQL text formatter.</param>
public void RenderSql(SqlBuilderContext sb)
{
SelectClause.RenderSql(sb);
FromClause.RenderSql(sb);
WhereClause.RenderSql(sb, this);
GroupByClause.RenderSql(sb);
HavingClause.RenderSql(sb);
OrderClause.RenderSql(sb);
if (!string.IsNullOrEmpty(ForClause))
{
sb.AppendOnNewLine(ForClause);
}
}
public void TestCloneHavingClause()
{
HavingClause havingClause = new HavingClause()
{
Expression = new BooleanScalarExpression()
{
ScalarExpression = new ColumnReference()
{
Identifiers = new List <string>()
{
"c1"
}
}
}
};
var clone = havingClause.Clone() as HavingClause;
Assert.AreEqual(havingClause, clone);
Assert.IsFalse(ReferenceEquals(havingClause, clone));
Assert.IsFalse(ReferenceEquals(havingClause.Expression, clone.Expression));
}
public override void AcceptChildren(WSqlFragmentVisitor visitor)
{
if (FromClause != null)
{
FromClause.Accept(visitor);
}
if (MatchClause != null)
{
MatchClause.Accept(visitor);
}
if (WhereClause != null)
{
WhereClause.Accept(visitor);
}
if (TopRowFilter != null)
{
TopRowFilter.Accept(visitor);
}
if (GroupByClause != null)
{
GroupByClause.Accept(visitor);
}
if (HavingClause != null)
{
HavingClause.Accept(visitor);
}
if (SelectElements != null)
{
var index = 0;
for (var count = SelectElements.Count; index < count; ++index)
{
SelectElements[index].Accept(visitor);
}
}
base.AcceptChildren(visitor);
}
internal override string ToString(string indent)
{
var sb = new StringBuilder(1024);
if (WithPathClause2 != null)
{
sb.Append(WithPathClause2.ToString(indent));
}
sb.AppendFormat("{0}SELECT ", indent);
if (TopRowFilter != null)
{
if (TopRowFilter.OneLine())
{
sb.AppendFormat("{0} ", TopRowFilter.ToString(""));
}
else
{
sb.Append("\r\n");
sb.AppendFormat("{0} ", TopRowFilter.ToString(indent));
}
}
switch (UniqueRowFilter)
{
case UniqueRowFilter.All:
sb.Append("ALL ");
break;
case UniqueRowFilter.Distinct:
sb.Append("DISTINCT ");
break;
}
for (var i = 0; i < SelectElements.Count; i++)
{
if (i > 0)
{
sb.Append(", ");
}
if (SelectElements[i].OneLine())
{
sb.Append(SelectElements[i].ToString(""));
}
else
{
sb.Append("\r\n");
sb.Append(SelectElements[i].ToString(indent + " "));
}
}
if (Into != null)
{
sb.AppendFormat(" INTO {0} ", Into);
}
if (FromClause != null)
{
sb.Append("\r\n");
sb.Append(FromClause.ToString(indent));
}
if (MatchClause != null)
{
sb.Append("\r\n");
sb.Append(MatchClause.ToString(indent));
}
if (WhereClause != null && (WhereClause.SearchCondition != null || !string.IsNullOrEmpty(WhereClause.GhostString)))
{
sb.Append("\r\n");
sb.Append(WhereClause.ToString(indent));
}
if (GroupByClause != null)
{
sb.Append("\r\n");
sb.Append(GroupByClause.ToString(indent));
}
if (HavingClause != null)
{
sb.Append("\r\n");
sb.Append(HavingClause.ToString(indent));
}
if (OrderByClause != null)
{
sb.Append("\r\n");
sb.Append(OrderByClause.ToString(indent));
}
return(sb.ToString());
}
/*
* private bool ContainsAggregateExpressions(Statement AExpression)
* {
* if (AExpression is UnaryExpression)
* return ContainsAggregateExpressions(((UnaryExpression)AExpression).Expression);
* else if (AExpression is BinaryExpression)
* return
* ContainsAggregateExpressions(((BinaryExpression)AExpression).LeftExpression) ||
* ContainsAggregateExpressions(((BinaryExpression)AExpression).RightExpression);
* else if (AExpression is AggregateCallExpression)
* return true;
* else if (AExpression is CallExpression)
* {
* foreach (Expression LExpression in ((CallExpression)AExpression).Expressions)
* if (ContainsAggregateExpressions(LExpression))
* return true;
* return false;
* }
* else if (AExpression is CaseExpression)
* {
* CaseExpression LExpression = (CaseExpression)AExpression;
* if (ContainsAggregateExpressions(LExpression.Expression))
* return true;
* foreach (CaseItemExpression LCaseItem in LExpression.CaseItems)
* if (ContainsAggregateExpressions(LCaseItem))
* return true;
* if (ContainsAggregateExpressions(LExpression.ElseExpression))
* return true;
* return false;
* }
* else if (AExpression is BetweenExpression)
* {
* BetweenExpression LExpression = (BetweenExpression)AExpression;
* return
* ContainsAggregateExpressions(LExpression.Expression) ||
* ContainsAggregateExpressions(LExpression.LowerExpression) ||
* ContainsAggregateExpressions(LExpression.UpperExpression);
* }
* else if (AExpression is UserExpression)
* {
* foreach (Expression LExpression in ((UserExpression)AExpression).Expressions)
* if (ContainsAggregateExpressions(LExpression))
* return true;
* return false;
* }
* else if (AExpression is QueryExpression)
* {
* QueryExpression LExpression = (QueryExpression)AExpression;
* if (ContainsAggregateExpressions(LExpression.SelectExpression))
* return true;
* foreach (TableOperatorExpression LTableOperator in LExpression.TableOperators)
* if (ContainsAggregateExpressions(LTableOperator.SelectExpression))
* return true;
* return false;
* }
* else if (AExpression is SelectExpression)
* {
* SelectExpression LExpression = (SelectExpression)AExpression;
* return
* ContainsAggregateExpressions(LExpression.SelectClause) ||
* ContainsAggregateExpressions(LExpression.FromClause) ||
* ContainsAggregateExpressions(LExpression.WhereClause) ||
* ContainsAggregateExpressions(LExpression.GroupClause) ||
* ContainsAggregateExpressions(LExpression.HavingClause);
* }
* else if (AExpression is SelectClause)
* {
* SelectClause LClause = (SelectClause)AExpression;
* foreach (ColumnExpression LColumn in LClause.Columns)
* if (ContainsAggregateExpressions(LColumn.Expression))
* return true;
* return false;
* }
* else if (AExpression is AlgebraicFromClause)
* {
* AlgebraicFromClause LClause = (AlgebraicFromClause)AExpression;
* if (ContainsAggregateExpressions(LClause.TableSpecifier.TableExpression))
* return true;
* foreach (JoinClause LJoin in LClause.Joins)
* if (ContainsAggregateExpressions(LJoin.FromClause) || ContainsAggregateExpressions(LJoin.JoinExpression))
* return true;
* return false;
* }
* else if (AExpression is CalculusFromClause)
* {
* CalculusFromClause LClause = (CalculusFromClause)AExpression;
* foreach (TableSpecifier LTable in LClause.TableSpecifiers)
* if (ContainsAggregateExpressions(LTable.TableExpression))
* return true;
* return false;
* }
* else if (AExpression is FilterClause)
* return ContainsAggregateExpressions(((FilterClause)AExpression).Expression);
* else if (AExpression is GroupClause)
* {
* GroupClause LClause = (GroupClause)AExpression;
* foreach (Expression LExpression in LClause.Columns)
* if (ContainsAggregateExpressions(LExpression))
* return true;
* return false;
* }
* return false;
* }
*/
private void EnsureRestrictedWhereClause()
{
if ((_restrictedWhereClause == null) && (_restrictedHavingClause == null))
{
// modify the statement to return everything greater than the last row in the set, inclusive, for all key colummns
/*
* for each column in the key, descending
* [or]
* for each column in the origin less than the current key column
* [and] ((current origin column is null and current origin value is null) or (current origin column = current origin value))
*
* [and]
* if the current key column is the last origin column
* ((Current key column is null and current origin value is null) or (current key column >= current origin value))
* else
* current key column > current origin value
*/
Expression columnExpression;
Expression keyExpression;
Expression restrictExpression = null;
for (int keyIndex = _keyIndexes.Length - 1; keyIndex >= 0; keyIndex--)
{
keyExpression = null;
for (int columnIndex = 0; columnIndex < keyIndex; columnIndex++)
{
columnExpression =
new BinaryExpression
(
new BinaryExpression
(
new UnaryExpression("iIsNull", _statement.QueryExpression.SelectExpression.SelectClause.Columns[_keyIndexes[columnIndex]].Expression),
"iAnd",
new UnaryExpression("iIsNull", new QueryParameterExpression(_statement.QueryExpression.SelectExpression.SelectClause.Columns[_keyIndexes[columnIndex]].ColumnAlias))
),
"iOr",
new BinaryExpression
(
_statement.QueryExpression.SelectExpression.SelectClause.Columns[_keyIndexes[columnIndex]].Expression,
"iEqual",
new QueryParameterExpression(_statement.QueryExpression.SelectExpression.SelectClause.Columns[_keyIndexes[columnIndex]].ColumnAlias)
)
);
if (keyExpression != null)
{
keyExpression = new BinaryExpression(keyExpression, "iAnd", columnExpression);
}
else
{
keyExpression = columnExpression;
}
}
if (_statement.OrderClause.Columns[keyIndex].Ascending)
{
#if USEINCLUSIVEMULTIPLEX
if (keyIndex == (_keyIndexes.Length - 1))
{
columnExpression =
new BinaryExpression
(
new UnaryExpression("iIsNull", new QueryParameterExpression(_statement.QueryExpression.SelectExpression.SelectClause.Columns[_keyIndexes[keyIndex]].ColumnAlias)),
"iOr",
new BinaryExpression
(
_statement.QueryExpression.SelectExpression.SelectClause.Columns[_keyIndexes[keyIndex]].Expression,
"iInclusiveGreater",
new QueryParameterExpression(_statement.QueryExpression.SelectExpression.SelectClause.Columns[_keyIndexes[keyIndex]].ColumnAlias)
)
);
}
else
#endif
columnExpression =
new BinaryExpression
(
new BinaryExpression
(
new UnaryExpression("iNot", new UnaryExpression("iIsNull", _statement.QueryExpression.SelectExpression.SelectClause.Columns[_keyIndexes[keyIndex]].Expression)),
"iAnd",
new UnaryExpression("iIsNull", new QueryParameterExpression(_statement.QueryExpression.SelectExpression.SelectClause.Columns[_keyIndexes[keyIndex]].ColumnAlias))
),
"iOr",
new BinaryExpression
(
_statement.QueryExpression.SelectExpression.SelectClause.Columns[_keyIndexes[keyIndex]].Expression,
"iGreater",
new QueryParameterExpression(_statement.QueryExpression.SelectExpression.SelectClause.Columns[_keyIndexes[keyIndex]].ColumnAlias)
)
);
}
else
{
#if USEINCLUSIVEMULTIPLEX
if (keyIndex == (_keyIndexes.Length - 1))
{
columnExpression =
new BinaryExpression
(
new UnaryExpression("iIsNull", _statement.QueryExpression.SelectExpression.SelectClause.Columns[_keyIndexes[keyIndex]].Expression),
"iOr",
new BinaryExpression
(
_statement.QueryExpression.SelectExpression.SelectClause.Columns[_keyIndexes[keyIndex]].Expression,
"iInclusiveLess",
new QueryParameterExpression(_statement.QueryExpression.SelectExpression.SelectClause.Columns[_keyIndexes[keyIndex]].ColumnAlias)
)
);
}
else
#endif
columnExpression =
new BinaryExpression
(
new BinaryExpression
(
new UnaryExpression("iIsNull", _statement.QueryExpression.SelectExpression.SelectClause.Columns[_keyIndexes[keyIndex]].Expression),
"iAnd",
new UnaryExpression("iNot", new UnaryExpression("iIsNull", new QueryParameterExpression(_statement.QueryExpression.SelectExpression.SelectClause.Columns[_keyIndexes[keyIndex]].ColumnAlias)))
),
"iOr",
new BinaryExpression
(
_statement.QueryExpression.SelectExpression.SelectClause.Columns[_keyIndexes[keyIndex]].Expression,
"iLess",
new QueryParameterExpression(_statement.QueryExpression.SelectExpression.SelectClause.Columns[_keyIndexes[keyIndex]].ColumnAlias)
)
);
}
if (keyExpression != null)
{
keyExpression = new BinaryExpression(keyExpression, "iAnd", columnExpression);
}
else
{
keyExpression = columnExpression;
}
if (restrictExpression != null)
{
restrictExpression = new BinaryExpression(restrictExpression, "iOr", keyExpression);
}
else
{
restrictExpression = keyExpression;
}
}
if (_isAggregate)
{
_restrictedHavingClause = new HavingClause();
if (_originalHavingClause != null)
{
_restrictedHavingClause.Expression = new BinaryExpression(_originalHavingClause.Expression, "iAnd", restrictExpression);
}
else
{
_restrictedHavingClause.Expression = restrictExpression;
}
}
else
{
_restrictedWhereClause = new WhereClause();
if (_originalWhereClause != null)
{
_restrictedWhereClause.Expression = new BinaryExpression(_originalWhereClause.Expression, "iAnd", restrictExpression);
}
else
{
_restrictedWhereClause.Expression = restrictExpression;
}
}
}
}
public override void Visit(QuerySpecification node)
{
WhereClause lol = node.WhereClause;
HavingClause xD = node.HavingClause;
if (lol != null)
{
if (!GetNodeTokenText(lol).ToLower().Contains("select"))
{
seperate(GetNodeTokenText(lol).ToLower().Replace("where", ""));
}
else
{
seperate(GetNodeTokenText(lol).ToLower().Substring(6, GetNodeTokenText(lol).Length - 6));
}
}
if (xD != null)
{
string havingClause = GetNodeTokenText(xD).ToLower().Substring(6, GetNodeTokenText(xD).Length - 6);
havingClause = havingClause.Replace("\r\n", "");
Regex rgx = new Regex(@"\s+");
havingClause = rgx.Replace(havingClause, " ");
selection += "|" + havingClause;
filtreHaving = havingClause;
}
/* MY BIG PART OF CODE ! mouahaha*/
id_requete_courante = Int32.Parse(this.id);
node.ToString();
bool starExpression = false;
if (this.id_requete_courante != this.id_requete_precedante)
{
projectionList = new List <String>();
Regex rxUser = new Regex(@"\[[^\[\]\(\)]*\]\.\[[^\[\]\(\)]*\]", RegexOptions.Compiled | RegexOptions.IgnoreCase);
// Find matches.//
//Console.WriteLine(this.PhysicalTableList["[1002].[Tokyo_0_merged.csv]"]);
MatchCollection matchesUser = rxUser.Matches(this.requete);
if (matchesUser.Count > 0)
{
String matchTexte = matchesUser[0].Groups[0].Value;
this.user_courant = matchTexte.Split('.')[0].Replace("[", "").Replace("]", "");
}
if (node.SelectElements != null)
{
foreach (TSqlFragment selectElement in node.SelectElements)
{
if (selectElement is SelectStarExpression)
{
starExpression = true;
if (node.SelectElements.Count > 1)
{
//Lever une exception qui dit que c'est non géré*
break;
}
else
{
if (node.FromClause != null)
{
foreach (TSqlFragment fromElement in node.FromClause.TableReferences)
{
if (fromElement is NamedTableReference)
{
String namedTableReferenceText = GetNodeTokenText(fromElement);
if (this.dictTableWith.ContainsKey(this.id_requete_courante))
{
foreach (CommonTableExpression commonTableExpression in this.dictTableWith[this.id_requete_courante])
{
if (commonTableExpression.ExpressionName.Value == namedTableReferenceText)
{
if (commonTableExpression.QueryExpression is QuerySpecification)
{
QuerySpecification queryUsedForTableDefinition = (QuerySpecification)commonTableExpression.QueryExpression;
foreach (SelectElement selectElementInQueryUsedForTableDefinition in queryUsedForTableDefinition.SelectElements)
{
projectionList.Add(GetNodeTokenText(selectElementInQueryUsedForTableDefinition));
}
}
}
}
}
else
{
Regex rx = new Regex(@"\[.*\]\.\[.*\]", RegexOptions.Compiled | RegexOptions.IgnoreCase);
// Find matches.
//Console.WriteLine(this.PhysicalTableList["[1002].[Tokyo_0_merged.csv]"]);
String matchText = "";
MatchCollection matches = rx.Matches(namedTableReferenceText);
if (matches.Count > 0)
{
matchText = matches[0].Groups[0].Value;
}
if (this.PhysicalTableList.ContainsKey(matchText.ToLower()))
{
foreach (String attribut in this.PhysicalTableList[matchText.ToLower()])
{
projectionList.Add(attribut);
}
}
}
}
}
}
}
}
}
if (starExpression == false)
{
foreach (SelectElement selectElement in node.SelectElements)
{
if (GetNodeTokenText(selectElement).Contains(','))
{
// Console.WriteLine(GetNodeTokenText(selectElement));
}
projectionList.Add(GetNodeTokenText(selectElement));
}
}
}
ProjectionListPerQuery.Add(this.id_requete_courante, projectionList);
int nombreProjectionsCommunes = 0;
int nombreProjections = projectionList.Count;
if (user_precedant.Equals("") || !user_courant.Equals(user_precedant))
{
nombreProjectionsCommunes = 0;
if (!user_courant.Equals(user_precedant))
{
this.id_explo = this.id_explo + 1;
}
}
else
{
if (user_precedant.Equals(user_courant))
{
nombreProjectionsCommunes = previousProjectionList.Intersect(projectionList, StringComparer.InvariantCultureIgnoreCase).ToList().Count;
//Faire l'intersection
}
}
using (StreamWriter sw = File.AppendText(path_explo))
{
sw.WriteLine(this.id_requete_courante + ";" + user_courant + ";" + this.id_explo);
}
previousProjectionList = projectionList;
user_precedant = user_courant;
using (StreamWriter sw = File.AppendText(path_myfriend))
{
sw.Write("\n-------\nProjection pour la requête : " + this.requete);
//sw.Write("Projections pour la requête : " + text_requete_courante);
// Console.WriteLine(" Sont : ");
//sw.Write("\n Sont :");
foreach (String projection in projectionList)
{
//Console.WriteLine(projection);
sw.Write("\n" + projection);
}
sw.Write("\n--------\n");
}
}
this.id_requete_precedante = this.id_requete_courante;
}
public override void Visit(HavingClause node) { this.action(node); }
public override void ExplicitVisit(HavingClause node)
{
Rewrite(node, n => n.SearchCondition);
base.ExplicitVisit(node);
}
public override void ExplicitVisit(HavingClause node)
{
_ignoreAliases = true;
base.ExplicitVisit(node);
_ignoreAliases = false;
}
/// <summary>
/// Renders the object model in it's EPL syntax textual representation, using a whitespace-formatter as provided.
/// </summary>
/// <param name="formatter">the formatter to use</param>
/// <param name="writer">writer to use</param>
/// <throws>IllegalStateException if required clauses do not exist</throws>
public void ToEPL(
EPStatementFormatter formatter,
TextWriter writer)
{
AnnotationPart.ToEPL(writer, Annotations, formatter);
ExpressionDeclaration.ToEPL(writer, ExpressionDeclarations, formatter);
ScriptExpression.ToEPL(writer, ScriptExpressions, formatter);
ClassProvidedExpression.ToEPL(writer, ClassProvidedExpressions, formatter);
if (ContextName != null)
{
formatter.BeginContext(writer);
writer.Write("context ");
writer.Write(ContextName);
}
if (CreateIndex != null)
{
formatter.BeginCreateIndex(writer);
CreateIndex.ToEPL(writer);
return;
}
if (CreateSchema != null)
{
formatter.BeginCreateSchema(writer);
CreateSchema.ToEPL(writer);
return;
}
if (CreateExpression != null)
{
formatter.BeginCreateExpression(writer);
CreateExpression.ToEPL(writer);
return;
}
if (CreateClass != null)
{
formatter.BeginCreateExpression(writer);
CreateClass.ToEPL(writer);
return;
}
if (CreateContext != null)
{
formatter.BeginCreateContext(writer);
CreateContext.ToEPL(writer, formatter);
return;
}
if (CreateWindow != null)
{
formatter.BeginCreateWindow(writer);
CreateWindow.ToEPL(writer);
writer.Write(" as ");
if (SelectClause == null || SelectClause.SelectList.IsEmpty() && !CreateWindow.Columns.IsEmpty())
{
CreateWindow.ToEPLCreateTablePart(writer);
}
else
{
SelectClause.ToEPL(writer, formatter, false, false);
if (CreateWindow.AsEventTypeName != null)
{
writer.Write(" from ");
writer.Write(CreateWindow.AsEventTypeName);
}
CreateWindow.ToEPLInsertPart(writer);
}
return;
}
if (CreateVariable != null)
{
formatter.BeginCreateVariable(writer);
CreateVariable.ToEPL(writer);
return;
}
if (CreateTable != null)
{
formatter.BeginCreateTable(writer);
CreateTable.ToEPL(writer);
return;
}
if (CreateDataFlow != null)
{
formatter.BeginCreateDataFlow(writer);
CreateDataFlow.ToEPL(writer, formatter);
return;
}
var displayWhereClause = true;
if (UpdateClause != null)
{
formatter.BeginUpdate(writer);
UpdateClause.ToEPL(writer);
}
else if (OnExpr != null)
{
formatter.BeginOnTrigger(writer);
writer.Write("on ");
FromClause.Streams[0].ToEPL(writer, formatter);
if (OnExpr is OnDeleteClause onDeleteClause)
{
formatter.BeginOnDelete(writer);
writer.Write("delete from ");
onDeleteClause.ToEPL(writer);
}
else if (OnExpr is OnUpdateClause onUpdateClause)
{
formatter.BeginOnUpdate(writer);
writer.Write("update ");
onUpdateClause.ToEPL(writer);
}
else if (OnExpr is OnSelectClause onSelectClause)
{
InsertInto?.ToEPL(writer, formatter, true);
SelectClause.ToEPL(writer, formatter, true, onSelectClause.IsDeleteAndSelect);
writer.Write(" from ");
onSelectClause.ToEPL(writer);
}
else if (OnExpr is OnSetClause onSetClause)
{
onSetClause.ToEPL(writer, formatter);
}
else if (OnExpr is OnMergeClause onMergeClause)
{
onMergeClause.ToEPL(writer, WhereClause, formatter);
displayWhereClause = false;
}
else
{
var split = (OnInsertSplitStreamClause)OnExpr;
InsertInto.ToEPL(writer, formatter, true);
SelectClause.ToEPL(writer, formatter, true, false);
if (WhereClause != null)
{
writer.Write(" where ");
WhereClause.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM);
}
split.ToEPL(writer, formatter);
displayWhereClause = false;
}
}
else
{
IntoTableClause?.ToEPL(writer);
if (SelectClause == null)
{
throw new IllegalStateException("Select-clause has not been defined");
}
if (FromClause == null)
{
throw new IllegalStateException("From-clause has not been defined");
}
if (FireAndForgetClause is FireAndForgetUpdate fireAndForgetUpdate)
{
writer.Write("update ");
FromClause.ToEPLOptions(writer, formatter, false);
writer.Write(" ");
UpdateClause.RenderEPLAssignments(writer, fireAndForgetUpdate.Assignments);
}
else if (FireAndForgetClause is FireAndForgetInsert fireAndForgetInsert)
{
InsertInto.ToEPL(writer, formatter, true);
if (fireAndForgetInsert.IsUseValuesKeyword)
{
writer.Write(" values (");
var delimiter = "";
foreach (var element in SelectClause.SelectList)
{
writer.Write(delimiter);
element.ToEPLElement(writer);
delimiter = ", ";
}
writer.Write(")");
}
else
{
SelectClause.ToEPL(writer, formatter, true, false);
}
}
else if (FireAndForgetClause is FireAndForgetDelete)
{
writer.Write("delete ");
FromClause.ToEPLOptions(writer, formatter, true);
}
else
{
InsertInto?.ToEPL(writer, formatter, true);
SelectClause.ToEPL(writer, formatter, true, false);
FromClause.ToEPLOptions(writer, formatter, true);
}
}
MatchRecognizeClause?.ToEPL(writer);
if (WhereClause != null && displayWhereClause)
{
formatter.BeginWhere(writer);
writer.Write("where ");
WhereClause.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM);
}
if (GroupByClause != null)
{
formatter.BeginGroupBy(writer);
writer.Write("group by ");
GroupByClause.ToEPL(writer);
}
if (HavingClause != null)
{
formatter.BeginHaving(writer);
writer.Write("having ");
HavingClause.ToEPL(writer, ExpressionPrecedenceEnum.MINIMUM);
}
if (OutputLimitClause != null)
{
formatter.BeginOutput(writer);
writer.Write("output ");
OutputLimitClause.ToEPL(writer);
}
if (OrderByClause != null)
{
formatter.BeginOrderBy(writer);
writer.Write("order by ");
OrderByClause.ToEPL(writer);
}
if (RowLimitClause != null)
{
formatter.BeginLimit(writer);
writer.Write("limit ");
RowLimitClause.ToEPL(writer);
}
if (ForClause != null)
{
formatter.BeginFor(writer);
ForClause.ToEPL(writer);
}
}
protected string CompileHaving(HavingClause having)
{
// TODO: Check for RAW type
return(CompileBasicHaving(having));
}
public QsiGroupingExpressionNode VisitGroupByClause(GroupByClause groupByClause, HavingClause havingClause)
{
return(TreeHelper.Create <QsiGroupingExpressionNode>(n =>
{
n.Items.AddRange(groupByClause.GroupingSpecifications.Select(VisitGroupSpecifcation));
if (havingClause != null)
{
n.Having.SetValue(VisitHavingClause(havingClause));
}
SqlServerTree.PutFragmentSpan(n, groupByClause);
}));
}
public QsiExpressionNode VisitHavingClause(HavingClause havingClause)
{
return(ExpressionVisitor.VisitBooleanExpression(havingClause.SearchCondition));
}
public override string Render(HavingClause havingClause)
{
return(string.Format("{0}", havingClause.Predicate.Render(this)));
}
public abstract string Render(HavingClause havingClause);
public virtual void VisitHavingClause(HavingClause havingClause)
{
Visit(havingClause.Expression);
//DONE
}
public override void Visit(QuerySpecification node)
{
WhereClause lol = node.WhereClause;
HavingClause xD = node.HavingClause;
if (lol != null)
{
if (!GetNodeTokenText(lol).ToLower().Contains("select"))
{
seperate(GetNodeTokenText(lol).ToLower().Replace("where", ""));
}
else
{
seperate(GetNodeTokenText(lol).ToLower().Substring(6, GetNodeTokenText(lol).Length - 6));
}
}
if (xD != null)
{
string havingClause = GetNodeTokenText(xD).ToLower().Substring(6, GetNodeTokenText(xD).Length - 6);
havingClause = havingClause.Replace("\r\n", "");
Regex rgx = new Regex(@"\s+");
havingClause = rgx.Replace(havingClause, " ");
selection += "|" + havingClause;
filtreHaving = havingClause;
}
/* MY BIG PART OF CODE ! mouahaha*/
id_requete_courante = Int32.Parse(this.id);
node.ToString();
//bool starExpression = false;
if (this.id_requete_courante != this.id_requete_precedante)
{
projectionList = new List <String>();
Regex rxUser = new Regex(@"\[[^\[\]\(\)]*\]\.\[[^\[\]\(\)]*\]", RegexOptions.Compiled | RegexOptions.IgnoreCase);
// Find matches.//
//Console.WriteLine(this.PhysicalTableList["[1002].[Tokyo_0_merged.csv]"]);
MatchCollection matchesUser = rxUser.Matches(this.requete);
if (matchesUser.Count > 0)
{
String matchTexte = matchesUser[0].Groups[0].Value;
this.user_courant = matchTexte.Split('.')[0].Replace("[", "").Replace("]", "");
}
//Jesus christ
recursifRecuperationProjection(node);
ProjectionListPerQuery.Add(this.id_requete_courante, projectionList);
int nombreProjectionsCommunes = 0;
int nombreProjections = projectionList.Count;
if (user_precedant.Equals("") || !user_courant.Equals(user_precedant))
{
nombreProjectionsCommunes = 0;
if (!user_courant.Equals(user_precedant))
{
this.id_explo = this.id_explo + 1;
}
}
else
{
if (user_precedant.Equals(user_courant))
{
nombreProjectionsCommunes = previousProjectionList.Intersect(projectionList, StringComparer.InvariantCultureIgnoreCase).ToList().Count;
//Faire l'intersection
}
}
using (StreamWriter sw = File.AppendText(path_explo))
{
sw.WriteLine(this.id_requete_courante + ";" + user_courant + ";" + this.id_explo);
}
previousProjectionList = projectionList;
user_precedant = user_courant;
using (StreamWriter sw = File.AppendText(path_myfriend))
{
sw.Write("\n-------\nProjection pour la requête : " + this.requete);
//sw.Write("Projections pour la requête : " + text_requete_courante);
// Console.WriteLine(" Sont : ");
//sw.Write("\n Sont :");
foreach (String projection in projectionList)
{
//Console.WriteLine(projection);
sw.Write("\n" + projection);
}
sw.Write("\n--------\n");
}
}
this.id_requete_precedante = this.id_requete_courante;
}
public override void ExplicitVisit(HavingClause fragment)
{
_fragments.Add(fragment);
}
protected virtual string GetClauseSql (HavingClause clause)
{
throw new NotImplementedException ();
}
protected virtual string GetClauseSql(HavingClause clause)
{
throw new NotImplementedException();
}
