private BoundRelation BindNamedTableReference(NamedTableReferenceSyntax node)
{
var symbols = LookupTable(node.TableName).ToImmutableArray();
if (symbols.Length == 0)
{
Diagnostics.ReportUndeclaredTable(node);
var errorTable = new ErrorTableSymbol(node.TableName.ValueText);
var errorAlias = node.Alias == null
? errorTable.Name
: node.Alias.Identifier.ValueText;
var errorInstance = new TableInstanceSymbol(errorAlias, errorTable, ValueSlotFactory);
return(new BoundTableRelation(errorInstance));
}
if (symbols.Length > 1)
{
Diagnostics.ReportAmbiguousTable(node.TableName, symbols);
}
var table = symbols[0];
var aliasIdentifier = node.Alias != null
? node.Alias.Identifier
: node.TableName;
var alias = aliasIdentifier.ValueText;
var tableInstance = new TableInstanceSymbol(alias, table, ValueSlotFactory);
QueryState.IntroducedTables.Add(tableInstance, aliasIdentifier);
return(new BoundTableRelation(tableInstance));
}
private static string CreateCondition(TableInstanceSymbol left, IReadOnlyList <ColumnSymbol> leftColumns, TableInstanceSymbol right, IReadOnlyList <ColumnSymbol> rightColumns)
{
var sb = new StringBuilder();
for (var i = 0; i < leftColumns.Count; i++)
{
if (sb.Length > 0)
{
sb.Append(@" AND ");
}
var leftColumn = leftColumns[i];
var rightColumn = rightColumns[i];
sb.Append(SyntaxFacts.GetValidIdentifier(right.Name));
sb.Append(@".");
sb.Append(SyntaxFacts.GetValidIdentifier(rightColumn.Name));
sb.Append(@" = ");
sb.Append(SyntaxFacts.GetValidIdentifier(left.Name));
sb.Append(@".");
sb.Append(SyntaxFacts.GetValidIdentifier(leftColumn.Name));
}
return(sb.ToString());
}
private BoundRelation BindDerivedTableReference(DerivedTableReferenceSyntax node)
{
// TODO: Ensure query has no ORDER BY unless TOP is also specified
var query = BindQuery(node.Query);
var namedQueryColumns = query.OutputColumns.Where(c => !string.IsNullOrEmpty(c.Name));
var columns = new List <ColumnSymbol>();
var valueSlotFromColumn = new Dictionary <ColumnSymbol, ValueSlot>();
foreach (var queryColumn in namedQueryColumns)
{
var columnSymbol = new ColumnSymbol(queryColumn.Name, queryColumn.Type);
columns.Add(columnSymbol);
valueSlotFromColumn.Add(columnSymbol, queryColumn.ValueSlot);
}
var derivedTable = new DerivedTableSymbol(columns);
var valueSlotFactory = new Func <TableInstanceSymbol, ColumnSymbol, ValueSlot>((ti, c) => valueSlotFromColumn[c]);
var derivedTableInstance = new TableInstanceSymbol(node.Name.ValueText, derivedTable, valueSlotFactory);
var boundTableReference = new BoundDerivedTableRelation(derivedTableInstance, query.Relation);
QueryState.IntroducedTables.Add(derivedTableInstance, node.Name);
return(boundTableReference);
}
public BoundDerivedTableRelation Update(TableInstanceSymbol tableInstance, BoundRelation relation)
{
if (tableInstance == TableInstance && Relation == relation)
{
return(this);
}
return(new BoundDerivedTableRelation(tableInstance, relation));
}
public BoundTableRelation Update(TableInstanceSymbol tableInstance, ImmutableArray <TableColumnInstanceSymbol> definedValues)
{
if (tableInstance == TableInstance && definedValues == DefinedValues)
{
return(this);
}
return(new BoundTableRelation(tableInstance, definedValues));
}
protected override void VisitTableRelation(BoundTableRelation node)
{
if (node.TableInstance.Table == _symbol)
{
Debug.Assert(_instance == null);
_instance = node.TableInstance;
}
base.VisitTableRelation(node);
}
private static CompletionItem GetCompletionItem(TableRelation tableRelation, TableInstanceSymbol leftInstance, TableInstanceSymbol rightInstance)
{
var leftColumns = leftInstance.Table == tableRelation.ParentTable
? tableRelation.ParentColumns
: tableRelation.ChildColumns;
var rightColumns = leftInstance.Table == tableRelation.ParentTable
? tableRelation.ChildColumns
: tableRelation.ParentColumns;
var condition = CreateCondition(leftInstance, leftColumns, rightInstance, rightColumns);
var displayText = condition;
var insertionText = condition;
var description = condition;
return(new CompletionItem(displayText, insertionText, description, Glyph.Relation));
}
protected override BoundRelation RewriteTableRelation(BoundTableRelation node)
{
if (!node.DefinedValues.Any())
{
return(node);
}
var factory = node.DefinedValues.First().ValueSlot.Factory;
var original = node.TableInstance;
var valueSlotMapping = original.ColumnInstances.ToDictionary(c => c.Column, c => _valueSlotMapping[c.ValueSlot]);
var instanceName = factory.CreateNamed(original.Name, typeof(int)).Name;
var instance = new TableInstanceSymbol(instanceName, original.Table, (t, c) => valueSlotMapping[c]);
var columnMapping = instance.ColumnInstances.ToDictionary(c => c.Column);
var definedValues = node.DefinedValues.Select(d => columnMapping[d.Column]).ToImmutableArray();
return(node.Update(instance, definedValues));
}
public BoundWildcardSelectColumn(TableInstanceSymbol table, IEnumerable <TableColumnInstanceSymbol> columns)
{
Table = table;
_tableColumns = columns.ToImmutableArray();
QueryColumns = _tableColumns.Select(c => new QueryColumnInstanceSymbol(c.Name, c.ValueSlot)).ToImmutableArray();
}
public BoundDerivedTableRelation(TableInstanceSymbol tableInstance, BoundRelation relation)
{
TableInstance = tableInstance;
Relation = relation;
}
public BoundTableRelation(TableInstanceSymbol tableInstance, ImmutableArray <TableColumnInstanceSymbol> definedValues)
{
TableInstance = tableInstance;
DefinedValues = definedValues;
}
public BoundTableRelation(TableInstanceSymbol tableInstance)
: this(tableInstance, tableInstance.ColumnInstances)
{
}
public static void ReportUndeclaredColumn(this ICollection <Diagnostic> diagnostics, PropertyAccessExpressionSyntax node, TableInstanceSymbol tableInstance)
{
var tableName = tableInstance.Name;
var columnName = node.Name.ValueText;
diagnostics.Report(node.Span, DiagnosticId.UndeclaredColumn, tableName, columnName);
}
private BoundExpression BindColumnInstance(PropertyAccessExpressionSyntax node, TableInstanceSymbol tableInstance)
{
var columnName = node.Name;
var columnInstances = tableInstance.ColumnInstances.Where(c => columnName.Matches(c.Name)).ToImmutableArray();
if (columnInstances.Length == 0)
{
Diagnostics.ReportUndeclaredColumn(node, tableInstance);
return(new BoundErrorExpression());
}
if (columnInstances.Length > 1)
{
Diagnostics.ReportAmbiguousColumnInstance(columnName, columnInstances);
}
var columnInstance = columnInstances.First();
return(new BoundColumnExpression(columnInstance));
}
public BoundTableExpression(TableInstanceSymbol symbol)
{
Symbol = symbol;
}
private static IEnumerable <CompletionItem> GetTableCompletions(TableInstanceSymbol tableInstanceSymbol)
{
return(CreateSymbolCompletions(tableInstanceSymbol.ColumnInstances));
}
