| /* Copyright (c) 2001-2010, The HSQL Development Group |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * Redistributions of source code must retain the above copyright notice, this |
| * list of conditions and the following disclaimer. |
| * |
| * Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * Neither the name of the HSQL Development Group nor the names of its |
| * contributors may be used to endorse or promote products derived from this |
| * software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG, |
| * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| |
| package org.hsqldb; |
| |
| import java.math.BigDecimal; |
| import java.util.Locale; |
| |
| import org.hsqldb.error.Error; |
| import org.hsqldb.error.ErrorCode; |
| import org.hsqldb.lib.ArrayUtil; |
| import org.hsqldb.lib.CharArrayWriter; |
| import org.hsqldb.lib.HsqlByteArrayOutputStream; |
| import org.hsqldb.lib.OrderedIntHashSet; |
| import org.hsqldb.lib.java.JavaSystem; |
| import org.hsqldb.store.BitMap; |
| import org.hsqldb.store.ValuePool; |
| import org.hsqldb.types.BinaryData; |
| import org.hsqldb.types.BinaryType; |
| import org.hsqldb.types.BitType; |
| import org.hsqldb.types.CharacterType; |
| import org.hsqldb.types.DTIType; |
| import org.hsqldb.types.DateTimeType; |
| import org.hsqldb.types.IntervalMonthData; |
| import org.hsqldb.types.IntervalSecondData; |
| import org.hsqldb.types.IntervalType; |
| import org.hsqldb.types.NumberType; |
| import org.hsqldb.types.TimeData; |
| import org.hsqldb.types.TimestampData; |
| import org.hsqldb.types.Type; |
| import org.hsqldb.types.Types; |
| |
| /** |
| * Scans for SQL tokens. |
| * |
| * @author Fred Toussi (fredt@users dot sourceforge.net) |
| * @version 1.9.0 |
| * @since 1.9.0 |
| */ |
| public class Scanner { |
| |
| /* |
| <delimiter token> ::= |
| <character string literal> |
| | <date string> |
| | <time string> |
| | <timestamp string> |
| | <interval string> |
| | <delimited identifier> |
| | <SQL special character> |
| | <not equals operator> |
| | <greater than or equals operator> |
| | <less than or equals operator> |
| | <concatenation operator> |
| | <right arrow> |
| | <left bracket trigraph> |
| | <right bracket trigraph> |
| | <double colon> |
| | <double period> |
| |
| */ |
| //J- |
| final static char[] specials = new char[] { |
| '"', |
| '%', |
| '&', |
| '\'', |
| '(', |
| ')', |
| '*', |
| '+', |
| ',', |
| '-', |
| '.', |
| '/', |
| '\\', |
| ':', |
| ';', |
| '<', |
| '=', |
| '>', |
| '?', |
| '[', |
| ']', |
| '^', |
| '_', |
| '|', |
| '{', |
| '}' |
| }; |
| final static String[] multi = new String[] { |
| "??(", |
| "??)", |
| "<>", |
| ">=", |
| "<=", |
| "||", |
| "->", |
| "::", |
| "..", |
| "--", |
| "/*", |
| "*/", |
| }; |
| |
| final static char[] whitespace = { |
| // SQL extras |
| 0x9, |
| 0xA, |
| 0xB, |
| 0xC, |
| 0xD, |
| 0x20, |
| 0x85, |
| // U Zs |
| 0x0020, |
| 0x00A0, |
| 0x1680, |
| 0x180E, |
| 0x2000, |
| 0x2001, |
| 0x2002, |
| 0x2003, |
| 0x2004, |
| 0x2005, |
| 0x2006, |
| 0x2007, |
| 0x2008, |
| 0x2009, |
| 0x200A, |
| 0x202F, |
| 0x205F, |
| 0x3000, |
| // U Zl |
| 0x2028, |
| // U Zp |
| 0x2029, |
| }; |
| |
| //J+ |
| final static OrderedIntHashSet whiteSpaceSet = new OrderedIntHashSet(32); |
| |
| static { |
| for (int i = 0; i < whitespace.length; i++) { |
| whiteSpaceSet.add(whitespace[i]); |
| } |
| } |
| |
| // single token types |
| String sqlString; |
| int currentPosition; |
| int tokenPosition; |
| int limit; |
| Token token = new Token(); |
| boolean nullAndBooleanAsValue; |
| |
| // |
| private boolean hasNonSpaceSeparator; |
| private int eolPosition; |
| private int lineNumber; |
| private int eolCode; |
| |
| // |
| private static final int maxPooledStringLength = |
| ValuePool.getMaxStringLength(); |
| |
| // |
| char[] charBuffer = new char[256]; |
| CharArrayWriter charWriter = new CharArrayWriter(charBuffer); |
| |
| // |
| byte[] byteBuffer = new byte[256]; |
| HsqlByteArrayOutputStream byteOutputStream = |
| new HsqlByteArrayOutputStream(byteBuffer); |
| |
| public Scanner() {} |
| |
| Scanner(String sql) { |
| reset(sql); |
| } |
| |
| public void reset(String sql) { |
| |
| sqlString = sql; |
| currentPosition = 0; |
| tokenPosition = 0; |
| limit = sqlString.length(); |
| hasNonSpaceSeparator = false; |
| eolPosition = -1; |
| lineNumber = 1; |
| |
| token.reset(); |
| |
| token.tokenType = Tokens.X_STARTPARSE; |
| } |
| |
| void resetState() { |
| |
| tokenPosition = currentPosition; |
| |
| token.reset(); |
| } |
| |
| public void setNullAndBooleanAsValue() { |
| nullAndBooleanAsValue = true; |
| } |
| |
| public void scanNext() { |
| |
| if (currentPosition == limit) { |
| resetState(); |
| |
| token.tokenType = Tokens.X_ENDPARSE; |
| |
| return; |
| } |
| |
| if (scanSeparator()) { |
| |
| // token.isDelimiter = true; |
| } |
| |
| if (currentPosition == limit) { |
| resetState(); |
| |
| token.tokenType = Tokens.X_ENDPARSE; |
| |
| return; |
| } |
| |
| boolean needsDelimiter = !token.isDelimiter; |
| |
| scanToken(); |
| |
| if (needsDelimiter && !token.isDelimiter) { |
| |
| // token.tokenType = Token.X_UNKNOWN_TOKEN; |
| } |
| |
| if (token.isMalformed) { |
| token.fullString = getPart(tokenPosition, currentPosition); |
| } |
| } |
| |
| public void scanEnd() { |
| |
| if (currentPosition == limit) { |
| resetState(); |
| |
| token.tokenType = Tokens.X_ENDPARSE; |
| } |
| } |
| |
| public Token getToken() { |
| return token; |
| } |
| |
| public String getString() { |
| return token.tokenString; |
| } |
| |
| public int getTokenType() { |
| return token.tokenType; |
| } |
| |
| public Object getValue() { |
| return token.tokenValue; |
| } |
| |
| public Type getDataType() { |
| return token.dataType; |
| } |
| |
| public int getLineNumber() { |
| return lineNumber; |
| } |
| |
| int getTokenPosition() { |
| return tokenPosition; |
| } |
| |
| int getPosition() { |
| return tokenPosition; |
| } |
| |
| void position(int position) { |
| currentPosition = tokenPosition = position; |
| } |
| |
| String getPart(int start, int end) { |
| return sqlString.substring(start, end); |
| } |
| |
| private int charAt(int i) { |
| |
| if (i >= limit) { |
| return -1; |
| } |
| |
| return sqlString.charAt(i); |
| } |
| |
| void scanBinaryString() { |
| |
| byteOutputStream.reset(byteBuffer); |
| |
| while (true) { |
| scanBinaryStringPart(); |
| |
| if (token.isMalformed) { |
| return; |
| } |
| |
| if (scanSeparator() && charAt(currentPosition) == '\'') { |
| continue; |
| } |
| |
| break; |
| } |
| |
| token.tokenValue = new BinaryData(byteOutputStream.toByteArray(), |
| false); |
| |
| byteOutputStream.reset(byteBuffer); |
| } |
| |
| /** |
| * returns hex value of a hex character, or 16 if not a hex character |
| */ |
| static int getHexValue(int c) { |
| |
| if (c >= '0' && c <= '9') { |
| c -= '0'; |
| } else if (c > 'z') { |
| c = 16; |
| } else if (c >= 'a') { |
| c -= ('a' - 10); |
| } else if (c > 'Z') { |
| c = 16; |
| } else if (c >= 'A') { |
| c -= ('A' - 10); |
| } else { |
| c = -1; |
| } |
| |
| return c; |
| } |
| |
| public void scanBinaryStringWithQuote() { |
| |
| resetState(); |
| scanSeparator(); |
| |
| if (charAt(currentPosition) != '\'') { |
| token.tokenType = Tokens.X_MALFORMED_BINARY_STRING; |
| token.isMalformed = true; |
| |
| return; |
| } |
| |
| scanBinaryString(); |
| } |
| |
| void scanBinaryStringPart() { |
| |
| boolean complete = false; |
| boolean hi = true; |
| byte b = 0; |
| |
| currentPosition++; |
| |
| for (; currentPosition < limit; currentPosition++) { |
| int c = sqlString.charAt(currentPosition); |
| |
| if (c == ' ') { |
| continue; |
| } |
| |
| if (c == '\'') { |
| complete = true; |
| |
| currentPosition++; |
| |
| break; |
| } |
| |
| c = getHexValue(c); |
| |
| if (c == -1) { |
| |
| // bad character |
| token.tokenType = Tokens.X_MALFORMED_BINARY_STRING; |
| token.isMalformed = true; |
| |
| return; |
| } |
| |
| if (hi) { |
| b = (byte) (c << 4); |
| hi = false; |
| } else { |
| b += (byte) c; |
| |
| byteOutputStream.writeByte(b); |
| |
| hi = true; |
| } |
| } |
| |
| if (!hi) { |
| |
| // odd nibbles |
| token.tokenType = Tokens.X_MALFORMED_BINARY_STRING; |
| token.isMalformed = true; |
| |
| return; |
| } |
| |
| if (!complete) { |
| |
| // no end quote |
| token.tokenType = Tokens.X_MALFORMED_BINARY_STRING; |
| token.isMalformed = true; |
| |
| return; |
| } |
| } |
| |
| void scanBitString() { |
| |
| BitMap map = new BitMap(32); |
| |
| while (true) { |
| scanBitStringPart(map); |
| |
| if (token.isMalformed) { |
| return; |
| } |
| |
| if (scanSeparator() && charAt(currentPosition) == '\'') { |
| continue; |
| } |
| |
| break; |
| } |
| |
| token.tokenValue = BinaryData.getBitData(map.getBytes(), map.size()); |
| } |
| |
| public void scanBitStringWithQuote() { |
| |
| resetState(); |
| scanSeparator(); |
| |
| if (charAt(currentPosition) != '\'') { |
| token.tokenType = Tokens.X_MALFORMED_BIT_STRING; |
| token.isMalformed = true; |
| |
| return; |
| } |
| |
| scanBitString(); |
| } |
| |
| void scanBitStringPart(BitMap map) { |
| |
| boolean complete = false; |
| int bitIndex = map.size(); |
| |
| currentPosition++; |
| |
| for (; currentPosition < limit; currentPosition++) { |
| char c = sqlString.charAt(currentPosition); |
| |
| if (c == ' ') { |
| continue; |
| } |
| |
| if (c == '\'') { |
| complete = true; |
| |
| currentPosition++; |
| |
| break; |
| } |
| |
| if (c == '0') { |
| bitIndex++; |
| } else if (c == '1') { |
| map.set(bitIndex); |
| |
| bitIndex++; |
| } else { |
| token.tokenType = Tokens.X_MALFORMED_BIT_STRING; |
| token.isMalformed = true; |
| |
| return; |
| } |
| } |
| |
| if (!complete) { |
| token.tokenType = Tokens.X_MALFORMED_BIT_STRING; |
| token.isMalformed = true; |
| |
| return; |
| } |
| |
| map.setSize(bitIndex); |
| } |
| |
| void convertUnicodeString(int escape) { |
| |
| charWriter.reset(charBuffer); |
| |
| int position = 0; |
| |
| for (;;) { |
| int nextIndex = token.tokenString.indexOf(escape, position); |
| |
| if (nextIndex < 0) { |
| nextIndex = token.tokenString.length(); |
| } |
| |
| charWriter.write(token.tokenString, position, |
| nextIndex - position); |
| |
| if (nextIndex == token.tokenString.length()) { |
| break; |
| } |
| |
| nextIndex++; |
| |
| if (nextIndex == token.tokenString.length()) { |
| token.tokenType = Tokens.X_MALFORMED_UNICODE_STRING; |
| token.isMalformed = true; |
| |
| return; |
| } |
| |
| if (token.tokenString.charAt(nextIndex) == escape) { |
| charWriter.write(escape); |
| |
| nextIndex++; |
| |
| position = nextIndex; |
| |
| continue; |
| } |
| |
| if (nextIndex > token.tokenString.length() - 4) { |
| token.tokenType = Tokens.X_MALFORMED_UNICODE_STRING; |
| token.isMalformed = true; |
| |
| return; |
| } |
| |
| int hexCount = 4; |
| int hexIndex = 0; |
| int hexValue = 0; |
| |
| if (token.tokenString.charAt(nextIndex) == '+') { |
| nextIndex++; |
| |
| if (nextIndex > token.tokenString.length() - 6) { |
| token.tokenType = Tokens.X_MALFORMED_UNICODE_STRING; |
| token.isMalformed = true; |
| |
| return; |
| } |
| |
| hexIndex = 2; |
| hexCount = 8; |
| } |
| |
| for (; hexIndex < hexCount; hexIndex++) { |
| int character = token.tokenString.charAt(position++); |
| |
| character = getHexValue(character); |
| |
| if (character == -1) { |
| token.tokenType = Tokens.X_MALFORMED_UNICODE_STRING; |
| token.isMalformed = true; |
| |
| return; |
| } |
| |
| hexValue |= character << ((hexCount - hexIndex - 1) * 4); |
| } |
| |
| if (hexCount == 8) { |
| charWriter.write(hexValue >>> 16); |
| } |
| |
| charWriter.write(hexValue & (hexValue & 0xffff)); |
| |
| token.tokenValue = charWriter.toString(); |
| } |
| } |
| |
| /** |
| * Only for identifiers that are part of known token sequences |
| */ |
| public boolean scanSpecialIdentifier(String identifier) { |
| |
| int length = identifier.length(); |
| |
| if (limit - currentPosition < length) { |
| return false; |
| } |
| |
| for (int i = 0; i < length; i++) { |
| int character = identifier.charAt(i); |
| |
| if (character == sqlString.charAt(currentPosition + i)) { |
| continue; |
| } |
| |
| if (character |
| == Character.toUpperCase(sqlString.charAt(currentPosition |
| + i))) { |
| continue; |
| } |
| |
| return false; |
| } |
| |
| currentPosition += length; |
| |
| return true; |
| } |
| |
| private int scanEscapeDefinition() { |
| |
| int c = charAt(currentPosition); |
| |
| if (c == '\'') { |
| currentPosition++; |
| |
| if (!scanWhitespace()) { |
| c = charAt(currentPosition); |
| |
| if (getHexValue(c) == -1) { |
| if (c != '+' && c != '\'' && c != '\"') { |
| int escape = c; |
| |
| currentPosition++; |
| |
| c = charAt(currentPosition); |
| |
| if (c == '\'') { |
| currentPosition++; |
| |
| return escape; |
| } |
| } |
| } |
| } |
| } |
| |
| return -1; |
| } |
| |
| private void scanUnicodeString() { |
| |
| int escape = '\\'; |
| |
| scanCharacterString(); |
| scanSeparator(); |
| |
| int c = charAt(currentPosition); |
| |
| if (c == 'u' || c == 'U') { |
| if (scanSpecialIdentifier(Tokens.T_UESCAPE)) { |
| scanSeparator(); |
| |
| escape = scanEscapeDefinition(); |
| |
| if (escape == -1) { |
| token.tokenType = Tokens.X_MALFORMED_UNICODE_ESCAPE; |
| token.isMalformed = true; |
| |
| return; |
| } |
| } |
| } |
| |
| convertUnicodeString(escape); |
| } |
| |
| private boolean scanUnicodeIdentifier() { |
| |
| int escape = '\\'; |
| |
| scanStringPart('"'); |
| |
| if (token.isMalformed) { |
| return false; |
| } |
| |
| token.tokenString = charWriter.toString(); |
| |
| int c = charAt(currentPosition); |
| |
| if (c == 'u' || c == 'U') { |
| if (scanSpecialIdentifier(Tokens.T_UESCAPE)) { |
| scanSeparator(); |
| |
| escape = scanEscapeDefinition(); |
| |
| if (escape == -1) { |
| token.tokenType = Tokens.X_MALFORMED_UNICODE_ESCAPE; |
| token.isMalformed = true; |
| |
| return false; |
| } |
| } |
| } |
| |
| convertUnicodeString(escape); |
| |
| return !token.isMalformed; |
| } |
| |
| boolean shiftPrefixes() { |
| |
| if (token.namePrePrePrefix != null) { |
| return false; |
| } |
| |
| token.namePrePrePrefix = token.namePrePrefix; |
| token.isDelimitedPrePrePrefix = token.isDelimitedPrePrefix; |
| token.namePrePrefix = token.namePrefix; |
| token.isDelimitedPrePrefix = token.isDelimitedPrefix; |
| token.namePrefix = token.tokenString; |
| token.isDelimitedPrefix = (token.tokenType |
| == Tokens.X_DELIMITED_IDENTIFIER); |
| |
| return true; |
| } |
| |
| private void scanIdentifierChain() { |
| |
| int c = charAt(currentPosition); |
| |
| switch (c) { |
| |
| case '"' : |
| charWriter.reset(charBuffer); |
| scanStringPart('"'); |
| |
| if (token.isMalformed) { |
| return; |
| } |
| |
| token.tokenType = Tokens.X_DELIMITED_IDENTIFIER; |
| token.tokenString = charWriter.toString(); |
| token.isDelimiter = true; |
| break; |
| |
| case 'u' : |
| case 'U' : |
| if (charAt(currentPosition + 1) == '&') { |
| if (charAt(currentPosition + 1) == '"') { |
| currentPosition += 3; |
| |
| boolean result = scanUnicodeIdentifier(); |
| |
| if (!result) { |
| return; |
| } |
| |
| token.tokenType = Tokens.X_DELIMITED_IDENTIFIER; |
| token.isDelimiter = false; |
| |
| break; |
| } |
| } |
| |
| // fall through |
| default : |
| boolean result = scanUndelimitedIdentifier(); |
| |
| if (!result) { |
| return; |
| } |
| |
| token.tokenType = Tokens.X_IDENTIFIER; |
| token.isDelimiter = false; |
| } |
| |
| c = charAt(currentPosition); |
| |
| if (c == '.') { |
| currentPosition++; |
| |
| c = charAt(currentPosition); |
| |
| if (c == '*') { |
| currentPosition++; |
| |
| shiftPrefixes(); |
| |
| token.tokenString = Tokens.T_ASTERISK; |
| token.tokenType = Tokens.ASTERISK; |
| } else { |
| shiftPrefixes(); |
| scanIdentifierChain(); |
| } |
| } |
| } |
| |
| public boolean scanUndelimitedIdentifier() { |
| |
| if (currentPosition == limit) { |
| return false; |
| } |
| |
| char start = sqlString.charAt(currentPosition); |
| |
| if (!Character.isLetter(start)) { |
| token.tokenString = Character.toString(start); |
| token.tokenType = Tokens.X_UNKNOWN_TOKEN; |
| token.isMalformed = true; |
| |
| return false; |
| } |
| |
| int i = currentPosition + 1; |
| |
| for (; i < limit; i++) { |
| char c = sqlString.charAt(i); |
| |
| if (c == '_' || Character.isLetterOrDigit(c)) { |
| continue; |
| } |
| |
| break; |
| } |
| |
| token.tokenString = sqlString.substring(currentPosition, |
| i).toUpperCase(Locale.ENGLISH); |
| currentPosition = i; |
| |
| if (nullAndBooleanAsValue) { |
| int tokenLength = currentPosition - tokenPosition; |
| |
| if (tokenLength == 4 || tokenLength == 5) { |
| switch (start) { |
| |
| case 'T' : |
| case 't' : |
| if (Tokens.T_TRUE.equals(token.tokenString)) { |
| token.tokenString = Tokens.T_TRUE; |
| token.tokenType = Tokens.X_VALUE; |
| token.tokenValue = Boolean.TRUE; |
| token.dataType = Type.SQL_BOOLEAN; |
| |
| return false; |
| } |
| break; |
| |
| case 'F' : |
| case 'f' : |
| if (Tokens.T_FALSE.equals(token.tokenString)) { |
| token.tokenString = Tokens.T_FALSE; |
| token.tokenType = Tokens.X_VALUE; |
| token.tokenValue = Boolean.FALSE; |
| token.dataType = Type.SQL_BOOLEAN; |
| |
| return false; |
| } |
| break; |
| |
| case 'N' : |
| case 'n' : |
| if (Tokens.T_NULL.equals(token.tokenString)) { |
| token.tokenString = Tokens.T_NULL; |
| token.tokenType = Tokens.X_VALUE; |
| token.tokenValue = null; |
| |
| return false; |
| } |
| break; |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| void scanNumber() { |
| |
| int c; |
| boolean hasDigit = false; |
| boolean hasPoint = false; |
| int exponentIndex = -1; |
| |
| token.tokenType = Tokens.X_VALUE; |
| token.dataType = Type.SQL_INTEGER; |
| |
| int tokenStart = currentPosition; |
| |
| for (; currentPosition < limit; currentPosition++) { |
| boolean end = false; |
| |
| c = charAt(currentPosition); |
| |
| switch (c) { |
| |
| case '0' : |
| case '1' : |
| case '2' : |
| case '3' : |
| case '4' : |
| case '5' : |
| case '6' : |
| case '7' : |
| case '8' : |
| case '9' : |
| hasDigit = true; |
| break; |
| |
| case '.' : |
| token.dataType = Type.SQL_NUMERIC; |
| |
| if (hasPoint || exponentIndex != -1) { |
| token.tokenString = sqlString.substring(tokenStart, |
| currentPosition + 1); |
| token.tokenType = Tokens.X_MALFORMED_NUMERIC; |
| token.isMalformed = true; |
| |
| return; |
| } |
| |
| hasPoint = true; |
| break; |
| |
| case 'E' : |
| case 'e' : |
| token.dataType = Type.SQL_DOUBLE; |
| |
| if (exponentIndex != -1 || !hasDigit) { |
| token.tokenString = sqlString.substring(tokenStart, |
| currentPosition + 1); |
| token.tokenType = Tokens.X_MALFORMED_NUMERIC; |
| token.isMalformed = true; |
| |
| return; |
| } |
| |
| hasPoint = true; |
| exponentIndex = currentPosition; |
| break; |
| |
| case '-' : |
| case '+' : |
| if (exponentIndex != currentPosition - 1) { |
| end = true; |
| } |
| break; |
| |
| case 'K' : |
| case 'k' : |
| case 'M' : |
| case 'm' : |
| case 'G' : |
| case 'g' : |
| case 'T' : |
| case 't' : |
| case 'P' : |
| case 'p' : |
| if (!hasDigit || hasPoint) { |
| token.tokenType = Tokens.X_MALFORMED_NUMERIC; |
| token.isMalformed = true; |
| |
| return; |
| } |
| |
| String s = Character.toString((char) c).toUpperCase( |
| Locale.ENGLISH); |
| |
| token.lobMultiplierType = Tokens.getNonKeywordID(s, |
| Tokens.X_MALFORMED_NUMERIC); |
| |
| if (token.lobMultiplierType |
| == Tokens.X_MALFORMED_NUMERIC) { |
| token.tokenType = Tokens.X_MALFORMED_NUMERIC; |
| token.isMalformed = true; |
| |
| return; |
| } |
| |
| try { |
| token.tokenValue = ValuePool.getInt( |
| Integer.parseInt( |
| sqlString.substring( |
| tokenStart, currentPosition))); |
| token.tokenType = Tokens.X_LOB_SIZE; |
| |
| currentPosition++; |
| |
| token.fullString = getPart(tokenPosition, |
| currentPosition); |
| } catch (NumberFormatException e) { |
| token.tokenType = Tokens.X_MALFORMED_NUMERIC; |
| token.isMalformed = true; |
| } |
| |
| return; |
| |
| default : |
| end = true; |
| break; |
| } |
| |
| if (end) { |
| break; |
| } |
| } |
| |
| token.tokenString = sqlString.substring(tokenStart, currentPosition); |
| |
| switch (token.dataType.typeCode) { |
| |
| case Types.SQL_INTEGER : |
| |
| // fredt - -Integer.MIN_VALUE or -Long.MIN_VALUE are promoted |
| // to a wider type. |
| if (token.tokenString.length() < 11) { |
| try { |
| token.tokenValue = ValuePool.getInt( |
| Integer.parseInt(token.tokenString)); |
| |
| return; |
| } catch (Exception e1) {} |
| } |
| |
| if (this.token.tokenString.length() < 20) { |
| try { |
| token.dataType = Type.SQL_BIGINT; |
| token.tokenValue = ValuePool.getLong( |
| Long.parseLong(token.tokenString)); |
| |
| return; |
| } catch (Exception e2) {} |
| } |
| |
| token.dataType = Type.SQL_NUMERIC; |
| |
| // fall through |
| case Types.SQL_NUMERIC : |
| try { |
| BigDecimal decimal = new BigDecimal(token.tokenString); |
| |
| token.tokenValue = decimal; |
| token.dataType = NumberType.getNumberType(Types.NUMERIC, |
| JavaSystem.precision(decimal), decimal.scale()); |
| } catch (Exception e2) { |
| token.tokenType = Tokens.X_MALFORMED_NUMERIC; |
| token.isMalformed = true; |
| |
| return; |
| } |
| |
| return; |
| |
| case Types.SQL_DOUBLE : |
| try { |
| double d = JavaSystem.parseDouble(token.tokenString); |
| long l = Double.doubleToLongBits(d); |
| |
| token.tokenValue = ValuePool.getDouble(l); |
| } catch (Exception e2) { |
| token.tokenType = Tokens.X_MALFORMED_NUMERIC; |
| token.isMalformed = true; |
| |
| return; |
| } |
| |
| return; |
| } |
| } |
| |
| boolean scanSeparator() { |
| |
| boolean result = false; |
| |
| while (true) { |
| boolean whiteSpace = scanWhitespace(); |
| |
| result |= whiteSpace; |
| |
| if (scanCommentAsInlineSeparator()) { |
| result = true; |
| hasNonSpaceSeparator = true; |
| |
| continue; |
| } |
| |
| break; |
| } |
| |
| // token.isDelimiter |= result; |
| return result; |
| } |
| |
| boolean scanCommentAsInlineSeparator() { |
| |
| int character = charAt(currentPosition); |
| |
| if (character == '-' && charAt(currentPosition + 1) == '-') { |
| int pos = sqlString.indexOf('\r', currentPosition + 2); |
| |
| if (pos == -1) { |
| pos = sqlString.indexOf('\n', currentPosition + 2); |
| } else if (charAt(pos + 1) == '\n') { |
| pos++; |
| } |
| |
| if (pos == -1) { |
| currentPosition = limit; |
| } else { |
| currentPosition = pos + 1; |
| } |
| |
| return true; |
| } else if (character == '/' && charAt(currentPosition + 1) == '*') { |
| int pos = sqlString.indexOf("*/", currentPosition + 2); |
| |
| if (pos == -1) { |
| token.tokenString = sqlString.substring(currentPosition, |
| currentPosition + 2); |
| token.tokenType = Tokens.X_MALFORMED_COMMENT; |
| token.isMalformed = true; |
| |
| return false; |
| } |
| |
| currentPosition = pos + 2; |
| |
| return true; |
| } |
| |
| return false; |
| } |
| |
| public boolean scanWhitespace() { |
| |
| boolean result = false; |
| |
| for (; currentPosition < limit; currentPosition++) { |
| char c = sqlString.charAt(currentPosition); |
| |
| if (c == ' ') { |
| result = true; |
| |
| continue; |
| } |
| |
| if (whiteSpaceSet.contains(c)) { |
| hasNonSpaceSeparator = true; |
| result = true; |
| |
| setLineNumber(c); |
| |
| continue; |
| } |
| |
| break; |
| } |
| |
| return result; |
| } |
| |
| private void setLineNumber(int c) { |
| |
| if (c == '\r' || c == '\n') { |
| if (currentPosition == eolPosition + 1) { |
| if (c == '\n' && eolCode != c) { |
| |
| // |
| } else { |
| lineNumber++; |
| } |
| } else { |
| lineNumber++; |
| } |
| |
| eolPosition = currentPosition; |
| eolCode = c; |
| } |
| } |
| |
| void scanCharacterString() { |
| |
| charWriter.reset(charBuffer); |
| |
| while (true) { |
| scanStringPart('\''); |
| |
| if (token.isMalformed) { |
| return; |
| } |
| |
| if (scanSeparator() && charAt(currentPosition) == '\'') { |
| continue; |
| } |
| |
| break; |
| } |
| |
| token.tokenString = charWriter.toString(); |
| token.tokenValue = token.tokenString; |
| } |
| |
| public void scanStringPart(char quoteChar) { |
| |
| currentPosition++; |
| |
| for (;;) { |
| int nextIndex = sqlString.indexOf(quoteChar, currentPosition); |
| |
| if (nextIndex < 0) { |
| token.tokenString = sqlString.substring(currentPosition, |
| limit); |
| token.tokenType = quoteChar == '\'' ? Tokens.X_MALFORMED_STRING |
| : Tokens |
| .X_MALFORMED_IDENTIFIER; |
| token.isMalformed = true; |
| |
| return; |
| } |
| |
| if (charAt(nextIndex + 1) == quoteChar) { |
| nextIndex += 1; |
| |
| charWriter.write(sqlString, currentPosition, |
| nextIndex - currentPosition); |
| |
| currentPosition = nextIndex + 1; |
| |
| continue; |
| } else { |
| charWriter.write(sqlString, currentPosition, |
| nextIndex - currentPosition); |
| |
| currentPosition = nextIndex + 1; |
| |
| break; |
| } |
| } |
| } |
| |
| /** |
| * token [separator] , nondelimiter {delimiter | separator} |
| */ |
| void scanToken() { |
| |
| int character = charAt(currentPosition); |
| |
| resetState(); |
| |
| token.tokenType = Tokens.X_IDENTIFIER; |
| |
| switch (character) { |
| |
| /* |
| case '%' : |
| case '^' : |
| case '&' : |
| case ':' : |
| case '{' : |
| case '}' : |
| break; |
| */ |
| case '[' : |
| token.tokenString = Tokens.T_LEFTBRACKET; |
| token.tokenType = Tokens.LEFTBRACKET; |
| |
| currentPosition++; |
| |
| token.isDelimiter = true; |
| |
| return; |
| |
| case ']' : |
| token.tokenString = Tokens.T_RIGHTBRACKET; |
| token.tokenType = Tokens.RIGHTBRACKET; |
| |
| currentPosition++; |
| |
| token.isDelimiter = true; |
| |
| return; |
| |
| case '(' : |
| token.tokenString = Tokens.T_OPENBRACKET; |
| token.tokenType = Tokens.OPENBRACKET; |
| |
| currentPosition++; |
| |
| token.isDelimiter = true; |
| |
| return; |
| |
| case ')' : |
| token.tokenString = Tokens.T_CLOSEBRACKET; |
| token.tokenType = Tokens.CLOSEBRACKET; |
| |
| currentPosition++; |
| |
| token.isDelimiter = true; |
| |
| return; |
| |
| case ',' : |
| token.tokenString = Tokens.T_COMMA; |
| token.tokenType = Tokens.COMMA; |
| |
| currentPosition++; |
| |
| token.isDelimiter = true; |
| |
| return; |
| |
| case '*' : |
| token.tokenString = Tokens.T_ASTERISK; |
| token.tokenType = Tokens.ASTERISK; |
| |
| currentPosition++; |
| |
| token.isDelimiter = true; |
| |
| return; |
| |
| case '=' : |
| token.tokenString = Tokens.T_EQUALS; |
| token.tokenType = Tokens.EQUALS; |
| |
| currentPosition++; |
| |
| token.isDelimiter = true; |
| |
| return; |
| |
| case ';' : |
| token.tokenString = Tokens.T_SEMICOLON; |
| token.tokenType = Tokens.SEMICOLON; |
| |
| currentPosition++; |
| |
| token.isDelimiter = true; |
| |
| return; |
| |
| case '+' : |
| token.tokenString = Tokens.T_PLUS; |
| token.tokenType = Tokens.PLUS; |
| |
| currentPosition++; |
| |
| token.isDelimiter = true; |
| |
| return; |
| |
| case ':' : |
| if (charAt(currentPosition + 1) == ':') { |
| currentPosition += 2; |
| token.tokenString = Tokens.T_DOUBLE_COLON; |
| token.tokenType = Tokens.COLON; |
| token.isDelimiter = true; |
| |
| return; |
| } else { |
| token.tokenString = Tokens.T_COLON; |
| token.tokenType = Tokens.COLON; |
| |
| currentPosition++; |
| |
| token.isDelimiter = true; |
| |
| return; |
| } |
| case '?' : |
| if (charAt(currentPosition + 1) == '?') { |
| if (charAt(currentPosition + 2) == '(') { |
| token.tokenString = Tokens.T_OPENBRACKET; |
| token.tokenType = Tokens.OPENBRACKET; |
| currentPosition += 3; |
| token.isDelimiter = true; |
| |
| return; |
| } else if (charAt(currentPosition + 2) == ')') { |
| token.tokenString = Tokens.T_CLOSEBRACKET; |
| token.tokenType = Tokens.CLOSEBRACKET; |
| currentPosition += 3; |
| token.isDelimiter = true; |
| |
| return; |
| } |
| } |
| |
| token.tokenString = Tokens.T_QUESTION; |
| token.tokenType = Tokens.QUESTION; |
| |
| currentPosition++; |
| |
| token.isDelimiter = true; |
| |
| return; |
| |
| case '!' : |
| if (charAt(currentPosition + 1) == '=') { |
| token.tokenString = Tokens.T_NOT_EQUALS; |
| token.tokenType = Tokens.NOT_EQUALS; |
| currentPosition += 2; |
| token.isDelimiter = true; |
| |
| return; |
| } |
| |
| token.tokenString = sqlString.substring(currentPosition, |
| currentPosition + 2); |
| token.tokenType = Tokens.X_UNKNOWN_TOKEN; |
| token.isDelimiter = true; |
| |
| return; |
| |
| case '<' : |
| if (charAt(currentPosition + 1) == '>') { |
| token.tokenString = Tokens.T_NOT_EQUALS; |
| token.tokenType = Tokens.NOT_EQUALS; |
| currentPosition += 2; |
| token.isDelimiter = true; |
| |
| return; |
| } |
| |
| if (charAt(currentPosition + 1) == '=') { |
| token.tokenString = Tokens.T_LESS_EQUALS; |
| token.tokenType = Tokens.LESS_EQUALS; |
| currentPosition += 2; |
| token.isDelimiter = true; |
| |
| return; |
| } |
| |
| token.tokenString = Tokens.T_LESS; |
| token.tokenType = Tokens.LESS; |
| |
| currentPosition++; |
| |
| token.isDelimiter = true; |
| |
| return; |
| |
| case '>' : |
| if (charAt(currentPosition + 1) == '=') { |
| token.tokenString = Tokens.T_GREATER_EQUALS; |
| token.tokenType = Tokens.GREATER_EQUALS; |
| currentPosition += 2; |
| token.isDelimiter = true; |
| |
| return; |
| } |
| |
| token.tokenString = Tokens.T_GREATER; |
| token.tokenType = Tokens.GREATER; |
| |
| currentPosition++; |
| |
| token.isDelimiter = true; |
| |
| return; |
| |
| case '|' : |
| if (charAt(currentPosition + 1) == '|') { |
| token.tokenString = Tokens.T_CONCAT; |
| token.tokenType = Tokens.CONCAT; |
| currentPosition += 2; |
| token.isDelimiter = true; |
| |
| return; |
| } |
| |
| token.tokenString = sqlString.substring(currentPosition, |
| currentPosition + 2); |
| token.tokenType = Tokens.X_UNKNOWN_TOKEN; |
| token.isDelimiter = true; |
| |
| return; |
| |
| case '/' : |
| if (charAt(currentPosition + 1) == '/') { |
| int pos = sqlString.indexOf('\r', currentPosition + 2); |
| |
| if (pos == -1) { |
| pos = sqlString.indexOf('\n', currentPosition + 2); |
| } |
| |
| if (pos == -1) { |
| pos = limit; |
| } |
| |
| token.tokenString = sqlString.substring(currentPosition |
| + 2, pos); |
| token.tokenType = Tokens.X_REMARK; |
| token.isDelimiter = true; |
| |
| return; |
| } else if (charAt(currentPosition + 1) == '*') { |
| int pos = sqlString.indexOf("*/", currentPosition + 2); |
| |
| if (pos == -1) { |
| token.tokenString = |
| sqlString.substring(currentPosition, |
| currentPosition + 2); |
| token.tokenType = Tokens.X_UNKNOWN_TOKEN; |
| token.isDelimiter = true; |
| |
| return; |
| } |
| |
| token.tokenString = sqlString.substring(currentPosition |
| + 2, pos); |
| token.tokenType = Tokens.X_REMARK; |
| token.isDelimiter = true; |
| |
| return; |
| } |
| |
| token.tokenString = Tokens.T_DIVIDE; |
| token.tokenType = Tokens.DIVIDE; |
| |
| currentPosition++; |
| |
| token.isDelimiter = true; |
| |
| return; |
| |
| case '-' : |
| if (charAt(currentPosition + 1) == '-') { |
| int pos = sqlString.indexOf('\r', currentPosition + 2); |
| |
| if (pos == -1) { |
| pos = sqlString.indexOf('\n', currentPosition + 2); |
| } |
| |
| if (pos == -1) { |
| pos = limit; |
| } |
| |
| token.tokenString = sqlString.substring(currentPosition |
| + 2, pos); |
| token.tokenType = Tokens.X_REMARK; |
| token.isDelimiter = true; |
| |
| return; |
| } |
| |
| token.tokenString = Tokens.T_MINUS; |
| token.tokenType = Tokens.MINUS; |
| |
| currentPosition++; |
| |
| token.isDelimiter = true; |
| |
| return; |
| |
| case '\"' : |
| token.tokenType = Tokens.X_DELIMITED_IDENTIFIER; |
| break; |
| |
| case '\'' : |
| scanCharacterString(); |
| |
| if (token.isMalformed) { |
| return; |
| } |
| |
| token.dataType = CharacterType.getCharacterType(Types.SQL_CHAR, |
| token.tokenString.length()); |
| token.tokenType = Tokens.X_VALUE; |
| token.isDelimiter = true; |
| |
| return; |
| |
| case 'x' : |
| case 'X' : |
| if (charAt(currentPosition + 1) == '\'') { |
| currentPosition++; |
| |
| scanBinaryString(); |
| |
| if (token.isMalformed) { |
| return; |
| } |
| |
| token.dataType = BinaryType.getBinaryType( |
| Types.SQL_VARBINARY, |
| ((BinaryData) token.tokenValue).length(null)); |
| token.tokenType = Tokens.X_VALUE; |
| |
| return; |
| } |
| break; |
| |
| case 'b' : |
| case 'B' : |
| if (charAt(currentPosition + 1) == '\'') { |
| currentPosition++; |
| |
| scanBitString(); |
| |
| if (token.isMalformed) { |
| return; |
| } |
| |
| token.dataType = BitType.getBitType( |
| Types.SQL_BIT, |
| ((BinaryData) token.tokenValue).bitLength(null)); |
| token.tokenType = Tokens.X_VALUE; |
| |
| return; |
| } |
| break; |
| |
| case 'n' : |
| case 'N' : |
| if (charAt(currentPosition + 1) == '\'') { |
| currentPosition++; |
| |
| scanCharacterString(); |
| |
| if (token.isMalformed) { |
| return; |
| } |
| |
| token.dataType = CharacterType.getCharacterType( |
| Types.SQL_CHAR, token.tokenString.length()); |
| token.tokenType = Tokens.X_VALUE; |
| |
| return; |
| } |
| break; |
| |
| case 'u' : |
| case 'U' : |
| if (charAt(currentPosition + 1) == '&') { |
| if (charAt(currentPosition + 2) == '\'') { |
| currentPosition += 2; |
| token.dataType = Type.SQL_CHAR; |
| token.tokenType = Tokens.X_VALUE; |
| |
| scanUnicodeString(); |
| |
| if (token.isMalformed) { |
| return; |
| } |
| |
| token.dataType = CharacterType.getCharacterType( |
| Types.SQL_CHAR, |
| ((String) token.tokenValue).length()); |
| |
| return; |
| } |
| } |
| break; |
| |
| case '_' : |
| |
| /** |
| * @todo 1.9.0 - review following |
| * identifier chain must not have catalog identifier |
| * character set specification to be included in the token.dataType |
| */ |
| currentPosition++; |
| |
| scanIdentifierChain(); |
| |
| if (token.isMalformed) { |
| return; |
| } |
| |
| if (token.tokenType != Tokens.X_IDENTIFIER |
| || token.namePrePrefix != null) { |
| |
| /** @todo 1.9.0 - review message malformed character set identifier */ |
| token.tokenType = Tokens.X_MALFORMED_STRING; |
| token.isMalformed = true; |
| |
| return; |
| } |
| |
| token.charsetSchema = token.namePrefix; |
| token.charsetName = token.tokenString; |
| |
| scanSeparator(); |
| |
| if (charAt(currentPosition) == '\'') { |
| scanCharacterString(); |
| |
| token.tokenType = Tokens.X_VALUE; |
| token.dataType = CharacterType.getCharacterType( |
| Types.SQL_CHAR, token.tokenString.length()); |
| token.isDelimiter = true; |
| |
| return; |
| } |
| break; |
| |
| case '0' : |
| case '1' : |
| case '2' : |
| case '3' : |
| case '4' : |
| case '5' : |
| case '6' : |
| case '7' : |
| case '8' : |
| case '9' : |
| case '.' : |
| token.tokenType = Tokens.X_VALUE; |
| |
| scanNumber(); |
| |
| return; |
| } |
| |
| scanIdentifierChain(); |
| |
| if (token.tokenType == Tokens.X_IDENTIFIER) { |
| token.isUndelimitedIdentifier = true; |
| token.tokenType = Tokens.getKeywordID(token.tokenString, |
| Tokens.X_IDENTIFIER); |
| |
| if (token.tokenType == Tokens.X_IDENTIFIER) { |
| token.tokenType = Tokens.getNonKeywordID(token.tokenString, |
| Tokens.X_IDENTIFIER); |
| } else { |
| token.isReservedIdentifier = true; |
| token.isCoreReservedIdentifier = |
| Tokens.isCoreKeyword(token.tokenType); |
| } |
| } else if (token.tokenType == Tokens.X_DELIMITED_IDENTIFIER) { |
| token.isDelimitedIdentifier = true; |
| } |
| } |
| |
| public boolean scanNull() { |
| |
| scanSeparator(); |
| |
| int character = charAt(currentPosition); |
| |
| if (character == 'N' || character == 'n') { |
| if (scanSpecialIdentifier(Tokens.T_NULL)) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| // |
| private void scanNext(int error) { |
| |
| scanNext(); |
| |
| if (token.isMalformed) { |
| throw Error.error(error); |
| } |
| } |
| |
| /** |
| * Reads the type part of the INTERVAL |
| */ |
| IntervalType scanIntervalType() { |
| |
| int precision = -1; |
| int scale = -1; |
| int startToken; |
| int endToken; |
| final int errorCode = ErrorCode.X_22006; |
| |
| startToken = endToken = token.tokenType; |
| |
| scanNext(errorCode); |
| |
| if (token.tokenType == Tokens.OPENBRACKET) { |
| scanNext(errorCode); |
| |
| if (token.dataType == null |
| || token.dataType.typeCode != Types.SQL_INTEGER) { |
| throw Error.error(errorCode); |
| } |
| |
| precision = ((Number) this.token.tokenValue).intValue(); |
| |
| scanNext(errorCode); |
| |
| if (token.tokenType == Tokens.COMMA) { |
| if (startToken != Tokens.SECOND) { |
| throw Error.error(errorCode); |
| } |
| |
| scanNext(errorCode); |
| |
| if (token.dataType == null |
| || token.dataType.typeCode != Types.SQL_INTEGER) { |
| throw Error.error(errorCode); |
| } |
| |
| scale = ((Number) token.tokenValue).intValue(); |
| |
| scanNext(errorCode); |
| } |
| |
| if (token.tokenType != Tokens.CLOSEBRACKET) { |
| throw Error.error(errorCode); |
| } |
| |
| scanNext(errorCode); |
| } |
| |
| if (token.tokenType == Tokens.TO) { |
| scanNext(errorCode); |
| |
| endToken = token.tokenType; |
| |
| scanNext(errorCode); |
| } |
| |
| if (token.tokenType == Tokens.OPENBRACKET) { |
| if (endToken != Tokens.SECOND || endToken == startToken) { |
| throw Error.error(errorCode); |
| } |
| |
| scanNext(errorCode); |
| |
| if (token.dataType == null |
| || token.dataType.typeCode != Types.SQL_INTEGER) { |
| throw Error.error(errorCode); |
| } |
| |
| scale = ((Number) token.tokenValue).intValue(); |
| |
| scanNext(errorCode); |
| |
| if (token.tokenType != Tokens.CLOSEBRACKET) { |
| throw Error.error(errorCode); |
| } |
| |
| scanNext(errorCode); |
| } |
| |
| int startIndex = ArrayUtil.find(Tokens.SQL_INTERVAL_FIELD_CODES, |
| startToken); |
| int endIndex = ArrayUtil.find(Tokens.SQL_INTERVAL_FIELD_CODES, |
| endToken); |
| |
| return IntervalType.getIntervalType(startIndex, endIndex, precision, |
| scale); |
| } |
| |
| private String intervalString; |
| private int intervalPosition; |
| private int intervalPrecision; |
| private int fractionPrecision; |
| Type dateTimeType; |
| |
| public TimestampData newDate(String s) { |
| |
| intervalPosition = 0; |
| fractionPrecision = 0; |
| dateTimeType = null; |
| intervalString = s; |
| |
| scanDateParts(2); |
| |
| if (intervalPosition != s.length()) { |
| throw Error.error(ErrorCode.X_22007); |
| } |
| |
| long seconds = HsqlDateTime.getDateSeconds(s); |
| |
| return new TimestampData(seconds); |
| } |
| |
| /** |
| * @todo 1.9.0 - review the following |
| * - misses nano fractions |
| * - misses displacement |
| * - doesn't allow single digit components |
| */ |
| public TimestampData newTimestamp(String s) { |
| |
| long zoneSeconds = 0; |
| long seconds; |
| int fraction = 0; |
| int endIndex = s.length(); |
| boolean negate; |
| boolean hasZone = false; |
| |
| intervalPosition = 0; |
| fractionPrecision = 0; |
| dateTimeType = null; |
| intervalString = s; |
| |
| scanDateParts(5); |
| |
| try { |
| seconds = HsqlDateTime.getTimestampSeconds(s.substring(0, |
| intervalPosition)); |
| } catch (Throwable e) { |
| throw Error.error(ErrorCode.X_22007); |
| } |
| |
| int position; |
| |
| fraction = scanIntervalFraction(DTIType.maxFractionPrecision); |
| position = intervalPosition; |
| negate = scanIntervalSign(); |
| |
| if (negate || position != intervalPosition) { |
| zoneSeconds = scanIntervalValue(Type.SQL_INTERVAL_HOUR_TO_MINUTE); |
| hasZone = true; |
| |
| if (negate) { |
| zoneSeconds = -zoneSeconds; |
| } |
| } |
| |
| if (zoneSeconds >= DTIType.yearToSecondFactors[2] |
| || zoneSeconds > DTIType.timezoneSecondsLimit |
| || -zoneSeconds > DTIType.timezoneSecondsLimit) { |
| throw Error.error(ErrorCode.X_22009); |
| } |
| |
| if (intervalPosition != endIndex) { |
| throw Error.error(ErrorCode.X_22007); |
| } |
| |
| int type = hasZone ? Types.SQL_TIMESTAMP_WITH_TIME_ZONE |
| : Types.SQL_TIMESTAMP; |
| |
| dateTimeType = DateTimeType.getDateTimeType(type, fractionPrecision); |
| |
| if (hasZone) { |
| seconds -= zoneSeconds; |
| } |
| |
| return new TimestampData(seconds, fraction, (int) zoneSeconds); |
| } |
| |
| void scanDateParts(int lastPart) { |
| |
| byte[] separators = DTIType.yearToSecondSeparators; |
| int i = intervalPosition; |
| final int firstPart = 0; |
| int currentPart = firstPart; |
| int currentDigits = 0; |
| |
| for (; currentPart <= lastPart; ) { |
| boolean endOfPart = false; |
| |
| if (i == intervalString.length()) { |
| if (currentPart == lastPart) { |
| endOfPart = true; |
| } else { |
| |
| // parts missing |
| throw Error.error(ErrorCode.X_22007); |
| } |
| } else { |
| int character = intervalString.charAt(i); |
| |
| if (character >= '0' && character <= '9') { |
| currentDigits++; |
| i++; |
| } else if (character == separators[currentPart]) { |
| endOfPart = true; |
| |
| if (currentPart != lastPart) { |
| i++; |
| } |
| } else if (currentPart == lastPart) { |
| endOfPart = true; |
| } else { |
| throw Error.error(ErrorCode.X_22007); |
| } |
| } |
| |
| if (endOfPart) { |
| if (currentPart == firstPart) { |
| if (currentDigits != 4) { |
| throw Error.error(ErrorCode.X_22007); |
| } |
| } else { |
| if (currentDigits != 2) { |
| throw Error.error(ErrorCode.X_22007); |
| } |
| } |
| |
| currentPart++; |
| |
| currentDigits = 0; |
| |
| if (i == intervalString.length()) { |
| break; |
| } |
| } |
| } |
| |
| intervalPosition = i; |
| } |
| |
| public TimeData newTime(String s) { |
| |
| intervalPosition = 0; |
| fractionPrecision = 0; |
| dateTimeType = null; |
| intervalString = s; |
| |
| long seconds = scanIntervalValue(Type.SQL_INTERVAL_HOUR_TO_SECOND); |
| int fraction = scanIntervalFraction(DTIType.maxFractionPrecision); |
| long zoneSeconds = 0; |
| int position = intervalPosition; |
| boolean hasZone = false; |
| boolean negate = scanIntervalSign(); |
| |
| if (position != intervalPosition) { |
| zoneSeconds = scanIntervalValue(Type.SQL_INTERVAL_HOUR_TO_MINUTE); |
| hasZone = true; |
| } |
| |
| if (intervalPosition != s.length()) { |
| throw Error.error(ErrorCode.X_22009); |
| } |
| |
| if (seconds >= DTIType.yearToSecondFactors[2]) { |
| throw Error.error(ErrorCode.X_22008); |
| } |
| |
| if (zoneSeconds > DTIType.timezoneSecondsLimit) { |
| throw Error.error(ErrorCode.X_22009); |
| } |
| |
| if (negate) { |
| zoneSeconds = -zoneSeconds; |
| } |
| |
| int type = hasZone ? Types.SQL_TIME_WITH_TIME_ZONE |
| : Types.SQL_TIME; |
| |
| dateTimeType = DateTimeType.getDateTimeType(type, fractionPrecision); |
| |
| if (hasZone) { |
| seconds -= zoneSeconds; |
| } |
| |
| return new TimeData((int) seconds, fraction, (int) zoneSeconds); |
| } |
| |
| public Object newInterval(String s, IntervalType type) { |
| |
| intervalPosition = 0; |
| intervalString = s; |
| |
| boolean negate = scanIntervalSign(); |
| long units = scanIntervalValue(type); |
| int fraction = 0; |
| |
| if (type.endIntervalType == Types.SQL_INTERVAL_SECOND) { |
| fraction = scanIntervalFraction(type.scale); |
| } |
| |
| if (intervalPosition != s.length()) { |
| throw Error.error(ErrorCode.X_22006); |
| } |
| |
| if (negate) { |
| units = -units; |
| fraction = -fraction; |
| } |
| |
| dateTimeType = type; |
| |
| if (type.defaultPrecision) { |
| dateTimeType = IntervalType.getIntervalType(type.typeCode, |
| type.startIntervalType, type.endIntervalType, |
| intervalPrecision, fractionPrecision, false); |
| } |
| |
| if (type.endPartIndex <= DTIType.INTERVAL_MONTH_INDEX) { |
| return new IntervalMonthData(units); |
| } else { |
| return new IntervalSecondData(units, fraction); |
| } |
| } |
| |
| public long scanIntervalValue(IntervalType type) { |
| |
| byte[] separators = DTIType.yearToSecondSeparators; |
| int[] factors = DTIType.yearToSecondFactors; |
| int[] limits = DTIType.yearToSecondLimits; |
| int firstPart = type.startPartIndex; |
| int lastPart = type.endPartIndex; |
| long totalValue = 0; |
| int currentValue = 0; |
| int i = intervalPosition; |
| int currentPart = firstPart; |
| int currentDigits = 0; |
| |
| for (; currentPart <= lastPart; ) { |
| boolean endOfPart = false; |
| |
| if (i == intervalString.length()) { |
| if (currentPart == lastPart) { |
| endOfPart = true; |
| } else { |
| throw Error.error(ErrorCode.X_22006); |
| } |
| } else { |
| int character = intervalString.charAt(i); |
| |
| if (character >= '0' && character <= '9') { |
| int digit = character - '0'; |
| |
| currentValue *= 10; |
| currentValue += digit; |
| |
| currentDigits++; |
| i++; |
| } else if (character == separators[currentPart]) { |
| endOfPart = true; |
| |
| if (currentPart != lastPart) { |
| i++; |
| } |
| } else if (currentPart == lastPart) { |
| endOfPart = true; |
| } else { |
| throw Error.error(ErrorCode.X_22006); |
| } |
| } |
| |
| if (endOfPart) { |
| if (currentPart == firstPart) { |
| if (!type.defaultPrecision |
| && currentDigits > type.precision) { |
| throw Error.error(ErrorCode.X_22015); |
| } |
| |
| if (currentDigits == 0) { |
| throw Error.error(ErrorCode.X_22006); |
| } |
| |
| int factor = factors[currentPart]; |
| |
| totalValue += (long) currentValue * factor; |
| intervalPrecision = currentDigits; |
| } else { |
| if (currentValue >= limits[currentPart]) { |
| throw Error.error(ErrorCode.X_22015); |
| } |
| |
| if (currentDigits != 2) { |
| throw Error.error(ErrorCode.X_22006); |
| } |
| |
| totalValue += currentValue * factors[currentPart]; |
| } |
| |
| currentPart++; |
| |
| currentValue = 0; |
| currentDigits = 0; |
| |
| if (i == intervalString.length()) { |
| break; |
| } |
| } |
| } |
| |
| intervalPosition = i; |
| |
| return totalValue; |
| } |
| |
| boolean scanIntervalSign() { |
| |
| boolean negate = false; |
| |
| if (intervalPosition == intervalString.length()) { |
| return false; |
| } |
| |
| if (intervalString.charAt(intervalPosition) == '-') { |
| negate = true; |
| |
| intervalPosition++; |
| } else if (intervalString.charAt(intervalPosition) == '+') { |
| intervalPosition++; |
| } |
| |
| return negate; |
| } |
| |
| int scanIntervalFraction(int decimalPrecision) { |
| |
| if (intervalPosition == intervalString.length()) { |
| return 0; |
| } |
| |
| if (intervalString.charAt(intervalPosition) != '.') { |
| return 0; |
| } |
| |
| intervalPosition++; |
| |
| int currentValue = 0; |
| int currentDigits = 0; |
| |
| for (; intervalPosition < intervalString.length(); ) { |
| int character = intervalString.charAt(intervalPosition); |
| |
| if (character >= '0' && character <= '9') { |
| int digit = character - '0'; |
| |
| currentValue *= 10; |
| currentValue += digit; |
| |
| intervalPosition++; |
| currentDigits++; |
| |
| if (currentDigits == DTIType.maxFractionPrecision) { |
| break; |
| } |
| } else { |
| break; |
| } |
| } |
| |
| fractionPrecision = currentDigits; |
| currentValue *= DTIType.nanoScaleFactors[currentDigits]; |
| currentValue = DTIType.normaliseFraction(currentValue, |
| decimalPrecision); |
| |
| return currentValue; |
| } |
| |
| void scanIntervalSpaces() { |
| |
| for (; intervalPosition < intervalString.length(); |
| intervalPosition++) { |
| if (intervalString.charAt(intervalPosition) != ' ') { |
| break; |
| } |
| } |
| } |
| |
| /* |
| * synchronized methods for use with shared Scanner objects used for type |
| * conversion |
| */ |
| public synchronized Number convertToNumber(String s, |
| NumberType numberType) { |
| |
| Number number; |
| boolean minus = false; |
| Type type; |
| |
| reset(s); |
| resetState(); |
| scanWhitespace(); |
| scanToken(); |
| scanWhitespace(); |
| |
| if (token.tokenType == Tokens.PLUS) { |
| scanToken(); |
| scanWhitespace(); |
| } else if (token.tokenType == Tokens.MINUS) { |
| minus = true; |
| |
| scanToken(); |
| scanWhitespace(); |
| } |
| |
| if (!hasNonSpaceSeparator && token.tokenType == Tokens.X_VALUE |
| && token.tokenValue instanceof Number) { |
| number = (Number) token.tokenValue; |
| type = token.dataType; |
| |
| if (minus) { |
| number = (Number) token.dataType.negate(number); |
| } |
| |
| scanEnd(); |
| |
| if (token.tokenType == Tokens.X_ENDPARSE) { |
| number = (Number) numberType.convertToType(null, number, type); |
| |
| return number; |
| } |
| } |
| |
| throw Error.error(ErrorCode.X_22018); |
| } |
| |
| public synchronized BinaryData convertToBinary(String s) { |
| |
| boolean hi = true; |
| byte b = 0; |
| |
| reset(s); |
| resetState(); |
| byteOutputStream.reset(byteBuffer); |
| |
| for (; currentPosition < limit; currentPosition++, hi = !hi) { |
| int c = sqlString.charAt(currentPosition); |
| |
| c = getHexValue(c); |
| |
| if (c == -1) { |
| |
| // bad character |
| token.tokenType = Tokens.X_MALFORMED_BINARY_STRING; |
| token.isMalformed = true; |
| |
| break; |
| } |
| |
| if (hi) { |
| b = (byte) (c << 4); |
| } else { |
| b += (byte) c; |
| |
| byteOutputStream.writeByte(b); |
| } |
| } |
| |
| if (!hi) { |
| |
| // odd nibbles |
| token.tokenType = Tokens.X_MALFORMED_BINARY_STRING; |
| token.isMalformed = true; |
| } |
| |
| if (token.isMalformed) { |
| throw Error.error(ErrorCode.X_22018); |
| } |
| |
| BinaryData data = new BinaryData(byteOutputStream.toByteArray(), |
| false); |
| |
| byteOutputStream.reset(byteBuffer); |
| |
| return data; |
| } |
| |
| public synchronized BinaryData convertToBit(String s) { |
| |
| BitMap map = new BitMap(32); |
| int bitIndex = map.size(); |
| |
| reset(s); |
| resetState(); |
| byteOutputStream.reset(byteBuffer); |
| |
| for (; currentPosition < limit; currentPosition++) { |
| int c = sqlString.charAt(currentPosition); |
| |
| if (c == '0') { |
| bitIndex++; |
| } else if (c == '1') { |
| map.set(bitIndex); |
| |
| bitIndex++; |
| } else { |
| token.tokenType = Tokens.X_MALFORMED_BIT_STRING; |
| token.isMalformed = true; |
| |
| throw Error.error(ErrorCode.X_22018); |
| } |
| } |
| |
| map.setSize(bitIndex); |
| |
| return BinaryData.getBitData(map.getBytes(), map.size()); |
| } |
| |
| // should perform range checks etc. |
| public synchronized Object convertToDatetimeInterval( |
| SessionInterface session, String s, DTIType type) { |
| |
| Object value; |
| IntervalType intervalType = null; |
| int dateTimeToken = -1; |
| int errorCode = type.isDateTimeType() ? ErrorCode.X_22007 |
| : ErrorCode.X_22006; |
| |
| reset(s); |
| resetState(); |
| scanToken(); |
| scanWhitespace(); |
| |
| switch (token.tokenType) { |
| |
| case Tokens.INTERVAL : |
| case Tokens.DATE : |
| case Tokens.TIME : |
| case Tokens.TIMESTAMP : |
| dateTimeToken = token.tokenType; |
| |
| scanToken(); |
| |
| if (token.tokenType != Tokens.X_VALUE |
| || token.dataType.typeCode != Types.SQL_CHAR) { |
| |
| // error datetime bad literal |
| throw Error.error(errorCode); |
| } |
| |
| s = token.tokenString; |
| |
| scanNext(ErrorCode.X_22007); |
| |
| if (type.isIntervalType()) { |
| intervalType = scanIntervalType(); |
| } |
| |
| if (token.tokenType != Tokens.X_ENDPARSE) { |
| throw Error.error(errorCode); |
| } |
| |
| // fall through |
| default : |
| } |
| |
| switch (type.typeCode) { |
| |
| case Types.SQL_DATE : { |
| if (dateTimeToken != -1 && dateTimeToken != Tokens.DATE) { |
| throw Error.error(errorCode); |
| } |
| |
| value = newDate(s); |
| |
| return type.convertToType(session, value, Type.SQL_DATE); |
| } |
| case Types.SQL_TIME : |
| case Types.SQL_TIME_WITH_TIME_ZONE : { |
| if (dateTimeToken != -1 && dateTimeToken != Tokens.TIME) { |
| throw Error.error(errorCode); |
| } |
| |
| Object o = newTime(s); |
| |
| return type.convertToType(session, o, dateTimeType); |
| } |
| case Types.SQL_TIMESTAMP : |
| case Types.SQL_TIMESTAMP_WITH_TIME_ZONE : { |
| if (dateTimeToken != -1 && dateTimeToken != Tokens.TIMESTAMP) { |
| throw Error.error(errorCode); |
| } |
| |
| value = newTimestamp(s); |
| |
| return type.convertToType(session, value, dateTimeType); |
| } |
| default : |
| if (dateTimeToken != -1 && dateTimeToken != Tokens.INTERVAL) { |
| throw Error.error(errorCode); |
| } |
| |
| if (type.isIntervalType()) { |
| value = newInterval(s, (IntervalType) type); |
| |
| if (intervalType != null) { |
| if (intervalType.startIntervalType != type |
| .startIntervalType || intervalType |
| .endIntervalType != type.endIntervalType) { |
| throw Error.error(errorCode); |
| } |
| } |
| |
| return type.convertToType(session, value, dateTimeType); |
| } |
| |
| throw Error.runtimeError(ErrorCode.U_S0500, "Scanner"); |
| } |
| } |
| } |
