protected internal override Expression VisitScalar(ScalarExpression scalar) { if (!scalar.Select !.IsForXmlPathEmpty) { using (Scope()) return(base.VisitScalar(scalar)); }
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 object VisitSet_variable_statement([NotNull] KoraliumParser.Set_variable_statementContext context) { var variableReference = Visit(context.variable_reference()) as VariableReference; if (variableReference == null) { throw new SqlParserException("Could not parse variable reference"); } ScalarExpression scalarExpression = null; if (context.b64 != null) { scalarExpression = new Base64Literal() { Value = context.b64.Text.Substring(4, context.b64.Text.Length - 5) }; } else { scalarExpression = Visit(context.scalar_expression()) as ScalarExpression; } if (scalarExpression == null) { throw new SqlParserException("Could not parse scalar expression"); } return(new SetVariableStatement() { VariableReference = variableReference, ScalarExpression = scalarExpression }); }
private void VisitFetchExpression(ScalarExpression fetchExpression) { if (fetchExpression is IntegerLiteral integerLiteral) { takeCount = (int)integerLiteral.Value; } else if (fetchExpression is VariableReference variableReference) { if (!_visitorMetadata.Parameters.TryGetParameter(variableReference.Name, out var parameter)) { throw new SqlErrorException($"The parameter {variableReference.Name} was not found"); } if (parameter.TryGetValue <int>(out var parameterValue)) { takeCount = parameterValue; } else { throw new SqlErrorException($"The value in parameter {variableReference.Name} used in fetch can only contain integer values"); } } else { throw new SqlErrorException("Only integers or variables can be used as offset"); } }
protected override ScalarExpression ReplaceExpression(ScalarExpression expression, out string name) { name = null; if (expression == null) { return(null); } if (_mappings.TryGetValue(expression.ToSql(), out var column)) { name = column; return(new ColumnReferenceExpression { MultiPartIdentifier = new MultiPartIdentifier { Identifiers = { new Identifier { Value = column } } } }); } return(expression); }
public override SQ.Entity OnBuildQueryNode(QueryBuilderContext context, bool allowReuse) { // Find a node if (ChildContainer.ChildEntityNodes.Count > 1) { throw new Exception("Cross-join in report calculations are unsupported."); } SQ.Entity reportNode; if (ChildContainer.ChildEntityNodes.Count == 0) { reportNode = new SingleRowNode( ); } else { reportNode = ChildContainer.ChildEntityNodes.Single( ).BuildQueryNode(context, false); } // Attach conditions ScalarExpression condition = Right.BuildQuery(context); if (reportNode.Conditions == null) { reportNode.Conditions = new List <ScalarExpression>(); } reportNode.Conditions.Add(condition); return(reportNode); }
private void checkIsLiteral(ScalarExpression secondExpression, ScalarExpression firstExpression) { if (secondExpression is Literal || firstExpression is Literal) { IsSuspected = true; } }
public StructuredQuery CreateQuery(string script, EntityRef rootType) { StructuredQuery sq = new StructuredQuery(); sq.RootEntity = new ResourceEntity { EntityTypeId = rootType }; BuilderSettings settings = new BuilderSettings(); settings.RootContextType = ExprTypeHelper.EntityOfType(rootType); settings.TestMode = true; IExpression expr = Factory.ExpressionCompiler.Compile(script, settings); string xml = expr.ToXml( ); QueryBuilderSettings qbSettings = new QueryBuilderSettings(); qbSettings.StructuredQuery = sq; qbSettings.ContextEntity = (ResourceEntity)sq.RootEntity; ScalarExpression queryExpr = Factory.ExpressionCompiler.CreateQueryEngineExpression(expr, qbSettings); sq.SelectColumns.Add(new SelectColumn { Expression = queryExpr }); return(sq); }
private void ProcessWhereScalarExpression(ScalarExpression WhereExpression) { string ExpressionType = FragmentTypeParser.GetFragmentType(WhereExpression); String ParameterType; switch (ExpressionType) { case "ConvertCall": var ConvertCall = (ConvertCall)WhereExpression; ParameterType = FragmentTypeParser.GetFragmentType(ConvertCall.Parameter); if (ParameterType == "ColumnReferenceExpression") { _smells.SendFeedBack(6, ConvertCall); } break; case "CastCall": var CastCall = (CastCall)WhereExpression; ParameterType = FragmentTypeParser.GetFragmentType(CastCall.Parameter); if (ParameterType == "ColumnReferenceExpression") { _smells.SendFeedBack(6, CastCall); } break; case "ScalarSubquery": var SubQuery = (ScalarSubquery)WhereExpression; _smells.ProcessQueryExpression(SubQuery.QueryExpression, "RG"); break; } }
protected internal override Expression VisitScalar(ScalarExpression exists) { sb.Append('('); this.Visit(exists.Select); sb.Append(')'); return(exists); }
public override Magnet[] GetMagnets() { if (IsStatic) { return(null); } var x = new ScalarExpression(Name, "a", Name + ".x", true); var y = new ScalarExpression(Name, "a", Name + ".y", true); var name = Name + "'s "; Center = new Magnet(x, y, name + "center"); Left = new Magnet(new ScalarExpression(Name, "a", Name + ".x - " + Name + ".radius1", true), y, name + "left radius"); Right = new Magnet(new ScalarExpression(Name, "a", Name + ".x + " + Name + ".radius1", true), y, name + "right radius"); Bottom = new Magnet(x, new ScalarExpression(Name, "a", Name + ".y + " + Name + ".radius2", true), name + "bottom radius"); Top = new Magnet(x, new ScalarExpression(Name, "a", Name + ".y - " + Name + ".radius2", true), name + "top radius"); return(new[] { Center, Left, Right, Bottom, Top }); }
private void BuildEqualsSameLiteral(BooleanExpression search, ScalarExpression firstParam, Literal literal) { var newExpression = new BooleanParenthesisExpression(); var expression = new BooleanBinaryExpression(); newExpression.Expression = expression; expression.BinaryExpressionType = BooleanBinaryExpressionType.Or; var isnull = new BooleanIsNullExpression(); isnull.Expression = firstParam; expression.FirstExpression = isnull; var second = new BooleanComparisonExpression(); second.FirstExpression = firstParam; second.SecondExpression = literal; expression.SecondExpression = second; var sql = ScriptDom.GenerateTSql(newExpression); _replacementsToMake.Add(new Replacements { Original = _script.Substring(search.StartOffset, search.FragmentLength), OriginalLength = search.FragmentLength, OriginalOffset = search.StartOffset, Replacement = sql, OriginalFragment = _currentFragment }); }
protected override Expression VisitScalar(ScalarExpression scalar) { scalar = (ScalarExpression)base.VisitScalar(scalar); if (_currentGroupBys != null && _currentFrom != null) { if (scalar.Query is SelectExpression innerSelect && SourcesAreEqual(_currentFrom, innerSelect.From)) { var groupedColumns = GroupedColumnGatherer.Gather(innerSelect.Where); if (groupedColumns?.SequenceEqual(_currentGroupBys) ?? false) { var innerAggExpr = (AggregateExpression)innerSelect.Columns[0].Expression; if (innerAggExpr.Argument == null) { return(new AggregateExpression( innerAggExpr.Type, innerAggExpr.AggregateType, null, innerAggExpr.IsDistict )); } else if (innerAggExpr.Argument is ColumnExpression column) { var source = GetSource(_currentFrom, innerSelect.From, column.Alias); return(new AggregateExpression( innerAggExpr.Type, innerAggExpr.AggregateType, new ColumnExpression(column.Type, source.Alias, column.Name), innerAggExpr.IsDistict )); } } } } return(scalar); }
private void ProcessWhereScalarExpression(ScalarExpression WhereExpression) { string ExpressionType = FragmentTypeParser.GetFragmentType(WhereExpression); String ParameterType; switch (ExpressionType) { case "ConvertCall": var ConvertCall = (ConvertCall) WhereExpression; ParameterType = FragmentTypeParser.GetFragmentType(ConvertCall.Parameter); if (ParameterType == "ColumnReferenceExpression") { _smells.SendFeedBack(6, ConvertCall); } break; case "CastCall": var CastCall = (CastCall) WhereExpression; ParameterType = FragmentTypeParser.GetFragmentType(CastCall.Parameter); if (ParameterType == "ColumnReferenceExpression") { _smells.SendFeedBack(6, CastCall); } break; case "ScalarSubquery": var SubQuery = (ScalarSubquery) WhereExpression; _smells.ProcessQueryExpression(SubQuery.QueryExpression, "RG"); break; } }
/// <summary> /// Gets the data type of the value. /// </summary> /// <param name="value">The value.</param> /// <returns></returns> protected static string GetDataType(ScalarExpression value) { if (value is IntegerLiteral exprInt) { return(GetDataType(exprInt)); } else if (value is NumericLiteral exprNum) { return(GetDataType(exprNum)); } else if (value is FunctionCall exprFunc) { if (_functions.ContainsKey(exprFunc.FunctionName.Value)) { return(_functions[exprFunc.FunctionName.Value]); } } else if (value is BinaryExpression exprBin) { return(GetDataType(exprBin.FirstExpression)); } else if (value is StringLiteral exprStr) { return(GetDataType(exprStr)); } return(null); }
private static void RunReport(StringBuilder sb, long contextType, IExpression expr) { // Build structured query ResourceEntity re = new ResourceEntity(); re.EntityTypeId = new EntityRef(contextType); StructuredQuery sq = new StructuredQuery { RootEntity = re }; // Convert script to query QueryBuilderSettings qsettings = new QueryBuilderSettings(); qsettings.StructuredQuery = sq; qsettings.ContextEntity = re; ScalarExpression resExpr = Factory.ExpressionCompiler.CreateQueryEngineExpression(expr, qsettings); sb.AppendLine("OK"); // Render XML sb.AppendLine("\nXML:"); sb.AppendLine(StructuredQueryHelper.ToXml(sq)); // Render SQL sb.AppendLine("\nSQL:"); sq.SelectColumns.Add(new SelectColumn { Expression = resExpr }); sb.AppendLine("declare @tenant as bigint = (select min(Id) from _vTenant) -- test harness"); string sql = EDC.ReadiNow.Metadata.Query.Structured.Builder.QueryBuilder.GetSql(sq); sb.AppendLine(sql); }
private string GetColumnDataType(TSqlObject sqlObj, QuerySpecification query, ScalarExpression expression) { var column = expression as ColumnReferenceExpression; var tables = new List <NamedTableReference>(); var namedTableVisitor = new NamedTableReferenceVisitor(); query.FromClause.AcceptChildren(namedTableVisitor); if (column.MultiPartIdentifier.Identifiers.Count == 2) { tables.AddRange(namedTableVisitor.Statements.Where(x => x.Alias?.Value == column.MultiPartIdentifier.Identifiers[0].Value)); } else { //they did NOT use a two part name, so logic dictates that this column SHOULD only appear once in the list of tables, but we will have to search all of the tables. tables.AddRange(namedTableVisitor.Statements); } var referencedTables = sqlObj.GetReferenced().Where(x => x.ObjectType == Table.TypeClass && tables.Any(t => x.Name.CompareTo(t.SchemaObject.Identifiers))); foreach (var referencedTable in referencedTables) { string fullColumnName = referencedTable.Name.ToString() + ".[" + column.MultiPartIdentifier.Identifiers.Last().Value + "]"; var retColumn = referencedTable.GetReferencedRelationshipInstances(Table.Columns).FirstOrDefault(p => _comparer.Equals(p.ObjectName.ToString(), fullColumnName)); if (retColumn != null) { var dataType = retColumn.Object.GetReferenced(Column.DataType) .FirstOrDefault(); return(dataType.Name.Parts.First()); } } return(null); }
public void ProcessSelectSetVariable(SelectSetVariable SelectElement) { string VarName = SelectElement.Variable.Name; ScalarExpression Expression = SelectElement.Expression; ProcessSelectSetFragment(Expression, VarName); }
public SqlExpression GetMappedExpression(ScalarExpression expression) { SqlExpression result; _mappedExpressions.TryGetValue(expression, out result); return(result); }
public override Magnet[] GetMagnets() { if (IsStatic) { return(null); } var w = new ScalarExpression(Name, "a", Name + ".x + " + Name + ".width", true); var h = new ScalarExpression(Name, "a", Name + ".y + " + Name + ".height", true); var x = new ScalarExpression(Name, "a", Name + ".x", true); var y = new ScalarExpression(Name, "a", Name + ".y", true); var name = Name + "'s "; Start = new Magnet(x, y, name + "start"); End = new Magnet(w, h, name + "end"); Center = new Magnet(new ScalarExpression(Name, "a", Name + ".x + (" + Name + ".width/2)", true), new ScalarExpression(Name, "a", Name + ".y + (" + Name + ".height/2)", true), name + "center"); return(new[] { Start, End, Center }); }
public static Field GetField( this ScalarExpression scalarExpression, ColumnDefinition column, IEnumerable <ColumnDefinition> columns, ILogger logger, SchemaFile file ) { switch (scalarExpression) { case ValueExpression valueExpression: return(valueExpression.GetField(column.ColumnIdentifier.Value, logger, file)); case ParenthesisExpression parenthesisExpression: return(parenthesisExpression.Expression.GetField(column, columns, logger, file)); case ColumnReferenceExpression columnReferenceExpression: return(columnReferenceExpression.GetField(logger, file, columns)); case BinaryExpression binaryExpression: { // TODO : what if you're working with different types, which one should be reported? (..compute the value) var first = binaryExpression.FirstExpression.GetField(column, columns, logger, file); var second = binaryExpression.SecondExpression.GetField(column, columns, logger, file); var result = first.Type != FieldType.NotSpecified ? first : second; return(result.Copy(column.ColumnIdentifier.Value)); } case ConvertCall convertCall: { var name = column.ColumnIdentifier.Value; var isNullable = column.IsNullable(); return(convertCall.DataType.GetField(name, isNullable, logger, file)); } case FunctionCall functionCall: { // TODO : do not return first.. compute the value var first = functionCall .Parameters .Select(x => x.GetField(column, columns, logger, file)) .FirstOrDefault(x => x.Type != FieldType.NotSpecified); if (first != null) { return(first); } break; } } logger.Log(LogLevel.Error, $"Unable to determine column type from scalar expression. Fragment: \"{scalarExpression.GetTokenText()}\""); return(new UnknownField() { Name = column.ColumnIdentifier.Value, }); }
protected AggregateSubqueryExpression UpdateAggregateSubquery(AggregateSubqueryExpression aggregate, ScalarExpression subquery) { if (subquery != aggregate.AggregateAsSubquery) { return new AggregateSubqueryExpression(aggregate.GroupByAlias, aggregate.AggregateInGroupSelect, subquery); } return aggregate; }
private void checkHasNullVariableReference( ScalarExpression firstExpression, ScalarExpression secondExpression, BooleanComparisonType comparisonType) { checkHasNullVariableReference(firstExpression, comparisonType); checkHasNullVariableReference(secondExpression, comparisonType); }
public override SqlNode Clone() { return(new CastExpression() { ScalarExpression = ScalarExpression.Clone() as ScalarExpression, ToType = ToType }); }
public override void ExplicitVisit(DefaultConstraintDefinition node) { _buffer.Append("\talter column "); node.Column.Accept(this); _buffer.Append(" set default "); ScalarExpression expression = node.Expression; while (expression is ParenthesisExpression) { expression = ((ParenthesisExpression)expression).Expression; } string columnName = node.Column.Value; PgTableColumn column = _table.Columns[columnName]; if (expression is IntegerLiteral literal) { string value = literal.Value; if (column.DataType == "bool") { if (value == "0") { value = "(\'f\')"; } else { value = "(\'t\')"; } _buffer.Append(value); return; } } else if (expression is FunctionCall call) { string functionName = call.FunctionName.Value.ToLower(); switch (functionName) { case "getutcdate": _buffer.Append("(current_timestamp at time zone 'UTC')"); return; case "getdate": _buffer.Append("(localtimestamp)"); return; case "suser_sname": _buffer.Append("(session_user)"); return; default: throw new InvalidOperationException($"unsupported function {functionName}"); } } _buffer.Append("("); expression.Accept(this); _buffer.Append(")"); }
public string CreateScalarExpressionXml(string script) { ScalarExpression queryExpr = CreateScalarExpression(script); string xml = Serializer <ScalarExpression> .ToXml(queryExpr); string xml2 = CleanXml(xml); return(xml2); }
public static IdentityOptions IdentityOptions(ScalarExpression increment, ScalarExpression seed, bool forReplication = false) { var fragemnt = new IdentityOptions(); fragemnt.IdentityIncrement = increment; fragemnt.IdentitySeed = seed; fragemnt.IsIdentityNotForReplication = forReplication; return(fragemnt); }
public FigureText(string text, string size, int index = 0) { _text = new ScalarExpression("a", "a", text, index, true); _text.ValueChanged += ExprValueChanged; _size = new ScalarExpression("a", "a", size, index, true); _size.ValueChanged += ExprValueChanged; FormattedText = GetText(); StringExpr = text + ";" + size; }
public override void ExplicitVisit(ScalarExpression node) { if (node == null) { return; } CurrentScalarExpression = node; if (node is Literal literal) { if (ShouldParameterize(literal)) { var variableReference = new VariableReference(); string parameterName = GetParameterName(); variableReference.Name = parameterName; AddToParameterCollection(literal, parameterName, SqlDataTypeOption, SqlDataTypeParameters); CurrentScalarExpression = variableReference; } return; } if (node is UnaryExpression unaryExpression) { ScalarExpression expression = unaryExpression.Expression; if (expression != null) { if (unaryExpression.UnaryExpressionType.Equals(UnaryExpressionType.Negative)) { IsNegative = !IsNegative; } ExplicitVisit(expression); } base.ExplicitVisit(node); //let the base class finish up return; } if (node is ParenthesisExpression parenthesisExpression) { ScalarExpression expression = parenthesisExpression.Expression; if (expression != null) { ScalarExpression tempScalarExpression = CurrentScalarExpression; ExplicitVisit(expression); parenthesisExpression.Expression = GetTransformedExpression(); CurrentScalarExpression = tempScalarExpression; } base.ExplicitVisit(node); // let the base class finish up } }
private void checkIsSuspectedCastCall(ScalarExpression scalarExpression) { var castCall = scalarExpression as CastCall; if (castCall == null || castCall.Parameter == null) return; if (castCall.Parameter is Literal) { IsSuspected = true; } }
private void checkHasUnparametrizedWhereClauses(ScalarExpression secondExpression, ScalarExpression firstExpression) { checkIsLiteral(secondExpression, firstExpression); checkIsSuspectedFunctionCall(firstExpression); checkIsSuspectedFunctionCall(secondExpression); checkIsSuspectedCastCall(firstExpression); checkIsSuspectedCastCall(secondExpression); }
private void checkIsSuspectedFunctionCall(ScalarExpression scalarExpression) { var function = scalarExpression as FunctionCall; if (function == null || function.Parameters == null) return; if (function.Parameters.OfType<Literal>().Any()) { IsSuspected = true; } }
protected internal virtual Expression VisitScalar(ScalarExpression scalar) { var select = (SelectExpression)this.Visit(scalar.Select) !; if (select != scalar.Select) { return(new ScalarExpression(scalar.Type, select)); } return(scalar); }
protected virtual Expression VisitScalar(ScalarExpression scalar) { SelectExpression select = (SelectExpression)Visit(scalar.Query); if (select != scalar.Query) { return(new ScalarExpression(scalar.Type, select)); } return(scalar); }
private void checkHasNullLiteral( ScalarExpression firstExpression, ScalarExpression secondExpression, BooleanComparisonType comparisonType) { if (firstExpression is NullLiteral || secondExpression is NullLiteral) { checkComparisonType(comparisonType); } }
protected override Expression VisitScalar(ScalarExpression scalar) { var select = scalar.Select; var colType = SqlType.Get(scalar.Type); if (string.IsNullOrEmpty(select.Columns[0].Name)) { var name = select.Columns.GetAvailableColumnName("scalar"); select = select.SetColumns(new[] { new ColumnDeclaration(name, select.Columns[0].Expression, colType) }); } this.currentFrom = new JoinExpression(JoinType.OuterApply, this.currentFrom, select, null); return new ColumnExpression(scalar.Type, colType, scalar.Select.Alias, select.Columns[0].Name); }
protected override Expression VisitScalar(ScalarExpression scalar) { if (connector.SupportsScalarSubquery && (!inAggregate || connector.SupportsScalarSubqueryInAggregates)) { return base.VisitScalar(scalar); } else { var select = scalar.Select; if (string.IsNullOrEmpty(select.Columns[0].Name)) { select = new SelectExpression(select.Alias, select.IsDistinct, select.Top, new[] { new ColumnDeclaration("scalar", select.Columns[0].Expression) }, select.From, select.Where, select.OrderBy, select.GroupBy, select.SelectOptions); } this.currentFrom = new JoinExpression(JoinType.OuterApply, this.currentFrom, select, null); return new ColumnExpression(scalar.Type, scalar.Select.Alias, select.Columns[0].Name); } }
protected virtual bool CompareScalar(ScalarExpression a, ScalarExpression b) { return this.Compare(a.Select, b.Select); }
protected override Expression VisitScalar(ScalarExpression scalar) { if (!scalar.Select.IsForXmlPathEmpty) { using (Scope()) return base.VisitScalar(scalar); } else { using (Scope()) { var oldOuterMostSelect = outerMostSelect; outerMostSelect = scalar.Select; var result = base.VisitScalar(scalar); outerMostSelect = oldOuterMostSelect; return result; } } }
private Expression BindAggregate(Expression source, string aggName, Type returnType, LambdaExpression argument, bool isRoot) { bool hasPredicateArg = this.language.AggregateArgumentIsPredicate(aggName); bool isDistinct = false; bool argumentWasPredicate = false; bool useAlternateArg = false; // check for distinct MethodCallExpression mcs = source as MethodCallExpression; if (mcs != null && !hasPredicateArg && argument == null) { if (mcs.Method.Name == "Distinct" && mcs.Arguments.Count == 1 && (mcs.Method.DeclaringType == typeof(Queryable) || mcs.Method.DeclaringType == typeof(Enumerable)) && this.language.AllowDistinctInAggregates) { source = mcs.Arguments[0]; isDistinct = true; } } if (argument != null && hasPredicateArg) { // convert query.Count(predicate) into query.Where(predicate).Count() source = Expression.Call(typeof(Queryable), "Where", new[] { TypeHelper.GetElementType(source.Type) }, source, argument); argument = null; argumentWasPredicate = true; } ProjectionExpression projection = this.VisitSequence(source); Expression argExpr = null; if (argument != null) { this.map[argument.Parameters[0]] = projection.Projector; argExpr = this.Visit(argument.Body); } else if (!hasPredicateArg || useAlternateArg) { argExpr = projection.Projector; } var alias = this.GetNextAlias(); var pc = this.ProjectColumns(projection.Projector, alias, projection.Select.Alias); Expression aggExpr = new AggregateExpression(returnType, aggName, argExpr, isDistinct); var colType = this.language.TypeSystem.GetColumnType(returnType); SelectExpression select = new SelectExpression(alias, new ColumnDeclaration[] { new ColumnDeclaration("", aggExpr, colType) }, projection.Select, null); if (isRoot) { ParameterExpression p = Expression.Parameter(typeof(IEnumerable<>).MakeGenericType(aggExpr.Type), "p"); LambdaExpression gator = Expression.Lambda(Expression.Call(typeof(Enumerable), "Single", new Type[] { returnType }, p), p); return new ProjectionExpression(select, new ColumnExpression(returnType, this.language.TypeSystem.GetColumnType(returnType), alias, ""), gator); } ScalarExpression subquery = new ScalarExpression(returnType, select); // if we can find the corresponding group-info we can build a special AggregateSubquery node that will enable us to // optimize the aggregate expression later using AggregateRewriter GroupByInfo info; if (!argumentWasPredicate && this.groupByMap.TryGetValue(projection, out info)) { // use the element expression from the group-by info to rebind the argument so the resulting expression is one that // would be legal to add to the columns in the select expression that has the corresponding group-by clause. if (argument != null) { this.map[argument.Parameters[0]] = info.Element; argExpr = this.Visit(argument.Body); } else if (!hasPredicateArg || useAlternateArg) { argExpr = info.Element; } aggExpr = new AggregateExpression(returnType, aggName, argExpr, isDistinct); // check for easy to optimize case. If the projection that our aggregate is based on is really the 'group' argument from // the query.GroupBy(xxx, (key, group) => yyy) method then whatever expression we return here will automatically // become part of the select expression that has the group-by clause, so just return the simple aggregate expression. if (projection == this.currentGroupElement) return aggExpr; return new AggregateSubqueryExpression(info.Alias, aggExpr, subquery); } return subquery; }
protected override Expression VisitScalar(ScalarExpression subquery) { sb.Append("("); this.AppendNewLine(Indentation.Inner); this.Visit(subquery.Select); this.AppendNewLine(Indentation.Same); sb.Append(")"); this.Indent(Indentation.Outer); return subquery; }
private void checkHasNullVariableReference(ScalarExpression expression, BooleanComparisonType comparisonType) { var reference = expression as VariableReference; if (reference == null) return; var parameterName = reference.Name; if (!_declaredNullVariables.Contains(parameterName) && !NullVariableNames.Contains(parameterName)) return; checkComparisonType(comparisonType); }
protected internal override Expression VisitScalar(ScalarExpression scalar) { AddSingleColumn(scalar); return base.VisitScalar(scalar); }
public override void ExplicitVisit(ScalarExpression node) { this.action(node); }
protected virtual Expression VisitScalar(ScalarExpression scalar) { SelectExpression select = (SelectExpression)this.Visit(scalar.Select); if (select != scalar.Select) { return new ScalarExpression(scalar.Type, select); } return scalar; }
public MergeStatamentParsingException(string name, int ordinal, ScalarExpression columnValue, int rowIndex) : base(string.Format("Could not parse column ordinal: {1} in table: {0}, row number: {3} extra info: base type: {2}", name, ordinal, columnValue.GetType(), rowIndex)) { }
protected virtual Expression VisitScalar(ScalarExpression scalar) { var select = (SelectExpression)this.Visit(scalar.Select); return this.UpdateScalar(scalar, select); }
protected ScalarExpression UpdateScalar(ScalarExpression scalar, SelectExpression select) { if (select != scalar.Select) { return new ScalarExpression(scalar.Type, select); } return scalar; }
private WScalarExpression ParseScalarExpression(ScalarExpression scalarExpr) { if (scalarExpr == null) { return null; } switch (scalarExpr.GetType().Name) { case "BinaryExpression": { var bexpr = scalarExpr as BinaryExpression; var wexpr = new WBinaryExpression { ExpressionType = bexpr.BinaryExpressionType, FirstExpr = ParseScalarExpression(bexpr.FirstExpression), SecondExpr = ParseScalarExpression(bexpr.SecondExpression), FirstTokenIndex = bexpr.FirstTokenIndex, LastTokenIndex = bexpr.LastTokenIndex, }; return wexpr; } case "UnaryExpression": { var uexpr = scalarExpr as UnaryExpression; var wuexpr = new WUnaryExpression { Expression = ParseScalarExpression(uexpr.Expression), ExpressionType = uexpr.UnaryExpressionType, FirstTokenIndex = uexpr.FirstTokenIndex, LastTokenIndex = uexpr.LastTokenIndex }; return wuexpr; } case "ColumnReferenceExpression": { var cre = scalarExpr as ColumnReferenceExpression; var wexpr = new WColumnReferenceExpression { MultiPartIdentifier = ParseMultiPartIdentifier(cre.MultiPartIdentifier), ColumnType = cre.ColumnType, FirstTokenIndex = cre.FirstTokenIndex, LastTokenIndex = cre.LastTokenIndex }; return wexpr; } case "ScalarSubquery": { var oquery = scalarExpr as ScalarSubquery; var wexpr = new WScalarSubquery { SubQueryExpr = ParseSelectQueryStatement(oquery.QueryExpression), FirstTokenIndex = oquery.FirstTokenIndex, LastTokenIndex = oquery.LastTokenIndex }; return wexpr; } case "ParenthesisExpression": { var parenExpr = scalarExpr as ParenthesisExpression; var wexpr = new WParenthesisExpression { Expression = ParseScalarExpression(parenExpr.Expression), FirstTokenIndex = parenExpr.FirstTokenIndex, LastTokenIndex = parenExpr.LastTokenIndex, }; return wexpr; } case "FunctionCall": { var fc = scalarExpr as FunctionCall; var wexpr = new WFunctionCall { CallTarget = ParseCallTarget(fc.CallTarget), FunctionName = fc.FunctionName, UniqueRowFilter = fc.UniqueRowFilter, FirstTokenIndex = fc.FirstTokenIndex, LastTokenIndex = fc.LastTokenIndex, }; if (fc.Parameters == null) return wexpr; wexpr.Parameters = new List<WScalarExpression>(fc.Parameters.Count); foreach (var pe in fc.Parameters.Select(ParseScalarExpression).Where(pe => pe != null)) { wexpr.Parameters.Add(pe); } return wexpr; } case "SearchedCaseExpression": { var caseExpr = scalarExpr as SearchedCaseExpression; var wexpr = new WSearchedCaseExpression { FirstTokenIndex = caseExpr.FirstTokenIndex, LastTokenIndex = caseExpr.LastTokenIndex, WhenClauses = new List<WSearchedWhenClause>(caseExpr.WhenClauses.Count) }; foreach (var pwhen in caseExpr.WhenClauses.Select(swhen => new WSearchedWhenClause { WhenExpression = ParseBooleanExpression(swhen.WhenExpression), ThenExpression = ParseScalarExpression(swhen.ThenExpression), FirstTokenIndex = swhen.FirstTokenIndex, LastTokenIndex = swhen.LastTokenIndex, })) { wexpr.WhenClauses.Add(pwhen); } wexpr.ElseExpr = ParseScalarExpression(caseExpr.ElseExpression); return wexpr; } case "CastCall": { var castExpr = scalarExpr as CastCall; var wexpr = new WCastCall { DataType = ParseDataType(castExpr.DataType), Parameter = ParseScalarExpression(castExpr.Parameter), FirstTokenIndex = castExpr.FirstTokenIndex, LastTokenIndex = castExpr.LastTokenIndex, }; return wexpr; } default: { if (!(scalarExpr is ValueExpression)) return null; var wexpr = new WValueExpression { FirstTokenIndex = scalarExpr.FirstTokenIndex, LastTokenIndex = scalarExpr.LastTokenIndex, }; var expr = scalarExpr as Literal; if (expr != null) { wexpr.Value = expr.Value; if (expr.LiteralType == LiteralType.String) { wexpr.SingleQuoted = true; } } else { var reference = scalarExpr as VariableReference; wexpr.Value = reference != null ? reference.Name : ((GlobalVariableExpression)scalarExpr).Name; } return wexpr; } } }
public override void ExplicitVisit(ScalarExpression fragment) { _fragments.Add(fragment); }
// don't count aggregates in subqueries protected internal override Expression VisitScalar(ScalarExpression scalar) { return base.VisitScalar(scalar); }
protected override Expression VisitScalar(ScalarExpression subquery) { sb.Append("("); Visit(subquery.Select); sb.Append(")"); return subquery; }
protected override Expression VisitScalar(ScalarExpression scalar) { var column = scalar.Select.Columns.SingleEx(); VisitColumn(new ColumnExpression(scalar.Type, scalar.Select.Alias, column.Name ?? "-")); var select = (SelectExpression)this.Visit(scalar.Select); if (select != scalar.Select) return new ScalarExpression(scalar.Type, select); return scalar; }
public void ProcessScalarExpression(ScalarExpression se) { string ExpressionType = GetFragmentType(se); String ParameterType; switch (ExpressionType) { case "ConvertCall": var ConvertCall = (ConvertCall)se; ParameterType = GetFragmentType(ConvertCall.Parameter); break; case "CastCall": var CastCall = (CastCall)se; ParameterType = GetFragmentType(CastCall.Parameter); break; case "ScalarSubquery": var SubQuery = (ScalarSubquery)se; ProcessQueryExpression(SubQuery.QueryExpression); break; } }
protected override Expression VisitScalar(ScalarExpression subquery) { this.Write("("); this.WriteLine(Indentation.Inner); this.Visit(subquery.Select); this.WriteLine(Indentation.Same); this.Write(")"); this.Indent(Indentation.Outer); return subquery; }
private bool CompareScalar(ScalarExpression a, ScalarExpression b) { return this.Compare(a.Select, b.Select); }