protected boolean parenthesisNeeded(Expression node, Expression parentNode) { if (parentNode == null) return false; // only unary expressions can go w/o parenthesis if (node.getOperandCount() > 1) return true; if (node.getType() == Expression.OBJ_PATH) return false; if (node.getType() == Expression.DB_PATH) return false; return true; }
@Override protected boolean parenthesisNeeded(Expression node, Expression parentNode) { if (node.getType() == Expression.FUNCTION_CALL) { if (node instanceof ASTExtract) { return false; } } return super.parenthesisNeeded(node, parentNode); }
@Override protected boolean parenthesisNeeded(Expression node, Expression parentNode) { if (node.getType() == Expression.FUNCTION_CALL) { if (node instanceof ASTExtract) { return false; } } return super.parenthesisNeeded(node, parentNode); }
@Override protected boolean parenthesisNeeded(Expression node, Expression parentNode) { if (node.getType() == Expression.FUNCTION_CALL) { if (node instanceof ASTExtract) { return false; } } return super.parenthesisNeeded(node, parentNode); }
@Override protected boolean parenthesisNeeded(Expression node, Expression parentNode) { if (node.getType() == Expression.FUNCTION_CALL) { if (node instanceof ASTExtract) { return false; } } return super.parenthesisNeeded(node, parentNode); }
@Override protected boolean parenthesisNeeded(Expression node, Expression parentNode) { if (node.getType() == Expression.FUNCTION_CALL) { if (node instanceof ASTExtract) { return false; } } return super.parenthesisNeeded(node, parentNode); }
@Override protected void appendLiteralDirect(Object val, DbAttribute attr, Expression parentExpression) throws IOException { // Special handling of string matching is needed: // Case-sensitive LIKE must be converted to [x][Y][z] format if (val instanceof String && (parentExpression.getType() == Expression.LIKE || parentExpression.getType() == Expression.NOT_LIKE)) { val = caseSensitiveLikePattern((String) val); } super.appendLiteralDirect(val, attr, parentExpression); }
@Override protected boolean parenthesisNeeded(Expression node, Expression parentNode) { if (node.getType() == Expression.FUNCTION_CALL) { if (node instanceof ASTExtract) { return false; } } return super.parenthesisNeeded(node, parentNode); }
@Override protected boolean parenthesisNeeded(Expression node, Expression parentNode) { if (node.getType() == Expression.FUNCTION_CALL) { if (node instanceof ASTExtract) { return false; } } return super.parenthesisNeeded(node, parentNode); }
@Override protected void processColumnWithQuoteSqlIdentifiers(DbAttribute dbAttr, Expression pathExp) { Expression node = peek(1); boolean likeCI = node != null && dbAttr.getType() == Types.CLOB && (node.getType() == Expression.LIKE_IGNORE_CASE || node.getType() == Expression.NOT_LIKE_IGNORE_CASE); if (likeCI) { out.append("CAST("); } super.processColumnWithQuoteSqlIdentifiers(dbAttr, node); if (likeCI) { out.append(" AS NVARCHAR(MAX))"); } }
@Override public void endNode(Expression node, Expression parentNode) { super.endNode(node, parentNode); if(node.getType() == Expression.FUNCTION_CALL) { if("LOCATE".equals(((ASTFunctionCall)node).getFunctionName())) { // order of args in ingres version of LOCATE is different, so swap them back swapNodeChildren((ASTFunctionCall)node, 0, 1); } } }
@Override public void endNode(Expression node, Expression parentNode) { super.endNode(node, parentNode); if(node.getType() == Expression.FUNCTION_CALL) { if("LOCATE".equals(((ASTFunctionCall)node).getFunctionName())) { // order of args in INSTR is different, so swap them back swapNodeChildren((ASTFunctionCall)node, 0, 1); } } }
/** * @since 4.0 */ @Override public void endNode(Expression node, Expression parentNode) { super.endNode(node, parentNode); if(node.getType() == Expression.FUNCTION_CALL) { if("LOCATE".equals(((ASTFunctionCall)node).getFunctionName())) { // order of args in INSTR is different, so swap them back swapNodeChildren((ASTFunctionCall)node, 0, 1); } } }
@Override public Iterator<CayenneMapEntry> resolvePathComponents(Expression pathExp) throws ExpressionException { if (pathExp.getType() != Expression.DB_PATH) { throw new ExpressionException("Invalid expression type: '" + pathExp.expName() + "', DB_PATH is expected."); } return new PathIterator((String) pathExp.getOperand(0)); }
public Iterator resolvePathComponents(Expression pathExp) throws ExpressionException { if (pathExp.getType() != Expression.DB_PATH) { throw new ExpressionException("Invalid expression type: '" + pathExp.expName() + "', DB_PATH is expected."); } return new PathIterator((String) pathExp.getOperand(0)); }
public Object transform(Object input) { if (!(input instanceof Expression)) { return input; } Expression expression = (Expression) input; if (expression.getType() != Expression.DB_PATH) { return input; } String path = (String) expression.getOperand(0); String converted = translatePath(path); Expression transformed = ExpressionFactory.expressionOfType(Expression.DB_PATH); transformed.setOperand(0, converted); return transformed; }
public Object transform(Object input) { if (!(input instanceof Expression)) { return input; } Expression expression = (Expression) input; if (expression.getType() != Expression.OBJ_PATH) { return input; } // convert obj_path to db_path String converted = toDbPath(createPathIterator((String) expression.getOperand(0))); Expression exp = ExpressionFactory.expressionOfType(Expression.DB_PATH); exp.setOperand(0, converted); return exp; } }
@Override public int hashCode() { HashCodeBuilder builder = new HashCodeBuilder().append(getType()); int opCount = getOperandCount(); for(int i=0; i<opCount; i++) { builder.append(getOperand(i)); } return builder.toHashCode(); }