Exemple #1
0
 protected internal override Expression VisitScalar(ScalarExpression scalar)
 {
     if (!scalar.Select !.IsForXmlPathEmpty)
     {
         using (Scope())
             return(base.VisitScalar(scalar));
     }
Exemple #2
0
        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);
        }
Exemple #3
0
        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
            });
        }
Exemple #4
0
 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");
     }
 }
Exemple #5
0
        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);
        }
Exemple #6
0
        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);
        }
Exemple #9
0
        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;
     }
 }
Exemple #15
0
        /// <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);
        }
Exemple #16
0
        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);
    }
 private void checkIsLiteral(ScalarExpression secondExpression, ScalarExpression firstExpression)
 {
     if (secondExpression is Literal || firstExpression is Literal)
     {
         IsSuspected = true;
     }
 }
        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);
        }
Exemple #21
0
        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
            });
        }
Exemple #22
0
        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;
 }
Exemple #24
0
 private void checkHasNullVariableReference(
     ScalarExpression firstExpression,
     ScalarExpression secondExpression,
     BooleanComparisonType comparisonType)
 {
     checkHasNullVariableReference(firstExpression, comparisonType);
     checkHasNullVariableReference(secondExpression, comparisonType);
 }
Exemple #25
0
 public override SqlNode Clone()
 {
     return(new CastExpression()
     {
         ScalarExpression = ScalarExpression.Clone() as ScalarExpression,
         ToType = ToType
     });
 }
Exemple #26
0
        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);
        }
Exemple #28
0
        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);
        }
Exemple #29
0
 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;
 }
Exemple #30
0
        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;
            }
        }
        private void checkHasUnparametrizedWhereClauses(ScalarExpression secondExpression, ScalarExpression firstExpression)
        {
            checkIsLiteral(secondExpression, firstExpression);

            checkIsSuspectedFunctionCall(firstExpression);
            checkIsSuspectedFunctionCall(secondExpression);

            checkIsSuspectedCastCall(firstExpression);
            checkIsSuspectedCastCall(secondExpression);
        }
    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);
    }
Exemple #36
0
        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);
     }
 }
Exemple #38
0
 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);
     }
 }
        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 virtual bool CompareScalar(ScalarExpression a, ScalarExpression b)
 {
     return this.Compare(a.Select, b.Select);
 }
Exemple #42
0
        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;
        }
Exemple #44
0
 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);
        }
 private void checkHasNullVariableReference(
     ScalarExpression firstExpression,
     ScalarExpression secondExpression,
     BooleanComparisonType comparisonType)
 {
     checkHasNullVariableReference(firstExpression, comparisonType);
     checkHasNullVariableReference(secondExpression, comparisonType);
 }
        protected internal override Expression VisitScalar(ScalarExpression scalar)
        {
            AddSingleColumn(scalar);

            return base.VisitScalar(scalar);
        }
Exemple #48
0
 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;
 }
Exemple #53
0
        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;
 }
Exemple #57
0
        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;
     }
 }
Exemple #59
0
 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);
		}