/**
* Returns a Result for setting the XML value designated by this SQLXML instance.
*
* <p>The systemID of the Result is implementation dependent.
*
* <p>The SQL XML object becomes not writeable when this method is called and may also become not
* readable depending on implementation.
*
* <p>Note that SAX is a callback architecture and the returned SAXResult has a content handler
* assigned that will receive the SAX events based on the contents of the XML. Call the content
* handler with the contents of the XML document to assign the values.
*
* <pre>
* SAXResult saxResult = sqlxml.setResult(SAXResult.class);
* ContentHandler contentHandler = saxResult.getXMLReader().getContentHandler();
* contentHandler.startDocument();
* // set the XML elements and attributes into the result
* contentHandler.endDocument();
* </pre>
*
* @param resultClass The class of the result, or null. If resultClass is null, a vendor specific
* Result implementation will be returned. The following classes are supported at a minimum:
* <pre>
* javax.xml.transform.dom.DOMResult - returns a DOMResult
* javax.xml.transform.sax.SAXResult - returns a SAXResult
* javax.xml.transform.stax.StAXResult - returns a StAXResult
* javax.xml.transform.stream.StreamResult - returns a StreamResult
* </pre>
*
* @return Returns a Result for setting the XML value.
* @throws SQLException if there is an error processing the XML value or if this feature is not
* supported. The getCause() method of the exception may provide a more detailed exception,
* for example, if an XML parser exception occurs. An exception is thrown if the state is not
* writable.
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support this method
* @since 1.6
*/
public synchronized Result setResult(Class clazz) throws SQLException {
checkClosed();
checkWorkingWithResult();
this.workingWithResult = true;
this.asDOMResult = null;
this.asSAXResult = null;
this.saxToReaderConverter = null;
this.stringRep = null;
this.asStringWriter = null;
this.asByteArrayOutputStream = null;
if (clazz == null || clazz.equals(SAXResult.class)) {
this.saxToReaderConverter = new SimpleSaxToReader();
this.asSAXResult = new SAXResult(this.saxToReaderConverter);
return this.asSAXResult;
} else if (clazz.equals(DOMResult.class)) {
this.asDOMResult = new DOMResult();
return this.asDOMResult;
} else if (clazz.equals(StreamResult.class)) {
return new StreamResult(setCharacterStreamInternal());
} else if (clazz.equals(StAXResult.class)) {
try {
if (this.outputFactory == null) {
this.outputFactory = XMLOutputFactory.newInstance();
}
return new StAXResult(
this.outputFactory.createXMLEventWriter(setCharacterStreamInternal()));
} catch (XMLStreamException ex) {
SQLException sqlEx =
SQLError.createSQLException(
ex.getMessage(), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
sqlEx.initCause(ex);
throw sqlEx;
}
} else {
throw SQLError.createSQLException(
"XML Result of type \"" + clazz.toString() + "\" Not supported.",
SQLError.SQL_STATE_ILLEGAL_ARGUMENT,
this.exceptionInterceptor);
}
}
/**
* Get a description of the access rights for a table's columns.
*
* <p>Only privileges matching the column name criteria are returned. They are ordered by
* COLUMN_NAME and PRIVILEGE.
*
* <p>Each privilige description has the following columns:
*
* <OL>
* <li><B>TABLE_CAT</B> String => table catalog (may be null)
* <li><B>TABLE_SCHEM</B> String => table schema (may be null)
* <li><B>TABLE_NAME</B> String => table name
* <li><B>COLUMN_NAME</B> String => column name
* <li><B>GRANTOR</B> => grantor of access (may be null)
* <li><B>GRANTEE</B> String => grantee of access
* <li><B>PRIVILEGE</B> String => name of access (SELECT, INSERT, UPDATE, REFRENCES, ...)
* <li><B>IS_GRANTABLE</B> String => "YES" if grantee is permitted to grant to others; "NO" if
* not; null if unknown
* </ol>
*
* @param catalog a catalog name; "" retrieves those without a catalog
* @param schema a schema name; "" retrieves those without a schema
* @param table a table name
* @param columnNamePattern a column name pattern
* @return ResultSet each row is a column privilege description
* @throws SQLException if a database access error occurs
* @see #getSearchStringEscape
*/
public java.sql.ResultSet getColumnPrivileges(
String catalog, String schema, String table, String columnNamePattern) throws SQLException {
if (columnNamePattern == null) {
if (this.conn.getNullNamePatternMatchesAll()) {
columnNamePattern = "%";
} else {
throw SQLError.createSQLException(
"Column name pattern can not be NULL or empty.", SQLError.SQL_STATE_ILLEGAL_ARGUMENT);
}
}
if (catalog == null) {
if (this.conn.getNullCatalogMeansCurrent()) {
catalog = this.database;
}
}
String sql =
"SELECT TABLE_SCHEMA AS TABLE_CAT, NULL AS TABLE_SCHEM, TABLE_NAME,"
+ "COLUMN_NAME, NULL AS GRANTOR, GRANTEE, PRIVILEGE_TYPE AS PRIVILEGE, IS_GRANTABLE FROM "
+ "INFORMATION_SCHEMA.COLUMN_PRIVILEGES WHERE "
+ "TABLE_SCHEMA LIKE ? AND "
+ "TABLE_NAME =? AND COLUMN_NAME LIKE ? ORDER BY "
+ "COLUMN_NAME, PRIVILEGE_TYPE";
PreparedStatement pStmt = null;
try {
pStmt = prepareMetaDataSafeStatement(sql);
if (catalog != null) {
pStmt.setString(1, catalog);
} else {
pStmt.setString(1, "%");
}
pStmt.setString(2, table);
pStmt.setString(3, columnNamePattern);
ResultSet rs = executeMetadataQuery(pStmt);
((com.mysql.jdbc.ResultSet) rs)
.redefineFieldsForDBMD(
new Field[] {
new Field("", "TABLE_CAT", Types.CHAR, 64),
new Field("", "TABLE_SCHEM", Types.CHAR, 1),
new Field("", "TABLE_NAME", Types.CHAR, 64),
new Field("", "COLUMN_NAME", Types.CHAR, 64),
new Field("", "GRANTOR", Types.CHAR, 77),
new Field("", "GRANTEE", Types.CHAR, 77),
new Field("", "PRIVILEGE", Types.CHAR, 64),
new Field("", "IS_GRANTABLE", Types.CHAR, 3)
});
return rs;
} finally {
if (pStmt != null) {
pStmt.close();
}
}
}
/**
* Returns the next row.
*
* @return the next row value
* @throws SQLException if a database error occurs
*/
public ResultSetRow next() throws SQLException {
if (this.fetchedRows == null && this.currentPositionInEntireResult != BEFORE_START_OF_ROWS) {
throw SQLError.createSQLException(
Messages.getString(
"ResultSet.Operation_not_allowed_after_ResultSet_closed_144"), //$NON-NLS-1$
SQLError.SQL_STATE_GENERAL_ERROR,
mysql.getExceptionInterceptor());
}
if (!hasNext()) {
return null;
}
this.currentPositionInEntireResult++;
this.currentPositionInFetchedRows++;
// Catch the forced scroll-passed-end
if (this.fetchedRows != null && this.fetchedRows.size() == 0) {
return null;
}
if (this.currentPositionInFetchedRows > (this.fetchedRows.size() - 1)) {
fetchMoreRows();
this.currentPositionInFetchedRows = 0;
}
ResultSetRow row = this.fetchedRows.get(this.currentPositionInFetchedRows);
row.setMetadata(this.metadata);
return row;
}
/**
* Try to make a database connection to the given URL. The driver should return "null" if it
* realizes it is the wrong kind of driver to connect to the given URL. This will be common, as
* when the JDBC driverManager is asked to connect to a given URL, it passes the URL to each
* loaded driver in turn.
*
* <p>The driver should raise an SQLException if it is the right driver to connect to the given
* URL, but has trouble connecting to the database.
*
* <p>The java.util.Properties argument can be used to pass arbitrary string tag/value pairs as
* connection arguments.
*
* <p>My protocol takes the form:
*
* <PRE>
*
* jdbc:mysql://host:port/database
*
* </PRE>
*
* @param url the URL of the database to connect to
* @param info a list of arbitrary tag/value pairs as connection arguments
* @return a connection to the URL or null if it isnt us
* @exception SQLException if a database access error occurs
* @see java.sql.Driver#connect
*/
public java.sql.Connection connect(String url, Properties info) throws SQLException {
if (url != null) {
if (StringUtils.startsWithIgnoreCase(url, LOADBALANCE_URL_PREFIX)) {
return connectLoadBalanced(url, info);
} else if (StringUtils.startsWithIgnoreCase(url, REPLICATION_URL_PREFIX)) {
return connectReplicationConnection(url, info);
}
}
Properties props = null;
if ((props = parseURL(url, info)) == null) {
return null;
}
try {
Connection newConn =
new com.mysql.jdbc.Connection(host(props), port(props), props, database(props), url);
return newConn;
} catch (SQLException sqlEx) {
// Don't wrap SQLExceptions, throw
// them un-changed.
throw sqlEx;
} catch (Exception ex) {
throw SQLError.createSQLException(
Messages.getString("NonRegisteringDriver.17") // $NON-NLS-1$
+ ex.toString()
+ Messages.getString("NonRegisteringDriver.18"), // $NON-NLS-1$
SQLError.SQL_STATE_UNABLE_TO_CONNECT_TO_DATASOURCE);
}
}
/**
* Parses hostPortPair in the form of [host][:port] into an array, with the element of index
* HOST_NAME_INDEX being the host (or null if not specified), and the element of index
* PORT_NUMBER_INDEX being the port (or null if not specified).
*
* @param hostPortPair host and port in form of of [host][:port]
* @return array containing host and port as Strings
* @throws SQLException if a parse error occurs
*/
protected static String[] parseHostPortPair(String hostPortPair) throws SQLException {
int portIndex = hostPortPair.indexOf(":"); // $NON-NLS-1$
String[] splitValues = new String[2];
String hostname = null;
if (portIndex != -1) {
if ((portIndex + 1) < hostPortPair.length()) {
String portAsString = hostPortPair.substring(portIndex + 1);
hostname = hostPortPair.substring(0, portIndex);
splitValues[HOST_NAME_INDEX] = hostname;
splitValues[PORT_NUMBER_INDEX] = portAsString;
} else {
throw SQLError.createSQLException(
Messages.getString("NonRegisteringDriver.37"), // $NON-NLS-1$
SQLError.SQL_STATE_INVALID_CONNECTION_ATTRIBUTE);
}
} else {
splitValues[HOST_NAME_INDEX] = hostPortPair;
splitValues[PORT_NUMBER_INDEX] = null;
}
return splitValues;
}
/**
* Convenience method for turning a byte[] into a string with the given encoding.
*
* @param encoding the Java encoding name for the byte[] -> char conversion
* @param conn the MySQLConnection that created the result set
* @param value the String value as a series of bytes, encoded using "encoding"
* @param offset where to start the decoding
* @param length how many bytes to decode
* @return the String as decoded from bytes with the given encoding
* @throws SQLException if an error occurs
*/
protected String getString(
String encoding, MySQLConnection conn, byte[] value, int offset, int length)
throws SQLException {
String stringVal = null;
if ((conn != null) && conn.getUseUnicode()) {
try {
if (encoding == null) {
stringVal = StringUtils.toString(value);
} else {
SingleByteCharsetConverter converter = conn.getCharsetConverter(encoding);
if (converter != null) {
stringVal = converter.toString(value, offset, length);
} else {
stringVal = StringUtils.toString(value, offset, length, encoding);
}
}
} catch (java.io.UnsupportedEncodingException E) {
throw SQLError.createSQLException(
Messages.getString("ResultSet.Unsupported_character_encoding____101") // $NON-NLS-1$
+ encoding
+ "'.",
"0S100",
this.exceptionInterceptor);
}
} else {
stringVal = StringUtils.toAsciiString(value, offset, length);
}
return stringVal;
}
/**
* Removes a host from the host list.
*
* @param host The host to be removed.
* @throws SQLException
*/
public synchronized void removeHost(String host) throws SQLException {
if (this.connectionGroup != null) {
if (this.connectionGroup.getInitialHosts().size() == 1
&& this.connectionGroup.getInitialHosts().contains(host)) {
throw SQLError.createSQLException("Cannot remove only configured host.", null);
}
this.hostToRemove = host;
if (host.equals(this.currentConnection.getHost())) {
closeAllConnections();
} else {
this.connectionsToHostsMap.remove(this.liveConnections.remove(host));
Integer idx = this.hostsToListIndexMap.remove(host);
long[] newResponseTimes = new long[this.responseTimes.length - 1];
int newIdx = 0;
for (Iterator<String> i = this.hostList.iterator(); i.hasNext(); newIdx++) {
String copyHost = i.next();
if (idx != null && idx < this.responseTimes.length) {
newResponseTimes[newIdx] = this.responseTimes[idx];
this.hostsToListIndexMap.put(copyHost, newIdx);
}
}
this.responseTimes = newResponseTimes;
}
}
}
public synchronized void truncate(long len) throws SQLException {
checkClosed();
if (len < 0L) {
throw SQLError.createSQLException(
"\"len\" argument can not be < 1.", "S1009", this.exceptionInterceptor);
}
if (len > this.binaryData.length) {
throw SQLError.createSQLException(
"\"len\" argument can not be larger than the BLOB's length.",
"S1009",
this.exceptionInterceptor);
}
byte[] newData = new byte[(int) len];
System.arraycopy(getBinaryData(), 0, newData, 0, (int) len);
this.binaryData = newData;
}
/**
* Creates a proxy for java.sql.Connection that routes requests between the given list of
* host:port and uses the given properties when creating connections.
*
* @param hosts
* @param props
* @throws SQLException
*/
LoadBalancingConnectionProxy(List hosts, Properties props) throws SQLException {
this.hostList = hosts;
int numHosts = this.hostList.size();
this.liveConnections = new HashMap(numHosts);
this.connectionsToHostsMap = new HashMap(numHosts);
this.responseTimes = new long[numHosts];
this.hostsToListIndexMap = new HashMap(numHosts);
for (int i = 0; i < numHosts; i++) {
this.hostsToListIndexMap.put(this.hostList.get(i), new Integer(i));
}
this.localProps = (Properties) props.clone();
this.localProps.remove(NonRegisteringDriver.HOST_PROPERTY_KEY);
this.localProps.remove(NonRegisteringDriver.PORT_PROPERTY_KEY);
this.localProps.setProperty("useLocalSessionState", "true");
String strategy = this.localProps.getProperty("loadBalanceStrategy", "random");
if ("random".equals(strategy)) {
this.balancer = new RandomBalanceStrategy();
} else if ("bestResponseTime".equals(strategy)) {
this.balancer = new BestResponseTimeBalanceStrategy();
} else {
throw SQLError.createSQLException(
Messages.getString("InvalidLoadBalanceStrategy", new Object[] {strategy}),
SQLError.SQL_STATE_ILLEGAL_ARGUMENT);
}
pickNewConnection();
}
public <T> T unwrap(java.lang.Class<T> iface) throws java.sql.SQLException {
try {
// This works for classes that aren't actually wrapping anything
return iface.cast(this);
} catch (ClassCastException cce) {
throw SQLError.createSQLException("Unable to unwrap to " + iface.toString(), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, getExceptionInterceptor());
}
}
private synchronized void checkWorkingWithResult() throws SQLException {
if (this.workingWithResult) {
throw SQLError.createSQLException(
"Can't perform requested operation after getResult() has been called to write XML data",
SQLError.SQL_STATE_ILLEGAL_ARGUMENT,
this.exceptionInterceptor);
}
}
private void nextRecord() throws SQLException {
try {
if (!this.noMoreRows) {
this.nextRow =
this.isInterrupted
? null
: this.io.nextRow(
this.metadata,
this.columnCount,
this.isBinaryEncoded,
java.sql.ResultSet.CONCUR_READ_ONLY,
true,
this.useBufferRowExplicit,
true,
null);
if (this.nextRow == null) {
this.noMoreRows = true;
this.isAfterEnd = true;
this.moreResultsExisted = this.io.tackOnMoreStreamingResults(this.owner);
if (this.index == -1) {
this.wasEmpty = true;
}
}
} else {
this.isAfterEnd = true;
}
} catch (SQLException sqlEx) {
if (sqlEx instanceof StreamingNotifiable) {
((StreamingNotifiable) sqlEx).setWasStreamingResults();
} else if (sqlEx instanceof MySQLQueryInterruptedException) {
this.isInterrupted = true;
}
// don't wrap SQLExceptions
throw sqlEx;
} catch (Exception ex) {
String exceptionType = ex.getClass().getName();
String exceptionMessage = ex.getMessage();
exceptionMessage += Messages.getString("RowDataDynamic.7");
exceptionMessage += Util.stackTraceToString(ex);
SQLException sqlEx =
SQLError.createSQLException(
Messages.getString("RowDataDynamic.8")
+ exceptionType
+ Messages.getString("RowDataDynamic.9")
+ exceptionMessage,
SQLError.SQL_STATE_GENERAL_ERROR,
this.exceptionInterceptor);
sqlEx.initCause(ex);
throw sqlEx;
}
}
/**
* Returns the field instance for the given column index
*
* @param columnIndex the column number to retrieve a field instance for
* @return the field instance for the given column index
* @throws SQLException if an error occurs
*/
protected Field getField(int columnIndex) throws SQLException {
if ((columnIndex < 1) || (columnIndex > this.fields.length)) {
throw SQLError.createSQLException(
Messages.getString("ResultSetMetaData.46"), // $NON-NLS-1$
SQLError.SQL_STATE_INVALID_COLUMN_NUMBER);
}
return this.fields[columnIndex - 1];
}
MysqlSavepoint(String name, ExceptionInterceptor exceptionInterceptor) throws SQLException {
if ((name == null) || (name.length() == 0)) {
throw SQLError.createSQLException(
"Savepoint name can not be NULL or empty", "S1009", exceptionInterceptor);
}
this.savepointName = name;
this.exceptionInterceptor = exceptionInterceptor;
}
public synchronized InputStream getBinaryStream(long pos, long length) throws SQLException {
checkClosed();
if (pos < 1L) {
throw SQLError.createSQLException(
"\"pos\" argument can not be < 1.", "S1009", this.exceptionInterceptor);
}
pos -= 1L;
if (pos > this.binaryData.length) {
throw SQLError.createSQLException(
"\"pos\" argument can not be larger than the BLOB's length.",
"S1009",
this.exceptionInterceptor);
}
if (pos + length > this.binaryData.length) {
throw SQLError.createSQLException(
"\"pos\" + \"length\" arguments can not be larger than the BLOB's length.",
"S1009",
this.exceptionInterceptor);
}
return new ByteArrayInputStream(getBinaryData(), (int) pos, (int) length);
}
/** Read string[$len] */
final String readString(
String encoding, ExceptionInterceptor exceptionInterceptor, int expectedLength)
throws SQLException {
if (this.position + expectedLength > getBufLength()) {
throw SQLError.createSQLException(
Messages.getString("ByteArrayBuffer.2"),
SQLError.SQL_STATE_ILLEGAL_ARGUMENT,
exceptionInterceptor);
}
try {
return StringUtils.toString(this.byteBuffer, this.position, expectedLength, encoding);
} catch (UnsupportedEncodingException uEE) {
throw SQLError.createSQLException(
Messages.getString("ByteArrayBuffer.1") + encoding + "'",
SQLError.SQL_STATE_ILLEGAL_ARGUMENT,
exceptionInterceptor);
} finally {
this.position += expectedLength; // update cursor
}
}
/**
* Get a description of a table's primary key columns. They are ordered by COLUMN_NAME.
*
* <p>Each column description has the following columns:
*
* <OL>
* <li><B>TABLE_CAT</B> String => table catalog (may be null)
* <li><B>TABLE_SCHEM</B> String => table schema (may be null)
* <li><B>TABLE_NAME</B> String => table name
* <li><B>COLUMN_NAME</B> String => column name
* <li><B>KEY_SEQ</B> short => sequence number within primary key
* <li><B>PK_NAME</B> String => primary key name (may be null)
* </ol>
*
* @param catalog a catalog name; "" retrieves those without a catalog
* @param schema a schema name pattern; "" retrieves those without a schema
* @param table a table name
* @return ResultSet each row is a primary key column description
* @throws SQLException DOCUMENT ME!
*/
public java.sql.ResultSet getPrimaryKeys(String catalog, String schema, String table)
throws SQLException {
if (catalog == null) {
if (this.conn.getNullCatalogMeansCurrent()) {
catalog = this.database;
}
}
if (table == null) {
throw SQLError.createSQLException(
"Table not specified.", SQLError.SQL_STATE_ILLEGAL_ARGUMENT);
}
String sql =
"SELECT TABLE_SCHEMA AS TABLE_CAT, NULL AS TABLE_SCHEM, TABLE_NAME, "
+ "COLUMN_NAME, SEQ_IN_INDEX AS KEY_SEQ, 'PRIMARY' AS PK_NAME FROM INFORMATION_SCHEMA.STATISTICS "
+ "WHERE TABLE_SCHEMA LIKE ? AND TABLE_NAME LIKE ? AND "
+ "INDEX_NAME='PRIMARY' ORDER BY TABLE_SCHEMA, TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX";
PreparedStatement pStmt = null;
try {
pStmt = prepareMetaDataSafeStatement(sql);
if (catalog != null) {
pStmt.setString(1, catalog);
} else {
pStmt.setString(1, "%");
}
pStmt.setString(2, table);
ResultSet rs = executeMetadataQuery(pStmt);
((com.mysql.jdbc.ResultSet) rs)
.redefineFieldsForDBMD(
new Field[] {
new Field("", "TABLE_CAT", Types.CHAR, 255),
new Field("", "TABLE_SCHEM", Types.CHAR, 0),
new Field("", "TABLE_NAME", Types.CHAR, 255),
new Field("", "COLUMN_NAME", Types.CHAR, 32),
new Field("", "KEY_SEQ", Types.SMALLINT, 5),
new Field("", "PK_NAME", Types.CHAR, 32)
});
return rs;
} finally {
if (pStmt != null) {
pStmt.close();
}
}
}
public synchronized OutputStream setBinaryStream(long indexToWriteAt) throws SQLException {
checkClosed();
if (indexToWriteAt < 1L) {
throw SQLError.createSQLException(
Messages.getString("Blob.0"), "S1009", this.exceptionInterceptor);
}
WatchableOutputStream bytesOut = new WatchableOutputStream();
bytesOut.setWatcher(this);
if (indexToWriteAt > 0L) {
bytesOut.write(this.binaryData, 0, (int) (indexToWriteAt - 1L));
}
return bytesOut;
}
public CommunicationsException(
MySQLConnection conn,
long lastPacketSentTimeMs,
long lastPacketReceivedTimeMs,
Exception underlyingException) {
this.exceptionMessage =
SQLError.createLinkFailureMessageBasedOnHeuristics(
conn, lastPacketSentTimeMs, lastPacketReceivedTimeMs, underlyingException);
if (underlyingException != null) {
initCause(underlyingException);
}
}
public synchronized byte[] getBytes(long pos, int length) throws SQLException {
checkClosed();
if (pos < 1L) {
throw SQLError.createSQLException(
Messages.getString("Blob.2"), "S1009", this.exceptionInterceptor);
}
pos -= 1L;
if (pos > this.binaryData.length) {
throw SQLError.createSQLException(
"\"pos\" argument can not be larger than the BLOB's length.",
"S1009",
this.exceptionInterceptor);
}
if (pos + length > this.binaryData.length) {
throw SQLError.createSQLException(
"\"pos\" + \"length\" arguments can not be larger than the BLOB's length.",
"S1009",
this.exceptionInterceptor);
}
byte[] newData = new byte[length];
System.arraycopy(getBinaryData(), (int) pos, newData, 0, length);
return newData;
}
public Reader getReader(int columnIndex) throws SQLException {
InputStream stream = getBinaryInputStream(columnIndex);
if (stream == null) {
return null;
}
try {
return new InputStreamReader(stream, this.metadata[columnIndex].getCharacterSet());
} catch (UnsupportedEncodingException e) {
SQLException sqlEx = SQLError.createSQLException("", this.exceptionInterceptor);
sqlEx.initCause(e);
throw sqlEx;
}
}
/**
* @param columnIndex
* @param bits
* @param offset
* @param length
* @param conn
* @param rs
* @param cal
* @return
* @throws SQLException
*/
protected java.sql.Date getNativeDate(
int columnIndex,
byte[] bits,
int offset,
int length,
MySQLConnection conn,
ResultSetImpl rs,
Calendar cal)
throws SQLException {
int year = 0;
int month = 0;
int day = 0;
if (length != 0) {
year = (bits[offset + 0] & 0xff) | ((bits[offset + 1] & 0xff) << 8);
month = bits[offset + 2];
day = bits[offset + 3];
}
if (length == 0 || ((year == 0) && (month == 0) && (day == 0))) {
if (ConnectionPropertiesImpl.ZERO_DATETIME_BEHAVIOR_CONVERT_TO_NULL.equals(
conn.getZeroDateTimeBehavior())) {
return null;
} else if (ConnectionPropertiesImpl.ZERO_DATETIME_BEHAVIOR_EXCEPTION.equals(
conn.getZeroDateTimeBehavior())) {
throw SQLError.createSQLException(
"Value '0000-00-00' can not be represented as java.sql.Date",
SQLError.SQL_STATE_ILLEGAL_ARGUMENT,
this.exceptionInterceptor);
}
year = 1;
month = 1;
day = 1;
}
if (!rs.useLegacyDatetimeCode) {
return TimeUtil.fastDateCreate(year, month, day, cal);
}
return rs.fastDateCreate(
cal == null ? rs.getCalendarInstanceForSessionOrNew() : cal, year, month, day);
}
protected java.sql.Connection connectReplicationConnection(String url, Properties info)
throws SQLException {
Properties parsedProps = parseURL(url, info);
if (parsedProps == null) {
return null;
}
Properties masterProps = (Properties) parsedProps.clone();
Properties slavesProps = (Properties) parsedProps.clone();
// Marker used for further testing later on, also when
// debugging
slavesProps.setProperty("com.mysql.jdbc.ReplicationConnection.isSlave", "true");
int numHosts = Integer.parseInt(parsedProps.getProperty(NUM_HOSTS_PROPERTY_KEY));
if (numHosts < 2) {
throw SQLError.createSQLException(
"Must specify at least one slave host to connect to for master/slave replication load-balancing functionality",
SQLError.SQL_STATE_INVALID_CONNECTION_ATTRIBUTE,
null);
}
for (int i = 1; i < numHosts; i++) {
int index = i + 1;
masterProps.remove(HOST_PROPERTY_KEY + "." + index);
masterProps.remove(PORT_PROPERTY_KEY + "." + index);
slavesProps.setProperty(
HOST_PROPERTY_KEY + "." + i, parsedProps.getProperty(HOST_PROPERTY_KEY + "." + index));
slavesProps.setProperty(
PORT_PROPERTY_KEY + "." + i, parsedProps.getProperty(PORT_PROPERTY_KEY + "." + index));
}
masterProps.setProperty(NUM_HOSTS_PROPERTY_KEY, "1");
slavesProps.remove(HOST_PROPERTY_KEY + "." + numHosts);
slavesProps.remove(PORT_PROPERTY_KEY + "." + numHosts);
slavesProps.setProperty(NUM_HOSTS_PROPERTY_KEY, String.valueOf(numHosts - 1));
slavesProps.setProperty(HOST_PROPERTY_KEY, slavesProps.getProperty(HOST_PROPERTY_KEY + ".1"));
slavesProps.setProperty(PORT_PROPERTY_KEY, slavesProps.getProperty(PORT_PROPERTY_KEY + ".1"));
return new ReplicationConnection(masterProps, slavesProps);
}
protected String domSourceToString() throws SQLException {
try {
DOMSource source = new DOMSource(this.asDOMResult.getNode());
Transformer identity = TransformerFactory.newInstance().newTransformer();
StringWriter stringOut = new StringWriter();
Result result = new StreamResult(stringOut);
identity.transform(source, result);
return stringOut.toString();
} catch (Throwable t) {
SQLException sqlEx =
SQLError.createSQLException(
t.getMessage(), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
sqlEx.initCause(t);
throw sqlEx;
}
}
protected String readerToString(Reader reader) throws SQLException {
StringBuffer buf = new StringBuffer();
int charsRead = 0;
char[] charBuf = new char[512];
try {
while ((charsRead = reader.read(charBuf)) != -1) {
buf.append(charBuf, 0, charsRead);
}
} catch (IOException ioEx) {
SQLException sqlEx =
SQLError.createSQLException(
ioEx.getMessage(), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
sqlEx.initCause(ioEx);
throw sqlEx;
}
return buf.toString();
}
/**
* Read string[NUL]
*
* @param encoding
* @param exceptionInterceptor
* @throws SQLException
*/
final String readString(String encoding, ExceptionInterceptor exceptionInterceptor)
throws SQLException {
int i = this.position;
int len = 0;
int maxLen = getBufLength();
while ((i < maxLen) && (this.byteBuffer[i] != 0)) {
len++;
i++;
}
try {
return StringUtils.toString(this.byteBuffer, this.position, len, encoding);
} catch (UnsupportedEncodingException uEE) {
throw SQLError.createSQLException(
Messages.getString("ByteArrayBuffer.1") + encoding + "'",
SQLError.SQL_STATE_ILLEGAL_ARGUMENT,
exceptionInterceptor);
} finally {
this.position += (len + 1); // update cursor
}
}
public synchronized int setBytes(long writeAt, byte[] bytes, int offset, int length)
throws SQLException {
checkClosed();
OutputStream bytesOut = setBinaryStream(writeAt);
try {
bytesOut.write(bytes, offset, length);
} catch (IOException ioEx) {
SQLException sqlEx =
SQLError.createSQLException(
Messages.getString("Blob.1"), "S1000", this.exceptionInterceptor);
sqlEx.initCause(ioEx);
throw sqlEx;
} finally {
try {
bytesOut.close();
} catch (IOException doNothing) {
}
}
return length;
}
/**
* Returns a Source for reading the XML value designated by this SQLXML instance. Sources are used
* as inputs to XML parsers and XSLT transformers.
*
* <p>Sources for XML parsers will have namespace processing on by default. The systemID of the
* Source is implementation dependent.
*
* <p>The SQL XML object becomes not readable when this method is called and may also become not
* writable depending on implementation.
*
* <p>Note that SAX is a callback architecture, so a returned SAXSource should then be set with a
* content handler that will receive the SAX events from parsing. The content handler will receive
* callbacks based on the contents of the XML.
*
* <pre>
* SAXSource saxSource = sqlxml.getSource(SAXSource.class);
* XMLReader xmlReader = saxSource.getXMLReader();
* xmlReader.setContentHandler(myHandler);
* xmlReader.parse(saxSource.getInputSource());
* </pre>
*
* @param sourceClass The class of the source, or null. If the class is null, a vendor specifc
* Source implementation will be returned. The following classes are supported at a minimum:
* <p>(MySQL returns a SAXSource if sourceClass == null)
* <pre>
* javax.xml.transform.dom.DOMSource - returns a DOMSource
* javax.xml.transform.sax.SAXSource - returns a SAXSource
* javax.xml.transform.stax.StAXSource - returns a StAXSource
* javax.xml.transform.stream.StreamSource - returns a StreamSource
* </pre>
*
* @return a Source for reading the XML value.
* @throws SQLException if there is an error processing the XML value or if this feature is not
* supported. The getCause() method of the exception may provide a more detailed exception,
* for example, if an XML parser exception occurs. An exception is thrown if the state is not
* readable.
* @exception SQLFeatureNotSupportedException if the JDBC driver does not support this method
* @since 1.6
*/
public synchronized Source getSource(Class clazz) throws SQLException {
checkClosed();
checkWorkingWithResult();
// Note that we try and use streams here wherever possible
// for the day that the server actually supports streaming
// from server -> client (futureproofing)
if (clazz == null || clazz.equals(SAXSource.class)) {
InputSource inputSource = null;
if (this.fromResultSet) {
inputSource =
new InputSource(this.owningResultSet.getCharacterStream(this.columnIndexOfXml));
} else {
inputSource = new InputSource(new StringReader(this.stringRep));
}
return new SAXSource(inputSource);
} else if (clazz.equals(DOMSource.class)) {
try {
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
builderFactory.setNamespaceAware(true);
DocumentBuilder builder = builderFactory.newDocumentBuilder();
InputSource inputSource = null;
if (this.fromResultSet) {
inputSource =
new InputSource(this.owningResultSet.getCharacterStream(this.columnIndexOfXml));
} else {
inputSource = new InputSource(new StringReader(this.stringRep));
}
return new DOMSource(builder.parse(inputSource));
} catch (Throwable t) {
SQLException sqlEx =
SQLError.createSQLException(
t.getMessage(), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
sqlEx.initCause(t);
throw sqlEx;
}
} else if (clazz.equals(StreamSource.class)) {
Reader reader = null;
if (this.fromResultSet) {
reader = this.owningResultSet.getCharacterStream(this.columnIndexOfXml);
} else {
reader = new StringReader(this.stringRep);
}
return new StreamSource(reader);
} else if (clazz.equals(StAXSource.class)) {
try {
Reader reader = null;
if (this.fromResultSet) {
reader = this.owningResultSet.getCharacterStream(this.columnIndexOfXml);
} else {
reader = new StringReader(this.stringRep);
}
return new StAXSource(this.inputFactory.createXMLStreamReader(reader));
} catch (XMLStreamException ex) {
SQLException sqlEx =
SQLError.createSQLException(
ex.getMessage(), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
sqlEx.initCause(ex);
throw sqlEx;
}
} else {
throw SQLError.createSQLException(
"XML Source of type \"" + clazz.toString() + "\" Not supported.",
SQLError.SQL_STATE_ILLEGAL_ARGUMENT,
this.exceptionInterceptor);
}
}
private synchronized void checkClosed() throws SQLException {
if (this.isClosed) {
throw SQLError.createSQLException(
"SQLXMLInstance has been free()d", this.exceptionInterceptor);
}
}
public Properties parseURL(String url, Properties defaults) throws java.sql.SQLException {
Properties urlProps = (defaults != null) ? new Properties(defaults) : new Properties();
if (url == null) {
return null;
}
if (!StringUtils.startsWithIgnoreCase(url, URL_PREFIX)
&& !StringUtils.startsWithIgnoreCase(url, MXJ_URL_PREFIX)
&& !StringUtils.startsWithIgnoreCase(url, LOADBALANCE_URL_PREFIX)
&& !StringUtils.startsWithIgnoreCase(url, REPLICATION_URL_PREFIX)) { // $NON-NLS-1$
return null;
}
int beginningOfSlashes = url.indexOf("//");
if (StringUtils.startsWithIgnoreCase(url, MXJ_URL_PREFIX)) {
urlProps.setProperty(
"socketFactory", "com.mysql.management.driverlaunched.ServerLauncherSocketFactory");
}
/*
* Parse parameters after the ? in the URL and remove them from the
* original URL.
*/
int index = url.indexOf("?"); // $NON-NLS-1$
if (index != -1) {
String paramString = url.substring(index + 1, url.length());
url = url.substring(0, index);
StringTokenizer queryParams = new StringTokenizer(paramString, "&"); // $NON-NLS-1$
while (queryParams.hasMoreTokens()) {
String parameterValuePair = queryParams.nextToken();
int indexOfEquals = StringUtils.indexOfIgnoreCase(0, parameterValuePair, "=");
String parameter = null;
String value = null;
if (indexOfEquals != -1) {
parameter = parameterValuePair.substring(0, indexOfEquals);
if (indexOfEquals + 1 < parameterValuePair.length()) {
value = parameterValuePair.substring(indexOfEquals + 1);
}
}
if ((value != null && value.length() > 0)
&& (parameter != null && parameter.length() > 0)) {
try {
urlProps.put(parameter, URLDecoder.decode(value, "UTF-8"));
} catch (UnsupportedEncodingException badEncoding) {
// punt
urlProps.put(parameter, URLDecoder.decode(value));
} catch (NoSuchMethodError nsme) {
// punt again
urlProps.put(parameter, URLDecoder.decode(value));
}
}
}
}
url = url.substring(beginningOfSlashes + 2);
String hostStuff = null;
int slashIndex =
StringUtils.indexOfIgnoreCaseRespectMarker(
0, url, "/", ALLOWED_QUOTES, ALLOWED_QUOTES, true); // $NON-NLS-1$
if (slashIndex != -1) {
hostStuff = url.substring(0, slashIndex);
if ((slashIndex + 1) < url.length()) {
urlProps.put(
DBNAME_PROPERTY_KEY, //$NON-NLS-1$
url.substring((slashIndex + 1), url.length()));
}
} else {
hostStuff = url;
}
int numHosts = 0;
if ((hostStuff != null) && (hostStuff.trim().length() > 0)) {
List<String> hosts = StringUtils.split(hostStuff, ",", ALLOWED_QUOTES, ALLOWED_QUOTES, false);
for (String hostAndPort : hosts) {
numHosts++;
String[] hostPortPair = parseHostPortPair(hostAndPort);
if (hostPortPair[HOST_NAME_INDEX] != null
&& hostPortPair[HOST_NAME_INDEX].trim().length() > 0) {
urlProps.setProperty(HOST_PROPERTY_KEY + "." + numHosts, hostPortPair[HOST_NAME_INDEX]);
} else {
urlProps.setProperty(HOST_PROPERTY_KEY + "." + numHosts, "localhost");
}
if (hostPortPair[PORT_NUMBER_INDEX] != null) {
urlProps.setProperty(PORT_PROPERTY_KEY + "." + numHosts, hostPortPair[PORT_NUMBER_INDEX]);
} else {
urlProps.setProperty(PORT_PROPERTY_KEY + "." + numHosts, "3306");
}
}
} else {
numHosts = 1;
urlProps.setProperty(HOST_PROPERTY_KEY + ".1", "localhost");
urlProps.setProperty(PORT_PROPERTY_KEY + ".1", "3306");
}
urlProps.setProperty(NUM_HOSTS_PROPERTY_KEY, String.valueOf(numHosts));
urlProps.setProperty(HOST_PROPERTY_KEY, urlProps.getProperty(HOST_PROPERTY_KEY + ".1"));
urlProps.setProperty(PORT_PROPERTY_KEY, urlProps.getProperty(PORT_PROPERTY_KEY + ".1"));
String propertiesTransformClassName = urlProps.getProperty(PROPERTIES_TRANSFORM_KEY);
if (propertiesTransformClassName != null) {
try {
ConnectionPropertiesTransform propTransformer =
(ConnectionPropertiesTransform)
Class.forName(propertiesTransformClassName).newInstance();
urlProps = propTransformer.transformProperties(urlProps);
} catch (InstantiationException e) {
throw SQLError.createSQLException(
"Unable to create properties transform instance '"
+ propertiesTransformClassName
+ "' due to underlying exception: "
+ e.toString(),
SQLError.SQL_STATE_INVALID_CONNECTION_ATTRIBUTE,
null);
} catch (IllegalAccessException e) {
throw SQLError.createSQLException(
"Unable to create properties transform instance '"
+ propertiesTransformClassName
+ "' due to underlying exception: "
+ e.toString(),
SQLError.SQL_STATE_INVALID_CONNECTION_ATTRIBUTE,
null);
} catch (ClassNotFoundException e) {
throw SQLError.createSQLException(
"Unable to create properties transform instance '"
+ propertiesTransformClassName
+ "' due to underlying exception: "
+ e.toString(),
SQLError.SQL_STATE_INVALID_CONNECTION_ATTRIBUTE,
null);
}
}
if (Util.isColdFusion()
&& urlProps.getProperty("autoConfigureForColdFusion", "true").equalsIgnoreCase("true")) {
String configs = urlProps.getProperty(USE_CONFIG_PROPERTY_KEY);
StringBuffer newConfigs = new StringBuffer();
if (configs != null) {
newConfigs.append(configs);
newConfigs.append(",");
}
newConfigs.append("coldFusion");
urlProps.setProperty(USE_CONFIG_PROPERTY_KEY, newConfigs.toString());
}
// If we use a config, it actually should get overridden by anything in
// the URL or passed-in properties
String configNames = null;
if (defaults != null) {
configNames = defaults.getProperty(USE_CONFIG_PROPERTY_KEY);
}
if (configNames == null) {
configNames = urlProps.getProperty(USE_CONFIG_PROPERTY_KEY);
}
if (configNames != null) {
List splitNames = StringUtils.split(configNames, ",", true);
Properties configProps = new Properties();
Iterator namesIter = splitNames.iterator();
while (namesIter.hasNext()) {
String configName = (String) namesIter.next();
try {
InputStream configAsStream =
getClass().getResourceAsStream("configs/" + configName + ".properties");
if (configAsStream == null) {
throw SQLError.createSQLException(
"Can't find configuration template named '" + configName + "'",
SQLError.SQL_STATE_INVALID_CONNECTION_ATTRIBUTE,
null);
}
configProps.load(configAsStream);
} catch (IOException ioEx) {
SQLException sqlEx =
SQLError.createSQLException(
"Unable to load configuration template '"
+ configName
+ "' due to underlying IOException: "
+ ioEx,
SQLError.SQL_STATE_INVALID_CONNECTION_ATTRIBUTE,
null);
sqlEx.initCause(ioEx);
throw sqlEx;
}
}
Iterator propsIter = urlProps.keySet().iterator();
while (propsIter.hasNext()) {
String key = propsIter.next().toString();
String property = urlProps.getProperty(key);
configProps.setProperty(key, property);
}
urlProps = configProps;
}
// Properties passed in should override ones in URL
if (defaults != null) {
Iterator propsIter = defaults.keySet().iterator();
while (propsIter.hasNext()) {
String key = propsIter.next().toString();
if (!key.equals(NUM_HOSTS_PROPERTY_KEY)) {
String property = defaults.getProperty(key);
urlProps.setProperty(key, property);
}
}
}
return urlProps;
}
