private MethodField parseSQLMethodInvokeExprWithFunctionInWhere(SQLMethodInvokeExpr soExpr) throws SqlParseException { MethodField methodField = FieldMaker.makeMethodField(soExpr.getMethodName(), soExpr.getParameters(), null, null, query != null ? query.getFrom().getAlias() : null, false); return methodField; }
public Object eval(SQLEvalVisitor visitor, SQLMethodInvokeExpr x) { if (x.getParameters().size() != 1) { return SQLEvalVisitor.EVAL_ERROR; SQLExpr param0 = x.getParameters().get(0); if (paramMethodExpr.getMethodName().equalsIgnoreCase("hex")) { SQLExpr subParamExpr = paramMethodExpr.getParameters().get(0); subParamExpr.accept(visitor); x.putAttribute(EVAL_EXPR, subParamExpr); return SQLEvalVisitor.EVAL_ERROR;
public static SQLExpr transformOracleToPostgresql(SQLMethodInvokeExpr x) { final long nameHashCode64 = x.methodNameHashCode64(); List<SQLExpr> parameters = x.getParameters(); SQLMethodInvokeExpr uuid_generate_v4 = new SQLMethodInvokeExpr("uuid_generate_v4"); uuid_generate_v4.setParent(x.getParent()); return uuid_generate_v4; || (param0 instanceof SQLIdentifierExpr && ((SQLIdentifierExpr) param0).nameHashCode64() == FnvHash.Constants.CURRENT_TIMESTAMP)) { SQLMethodInvokeExpr current_timestamp = new SQLMethodInvokeExpr("CURRENT_TIMESTAMP"); current_timestamp.addParameter(new SQLIntegerExpr(0)); current_timestamp.setParent(x.getParent()); return current_timestamp; if (parameters.size() == 0 && x.getParent() instanceof SQLColumnDefinition) { SQLDataType dataType = ((SQLColumnDefinition) x.getParent()).getDataType(); if (dataType.nameHashCode64() == FnvHash.Constants.TIMESTAMP && dataType.getArguments().size() == 1) { x.addParameter(dataType.getArguments().get(0).clone()); } else { x.addParameter(new SQLIntegerExpr(0)); SQLMethodInvokeExpr xx = x.clone(); xx.setMethodName("CURRENT_TIMESTAMP"); xx.setParent(x.getParent()); return xx;
public SQLMethodInvokeExpr(String methodName, SQLExpr owner, SQLExpr... params){ this.name = methodName; setOwner(owner); for (SQLExpr param : params) { this.addParameter(param); } }
public SQLMethodInvokeExpr clone() { SQLMethodInvokeExpr x = new SQLMethodInvokeExpr(); x.name = name; if (owner != null) { x.setOwner(owner.clone()); } for (SQLExpr param : parameters) { x.addParameter(param.clone()); } if (from != null) { x.setFrom(from.clone()); } if (using != null) { x.setUsing(using.clone()); } return x; }
private static SQLMethodInvokeExpr convertBinaryOperatorToMethod(String operator, SQLBinaryOpExpr expr) { SQLMethodInvokeExpr methodInvokeExpr = new SQLMethodInvokeExpr(operator, null); methodInvokeExpr.addParameter(expr.getLeft()); methodInvokeExpr.addParameter(expr.getRight()); return methodInvokeExpr; }
public boolean visit(SQLMethodInvokeExpr x) { SQLExpr owner = x.getOwner(); if (owner != null) { printMethodOwner(owner); String function = x.getMethodName(); List<SQLExpr> parameters = x.getParameters(); String trimOption = x.getTrimOption(); if (trimOption != null) { print0(trimOption); SQLExpr from = x.getFrom(); if (from != null) { print0(ucase ? " FROM " : " from "); printExpr(from); SQLExpr _for = x.getFor(); if (_for != null) { print0(ucase ? " FOR " : " for "); SQLExpr using = x.getUsing(); if (using != null) { print0(ucase ? " USING " : " using ");
public boolean visit(SQLMethodInvokeExpr x) { this.functions.add(x); accept(x.getParameters()); return false; }
public static boolean visit(SQLEvalVisitor visitor, SQLMethodInvokeExpr x) { String methodName = x.getMethodName().toLowerCase(); x.getAttributes().put(EVAL_VALUE, result); if (x.getParameters().size() != 2) { return false; SQLExpr param0 = x.getParameters().get(0); SQLExpr param1 = x.getParameters().get(1); param0.accept(visitor); param1.accept(visitor); if (result >= Integer.MIN_VALUE && result <= Integer.MAX_VALUE) { int intResult = (int) result; x.putAttribute(EVAL_VALUE, intResult); } else { x.putAttribute(EVAL_VALUE, result); if (x.getParameters().size() != 1) { return false; SQLExpr param0 = x.getParameters().get(0); param0.accept(visitor); x.putAttribute(EVAL_VALUE, result); } else if ("acos".equals(methodName)) { if (x.getParameters().size() != 1) { return false;
SQLMethodInvokeExpr concat = new SQLMethodInvokeExpr("CONCAT"); concat.addParameter(expr); do { String chars = lexer.stringVal(); concat.addParameter(new SQLCharExpr(chars)); lexer.nextToken(); } while (lexer.token() == Token.LITERAL_CHARS || lexer.token() == Token.LITERAL_ALIAS); } else if ("SUBSTRING".equalsIgnoreCase(ident)) { lexer.nextToken(); SQLMethodInvokeExpr methodInvokeExpr = new SQLMethodInvokeExpr(ident); for (; ; ) { SQLExpr param = expr(); methodInvokeExpr.addParameter(param); lexer.nextToken(); SQLExpr from = expr(); methodInvokeExpr.addParameter(from); methodInvokeExpr.addParameter(forExpr); } else if ("TRIM".equalsIgnoreCase(ident)) { lexer.nextToken(); SQLMethodInvokeExpr methodInvokeExpr = new SQLMethodInvokeExpr(ident); if ("LEADING".equalsIgnoreCase(flagVal)) { lexer.nextToken(); methodInvokeExpr.getAttributes().put("TRIM_TYPE", "LEADING"); } else if ("BOTH".equalsIgnoreCase(flagVal)) {
if (methodInvoke.getParameters().size() == 1) { SQLExpr paramExpr = methodInvoke.getParameters().get(0); if (paramExpr instanceof SQLIdentifierExpr && "+".equals(((SQLIdentifierExpr) paramExpr).getName())) { OracleOuterExpr outerExpr = new OracleOuterExpr(); if (methodInvoke.getOwner() == null) { outerExpr.setExpr(new SQLIdentifierExpr(methodInvoke.getMethodName())); } else { outerExpr.setExpr(new SQLPropertyExpr(methodInvoke.getOwner(), methodInvoke.getMethodName()));
if (!"decode".equalsIgnoreCase(x.getMethodName())) { throw new IllegalArgumentException(x.getMethodName()); List<SQLExpr> parameters = x.getParameters(); SQLCaseExpr caseExpr = new SQLCaseExpr(); caseExpr.setParent(x.getParent()); caseExpr.setValueExpr(parameters.get(0)); SQLExpr param1 = parameters.get(1); x.setMethodName("if"); if ("decode".equalsIgnoreCase(methodInvokeExpr.getMethodName())) { valueExpr = transformDecode(methodInvokeExpr); if ("decode".equalsIgnoreCase(methodInvokeExpr.getMethodName())) { defaultExpr = transformDecode(methodInvokeExpr); caseExpr.setParent(x.getParent());
@Override public void endVisit(SQLMethodInvokeExpr x) { List<Item> args = visitExprList(x.getParameters()); String funcName = x.getMethodName().toUpperCase(); Map<String, Object> attributes = x.getAttributes(); switch (funcName) { case "TRIM": SQLExpr from = x.getFrom(); if (from == null) { item = new ItemFuncTrim(args.get(0), TrimTypeEnum.DEFAULT); } else { TrimTypeEnum trimType = TrimTypeEnum.DEFAULT; String trimOption = x.getTrimOption(); if (trimOption != null) { trimType = TrimTypeEnum.valueOf(trimOption); case "CHAR": if (attributes == null || attributes.get(ItemFuncKeyWord.USING) == null) { attributes = x.getParameters().get(0).getAttributes(); break; case "ADDDATE": if (x.getParameters().get(1) instanceof SQLIntegerExpr) { item = new ItemDateAddInterval(args.get(0), args.get(1), SQLIntervalUnit.DAY, false); break; SQLIntervalExpr intervalExpr = (SQLIntervalExpr) (x.getParameters().get(1)); item = new ItemDateAddInterval(args.get(0), getItem(intervalExpr.getValue()), getIntervalUnit(x.getParameters().get(1)), false); break; case "SUBDATE":
SQLMethodInvokeExpr methodInvokeExpr = new SQLMethodInvokeExpr(name); methodInvokeExpr.setOwner(expr); if (lexer.token == Token.RPAREN) { lexer.nextToken(); } else { if (lexer.token == Token.PLUS) { methodInvokeExpr.addParameter(new SQLIdentifierExpr("+")); lexer.nextToken(); } else { exprList(methodInvokeExpr.getParameters(), methodInvokeExpr);
methodInvokeExpr = new SQLMethodInvokeExpr(methodName, hash_lower); if (owner != null) { methodInvokeExpr.setOwner(owner); methodInvokeExpr.setTrimOption(trimOption); exprList(methodInvokeExpr.getParameters(), methodInvokeExpr); && methodInvokeExpr.getParameters().size() == 1 && methodInvokeExpr.getParameters().get(0) instanceof SQLQueryExpr) { throw new ParserException("exists syntax error."); lexer.nextToken(); SQLExpr from = this.expr(); methodInvokeExpr.setFrom(from); methodInvokeExpr.setFor(forExpr); using = this.primary(); methodInvokeExpr.setUsing(using); aggregateExpr.getArguments().addAll(methodInvokeExpr.getParameters()); if (aggregateExpr == null) { aggregateExpr = new SQLAggregateExpr(methodName); aggregateExpr.getArguments().addAll(methodInvokeExpr.getParameters());
private boolean isAllowedMethodOnConditionLeft(SQLMethodInvokeExpr method, SQLBinaryOperator operator) { return (method.getMethodName().toLowerCase().equals("nested") || method.getMethodName().toLowerCase().equals("children") || SQLFunctions.buildInFunctions.contains(method.getMethodName().toLowerCase()) ) && !operator.isLogical(); }
if (!SQLFunctions.buildInFunctions.contains(((SQLMethodInvokeExpr) soExpr.getLeft()).getMethodName())) { return null; if (!SQLFunctions.buildInFunctions.contains(((SQLMethodInvokeExpr) soExpr.getRight()).getMethodName())) { return null; SQLMethodInvokeExpr scriptMethod = new SQLMethodInvokeExpr("script", null); scriptMethod.addParameter(new SQLCharExpr(finalStr)); return scriptMethod;
checkSchema(visitor, x.getOwner()); String methodName = x.getMethodName().toLowerCase(); boolean isShow = x.getParent() instanceof MySqlShowGrantsStatement; if (isShow) { return;
@Override protected SQLExpr methodRest(SQLExpr expr, boolean acceptLPAREN) { if (acceptLPAREN) { accept(Token.LPAREN); } if (expr instanceof SQLName || expr instanceof SQLDefaultExpr) { String methodName; SQLMethodInvokeExpr methodInvokeExpr; if (expr instanceof SQLPropertyExpr) { methodName = ((SQLPropertyExpr) expr).getName(); methodInvokeExpr = new SQLMethodInvokeExpr(methodName); methodInvokeExpr.setOwner(((SQLPropertyExpr) expr).getOwner()); } else { methodName = expr.toString(); methodInvokeExpr = new SQLMethodInvokeExpr(methodName); } if (isAggreateFunction(methodName)) { SQLAggregateExpr aggregateExpr = parseAggregateExpr(methodName); return aggregateExpr; } if (lexer.token() != Token.RPAREN) { exprList(methodInvokeExpr.getParameters(), methodInvokeExpr); } accept(Token.RPAREN); return primaryRest(methodInvokeExpr); } throw new ParserException("not support token:" + lexer.token()); }
public static void checkFunctionInTableSource(WallVisitor visitor, SQLMethodInvokeExpr x) { final WallTopStatementContext topStatementContext = wallTopStatementContextLocal.get(); if (topStatementContext != null && (topStatementContext.fromSysSchema || topStatementContext.fromSysTable)) { return; } checkSchema(visitor, x.getOwner()); String methodName = x.getMethodName().toLowerCase(); if (!visitor.getProvider().checkDenyTable(methodName)) { if (isTopStatementWithTableSource(x) || isFirstSelectTableSource(x)) { if (topStatementContext != null) { topStatementContext.setFromSysSchema(Boolean.TRUE); clearViolation(visitor); } } } }