Examples with FieldOrRow org.jooq.FieldOrRow used on opensource projects

Example 1 with FieldOrRow

use of org.jooq.FieldOrRow in project jOOQ by jOOQ.

the class DefaultParseContext method parsePredicate.

private final QueryPart parsePredicate() {
    Condition condition;
    switch(characterUpper()) {
        case 'D':
            break;
        case 'E':
            if (parseKeywordIf("EXISTS"))
                return exists(parseParenthesised(c -> parseWithOrSelect()));
            break;
        case 'I':
            break;
        case 'J':
            if ((condition = parsePredicateJSONExistsIf()) != null)
                return condition;
            break;
        case 'R':
            if (parseKeywordIf("REGEXP_LIKE"))
                return parseFunctionArgs2(Field::likeRegex);
            break;
        case 'S':
            if (!ignoreProEdition() && parseFunctionNameIf("ST_CONTAINS", "SDO_CONTAINS") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_CROSSES") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_DISJOINT") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_EQUALS", "SDO_EQUAL") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_INTERSECTS") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_ISCLOSED") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_ISEMPTY") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_OVERLAPS", "SDO_OVERLAPS") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_TOUCHES", "SDO_TOUCH") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_WITHIN", "SDO_INSIDE") && requireProEdition()) {
            }
            break;
        case 'U':
            if (parseKeywordIf("UNIQUE"))
                // javac can't infer this (?)
                return unique(this.<Select<?>>parseParenthesised(c -> parseWithOrSelect()));
            break;
        case 'X':
            if ((condition = parsePredicateXMLExistsIf()) != null)
                return condition;
            break;
    }
    FieldOrRow left;
    Comparator comp;
    TSQLOuterJoinComparator outer;
    boolean not;
    boolean notOp = false;
    left = parseConcat();
    int p = position();
    not = parseKeywordIf("NOT");
    boolean isField = left instanceof Field;
    if (!not && !ignoreProEdition() && ((outer = parseTSQLOuterJoinComparatorIf()) != null) && requireProEdition()) {
        Condition result = null;
        return result;
    } else if (!not && (comp = parseComparatorIf()) != null) {
        boolean all = parseKeywordIf("ALL");
        boolean any = !all && (parseKeywordIf("ANY") || parseKeywordIf("SOME"));
        if (all || any)
            parse('(');
        // TODO equal degrees
        Condition result = all ? isField ? peekSelectOrWith(true) ? ((Field) left).compare(comp, DSL.all(parseWithOrSelect(1))) : ((Field) left).compare(comp, DSL.all(parseList(',', c -> c.parseField()).toArray(EMPTY_FIELD))) : // TODO: Support quantifiers also for rows
        new RowSubqueryCondition((Row) left, DSL.all(parseWithOrSelect(((Row) left).size())), comp) : any ? isField ? peekSelectOrWith(true) ? ((Field) left).compare(comp, DSL.any(parseWithOrSelect(1))) : ((Field) left).compare(comp, DSL.any(parseList(',', c -> c.parseField()).toArray(EMPTY_FIELD))) : // TODO: Support quantifiers also for rows
        new RowSubqueryCondition((Row) left, DSL.any(parseWithOrSelect(((Row) left).size())), comp) : isField ? ((Field) left).compare(comp, toField(parseConcat())) : new RowCondition((Row) left, parseRow(((Row) left).size(), true), comp);
        if (all || any)
            parse(')');
        return result;
    } else if (!not && parseKeywordIf("IS")) {
        not = parseKeywordIf("NOT");
        if (parseKeywordIf("NULL"))
            return not ? isField ? ((Field) left).isNotNull() : ((Row) left).isNotNull() : isField ? ((Field) left).isNull() : ((Row) left).isNull();
        else if (isField && parseKeywordIf("JSON"))
            return not ? ((Field) left).isNotJson() : ((Field) left).isJson();
        else if (isField && parseKeywordIf("DOCUMENT"))
            return not ? ((Field) left).isNotDocument() : ((Field) left).isDocument();
        not = parseKeywordIf("DISTINCT FROM") == not;
        if (left instanceof Field) {
            Field f = (Field) left;
            Field right = toField(parseConcat());
            return not ? f.isNotDistinctFrom(right) : f.isDistinctFrom(right);
        } else {
            Row right = parseRow(((Row) left).size(), true);
            return new RowIsDistinctFrom((Row) left, right, not);
        }
    } else if (!not && parseIf("@>")) {
        return toField(left).contains((Field) toField(parseConcat()));
    } else if (!forbidden.contains(FK_IN) && parseKeywordIf("IN")) {
        Condition result;
        // [#12691] Some dialects support A IN B syntax without parentheses for single element in lists
        if (isField && !peek('(')) {
            result = not ? ((Field) left).notIn(parseConcat()) : ((Field) left).in(parseConcat());
        } else {
            parse('(');
            if (peek(')'))
                result = not ? isField ? ((Field) left).notIn(EMPTY_FIELD) : new RowInCondition((Row) left, new QueryPartList<>(), true) : isField ? ((Field) left).in(EMPTY_FIELD) : new RowInCondition((Row) left, new QueryPartList<>(), false);
            else if (peekSelectOrWith(true))
                result = not ? isField ? ((Field) left).notIn(parseWithOrSelect(1)) : new RowSubqueryCondition((Row) left, parseWithOrSelect(((Row) left).size()), NOT_IN) : isField ? ((Field) left).in(parseWithOrSelect(1)) : new RowSubqueryCondition((Row) left, parseWithOrSelect(((Row) left).size()), IN);
            else
                result = not ? isField ? ((Field) left).notIn(parseList(',', c -> c.parseField())) : new RowInCondition((Row) left, new QueryPartList<>(parseList(',', c -> parseRow(((Row) left).size()))), true) : isField ? ((Field) left).in(parseList(',', c -> c.parseField())) : new RowInCondition((Row) left, new QueryPartList<>(parseList(',', c -> parseRow(((Row) left).size()))), false);
            parse(')');
        }
        return result;
    } else if (parseKeywordIf("BETWEEN")) {
        boolean symmetric = !parseKeywordIf("ASYMMETRIC") && parseKeywordIf("SYMMETRIC");
        FieldOrRow r1 = isField ? parseConcat() : parseRow(((Row) left).size());
        parseKeyword("AND");
        FieldOrRow r2 = isField ? parseConcat() : parseRow(((Row) left).size());
        return symmetric ? not ? isField ? ((Field) left).notBetweenSymmetric((Field) r1, (Field) r2) : new RowBetweenCondition((Row) left, (Row) r1, not, symmetric, (Row) r2) : isField ? ((Field) left).betweenSymmetric((Field) r1, (Field) r2) : new RowBetweenCondition((Row) left, (Row) r1, not, symmetric, (Row) r2) : not ? isField ? ((Field) left).notBetween((Field) r1, (Field) r2) : new RowBetweenCondition((Row) left, (Row) r1, not, symmetric, (Row) r2) : isField ? ((Field) left).between((Field) r1, (Field) r2) : new RowBetweenCondition((Row) left, (Row) r1, not, symmetric, (Row) r2);
    } else if (isField && (parseKeywordIf("LIKE") || parseOperatorIf("~~") || (notOp = parseOperatorIf("!~~")))) {
        if (parseKeywordIf("ANY")) {
            parse('(');
            if (peekSelectOrWith(true)) {
                Select<?> select = parseWithOrSelect();
                parse(')');
                LikeEscapeStep result = (not ^ notOp) ? ((Field) left).notLike(any(select)) : ((Field) left).like(any(select));
                return parseEscapeClauseIf(result);
            } else {
                List<Field<?>> fields;
                if (parseIf(')')) {
                    fields = emptyList();
                } else {
                    fields = parseList(',', c -> toField(parseConcat()));
                    parse(')');
                }
                Field<String>[] fieldArray = fields.toArray(new Field[0]);
                LikeEscapeStep result = (not ^ notOp) ? ((Field<String>) left).notLike(any(fieldArray)) : ((Field<String>) left).like(any(fieldArray));
                return parseEscapeClauseIf(result);
            }
        } else if (parseKeywordIf("ALL")) {
            parse('(');
            if (peekSelectOrWith(true)) {
                Select<?> select = parseWithOrSelect();
                parse(')');
                LikeEscapeStep result = (not ^ notOp) ? ((Field) left).notLike(all(select)) : ((Field) left).like(all(select));
                return parseEscapeClauseIf(result);
            } else {
                List<Field<?>> fields;
                if (parseIf(')')) {
                    fields = emptyList();
                } else {
                    fields = parseList(',', c -> toField(parseConcat()));
                    parse(')');
                }
                Field<String>[] fieldArray = fields.toArray(new Field[0]);
                LikeEscapeStep result = (not ^ notOp) ? ((Field<String>) left).notLike(all(fieldArray)) : ((Field<String>) left).like(all(fieldArray));
                return parseEscapeClauseIf(result);
            }
        } else {
            Field right = toField(parseConcat());
            LikeEscapeStep like = (not ^ notOp) ? ((Field) left).notLike(right) : ((Field) left).like(right);
            return parseEscapeClauseIf(like);
        }
    } else if (isField && (parseKeywordIf("ILIKE") || parseOperatorIf("~~*") || (notOp = parseOperatorIf("!~~*")))) {
        Field right = toField(parseConcat());
        LikeEscapeStep like = (not ^ notOp) ? ((Field) left).notLikeIgnoreCase(right) : ((Field) left).likeIgnoreCase(right);
        return parseEscapeClauseIf(like);
    } else if (isField && (parseKeywordIf("REGEXP") || parseKeywordIf("RLIKE") || parseKeywordIf("LIKE_REGEX") || parseOperatorIf("~") || (notOp = parseOperatorIf("!~")))) {
        Field right = toField(parseConcat());
        return (not ^ notOp) ? ((Field) left).notLikeRegex(right) : ((Field) left).likeRegex(right);
    } else if (isField && parseKeywordIf("SIMILAR TO")) {
        Field right = toField(parseConcat());
        LikeEscapeStep like = not ? ((Field) left).notSimilarTo(right) : ((Field) left).similarTo(right);
        return parseEscapeClauseIf(like);
    } else if (left instanceof Row && ((Row) left).size() == 2 && parseKeywordIf("OVERLAPS")) {
        Row leftRow = (Row) left;
        Row rightRow = parseRow(2);
        Row2 leftRow2 = row(leftRow.field(0), leftRow.field(1));
        Row2 rightRow2 = row(rightRow.field(0), rightRow.field(1));
        return leftRow2.overlaps(rightRow2);
    } else {
        position(p);
        return left;
    }
}

