protected Operator parseGeneralComp( TokenStream tokens ) { if (tokens.canConsume("!", "=")) return Operator.NOT_EQUAL_TO; if (tokens.canConsume("=")) return Operator.EQUAL_TO; if (tokens.canConsume("<", "=")) return Operator.LESS_THAN_OR_EQUAL_TO; if (tokens.canConsume(">", "=")) return Operator.GREATER_THAN_OR_EQUAL_TO; if (tokens.canConsume("<")) return Operator.LESS_THAN; if (tokens.canConsume(">")) return Operator.GREATER_THAN; return null; }
protected List<Ordering> parseOrderBy( TokenStream tokens, TypeSystem typeSystem, Source source ) { if (tokens.canConsume("ORDER", "BY")) { List<Ordering> orderings = new ArrayList<Ordering>(); do { orderings.add(parseOrdering(tokens, typeSystem, source)); } while (tokens.canConsume(',')); return orderings; } return null; }
protected Constraint parseWhere( TokenStream tokens, TypeSystem typeSystem, Source source ) { if (tokens.canConsume("WHERE")) { return parseConstraint(tokens, typeSystem, source); } return null; }
protected CommentTest parseCommentTest( TokenStream tokens ) { if (tokens.canConsume("comment", "(", ")")) { return new CommentTest(); } return null; }
protected TextTest parseTextTest( TokenStream tokens ) { if (tokens.canConsume("text", "(", ")")) { return new TextTest(); } return null; }
protected Term parseTerm( TokenStream tokens ) { boolean negated = tokens.canConsume('-'); if (!negated) tokens.canConsume('+'); Term result = new SimpleTerm(removeQuotes(tokens.consume())); return negated ? new NegationTerm(result) : result; }
protected List<Component> parsePredicates( TokenStream tokens ) { List<Component> predicates = new ArrayList<Component>(); while (tokens.canConsume('[')) { predicates.add(collapse(parseExpr(tokens))); tokens.consume(']'); } return predicates; }
protected Component parseOrExpr( TokenStream tokens ) { Component result = parseAndExpr(tokens); while (tokens.canConsume("or")) { result = new Or(result, parseInstanceofExpr(tokens)); } return result; }
protected SchemaElementTest parseSchemaElementTest( TokenStream tokens ) { if (tokens.canConsume("schema-element", "(")) { NameTest elementDeclarationName = parseNameTest(tokens); SchemaElementTest result = new SchemaElementTest(elementDeclarationName); tokens.consume(")"); return result; } return null; }
protected SchemaAttributeTest parseSchemaAttributeTest( TokenStream tokens ) { if (tokens.canConsume("schema-attribute", "(")) { NameTest attributeDeclarationName = parseNameTest(tokens); SchemaAttributeTest result = new SchemaAttributeTest(attributeDeclarationName); tokens.consume(")"); return result; } return null; }
protected SchemaElementTest parseSchemaElementTest( TokenStream tokens ) { if (tokens.canConsume("schema-element", "(")) { NameTest elementDeclarationName = parseNameTest(tokens); SchemaElementTest result = new SchemaElementTest(elementDeclarationName); tokens.consume(")"); return result; } return null; }
protected Component parseAndExpr( TokenStream tokens ) { Component result = parseInstanceofExpr(tokens); while (tokens.canConsume("and")) { result = new And(result, parseInstanceofExpr(tokens)); } return result; }
@Test public void shouldReturnFalseFromCanConsumeWithCaseInsensitiveTokenStreamIfMatchStringIsNotUppercase() { makeCaseInsensitive(); assertThat(tokens.canConsume("Select"), is(false)); assertThat(tokens.canConsume("SELECT"), is(true)); assertThat(tokens.canConsume("aLL"), is(false)); assertThat(tokens.canConsume("all"), is(false)); assertThat(tokens.canConsume("ALL"), is(true)); }
@Test public void shouldReturnTrueFromCanConsumeWithCaseInsensitiveTokenStreamIfMatchStringDoesNotMatchCaseExactly() { makeCaseInsensitive(); assertThat(tokens.canConsume("SELECT"), is(true)); assertThat(tokens.canConsume("ALL"), is(true)); assertThat(tokens.canConsume("COLUMNS"), is(true)); assertThat(tokens.canConsume("FROM"), is(true)); assertThat(tokens.canConsume("THIS"), is(true)); assertThat(tokens.canConsume("TABLE"), is(true)); assertThat(tokens.hasNext(), is(false)); }
protected FunctionCall parseFunctionCall( TokenStream tokens ) { NameTest name = parseQName(tokens); tokens.consume("("); List<Component> args = new ArrayList<Component>(); if (!tokens.matches(')')) { do { args.add(collapse(parseExprSingle(tokens))); } while (tokens.canConsume(",")); } tokens.consume(")"); return new FunctionCall(name, args); }
@Test public void shouldReturnTrueFromCanConsumeMultipleTokensWithAnyValueConstant() { makeCaseInsensitive(); // Unable to consume unless they all match ... assertThat(tokens.canConsume("SELECT", "ALL", TokenStream.ANY_VALUE, "FRM", "THIS", "TABLE"), is(false)); assertThat(tokens.canConsume("SELECT", "ALL", "COLUMNS", "FROM", TokenStream.ANY_VALUE, "TABLE"), is(true)); assertThat(tokens.hasNext(), is(false)); }
protected ParenthesizedExpression parseParenthesizedExpr( TokenStream tokens ) { tokens.consume('('); if (tokens.canConsume(')')) { return new ParenthesizedExpression(); } Component expr = collapse(parseExpr(tokens)); tokens.consume(')'); return new ParenthesizedExpression(expr); }
@Test public void shouldReturnTrueFromMatchesWithCaseSensitiveTokenStreamIfMatchStringDoesMatchCaseExactly() { makeCaseSensitive(); assertThat(tokens.matches("Select"), is(true)); assertThat(tokens.matches("select"), is(false)); assertThat(tokens.canConsume("Select"), is(true)); assertThat(tokens.matches("all"), is(true)); assertThat(tokens.canConsume("all"), is(true)); }
@Test public void shouldReturnTrueFromCanConsumeMultipleTokensIfTheyAllMatch() { makeCaseInsensitive(); assertThat(tokens.canConsume("SELECT", "ALL", "COLUMNS", "FROM", "THIS", "TABLE"), is(true)); assertThat(tokens.hasNext(), is(false)); }
@FixFor( "MODE-869" ) @Test public void shouldParseStaticOperandWithSubqueryWithoutConsumingExtraTokens() { QueryCommand expected = parser.parseQuery(tokens("SELECT * FROM tableA"), typeSystem); TokenStream tokens = tokens("SELECT * FROM tableA)"); StaticOperand operand = parser.parseStaticOperand(tokens, typeSystem); assertThat(operand, is(instanceOf(Subquery.class))); Subquery subquery = (Subquery)operand; assertThat(subquery.query(), is(expected)); assertThat(tokens.canConsume(')'), is(true)); }