public void AggregateTypeIsRaw()
        {
            const int constantValue = 999;
            var       element       = new ConstantElement(constantValue);

            Assert.That(element.AggregateType, Is.EqualTo(AggregateType.AddRaw));
        }
Exemple #2
0
        public void ValueAfterAddedElement()
        {
            var element = new ConstantElement(4711);

            this.composableAttribute.AddElement(element);
            Assert.That(this.composableAttribute.Value, Is.EqualTo(element.Value));
        }
        public void ValueAsDefined()
        {
            const int constantValue = 999;
            var       element       = new ConstantElement(constantValue);

            Assert.That(element.Value, Is.EqualTo(constantValue));
        }
Exemple #4
0
        public void ValueOfMultipleElements()
        {
            var element1 = new ConstantElement(3000);
            var element2 = new ConstantElement(5000);

            this.composableAttribute.AddElement(element1);
            this.composableAttribute.AddElement(element2);
            Assert.That(this.composableAttribute.Value, Is.EqualTo(element1.Value + element2.Value));
        }
        public void ActualParameterElement_ShouldBeValueObject()
        {
            // Given
            var value = new ConstantElement(10, typeof (Int32));
            var underTest = new ActualParameterElement(value, position: 0);

            // Then
            AssertHelper.AreEqualByValue(underTest, new ActualParameterElement(value, position: 0));
        }
        /// <summary>
        /// Creates a selectorElement ElementTypeSelector
        /// </summary>
        public AttributeElement CreateAttributeSelector(String name, ConstantElement value)
        {
            Assume.NotNull(name, nameof(name));

            return(new AttributeElement {
                Name = name,
                Value = value ?? new ConstantElement(null, typeof(Object))
            });
        }
Exemple #7
0
        public void ActualParameterElement_ShouldBeValueObject()
        {
            // Given
            var value     = new ConstantElement(10, typeof(Int32));
            var underTest = new ActualParameterElement(value, position: 0);

            // Then
            AssertHelper.AreEqualByValue(underTest, new ActualParameterElement(value, position: 0));
        }
        /// <summary>
        /// Creates a selectorElement ElementTypeSelector
        /// </summary>
        public AttributeElement CreateAttributeSelector(String name, ConstantElement value)
        {
            Assume.NotNull(name, nameof(name));

            return new AttributeElement {
                Name = name,
                Value = value ?? new ConstantElement(null, typeof(Object))
            };
        }
        public void ConstantElement_ShouldBeValueObject()
        {
            // Given
            var underTest = new ConstantElement(10, typeof (Int32));

            // Then
            AssertHelper.AreEqualByValue(underTest, new ConstantElement(10, typeof (Int32)));
            AssertHelper.AreNotEqualByValue(underTest, new ConstantElement(11, typeof (Int32)));
            AssertHelper.AreNotEqualByValue(underTest, new ConstantElement(10, typeof (Double)));
        }
Exemple #10
0
        public void ConstantElement_ShouldBeValueObject()
        {
            // Given
            var underTest = new ConstantElement(10, typeof(Int32));

            // Then
            AssertHelper.AreEqualByValue(underTest, new ConstantElement(10, typeof(Int32)));
            AssertHelper.AreNotEqualByValue(underTest, new ConstantElement(11, typeof(Int32)));
            AssertHelper.AreNotEqualByValue(underTest, new ConstantElement(10, typeof(Double)));
        }
Exemple #11
0
        public void ValueWithMultiplierElement()
        {
            var element1 = new ConstantElement(3000);
            var element2 = new SimpleElement {
                Value = 5, AggregateType = AggregateType.Multiplicate
            };

            this.composableAttribute.AddElement(element1);
            this.composableAttribute.AddElement(element2);
            Assert.That(this.composableAttribute.Value, Is.EqualTo(element1.Value * element2.Value));
        }
