private void PrintTableReferenceRecurse(TableReference aTableReference)
{
if (aTableReference.GetType() == typeof(NamedTableReference))
{
NamedTableReference aNamedTableReference = (NamedTableReference)aTableReference;
Identifier aAliasIdentifier = aNamedTableReference.Alias;
SchemaObjectName aSchemaObjectName = aNamedTableReference.SchemaObject;
AddLogText(string.Format("Table Reference Schema.Base={0}.{1}",
(aSchemaObjectName.SchemaIdentifier != null) ? aSchemaObjectName.SchemaIdentifier.Value : "",
(aSchemaObjectName.BaseIdentifier != null) ? aSchemaObjectName.BaseIdentifier.Value : "")
);
//foreach (Identifier aSchemaObjectNameIdentifier in aSchemaObjectName.Identifiers)
//{
// AddText(string.Format("Table Reference Identifier={0}", aSchemaObjectNameIdentifier.Value));
//}
if (aAliasIdentifier != null)
{
AddLogText(string.Format("Table Reference Alias:{0}", aAliasIdentifier.Value));
}
aColumnInfoList.AddTableReference(aSchemaObjectName, aAliasIdentifier);
}
if (aTableReference.GetType() == typeof(QualifiedJoin))
{
QualifiedJoin aQualifiedJoin = (QualifiedJoin)aTableReference;
AddLogText(string.Format("Table Reference QualifiedJoinType ={0}", aQualifiedJoin.QualifiedJoinType));
PrintTableReferenceRecurse(aQualifiedJoin.FirstTableReference);
PrintTableReferenceRecurse(aQualifiedJoin.SecondTableReference);
}
if (aTableReference.GetType() == typeof(JoinTableReference))
{
JoinTableReference aJoinTableReference = (JoinTableReference)aTableReference;
PrintTableReferenceRecurse(aJoinTableReference.FirstTableReference);
PrintTableReferenceRecurse(aJoinTableReference.SecondTableReference);
}
}
public override void ExplicitVisit(QualifiedJoin aQualifiedJoin)
{
ScalarExpressionVisitor seVisitor = new ScalarExpressionVisitor(Context);
aQualifiedJoin.AcceptChildren(seVisitor);
AddJoin(aQualifiedJoin.QualifiedJoinType, seVisitor.Columns);
}
private void Pro(QualifiedJoin join)
{
if (join != null)
{
if (join.FirstTableReference is QualifiedJoin)
{
this.Pro(join.FirstTableReference as QualifiedJoin);
}
if (join.FirstTableReference is NamedTableReference)
{
this.Process(join.FirstTableReference as NamedTableReference);
}
if (join.SecondTableReference is QualifiedJoin)
{
this.Pro(join.SecondTableReference as QualifiedJoin);
}
if (join.SecondTableReference is NamedTableReference)
{
this.Process(join.SecondTableReference as NamedTableReference);
}
}
}
/*A chaque join trouvé dans la requête*/
public override void Visit(QualifiedJoin node)
{
/*On récupére l'information en un string pour pouvoir effectuer des opérations dessus
* On enlève toutes les majuscules*/
string study = GetNodeTokenText(node).ToLower();
/*Inialisation de la regex pour trouver les sélections, tout ce qu'il y a après le "on" d'un join*/
Regex regex = new Regex(@"[(/r)|\s+]+on[^A-z].*((\s+)*(substring\([A-z.,'\s+\(\)0-9]*\))|(\s+)*[A-z.0-9]*[\s+]*=[\s+]*[A-z_.0-9]*|(\s+)*[A-z.0-9]*[\s+]=[\s+]*\([A-z\s+0-9.=!\(\]]*\)|(\s+)*[A-z.(\s+)]*=[\s+]*\([A-z\s+0-9 .\[\]=!><\(\),']*\)|((\s+)*(and|or).*)*)?");
Match match = regex.Match(study);
/*Tant qu'on trouve une clause sélection à récupérer*/
while (match.Success)
{
/*On l'extrait de la chaine de caractère*/
string tmp = study.Substring(match.Index, match.Length);
/*Si la selection contient un or ou un and, on appelle la méthode seperate qui va séparer les clauses*/
if (tmp.Contains("or") || tmp.Contains("and"))
{
seperate(tmp);
}
else
{
/*Sinon, on enleve toute les informations superflux ex : "on" du join
* avant de l'ajouter à selection, on regarde si elle y est déjà*/
if (!selection.Contains(tmp.Substring(tmp.IndexOf("on ") + 2, tmp.Length - tmp.IndexOf("on ") - 2)))
{
selection += "|" + tmp.Substring(tmp.IndexOf("on ") + 2, tmp.Length - tmp.IndexOf("on ") - 2);
}
}
/*On enlève la selection trouvée de la chaine initiale et on cherche si il en existe une autre*/
study = study.Substring(0, match.Index) + " " + study.Substring(match.Index + match.Length, study.Length - (match.Index + match.Length));
match = regex.Match(study);
}
}
internal void GetJoins(QualifiedJoin qualifiedJoin)
{
gsJoin join = new gsJoin();
join.JoinType = qualifiedJoin.QualifiedJoinType.ToJoinType();
if (qualifiedJoin.FirstTableReference is QualifiedJoin)
{
GetJoins(qualifiedJoin.FirstTableReference as QualifiedJoin);
}
else if (qualifiedJoin.FirstTableReference is NamedTableReference)
{
join.TableA = GetTable(qualifiedJoin.FirstTableReference as NamedTableReference);
}
else if (qualifiedJoin.FirstTableReference is QueryDerivedTable)
{
join.TableA = GetTable(qualifiedJoin.FirstTableReference as QueryDerivedTable);
}
else
{
throw new NotImplementedException($"Join table reference of type {qualifiedJoin.FirstTableReference.GetType().Name} not supported");
}
if (qualifiedJoin.SecondTableReference is QualifiedJoin)
{
GetJoins(qualifiedJoin.SecondTableReference as QualifiedJoin);
}
else if (qualifiedJoin.SecondTableReference is NamedTableReference)
{
join.TableB = GetTable(qualifiedJoin.SecondTableReference as NamedTableReference);
}
else if (qualifiedJoin.SecondTableReference is QueryDerivedTable)
{
join.TableB = GetTable(qualifiedJoin.SecondTableReference as QueryDerivedTable);
}
else
{
throw new NotImplementedException($"Join table reference of type {qualifiedJoin.SecondTableReference.GetType().Name} not supported");
}
join.JoinClause = new gsWhereClauseParser().GetWhereClause(qualifiedJoin.SearchCondition);
// SqlOm Join syntax is problematic when using the overload with WhereClause.
// Left table is not needed, so we pass the last right table just to be valid for compilation.
try {
if (join.TableA == null)
{
join.TableA = Joins.Last().TableB;
}
if (join.TableB == null)
{
join.TableB = Joins.Last().TableB;
}
}
catch {
throw new NotImplementedException("Join.JoinClause.Terms is only supported as WhereTermCompare");
}
Joins.Add(join);
}
protected override object InternalVisit(QualifiedJoin node)
{
//this should return a tuple of string,recordtable
//the name will probably be null, i dont seem to have access to the alias here.
var first = Visit <IResultTable>(node.FirstTableReference);
var second = Visit <IResultTable>(node.SecondTableReference);
var env = Database.GlobalEnvironment.NewChild();
var where = new WhereClause()
{
SearchCondition = node.SearchCondition
};
var predicate = EvaluateExpression <Func <IResultRow, bool> >(where, env, row => true);
if (predicate == null)
{
predicate = (row) => true;
}
if (node.QualifiedJoinType == QualifiedJoinType.Inner)
{
return(new InnerJoinedTable(first, second, predicate));
}
else
{
return(new OuterJoinedTable(node.QualifiedJoinType, first, second, predicate));
}
}
private void PrintTableReferenceRecurse(TableReference aTableReference)
{
if (aTableReference.GetType() == typeof(NamedTableReference))
{
NamedTableReference aNamedTableReference = (NamedTableReference)aTableReference;
Identifier aAliasIdentifier = aNamedTableReference.Alias;
SchemaObjectName aSchemaObjectName = aNamedTableReference.SchemaObject;
AddLogText(string.Format("Table Reference Server.Database.Schema.Base={0}.{1}.{2}.{3}",
(aSchemaObjectName.ServerIdentifier != null) ? aSchemaObjectName.ServerIdentifier.Value : "",
(aSchemaObjectName.DatabaseIdentifier != null) ? aSchemaObjectName.DatabaseIdentifier.Value : "",
(aSchemaObjectName.SchemaIdentifier != null) ? aSchemaObjectName.SchemaIdentifier.Value : "",
(aSchemaObjectName.BaseIdentifier != null) ? aSchemaObjectName.BaseIdentifier.Value : "")
);
if (aAliasIdentifier != null)
{
AddLogText(string.Format("Table Reference Alias:{0}", aAliasIdentifier.Value));
}
AddTableReference(aSchemaObjectName, aAliasIdentifier);
}
if (aTableReference.GetType() == typeof(QualifiedJoin))
{
QualifiedJoin aQualifiedJoin = (QualifiedJoin)aTableReference;
AddLogText(string.Format("Table Reference QualifiedJoinType ={0}", aQualifiedJoin.QualifiedJoinType.ToString()));
PrintTableReferenceRecurse(aQualifiedJoin.FirstTableReference);
PrintTableReferenceRecurse(aQualifiedJoin.SecondTableReference);
}
if (aTableReference.GetType() == typeof(JoinTableReference))
{
JoinTableReference aJoinTableReference = (JoinTableReference)aTableReference;
PrintTableReferenceRecurse(aJoinTableReference.FirstTableReference);
PrintTableReferenceRecurse(aJoinTableReference.SecondTableReference);
}
}
//JOINが発生する場合に呼び出される。
public override void ExplicitVisit(QualifiedJoin node)
{
if (candidateStack.Count > 0)
{
TableNameIllegalCandidate candidate = candidateStack.Peek();
candidate.hasJoin = true;
}
base.ExplicitVisit(node);
}
/// <summary>
/// WHERE句 にコンストラクタで指定された条件式を追加する。
/// </summary>
/// <param name="node">WHERE句</param>
public override void ExplicitVisit(Microsoft.SqlServer.TransactSql.ScriptDom.FromClause node)
{
try
{
var tableReference = FindTableReference.Compile().Invoke(node);
if (tableReference != null && QualifiedJoinType.HasValue)
{
tableReference = new QualifiedJoin()
{
QualifiedJoinType = QualifiedJoinType.Value,
FirstTableReference = tableReference,
SecondTableReference = TableReference,
JoinHint = JoinHint.Value,
SearchCondition = BooleanExpression,
};
}
else if (tableReference != null && UnqualifiedJoinType.HasValue)
{
tableReference = new UnqualifiedJoin()
{
UnqualifiedJoinType = UnqualifiedJoinType.Value,
FirstTableReference = tableReference,
SecondTableReference = TableReference,
};
}
else
{
tableReference = TableReference;
}
if (FindTableReference.Body is MemberExpression member)
{
var param = Expression.Parameter(typeof(TableReference), "value");
var set = Expression.Lambda <Action <Microsoft.SqlServer.TransactSql.ScriptDom.FromClause, TableReference> >(
Expression.Assign(member, param), FindTableReference.Parameters[0], param);
set.Compile().Invoke(node, tableReference);
}
else
{
var methodCall = ((MethodCallExpression)FindTableReference.Body).Object;
var param = Expression.Parameter(typeof(TableReference), "value");
var set = Expression.Lambda <Action <Microsoft.SqlServer.TransactSql.ScriptDom.FromClause, TableReference> >(
Expression.Assign(Expression.MakeIndex(methodCall, typeof(IList <TableReference>).GetProperty("Item"), new List <Expression>()
{
((IArgumentProvider)FindTableReference.Body).GetArgument(0)
}), param), FindTableReference.Parameters[0], param);
set.Compile().Invoke(node, tableReference);
}
}
catch (Exception e)
{
throw new InvalidOperationException("指定された結合条件は追加できません。", e);
}
}
private void ProcessTableReference(TableReference TableRef)
{
string Type = GetFragmentType(TableRef);
switch (Type)
{
case "FullTextTableReference":
break;
case "NamedTableReference":
var NamedTableRef = (NamedTableReference)TableRef;
var Naming = NamedTableRef.SchemaObject;
string ObjectName = (Naming.DatabaseIdentifier == null ? this.databaseName : Naming.DatabaseIdentifier.Value) + "." +
(Naming.SchemaIdentifier == null ? this.schemaName : Naming.SchemaIdentifier.Value) + "." +
(Naming.BaseIdentifier == null ? "" : Naming.BaseIdentifier.Value);
addSourcetoCurrentObject(ObjectName);
break;
case "QueryDerivedTable":
QueryDerivedTable qdt = (QueryDerivedTable)TableRef;
ProcessQueryExpression(qdt.QueryExpression);
break;
case "QualifiedJoin":
QualifiedJoin qj = (QualifiedJoin)TableRef;
ProcessTableReference(qj.FirstTableReference);
ProcessTableReference(qj.SecondTableReference);
break;
case "UnqualifiedJoin":
UnqualifiedJoin uqj = (UnqualifiedJoin)TableRef;
ProcessTableReference(uqj.FirstTableReference);
ProcessTableReference(uqj.SecondTableReference);
break;
case "SchemaObjectFunctionTableReference":
SchemaObjectFunctionTableReference ftr = (SchemaObjectFunctionTableReference)TableRef;
break;
case "PivotedTableReference":
PivotedTableReference pvt = (PivotedTableReference)TableRef;
ProcessTableReference(pvt.TableReference);
break;
default:
break;
}
}
public override void Visit(QualifiedJoin qualifiedJoin)
{
var findEqualityComparisonVisitor = new FindEqualityComparisonVisitor();
qualifiedJoin.SearchCondition.Accept(findEqualityComparisonVisitor);
foreach (var equalityComparison in findEqualityComparisonVisitor.Comparisons)
{
var firstColumnReferenceExpression = equalityComparison.FirstExpression as ColumnReferenceExpression;
var secondColumnReferenceExpression = equalityComparison.SecondExpression as ColumnReferenceExpression;
if (firstColumnReferenceExpression != null && secondColumnReferenceExpression != null)
{
var firstColumnResolved = resolveMultiPartIdentifier(firstColumnReferenceExpression.MultiPartIdentifier);
var secondColumnResolved = resolveMultiPartIdentifier(secondColumnReferenceExpression.MultiPartIdentifier);
EqualityJoins.Add(new EqualityJoin(firstColumnResolved, secondColumnResolved));
}
}
}
/// <summary>
/// Traverses the joins and gets a list of tables that have been outer joined.
/// </summary>
/// <param name="outerJoinedTables">The outer joined tables list.</param>
/// <param name="qualifiedJoin">The qualified join.</param>
/// <param name="isParentOuterJoined">if set to <c>true</c> a parent join was outer joined.</param>
private void FillOuterJoins(List <string> outerJoinedTables, QualifiedJoin qualifiedJoin, bool isParentOuterJoined)
{
var tableReferences = new List <TableReference>();
if (qualifiedJoin.QualifiedJoinType == QualifiedJoinType.LeftOuter)
{
if (isParentOuterJoined)
{
tableReferences.Add(qualifiedJoin.FirstTableReference);
}
tableReferences.Add(qualifiedJoin.SecondTableReference);
}
else if (qualifiedJoin.QualifiedJoinType == QualifiedJoinType.RightOuter)
{
if (isParentOuterJoined)
{
tableReferences.Add(qualifiedJoin.SecondTableReference);
}
tableReferences.Add(qualifiedJoin.FirstTableReference);
}
else if (qualifiedJoin.QualifiedJoinType == QualifiedJoinType.FullOuter || qualifiedJoin.QualifiedJoinType == QualifiedJoinType.Inner)
{
if (isParentOuterJoined)
{
tableReferences.Add(qualifiedJoin.FirstTableReference);
tableReferences.Add(qualifiedJoin.SecondTableReference);
}
}
foreach (var tableReference in tableReferences)
{
var nestedQualifiedJoin = tableReference as QualifiedJoin;
var namedTableReference = tableReference as NamedTableReference;
if (nestedQualifiedJoin != null)
{
FillOuterJoins(outerJoinedTables, nestedQualifiedJoin, true);
}
else if (namedTableReference != null)
{
var aliasOrName = namedTableReference.Alias != null && !string.IsNullOrEmpty(namedTableReference.Alias.Value)
? namedTableReference.Alias.Value
: namedTableReference.SchemaObject.BaseIdentifier.Value;
outerJoinedTables.Add(aliasOrName);
}
}
}
public override void Visit(QualifiedJoin qualifiedJoin)
{
var findEqualityComparisonVisitor = new FindEqualityComparisonVisitor();
qualifiedJoin.SearchCondition.Accept(findEqualityComparisonVisitor);
foreach (var equalityComparison in findEqualityComparisonVisitor.Comparisons)
{
var firstColumnReferenceExpression = equalityComparison.FirstExpression as ColumnReferenceExpression;
var secondColumnReferenceExpression = equalityComparison.SecondExpression as ColumnReferenceExpression;
if (firstColumnReferenceExpression != null && secondColumnReferenceExpression != null)
{
var firstColumnResolved = resolveMultiPartIdentifier(firstColumnReferenceExpression.MultiPartIdentifier);
var secondColumnResolved = resolveMultiPartIdentifier(secondColumnReferenceExpression.MultiPartIdentifier);
EqualityJoins.Add(new EqualityJoin(firstColumnResolved, secondColumnResolved));
}
}
}
/// <inheritdoc />
public override void ExplicitVisit(QualifiedJoin node)
{
if (toRemove.Count > 0)
{
node.FirstTableReference = RemoveReference(node.FirstTableReference);
node.SecondTableReference = RemoveReference(node.SecondTableReference);
}
if (toReplace.TryGetValue(node.FirstTableReference, out var replacement))
{
toReplace.Remove(node.FirstTableReference);
node.FirstTableReference = replacement;
}
if (toReplace.TryGetValue(node.SecondTableReference, out replacement))
{
toReplace.Remove(node.SecondTableReference);
node.SecondTableReference = replacement;
}
base.ExplicitVisit(node);
}
public override void Visit(QualifiedJoin node)
{
string study = GetNodeTokenText(node).ToLower();
Regex regex = new Regex(@"[(/r)\s+]+on[^A-z].*((\s+)*(substring\([A-z.,'\s+\(\)0-9]*\))|(\s+)*[A-z.0-9]*[\s+]*=[\s+]*[A-z_.0-9]*|(\s+)*[A-z.0-9]*[\s+]=[\s+]*\([A-z\s+0-9.=!\(\]]*\)|(\s+)*[A-z.(\s+)]*=[\s+]*\([A-z\s+0-9.\[\]=!><\(\),']*\)|((\s+)*(and|or).*)*)?");
Match match = regex.Match(study);
while (match.Success)
{
string tmp = study.Substring(match.Index, match.Length);
if (tmp.Contains("or") || tmp.Contains("and"))
{
seperate(tmp);
}
else
{
selection += "|" + tmp.Substring(tmp.IndexOf("on ") + 2, tmp.Length - tmp.IndexOf("on ") - 2);
}
study = study.Substring(0, match.Index) + " " + study.Substring(match.Index + match.Length, study.Length - (match.Index + match.Length));
match = regex.Match(study);
}
study = study.Substring(study.IndexOf("on ") + 2, study.Length - study.IndexOf("on ") - 2);
}
public ISyntaxNode Visit(TSqlFragment node, TSqlFragment parent, string sourceProperty, ISyntaxNode result)
{
QualifiedJoin join = node as QualifiedJoin;
if (join == null)
{
return(result);
}
StatementNode statement = result as StatementNode;
if (statement == null)
{
return(result);
}
statement.VisitContext = join; // set current visiting context
// TODO: how to set VisitingContext to null when QualifiedJoin visiting scope is missed ???
// TODO: EnterContext !?
// TODO: ExitContext !?
return(result);
}
private IList <TableIdentifier> ProcessJoin(QualifiedJoin joinRef, SqlAction action)
{
var identifiers = new List <TableIdentifier>();
if (joinRef != null)
{
HashSet <string> tables;
switch (action)
{
case SqlAction.Delete:
tables = DeleteTables;
break;
default:
tables = SelectTables;
break;
}
identifiers.AddRange(ProcessTableReference(joinRef.FirstTableReference, action, tables));
identifiers.AddRange(ProcessTableReference(joinRef.SecondTableReference, SqlAction.Select));
}
return(identifiers);
}
public override void ExplicitVisit(QualifiedJoin fragment)
{
_fragments.Add(fragment);
}
/// <summary>
/// Recurse through link-entities to add joins to FROM clause and update SELECT clause
/// </summary>
/// <param name="metadata">The metadata cache to use for the conversion</param>
/// <param name="dataSource">The current data source of the SQL query</param>
/// <param name="parentTable">The details of the table that this new table is being linked to</param>
/// <param name="items">The FetchXML items in this entity</param>
/// <param name="query">The current state of the SQL query being built</param>
/// <param name="aliasToLogicalName">A mapping of table aliases to the logical name</param>
/// <param name="nolock">Indicates if the NOLOCK table hint should be applied</param>
/// <returns>The data source including any required joins</returns>
private static TableReference BuildJoins(IAttributeMetadataCache metadata, TableReference dataSource, NamedTableReference parentTable, object[] items, QuerySpecification query, IDictionary <string, string> aliasToLogicalName, bool nolock)
{
if (items == null)
{
return(dataSource);
}
// Find any <link-entity> elements to process
foreach (var link in items.OfType <FetchLinkEntityType>())
{
// Store the alias of this link
if (!String.IsNullOrEmpty(link.alias))
{
aliasToLogicalName[link.alias] = link.name;
}
// Create the new table reference
var table = new NamedTableReference
{
SchemaObject = new SchemaObjectName
{
Identifiers =
{
new Identifier
{
Value = link.name
}
}
},
Alias = String.IsNullOrEmpty(link.alias) ? null : new Identifier {
Value = link.alias
}
};
if (nolock)
{
table.TableHints.Add(new TableHint {
HintKind = TableHintKind.NoLock
});
}
// Add the join from the current data source to the new table
var join = new QualifiedJoin
{
FirstTableReference = dataSource,
SecondTableReference = table,
QualifiedJoinType = link.linktype == "outer" ? QualifiedJoinType.LeftOuter : QualifiedJoinType.Inner,
SearchCondition = new BooleanComparisonExpression
{
FirstExpression = new ColumnReferenceExpression
{
MultiPartIdentifier = new MultiPartIdentifier
{
Identifiers =
{
new Identifier {
Value = parentTable.Alias?.Value ?? parentTable.SchemaObject.Identifiers.Last().Value
},
new Identifier {
Value = link.to
}
}
}
},
ComparisonType = BooleanComparisonType.Equals,
SecondExpression = new ColumnReferenceExpression
{
MultiPartIdentifier = new MultiPartIdentifier
{
Identifiers =
{
new Identifier {
Value = link.alias ?? link.name
},
new Identifier {
Value = link.from
}
}
}
}
}
};
// Update the SELECT clause
AddSelectElements(query, link.Items, link.alias ?? link.name);
// Handle any filters within the <link-entity> as additional join criteria
var filter = GetFilter(metadata, link.Items, link.alias ?? link.name, aliasToLogicalName);
if (filter != null)
{
var finalFilter = new BooleanBinaryExpression
{
FirstExpression = join.SearchCondition,
BinaryExpressionType = BooleanBinaryExpressionType.And,
SecondExpression = filter
};
join.SearchCondition = finalFilter;
}
// Recurse into any other links
dataSource = BuildJoins(metadata, join, (NamedTableReference)join.SecondTableReference, link.Items, query, aliasToLogicalName, nolock);
}
return(dataSource);
}
private static string JoinTypeName(QualifiedJoin join)
{
return Enum.GetName(typeof (QualifiedJoinType), join.QualifiedJoinType).ToLower();
}
public override void ExplicitVisit(QualifiedJoin node)
{
}
private void recursifRecuperationProjection(QuerySpecification node)
{
bool starExpression = false;
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);
projectionList.AddRange(GetProjectionsFromTablesReference(namedTableReferenceText));
}
if (fromElement is QualifiedJoin)
{
QualifiedJoin currQualifiedJoin = (QualifiedJoin)fromElement;
if (currQualifiedJoin.FirstTableReference is NamedTableReference && currQualifiedJoin.SecondTableReference is NamedTableReference)
{
String namedTableReferenceText1 = GetNodeTokenText(currQualifiedJoin.FirstTableReference);
projectionList.AddRange(GetProjectionsFromTablesReference(namedTableReferenceText1));
String namedTableReferenceText2 = GetNodeTokenText(currQualifiedJoin.SecondTableReference);
projectionList.AddRange(GetProjectionsFromTablesReference(namedTableReferenceText2));
}
}
if (fromElement is PivotedTableReference)
{
PivotedTableReference currPivotedTable = (PivotedTableReference)fromElement;
if (currPivotedTable.TableReference is NamedTableReference)
{
String namedTableReferenceText = GetNodeTokenText(currPivotedTable.TableReference);
projectionList.AddRange(GetProjectionsFromTablesReference(namedTableReferenceText));
}
}
if (fromElement is QueryDerivedTable)
{
QueryDerivedTable currQueryDerivedTable = (QueryDerivedTable)fromElement;
if (currQueryDerivedTable.QueryExpression is QuerySpecification)
{
QuerySpecification currQuerySpecification = (QuerySpecification)currQueryDerivedTable.QueryExpression;
recursifRecuperationProjection(currQuerySpecification);
}
if (currQueryDerivedTable.QueryExpression is BinaryQueryExpression)
{
//BinaryQueryExpression représente un union entre deux requête donc si on veut les projections dans le cas ou
//Il y à un * il faut prendre les projections de la première requête d'union ou intersection
BinaryQueryExpression currBinaryQueryExpression = (BinaryQueryExpression)currQueryDerivedTable.QueryExpression;
while (currBinaryQueryExpression.FirstQueryExpression is BinaryQueryExpression)
{
currBinaryQueryExpression = (BinaryQueryExpression)currBinaryQueryExpression.FirstQueryExpression;
}
if (currBinaryQueryExpression.FirstQueryExpression is QuerySpecification)
{
QuerySpecification currQuerySpecification = (QuerySpecification)currBinaryQueryExpression.FirstQueryExpression;
recursifRecuperationProjection(currQuerySpecification);
}
}
}
}
}
}
}
}
if (starExpression == false)
{
foreach (SelectElement selectElement in node.SelectElements)
{
projectionList.Add(GetNodeTokenText(selectElement));
}
}
}
}
/// <summary>
/// Traverses the joins and gets a list of tables that have been outer joined.
/// </summary>
/// <param name="outerJoinedTables">The outer joined tables list.</param>
/// <param name="qualifiedJoin">The qualified join.</param>
/// <param name="isParentOuterJoined">if set to <c>true</c> a parent join was outer joined.</param>
private void FillOuterJoins(List<string> outerJoinedTables, QualifiedJoin qualifiedJoin, bool isParentOuterJoined)
{
var tableReferences = new List<TableReference>();
if (qualifiedJoin.QualifiedJoinType == QualifiedJoinType.LeftOuter)
{
if (isParentOuterJoined) tableReferences.Add(qualifiedJoin.FirstTableReference);
tableReferences.Add(qualifiedJoin.SecondTableReference);
}
else if (qualifiedJoin.QualifiedJoinType == QualifiedJoinType.RightOuter)
{
if (isParentOuterJoined) tableReferences.Add(qualifiedJoin.SecondTableReference);
tableReferences.Add(qualifiedJoin.FirstTableReference);
}
else if (qualifiedJoin.QualifiedJoinType == QualifiedJoinType.FullOuter || qualifiedJoin.QualifiedJoinType == QualifiedJoinType.Inner)
{
if (isParentOuterJoined)
{
tableReferences.Add(qualifiedJoin.FirstTableReference);
tableReferences.Add(qualifiedJoin.SecondTableReference);
}
}
foreach (var tableReference in tableReferences)
{
var nestedQualifiedJoin = tableReference as QualifiedJoin;
var namedTableReference = tableReference as NamedTableReference;
if (nestedQualifiedJoin != null)
{
FillOuterJoins(outerJoinedTables, nestedQualifiedJoin, true);
}
else if (namedTableReference != null)
{
var aliasOrName = namedTableReference.Alias != null && !string.IsNullOrEmpty(namedTableReference.Alias.Value)
? namedTableReference.Alias.Value
: namedTableReference.SchemaObject.BaseIdentifier.Value;
outerJoinedTables.Add(aliasOrName);
}
}
}
public override void Visit(QualifiedJoin node) { this.action(node); }
public override void ExplicitVisit(QualifiedJoin node)
{
CommandStatistics.JoinsCount++;
base.ExplicitVisit(node);
}
public override void ExplicitVisit(QualifiedJoin node)
{
CommandStatistics.JoinsCount++;
base.ExplicitVisit(node);
}
