Example #1
0
        private SoqlLiteralValueModifiers ParseLiteralValueModifiers()
        {
            SoqlLiteralValueModifiers retVal = new SoqlLiteralValueModifiers();

            string        typeName     = tokenizer.EatKeyword();
            FieldDataType typeOverride = (FieldDataType)FieldDataType.Parse(typeof(FieldDataType), typeName);

            retVal.DataTypeOverride = typeOverride;
            return(retVal);
        }
Example #2
0
        public static SoqlLiteralValueModifiers ParseLiteralValueModifiers(string expr)
        {
            SoqlParser parser           = new SoqlParser(expr);
            SoqlLiteralValueModifiers e = parser.ParseLiteralValueModifiers();

            if (!parser.tokenizer.IsEOF())
            {
                throw new SoqlException("Unexpected token: " + parser.tokenizer.TokenValue, parser.tokenizer.TokenPosition);
            }
            return(e);
        }
 public SoqlParameterLiteralExpression(int parameterPos, SoqlLiteralValueModifiers modifiers)
 {
     this.ParameterPosition = parameterPos;
     this.Modifiers         = modifiers;
 }
Example #4
0
        private SoqlExpression ParseLiteralExpression()
        {
            if (tokenizer.IsToken(SoqlTokenType.LeftParen))
            {
                tokenizer.GetNextToken();
                SoqlExpression e;
                if (tokenizer.IsKeyword("select"))
                {
                    e = ParseQuery();
                }
                else
                {
                    e = ParseExpression();
                }
                tokenizer.Expect(SoqlTokenType.RightParen);
                return(e);
            }
            ;

            if (tokenizer.IsNumber())
            {
                string numberString = (string)tokenizer.TokenValue;
                tokenizer.GetNextToken();
                if (numberString.IndexOf('.') >= 0)
                {
                    return(new SoqlLiteralExpression(Double.Parse(numberString, CultureInfo.InvariantCulture)));
                }
                else
                {
                    return(new SoqlLiteralExpression(Int32.Parse(numberString, CultureInfo.InvariantCulture)));
                }
            }

            if (tokenizer.TokenType == SoqlTokenType.String)
            {
                SoqlExpression e = new SoqlLiteralExpression(tokenizer.StringTokenValue);
                tokenizer.GetNextToken();
                return(e);
            }

            if (tokenizer.TokenType == SoqlTokenType.LeftCurlyBrace)
            {
                tokenizer.GetNextToken();
                int val = Int32.Parse((string)tokenizer.TokenValue);
                tokenizer.GetNextToken();
                if (tokenizer.TokenType == SoqlTokenType.Colon)
                {
                    tokenizer.GetNextToken();
                    SoqlLiteralValueModifiers modifiers = ParseLiteralValueModifiers();
                    tokenizer.Expect(SoqlTokenType.RightCurlyBrace);
                    return(new SoqlParameterLiteralExpression(val, modifiers));
                }
                else
                {
                    tokenizer.Expect(SoqlTokenType.RightCurlyBrace);
                    return(new SoqlParameterLiteralExpression(val));
                }
            }

            if (tokenizer.TokenType == SoqlTokenType.Asterisk)
            {
                tokenizer.GetNextToken();
                return(new SoqlAsteriskExpression(null));
            }

            if (tokenizer.TokenType == SoqlTokenType.Keyword)
            {
                string keyword = tokenizer.EatKeyword();

                if (0 == String.Compare(keyword, "not", true, System.Globalization.CultureInfo.InvariantCulture))
                {
                    return(new SoqlBooleanNegationExpression((SoqlBooleanExpression)ParseBooleanPredicate()));
                }

                if (0 == String.Compare(keyword, "null", true, System.Globalization.CultureInfo.InvariantCulture))
                {
                    return(new SoqlNullLiteral());
                }

                if (0 == String.Compare(keyword, "true", true, System.Globalization.CultureInfo.InvariantCulture))
                {
                    return(new SoqlBooleanLiteralExpression(true));
                }

                if (0 == String.Compare(keyword, "false", true, System.Globalization.CultureInfo.InvariantCulture))
                {
                    return(new SoqlBooleanLiteralExpression(false));
                }

                /*if (tokenizer.IsKeyword("as"))
                 * {
                 *  tokenizer.GetNextToken();
                 *  string alias = tokenizer.EatKeyword();
                 *  string className = keyword;
                 *
                 *  return ParseSimplifiedQuery(className, alias);
                 * }
                 */

                if (tokenizer.IsKeyword("where"))
                {
                    // className WHERE expr

                    return(ParseSimplifiedQuery(keyword, String.Empty));
                }

                return(ParsePathLikeExpression(keyword));
            }

            if (tokenizer.TokenType == SoqlTokenType.Sub)
            {
                tokenizer.GetNextToken();
                return(new SoqlUnaryNegationExpression(ParseLiteralExpression()));
            }

            throw new SoqlException("Unexpected token: " + tokenizer.TokenValue, tokenizer.TokenPosition);
        }