Exemple #12
0
        public void ValueCorrectAfterElementRemoved()
        {
            var element1 = new ConstantElement(3000);
            var element2 = new SimpleElement {
                Value = 5, AggregateType = AggregateType.Multiplicate
            };
            var element3 = new SimpleElement {
                Value = 1000, AggregateType = AggregateType.AddFinal
            };

            this.composableAttribute.AddElement(element1);
            this.composableAttribute.AddElement(element2);
            this.composableAttribute.AddElement(element3);
            Assert.That(this.composableAttribute.Value, Is.EqualTo((element1.Value * element2.Value) + element3.Value));
            this.composableAttribute.RemoveElement(element2);
            Assert.That(this.composableAttribute.Value, Is.EqualTo(element1.Value + element3.Value));
        }
Exemple #13
0
        internal static bool TryParseSource(ScriptParser Parser, out SourceDefinition Source)
        {
            Parser.SkipWhiteSpace();

            int        Start = Parser.Position;
            ScriptNode Node  = Parser.ParseNoWhiteSpace();
            ScriptNode Name  = null;
            string     s;

            Parser.SkipWhiteSpace();

            s = Parser.PeekNextToken().ToUpper();
            if (!string.IsNullOrEmpty(s) &&
                IsAlias(s) &&
                s != "INNER" &&
                s != "OUTER" &&
                s != "LEFT" &&
                s != "RIGHT" &&
                s != "FULL" &&
                s != "JOIN" &&
                s != "WHERE" &&
                s != "GROUP" &&
                s != "ORDER" &&
                s != "OFFSET" &&
                s != "ON" &&
                s != "SET" &&
                s != "SELECT" &&
                s != "OBJECT" &&
                s != "OBJECTS")
            {
                if (s == "AS")
                {
                    Parser.NextToken();
                }

                Name = Parser.ParseNoWhiteSpace();
            }
            else if (Node is VariableReference Ref)
            {
                Name = new ConstantElement(new StringValue(Ref.VariableName), Node.Start, Node.Length, Node.Expression);
            }

            Source = new SourceReference(Node, Name, Start, Parser.Position - Start, Parser.Expression);

            return(true);
        }
