private (string fieldName, object value) CheckComparisonArguments(ScalarExpression left, ScalarExpression right) { ColumnReference columnReference = null; object value = null; if (left is ColumnReference leftColumn) { columnReference = leftColumn; } if (right is ColumnReference rightColumn) { if (columnReference != null) { //TODO: Fix exception throw new System.Exception("Elasticsearch filter can not compare two columns"); } columnReference = rightColumn; } if (left is Literal leftLiteral) { value = leftLiteral.GetValue(); } if (right is Literal rightLiteral) { value = rightLiteral.GetValue(); } if (columnReference == null || value == null) { throw new System.Exception("Comparisions for elasticsearch filter must contain only a column and a value"); } return(string.Join(".", columnReference.Identifiers), value); }
public override void VisitColumnReference(ColumnReference columnReference) { var identifiers = columnReference.Identifiers; if (_lambdaParameters != null && _lambdaParameters.Count > 0 && _lambdaParameters.Peek().TryGetValue(identifiers.FirstOrDefault(), out var parameterExpression)) { if (identifiers.Count > 1) { AddExpressionToStack(MemberUtils.GetSubfieldMember(identifiers, 1, parameterExpression, _visitorMetadata.OperationsProvider)); } else { AddExpressionToStack(parameterExpression); } return; } identifiers = MemberUtils.RemoveAlias(_previousStage, identifiers); var memberAccess = MemberUtils.GetMember(_previousStage, identifiers, _visitorMetadata.OperationsProvider, out var property); AddUsedProperty(property); AddExpressionToStack(memberAccess); AddNameToStack(string.Join(".", identifiers)); }
/// <summary> /// Creates a sheet reference from a rectangle and a sheet /// </summary> /// <param name="rect">The rectangle to create the sheet reference from</param> /// <param name="sheet">The sheet that the reference will be on</param> /// <returns>A sheet reference that matches the given rectangle and is on the given sheet</returns> /// <remarks> /// Use this method when you have a rectangle that you would like translated into a sheet reference. Note that the /// top-left corner of the sheet is (1,1). The method will try to create the appropriate type of reference based on /// the /// dimensions of the rectangle. For example: A rectangle 1 unit wide and 1 unit tall will be translated into a cell /// reference /// </remarks> /// <exception cref="T:System.ArgumentException"> /// <para>The resulting sheet reference is not within the bounds of its sheet</para> /// <para>The given sheet argument is not registered with the SheetManager</para> /// </exception> /// <example> /// The following code creates a reference to the range A1:B2 on the currently active sheet /// <code> /// Dim engine As New FormulaEngine /// Dim rect As New Rectangle(1, 1, 2, 2) /// Dim ref As ISheetReference = factory.FromRectangle(rect) /// </code> /// </example> public ISheetReference FromRectangle(ISheet sheet, Rectangle rect) { FormulaEngine.ValidateNonNull(sheet, "sheet"); SheetReference @ref; Rectangle sheetRect = SheetReference.GetSheetRectangle(sheet); if (rect.Width == 1 & rect.Height == 1) { @ref = new CellReference(rect.Top, rect.Left); } else if (rect.Height == sheetRect.Height) { @ref = new ColumnReference(rect.Left, rect.Right - 1); } else if (rect.Width == sheetRect.Width) { @ref = new RowReference(rect.Top, rect.Bottom - 1); } else { @ref = new CellRangeReference(rect); } InitializeGridReference(@ref, sheet); return(@ref); }
public void TestBasicColumnReference() { var ctx = new Machine().Initialize(); var table = new TableMeta() { Name = "table" }; Context.AddColumn(new ColumnMeta() { Name = "a", Type = ColumnType.Number }, table); ctx.AddTable(table); var input = "table.a"; var parser = new Parser(); var reference = parser.ParseReference(input, 0, ctx, new SelectStatement(), new Parser.ReferenceFlags() { ResolveReferences = true }); var expected = new ColumnReference() { Column = "a", Table = "table", InputLength = input.Length }; Assert.AreEqual(reference, expected); }
public ColumnReferenceInfo(String alias, ColumnReference reference) { ArgumentValidator.ValidateNotNull(nameof(reference), reference); this._alias = alias; this._reference = reference; }
/// <summary> /// Creates a reference to a range of columns on a given sheet /// </summary> /// <param name="sheet">The sheet the reference will use</param> /// <param name="start">The left column of the range</param> /// <param name="finish">The right column of the range</param> /// <returns>A sheet reference to the range of columns on the given sheet</returns> /// <remarks> /// This method will create a sheet reference to an entire range of columns on the given sheet. Use it when you /// want to reference entire columns and have the two indices handy. /// </remarks> /// <exception cref="T:System.ArgumentException"> /// <para>The resultant range is not within the bounds of the given sheet</para> /// <para>The given sheet argument is not registered with the SheetManager</para> /// </exception> /// <example> /// The following example creates a reference to columns A through C on the currently active sheet /// <code> /// Dim engine As New FormulaEngine /// Dim ref As ISheetReference = engine.ReferenceFactory.Columns(1, 3) /// </code> /// </example> public ISheetReference Columns(ISheet sheet, int start, int finish) { FormulaEngine.ValidateNonNull(sheet, "sheet"); var @ref = new ColumnReference(start, finish); InitializeGridReference(@ref, sheet); return(@ref); }
public void TestColumnReferenceAccept() { Mock <KoraliumSqlVisitor> mock = new Mock <KoraliumSqlVisitor>(); ColumnReference columnReference = new ColumnReference(); columnReference.Accept(mock.Object); mock.Verify(x => x.VisitColumnReference(columnReference)); }
public void TestVisitColumnReference() { ColumnReference columnReference = new ColumnReference(); KoraliumSqlVisitor koraliumSqlVisitor = new KoraliumSqlVisitor(); koraliumSqlVisitor.Visit(columnReference); //Nothing to verify yet, only that no exceptions are thrown Assert.Pass(); }
public override void VisitColumnReference(ColumnReference columnReference) { var identifiers = columnReference.Identifiers; identifiers = MemberUtils.RemoveAlias(_previousStage, identifiers); var memberAccess = MemberUtils.GetMember(_previousStage, identifiers, _visitorMetadata.OperationsProvider, out var property); _usedProperties.Add(property); _groupByExpressions.Add(new GroupByExpression(memberAccess, string.Join(".", identifiers), property)); }
public ColumnMeta FindColumn(ColumnReference reference) { var tableMeta = FindTable(reference); if (tableMeta != null) { return(tableMeta.Columns.Find(c => c.Name.ToUpper() == reference.Column.ToUpper())); } return(null); }
private VisitResult VisitColumnReferenceExpression_Internal(ColumnReference columnReference) { var identifiers = columnReference.Identifiers; identifiers = MemberUtils.RemoveAlias(_previousStage, identifiers); var memberAccess = MemberUtils.GetMember(_previousStage, identifiers, _visitorMetadata.OperationsProvider, out var property); AddUsedProperty(property); return(new VisitResult() { Expression = memberAccess }); }
/// <summary> /// /// </summary> /// <param name="column"></param> /// <returns></returns> /// <remarks> /// In this function call, tables are always referenced by /// their aliases, if they have one. /// </remarks> public string GetResolvedColumnName(ColumnReference column) { string tablename; if (!String.IsNullOrEmpty(column.TableReference.Alias)) { tablename = QuoteIdentifier(column.TableReference.Alias); } else { tablename = GetResolvedTableName(column.TableReference); } return(GetResolvedColumnName(tablename, column.ColumnName)); }
public void TestCloneColumnReference() { ColumnReference columnReference = new ColumnReference() { Identifiers = new List <string>() { "test" } }; var clone = columnReference.Clone() as ColumnReference; Assert.AreEqual(columnReference, clone); Assert.IsFalse(ReferenceEquals(columnReference, clone)); Assert.IsFalse(ReferenceEquals(columnReference.Identifiers, clone.Identifiers)); }
private Column ResolveColumnReference(Table table, Column column) { ColumnReference columnRef = column as ColumnReference; if (columnRef == null) { return(column); } var result = table.Columns.SingleOrDefault(c => c.Name == columnRef.Name); if (result == null) { throw new TaupoInvalidOperationException("The column '" + columnRef.Name + "' was not found in '" + table + "'"); } return(result); }
public ColumnReference TryFindReferenceRecursive(ColumnReference reference, int level) { if (reference.Table == MainSource.Table || reference.Table == MainSource.Identifier) { reference.Table = MainSource.Table; reference.TableIdentifier = MainSource.Identifier; reference.ParentLevel = level; return(reference); } if (Parent != null) { return(Parent.TryFindReferenceRecursive(reference, level + 1)); } else { return(null); } }
/// <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); } } }
private SheetReference TryParseGridReference(string s) { if (CellReference.IsValidString(s)) { return(CellReference.FromString(s)); } if (CellRangeReference.IsValidString(s)) { return(CellRangeReference.FromString(s)); } if (ColumnReference.IsValidString(s)) { return(ColumnReference.FromString(s)); } if (RowReference.IsValidString(s)) { return(RowReference.FromString(s)); } return(null); }
/// <summary> /// Resolves the references to hook up various node and column identifiers from the entity model context. /// </summary> /// <param name="query">The query.</param> /// <param name="report">The report.</param> /// <param name="context">The context.</param> internal static void ResolveReferences(StructuredQuery query, Report report, FromEntityContext context) { if (query.RootEntity is AggregateEntity) { AggregateEntity ae = query.RootEntity as AggregateEntity; foreach (ResourceDataColumn rdc in ae.GroupBy.OfType <ResourceDataColumn>()) { rdc.NodeId = context.ReportNodeMap[rdc.SourceNodeEntityId]; } } // Resolve the Node Expressions for report columns foreach (ReportColumn reportColumn in report.ReportColumns) { AssignColumnNodeGuidForExpression(query.SelectColumns, reportColumn, context); } // Resolve the Node expressions for the analyser foreach (QueryCondition queryCondition in query.Conditions) { ResolveExpressionToNode(StructuredQueryHelper.WalkExpressions(queryCondition.Expression), context); ColumnReference columnReference = queryCondition.Expression as ColumnReference; //if the expression is ColumnReferenceExpression, the referenced report column must exists if (columnReference != null && context.ColumnReferenceMap.ContainsKey(columnReference.ExpressionId) && context.ReportColumnMap.ContainsKey(context.ColumnReferenceMap[columnReference.ExpressionId])) { columnReference.ColumnId = context.ReportColumnMap[context.ColumnReferenceMap[columnReference.ExpressionId]]; } } // Resolve the order by expressions (NOTE: Am assuming that order by can only contain column references here) foreach (ColumnReference columnReference in query.OrderBy.Select(orderByItem => orderByItem.Expression).OfType <ColumnReference>()) { //the orderby expression is ColumnReferenceExpression, the referenced report column must exists if (context.ColumnReferenceMap.ContainsKey(columnReference.ExpressionId) && context.ReportColumnMap.ContainsKey(context.ColumnReferenceMap[columnReference.ExpressionId])) { columnReference.ColumnId = context.ReportColumnMap[context.ColumnReferenceMap[columnReference.ExpressionId]]; } } }
public override void VisitColumnReference(ColumnReference columnReference) { var identifiers = columnReference.Identifiers; identifiers = MemberUtils.RemoveAlias(_previousStage, identifiers); Expression expression; if (_inAggregateFunction) { expression = MemberUtils.GetMemberGroupByInValue(_previousStage, identifiers, _visitorMetadata.OperationsProvider, out var property); AddUsedProperty(property); } else { expression = MemberUtils.GetMemberGroupByInKey(_previousStage, identifiers, _visitorMetadata.OperationsProvider, out var property); AddUsedProperty(property); } AddExpressionToStack(expression); AddNameToStack(string.Join(".", identifiers)); }
public void TestTableReference() { var ctx = new Machine().Initialize(); ctx.AddTable(new TableMeta() { Name = "table" }); var input = "table"; var parser = new Parser(); var reference = parser.ParseReference(input, 0, ctx, new SelectStatement(), new Parser.ReferenceFlags() { TableOnly = true }); var expected = new ColumnReference() { Table = "table" }; Assert.AreEqual(reference, expected); }
public void TestColumnReferenceEquals() { ColumnReference first = new ColumnReference() { Identifiers = new List <string>() { "test" } }; ColumnReference firstClone = new ColumnReference() { Identifiers = new List <string>() { "test" } }; ColumnReference second = new ColumnReference() { Identifiers = new List <string>() { "test2" } }; //Equals Assert.IsTrue(Equals(first, firstClone)); Assert.IsFalse(Equals(first, null)); Assert.IsFalse(Equals(first, "test")); Assert.IsFalse(Equals(first, second)); //Hash code Assert.AreEqual(first.GetHashCode(), firstClone.GetHashCode()); Assert.AreNotEqual(first.GetHashCode(), second.GetHashCode()); }
public override void VisitColumnReference(ColumnReference columnReference) { //Add the alias to the front columnReference.Identifiers.Insert(0, _tableAlias); }
protected virtual void ColumnRef(ColumnReference colref) { Put("%i", colref.RefColumnName); //WriteRaw(QuoteIdentifier(colref.Name, null)); }
/// <summary> /// Remove any columns from a report that are not required to achieve a rollup result. /// </summary> /// <remarks> /// If columns get removed here then the query optimiser will later remove various joins. /// This can affect whether some rows are repeated. /// Some aggregate types (e.g. max/min) are unaffected by this. /// Some types (e.g. Count) are very affected by this, so we replace columns with simpler ones, rather than removing them completely. /// Some types (e.g. Sum) in principle could be affected by this, but in practice are OK because they will reference the relationship branch that is relevant to them anyway. /// </remarks> /// <param name="query">The original query.</param> /// <param name="clientAggregate">Aggregate settings that are used to determine what columns are used.</param> /// <returns>A clone of the query, with unused columns removed.</returns> public static StructuredQuery RemoveUnusedColumns(StructuredQuery query, ClientAggregate clientAggregate, bool supportQuickSearch = false) { StructuredQuery queryCopy = query.DeepCopy( ); // Determine columns that are used by the rollup HashSet <Guid> referencedColumns = new HashSet <Guid>(clientAggregate.AggregatedColumns.Select(a => a.ReportColumnId) .Concat(clientAggregate.GroupedColumns.Select(g => g.ReportColumnId))); // Also include columns that are referenced by analyzer conditions foreach (QueryCondition condition in query.Conditions) { ColumnReference colRefExpr = condition.Expression as ColumnReference; if (colRefExpr == null) { continue; } referencedColumns.Add(colRefExpr.ColumnId); } // Ensure that the inner report returns at least something. (This will typically be the ID column). if (referencedColumns.Count == 0 && query.SelectColumns.Count > 0) { referencedColumns.Add(query.SelectColumns [0].ColumnId); } // There are two types of optimisations. Either we can just pull out all unused columns, and let the structured query optimiser // remove the subsequent relationship joins - which is OK for things like max & min in particular. // But in some cases (e.g. for Count) we need to ensure we capture all relationships to get the true fanout. // This is safer, but less efficient. bool strictlyMaintainRowPresence = clientAggregate.AggregatedColumns.Any(ag => ag.AggregateMethod == AggregateMethod.Count); if (!strictlyMaintainRowPresence) { // Remove all unused columns queryCopy.SelectColumns.RemoveAll(column => !referencedColumns.Contains(column.ColumnId)); } else { // Visit each column and determine if it can be removed, or converted to a simpler type List <SelectColumn> columns = queryCopy.SelectColumns; List <Guid> toRemove = new List <Guid>( ); for (int i = 0; i < columns.Count; i++) { SelectColumn column = columns [i]; if (referencedColumns.Contains(column.ColumnId)) { continue; } // Replace field lookups with an equivalent ID column .. to maintain the relationship join, but remove the field join. ResourceDataColumn fieldColumnExpr = column.Expression as ResourceDataColumn; if (fieldColumnExpr != null) { // TODO: we could delete this column entire IF the entire relationship path to it is 'to one' relationships, without any advance properties to enforce rows. // UPDATE: for quick serach purpose, the column expression should be ResourceDataColumn but skip in select clause. // however for performance reasons, if without quick search, still change to IdExpression if (supportQuickSearch) { column.IsHidden = true; } else { column.Expression = new IdExpression { NodeId = fieldColumnExpr.NodeId } }; continue; } // Remove aggregate expressions if they don't have group-bys. (A group-by would cause the aggregate to return more than one row). AggregateExpression aggExpr = column.Expression as AggregateExpression; if (aggExpr != null) { AggregateEntity aggNode = StructuredQueryHelper.FindNode(queryCopy.RootEntity, aggExpr.NodeId) as AggregateEntity; if (aggNode != null) { if (aggNode.GroupBy == null || aggNode.GroupBy.Count == 0) { toRemove.Add(column.ColumnId); } } } // Would be nice to remove calculated columns .. but probably too risky } queryCopy.SelectColumns.RemoveAll(column => toRemove.Contains(column.ColumnId)); } // Remove any obsolete order-by instructions queryCopy.OrderBy.RemoveAll(orderBy => { ColumnReference colRefExpr = orderBy.Expression as ColumnReference; if (colRefExpr == null) { return(false); } bool colStillPresent = queryCopy.SelectColumns.Any(column => column.ColumnId == colRefExpr.ColumnId); return(!colStillPresent); }); return(queryCopy); } }
protected AbstractColumnCommand(int num, XElement inner) : base(num) { this.column = XMLParser.ParseColumnReference(inner); }
public virtual void VisitColumnReference(ColumnReference columnReference) { //NOP }
public ColumnReferenceInfo(ColumnReference aRef) : this(null, aRef) { }
/// <summary> /// Gets the drawing information for a particular element in the compartment. /// </summary> /// <param name="listField">The <see cref="ShapeField"/> of this <see cref="ColumnElementListCompartment"/> which /// paints the items in this compartment.</param> /// <param name="row">The index of the array of items whose item drawing information is of interest.</param> /// <param name="itemDrawInfo">A previously initialized <see cref="ItemDrawInfo"/> object whose properties will be modified.</param> public override void GetItemDrawInfo(ListField listField, int row, ItemDrawInfo itemDrawInfo) { base.GetItemDrawInfo(listField, row, itemDrawInfo); Column currentColumn = this.Items[row] as Column; Debug.Assert(currentColumn != null, "An item in the ColumnElementListCompartment is not a column."); if (!currentColumn.IsNullable) { itemDrawInfo.AlternateFont = true; } StringBuilder columnText = new StringBuilder(); bool seenConstraint = false; LinkedElementCollection <UniquenessConstraint> tableUniquenessConstraints = null; Table currentTable = null; foreach (UniquenessConstraint constraint in UniquenessConstraintIncludesColumn.GetUniquenessConstraints(currentColumn)) { if (seenConstraint) { columnText.Append(CommaString); } if (constraint.IsPrimary) { columnText.Append(PrimaryKeyString); } else { if (tableUniquenessConstraints == null) { currentTable = currentColumn.Table; tableUniquenessConstraints = currentTable.UniquenessConstraintCollection; } int constraintNumber = 0; foreach (UniquenessConstraint tableConstraint in tableUniquenessConstraints) { if (!tableConstraint.IsPrimary) { ++constraintNumber; if (tableConstraint == constraint) { break; } } } columnText.AppendFormat(AlternateKeyString, constraintNumber); } seenConstraint = true; } LinkedElementCollection <ReferenceConstraint> tableReferenceConstraints = null; foreach (ColumnReference columnReference in ColumnReference.GetLinksToTargetColumnCollection(currentColumn)) { if (seenConstraint) { columnText.Append(CommaString); } if (tableReferenceConstraints == null) { if (currentTable == null) { currentTable = currentColumn.Table; } tableReferenceConstraints = currentTable.ReferenceConstraintCollection; } columnText.AppendFormat(ForeignKeyString, tableReferenceConstraints.IndexOf(columnReference.ReferenceConstraint) + 1); seenConstraint = true; } if (seenConstraint) { columnText.Append(ColonString); } columnText.Append(currentColumn.Name); if (((RelationalDiagram)this.Diagram).DisplayDataTypes) { columnText.Append(ColonString); columnText.Append(GetDataType(currentColumn.AssociatedValueType)); } itemDrawInfo.Text = columnText.ToString(); }
public override Reference CreateReference() { return(ColumnReference.FromString(_image)); }
/// <summary> /// Gets the type of the column database. /// </summary> /// <param name="sourceQuery">The source query.</param> /// <param name="selectColumn">The select column.</param> /// <returns></returns> private static DatabaseType GetColumnDatabaseType(StructuredQuery sourceQuery, SelectColumn selectColumn) { DatabaseType columnType = DatabaseType.UnknownType; var field = selectColumn.Expression as ResourceDataColumn; if (field != null) { ResourceDataColumn dataField = field; if (dataField.CastType != null && dataField.CastType.GetDisplayName( ) != DatabaseType.UnknownType.GetDisplayName( )) { columnType = dataField.CastType; } else { columnType = GetFieldDataType(dataField.FieldId); } } else if (selectColumn.Expression is StructureViewExpression) { columnType = DatabaseType.StructureLevelsType; } else { var expression = selectColumn.Expression as CalculationExpression; if (expression != null) { //TODO hack now if (expression.DisplayType != null && expression.DisplayType != DatabaseType.UnknownType) { return(expression.DisplayType); } } else { var reference = selectColumn.Expression as ColumnReference; if (reference != null) { ColumnReference columnReference = reference; // Sanity check. Prevent infinite recursion if (columnReference.ColumnId != selectColumn.ColumnId) { SelectColumn referencedColumn = sourceQuery.SelectColumns.FirstOrDefault(c => c.ColumnId == columnReference.ColumnId); columnType = GetColumnDatabaseType(sourceQuery, referencedColumn); } } else { var aggregateExpression = selectColumn.Expression as AggregateExpression; if (aggregateExpression != null) { if (aggregateExpression.Expression is StructureViewExpression) { columnType = DatabaseType.StructureLevelsType; } else { columnType = (aggregateExpression.Expression is ResourceDataColumn) ? ((ResourceDataColumn)(aggregateExpression.Expression)).CastType : DatabaseType.StringType; } } else if (selectColumn.Expression is IdExpression) { columnType = DatabaseType.IdentifierType; } } } } return(columnType); }
// --- private string GetResolvedColumnName(ColumnReference column) { string tablename; if (!String.IsNullOrEmpty(column.TableReference.Alias)) { tablename = QuoteIdentifier(column.TableReference.Alias); } else { tablename = GetResolvedTableName(column.TableReference); } return String.Format("{0}.{1}", tablename, QuoteIdentifier(column.ColumnName)); }