{
// "Object(p)", so interpret as "p"
processExpression(); // identifier at top of stack
if (!p.parseChar(')'))
{
throw new QueryCompilerSyntaxException("')' expected", p.getIndex(), p.getInput());
}
return true;
}
if (method.equalsIgnoreCase("EXISTS"))
{
Node existsNode = new Node(Node.SUBQUERY, "EXISTS");
processExpression(); // subquery variable
Node subqueryNode = stack.pop();
existsNode.appendChildNode(subqueryNode);
stack.push(existsNode);
if (!p.parseChar(')'))
{
throw new QueryCompilerSyntaxException("')' expected", p.getIndex(), p.getInput());
}
return true;
}
else if (method.equalsIgnoreCase("ANY"))
{
Node existsNode = new Node(Node.SUBQUERY, "ANY");
processExpression(); // subquery variable
Node subqueryNode = stack.pop();
existsNode.appendChildNode(subqueryNode);
stack.push(existsNode);
if (!p.parseChar(')'))
{
throw new QueryCompilerSyntaxException("')' expected", p.getIndex(), p.getInput());
}
return true;
}
else if (method.equalsIgnoreCase("ALL"))
{
Node existsNode = new Node(Node.SUBQUERY, "ALL");
processExpression(); // subquery variable
Node subqueryNode = stack.pop();
existsNode.appendChildNode(subqueryNode);
stack.push(existsNode);
if (!p.parseChar(')'))
{
throw new QueryCompilerSyntaxException("')' expected", p.getIndex(), p.getInput());
}
return true;
}
else if (method.equalsIgnoreCase("SOME"))
{
Node existsNode = new Node(Node.SUBQUERY, "SOME");
processExpression(); // subquery variable
Node subqueryNode = stack.pop();
existsNode.appendChildNode(subqueryNode);
stack.push(existsNode);
if (!p.parseChar(')'))
{
throw new QueryCompilerSyntaxException("')' expected", p.getIndex(), p.getInput());
}
return true;
}
else if (method.equalsIgnoreCase("SUBSTRING"))
{
// SUBSTRING(string_primary, simple_arithmetic_expression[, simple_arithmetic_expression])
// Convert to be {primary}.INVOKE(substring, {arg1[, arg2]})
Node invokeNode = new Node(Node.INVOKE, "substring");
processExpression();
Node primaryNode = stack.pop();
if (!p.parseChar(','))
{
throw new QueryCompilerSyntaxException("',' expected", p.getIndex(), p.getInput());
}
// First arg to substring(...) has origin 0, but JPQL has origin 1!
processExpression();
Node arg1 = stack.pop();
Node oneNode = new Node(Node.LITERAL, 1);
Node arg1Node = new Node(Node.OPERATOR, "-");
arg1Node.insertChildNode(arg1);
arg1Node.appendChildNode(oneNode);
if (p.parseChar(','))
{
// String.substring(arg1, arg2)
// Second arg to substring(...) has origin 0, but in JPQL is length of result!
processExpression();
Node arg2 = stack.pop();
Node arg2Node = new Node(Node.OPERATOR, "+");
arg2Node.appendChildNode(arg2);
arg2Node.appendChildNode(arg1Node);
if (!p.parseChar(')'))
{
throw new QueryCompilerSyntaxException("')' expected", p.getIndex(), p.getInput());
}
primaryNode.appendChildNode(invokeNode);
invokeNode.addProperty(arg1Node);
invokeNode.addProperty(arg2Node);
stack.push(primaryNode);
return true;
}
else if (p.parseChar(')'))
{
// String.substring(arg1)
primaryNode.appendChildNode(invokeNode);
invokeNode.addProperty(arg1Node);
stack.push(primaryNode);
return true;
}
else
{
throw new QueryCompilerSyntaxException("')' expected", p.getIndex(), p.getInput());
}
}
else if (method.equalsIgnoreCase("UPPER"))
{
// UPPER(string_primary)
// Convert to be {primary}.INVOKE(toUpper)
Node invokeNode = new Node(Node.INVOKE, "toUpperCase");
processExpression();
Node primaryNode = stack.pop();
if (!p.parseChar(')'))
{
throw new QueryCompilerSyntaxException("',' expected", p.getIndex(), p.getInput());
}
primaryNode.appendChildNode(invokeNode);
stack.push(primaryNode);
return true;
}
else if (method.equalsIgnoreCase("LOWER"))
{
// UPPER(string_primary)
// Convert to be {primary}.INVOKE(toLower)
Node invokeNode = new Node(Node.INVOKE, "toLowerCase");
processExpression();
Node primaryNode = stack.pop();
if (!p.parseChar(')'))
{
throw new QueryCompilerSyntaxException("',' expected", p.getIndex(), p.getInput());
}
primaryNode.appendChildNode(invokeNode);
stack.push(primaryNode);
return true;
}
else if (method.equalsIgnoreCase("LENGTH"))
{
// LENGTH(string_primary)
// Convert to be {primary}.INVOKE(length)
Node invokeNode = new Node(Node.INVOKE, "length");
processExpression();
Node primaryNode = stack.pop();
if (!p.parseChar(')'))
{
throw new QueryCompilerSyntaxException("',' expected", p.getIndex(), p.getInput());
}
primaryNode.appendChildNode(invokeNode);
stack.push(primaryNode);
return true;
}
else if (method.equalsIgnoreCase("CONCAT"))
{
// CONCAT(string_primary, string_primary[, string_primary])
// Convert to be {primary1}+{primary2}[+primary3]
processExpression();
Node prevNode = stack.pop();
while (true)
{
if (!p.parseChar(','))
{
throw new QueryCompilerSyntaxException("',' expected", p.getIndex(), p.getInput());
}
processExpression();
Node thisNode = stack.pop();
Node currentNode = new Node(Node.OPERATOR, "+");
currentNode.appendChildNode(prevNode);
currentNode.appendChildNode(thisNode);
if (p.parseChar(')'))
{
stack.push(currentNode);
return true;
}
prevNode = currentNode;
currentNode = null;
}
}
else if (method.equalsIgnoreCase("LOCATE"))
{
// LOCATE(string_primary, string_primary[, simple_arithmetic_expression])
// Convert to ({stringExpr}.indexOf(strExpr[, posExpr]) + 1)
processExpression();
Node searchNode = stack.pop();
if (!p.parseChar(','))
{
throw new QueryCompilerSyntaxException("',' expected", p.getIndex(), p.getInput());
}
processExpression();
Node primaryNode = stack.pop();
Node invokeNode = new Node(Node.INVOKE, "indexOf");
invokeNode.addProperty(searchNode);
Node oneNode = new Node(Node.LITERAL, 1);
if (p.parseChar(','))
{
processExpression();
Node fromPosNode = stack.pop();
Node positionNode = new Node(Node.OPERATOR, "-");
positionNode.appendChildNode(fromPosNode);
positionNode.appendChildNode(oneNode);
invokeNode.addProperty(positionNode);
}
if (!p.parseChar(')'))
{
throw new QueryCompilerSyntaxException("')' expected", p.getIndex(), p.getInput());
}
primaryNode.appendChildNode(invokeNode);
Node locateNode = new Node(Node.OPERATOR, "+");
locateNode.appendChildNode(primaryNode);
locateNode.appendChildNode(oneNode);
stack.push(locateNode);
return true;
}
else if (method.equalsIgnoreCase("TRIM"))
{
// TRIM([[LEADING | TRAILING | BOTH] [trim_character] FROM] string_primary)
// Convert to be {primary}.INVOKE(trim|trimLeft|trimRight, [{trimChar}])
String methodName = "trim";
if (p.parseStringIgnoreCase("LEADING"))
{
methodName = "trimLeft";
}
else if (p.parseStringIgnoreCase("TRAILING"))
{
methodName = "trimRight";
}
else if (p.parseStringIgnoreCase("BOTH"))
{
// Default
}
Node invokeNode = new Node(Node.INVOKE, methodName);
Node trimCharNode = null;
processExpression();
Node next = stack.pop();
if (p.parseChar(')'))
{
next.appendChildNode(invokeNode);
stack.push(next);
return true;
}
else
{
if (next.getNodeType() == Node.IDENTIFIER)
{
Object litValue = next.getNodeValue();
if (litValue instanceof String && ((String)litValue).equals("FROM"))
{
// FROM so ignore
processExpression(); // field expression that we are trimming
next = stack.pop();
}
else
{
// trim character first
trimCharNode = next;
if (p.parseStringIgnoreCase("FROM "))
{
// Ignore the FROM
}
processExpression();
next = stack.pop();
}
}
else
{
// No "trimChar" or FROM, so "next" is the string expression node
}
if (!p.parseChar(')'))
{
throw new QueryCompilerSyntaxException("')' expected", p.getIndex(), p.getInput());
}
next.appendChildNode(invokeNode);
if (trimCharNode != null)
{
invokeNode.addProperty(trimCharNode);
}
stack.push(next);
return true;
}
}
else if (method.equalsIgnoreCase("SIZE"))
{
// SIZE(collection_valued_path_expression)
// Convert to be {primary}.INVOKE(size)
Node invokeNode = new Node(Node.INVOKE, "size");
processExpression();
Node primaryNode = stack.pop(); // Could check type ? (Collection/Map/array)
if (!p.parseChar(')'))
{
throw new QueryCompilerSyntaxException("',' expected", p.getIndex(), p.getInput());
}
primaryNode.appendChildNode(invokeNode);
stack.push(primaryNode);
return true;
}
else if (method.equalsIgnoreCase("KEY"))
{
// KEY(identification_variable)
// Convert to be {primary}.INVOKE(mapKey)
Node invokeNode = new Node(Node.INVOKE, "mapKey");
processExpression();
Node primaryNode = stack.pop(); // Could check type ? (Map)
if (!p.parseChar(')'))
{
throw new QueryCompilerSyntaxException("',' expected", p.getIndex(), p.getInput());
}
primaryNode.appendChildNode(invokeNode);
stack.push(primaryNode);
return true;
}
else if (method.equalsIgnoreCase("VALUE"))
{
// VALUE(identification_variable)
// Convert to be {primary}.INVOKE(mapValue)
Node invokeNode = new Node(Node.INVOKE, "mapValue");
processExpression();
Node primaryNode = stack.pop(); // Could check type ? (Map)
if (!p.parseChar(')'))
{
throw new QueryCompilerSyntaxException("',' expected", p.getIndex(), p.getInput());
}
primaryNode.appendChildNode(invokeNode);
stack.push(primaryNode);
return true;
}
else if (method.equalsIgnoreCase("ENTRY"))
{
// ENTRY(identification_variable)
// Convert to be {primary}.INVOKE(mapEntry)
Node invokeNode = new Node(Node.INVOKE, "mapEntry");
processExpression();
Node primaryNode = stack.pop(); // Could check type ? (Map)
if (!p.parseChar(')'))
{
throw new QueryCompilerSyntaxException("',' expected", p.getIndex(), p.getInput());
}
primaryNode.appendChildNode(invokeNode);
stack.push(primaryNode);
return true;
}
else
{
// Found syntax for a method, so invoke the method
// TODO What if the method is not supported for JPQL?
Node expr = new Node(Node.INVOKE, method);
if (!p.parseChar(')'))
{
do
{
// Argument for the method call, add as a node property
processExpression();
expr.addProperty(stack.pop());
}
while (p.parseChar(','));
if (!p.parseChar(')'))
{
throw new QueryCompilerSyntaxException("')' expected", p.getIndex(), p.getInput());
}
}
stack.push(expr);
return true;
}