Exemple #14
0
        /// <summary>
        /// Tries to parse a script node.
        /// </summary>
        /// <param name="Parser">Custom parser.</param>
        /// <param name="Result">Parsed Script Node.</param>
        /// <returns>If successful in parsing a script node.</returns>
        public bool TryParse(ScriptParser Parser, out ScriptNode Result)
        {
            Result = null;

            try
            {
                List <ScriptNode> Columns;
                List <ScriptNode> ColumnNames;
                ScriptNode        Top = null;
                string            s;
                bool Distinct = false;

                s = Parser.PeekNextToken().ToUpper();
                if (string.IsNullOrEmpty(s))
                {
                    return(false);
                }

                while (s == "TOP" || s == "DISTINCT")
                {
                    switch (s)
                    {
                    case "TOP":
                        Parser.NextToken();
                        Top = Parser.ParseNoWhiteSpace();
                        break;

                    case "DISTINCT":
                        Parser.NextToken();
                        Distinct = true;
                        break;
                    }

                    s = Parser.PeekNextToken();
                    if (string.IsNullOrEmpty(s))
                    {
                        return(false);
                    }
                }

                if (s == "*")
                {
                    Parser.NextToken();
                    Columns     = null;
                    ColumnNames = null;
                }
                else
                {
                    Columns     = new List <ScriptNode>();
                    ColumnNames = new List <ScriptNode>();

                    while (true)
                    {
                        ScriptNode Node = Parser.ParseNoWhiteSpace();
                        ScriptNode Name = null;

                        Parser.SkipWhiteSpace();

                        s = Parser.PeekNextToken().ToUpper();
                        if (!string.IsNullOrEmpty(s) && s != "," && s != "FROM")
                        {
                            if (s == "AS")
                            {
                                Parser.NextToken();
                            }

                            Name = Parser.ParseNoWhiteSpace();
                            s    = Parser.PeekNextToken();
                        }
                        else if (Node is VariableReference Ref)
                        {
                            Name = new ConstantElement(new StringValue(Ref.VariableName), Node.Start, Node.Length, Node.Expression);
                        }
                        else if (Node is NamedMember NamedMember)
                        {
                            Name = new ConstantElement(new StringValue(NamedMember.Name), Node.Start, Node.Length, Node.Expression);
                        }

                        Columns.Add(Node);
                        ColumnNames.Add(Name);

                        if (s != ",")
                        {
                            break;
                        }

                        Parser.NextToken();
                    }
                }

                s = Parser.NextToken().ToUpper();
                if (s != "FROM")
                {
                    return(false);
                }

                if (!TryParseSources(Parser, out SourceDefinition Source))
                {
                    return(false);
                }

                ScriptNode Where = null;

                s = Parser.PeekNextToken().ToUpper();
                if (s == "WHERE")
                {
                    Parser.NextToken();
                    Where = Parser.ParseOrs();
                    s     = Parser.PeekNextToken().ToUpper();
                }

                List <ScriptNode> GroupBy      = null;
                List <ScriptNode> GroupByNames = null;
                ScriptNode        Having       = null;

                if (s == "GROUP")
                {
                    Parser.NextToken();
                    if (Parser.NextToken().ToUpper() != "BY")
                    {
                        return(false);
                    }

                    GroupBy      = new List <ScriptNode>();
                    GroupByNames = new List <ScriptNode>();

                    while (true)
                    {
                        ScriptNode Node = Parser.ParseNoWhiteSpace();
                        ScriptNode Name = null;

                        Parser.SkipWhiteSpace();

                        s = Parser.PeekNextToken().ToUpper();
                        if (!string.IsNullOrEmpty(s) && s != "," && s != "HAVING" && s != "ORDER" && s != "OFFSET")
                        {
                            if (s == "AS")
                            {
                                Parser.NextToken();
                            }

                            Name = Parser.ParseNoWhiteSpace();
                            s    = Parser.PeekNextToken().ToUpper();
                        }
                        else if (Node is VariableReference Ref)
                        {
                            Name = new ConstantElement(new StringValue(Ref.VariableName), Node.Start, Node.Length, Node.Expression);
                        }
                        else if (Node is NamedMember NamedMember)
                        {
                            Name = new ConstantElement(new StringValue(NamedMember.Name), Node.Start, Node.Length, Node.Expression);
                        }

                        GroupBy.Add(Node);
                        GroupByNames.Add(Name);

                        if (s != ",")
                        {
                            break;
                        }

                        Parser.NextToken();
                    }

                    if (s == "HAVING")
                    {
                        Parser.NextToken();
                        Having = Parser.ParseOrs();
                        s      = Parser.PeekNextToken().ToUpper();
                    }
                }
                else if (!(Columns is null))
                {
                    bool ImplicitGrouping = false;

                    foreach (ScriptNode Column in Columns)
                    {
                        if (this.ContainsVectorFunction(Column))
                        {
                            ImplicitGrouping = true;
                            break;
                        }
                    }

                    if (ImplicitGrouping)
                    {
                        GroupBy      = new List <ScriptNode>();
                        GroupByNames = new List <ScriptNode>();
                    }
                }

                List <KeyValuePair <ScriptNode, bool> > OrderBy = null;

                if (s == "ORDER")
                {
                    Parser.NextToken();
                    if (Parser.NextToken().ToUpper() != "BY")
                    {
                        return(false);
                    }

                    OrderBy = new List <KeyValuePair <ScriptNode, bool> >();

                    while (true)
                    {
                        ScriptNode Node = Parser.ParseNoWhiteSpace();

                        s = Parser.PeekNextToken().ToUpper();
                        if (s == "ASC")
                        {
                            Parser.NextToken();
                            OrderBy.Add(new KeyValuePair <ScriptNode, bool>(Node, true));
                            s = Parser.PeekNextToken().ToUpper();
                        }
                        else if (s == "DESC")
                        {
                            Parser.NextToken();
                            OrderBy.Add(new KeyValuePair <ScriptNode, bool>(Node, false));
                            s = Parser.PeekNextToken().ToUpper();
                        }
                        else
                        {
                            OrderBy.Add(new KeyValuePair <ScriptNode, bool>(Node, true));
                        }

                        if (s != ",")
                        {
                            break;
                        }

                        Parser.NextToken();
                    }
                }

                ScriptNode Offset = null;

                if (s == "OFFSET")
                {
                    Parser.NextToken();
                    Offset = Parser.ParseNoWhiteSpace();
                }

                Result = new Select(Columns?.ToArray(), ColumnNames?.ToArray(), Source, Where, GroupBy?.ToArray(),
                                    GroupByNames?.ToArray(), Having, OrderBy?.ToArray(), Top, Offset, Distinct,
                                    Parser.Start, Parser.Length, Parser.Expression);

                return(true);
            }
            catch (Exception)
            {
                return(false);
            }
        }
        private Object createModifierSelectorArgument(ConstantElement argument)
        {
            if (argument.Type == typeof (SelectorElementBase))
                return Create(argument.Value as SelectorElementBase);

            return argument.Value;
        }
 /// <summary>
 /// Creates a method call actual parameter node
 /// </summary>
 public ActualParameterElement CreateActualParameter(ConstantElement value, String parameterName)
 {
     return new ActualParameterElement(value, parameterName);
 }
 /// <summary>
 /// Creates a method call actual parameter node
 /// </summary>
 public ActualParameterElement CreateActualParameter(ConstantElement value, Int32 position)
 {
     return new ActualParameterElement(value, position);
 }
 /// <summary>
 /// Creates a method call actual parameter node
 /// </summary>
 public ActualParameterElement CreateActualParameter(ConstantElement value, String parameterName)
 {
     return(new ActualParameterElement(value, parameterName));
 }
 /// <summary>
 /// Creates a method call actual parameter node
 /// </summary>
 public ActualParameterElement CreateActualParameter(ConstantElement value, Int32 position)
 {
     return(new ActualParameterElement(value, position));
 }
