| /* |
| * Copyright (c) 2006, 2021 Oracle and/or its affiliates. All rights reserved. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0 which is available at |
| * http://www.eclipse.org/legal/epl-2.0, |
| * or the Eclipse Distribution License v. 1.0 which is available at |
| * http://www.eclipse.org/org/documents/edl-v10.php. |
| * |
| * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause |
| */ |
| |
| // Contributors: |
| // Oracle - initial API and implementation |
| // |
| package org.eclipse.persistence.jpa.jpql; |
| |
| /** |
| * This "parser/scanner" holds onto the string version of the JPQL query that is parsed into a |
| * parsed tree. It uses a cursor that lets the current {@link |
| * org.eclipse.persistence.jpa.jpql.parser.Expression Expression} object to parse its fragment of the query. |
| * <p> |
| * Provisional API: This interface is part of an interim API that is still under development and |
| * expected to change significantly before reaching stability. It is available at this early stage |
| * to solicit feedback from pioneering adopters on the understanding that any code that uses this |
| * API will almost certainly be broken (repeatedly) as the API evolves. |
| * |
| * @version 2.5.1 |
| * @since 2.3 |
| * @author Pascal Filion |
| */ |
| public final class WordParser { |
| |
| /** |
| * The current position of the cursor within the JPQL query. |
| */ |
| private int cursor; |
| |
| /** |
| * The length of the JPQL query. |
| */ |
| private final int length; |
| |
| /** |
| * The string representation of the JPQL query. |
| */ |
| private final CharSequence text; |
| |
| /** |
| * When {@link WordParser#word()}, {@link WordParser#wordEndPosition()}, or {@link |
| * WordParser#wordEndPosition(int)} is called, this is updated to reflect the type of word that |
| * is scanned. |
| * |
| * @since 2.4 |
| */ |
| private WordType wordType; |
| |
| /** |
| * Creates a new <code>WordParser</code>. |
| * |
| * @param text The string representation of the JPQL query |
| */ |
| public WordParser(CharSequence text) { |
| super(); |
| this.cursor = 0; |
| this.text = text; |
| this.length = text.length(); |
| this.wordType = WordType.UNDEFINED; |
| } |
| |
| /** |
| * Retrieves the character at the current cursor position. |
| * |
| * @return The character retrieved from the string at the current cursor position or '\0' if the |
| * position is beyond the end of the text |
| */ |
| public char character() { |
| return character(cursor); |
| } |
| |
| /** |
| * Retrieves the character at the given cursor position. |
| * |
| * @param position The position of the character to return |
| * @return The character retrieved from the string at the given position or '\0' if the position |
| * is beyond the end of the text |
| */ |
| public char character(int position) { |
| return (position >= length) ? '\0' : text.charAt(position); |
| } |
| |
| /** |
| * Determines whether the query ends with the given suffix and the end position is the end of the |
| * range for testing. |
| * |
| * @param endPosition The position where the check stops |
| * @param suffix The suffix is the text that is used to match it with the substring within the text |
| * @return <code>true</code> if the character sequence represented by the argument is a suffix of |
| * the query; <code>false</code> otherwise |
| */ |
| public boolean endsWith(int endPosition, String suffix) { |
| return startsWith(suffix, endPosition - suffix.length()); |
| } |
| |
| /** |
| * Determines whether the query ends with the given suffix and the end position is the end of the |
| * range for testing. The case of the character is ignored. |
| * |
| * @param endPosition The position where the check stops |
| * @param suffix The suffix is the text that is used to match it with the substring within the text |
| * @return <code>true</code> if the character sequence represented by the argument is a suffix of |
| * the query; <code>false</code> otherwise |
| * @since 2.5 |
| */ |
| public boolean endsWithIgnoreCase(int endPosition, String suffix) { |
| return startsWithIgnoreCase(suffix, endPosition - suffix.length()); |
| } |
| |
| /** |
| * Retrieves a word starting at the current position. The text before and after the position will |
| * be part of the returned value. |
| * <p> |
| * For instance, "<b>SELECT</b> <b>AVG</b>(e.age) <b>FROM</b> Employee e": |
| * <ul> |
| * <li>Position 3, result is "SELECT"; |
| * <li>Position 6, result is "SELECT"; |
| * <li>Position 7, result is an empty string. |
| * <li>Position 11, result is an empty string. |
| * <li>Position 13, result is "e.". |
| * </ul> |
| * |
| * @return The word in which the cursor is |
| */ |
| public String entireWord() { |
| return entireWord(cursor); |
| } |
| |
| /** |
| * Retrieves a word starting at the given position. The text before and after the position will |
| * be part of the returned value. |
| * <p> |
| * For instance, "<b>SELECT</b> <b>AVG</b>(e.age) <b>FROM</b> Employee e": |
| * <ul> |
| * <li>Position 3, result is "SELECT"; |
| * <li>Position 6, result is "SELECT"; |
| * <li>Position 7, result is an empty string. |
| * <li>Position 11, result is an empty string. |
| * <li>Position 13, result is "e.". |
| * </ul> |
| * |
| * @param position The position where to retrieve the word |
| * @return The word in which the cursor is |
| */ |
| public String entireWord(int position) { |
| int startPosition = partialWordStartPosition(position); |
| int endPosition = wordEndPosition(position); |
| return substring(startPosition, endPosition); |
| } |
| |
| /** |
| * Returns what the type of word {@link #word()} returns. |
| * |
| * @return The category of the word returned by {@link #word()} |
| * @since 2.4 |
| */ |
| public WordType getWordType() { |
| return wordType; |
| } |
| |
| /** |
| * Determines whether the given character is an arithmetic symbol, which is one of the following: |
| * { {@literal '>', '<', '/', '*', '-', '+', '=', '{'} }. |
| * |
| * @param character The character to test if it's a math symbol |
| * @return <code>true</code> if the given character is one of the valid math symbols; |
| * <code>false</code> otherwise |
| */ |
| public boolean isArithmeticSymbol(char character) { |
| return character == '>' || |
| character == '!' || |
| character == '<' || |
| character == '/' || |
| character == '*' || |
| character == '-' || |
| character == '+' || |
| character == '=' || |
| character == '{'; |
| } |
| |
| /** |
| * Determines whether the given character is a delimiter. The delimiter are '(', ')' and ','. |
| * |
| * @param character The character to test |
| * @return <code>true</code> if the given character is a delimiter; <code>false</code> otherwise |
| */ |
| public boolean isDelimiter(char character) { |
| return character == '(' || |
| character == ')' || |
| character == ','; |
| } |
| |
| /** |
| * Determines whether the given character is a character that can be used in a number. This only |
| * includes the numeric characters [0, 9] and the period character. This method should only be |
| * used to determine if a word starts with a digit character. |
| * |
| * @param character The character to test if it's a digit |
| * @return <code>true</code> if the given character is a digit; <code>false</code> otherwise |
| */ |
| public boolean isDigit(char character) { |
| return (character == '.') || Character.isDigit(character); |
| } |
| |
| /** |
| * Determines whether the position of the cursor is at the end of the text. |
| * |
| * @return <code>true</code> if the position of the cursor is at the end of the text; |
| * <code>false</code> otherwise |
| */ |
| public boolean isTail() { |
| return cursor >= length; |
| } |
| |
| /** |
| * Determines whether the given character is not considered to be part of a word (which is |
| * usually comprise of alphanumeric characters). |
| * |
| * @param character The character used to determine if it should be part of a word or not |
| * @return <code>true</code> if the character can be part of a word; <code>false</code> if it is |
| * not an alphanumeric character, which usually means is a whitespace, a delimiter or an |
| * arithmetic symbol |
| * @see Character#isWhitespace(char) |
| * @see #isArithmeticSymbol(char) |
| * @see #isDelimiter(char) |
| */ |
| public boolean isWordSeparator(char character) { |
| return Character.isWhitespace(character) || |
| isDelimiter(character) || |
| isArithmeticSymbol(character); |
| } |
| |
| /** |
| * Returns the length of the string value. |
| * |
| * @return The total count of characters |
| */ |
| public int length() { |
| return length; |
| } |
| |
| /** |
| * Moves the position of the cursor by the length of the given word. |
| * |
| * @param word The word used to determine how much to move the position forward |
| */ |
| public void moveBackward(CharSequence word) { |
| cursor -= word.length(); |
| } |
| |
| /** |
| * Moves backward the position of the cursor by the given amount. |
| * |
| * @param position The amount to remove from the current position |
| */ |
| public void moveBackward(int position) { |
| cursor -= position; |
| } |
| |
| /** |
| * Moves the position of the cursor by the length of the given word. |
| * |
| * @param word The word used to determine how much to move the position forward |
| * @return The actual portion of the text that was skipped |
| */ |
| public String moveForward(CharSequence word) { |
| return moveForward(word.length()); |
| } |
| |
| /** |
| * Moves forward the position of the cursor by the given amount. |
| * |
| * @param position The amount to add to the current position |
| * @return The actual portion of the text that was skipped |
| */ |
| public String moveForward(int position) { |
| String word = substring(cursor, cursor + position); |
| cursor += position; |
| return word; |
| } |
| |
| /** |
| * Moves the position of the cursor by the length of the given word and ignore any different in |
| * whitespace count. If the text has more than one whitespace and the given word usually has one, |
| * then only one will be part of the returned substring. |
| * |
| * @param word The word used to determine how much to move the position forward |
| * @return The actual portion of the text that was skipped |
| * @since 2.4.3 |
| */ |
| public String moveForwardIgnoreWhitespace(CharSequence word) { |
| |
| StringBuilder sb = new StringBuilder(); |
| int pc = word.length(); |
| int po = 0; |
| |
| while (--pc >= 0) { |
| |
| char c1 = text.charAt(cursor++); |
| char c2 = word.charAt(po++); |
| |
| // Handle testing |
| // 1. "... GROUP BY" and "GROUP BY" |
| // 2. "... GROUP\nBY" and "GROUP BY" |
| if (Character.isWhitespace(c1)) { |
| |
| if (Character.isWhitespace(c2)) { |
| sb.append(' '); |
| continue; |
| } |
| |
| pc++; |
| po--; |
| continue; |
| } |
| |
| sb.append(c1); |
| } |
| |
| return sb.toString(); |
| } |
| |
| /** |
| * Retrieves the numeric literal that should be the current word to parse. |
| * |
| * @return The numeric literal value |
| */ |
| public String numericLiteral() { |
| return substring(cursor, scanNumericLiteral(cursor)); |
| } |
| |
| /** |
| * Retrieves a word before the current position of the cursor, which determines when the parsing |
| * stop. |
| * <p> |
| * For instance, "<b>SELECT</b> <b>AVG</b>(e.age) <b>FROM</b> Employee e": |
| * <ul> |
| * <li>Position 3, result is "SEL"; |
| * <li>Position 6, result is "SELECT"; |
| * <li>Position 7, result is an empty string. |
| * <li>Position 11, result is an empty string. |
| * <li>Position 13, result is "e.". |
| * </ul> |
| * |
| * @return The sub-string that is before the position |
| */ |
| public String partialWord() { |
| int startIndex = partialWordStartPosition(cursor); |
| return substring(startIndex, cursor); |
| } |
| |
| /** |
| * Retrieves a word before the specified position, which determines when the parsing stop. |
| * <p> |
| * For instance, "<b>SELECT</b> <b>AVG</b>(e.age) <b>FROM</b> Employee e": |
| * <ul> |
| * <li>Position 3, result is "SEL"; |
| * <li>Position 6, result is "SELECT"; |
| * <li>Position 7, result is an empty string. |
| * <li>Position 11, result is an empty string. |
| * <li>Position 13, result is "e.". |
| * </ul> |
| * |
| * @param position The position of the cursor |
| * @return The sub-string that is before the position |
| */ |
| public String partialWord(int position) { |
| int startIndex = partialWordStartPosition(position); |
| return substring(startIndex, position); |
| } |
| |
| /** |
| * Finds the beginning of the word and the given position is within that word. |
| * <p> |
| * For instance, "<b>SELECT</b> <b>AVG</b>(e.age) <b>FROM</b> Employee e": |
| * <ul> |
| * <li>Position 3, result is 0; |
| * <li>Position 8, result is 7; |
| * </ul> |
| * |
| * @param position The position from which the search ends |
| * @return The position, which is a smaller number or equal, than the given position |
| */ |
| public int partialWordStartPosition(int position) { |
| |
| int startIndex = position; |
| |
| for (int index = position; --index >= 0; ) { |
| char character = text.charAt(index); |
| |
| if (Character.isWhitespace(character) || |
| isDelimiter(character) || |
| isArithmeticSymbol(character)) { |
| |
| break; |
| } |
| |
| startIndex--; |
| } |
| |
| return startIndex; |
| } |
| |
| /** |
| * Returns the current position of the cursor. |
| * |
| * @return The current position of the cursor |
| */ |
| public int position() { |
| return cursor; |
| } |
| |
| private int scanNumericLiteral(int startPosition) { |
| |
| int endIndex = startPosition; |
| boolean digitParsed = false; |
| boolean dotParsed = false; |
| |
| for (; endIndex < length; endIndex++) { |
| char character = text.charAt(endIndex); |
| |
| // Usual digit |
| if (character >= '0' && character <= '9') { |
| digitParsed = true; |
| } |
| // The arithmetic sign before the number |
| else if ((character == '+' || character == '-')) { |
| |
| // '+' or '-' is only valid at the beginning of the literal |
| if (endIndex > startPosition) { |
| break; |
| } |
| } |
| // The separator of integer and decimal values |
| else if (character == '.') { |
| |
| // A '.' was already parsed, it is not a valid numeric literal |
| if (dotParsed) { |
| endIndex = startPosition + 1; |
| wordType = WordType.WORD; |
| break; |
| } |
| |
| dotParsed = true; |
| } |
| // Hexadecimal value |
| else if (character == 'x') { |
| boolean powerParsed = false; |
| |
| for (; endIndex < length; endIndex++) { |
| character = text.charAt(endIndex); |
| |
| if (character == 'p' || character == 'P') { |
| powerParsed = true; |
| } |
| else if (powerParsed && (character == '+' || character == '-')) { |
| continue; |
| } |
| else if (isWordSeparator(character)) { |
| break; |
| } |
| } |
| |
| break; |
| } |
| // Parse the exponent |
| else if (character == 'e' || character == 'E') { |
| |
| if (!digitParsed) { |
| wordType = WordType.WORD; |
| break; |
| } |
| |
| for (int index = ++endIndex; index < length; index++) { |
| character = text.charAt(index); |
| |
| // The first character can be '+', '-' or a number |
| if ((index == endIndex) && (character == '-' || character == '+') || |
| character >= '0' && character <= '9') { |
| |
| endIndex++; |
| continue; |
| } |
| |
| if (character == '.') { |
| wordType = WordType.WORD; |
| } |
| |
| // If it is not a character like '(', then it's not a valid number |
| if (isWordSeparator(character)) { |
| break; |
| } |
| |
| endIndex++; |
| } |
| |
| break; |
| } |
| // A float/double or long number |
| else if (character == 'f' || character == 'F' || |
| character == 'd' || character == 'D' || |
| character == 'l' || character == 'L') { |
| |
| // A single arithmetic symbol |
| // Example: "-LENGTH..." -> "-" |
| if (!digitParsed) { |
| wordType = WordType.WORD; |
| break; |
| } |
| |
| endIndex++; |
| |
| // End of the text |
| if (endIndex == length) { |
| break; |
| } |
| |
| character = text.charAt(endIndex); |
| |
| // Done parsing the numeric literal |
| if (isWordSeparator(character)) { |
| break; |
| } |
| } |
| // Example: "-AVG..." -> "-" |
| else if (!digitParsed && Character.isJavaIdentifierPart(character)) { |
| wordType = WordType.WORD; |
| break; |
| } |
| // Done parsing the numeric literal |
| else if (isWordSeparator(character)) { |
| break; |
| } |
| } |
| |
| return endIndex; |
| } |
| |
| /** |
| * Retrieves the first word from the given text starting at the specified position. |
| * |
| * @param startPosition the current position that will be used to parse the literal |
| * @return The first word contained in the text, if none could be found, then an empty string is |
| * returned |
| */ |
| private int scanStringLiteral(int startPosition) { |
| |
| int endIndex = startPosition; |
| char startQuote = text.charAt(endIndex); |
| |
| for (endIndex++; endIndex < length; endIndex++) { |
| |
| char character = text.charAt(endIndex); |
| |
| if (character == startQuote) { |
| endIndex++; |
| |
| // Verify the single quote is escaped with another single quote |
| if ((startQuote == '\'') && (endIndex < length)) { |
| char nextCharacter = text.charAt(endIndex); |
| |
| // The single quote is escaped, continue |
| if (nextCharacter == '\'') { |
| continue; |
| } |
| } |
| // Verify the double quote is escaped with backslash |
| else if ((startQuote == '\"') && (endIndex - 2 > startPosition)) { |
| char previousCharacter = text.charAt(endIndex - 2); |
| |
| // The double quote is escaped, continue |
| if (previousCharacter == '\\') { |
| continue; |
| } |
| } |
| |
| // Reached the end of the string literal |
| break; |
| } |
| } |
| |
| return endIndex; |
| } |
| |
| /** |
| * Manually sets the position of the cursor within the string. If the position is a negative |
| * number, the position will be 0. |
| * |
| * @param position The new position of the cursor |
| */ |
| public void setPosition(int position) { |
| this.cursor = (position < 0) ? 0 : position; |
| } |
| |
| /** |
| * Removes the whitespace that starts the given text. |
| * |
| * @return The number of whitespace removed |
| */ |
| public int skipLeadingWhitespace() { |
| |
| int count = 0; |
| |
| while (cursor < length) { |
| |
| char character = text.charAt(cursor); |
| if (!Character.isWhitespace(character)) { |
| break; |
| } |
| |
| cursor++; |
| count++; |
| } |
| |
| return count; |
| } |
| |
| /** |
| * Determines whether the text starts with the given character. The case of the character is not |
| * ignored. |
| * |
| * @param possibleCharacter The possible character at the current position |
| * @return <code>true</code> if the text starts with the given character at the current position; |
| * <code>false</code> otherwise |
| */ |
| public boolean startsWith(char possibleCharacter) { |
| return possibleCharacter == character(); |
| } |
| |
| /** |
| * Tests whether the query starts with the specified prefix from the current position. |
| * |
| * @param prefix The prefix |
| * @return <code>true</code> if the character sequence represented by the argument is a prefix of |
| * the text; <code>false</code> otherwise |
| */ |
| public boolean startsWith(CharSequence prefix) { |
| return startsWith(prefix, cursor); |
| } |
| |
| /** |
| * Tests whether the substring of the query beginning at the specified index starts with the |
| * specified prefix. |
| * |
| * @param prefix The prefix |
| * @param startIndex Where to begin looking in the query |
| * @return <code>true</code> if the character sequence represented by the |
| * argument is a prefix of the substring of this object starting at index <code>startIndex</code>; |
| * <code>false</code> otherwise |
| */ |
| public boolean startsWith(CharSequence prefix, int startIndex) { |
| |
| int prefixLength = prefix.length(); |
| |
| // Note: startIndex might be near -1 >>> 1 |
| if ((startIndex < 0) || (startIndex > length - prefixLength)) { |
| return false; |
| } |
| |
| int prefixIndex = 0; |
| |
| while (--prefixLength >= 0) { |
| if (text.charAt(startIndex++) != prefix.charAt(prefixIndex++)) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Determines whether the character at the current position is one of the arithmetic operators: |
| * { '+', '-', '*', '/' }, |
| * |
| * @return <code>true</code> if the character at the current position is an arithmetic operator; |
| * <code>false</code> otherwise |
| */ |
| public boolean startsWithArithmeticOperator() { |
| |
| char character = text.charAt(cursor); |
| |
| return (character == '+') || |
| (character == '/') || |
| (character == '-') || |
| (character == '*'); |
| } |
| |
| /** |
| * Determines if the text starts with a digit (<code>true</code>), an arithmetic term |
| * (<code>false</code>) or anything else (<code>null</code>). |
| * |
| * @return <code>true</code> if the text starts with a digit (we'll assume it is a digit if the |
| * text starts with a digit or an arithmetic sign followed by a digit), <code>false</code> if it |
| * starts with an arithmetic term (we'll assume it is a digit followed by a non-digit character); |
| * otherwise returns <code>null</code> |
| */ |
| public Boolean startsWithDigit() { |
| |
| char character = character(); |
| |
| // Check if the first character is either '+' or '-' and make sure it's not used for a numeric |
| // value, which in that case, a numeric value will be created |
| if (character == '-' || |
| character == '+') { |
| |
| moveForward(1); |
| int count = skipLeadingWhitespace(); |
| character = character(cursor); |
| moveBackward(count + 1); |
| |
| if (isDigit(character)) { |
| return Boolean.TRUE; |
| } |
| |
| if (character == '-' || |
| character == '+' || |
| character == '*' || |
| character == '/') { |
| |
| return null; |
| } |
| |
| return Boolean.FALSE; |
| } |
| |
| if (character == '.') { |
| return isDigit(character(cursor + 1)); |
| } |
| |
| if (isDigit(character)) { |
| return Boolean.TRUE; |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Determines whether the text at the current position start with the following identifier. |
| * |
| * @param identifier The JPQL identifier to match with the text at the current position |
| * @return <code>true</code> if the text starts with the given text (case is ignored) and the |
| * cursor is at the end of the text or is following by a word separator character; <code>false</code> |
| * otherwise |
| */ |
| public boolean startsWithIdentifier(CharSequence identifier) { |
| return startsWithIdentifier(identifier, cursor); |
| } |
| |
| /** |
| * Determines whether the text at the current position start with the following identifier. |
| * |
| * @param identifier The JPQL identifier to match with the text at the current position |
| * @param position The position to start matching the characters |
| * @return <code>true</code> if the text starts with the given text (case is ignored) and the |
| * cursor is at the end of the text or is following by a word separator character; <code>false</code> |
| * otherwise |
| */ |
| public boolean startsWithIdentifier(CharSequence identifier, int position) { |
| |
| int pc = identifier.length(); |
| |
| // Note: offset might be near -1 >>> 1 |
| if ((position < 0) || (position > length - pc)) { |
| return false; |
| } |
| |
| int po = 0; |
| int to = position; |
| |
| while (--pc >= 0) { |
| |
| char c1 = text.charAt(to++); |
| char c2 = identifier.charAt(po++); |
| |
| if (c1 == c2) { |
| continue; |
| } |
| |
| // Handle testing |
| // 1. "... GROUP BY" and "GROUP BY" |
| // 2. "... GROUP\nBY" and "GROUP BY" |
| if (Character.isWhitespace(c1)) { |
| |
| if (Character.isWhitespace(c2)) { |
| continue; |
| } |
| |
| if (to == length) { |
| return false; |
| } |
| |
| pc++; |
| po--; |
| continue; |
| } |
| |
| // If characters don't match but case may be ignored, try converting |
| // both characters to uppercase. If the results match, then the |
| // comparison scan should continue |
| char u1 = Character.toUpperCase(c1); |
| char u2 = Character.toUpperCase(c2); |
| |
| if (u1 != u2) { |
| return false; |
| } |
| |
| // Unfortunately, conversion to uppercase does not work properly for |
| // the Georgian alphabet, which has strange rules about case |
| // conversion. So we need to make one last check before exiting |
| if (Character.toLowerCase(u1) != Character.toLowerCase(u2)) { |
| return false; |
| } |
| } |
| |
| // End of the text |
| if (to == length) { |
| return true; |
| } |
| |
| // Check to see if the next character is a word separator |
| char character = text.charAt(to); |
| return isWordSeparator(character); |
| } |
| |
| /** |
| * Determines whether the text starts with the given character. The case of the character is ignored. |
| * |
| * @param possibleCharacter The possible character at the current position |
| * @return <code>true</code> if the text starts with the given character at the current position; |
| * <code>false</code> otherwise |
| */ |
| public boolean startsWithIgnoreCase(char possibleCharacter) { |
| |
| char character = character(); |
| |
| return possibleCharacter == character || |
| possibleCharacter == Character.toUpperCase(character); |
| } |
| |
| /** |
| * Tests if the string starts with the specified prefix. The case of the character is ignored. |
| * |
| * @param prefix The prefix to test against |
| * @return <code>true</code> if the character sequence represented by the argument is a prefix of |
| * the character sequence represented by this string; <code>false</code> otherwise. Note also |
| * that <code>true</code> will be returned if the argument is an empty string or is equal to this |
| * <code>String</code> object as determined by the {@link #equals(Object)} method |
| */ |
| public boolean startsWithIgnoreCase(CharSequence prefix) { |
| return startsWithIgnoreCase(prefix, cursor); |
| } |
| |
| /** |
| * Tests if the string starts with the specified prefix. The case of the character is ignored. |
| * |
| * @param prefix The prefix to test against |
| * @param offset Where to begin looking in this string |
| * @return <code>true</code> if the character sequence represented by the argument is a prefix of |
| * the character sequence represented by this string; <code>false</code> otherwise |
| */ |
| public boolean startsWithIgnoreCase(CharSequence prefix, int offset) { |
| |
| int pc = prefix.length(); |
| |
| // Note: offset might be near -1 >>> 1 |
| if ((offset < 0) || (offset > length - pc)) { |
| return false; |
| } |
| |
| int po = 0; |
| int to = offset; |
| |
| while (--pc >= 0) { |
| |
| char c1 = text.charAt(to++); |
| char c2 = prefix.charAt(po++); |
| |
| if (c1 == c2) { |
| continue; |
| } |
| |
| // If characters don't match but case may be ignored, try converting |
| // both characters to uppercase. If the results match, then the |
| // comparison scan should continue |
| char u1 = Character.toUpperCase(c1); |
| char u2 = Character.toUpperCase(c2); |
| |
| if (u1 != u2) { |
| return false; |
| } |
| |
| // Unfortunately, conversion to uppercase does not work properly for |
| // the Georgian alphabet, which has strange rules about case |
| // conversion. So we need to make one last check before exiting |
| if (Character.toLowerCase(u1) != Character.toLowerCase(u2)) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Returns a substring that is within the current position of the cursor and the end of the text. |
| * |
| * @return The remain of the string starting at the current position |
| */ |
| public String substring() { |
| return substring(cursor); |
| } |
| |
| /** |
| * Returns a substring that is within the given position and the end of the text. |
| * |
| * @param startIndex The beginning of the substring, inclusive |
| * @return The remain of the string starting at the given position |
| */ |
| public String substring(int startIndex) { |
| return substring(startIndex, length); |
| } |
| |
| /** |
| * Returns a substring that is within the given positions. |
| * |
| * @param startIndex The beginning of the substring, inclusive |
| * @param endIndex The end of the substring, exclusive |
| * @return The remain of the string that is within the given positions |
| */ |
| public String substring(int startIndex, int endIndex) { |
| return text.subSequence(startIndex, endIndex).toString(); |
| } |
| |
| @Override |
| public String toString() { |
| return isTail() ? ExpressionTools.EMPTY_STRING : substring(); |
| } |
| |
| /** |
| * Calculates the number of whitespace that are in the query. The check starts at the current position. |
| * |
| * @return The count of consecutive whitespace found from the current position |
| */ |
| public int whitespaceCount() { |
| return whitespaceCount(cursor); |
| } |
| |
| /** |
| * Calculates the number of whitespace that are in the query. The check starts at the current position. |
| * |
| * @param position The position from where the scan starts |
| * @return The count of consecutive whitespace found from the given position |
| */ |
| public int whitespaceCount(int position) { |
| |
| for (int index = position; index < length; index++) { |
| char character = text.charAt(index); |
| |
| if (!Character.isWhitespace(character)) { |
| return index - position; |
| } |
| } |
| |
| return 0; |
| } |
| |
| /** |
| * Retrieves the first word starting at the current position. |
| * |
| * @return The first word contained in the text, if none could be found, |
| * then an empty string is returned |
| */ |
| public String word() { |
| return substring(cursor, wordEndPosition()); |
| } |
| |
| /** |
| * Returns the position a word would end based on the current cursor position. {@link #getWordType()} |
| * can be used to determine the type of word that was scanned. |
| * |
| * @return The position where the current word ends |
| * @see #word() WordParser.word() |
| * @see WordType |
| */ |
| public int wordEndPosition() { |
| return wordEndPosition(cursor); |
| } |
| |
| /** |
| * Returns the position a word would end based on the given start position. {@link #getWordType()} |
| * can be used to determine the type of word that was scanned. |
| * |
| * @param position The position to start scanning the text |
| * @return The position where the current word ends |
| * @see #word() WordParser.word() |
| * @see WordType |
| */ |
| public int wordEndPosition(int position) { |
| |
| if (position >= length) { |
| wordType = WordType.UNDEFINED; |
| return position; |
| } |
| |
| char character = text.charAt(position); |
| int endIndex = position + 1; |
| wordType = WordType.WORD; |
| |
| // Parse a string literal |
| if (ExpressionTools.isQuote(character)) { |
| wordType = WordType.STRING_LITERAL; |
| |
| // The quote is the end quote |
| if (position > 1) { |
| character = character(position - 1); |
| if (ExpressionTools.isQuote(character)) { |
| return endIndex; |
| } |
| } |
| |
| return scanStringLiteral(position); |
| } |
| |
| // Parse an input parameter |
| if (ExpressionTools.isParameter(character)) { |
| wordType = WordType.INPUT_PARAMETER; |
| |
| for (; endIndex < length; endIndex++) { |
| character = text.charAt(endIndex); |
| |
| // Special case for '!=' |
| if ((character == '!') && (endIndex + 1 < length)) { |
| character = text.charAt(endIndex + 1); |
| |
| if (character == '=') { |
| break; |
| } |
| |
| endIndex++; |
| continue; |
| } |
| |
| if (isWordSeparator(character)) { |
| break; |
| } |
| } |
| |
| return endIndex; |
| } |
| |
| // Parse an arithmetic symbol |
| if (character == '/' || |
| character == '*' || |
| character == '+' || |
| character == '-') { |
| |
| return endIndex; |
| } |
| |
| // Parse JDBC date |
| if (character == '{') { |
| // TODO |
| return endIndex; |
| } |
| |
| // Parse a numeric literal |
| if (isDigit(character)) { |
| |
| wordType = WordType.NUMERIC_LITERAL; |
| endIndex = scanNumericLiteral(position); |
| |
| // The word is a valid numeric literal, stop now, |
| // otherwise scan for the entire word |
| if (wordType == WordType.NUMERIC_LITERAL) { |
| return endIndex; |
| } |
| } |
| |
| // '=' |
| else if (character == '=') { |
| return endIndex; |
| } |
| |
| // <, <>, <= |
| else if (character == '<') { |
| |
| if (endIndex < length) { |
| character = text.charAt(endIndex); |
| |
| if (character == '>' || |
| character == '=') { |
| |
| return endIndex + 1; |
| } |
| |
| return endIndex; |
| } |
| } |
| |
| // >, >=, != |
| else if (character == '>' || |
| character == '!') { |
| |
| // End of the text |
| if (endIndex == length) { |
| return endIndex; |
| } |
| |
| // Scan the next character |
| char nextCharacter = text.charAt(endIndex); |
| |
| if (nextCharacter == '=') { |
| return ++endIndex; |
| } |
| |
| if (character == '>') { |
| return endIndex; |
| } |
| } |
| |
| // Done scanning |
| else if (isWordSeparator(character)) { |
| return --endIndex; |
| } |
| |
| // Scan for an entire word |
| for (int index = endIndex; index < length; index++) { |
| character = text.charAt(index); |
| |
| // Special case for '!=' |
| if ((character == '!') && (endIndex + 1 < length)) { |
| character = text.charAt(index + 1); |
| |
| if (character == '=') { |
| return endIndex; |
| } |
| |
| endIndex++; |
| continue; |
| } |
| |
| if (Character.isWhitespace(character) || |
| isDelimiter(character) || |
| character == '>' || |
| character == '<' || |
| character == '/' || |
| character == '*' || |
| character == '-' || |
| character == '+' || |
| character == '=') { |
| |
| break; |
| } |
| |
| // Continue to the next character |
| endIndex++; |
| } |
| |
| return endIndex; |
| } |
| |
| /** |
| * This enumeration determines the type of word that was scanned. It will be set by {@link |
| * WordParser#word()}, {@link WordParser#wordEndPosition()}, {@link WordParser#wordEndPosition(int)}. |
| */ |
| public enum WordType { |
| |
| /** |
| * The word being scanned is an input parameter, it starts with either ':' or '?'. |
| */ |
| INPUT_PARAMETER, |
| |
| /** |
| * The word being scanned is a numeric literal (decimal or hexadecimal number). |
| */ |
| NUMERIC_LITERAL, |
| |
| /** |
| * The word being scanned is a string literal, it starts with either ''' or '"'. |
| */ |
| STRING_LITERAL, |
| |
| /** |
| * No word was scanned, this is usually set when the cursor is at the end of the text. |
| */ |
| UNDEFINED, |
| |
| /** |
| * The word being scanned anything else other than an input parameter, numeric literal or |
| * string literal. |
| */ |
| WORD |
| } |
| } |
