escapeprocessor.java

在资料浩瀚的互联网中

                             * For now, we get the fractional seconds
                             * part, but we don't use it, as MySQL doesn't
                             * support it in it's TIMESTAMP data type
                             *
                            String fractionalSecond = "";

                            if (st.hasMoreTokens()) {
                                fractionalSecond = st.nextToken();
                            }
                            */
                            /*
                             * Use the full format because number format
                             * will not work for "between" clauses.
                             *
                             * Ref. Mysql Docs
                             *
                             * You can specify DATETIME, DATE and TIMESTAMP values
                             * using any of a common set of formats:
                             *
                             * As a string in either 'YYYY-MM-DD HH:MM:SS' or
                             * 'YY-MM-DD HH:MM:SS' format.
                             *
                             * Thanks to Craig Longman for pointing out this bug
                             */
                            newSql.append("'").append(year4).append("-")
                                  .append(month2).append("-").append(day2)
                                  .append(" ").append(hour).append(":")
                                  .append(minute).append(":").append(second)
                                  .append("'");
                        } catch (java.util.NoSuchElementException e) {
                            throw new SQLException(
                                "Syntax error for TIMESTAMP escape sequence '"
                                + argument + "'", "42000");
                        }
                    } else if (StringUtils.startsWithIgnoreCase(
                                collapsedToken, "{t")) {
                        int startPos = token.indexOf('\'') + 1;
                        int endPos = token.lastIndexOf('\''); // no }

                        if ((startPos == -1) || (endPos == -1)) {
                            throw new SQLException(
                                "Syntax error for TIME escape sequence '"
                                + token + "'", "42000");
                        }

                        String argument = token.substring(startPos, endPos);

                        try {
                            StringTokenizer st = new StringTokenizer(argument,
                                    " :");
                            String hour = st.nextToken();
                            String minute = st.nextToken();
                            String second = st.nextToken();
                            String timeString = "'" + hour + ":" + minute + ":"
                                + second + "'";
                            newSql.append(timeString);
                        } catch (java.util.NoSuchElementException e) {
                            throw new SQLException(
                                "Syntax error for escape sequence '" + argument
                                + "'", "42000");
                        }
                    } else if (StringUtils.startsWithIgnoreCase(
                                collapsedToken, "{call")
                            || StringUtils.startsWithIgnoreCase(
                                collapsedToken, "{?=call")) {
                       
                        int startPos = StringUtils.indexOfIgnoreCase(token, "CALL") + 5;
                        int endPos = token.length() - 1;

                        newSql.append("CALL ");
                        newSql.append(token.substring(startPos, endPos));
                    } else if (StringUtils.startsWithIgnoreCase(
                                collapsedToken, "{oj")) {
                        // MySQL already handles this escape sequence
                        // because of ODBC. Cool.
                        newSql.append(token);
                    }
                } else {
                    newSql.append(token); // it's just part of the query
                }
            }
        }

        String escapedSql = newSql.toString();

        //
        // FIXME: Let MySQL do this, however requires
        //        lightweight parsing of statement
        //
        if (replaceEscapeSequence) {
            String currentSql = escapedSql;

            while (currentSql.indexOf(escapeSequence) != -1) {
                int escapePos = currentSql.indexOf(escapeSequence);
                String lhs = currentSql.substring(0, escapePos);
                String rhs = currentSql.substring(escapePos + 1,
                        currentSql.length());
                currentSql = lhs + "\\" + rhs;
            }

            escapedSql = currentSql;
        }

        EscapeProcessorResult epr = new EscapeProcessorResult();
        epr.escapedSql = escapedSql;
        
        if (usesVariables != Statement.USES_VARIABLES_TRUE) {
        	if (escapeTokenizer.sawVariableUse()) {
        		epr.usesVariables = Statement.USES_VARIABLES_TRUE;
        	} else {
        		epr.usesVariables = Statement.USES_VARIABLES_FALSE;
        	}
        }
        
        return epr;
    }

    /**
     * Removes all whitespace from the given String. We use this to make escape
     * token comparison white-space ignorant.
     *
     * @param toCollapse the string to remove the whitespace from
     *
     * @return a string with _no_ whitespace.
     */
    private static String removeWhitespace(String toCollapse) {
        if (toCollapse == null) {
            return null;
        }

        int length = toCollapse.length();

        StringBuffer collapsed = new StringBuffer(length);

        for (int i = 0; i < length; i++) {
            char c = toCollapse.charAt(i);

            if (!Character.isWhitespace(c)) {
                collapsed.append(c);
            }
        }

        return collapsed.toString();
    }

	/**
	 * Re-writes {fn convert (expr, type)} as cast(expr AS type)
	 * @param functionToken
	 * @return
	 * @throws SQLException
	 */
	private static String processConvertToken(String functionToken, boolean serverSupportsConvertFn) throws SQLException {
		// The JDBC spec requires these types:
		//
		// BIGINT
		// BINARY
		// BIT
		// CHAR
		// DATE
		// DECIMAL
		// DOUBLE
		// FLOAT
		// INTEGER
		// LONGVARBINARY
		// LONGVARCHAR
		// REAL
		// SMALLINT
		// TIME
		// TIMESTAMP
		// TINYINT
		// VARBINARY
		// VARCHAR
		
		// MySQL supports these types:
		//
		// BINARY
		// CHAR
		// DATE
		// DATETIME
		// SIGNED (integer)
		// UNSIGNED (integer)
		// TIME
		
		int firstIndexOfParen = functionToken.indexOf("(");
		
		if (firstIndexOfParen == -1) {
			throw new SQLException("Syntax error while processing {fn convert (... , ...)} token, missing opening parenthesis in token '" + functionToken + "'.", SQLError.SQL_STATE_SYNTAX_ERROR);
		}
		
		int tokenLength = functionToken.length();
		
		int indexOfComma = functionToken.lastIndexOf(",");
	
		if (indexOfComma == -1) {
			throw new SQLException("Syntax error while processing {fn convert (... , ...)} token, missing comma in token '" + functionToken + "'.", SQLError.SQL_STATE_SYNTAX_ERROR);
		}
	
		int indexOfCloseParen = functionToken.indexOf(')', indexOfComma);
		
		if (indexOfCloseParen == -1) {
			throw new SQLException("Syntax error while processing {fn convert (... , ...)} token, missing closing parenthesis in token '" + functionToken + "'.", SQLError.SQL_STATE_SYNTAX_ERROR);
			
		}
	
		String expression = functionToken.substring(firstIndexOfParen + 1, indexOfComma);
		String type = functionToken.substring(indexOfComma + 1, indexOfCloseParen);
		
		String newType = null;
		
		String trimmedType = type.trim();
		
		if (StringUtils.startsWithIgnoreCase(trimmedType, "SQL_")) {
			trimmedType = trimmedType.substring(4, trimmedType.length());
		}
		
		if (serverSupportsConvertFn) {
			newType = (String)JDBC_CONVERT_TO_MYSQL_TYPE_MAP.get(trimmedType.toUpperCase(Locale.ENGLISH));
		} else {
			newType = (String)JDBC_NO_CONVERT_TO_MYSQL_EXPRESSION_MAP.get(trimmedType.toUpperCase(Locale.ENGLISH));
			
			// We need a 'special' check here to give a better error message. If we're in this
			// block, the version of MySQL we're connected to doesn't support CAST/CONVERT,
			// so we can't re-write some data type conversions (date,time,timestamp, datetime)
			
			if (newType == null) {
				throw new SQLException("Can't find conversion re-write for type '" + type + "' that is applicable for this server version while processing escape tokens.", SQLError.SQL_STATE_GENERAL_ERROR);
			}
		}
		
		if (newType == null) {
			throw new SQLException("Unsupported conversion type '" + type.trim() + "' found while processing escape token.", SQLError.SQL_STATE_GENERAL_ERROR);
		}
		
		int replaceIndex = newType.indexOf("?");
		
		if (replaceIndex != -1) {
			StringBuffer convertRewrite = new StringBuffer(newType.substring(0, replaceIndex));
			convertRewrite.append(expression);
			convertRewrite.append(newType.substring(replaceIndex + 1, newType.length()));
			
			return convertRewrite.toString();
		} else {
		
			StringBuffer castRewrite = new StringBuffer("CAST(");
			castRewrite.append(expression);
			castRewrite.append(" AS ");
			castRewrite.append(newType);
			castRewrite.append(")");
		
			return castRewrite.toString();
		}
	}
}