escapeprocessor.java

用于JAVA数据库连接.解压就可用,方便得很

											int indexOfDot = timezoneLiteral.indexOf(".");
											
											if (indexOfDot != -1) {
												timezoneLiteral = timezoneLiteral.substring(0, indexOfDot);
											}
											
											newSql.append(timezoneLiteral);
										}
										
										newSql.append("'");	
										
									
									} catch (NumberFormatException nfe) {
										throw SQLError.createSQLException("Syntax error in TIMESTAMP escape sequence '" 
											+ token + "'.",
											SQLError.SQL_STATE_ILLEGAL_ARGUMENT);
									}
								}
							} catch (java.util.NoSuchElementException e) {
								throw SQLError.createSQLException(
										"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)) {
							newSql.append(token); // it's just part of the query, push possible syntax errors onto server's shoulders
						} else {

							String argument = token.substring(startPos, endPos);
	
							try {
								StringTokenizer st = new StringTokenizer(argument,
										" :");
								String hour = st.nextToken();
								String minute = st.nextToken();
								String second = st.nextToken();
								
								if (!conn.getUseTimezone()) {
									String timeString = "'" + hour + ":" + minute + ":"
										+ second + "'";
									newSql.append(timeString);
								} else {
									Calendar sessionCalendar = null;
									
									if (conn != null) {
										sessionCalendar = conn.getCalendarInstanceForSessionOrNew();
									} else {
										sessionCalendar = new GregorianCalendar();
									}
	
									try {
										int hourInt = Integer.parseInt(hour);
										int minuteInt = Integer.parseInt(minute);
										int secondInt = Integer.parseInt(second);
										
										synchronized (sessionCalendar) {
											Time toBeAdjusted = TimeUtil.fastTimeCreate(
													sessionCalendar,
													hourInt,
													minuteInt,
													secondInt);
											
											Time inServerTimezone = TimeUtil.changeTimezone(
													conn,
													sessionCalendar,
													null,
													toBeAdjusted,
													sessionCalendar.getTimeZone(),
													conn.getServerTimezoneTZ(),
													false);
											
											newSql.append("'");
											newSql.append(inServerTimezone.toString());
											newSql.append("'");		
										}
									
									} catch (NumberFormatException nfe) {
										throw SQLError.createSQLException("Syntax error in TIMESTAMP escape sequence '" 
											+ token + "'.",
											SQLError.SQL_STATE_ILLEGAL_ARGUMENT);
									}
								}
							} catch (java.util.NoSuchElementException e) {
								throw SQLError.createSQLException(
										"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));
						}
						
						for (int i = endPos - 1; i >= startPos; i--) {
							char c = token.charAt(i);
							
							if (Character.isWhitespace(c)) {
								continue;
							}
							
							if (c != ')') {
								newSql.append("()");  // handle no-parenthesis no-arg call not supported
			                                         // by MySQL parser
							}
							
							break;
						}
					} 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 != StatementImpl.USES_VARIABLES_TRUE) {
			if (escapeTokenizer.sawVariableUse()) {
				epr.usesVariables = StatementImpl.USES_VARIABLES_TRUE;
			} else {
				epr.usesVariables = StatementImpl.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 SQLError.createSQLException(
					"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 SQLError.createSQLException(
					"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 SQLError.createSQLException(
					"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 SQLError.createSQLException(
						"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 SQLError.createSQLException("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();
	}
}