Example 2 with FieldOrRow

use of org.jooq.FieldOrRow in project jOOQ by jOOQ.

the class DefaultParseContext method parseUnaryOps.

private final FieldOrRow parseUnaryOps() {
    if (!ignoreProEdition() && parseKeywordIf("CONNECT_BY_ROOT") && requireProEdition()) {
    }
    if (parseIf('~'))
        return toField(parseUnaryOps()).bitNot();
    FieldOrRow r;
    Sign sign = parseSign();
    if (sign == Sign.NONE)
        r = parseTerm();
    else if (sign == Sign.PLUS)
        r = toField(parseTerm());
    else if ((r = parseFieldUnsignedNumericLiteralIf(Sign.MINUS)) == null)
        r = toField(parseTerm()).neg();
    if (!ignoreProEdition() && parseTokensIf('(', '+', ')') && requireProEdition())
        ;
    // [#7171] Only identifier based field expressions could have been functions
    // E.g. 'abc' ('xyz') may be some other type of syntax, e.g. from Db2 SIGNAL statements
    int p = position();
    if (r instanceof TableField && parseIf('('))
        throw exception("Unknown function");
    while (parseIf("::")) r = cast(toField(r), parseDataType());
    if (parseIf('[')) {
        r = arrayGet((Field) toField(r), (Field) parseField());
        parse(']');
    }
    r = parseMethodCallIf(r);
    return r;
}

