public override void ExplicitVisit(ColumnReferenceExpression node)
{
RbacSelectColumn column = new RbacSelectColumn();
if (node.MultiPartIdentifier.Identifiers.Count == 1)
{
column.Name = node.MultiPartIdentifier.Identifiers[0].Value;
column.Table = Table;
}
else if (node.MultiPartIdentifier.Identifiers.Count == 2)
{
column.Table.Alias = node.MultiPartIdentifier.Identifiers[0].Value;
column.Name = node.MultiPartIdentifier.Identifiers[1].Value;
}
else if (node.MultiPartIdentifier.Identifiers.Count == 3)
{
column.Table.Schema = node.MultiPartIdentifier.Identifiers[0].Value;
column.Table.Alias = node.MultiPartIdentifier.Identifiers[1].Value;
column.Name = node.MultiPartIdentifier.Identifiers[2].Value;
}
else
{
throw new NotImplementedException("unknown number of identifiers found in select statement, please report this issue!");
}
column.SetToken(node);
Columns.Add(column);
}
public bool TryParseColumn(ColumnReferenceExpression columnReferenceExpression, IDictionary <string, ITable> tableByAliasIdentifier, out IColumn column)
{
column = null;
var multiPartIdentifier = columnReferenceExpression.MultiPartIdentifier;
var identifiers = multiPartIdentifier.Identifiers;
var columnName = identifiers.Last().Value;
var tableAliasIdentifier = identifiers.Count > (int)ColumnIdentifierScope.Column
? identifiers[identifiers.Count - (int)ColumnIdentifierScope.Table].Value
: columnName;
if (!tableByAliasIdentifier.ContainsKey(tableAliasIdentifier))
{
return(false);
}
var table = tableByAliasIdentifier[tableAliasIdentifier];
var columnMultiPartIdentifier = $"{table.MultiPartIdentifier}.{columnName}";
if (!_metadataIdentifierByMultiPartIdentifier.ContainsKey(columnMultiPartIdentifier))
{
return(false);
}
column = (IColumn)_metadataIdentifierByMultiPartIdentifier[columnMultiPartIdentifier];
return(true);
}
private int IsValidColumnReference(ColumnReferenceExpression columnReference,
List <PartitionedColumn> unspecifiedPartitions)
{
var identifier = columnReference.MultiPartIdentifier.Identifiers;
for (var index = 0; index < unspecifiedPartitions.Count; index++)
{
var unspecifiedPartition = unspecifiedPartitions[index];
var columnName = identifier.Last();
if (string.Equals(unspecifiedPartition.ColumnName, columnName.Value))
{
if (identifier.Count > 1)
{
var tableName = identifier[identifier.Count - 2];
if (!unspecifiedPartition.TableNames.Contains(tableName.Value))
{
continue;
}
}
return(index);
}
}
return(-1);
}
protected override object InternalVisit(ColumnReferenceExpression node)
{
return(new Func <Environment, object>((env) =>
{
return env.CurrentRow[Visit <string[]>(node.MultiPartIdentifier)];
}));
}
private OutputColumnDescriptor ResolveColumnReferenceCore(ColumnReferenceExpression node)
{
if (node.ColumnType != ColumnType.Regular)
{
throw new NotImplementedException(node.AsText());
}
if (node.MultiPartIdentifier.Count == 2)
{
// source (table/view) name without schema or alias
string sourceNameOrAlias = node.MultiPartIdentifier[0].Dequote();
string columnName = node.MultiPartIdentifier[1].Dequote();
return(TryResolveColumnReferenceCoreSN(node, sourceNameOrAlias, columnName));
}
else if (node.MultiPartIdentifier.Count == 1)
{
// no source only column name => traverse all source and find t
string columnName = node.MultiPartIdentifier[0].Dequote();
return(TryResolveColumnReferenceCoreSN(node, null, columnName));
}
else
{
// 3 or 4
throw new NotImplementedException(node.AsText() + " ## " + statement.WhatIsThis());
}
//return null;
}
private void BuildInsertAction(MergeSpecification specification)
{
var action = new InsertMergeAction();
var insertSource = action.Source = new ValuesInsertSource();
var row = new RowValue();
foreach (var column in _columnDescriptors)
{
var colRef = new ColumnReferenceExpression();
colRef.ColumnType = ColumnType.Regular;
colRef.MultiPartIdentifier = new MultiPartIdentifier().Create(column.Name);
action.Columns.Add(colRef);
colRef = new ColumnReferenceExpression();
colRef.ColumnType = ColumnType.Regular;
colRef.MultiPartIdentifier = new MultiPartIdentifier().Create(new Identifier {
Value = MergeIdentifierStrings.SourceName
},
column.Name);
row.ColumnValues.Add(colRef);
}
insertSource.RowValues.Add(row);
specification.ActionClauses.Add(new MergeActionClause
{
Action = action,
Condition = MergeCondition.NotMatchedByTarget
});
}
public void SetToken(ColumnReferenceExpression node)
{
Token = string.Empty;
for (int i = node.FirstTokenIndex; i <= node.LastTokenIndex; i++)
{
Token += node.ScriptTokenStream[i].Text;
}
}
public static string GetQualifiedIdentfier(this ColumnReferenceExpression columnReferenceExpression)
{
return(columnReferenceExpression
.MultiPartIdentifier
.Identifiers
.Select(x => x.Value)
.GetQualifiedIdentfier());
}
public QueryField GetOrCreateQueryField(ColumnReferenceExpression columnReference,
bool isRepresentation, SelectPart selectPart)
{
var queryRoot = queryEntityRegistry.Get(columnReference.Table);
if (!isRepresentation && selectPart == SelectPart.GroupBy)
{
QueryField fieldWithFunction;
var keyWithFunction = columnReference.Name + "." + true;
if (queryRoot.fields.TryGetValue(keyWithFunction, out fieldWithFunction))
{
if (fieldWithFunction.parts.Contains(SelectPart.Select))
{
isRepresentation = true;
}
}
}
var key = columnReference.Name + "." + isRepresentation;
QueryField field;
if (!queryRoot.fields.TryGetValue(key, out field))
{
var propertyNames = columnReference.Name.Split('.');
var subqueryRequired = propertyNames.Length > 1;
var needInvert = false;
if (propertyNames[propertyNames.Length - 1].EqualsIgnoringCase("ЭтоГруппа"))
{
needInvert = true;
subqueryRequired = true;
}
var propertiesEnumerator = new PropertiesEnumerator(propertyNames, queryRoot, this);
var referencedProperties = propertiesEnumerator.Enumerate();
if (isRepresentation)
{
if (ReplaceWithRepresentation(referencedProperties))
{
subqueryRequired = true;
}
}
string fieldAlias = null;
if (subqueryRequired)
{
queryRoot.subqueryRequired = true;
fieldAlias = nameGenerator.GenerateColumnName();
}
foreach (var p in referencedProperties)
{
p.referenced = true;
}
field = new QueryField(fieldAlias, referencedProperties.ToArray(), needInvert);
queryRoot.fields.Add(key, field);
}
if (!field.parts.Contains(selectPart))
{
field.parts.Add(selectPart);
}
return(field);
}
private void VisitReferenceTypeColumn(ColumnReferenceExpression node, TSqlFragment parent, string sourceProperty, IList <Identifier> identifiers, Identifier identifier, Property property, string fieldName)
{
Field field = null;
BinaryLiteral binaryLiteral = null;
if (fieldName == "uuid")
{
if (property.Fields.Count == 1)
{
field = property.Fields[0];
}
else
{
field = property.Fields.Where(f => f.Purpose == FieldPurpose.Object).FirstOrDefault();
}
}
else if (fieldName == "type")
{
if (property.Fields.Count == 1)
{
string HexTypeCode = $"0x{property.PropertyTypes[0].ToString("X").PadLeft(8, '0')}";
binaryLiteral = new BinaryLiteral()
{
Value = HexTypeCode
};
}
else
{
field = property.Fields.Where(f => f.Purpose == FieldPurpose.TypeCode).FirstOrDefault();
}
}
else if (fieldName == "TYPE")
{
if (property.Fields.Count == 1)
{
binaryLiteral = new BinaryLiteral()
{
Value = "0x08"
};
}
else
{
field = property.Fields.Where(f => f.Purpose == FieldPurpose.Discriminator).FirstOrDefault();
}
}
// TODO: throw new MissingMemberException !? if nonexistent field referenced
if (binaryLiteral == null)
{
identifier.Value = field.Name; // change object property identifier to SQL table column identifier
identifiers.RemoveAt(identifiers.Count - 1); // uuid | type | TYPE
}
else
{
TransformToBinaryLiteral(node, parent, sourceProperty, binaryLiteral);
}
}
private bool CheckName(ColumnReferenceExpression col)
{
var names = col.MultiPartIdentifier?.Identifiers;
if (names == null)
{
return(false);
}
return(names.Count == 1 && !Constants.DateParts.Contains(names.First().Value.ToLower()));
}
private void SetPropertyType(ColumnReferenceExpression columnReference, string name)
{
var queryRoot = queryEntityTree.Get(columnReference.Table);
var propertyNames = columnReference.Name.Split('.');
var referencedProperties = queryEntityTree.GetProperties(queryRoot, propertyNames);
foreach (var property in referencedProperties)
{
property.nestedEntities.RemoveAll(entity => !entity.mapping.QueryTableName.EqualsIgnoringCase(name));
}
}
public OutputColumnDescriptor ResolveColumnReference(ColumnReferenceExpression node)
{
IQueryModel model = EnsureModel();
if (TryColumnReference(model, node, out QueryColumnBase col))
{
return(ColumnModelToDescriptor(col));
}
throw new NotImplementedException(node.WhatIsThis());
}
public static string GetName(this ColumnReferenceExpression column)
{
int cnt = column.MultiPartIdentifier.Identifiers.Count;
if (cnt == 1)
{
return($"[{column.MultiPartIdentifier.Identifiers.First().Value}]");
}
var tname = "[" + string.Join("].[", column.MultiPartIdentifier.Identifiers.Take(cnt - 1).Select(i => i.Value)) + "]";
return(tname);
}
public override ISqlElement VisitColumnReference(ColumnReferenceExpression expression)
{
var alias = expression.Table.Alias;
if (!string.IsNullOrEmpty(alias))
{
builder.Append(alias);
builder.Append(".");
}
builder.Append(expression.Name);
return(expression);
}
// TODO : consolidate with below extension?
public static Field GetField(
this ColumnReferenceExpression columnReferenceExpression,
ILogger logger,
SchemaFile file,
IEnumerable <ColumnDefinition> columns
)
{
var columnReferenceName = columnReferenceExpression.MultiPartIdentifier.Identifiers.First().Value;
var column = columns.FirstOrDefault(x => x.ColumnIdentifier.Value.Equals(columnReferenceName));
return(column.DataType.GetField(column.ColumnIdentifier.Value, column.IsNullable(), logger, file));
}
private void SetPropertyType(ColumnReferenceExpression columnReference, string name)
{
var queryRoot = queryEntityRegistry.Get(columnReference.Table);
var propertyNames = columnReference.Name.Split('.');
var propertiesEnumerator = new PropertiesEnumerator(propertyNames, queryRoot, queryEntityAccessor);
var referencedProperties = propertiesEnumerator.Enumerate();
foreach (var property in referencedProperties)
{
property.nestedEntities.RemoveAll(entity => entity.mapping.QueryTableName != name);
}
}
public override ISqlElement VisitIsReference(IsReferenceExpression expression)
{
var queryRoot = queryEntityRegistry.Get(expression.Argument.Table);
var propertyNames = expression.Argument.Name.Split('.');
var propertiesEnumerator = new PropertiesEnumerator(propertyNames, queryRoot, queryEntityAccessor);
var referencedProperties = propertiesEnumerator.Enumerate();
if (referencedProperties.Count != 1)
{
const string messageFormat = "operator IsReference property [{0}] has many " +
"variants which is not supported currently";
throw new InvalidOperationException(string.Format(messageFormat,
expression.Argument.Name));
}
var property = referencedProperties[0];
var entity = property.nestedEntities.SingleOrDefault(x => x.mapping.QueryTableName == expression.ObjectName);
if (entity == null)
{
const string messageFormat = "can't find entity [{0}] for property [{1}]";
throw new InvalidOperationException(string.Format(messageFormat,
expression.ObjectName, expression.Argument.Name));
}
var unionCondition = queryEntityAccessor.GetUnionCondition(property, entity);
if (unionCondition == null)
{
const string messageFormat = "property [{0}] has only one possible type";
throw new InvalidOperationException(string.Format(messageFormat,
expression.Argument.Name));
}
if (queryRoot.additionalFields == null)
{
queryRoot.additionalFields = new List <SelectFieldExpression>();
}
var filterColumnName = nameGenerator.GenerateColumnName();
queryRoot.additionalFields.Add(new SelectFieldExpression
{
Expression = unionCondition,
Alias = filterColumnName
});
var result = new ColumnReferenceExpression
{
Name = filterColumnName,
Table = expression.Argument.Table
};
rewritten.Add(result);
return(result);
}
private static bool CheckName(NamedTableReference tbl, ColumnReferenceExpression col)
{
if (tbl == null)
{
return(false);
}
var colNameParts = col.MultiPartIdentifier.Identifiers;
var colTableName = new ObjectIdentifier(colNameParts.Take(colNameParts.Count - 1).Select(x => x.Value));
var alias = tbl.Alias?.Value;
var tblName = GetTableOrAliasName(tbl.SchemaObject.Identifiers);
return(alias.StringEquals(colTableName.Parts.First()) || colTableName.CompareTo(tblName) >= 5);
}
Expression VisitSelectExpression(SelectExpression selectExpression)
{
base.Visit(selectExpression);
if (!RequiresRowNumberPaging(selectExpression))
{
return(selectExpression);
}
var subQuery = selectExpression.PushDownSubquery();
foreach (var projection in subQuery.Projection)
{
selectExpression.AddToProjection(projection.LiftExpressionFromSubquery(subQuery));
}
if (subQuery.OrderBy.Count == 0)
{
subQuery.AddToOrderBy(
new Ordering(new SqlFunctionExpression("@@RowCount", typeof(int)), OrderingDirection.Asc));
}
var innerRowNumberExpression = new AliasExpression(
RowNumberColumnName + (_counter != 0 ? $"{_counter}" : ""),
new RowNumberExpression_SqlServer(subQuery.OrderBy));
_counter++;
subQuery.ClearOrderBy();
subQuery.AddToProjection(innerRowNumberExpression, false);
var rowNumberReferenceExpression = new ColumnReferenceExpression(innerRowNumberExpression, subQuery);
var offset = subQuery.Offset ?? Expression.Constant(0);
if (subQuery.Offset != null)
{
selectExpression.AddToPredicate
(Expression.GreaterThan(rowNumberReferenceExpression, offset));
subQuery.Offset = null;
}
if (subQuery.Limit != null)
{
var constantValue = (subQuery.Limit as ConstantExpression)?.Value;
var offsetValue = (offset as ConstantExpression)?.Value;
var limitExpression
= constantValue != null &&
offsetValue != null
? (Expression)Expression.Constant((int)offsetValue + (int)constantValue)
: Expression.Add(offset, subQuery.Limit);
selectExpression.AddToPredicate(
Expression.LessThanOrEqual(rowNumberReferenceExpression, limitExpression));
subQuery.Limit = null;
}
return(selectExpression);
}
static ColumnReferenceExpression ColRef(string identifier)
{
var ret = new ColumnReferenceExpression {
MultiPartIdentifier = new MultiPartIdentifier()
};
foreach (var part in identifier.Split('.'))
{
var id = new Identifier {
Value = part
};
ret.MultiPartIdentifier.Identifiers.Add(id);
}
return(ret);
}
public override ISqlElement VisitColumnReference(ColumnReferenceExpression expression)
{
if (rewritten.Contains(expression))
{
return(expression);
}
rewritten.Add(expression);
if (!currentPart.HasValue)
{
throw new InvalidOperationException("assertion failure");
}
var queryField = GetOrCreateQueryField(expression, isPresentation, currentPart.Value);
expression.Name = queryField.alias ?? queryField.properties[0].GetDbColumnName();
return(expression);
}
public override void ExplicitVisit(ColumnReferenceExpression node)
{
base.ExplicitVisit(node);
if (_ignoreAliases &&
node.MultiPartIdentifier?.Identifiers.Count == 1 &&
_selectAliases.Contains(node.MultiPartIdentifier.Identifiers[0].Value))
{
return;
}
if (!Columns.Contains(node))
{
Columns.Add(node);
}
}
public override void ExplicitVisit(ColumnReferenceExpression node)
{
string columnName;
if (node.MultiPartIdentifier.Count == 1)
{
columnName = node.MultiPartIdentifier[0].Value;
}
else
{
throw new NotImplementedException(node.AsText());
}
cs.CodeExpression targetObject = new cs.CodeThisReferenceExpression();
this.lastExpression = new cs.CodeFieldReferenceExpression(targetObject, columnName);
}
private void TransformToBinaryLiteral(ColumnReferenceExpression node, TSqlFragment parent, string sourceProperty, TSqlFragment expression)
{
PropertyInfo property = parent.GetType().GetProperty(sourceProperty);
bool isList = (property.PropertyType.IsGenericType &&
property.PropertyType.GetGenericTypeDefinition() == typeof(IList <>));
if (isList)
{
IList list = (IList)property.GetValue(parent);
int index = list.IndexOf(node);
list[index] = expression;
}
else
{
property.SetValue(parent, expression);
}
}
public override ISqlElement VisitColumnReference(ColumnReferenceExpression expression)
{
var items = expression.Name.Split('.');
var possiblyAlias = items[0];
IColumnSource table;
foreach (var context in contexts)
{
if (context.TablesByName.TryGetValue(possiblyAlias, out table))
{
expression.Name = items.Skip(1).JoinStrings(".");
expression.Table = table;
return(expression);
}
}
expression.Table = contexts.Peek().LastDeclaration;
return(expression);
}
public Column GetColumnFromReference(ColumnReferenceExpression columnReference, string alias, IEnumerable <Table> containers, IEnumerable <Table> parentContainers, IEnumerable <Cte> ctes, bool inPivot = false)
{
if (columnReference?.MultiPartIdentifier?.Identifiers == null)
{
return(null);
}
var identifiers = columnReference.MultiPartIdentifier.Identifiers.ToArray();
var columnName = identifiers.Last().Value;
var isKeyword = _reservedKeywords.Contains(columnName.ToUpperInvariant());
if (isKeyword && identifiers.First().QuoteType == QuoteType.NotQuoted)
{
Dump($"{_pad}***FOUND KEYWORD*** {columnName}");
return(null);
}
return(GetColumnFromIdentifiers(identifiers.Select(i => i.Value).ToArray(), alias, containers, parentContainers, ctes, inPivot));
}
/// <summary>
/// Assigns the column node unique identifier for expression.
/// </summary>
/// <param name="columns">The columns.</param>
/// <param name="reportColumn">The report column.</param>
/// <param name="context">The context.</param>
private static void AssignColumnNodeGuidForExpression(IEnumerable <SelectColumn> columns, ReportColumn reportColumn, FromEntityContext context)
{
// Get the GUID of the report column
Guid reportColumnGuid;
if (context.ReportColumnMap.ContainsKey(reportColumn.Id))
{
reportColumnGuid = context.ReportColumnMap[reportColumn.Id];
}
else
{
return;
}
// Look up the select column using the GUID
SelectColumn selectColumn = columns.FirstOrDefault(c => c.ColumnId == reportColumnGuid);
if (selectColumn == null)
{
return;
}
// Handle column reference expressions
if (selectColumn.Expression != null)
{
ColumnReferenceExpression columnReferenceExpression =
reportColumn.ColumnExpression.As <ColumnReferenceExpression>();
if (columnReferenceExpression != null)
{
long rootNodeId = columnReferenceExpression.ExpressionReferencesColumn.Id;
// Get the GUID for the referenced column rather than root node and populate
ColumnReference columnReference = selectColumn.Expression as ColumnReference;
if (columnReference != null)
{
columnReference.ColumnId = context.ReportColumnMap[rootNodeId];
}
}
else
{
ResolveExpressionToNode(StructuredQueryHelper.WalkExpressions(selectColumn.Expression), context);
}
}
}
public void Select_Query_Is_Converted_Into_Select_Count_Star()
{
var original = new QuerySpecification();
original.FromClause = new FromClause();
original.FromClause.TableReferences.Add(new NamedTableReference()
{
SchemaObject = new SchemaObjectName()
{
BaseIdentifier = { Value = "Bert"}
}
});
var selectCol1 = new ColumnReferenceExpression();
selectCol1.MultiPartIdentifier.Identifiers.Add(new Identifier()
{
Value = "Bertram"
});
//original.SelectElements.Add(new ColumnReferenceExpression());
}
public override void ExplicitVisit(ColumnReferenceExpression node)
{
if (hasSetVariable)
{
outputSet.Clear();
}
else
{
//Console.WriteLine("Resolve type for reference:" + node.AsText());
OutputColumnDescriptor columnDbType = resolveColumnType
? columnTypeResolver.ResolveColumnReference(node)
: null;
if (columnDbType == null)
{
// put breakpoint here and try again
//Console.WriteLine("Type resolve failed for reference:" + node.AsText());
}
outputSet.AddColumn(new ProcedureOutputColumn(node, columnDbType)); // ColumnReferenceExpression : [a].[attributeid]
}
}
private ScalarExpression GetColumnOrCastColumn(ColumnDescriptor column, string tableName)
{
var columnReference = new ColumnReferenceExpression();
columnReference.MultiPartIdentifier = MultiPartIdentifierBuilder.Get(tableName, column.Name.GetName());
if (column.UnderlyingType == "xml")
{
var cast = new CastCall();
var type = new SqlDataTypeReference();
type.SqlDataTypeOption = SqlDataTypeOption.NVarChar;
type.Parameters.Add(new MaxLiteral());
cast.DataType = type;
cast.Parameter = columnReference;
return(cast);
}
return(columnReference);
}
private void BuildInsertAction(MergeSpecification specification)
{
var action = new InsertMergeAction();
var insertSource = action.Source = new ValuesInsertSource();
var row = new RowValue();
foreach (var column in _merge.Table.Columns)
{
var colRef = new ColumnReferenceExpression();
colRef.ColumnType = ColumnType.Regular;
colRef.MultiPartIdentifier = MultiPartIdentifierBuilder.Get(column.Name.GetName());
action.Columns.Add(colRef);
colRef = new ColumnReferenceExpression();
colRef.ColumnType = ColumnType.Regular;
colRef.MultiPartIdentifier = MultiPartIdentifierBuilder.Get(MergeIdentifierStrings.SourceName, column.Name.GetName());
row.ColumnValues.Add(colRef);
}
insertSource.RowValues.Add(row);
specification.ActionClauses.Add(new MergeActionClause
{
Action = action,
Condition = MergeCondition.NotMatchedByTarget
});
}
private ScalarExpression GetColumnOrCastColumn(ColumnDescriptor column, string tableName)
{
var columnReference = new ColumnReferenceExpression();
columnReference.MultiPartIdentifier = MultiPartIdentifierBuilder.Get(tableName, column.Name.GetName());
if (column.UnderlyingType == "xml")
{
var cast = new CastCall();
var type = new SqlDataTypeReference();
type.SqlDataTypeOption = SqlDataTypeOption.NVarChar;
type.Parameters.Add(new MaxLiteral());
cast.DataType = type;
cast.Parameter = columnReference;
return cast;
}
return columnReference;
}
public override void ExplicitVisit(ColumnReferenceExpression fragment)
{
_fragments.Add(fragment);
}
public override void Visit(ColumnReferenceExpression col)
{
sw.WriteLine("Col" + col);
}
public override void Visit(ColumnReferenceExpression node) { this.action(node); }