Exemple #20
0
        /// <summary>
        /// Tries to parse a script node.
        /// </summary>
        /// <param name="Parser">Custom parser.</param>
        /// <param name="Result">Parsed Script Node.</param>
        /// <returns>If successful in parsing a script node.</returns>
        public bool TryParse(ScriptParser Parser, out ScriptNode Result)
        {
            Result = null;

            try
            {
                List <ScriptNode> Columns;
                List <ScriptNode> ColumnNames;
                ScriptNode        Top;
                string            s;

                s = Parser.PeekNextToken().ToUpper();
                if (s == string.Empty)
                {
                    return(false);
                }

                if (s == "TOP")
                {
                    Parser.NextToken();
                    Top = Parser.ParseNoWhiteSpace();

                    s = Parser.PeekNextToken();
                    if (s == string.Empty)
                    {
                        return(false);
                    }
                }
                else
                {
                    Top = null;
                }

                if (s == "*")
                {
                    Parser.NextToken();
                    Columns     = null;
                    ColumnNames = null;
                }
                else
                {
                    Columns     = new List <ScriptNode>();
                    ColumnNames = new List <ScriptNode>();

                    while (true)
                    {
                        ScriptNode Node = Parser.ParseNoWhiteSpace();
                        ScriptNode Name = null;

                        Parser.SkipWhiteSpace();

                        s = Parser.PeekNextToken().ToUpper();
                        if (!string.IsNullOrEmpty(s) && s != "," && s != "FROM")
                        {
                            Name = Parser.ParseNoWhiteSpace();
                            s    = Parser.PeekNextToken();
                        }
                        else if (Node is VariableReference Ref)
                        {
                            Name = new ConstantElement(new StringValue(Ref.VariableName), Node.Start, Node.Length, Node.Expression);
                        }

                        Columns.Add(Node);
                        ColumnNames.Add(Name);

                        if (s != ",")
                        {
                            break;
                        }

                        Parser.NextToken();
                    }
                }

                s = Parser.NextToken().ToUpper();
                if (s != "FROM")
                {
                    return(false);
                }

                List <ScriptNode> Sources     = new List <ScriptNode>();
                List <ScriptNode> SourceNames = new List <ScriptNode>();

                while (true)
                {
                    ScriptNode Node = Parser.ParseNoWhiteSpace();
                    ScriptNode Name = null;

                    Parser.SkipWhiteSpace();

                    s = Parser.PeekNextToken().ToUpper();
                    if (!string.IsNullOrEmpty(s) && s != "," && s != "WHERE" && s != "GROUP" && s != "ORDER" && s != "OFFSET")
                    {
                        Name = Parser.ParseNoWhiteSpace();
                        s    = Parser.PeekNextToken().ToUpper();
                    }
                    else if (Node is VariableReference Ref)
                    {
                        Name = new ConstantElement(new StringValue(Ref.VariableName), Node.Start, Node.Length, Node.Expression);
                    }

                    Sources.Add(Node);
                    SourceNames.Add(Name);

                    if (s != ",")
                    {
                        break;
                    }

                    Parser.NextToken();
                }

                ScriptNode Where = null;

                if (s == "WHERE")
                {
                    Parser.NextToken();
                    Where = Parser.ParseOrs();
                    s     = Parser.PeekNextToken().ToUpper();
                }

                List <ScriptNode> GroupBy      = null;
                List <ScriptNode> GroupByNames = null;
                ScriptNode        Having       = null;

                if (s == "GROUP")
                {
                    Parser.NextToken();
                    if (Parser.NextToken().ToUpper() != "BY")
                    {
                        return(false);
                    }

                    GroupBy      = new List <ScriptNode>();
                    GroupByNames = new List <ScriptNode>();

                    while (true)
                    {
                        ScriptNode Node = Parser.ParseNoWhiteSpace();
                        ScriptNode Name = null;

                        Parser.SkipWhiteSpace();

                        s = Parser.PeekNextToken().ToUpper();
                        if (!string.IsNullOrEmpty(s) && s != "," && s != "HAVING" && s != "ORDER" && s != "OFFSET")
                        {
                            Name = Parser.ParseNoWhiteSpace();
                            s    = Parser.PeekNextToken().ToUpper();
                        }
                        else if (Node is VariableReference Ref)
                        {
                            Name = new ConstantElement(new StringValue(Ref.VariableName), Node.Start, Node.Length, Node.Expression);
                        }

                        GroupBy.Add(Node);
                        GroupByNames.Add(Name);

                        if (s != ",")
                        {
                            break;
                        }

                        Parser.NextToken();
                    }

                    if (s == "HAVING")
                    {
                        Parser.NextToken();
                        Having = Parser.ParseOrs();
                        s      = Parser.PeekNextToken().ToUpper();
                    }
                }

                List <KeyValuePair <ScriptNode, bool> > OrderBy = null;

                if (s == "ORDER")
                {
                    Parser.NextToken();
                    if (Parser.NextToken().ToUpper() != "BY")
                    {
                        return(false);
                    }

                    OrderBy = new List <KeyValuePair <ScriptNode, bool> >();

                    while (true)
                    {
                        ScriptNode Node = Parser.ParseNoWhiteSpace();

                        s = Parser.PeekNextToken().ToUpper();
                        if (s == "ASC")
                        {
                            Parser.NextToken();
                            OrderBy.Add(new KeyValuePair <ScriptNode, bool>(Node, true));
                            s = Parser.PeekNextToken().ToUpper();
                        }
                        else if (s == "DESC")
                        {
                            Parser.NextToken();
                            OrderBy.Add(new KeyValuePair <ScriptNode, bool>(Node, false));
                            s = Parser.PeekNextToken().ToUpper();
                        }
                        else
                        {
                            OrderBy.Add(new KeyValuePair <ScriptNode, bool>(Node, true));
                        }

                        if (s != ",")
                        {
                            break;
                        }

                        Parser.NextToken();
                    }
                }

                ScriptNode Offset = null;

                if (s == "OFFSET")
                {
                    Parser.NextToken();
                    Offset = Parser.ParseNoWhiteSpace();
                }

                Result = new Select(Columns?.ToArray(), ColumnNames?.ToArray(), Sources.ToArray(), SourceNames.ToArray(),
                                    Where, GroupBy?.ToArray(), GroupByNames?.ToArray(), Having, OrderBy?.ToArray(), Top, Offset,
                                    Parser.Start, Parser.Length, Parser.Expression);

                return(true);
            }
            catch (Exception)
            {
                return(false);
            }
        }