Example 3 with FieldOrRow

use of org.jooq.FieldOrRow in project jOOQ by jOOQ.

the class DefaultParseContext method parseTuple.

private final Row parseTuple(Integer degree, boolean allowDoubleParens) {
    parse('(');
    List<? extends FieldOrRow> fieldsOrRows;
    if (allowDoubleParens)
        fieldsOrRows = parseList(',', c -> parseFieldOrRow());
    else
        fieldsOrRows = parseList(',', c -> c.parseField());
    Row row;
    if (fieldsOrRows.size() == 0)
        row = row();
    else if (fieldsOrRows.get(0) instanceof Field)
        row = row(fieldsOrRows);
    else if (fieldsOrRows.size() == 1)
        row = (Row) fieldsOrRows.get(0);
    else
        throw exception("Unsupported row size");
    if (degree != null && row.size() != degree)
        throw exception("Expected row of degree: " + degree + ". Got: " + row.size());
    parse(')');
    return row;
}

Example 4 with FieldOrRow

use of org.jooq.FieldOrRow in project jOOQ by jOOQ.

the class DefaultParseContext method parseTerm.

private final FieldOrRow parseTerm() {
    FieldOrRow field;
    Object value;
    switch(characterUpper()) {
        // [#8821] Known prefixes so far:
        case ':':
        case '@':
        case '?':
            if ((field = parseBindVariableIf()) != null)
                return field;
            break;
        case '\'':
            return inline(parseStringLiteral());
        case '$':
            if ((field = parseBindVariableIf()) != null)
                return field;
            else if ((value = parseDollarQuotedStringLiteralIf()) != null)
                return inline((String) value);
            break;
        case 'A':
            if (parseFunctionNameIf("ABS"))
                return abs((Field) parseFieldNumericOpParenthesised());
            else if (parseFunctionNameIf("ASC", "ASCII", "ASCII_VAL"))
                return ascii((Field) parseFieldParenthesised());
            else if (parseFunctionNameIf("ACOS"))
                return acos((Field) parseFieldNumericOpParenthesised());
            else if (parseFunctionNameIf("ASIN"))
                return asin((Field) parseFieldNumericOpParenthesised());
            else if (parseFunctionNameIf("ATAN", "ATN"))
                return atan((Field) parseFieldNumericOpParenthesised());
            else if (parseFunctionNameIf("ATN2", "ATAN2"))
                return parseFunctionArgs2(() -> toField(parseNumericOp()), DSL::atan2);
            else if (parseFunctionNameIf("ASCII_CHAR"))
                return chr((Field) parseFieldParenthesised());
            else if ((field = parseArrayValueConstructorIf()) != null)
                return field;
            else if (parseFunctionNameIf("ADD_YEARS"))
                return parseFieldAddDatePart(YEAR);
            else if (parseFunctionNameIf("ADD_MONTHS"))
                return parseFieldAddDatePart(MONTH);
            else if (parseFunctionNameIf("ADD_DAYS"))
                return parseFieldAddDatePart(DAY);
            else if (parseFunctionNameIf("ADD_HOURS"))
                return parseFieldAddDatePart(HOUR);
            else if (parseFunctionNameIf("ADD_MINUTES"))
                return parseFieldAddDatePart(MINUTE);
            else if (parseFunctionNameIf("ADD_SECONDS"))
                return parseFieldAddDatePart(SECOND);
            else if (parseFunctionNameIf("ARRAY_GET"))
                return parseFunctionArgs2((f1, f2) -> arrayGet(f1, f2));
            break;
        case 'B':
            if (parseFunctionNameIf("BIT_LENGTH"))
                return bitLength((Field) parseFieldParenthesised());
            else if (parseFunctionNameIf("BITCOUNT", "BIT_COUNT"))
                return bitCount((Field) parseFieldNumericOpParenthesised());
            else if (parseFunctionNameIf("BYTE_LENGTH"))
                return octetLength((Field) parseFieldParenthesised());
            else if ((field = parseFieldBitwiseFunctionIf()) != null)
                return field;
            else if ((value = parseBitLiteralIf()) != null)
                return DSL.inline((Boolean) value);
            break;
        case 'C':
            if ((field = parseFieldConcatIf()) != null)
                return field;
            else if ((parseFunctionNameIf("CURRENT_CATALOG") && parseEmptyParens()))
                return currentCatalog();
            else if ((parseFunctionNameIf("CURRENT_DATABASE") && parseEmptyParens()))
                return currentCatalog();
            else if ((parseKeywordIf("CURRENT_SCHEMA", "CURRENT SCHEMA")) && parseEmptyParensIf())
                return currentSchema();
            else if ((parseKeywordIf("CURRENT_USER", "CURRENT USER", "CURRENTUSER")) && parseEmptyParensIf())
                return currentUser();
            else if (parseFunctionNameIf("CHR", "CHAR"))
                return chr((Field) parseFieldParenthesised());
            else if (parseFunctionNameIf("CHARINDEX"))
                return parseFunctionArgs3((f1, f2) -> DSL.position(f2, f1), (f1, f2, f3) -> DSL.position(f2, f1, f3));
            else if (parseFunctionNameIf("CHAR_LENGTH"))
                return charLength((Field) parseFieldParenthesised());
            else if (parseFunctionNameIf("CARDINALITY"))
                return cardinality((Field) parseFieldParenthesised());
            else if (parseFunctionNameIf("CEILING", "CEIL"))
                return ceil((Field) parseFieldNumericOpParenthesised());
            else if (parseFunctionNameIf("COSH"))
                return cosh((Field) parseFieldNumericOpParenthesised());
            else if (parseFunctionNameIf("COS"))
                return cos((Field) parseFieldNumericOpParenthesised());
            else if (parseFunctionNameIf("COTH"))
                return coth((Field) parseFieldNumericOpParenthesised());
            else if (parseFunctionNameIf("COT"))
                return cot((Field) parseFieldNumericOpParenthesised());
            else if ((field = parseNextvalCurrvalIf(SequenceMethod.CURRVAL)) != null)
                return field;
            else if (parseFunctionNameIf("CENTURY"))
                return century(parseFieldParenthesised());
            else if ((parseKeywordIf("CURRENT_DATE") || parseKeywordIf("CURRENT DATE")) && parseEmptyParensIf())
                return currentDate();
            else if (parseKeywordIf("CURRENT_TIMESTAMP") || parseKeywordIf("CURRENT TIMESTAMP")) {
                Field<Integer> precision = null;
                if (parseIf('('))
                    if (!parseIf(')')) {
                        precision = (Field<Integer>) parseField();
                        parse(')');
                    }
                return precision != null ? currentTimestamp(precision) : currentTimestamp();
            } else if ((parseKeywordIf("CURRENT_TIME") || parseKeywordIf("CURRENT TIME")) && parseEmptyParensIf())
                return currentTime();
            else if (parseFunctionNameIf("CURDATE") && parseEmptyParens())
                return currentDate();
            else if (parseFunctionNameIf("CURTIME") && parseEmptyParens())
                return currentTime();
            else if ((field = parseFieldCaseIf()) != null)
                return field;
            else if ((field = parseFieldCastIf()) != null)
                return field;
            else if ((field = parseFieldCoalesceIf()) != null)
                return field;
            else if ((field = parseFieldCumeDistIf()) != null)
                return field;
            else if ((field = parseFieldConvertIf()) != null)
                return field;
            else if ((field = parseFieldChooseIf()) != null)
                return field;
            else if (!ignoreProEdition() && parseKeywordIf("CONNECT_BY_ISCYCLE") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseKeywordIf("CONNECT_BY_ISLEAF") && requireProEdition()) {
            }
            break;
        case 'D':
            if ((parseFunctionNameIf("DATABASE") && parseEmptyParens()))
                return currentCatalog();
            else if ((parseFunctionNameIf("DB_NAME") && parseEmptyParens()))
                return currentCatalog();
            else if ((parseFunctionNameIf("DBINFO") && parse('(') && parseStringLiteral("dbname") != null && parse(')')))
                return currentCatalog();
            else if (parseFunctionNameIf("DIGITS"))
                return digits((Field) parseFieldParenthesised());
            else if ((field = parseFieldDateLiteralIf()) != null)
                return field;
            else if ((field = parseFieldDateTruncIf()) != null)
                return field;
            else if ((field = parseFieldDateAddIf()) != null)
                return field;
            else if ((field = parseFieldDateDiffIf()) != null)
                return field;
            else if ((field = parseFieldDatePartIf()) != null)
                return field;
            else if ((field = parseFieldDenseRankIf()) != null)
                return field;
            else if (parseFunctionNameIf("DECADE"))
                return decade(parseFieldParenthesised());
            else if (parseFunctionNameIf("DAY") || parseFunctionNameIf("DAYOFMONTH"))
                return day(parseFieldParenthesised());
            else // DB2 and MySQL support the non-ISO version where weeks go from Sunday = 1 to Saturday = 7
            if (parseFunctionNameIf("DAYOFWEEK_ISO"))
                return isoDayOfWeek(parseFieldParenthesised());
            else if (parseFunctionNameIf("DAYOFWEEK") || parseFunctionNameIf("DAY_OF_WEEK"))
                return dayOfWeek(parseFieldParenthesised());
            else if (parseFunctionNameIf("DAYOFYEAR") || parseFunctionNameIf("DAY_OF_YEAR"))
                return dayOfYear(parseFieldParenthesised());
            else if (parseFunctionNameIf("DEGREES") || parseFunctionNameIf("DEGREE") || parseFunctionNameIf("DEG"))
                return deg((Field) parseFieldNumericOpParenthesised());
            else if (parseFunctionNameIf("DATALENGTH"))
                return octetLength((Field) parseFieldParenthesised());
            else if ((field = parseFieldDecodeIf()) != null)
                return field;
            else if (parseKeywordIf("DEFAULT"))
                return default_();
            break;
        case 'E':
            // [#6704] PostgreSQL E'...' escaped string literals
            if (characterNext() == '\'')
                return inline(parseStringLiteral());
            else if ((field = parseFieldExtractIf()) != null)
                return field;
            else if (parseFunctionNameIf("EXP"))
                return exp((Field) parseFieldNumericOpParenthesised());
            else if (parseFunctionNameIf("EPOCH"))
                return epoch(parseFieldParenthesised());
            break;
        case 'F':
            if (parseFunctionNameIf("FLOOR"))
                return floor((Field) parseFieldNumericOpParenthesised());
            else if ((field = parseFieldFirstValueIf()) != null)
                return field;
            else if ((field = parseFieldFieldIf()) != null)
                return field;
            break;
        case 'G':
            if (parseKeywordIf("GETDATE") && parseEmptyParens())
                return currentTimestamp();
            else if (parseFunctionNameIf("GENGUID", "GENERATE_UUID", "GEN_RANDOM_UUID") && parseEmptyParens())
                return uuid();
            else if ((field = parseFieldGreatestIf()) != null)
                return field;
            else if (!ignoreProEdition() && parseFunctionNameIf("GROUP_ID") && requireProEdition() && parseEmptyParens()) {
            } else if ((field = parseFieldGroupingIdIf()) != null)
                return field;
            else if (parseFunctionNameIf("GROUPING"))
                return grouping(parseFieldParenthesised());
            else if (!ignoreProEdition() && (parseFunctionNameIf("GEOMETRY::STGEOMFROMWKB") || parseFunctionNameIf("GEOGRAPHY::STGEOMFROMWKB")) && requireProEdition()) {
            } else if (!ignoreProEdition() && (parseFunctionNameIf("GEOMETRY::STGEOMFROMTEXT") || parseFunctionNameIf("GEOGRAPHY::STGEOMFROMTEXT")) && requireProEdition()) {
            } else
                break;
        case 'H':
            if (parseFunctionNameIf("HOUR"))
                return hour(parseFieldParenthesised());
            else if (parseFunctionNameIf("HASH_MD5"))
                return md5((Field) parseFieldParenthesised());
            else if (parseFunctionNameIf("HEX"))
                return toHex((Field) parseFieldParenthesised());
            break;
        case 'I':
            if ((field = parseFieldIntervalLiteralIf()) != null)
                return field;
            else if (parseFunctionNameIf("ISO_DAY_OF_WEEK"))
                return isoDayOfWeek(parseFieldParenthesised());
            else if (parseFunctionNameIf("INSTR"))
                return parseFunctionArgs3(DSL::position, DSL::position);
            else if (parseFunctionNameIf("INSERT"))
                return parseFunctionArgs4(DSL::insert);
            else if (parseFunctionNameIf("IFNULL"))
                return parseFunctionArgs2((f1, f2) -> ifnull((Field<?>) f1, (Field<?>) f2));
            else if (parseFunctionNameIf("ISNULL"))
                return parseFunctionArgs2(f -> field(f.isNull()), (f1, f2) -> isnull((Field<?>) f1, (Field<?>) f2));
            else if ((field = parseFieldIfIf()) != null)
                return field;
            else
                break;
        case 'J':
            if ((field = parseFieldJSONArrayConstructorIf()) != null)
                return field;
            else if ((field = parseFieldJSONObjectConstructorIf()) != null)
                return field;
            else if ((field = parseFieldJSONValueIf()) != null)
                return field;
            else if ((field = parseFieldJSONLiteralIf()) != null)
                return field;
            break;
        case 'L':
            if (parseFunctionNameIf("LOWER", "LCASE"))
                return lower((Field) parseFieldParenthesised());
            else if (parseFunctionNameIf("LPAD"))
                return parseFunctionArgs3(DSL::lpad, DSL::lpad);
            else if (parseFunctionNameIf("LTRIM"))
                return parseFunctionArgs2(DSL::ltrim, DSL::ltrim);
            else if (parseFunctionNameIf("LEFT"))
                return parseFunctionArgs2(DSL::left);
            else if (parseFunctionNameIf("LENGTH", "LEN"))
                return length((Field) parseFieldParenthesised());
            else if (parseFunctionNameIf("LENGTHB"))
                return octetLength((Field) parseFieldParenthesised());
            else if (parseFunctionNameIf("LN", "LOGN"))
                return ln((Field) parseFieldNumericOpParenthesised());
            else if (parseFunctionNameIf("LOG10"))
                return log10((Field) parseFieldNumericOpParenthesised());
            else if ((field = parseFieldLogIf()) != null)
                return field;
            else if ((field = parseFieldLocateIf()) != null)
                return field;
            else if (!ignoreProEdition() && parseKeywordIf("LEVEL") && requireProEdition()) {
            } else if (parseKeywordIf("LSHIFT"))
                return parseFunctionArgs2(() -> toField(parseNumericOp()), (f1, f2) -> shl(f1, f2));
            else if ((field = parseFieldLeastIf()) != null)
                return field;
            else if ((field = parseFieldLeadLagIf()) != null)
                return field;
            else if ((field = parseFieldLastValueIf()) != null)
                return field;
            break;
        case 'M':
            if (parseFunctionNameIf("MOD"))
                return parseFunctionArgs2(Field::mod);
            else if (parseFunctionNameIf("MICROSECOND"))
                return microsecond(parseFieldParenthesised());
            else if (parseFunctionNameIf("MILLENNIUM"))
                return millennium(parseFieldParenthesised());
            else if (parseFunctionNameIf("MILLISECOND"))
                return millisecond(parseFieldParenthesised());
            else if (parseFunctionNameIf("MINUTE"))
                return minute(parseFieldParenthesised());
            else if (parseFunctionNameIf("MONTH"))
                return month(parseFieldParenthesised());
            else if (parseFunctionNameIf("MID"))
                return parseFunctionArgs3(DSL::mid);
            else if (parseFunctionNameIf("MD5"))
                return md5((Field) parseFieldParenthesised());
            else if ((field = parseMultisetValueConstructorIf()) != null)
                return field;
            else if ((field = parseFieldGreatestIf()) != null)
                return field;
            else if ((field = parseFieldLeastIf()) != null)
                return field;
            else if ((field = parseFieldDecodeIf()) != null)
                return field;
            break;
        case 'N':
            // [#9540] N'...' NVARCHAR literals
            if (characterNext() == '\'')
                return inline(parseStringLiteral(), NVARCHAR);
            else if ((field = parseFieldNewIdIf()) != null)
                return field;
            else if (parseFunctionNameIf("NVL2"))
                return parseFunctionArgs3((f1, f2, f3) -> nvl2((Field<?>) f1, (Field<?>) f2, (Field<?>) f3));
            else if (parseFunctionNameIf("NVL"))
                return parseFunctionArgs2((f1, f2) -> nvl((Field<?>) f1, (Field<?>) f2));
            else if (parseFunctionNameIf("NULLIF"))
                return parseFunctionArgs2((f1, f2) -> nullif((Field<?>) f1, (Field<?>) f2));
            else if ((field = parseFieldNtileIf()) != null)
                return field;
            else if ((field = parseFieldNthValueIf()) != null)
                return field;
            else if ((field = parseNextValueIf()) != null)
                return field;
            else if ((field = parseNextvalCurrvalIf(SequenceMethod.NEXTVAL)) != null)
                return field;
            else if (parseFunctionNameIf("NOW") && parse('(')) {
                if (parseIf(')'))
                    return now();
                Field<Integer> precision = (Field<Integer>) parseField();
                parse(')');
                return now(precision);
            }
            break;
        case 'O':
            if (parseFunctionNameIf("OREPLACE"))
                return parseFunctionArgs3(DSL::replace, DSL::replace);
            else if ((field = parseFieldOverlayIf()) != null)
                return field;
            else if ((field = parseFieldTranslateIf()) != null)
                return field;
            else if (parseFunctionNameIf("OCTET_LENGTH"))
                return octetLength((Field) parseFieldParenthesised());
            break;
        case 'P':
            if ((field = parseFieldPositionIf()) != null)
                return field;
            else if ((field = parseFieldPercentRankIf()) != null)
                return field;
            else if (parseFunctionNameIf("POWER", "POW"))
                return parseFunctionArgs2(() -> toField(parseNumericOp()), DSL::power);
            else if (parseFunctionNameIf("PI") && parseEmptyParens())
                return pi();
            else if (!ignoreProEdition() && parseKeywordIf("PRIOR") && requireProEdition()) {
            }
            break;
        case 'Q':
            if (characterNext() == '\'')
                return inline(parseStringLiteral());
            else if (parseFunctionNameIf("QUARTER"))
                return quarter(parseFieldParenthesised());
        case 'R':
            if (parseFunctionNameIf("REPLACE"))
                return parseFunctionArgs3(DSL::replace, DSL::replace);
            else if ((field = parseFieldRegexpReplaceIf()) != null)
                return field;
            else if (parseFunctionNameIf("REPEAT", "REPLICATE"))
                return parseFunctionArgs2(DSL::repeat);
            else if (parseFunctionNameIf("REVERSE"))
                return reverse((Field) parseFieldParenthesised());
            else if (parseFunctionNameIf("RPAD"))
                return parseFunctionArgs3(DSL::rpad, DSL::rpad);
            else if (parseFunctionNameIf("RTRIM"))
                return parseFunctionArgs2(DSL::rtrim, DSL::rtrim);
            else if (parseFunctionNameIf("RIGHT"))
                return parseFunctionArgs2(DSL::right);
            else if (parseFunctionNameIf("RANDOM_UUID") && parseEmptyParens())
                return uuid();
            else if (parseFunctionNameIf("ROW_NUMBER") && parseEmptyParens())
                return parseWindowFunction(null, null, rowNumber());
            else if ((field = parseFieldRankIf()) != null)
                return field;
            else if ((field = parseFieldRoundIf()) != null)
                return field;
            else if (!ignoreProEdition() && parseKeywordIf("ROWNUM") && requireProEdition()) {
            } else if (parseFunctionNameIf("RADIANS") || parseFunctionNameIf("RADIAN") || parseFunctionNameIf("RAD"))
                return rad((Field) parseFieldNumericOpParenthesised());
            else if (parseFunctionNameIf("RAND", "RANDOM") && parseEmptyParens())
                return rand();
            else if (parseFunctionNameIf("RATIO_TO_REPORT"))
                return parseFunctionArgs1(f -> parseWindowFunction(null, null, ratioToReport(f)));
            else if (parseKeywordIf("RSHIFT"))
                return parseFunctionArgs2(() -> toField(parseNumericOp()), (f1, f2) -> shr(f1, f2));
            else if (parseFunctionNameIf("ROW"))
                return parseTuple();
            break;
        case 'S':
            if ((field = parseFieldSubstringIf()) != null)
                return field;
            else if (parseFunctionNameIf("SUBSTRING_INDEX"))
                return parseFunctionArgs3(DSL::substringIndex);
            else if (parseFunctionNameIf("SPACE"))
                return space((Field) parseFieldParenthesised());
            else if (parseFunctionNameIf("SPLIT_PART"))
                return parseFunctionArgs3(DSL::splitPart);
            else if (parseFunctionNameIf("STR_REPLACE"))
                return parseFunctionArgs3(DSL::replace, DSL::replace);
            else if (parseFunctionNameIf("SCHEMA") && parseEmptyParensIf())
                return currentSchema();
            else if (parseFunctionNameIf("STRREVERSE"))
                return reverse((Field) parseFieldParenthesised());
            else if (parseFunctionNameIf("SYSUUID") && parseEmptyParensIf())
                return uuid();
            else if (parseFunctionNameIf("SECOND"))
                return second(parseFieldParenthesised());
            else if (!ignoreProEdition() && parseFunctionNameIf("SEQ4", "SEQ8") && parseEmptyParens() && requireProEdition()) {
            } else if (parseFunctionNameIf("SIGN", "SGN"))
                return sign((Field) parseFieldParenthesised());
            else if (parseFunctionNameIf("SQRT", "SQR"))
                return sqrt((Field) parseFieldNumericOpParenthesised());
            else if (parseFunctionNameIf("SQUARE"))
                return square((Field) parseFieldNumericOpParenthesised());
            else if (parseFunctionNameIf("SINH"))
                return sinh((Field) parseFieldNumericOpParenthesised());
            else if (parseFunctionNameIf("SIN"))
                return sin((Field) parseFieldNumericOpParenthesised());
            else if (parseKeywordIf("SHL", "SHIFTLEFT"))
                return parseFunctionArgs2(() -> toField(parseNumericOp()), (f1, f2) -> shl(f1, f2));
            else if (parseKeywordIf("SHR", "SHIFTRIGHT"))
                return parseFunctionArgs2(() -> toField(parseNumericOp()), (f1, f2) -> shr(f1, f2));
            else if ((field = parseFieldSysConnectByPathIf()) != null)
                return field;
            else if (!ignoreProEdition() && parseFunctionNameIf("ST_AREA") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("SDO_GEOM.SDO_AREA") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_ASBINARY") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_ASTEXT") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_CENTROID") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("SDO_GEOM.SDO_CENTROID") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_DIFFERENCE") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("SDO_GEOM.SDO_DIFFERENCE") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_DISTANCE") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("SDO_GEOM.SDO_DISTANCE") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_ENDPOINT") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_EXTERIORRING") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_GEOMETRYN") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_GEOMETRYTYPE") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_GEOMFROMWKB") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_GEOMFROMTEXT", "SDO_GEOMETRY") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_INTERIORRINGN") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_INTERSECTION") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("SDO_GEOM.SDO_INTERSECTION") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_LENGTH") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("SDO_GEOM.SDO_LENGTH") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_NUMINTERIORRING", "ST_NUMINTERIORRINGS") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_NUMGEOMETRIES", "SDO_UTIL.GETNUMELEM") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_NUMPOINTS") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_POINTN") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_SRID") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_STARTPOINT") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_UNION") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("SDO_GEOM.SDO_UNION") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_X") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_Y") && requireProEdition()) {
            } else if (!ignoreProEdition() && parseFunctionNameIf("ST_Z") && requireProEdition()) {
            }
            break;
        case 'T':
            if ((field = parseBooleanValueExpressionIf()) != null)
                return field;
            else if ((field = parseFieldTrimIf()) != null)
                return field;
            else if ((field = parseFieldTranslateIf()) != null)
                return field;
            else if (parseFunctionNameIf("TO_CHAR"))
                return parseFunctionArgs2(DSL::toChar, DSL::toChar);
            else if (parseFunctionNameIf("TO_HEX"))
                return toHex((Field) parseFieldParenthesised());
            else if (parseFunctionNameIf("TANH"))
                return tanh((Field) parseFieldNumericOpParenthesised());
            else if (parseFunctionNameIf("TAN"))
                return tan((Field) parseFieldNumericOpParenthesised());
            else if (parseFunctionNameIf("TO_NUMBER"))
                return parseFunctionArgs1(f -> cast(f, NUMERIC));
            else if (parseFunctionNameIf("TIMEZONE_HOUR"))
                return timezoneHour(parseFieldParenthesised());
            else if (parseFunctionNameIf("TIMEZONE_MINUTE"))
                return timezoneMinute(parseFieldParenthesised());
            else if (parseFunctionNameIf("TIMEZONE"))
                return timezone(parseFieldParenthesised());
            else if ((field = parseFieldTimestampLiteralIf()) != null)
                return field;
            else if ((field = parseFieldTimeLiteralIf()) != null)
                return field;
            else if (parseFunctionNameIf("TO_DATE"))
                return parseFunctionArgs2(f1 -> toDate(f1, inline(settings().getParseDateFormat())), DSL::toDate);
            else if (parseFunctionNameIf("TO_TIMESTAMP"))
                return parseFunctionArgs2(f1 -> toTimestamp(f1, inline(settings().getParseTimestampFormat())), DSL::toTimestamp);
            else if (parseFunctionNameIf("TIMESTAMPDIFF"))
                return parseFunctionArgs2((f1, f2) -> DSL.timestampDiff(f1, f2));
            else if ((field = parseFieldTruncIf()) != null)
                return field;
            break;
        case 'U':
            if (parseFunctionNameIf("UPPER", "UCASE"))
                return DSL.upper((Field) parseFieldParenthesised());
            else if (parseFunctionNameIf("UUID", "UUID_GENERATE", "UUID_STRING") && parseEmptyParens())
                return uuid();
            else if (parseFunctionNameIf("UNIX_TIMESTAMP"))
                return epoch(parseFieldParenthesised());
            break;
        case 'W':
            if (parseFunctionNameIf("WIDTH_BUCKET"))
                return parseFunctionArgs4((f1, f2, f3, f4) -> widthBucket(f1, f2, f3, f4));
            else if (parseFunctionNameIf("WEEK"))
                return week(parseFieldParenthesised());
            break;
        case 'X':
            if ((value = parseBinaryLiteralIf()) != null)
                return inline((byte[]) value);
            else if (parseFunctionNameIf("XMLCOMMENT"))
                return xmlcomment((Field) parseField());
            else if ((field = parseFieldXMLConcatIf()) != null)
                return field;
            else if ((field = parseFieldXMLElementIf()) != null)
                return field;
            else if ((field = parseFieldXMLPIIf()) != null)
                return field;
            else if ((field = parseFieldXMLForestIf()) != null)
                return field;
            else if ((field = parseFieldXMLParseIf()) != null)
                return field;
            else if ((field = parseFieldXMLDocumentIf()) != null)
                return field;
            else if ((field = parseFieldXMLQueryIf()) != null)
                return field;
            else if ((field = parseFieldXMLSerializeIf()) != null)
                return field;
            break;
        case 'Y':
            if (parseFunctionNameIf("YEAR"))
                return year(parseFieldParenthesised());
            break;
        case 'Z':
            if (parseFunctionNameIf("ZEROIFNULL"))
                return coalesce(parseFieldParenthesised(), zero());
            break;
        case '0':
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
        case '-':
        case '.':
            if ((field = parseFieldUnsignedNumericLiteralIf(Sign.NONE)) != null)
                return field;
            break;
        case '{':
            parse('{', false);
            switch(characterUpper()) {
                case 'D':
                    parseKeyword("D");
                    field = inline(parseDateLiteral());
                    break;
                case 'F':
                    parseKeyword("FN");
                    // TODO: Limit the supported expressions in this context to the ones specified here:
                    // http://download.oracle.com/otn-pub/jcp/jdbc-4_2-mrel2-eval-spec/jdbc4.2-fr-spec.pdf
                    field = parseTerm();
                    break;
                case 'T':
                    if (parseKeywordIf("TS")) {
                        field = inline(parseTimestampLiteral());
                    } else {
                        parseKeyword("T");
                        field = inline(parseTimeLiteral());
                    }
                    break;
                default:
                    throw exception("Unsupported JDBC escape literal");
            }
            parse('}');
            return field;
        case '(':
            // A term parenthesis can mark the beginning of any of:
            // - ROW expression without ROW keyword:        E.g. (1, 2)
            // - Parenthesised field expression:            E.g. (1 + 2)
            // - A correlated subquery:                     E.g. (select 1)
            // - A correlated subquery with nested set ops: E.g. ((select 1) except (select 2))
            // - A combination of the above:                E.g. ((select 1) + 2, ((select 1) except (select 2)) + 2)
            int p = position();
            EnumSet fk = forbidden;
            try {
                if (!forbidden.isEmpty())
                    forbidden = EnumSet.noneOf(FunctionKeyword.class);
                FieldOrRow r = parseScalarSubqueryIf();
                if (r != null)
                    return r;
                parse('(');
                r = parseFieldOrRow();
                List<Field<?>> list = null;
                if (r instanceof Field) {
                    Field<?> f = (Field<?>) r;
                    while (parseIf(',')) {
                        if (list == null) {
                            list = new ArrayList<>();
                            list.add(f);
                        }
                        // TODO Allow for nesting ROWs
                        list.add(parseField());
                    }
                }
                parse(')');
                return list != null ? row(list) : r;
            } finally {
                forbidden = fk;
            }
    }
    if ((field = parseAggregateFunctionIf()) != null)
        return field;
    else if ((field = parseBooleanValueExpressionIf()) != null)
        return field;
    else
        return parseFieldNameOrSequenceExpression();
}