escapeprocessor.java

mysql的jdbc驱动

							 * 
							 * 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;

						if (StringUtils.startsWithIgnoreCase(collapsedToken,
								"{?=call")) {
							callingStoredFunction = true;
							newSql.append("SELECT ");
							newSql.append(token.substring(startPos, endPos));
						} else {
							callingStoredFunction = false;
							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;
		epr.callingStoredFunction = callingStoredFunction;

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

		return epr;
	}

	/**
	 * 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();
		}
	}

	/**
	 * 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();
	}
}