From c8fc9d31aa774e40b3473d8ca31004f8fa5023cc Mon Sep 17 00:00:00 2001 From: Jon Bratseth Date: Tue, 21 Dec 2021 13:00:38 +0100 Subject: Use snake case consistently --- .../main/antlr4/com/yahoo/search/yql/yqlplus.g4 | 94 ++++++++-------- .../java/com/yahoo/search/yql/ProgramParser.java | 118 ++++++++++----------- 2 files changed, 106 insertions(+), 106 deletions(-) (limited to 'container-search') diff --git a/container-search/src/main/antlr4/com/yahoo/search/yql/yqlplus.g4 b/container-search/src/main/antlr4/com/yahoo/search/yql/yqlplus.g4 index 6193cabeaa7..8c59ed0799b 100644 --- a/container-search/src/main/antlr4/com/yahoo/search/yql/yqlplus.g4 +++ b/container-search/src/main/antlr4/com/yahoo/search/yql/yqlplus.g4 @@ -302,8 +302,8 @@ field_def : expression[true] alias_def? ; -mapExpression - : LBRACE propertyNameAndValue? (COMMA propertyNameAndValue)* RBRACE +map_expression + : LBRACE property_name_and_value? (COMMA property_name_and_value)* RBRACE ; arguments[boolean in_select] @@ -325,90 +325,90 @@ expression [boolean select] @after { expression_stack.pop(); } - : annotateExpression - | logicalORExpression - | nullOperator + : annotate_expression + | logical_OR_expression + | null_operator ; -nullOperator +null_operator : 'null' ; -annotateExpression - : annotation logicalORExpression +annotate_expression + : annotation logical_OR_expression ; annotation - : LBRACKET mapExpression RBRACKET + : LBRACKET map_expression RBRACKET ; -logicalORExpression - : logicalANDExpression (OR logicalANDExpression)+ - | logicalANDExpression +logical_OR_expression + : logical_AND_expression (OR logical_AND_expression)+ + | logical_AND_expression ; -logicalANDExpression - : equalityExpression (AND equalityExpression)* +logical_AND_expression + : equality_expression (AND equality_expression)* ; -equalityExpression - : relationalExpression ( ((IN | NOT_IN) inNotInTarget) +equality_expression + : relational_expression ( ((IN | NOT_IN) in_not_in_target) | (IS_NULL | IS_NOT_NULL) - | (equalityOp relationalExpression) ) - | relationalExpression + | (equality_op relational_expression) ) + | relational_expression ; -inNotInTarget +in_not_in_target : {expression_stack.peek().in_select}? LPAREN select_statement RPAREN | literal_list ; -equalityOp +equality_op : (EQ | NEQ | LIKE | NOTLIKE | MATCHES | NOTMATCHES | CONTAINS) ; -relationalExpression - : additiveExpression (relationalOp additiveExpression)? +relational_expression + : additive_expression (relational_op additive_expression)? ; -relationalOp +relational_op : (LT | GT | LTEQ | GTEQ) ; -additiveExpression - : multiplicativeExpression (additiveOp additiveExpression)? +additive_expression + : multiplicative_expression (additive_op additive_expression)? ; -additiveOp +additive_op : '+' | '-' ; -multiplicativeExpression - : unaryExpression (multOp multiplicativeExpression)? +multiplicative_expression + : unary_expression (mult_op multiplicative_expression)? ; -multOp +mult_op : '*' | '/' | '%' ; -unaryOp +unary_op : '-' | '!' ; -unaryExpression - : dereferencedExpression - | unaryOp dereferencedExpression +unary_expression + : dereferenced_expression + | unary_op dereferenced_expression ; -dereferencedExpression +dereferenced_expression @init{ boolean in_select = expression_stack.peek().in_select; } - : primaryExpression + : primary_expression ( indexref[in_select] | propertyref @@ -422,17 +422,17 @@ propertyref : DOT nm=IDENTIFIER ; -primaryExpression +primary_expression @init { boolean in_select = expression_stack.peek().in_select; } - : callExpression[in_select] + : call_expression[in_select] | fieldref - | constantExpression + | constant_expression | LPAREN expression[in_select] RPAREN ; -callExpression[boolean in_select] +call_expression[boolean in_select] : namespaced_name arguments[in_select] ; @@ -445,11 +445,11 @@ parameter : AT ident ; -propertyNameAndValue - : propertyName ':' constantExpression +property_name_and_value + : property_name ':' constant_expression ; -propertyName +property_name : dotted_idents | STRING ; @@ -458,15 +458,15 @@ dotted_idents : ident (DOT ident)* ; -constantExpression +constant_expression : scalar_literal - | mapExpression - | arrayLiteral + | map_expression + | array_literal | parameter ; -arrayLiteral - : LBRACKET i+=constantExpression? (COMMA i+=constantExpression)* RBRACKET +array_literal + : LBRACKET i+=constant_expression? (COMMA i+=constant_expression)* RBRACKET ; scalar_literal diff --git a/container-search/src/main/java/com/yahoo/search/yql/ProgramParser.java b/container-search/src/main/java/com/yahoo/search/yql/ProgramParser.java index 74f2894f04c..fc0cef2fb5e 100644 --- a/container-search/src/main/java/com/yahoo/search/yql/ProgramParser.java +++ b/container-search/src/main/java/com/yahoo/search/yql/ProgramParser.java @@ -9,25 +9,25 @@ import com.google.common.collect.Iterables; import com.google.common.collect.Lists; import com.google.common.collect.Maps; import com.google.common.collect.Sets; -import com.yahoo.search.yql.yqlplusParser.AnnotateExpressionContext; +import com.yahoo.search.yql.yqlplusParser.Annotate_expressionContext; import com.yahoo.search.yql.yqlplusParser.AnnotationContext; import com.yahoo.search.yql.yqlplusParser.ArgumentContext; import com.yahoo.search.yql.yqlplusParser.ArgumentsContext; -import com.yahoo.search.yql.yqlplusParser.ArrayLiteralContext; +import com.yahoo.search.yql.yqlplusParser.Array_literalContext; import com.yahoo.search.yql.yqlplusParser.Call_sourceContext; -import com.yahoo.search.yql.yqlplusParser.ConstantExpressionContext; -import com.yahoo.search.yql.yqlplusParser.DereferencedExpressionContext; -import com.yahoo.search.yql.yqlplusParser.EqualityExpressionContext; +import com.yahoo.search.yql.yqlplusParser.Constant_expressionContext; +import com.yahoo.search.yql.yqlplusParser.Dereferenced_expressionContext; +import com.yahoo.search.yql.yqlplusParser.Equality_expressionContext; import com.yahoo.search.yql.yqlplusParser.Field_defContext; import com.yahoo.search.yql.yqlplusParser.IdentContext; -import com.yahoo.search.yql.yqlplusParser.InNotInTargetContext; +import com.yahoo.search.yql.yqlplusParser.In_not_in_targetContext; import com.yahoo.search.yql.yqlplusParser.LimitContext; import com.yahoo.search.yql.yqlplusParser.Literal_elementContext; import com.yahoo.search.yql.yqlplusParser.Literal_listContext; -import com.yahoo.search.yql.yqlplusParser.LogicalANDExpressionContext; -import com.yahoo.search.yql.yqlplusParser.LogicalORExpressionContext; -import com.yahoo.search.yql.yqlplusParser.MapExpressionContext; -import com.yahoo.search.yql.yqlplusParser.MultiplicativeExpressionContext; +import com.yahoo.search.yql.yqlplusParser.Logical_AND_expressionContext; +import com.yahoo.search.yql.yqlplusParser.Logical_OR_expressionContext; +import com.yahoo.search.yql.yqlplusParser.Map_expressionContext; +import com.yahoo.search.yql.yqlplusParser.Multiplicative_expressionContext; import com.yahoo.search.yql.yqlplusParser.Namespaced_nameContext; import com.yahoo.search.yql.yqlplusParser.OffsetContext; import com.yahoo.search.yql.yqlplusParser.OrderbyContext; @@ -36,10 +36,10 @@ import com.yahoo.search.yql.yqlplusParser.Output_specContext; import com.yahoo.search.yql.yqlplusParser.Pipeline_stepContext; import com.yahoo.search.yql.yqlplusParser.ProgramContext; import com.yahoo.search.yql.yqlplusParser.Project_specContext; -import com.yahoo.search.yql.yqlplusParser.PropertyNameAndValueContext; +import com.yahoo.search.yql.yqlplusParser.Property_name_and_valueContext; import com.yahoo.search.yql.yqlplusParser.Query_statementContext; -import com.yahoo.search.yql.yqlplusParser.RelationalExpressionContext; -import com.yahoo.search.yql.yqlplusParser.RelationalOpContext; +import com.yahoo.search.yql.yqlplusParser.Relational_expressionContext; +import com.yahoo.search.yql.yqlplusParser.Relational_opContext; import com.yahoo.search.yql.yqlplusParser.Scalar_literalContext; import com.yahoo.search.yql.yqlplusParser.Select_source_multiContext; import com.yahoo.search.yql.yqlplusParser.Select_statementContext; @@ -49,7 +49,7 @@ import com.yahoo.search.yql.yqlplusParser.Source_specContext; import com.yahoo.search.yql.yqlplusParser.Source_statementContext; import com.yahoo.search.yql.yqlplusParser.StatementContext; import com.yahoo.search.yql.yqlplusParser.TimeoutContext; -import com.yahoo.search.yql.yqlplusParser.UnaryExpressionContext; +import com.yahoo.search.yql.yqlplusParser.Unary_expressionContext; import com.yahoo.search.yql.yqlplusParser.WhereContext; import org.antlr.v4.runtime.BaseErrorListener; import org.antlr.v4.runtime.CharStream; @@ -604,7 +604,7 @@ final class ProgramParser { ParseTree firstChild = parseTree.getChild(0); if (getParseTreeIndex(firstChild) == yqlplusParser.RULE_annotation) { ParseTree secondChild = parseTree.getChild(1); - OperatorNode annotation = convertExpr(((AnnotationContext) firstChild).mapExpression(), scope); + OperatorNode annotation = convertExpr(((AnnotationContext) firstChild).map_expression(), scope); OperatorNode expr = OperatorNode.create(toLocation(scope, secondChild), ExpressionOperator.VESPA_GROUPING, secondChild.getText()); List names = annotation.getArgument(0); @@ -618,7 +618,7 @@ final class ProgramParser { firstChild.getText()); } } - case yqlplusParser.RULE_nullOperator: + case yqlplusParser.RULE_null_operator: return OperatorNode.create(ExpressionOperator.NULL); case yqlplusParser.RULE_argument: return convertExpr(parseTree.getChild(0), scope); @@ -630,11 +630,11 @@ final class ProgramParser { return convertExpr(firstChild, scope); } } - case yqlplusParser.RULE_mapExpression: { - List propertyList = ((MapExpressionContext)parseTree).propertyNameAndValue(); + case yqlplusParser.RULE_map_expression: { + List propertyList = ((Map_expressionContext)parseTree).property_name_and_value(); List names = Lists.newArrayListWithExpectedSize(propertyList.size()); List> exprs = Lists.newArrayListWithCapacity(propertyList.size()); - for (PropertyNameAndValueContext child : propertyList) { + for (Property_name_and_valueContext child : propertyList) { // : propertyName ':' expression[$expression::namespace] -> // ^(PROPERTY propertyName expression) names.add(StringUnescaper.unquote(child.getChild(0).getText())); @@ -642,17 +642,17 @@ final class ProgramParser { } return OperatorNode.create(toLocation(scope, parseTree),ExpressionOperator.MAP, names, exprs); } - case yqlplusParser.RULE_arrayLiteral: { - List expressionList = ((ArrayLiteralContext) parseTree).constantExpression(); + case yqlplusParser.RULE_array_literal: { + List expressionList = ((Array_literalContext) parseTree).constant_expression(); List> values = Lists.newArrayListWithExpectedSize(expressionList.size()); - for (ConstantExpressionContext expr : expressionList) { + for (Constant_expressionContext expr : expressionList) { values.add(convertExpr(expr, scope)); } return OperatorNode.create(toLocation(scope, expressionList.isEmpty()? parseTree:expressionList.get(0)), ExpressionOperator.ARRAY, values); } // dereferencedExpression: primaryExpression(indexref[in_select]| propertyref)* - case yqlplusParser.RULE_dereferencedExpression: { - DereferencedExpressionContext dereferencedExpression = (DereferencedExpressionContext) parseTree; + case yqlplusParser.RULE_dereferenced_expression: { + Dereferenced_expressionContext dereferencedExpression = (Dereferenced_expressionContext) parseTree; Iterator it = dereferencedExpression.children.iterator(); OperatorNode result = convertExpr(it.next(), scope); while (it.hasNext()) { @@ -667,14 +667,14 @@ final class ProgramParser { } return result; } - case yqlplusParser.RULE_primaryExpression: { + case yqlplusParser.RULE_primary_expression: { // ^(CALL namespaced_name arguments) ParseTree firstChild = parseTree.getChild(0); switch (getParseTreeIndex(firstChild)) { case yqlplusParser.RULE_fieldref: { return convertExpr(firstChild, scope); } - case yqlplusParser.RULE_callExpression: { + case yqlplusParser.RULE_call_expression: { List args = ((ArgumentsContext) firstChild.getChild(1)).argument(); List> arguments = Lists.newArrayListWithExpectedSize(args.size()); for (ArgumentContext argContext : args) { @@ -682,7 +682,7 @@ final class ProgramParser { } return OperatorNode.create(toLocation(scope, parseTree), ExpressionOperator.CALL, scope.resolvePath(readName((Namespaced_nameContext) firstChild.getChild(0))), arguments); } - case yqlplusParser.RULE_constantExpression: + case yqlplusParser.RULE_constant_expression: return convertExpr(firstChild, scope); case yqlplusParser.LPAREN: @@ -696,10 +696,10 @@ final class ProgramParser { IdentContext identContext = parameterContext.getRuleContext(IdentContext.class, 0); return OperatorNode.create(toLocation(scope, identContext), ExpressionOperator.VARREF, identContext.getText()); } - case yqlplusParser.RULE_annotateExpression: { + case yqlplusParser.RULE_annotate_expression: { //annotation logicalORExpression - AnnotationContext annotateExpressionContext = ((AnnotateExpressionContext)parseTree).annotation(); - OperatorNode annotation = convertExpr(annotateExpressionContext.mapExpression(), scope); + AnnotationContext annotateExpressionContext = ((Annotate_expressionContext)parseTree).annotation(); + OperatorNode annotation = convertExpr(annotateExpressionContext.map_expression(), scope); OperatorNode expr = convertExpr(parseTree.getChild(1), scope); List names = annotation.getArgument(0); List> annotates = annotation.getArgument(1); @@ -711,16 +711,16 @@ final class ProgramParser { case yqlplusParser.RULE_expression: { return convertExpr(parseTree.getChild(0), scope); } - case yqlplusParser.RULE_logicalANDExpression: - LogicalANDExpressionContext andExpressionContext = (LogicalANDExpressionContext) parseTree; - return readConjOp(ExpressionOperator.AND, andExpressionContext.equalityExpression(), scope); - case yqlplusParser.RULE_logicalORExpression: { + case yqlplusParser.RULE_logical_AND_expression: + Logical_AND_expressionContext andExpressionContext = (Logical_AND_expressionContext) parseTree; + return readConjOp(ExpressionOperator.AND, andExpressionContext.equality_expression(), scope); + case yqlplusParser.RULE_logical_OR_expression: { int childCount = parseTree.getChildCount(); - LogicalORExpressionContext logicalORExpressionContext = (LogicalORExpressionContext) parseTree; + Logical_OR_expressionContext logicalORExpressionContext = (Logical_OR_expressionContext) parseTree; if (childCount > 1) { return readConjOrOp(ExpressionOperator.OR, logicalORExpressionContext, scope); } else { - List equalityExpressionList = ((LogicalANDExpressionContext) parseTree.getChild(0)).equalityExpression(); + List equalityExpressionList = ((Logical_AND_expressionContext) parseTree.getChild(0)).equality_expression(); if (equalityExpressionList.size() > 1) { return readConjOp(ExpressionOperator.AND, equalityExpressionList, scope); } else { @@ -728,11 +728,11 @@ final class ProgramParser { } } } - case yqlplusParser.RULE_equalityExpression: { - EqualityExpressionContext equalityExpression = (EqualityExpressionContext) parseTree; - RelationalExpressionContext relationalExpressionContext = equalityExpression.relationalExpression(0); + case yqlplusParser.RULE_equality_expression: { + Equality_expressionContext equalityExpression = (Equality_expressionContext) parseTree; + Relational_expressionContext relationalExpressionContext = equalityExpression.relational_expression(0); OperatorNode expr = convertExpr(relationalExpressionContext, scope); - InNotInTargetContext inNotInTarget = equalityExpression.inNotInTarget(); + In_not_in_targetContext inNotInTarget = equalityExpression.in_not_in_target(); int childCount = equalityExpression.getChildCount(); if (childCount == 1) { return expr; @@ -786,11 +786,11 @@ final class ProgramParser { } break; } - case yqlplusParser.RULE_relationalExpression: { - RelationalExpressionContext relationalExpressionContext = (RelationalExpressionContext) parseTree; - RelationalOpContext opContext = relationalExpressionContext.relationalOp(); + case yqlplusParser.RULE_relational_expression: { + Relational_expressionContext relationalExpressionContext = (Relational_expressionContext) parseTree; + Relational_opContext opContext = relationalExpressionContext.relational_op(); if (opContext != null) { - switch (getParseTreeIndex(relationalExpressionContext.relationalOp().getChild(0))) { + switch (getParseTreeIndex(relationalExpressionContext.relational_op().getChild(0))) { case yqlplusParser.LT: return readBinOp(ExpressionOperator.LT, parseTree, scope); case yqlplusParser.LTEQ: @@ -801,12 +801,12 @@ final class ProgramParser { return readBinOp(ExpressionOperator.GTEQ, parseTree, scope); } } else { - return convertExpr(relationalExpressionContext.additiveExpression(0), scope); + return convertExpr(relationalExpressionContext.additive_expression(0), scope); } } break; - case yqlplusParser.RULE_additiveExpression: - case yqlplusParser.RULE_multiplicativeExpression: { + case yqlplusParser.RULE_additive_expression: + case yqlplusParser.RULE_multiplicative_expression: { if (parseTree.getChildCount() > 1) { String opStr = parseTree.getChild(1).getText(); switch (opStr) { @@ -821,23 +821,23 @@ final class ProgramParser { case "%": return readBinOp(ExpressionOperator.MOD, parseTree, scope); default: - if (parseTree.getChild(0) instanceof UnaryExpressionContext) { + if (parseTree.getChild(0) instanceof Unary_expressionContext) { return convertExpr(parseTree.getChild(0), scope); } else { throw new ProgramCompileException(toLocation(scope, parseTree), "Unknown expression type: " + parseTree.toStringTree()); } } } else { - if (parseTree.getChild(0) instanceof UnaryExpressionContext) { + if (parseTree.getChild(0) instanceof Unary_expressionContext) { return convertExpr(parseTree.getChild(0), scope); - } else if (parseTree.getChild(0) instanceof MultiplicativeExpressionContext) { + } else if (parseTree.getChild(0) instanceof Multiplicative_expressionContext) { return convertExpr(parseTree.getChild(0), scope); } else { throw new ProgramCompileException(toLocation(scope, parseTree), "Unknown expression type: " + parseTree.getText()); } } } - case yqlplusParser.RULE_unaryExpression: { + case yqlplusParser.RULE_unary_expression: { if (1 == parseTree.getChildCount()) { return convertExpr(parseTree.getChild(0), scope); } else if (2 == parseTree.getChildCount()) { @@ -886,7 +886,7 @@ final class ProgramParser { } case yqlplusParser.RULE_scalar_literal: return OperatorNode.create(toLocation(scope, parseTree), ExpressionOperator.LITERAL, convertLiteral((Scalar_literalContext) parseTree)); - case yqlplusParser.RULE_constantExpression: + case yqlplusParser.RULE_constant_expression: return convertExpr(parseTree.getChild(0), scope); case yqlplusParser.RULE_literal_list: if (getParseTreeIndex(parseTree.getChild(1)) == yqlplusParser.RULE_array_parameter) { @@ -968,7 +968,7 @@ final class ProgramParser { return OperatorNode.create(op, convertExpr(operand1, scope), convertExpr(operand2, scope)); } - private OperatorNode readConjOp(ExpressionOperator op, List nodes, Scope scope) { + private OperatorNode readConjOp(ExpressionOperator op, List nodes, Scope scope) { List> arguments = Lists.newArrayListWithExpectedSize(nodes.size()); for (ParseTree child : nodes) { arguments.add(convertExpr(child, scope)); @@ -976,16 +976,16 @@ final class ProgramParser { return OperatorNode.create(op, arguments); } - private OperatorNode readConjOrOp(ExpressionOperator op, LogicalORExpressionContext node, Scope scope) { - List andExpressionList = node.logicalANDExpression(); + private OperatorNode readConjOrOp(ExpressionOperator op, Logical_OR_expressionContext node, Scope scope) { + List andExpressionList = node.logical_AND_expression(); List> arguments = Lists.newArrayListWithExpectedSize(andExpressionList.size()); - for (LogicalANDExpressionContext child : andExpressionList) { - List equalities = child.equalityExpression(); + for (Logical_AND_expressionContext child : andExpressionList) { + List equalities = child.equality_expression(); if (equalities.size() == 1) { arguments.add(convertExpr(equalities.get(0), scope)); } else { List> andArguments = Lists.newArrayListWithExpectedSize(equalities.size()); - for (EqualityExpressionContext subTreeChild:equalities) { + for (Equality_expressionContext subTreeChild:equalities) { andArguments.add(convertExpr(subTreeChild, scope)); } arguments.add(OperatorNode.create(ExpressionOperator.AND, andArguments)); @@ -998,7 +998,7 @@ final class ProgramParser { // (IS_NULL | IS_NOT_NULL) // unaryExpression private OperatorNode readUnOp(ExpressionOperator op, ParseTree node, Scope scope) { - assert (node instanceof TerminalNode) || (node.getChildCount() == 1) || (node instanceof UnaryExpressionContext); + assert (node instanceof TerminalNode) || (node.getChildCount() == 1) || (node instanceof Unary_expressionContext); if (node instanceof TerminalNode) { return OperatorNode.create(op, convertExpr(node, scope)); } else if (node.getChildCount() == 1) { -- cgit v1.2.3