/** * Executes an SQL statement on the database in a separate thread. A certain number of worker * threads controlled by the "parallel" property will operate simultaneously. * * @param sql an SQL string. * @throws SQLException if an error has been reported by a previous operation - however, this does * not cancel the current operation. */ public void executeSqlInParallel(String sql) throws SQLException { SqlJob job = new SqlJob(sql); synchronized (this) { pending.add(job); } boolean notDone = true; while (notDone) { try { queue.put(job); notDone = false; } catch (InterruptedException e) { // Not done } } synchronized (this) { if (workers.size() < parallel) { Worker worker = new Worker(threadNo); Thread thread = new Thread(worker); thread.setDaemon(true); thread.setName("Database background thread " + threadNo); threadNo++; workers.add(worker); thread.start(); } if (reportedException != null) { SQLException re = new SQLException("Error while executing SQL"); re.initCause(reportedException); reportedException = null; throw re; } } }
/** {@inheritDoc} */ @Override public void nullSafeSet( final PreparedStatement statement, final Object value, final int index, final SessionImplementor session) throws SQLException { if (value == null) { statement.setNull(index, sqlTypes()[0]); } else { // Cf io.vertigo.dynamo.impl.database.vendor.core.SQLMappingImpl try { final DataStream dataStream = (DataStream) value; statement.setBinaryStream( index, dataStream.createInputStream(), (int) dataStream .getLength()); // attention le setBinaryStream avec une longueur de fichier en // long N'EST PAS implémentée dans de nombreux drivers !! } catch (final IOException e) { final SQLException sqlException = new SQLException("Erreur d'ecriture du flux"); sqlException.initCause(e); throw sqlException; } } }
public void logBatchUpdateExceptions(Throwable t) { while (!(t instanceof SQLException)) { t = t.getCause(); if (t == null) { return; } } SQLException sqle = (SQLException) t; // If the SQLException is the root chain the results of getNextException as initCauses if (sqle.getCause() == null) { SQLException nextException; while ((nextException = sqle.getNextException()) != null) { sqle.initCause(nextException); sqle = nextException; } } // The SQLException already has a cause so log the results of all getNextException calls else { while ((sqle = sqle.getNextException()) != null) { this.logger.error("Logging getNextException for root SQLException: " + t, sqle); } } }
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; } }
/** * This method will send an close command, which does not return any rowsets, to the ODBC server. * * @retrun A CloseReply class representing the reply from the ODBC server is returned * @exception A SQLException is thrown */ CloseReply Close() throws SQLException { try { getInputOutput().setTimeout(m_ic.t4props_.getNetworkTimeout()); LogicalByteArray wbuffer = CloseMessage.marshal(m_dialogueId, m_stmtLabel, SQL_CLOSE, this.m_ic); LogicalByteArray rbuffer = getReadBuffer(TRANSPORT.SRVR_API_SQLFREESTMT, wbuffer); CloseReply cr = new CloseReply(rbuffer, m_ncsAddress.getIPorName(), m_ic); return cr; } // end try catch (SQLException se) { throw se; } catch (CharacterCodingException e) { SQLException se = HPT4Messages.createSQLException( m_ic.t4props_, m_locale, "translation_of_parameter_failed", "CloseMessage", e.getMessage()); se.initCause(e); throw se; } catch (UnsupportedCharsetException e) { SQLException se = HPT4Messages.createSQLException( m_ic.t4props_, m_locale, "unsupported_encoding", e.getCharsetName()); se.initCause(e); throw se; } catch (Exception e) { SQLException se = HPT4Messages.createSQLException( m_ic.t4props_, m_locale, "close_message_error", e.getMessage()); se.initCause(e); throw se; } // end catch } // end Close
/** * クラスタリング対応のメソッド実行処理。 * * @param methodName * @param args * @return * @throws SQLException */ private Object clusterCall( String methodName, Object[] args, Class<?>[] parameterTypes, boolean saveMethod) throws SQLException { Object result = null; CalledMethod calledMethod = new CalledMethod(methodName, args, parameterTypes); logger.debug(calledMethod.toString()); try { result = calledMethod.invoke(st); } catch (Exception e) { logger.warn(MSG_WARN_SWITCH_DB, e); // try { st.close(); } catch (SQLException se) {} con.notifyError(this); // エラーを通知。ここでstは新しいものになっているはず。 try { // 再度実行。ここでもさらにエラーがでるならSQLExceptionにラップする。 result = calledMethod.invoke(st); } catch (InvocationTargetException e2) { // 例外がSQLExceptionならそのままthrow Throwable t = e2.getTargetException(); if (t instanceof SQLException) { throw (SQLException) t; } // それ以外ならwrapしてthrow SQLException sqle = new SQLException(); sqle.initCause(e2.getTargetException()); throw sqle; } catch (Exception e2) { SQLException sqle = new SQLException(); sqle.initCause(e2); throw sqle; } } if (saveMethod) { methodList.add(calledMethod); } return result; }
/** * 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); } }
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; } }
/** * Blocks until all the current pending jobs are finished. This will not block new jobs from * arriving, and those new jobs do not need to be finished for this method to return. * * @throws SQLException if an error has been reported by a previous operation */ public void waitForCurrentJobs() throws SQLException { Waiter waiter; synchronized (this) { waiter = new Waiter(pending); waiters.add(waiter); } waiter.waitUntilFinished(); synchronized (this) { waiters.remove(waiter); if (reportedException != null) { SQLException re = new SQLException("Error while executing SQL"); re.initCause(reportedException); reportedException = null; throw re; } } }
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; } }
/** * 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; } if (!"1".equals(props.getProperty(NUM_HOSTS_PROPERTY_KEY))) { return connectFailover(url, info); } try { Connection newConn = com.mysql.jdbc.ConnectionImpl.getInstance( 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) { SQLException sqlEx = 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, null); sqlEx.initCause(ex); throw sqlEx; } }
public static SQLException toSQLException(String msg, String sqlState, Throwable t) { if (t instanceof SQLException) { if (Debug.DEBUG && Debug.TRACE == Debug.TRACE_MAX && logger.isLoggable(MLevel.FINER)) { SQLException s = (SQLException) t; StringBuffer tmp = new StringBuffer(255); tmp.append("Attempted to convert SQLException to SQLException. Leaving it alone."); tmp.append(" [SQLState: "); tmp.append(s.getSQLState()); tmp.append("; errorCode: "); tmp.append(s.getErrorCode()); tmp.append(']'); if (msg != null) tmp.append(" Ignoring suggested message: '" + msg + "'."); logger.log(MLevel.FINER, tmp.toString(), t); SQLException s2 = s; while ((s2 = s2.getNextException()) != null) logger.log(MLevel.FINER, "Nested SQLException or SQLWarning: ", s2); } return (SQLException) t; } else { if (Debug.DEBUG) { // t.printStackTrace(); if (logger.isLoggable(MLevel.FINE)) logger.log(MLevel.FINE, "Converting Throwable to SQLException...", t); } if (msg == null) msg = "An SQLException was provoked by the following failure: " + t.toString(); if (VersionUtils.isAtLeastJavaVersion14()) { SQLException out = new SQLException(msg); out.initCause(t); return out; } else return new SQLException( msg + System.getProperty("line.separator") + "[Cause: " + ThrowableUtils.extractStackTrace(t) + ']', sqlState); } }
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(); }
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; }
public HarmonySerialClob(Clob clob) throws SQLException { Reader characterStream; if (clob == null) { throw new IllegalArgumentException(); } if ((characterStream = clob.getCharacterStream()) == null && clob.getAsciiStream() == null) { throw new IllegalArgumentException(); } this.clob = clob; origLen = clob.length(); len = origLen; buf = new char[(int) len]; try { characterStream.read(buf); } catch (IOException e) { SQLException se = new SQLException("SerialClob: " + e.getMessage()); se.initCause(e); throw se; } }
/** * Converts a clob to a string. * * @param clob the clob to convert. * @return the clob contents. * @throws SQLException if the CLOB cannot be processed. See <a * href="http://www.opengroup.org/bookstore/catalog/c449.htm">SQL 2</a>. */ @NotNull public String clobToString(@NotNull final Clob clob) throws SQLException { @NotNull final StringBuilder t_sbResult = new StringBuilder(); @Nullable SQLException t_ExceptionToThrow = null; @NotNull final BufferedReader t_Reader = new BufferedReader(clob.getCharacterStream()); try { String t_strLine = t_Reader.readLine(); while (t_strLine != null) { t_sbResult.append(t_strLine); t_strLine = t_Reader.readLine(); } // end of while () } catch (@NotNull final IOException ioException) { t_ExceptionToThrow = new SQLException( "cannot.read.clob", "22021"); // "Translation result not in target repertoire" t_ExceptionToThrow.initCause(ioException); } finally { try { t_Reader.close(); } catch (@NotNull final IOException ioException) { LogFactory.getLog(QueryUtils.class).warn("Cannot close CLOB stream.", ioException); } } if (t_ExceptionToThrow != null) { throw t_ExceptionToThrow; } return t_sbResult.toString(); }
@Test public void testEndTransactionWhenSQLBatchUpdateExceptionThrown() throws Exception { SQLException sqlException2 = new SQLException("sqlexception2"); sqlException2.setNextException(new SQLException("nextexception2")); SQLException sqlException1 = new SQLException("sqlexception1"); sqlException1.initCause(sqlException2); sqlException1.setNextException(new SQLException("nextexception1")); // Assume the transaction is already created. when(context.get("hibtransaction")).thenReturn(transaction); doThrow(new HibernateException("exception1", sqlException1)).when(transaction).commit(); try { store.endTransaction(context, true); fail("Should have thrown an exception here"); } catch (HibernateException e) { assertEquals( "Failed to commit or rollback transaction. Root cause [\n" + "SQL next exception = [java.sql.SQLException: nextexception1]\n" + "SQL next exception = [java.sql.SQLException: nextexception2]]", e.getMessage()); } }
/** Convenience method to allow a cause. Grrrr. */ public static SQLException create(String message, Throwable cause) { SQLException sqlException = new SQLException(message); sqlException.initCause(cause); return sqlException; }
protected final java.sql.Date getDateFast( int columnIndex, byte[] dateAsBytes, int offset, int length, MySQLConnection conn, ResultSetImpl rs, Calendar targetCalendar) throws SQLException { int year = 0; int month = 0; int day = 0; try { if (dateAsBytes == null) { return null; } boolean allZeroDate = true; boolean onlyTimePresent = false; for (int i = 0; i < length; i++) { if (dateAsBytes[offset + i] == ':') { onlyTimePresent = true; break; } } for (int i = 0; i < length; i++) { byte b = dateAsBytes[offset + i]; if (b == ' ' || b == '-' || b == '/') { onlyTimePresent = false; } if (b != '0' && b != ' ' && b != ':' && b != '-' && b != '/' && b != '.') { allZeroDate = false; break; } } if (!onlyTimePresent && allZeroDate) { 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 '" + StringUtils.toString(dateAsBytes) + "' can not be represented as java.sql.Date", SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor); } // We're left with the case of 'round' to a date Java _can_ // represent, which is '0001-01-01'. return rs.fastDateCreate(targetCalendar, 1, 1, 1); } else if (this.metadata[columnIndex].getMysqlType() == MysqlDefs.FIELD_TYPE_TIMESTAMP) { // Convert from TIMESTAMP switch (length) { case 29: case 21: case 19: { // java.sql.Timestamp format year = StringUtils.getInt(dateAsBytes, offset + 0, offset + 4); month = StringUtils.getInt(dateAsBytes, offset + 5, offset + 7); day = StringUtils.getInt(dateAsBytes, offset + 8, offset + 10); return rs.fastDateCreate(targetCalendar, year, month, day); } case 14: case 8: { year = StringUtils.getInt(dateAsBytes, offset + 0, offset + 4); month = StringUtils.getInt(dateAsBytes, offset + 4, offset + 6); day = StringUtils.getInt(dateAsBytes, offset + 6, offset + 8); return rs.fastDateCreate(targetCalendar, year, month, day); } case 12: case 10: case 6: { year = StringUtils.getInt(dateAsBytes, offset + 0, offset + 2); if (year <= 69) { year = year + 100; } month = StringUtils.getInt(dateAsBytes, offset + 2, offset + 4); day = StringUtils.getInt(dateAsBytes, offset + 4, offset + 6); return rs.fastDateCreate(targetCalendar, year + 1900, month, day); } case 4: { year = StringUtils.getInt(dateAsBytes, offset + 0, offset + 4); if (year <= 69) { year = year + 100; } month = StringUtils.getInt(dateAsBytes, offset + 2, offset + 4); return rs.fastDateCreate(targetCalendar, year + 1900, month, 1); } case 2: { year = StringUtils.getInt(dateAsBytes, offset + 0, offset + 2); if (year <= 69) { year = year + 100; } return rs.fastDateCreate(targetCalendar, year + 1900, 1, 1); } default: throw SQLError.createSQLException( Messages.getString( "ResultSet.Bad_format_for_Date", new Object[] { StringUtils.toString(dateAsBytes), Integer.valueOf(columnIndex + 1) }), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor); // $NON-NLS-1$ } /* endswitch */ } else if (this.metadata[columnIndex].getMysqlType() == MysqlDefs.FIELD_TYPE_YEAR) { if (length == 2 || length == 1) { year = StringUtils.getInt(dateAsBytes, offset, offset + length); if (year <= 69) { year = year + 100; } year += 1900; } else { year = StringUtils.getInt(dateAsBytes, offset + 0, offset + 4); } return rs.fastDateCreate(targetCalendar, year, 1, 1); } else if (this.metadata[columnIndex].getMysqlType() == MysqlDefs.FIELD_TYPE_TIME) { return rs.fastDateCreate(targetCalendar, 1970, 1, 1); // Return EPOCH } else { if (length < 10) { if (length == 8) { return rs.fastDateCreate(targetCalendar, 1970, 1, 1); // Return // EPOCH for // TIME } throw SQLError.createSQLException( Messages.getString( "ResultSet.Bad_format_for_Date", new Object[] { StringUtils.toString(dateAsBytes), Integer.valueOf(columnIndex + 1) }), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor); // $NON-NLS-1$ } if (length != 18) { year = StringUtils.getInt(dateAsBytes, offset + 0, offset + 4); month = StringUtils.getInt(dateAsBytes, offset + 5, offset + 7); day = StringUtils.getInt(dateAsBytes, offset + 8, offset + 10); } else { // JDK-1.3 timestamp format, not real easy to parse // positionally :p StringTokenizer st = new StringTokenizer( StringUtils.toString(dateAsBytes, offset, length, "ISO8859_1"), "- "); year = Integer.parseInt(st.nextToken()); month = Integer.parseInt(st.nextToken()); day = Integer.parseInt(st.nextToken()); } } return rs.fastDateCreate(targetCalendar, year, month, day); } catch (SQLException sqlEx) { throw sqlEx; // don't re-wrap } catch (Exception e) { SQLException sqlEx = SQLError.createSQLException( Messages.getString( "ResultSet.Bad_format_for_Date", new Object[] { StringUtils.toString(dateAsBytes), Integer.valueOf(columnIndex + 1) }), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor); // $NON-NLS-1$ sqlEx.initCause(e); throw sqlEx; } }
protected Timestamp getTimestampFast( int columnIndex, byte[] timestampAsBytes, int offset, int length, Calendar targetCalendar, TimeZone tz, boolean rollForward, MySQLConnection conn, ResultSetImpl rs) throws SQLException { try { Calendar sessionCalendar = conn.getUseJDBCCompliantTimezoneShift() ? conn.getUtcCalendar() : rs.getCalendarInstanceForSessionOrNew(); synchronized (sessionCalendar) { boolean allZeroTimestamp = true; boolean onlyTimePresent = false; for (int i = 0; i < length; i++) { if (timestampAsBytes[offset + i] == ':') { onlyTimePresent = true; break; } } for (int i = 0; i < length; i++) { byte b = timestampAsBytes[offset + i]; if (b == ' ' || b == '-' || b == '/') { onlyTimePresent = false; } if (b != '0' && b != ' ' && b != ':' && b != '-' && b != '/' && b != '.') { allZeroTimestamp = false; break; } } if (!onlyTimePresent && allZeroTimestamp) { 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 '" + StringUtils.toString(timestampAsBytes) + "' can not be represented as java.sql.Timestamp", SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor); } if (!rs.useLegacyDatetimeCode) { return TimeUtil.fastTimestampCreate(tz, 1, 1, 1, 0, 0, 0, 0); } // We're left with the case of 'round' to a date Java _can_ // represent, which is '0001-01-01'. return rs.fastTimestampCreate(null, 1, 1, 1, 0, 0, 0, 0); } else if (this.metadata[columnIndex].getMysqlType() == MysqlDefs.FIELD_TYPE_YEAR) { if (!rs.useLegacyDatetimeCode) { return TimeUtil.fastTimestampCreate( tz, StringUtils.getInt(timestampAsBytes, offset, 4), 1, 1, 0, 0, 0, 0); } return TimeUtil.changeTimezone( conn, sessionCalendar, targetCalendar, rs.fastTimestampCreate( sessionCalendar, StringUtils.getInt(timestampAsBytes, offset, 4), 1, 1, 0, 0, 0, 0), conn.getServerTimezoneTZ(), tz, rollForward); } else { if (timestampAsBytes[offset + length - 1] == '.') { length--; } // Convert from TIMESTAMP or DATE int year = 0; int month = 0; int day = 0; int hour = 0; int minutes = 0; int seconds = 0; int nanos = 0; switch (length) { case 29: case 26: case 25: case 24: case 23: case 22: case 21: case 20: case 19: { year = StringUtils.getInt(timestampAsBytes, offset + 0, offset + 4); month = StringUtils.getInt(timestampAsBytes, offset + 5, offset + 7); day = StringUtils.getInt(timestampAsBytes, offset + 8, offset + 10); hour = StringUtils.getInt(timestampAsBytes, offset + 11, offset + 13); minutes = StringUtils.getInt(timestampAsBytes, offset + 14, offset + 16); seconds = StringUtils.getInt(timestampAsBytes, offset + 17, offset + 19); nanos = 0; if (length > 19) { int decimalIndex = -1; for (int i = 0; i < length; i++) { if (timestampAsBytes[offset + i] == '.') { decimalIndex = i; } } if (decimalIndex != -1) { if ((decimalIndex + 2) <= length) { nanos = StringUtils.getInt( timestampAsBytes, offset + decimalIndex + 1, offset + length); int numDigits = (length) - (decimalIndex + 1); if (numDigits < 9) { int factor = (int) (Math.pow(10, 9 - numDigits)); nanos = nanos * factor; } } else { throw new IllegalArgumentException(); // re-thrown // further // down // with // a // much better error message } } } break; } case 14: { year = StringUtils.getInt(timestampAsBytes, offset + 0, offset + 4); month = StringUtils.getInt(timestampAsBytes, offset + 4, offset + 6); day = StringUtils.getInt(timestampAsBytes, offset + 6, offset + 8); hour = StringUtils.getInt(timestampAsBytes, offset + 8, offset + 10); minutes = StringUtils.getInt(timestampAsBytes, offset + 10, offset + 12); seconds = StringUtils.getInt(timestampAsBytes, offset + 12, offset + 14); break; } case 12: { year = StringUtils.getInt(timestampAsBytes, offset + 0, offset + 2); if (year <= 69) { year = (year + 100); } year += 1900; month = StringUtils.getInt(timestampAsBytes, offset + 2, offset + 4); day = StringUtils.getInt(timestampAsBytes, offset + 4, offset + 6); hour = StringUtils.getInt(timestampAsBytes, offset + 6, offset + 8); minutes = StringUtils.getInt(timestampAsBytes, offset + 8, offset + 10); seconds = StringUtils.getInt(timestampAsBytes, offset + 10, offset + 12); break; } case 10: { boolean hasDash = false; for (int i = 0; i < length; i++) { if (timestampAsBytes[offset + i] == '-') { hasDash = true; break; } } if ((this.metadata[columnIndex].getMysqlType() == MysqlDefs.FIELD_TYPE_DATE) || hasDash) { year = StringUtils.getInt(timestampAsBytes, offset + 0, offset + 4); month = StringUtils.getInt(timestampAsBytes, offset + 5, offset + 7); day = StringUtils.getInt(timestampAsBytes, offset + 8, offset + 10); hour = 0; minutes = 0; } else { year = StringUtils.getInt(timestampAsBytes, offset + 0, offset + 2); if (year <= 69) { year = (year + 100); } month = StringUtils.getInt(timestampAsBytes, offset + 2, offset + 4); day = StringUtils.getInt(timestampAsBytes, offset + 4, offset + 6); hour = StringUtils.getInt(timestampAsBytes, offset + 6, offset + 8); minutes = StringUtils.getInt(timestampAsBytes, offset + 8, offset + 10); year += 1900; // two-digit year } break; } case 8: { boolean hasColon = false; for (int i = 0; i < length; i++) { if (timestampAsBytes[offset + i] == ':') { hasColon = true; break; } } if (hasColon) { hour = StringUtils.getInt(timestampAsBytes, offset + 0, offset + 2); minutes = StringUtils.getInt(timestampAsBytes, offset + 3, offset + 5); seconds = StringUtils.getInt(timestampAsBytes, offset + 6, offset + 8); year = 1970; month = 1; day = 1; break; } year = StringUtils.getInt(timestampAsBytes, offset + 0, offset + 4); month = StringUtils.getInt(timestampAsBytes, offset + 4, offset + 6); day = StringUtils.getInt(timestampAsBytes, offset + 6, offset + 8); year -= 1900; month--; break; } case 6: { year = StringUtils.getInt(timestampAsBytes, offset + 0, offset + 2); if (year <= 69) { year = (year + 100); } year += 1900; month = StringUtils.getInt(timestampAsBytes, offset + 2, offset + 4); day = StringUtils.getInt(timestampAsBytes, offset + 4, offset + 6); break; } case 4: { year = StringUtils.getInt(timestampAsBytes, offset + 0, offset + 2); if (year <= 69) { year = (year + 100); } month = StringUtils.getInt(timestampAsBytes, offset + 2, offset + 4); day = 1; break; } case 2: { year = StringUtils.getInt(timestampAsBytes, offset + 0, offset + 2); if (year <= 69) { year = (year + 100); } year += 1900; month = 1; day = 1; break; } default: throw new java.sql.SQLException( "Bad format for Timestamp '" + StringUtils.toString(timestampAsBytes) + "' in column " + (columnIndex + 1) + ".", SQLError.SQL_STATE_ILLEGAL_ARGUMENT); } if (!rs.useLegacyDatetimeCode) { return TimeUtil.fastTimestampCreate( tz, year, month, day, hour, minutes, seconds, nanos); } return TimeUtil.changeTimezone( conn, sessionCalendar, targetCalendar, rs.fastTimestampCreate( sessionCalendar, year, month, day, hour, minutes, seconds, nanos), conn.getServerTimezoneTZ(), tz, rollForward); } } } catch (RuntimeException e) { SQLException sqlEx = SQLError.createSQLException( "Cannot convert value '" + getString(columnIndex, "ISO8859_1", conn) + "' from column " + (columnIndex + 1) + " to TIMESTAMP.", SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor); sqlEx.initCause(e); throw sqlEx; } }
/** * 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); } }
protected Time getTimeFast( int columnIndex, byte[] timeAsBytes, int offset, int fullLength, Calendar targetCalendar, TimeZone tz, boolean rollForward, MySQLConnection conn, ResultSetImpl rs) throws SQLException { int hr = 0; int min = 0; int sec = 0; int nanos = 0; int decimalIndex = -1; try { if (timeAsBytes == null) { return null; } boolean allZeroTime = true; boolean onlyTimePresent = false; for (int i = 0; i < fullLength; i++) { if (timeAsBytes[offset + i] == ':') { onlyTimePresent = true; break; } } for (int i = 0; i < fullLength; i++) { if (timeAsBytes[offset + i] == '.') { decimalIndex = i; break; } } for (int i = 0; i < fullLength; i++) { byte b = timeAsBytes[offset + i]; if (b == ' ' || b == '-' || b == '/') { onlyTimePresent = false; } if (b != '0' && b != ' ' && b != ':' && b != '-' && b != '/' && b != '.') { allZeroTime = false; break; } } if (!onlyTimePresent && allZeroTime) { 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 '" + StringUtils.toString(timeAsBytes) + "' can not be represented as java.sql.Time", SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor); } // We're left with the case of 'round' to a time Java _can_ // represent, which is '00:00:00' return rs.fastTimeCreate(targetCalendar, 0, 0, 0); } Field timeColField = this.metadata[columnIndex]; int length = fullLength; if (decimalIndex != -1) { length = decimalIndex; if ((decimalIndex + 2) <= fullLength) { nanos = StringUtils.getInt(timeAsBytes, offset + decimalIndex + 1, offset + fullLength); int numDigits = (fullLength) - (decimalIndex + 1); if (numDigits < 9) { int factor = (int) (Math.pow(10, 9 - numDigits)); nanos = nanos * factor; } } else { throw new IllegalArgumentException(); // re-thrown // further // down // with // a // much better error message } } if (timeColField.getMysqlType() == MysqlDefs.FIELD_TYPE_TIMESTAMP) { switch (length) { case 19: { // YYYY-MM-DD hh:mm:ss hr = StringUtils.getInt(timeAsBytes, offset + length - 8, offset + length - 6); min = StringUtils.getInt(timeAsBytes, offset + length - 5, offset + length - 3); sec = StringUtils.getInt(timeAsBytes, offset + length - 2, offset + length); } break; case 14: case 12: { hr = StringUtils.getInt(timeAsBytes, offset + length - 6, offset + length - 4); min = StringUtils.getInt(timeAsBytes, offset + length - 4, offset + length - 2); sec = StringUtils.getInt(timeAsBytes, offset + length - 2, offset + length); } break; case 10: { hr = StringUtils.getInt(timeAsBytes, offset + 6, offset + 8); min = StringUtils.getInt(timeAsBytes, offset + 8, offset + 10); sec = 0; } break; default: throw SQLError.createSQLException( Messages.getString( "ResultSet.Timestamp_too_small_to_convert_to_Time_value_in_column__257") //$NON-NLS-1$ + (columnIndex + 1) + "(" + timeColField + ").", SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor); } /* endswitch */ @SuppressWarnings("unused") SQLWarning precisionLost = new SQLWarning( Messages.getString( "ResultSet.Precision_lost_converting_TIMESTAMP_to_Time_with_getTime()_on_column__261") //$NON-NLS-1$ + columnIndex + "(" + timeColField + ")."); /* * if (this.warningChain == null) { this.warningChain = * precisionLost; } else { * this.warningChain.setNextWarning(precisionLost); } */ } else if (timeColField.getMysqlType() == MysqlDefs.FIELD_TYPE_DATETIME) { hr = StringUtils.getInt(timeAsBytes, offset + 11, offset + 13); min = StringUtils.getInt(timeAsBytes, offset + 14, offset + 16); sec = StringUtils.getInt(timeAsBytes, offset + 17, offset + 19); @SuppressWarnings("unused") SQLWarning precisionLost = new SQLWarning( Messages.getString( "ResultSet.Precision_lost_converting_DATETIME_to_Time_with_getTime()_on_column__264") //$NON-NLS-1$ + (columnIndex + 1) + "(" + timeColField + ")."); /* * if (this.warningChain == null) { this.warningChain = * precisionLost; } else { * this.warningChain.setNextWarning(precisionLost); } */ } else if (timeColField.getMysqlType() == MysqlDefs.FIELD_TYPE_DATE) { return rs.fastTimeCreate(null, 0, 0, 0); // midnight on the // given // date } else { // convert a String to a Time if ((length != 5) && (length != 8)) { throw SQLError.createSQLException( Messages.getString("ResultSet.Bad_format_for_Time____267") // $NON-NLS-1$ + StringUtils.toString(timeAsBytes) + Messages.getString("ResultSet.___in_column__268") + (columnIndex + 1), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor); } hr = StringUtils.getInt(timeAsBytes, offset + 0, offset + 2); min = StringUtils.getInt(timeAsBytes, offset + 3, offset + 5); sec = (length == 5) ? 0 : StringUtils.getInt(timeAsBytes, offset + 6, offset + 8); } Calendar sessionCalendar = rs.getCalendarInstanceForSessionOrNew(); if (!rs.useLegacyDatetimeCode) { // TODO: return rs.fastTimeCreate(targetCalendar, hr, min, sec, nanos); // java.sql.Time doesn't contain fractional part, so PreparedStatement.setTime/getTime can't // deal with TIME(n) fractional part. // There may be better mappings to high-precision time coming in JDBC-5 with the adoption of // JSR-310. return rs.fastTimeCreate(targetCalendar, hr, min, sec); } synchronized (sessionCalendar) { return TimeUtil.changeTimezone( conn, sessionCalendar, targetCalendar, rs.fastTimeCreate(sessionCalendar, hr, min, sec), conn.getServerTimezoneTZ(), tz, rollForward); // TODO: min, sec, nanos), conn.getServerTimezoneTZ(), tz, // java.sql.Time doesn't contain fractional part, so PreparedStatement.setTime/getTime can't // deal with TIME(n) fractional part. // There may be better mappings to high-precision time coming in JDBC-5 with the adoption of // JSR-310. } } catch (RuntimeException ex) { SQLException sqlEx = SQLError.createSQLException( ex.toString(), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor); sqlEx.initCause(ex); throw sqlEx; } }
/** * Returns the backing-store factory for HSQL syntax. If the cached tables are not available, they * will be created now from the SQL scripts bundled in this plugin. * * @param hints A map of hints, including the low-level factories to use for CRS creation. * @return The EPSG factory using HSQL syntax. * @throws SQLException if connection to the database failed. */ protected AbstractAuthorityFactory createBackingStore(final Hints hints) throws SQLException { final DataSource source = getDataSource(); final File directory = getDirectory(source); directory.mkdirs(); if (!dataExists(directory)) { FileLock lock = null; try { // get an exclusive lock lock = acquireLock(directory); // if after getting the lock the database is still incomplete let's work on it if (!dataExists(directory)) { /* * HSQL has created automatically an empty database. We need to populate it. * Executes the SQL scripts bundled in the JAR. In theory, each line contains * a full SQL statement. For this plugin however, we have compressed "INSERT * INTO" statements using Compactor class in this package. */ final Logger logger = Logging.getLogger(LOGGER); final LogRecord record = Loggings.format(Level.INFO, LoggingKeys.CREATING_CACHED_EPSG_DATABASE_$1, VERSION); record.setLoggerName(logger.getName()); logger.log(record); ZipInputStream zin = new ZipInputStream(ThreadedH2EpsgFactory.class.getResourceAsStream(ZIP_FILE)); ZipEntry ze = null; byte[] buf = new byte[1024]; int read = 0; while ((ze = zin.getNextEntry()) != null) { File file = new File(directory, ze.getName()); if (file.exists()) { file.delete(); } FileOutputStream fout = new FileOutputStream(file); while ((read = zin.read(buf)) > 0) { fout.write(buf, 0, read); } zin.closeEntry(); fout.close(); } zin.close(); // mark the successful creation File marker = new File(directory, MARKER_FILE); if (marker.exists()) { marker.delete(); } marker.createNewFile(); setReadOnly(directory); } } catch (IOException exception) { SQLException e = new SQLException(Errors.format(ErrorKeys.CANT_READ_$1, ZIP_FILE)); e.initCause(exception); // TODO: inline cause when we will be allowed to target Java 6. throw e; } finally { if (lock != null) { try { lock.release(); lock.channel().close(); new File(directory, LOCK_FILE).delete(); } catch (IOException e) { // does not matter, was just cleanup } } } } FactoryUsingAnsiSQL factory = new FactoryUsingAnsiSQL(hints, getDataSource().getConnection()); factory.setValidationQuery("CALL NOW()"); return factory; }
public Connection getConnection() throws SQLException { // If we are already connected, test to see if we are // still connected. If not, reset our connection. if (this.connection != null && this.connection.isClosed()) try { Log.debug("Closing dead JDBC connection"); this.connection.close(); } catch (final SQLException e) { // We don't care. Ignore it. } finally { this.connection = null; } // If we are not connected, we should attempt to (re)connect now. if (this.connection == null) { Log.debug("Establishing JDBC connection"); // Start out with no driver at all. Class loadedDriverClass = null; // Try the system class loader instead. try { loadedDriverClass = Class.forName(this.conObj.getJdbcType().getDriverClassName()); } catch (final ClassNotFoundException e) { final SQLException e2 = new SQLException(); e2.initCause(e); throw e2; } // Check it really is an instance of Driver. if (!Driver.class.isAssignableFrom(loadedDriverClass)) throw new ClassCastException(Resources.get("driverClassNotJDBCDriver")); // Connect! final Properties properties = new Properties(); properties.setProperty("user", this.conObj.getUserName()); if (!this.conObj.getPassword().equals("")) properties.setProperty("password", this.conObj.getPassword()); properties.setProperty("nullCatalogMeansCurrent", "false"); /* * this.connection = DriverManager.getConnection( overrideDataLinkSchema == null ? this.conObj.getJdbcUrl(): * (this.conObj.getJdbcUrl()) .replaceAll(this.getDataLinkSchema(), overrideDataLinkSchema), properties); */ this.connection = DriverManager.getConnection( this.conObj.getJdbcUrl(), conObj.getUserName(), conObj.getPassword()); // Check the schema name. final DatabaseMetaData dmd = this.connection.getMetaData(); final String catalog = this.connection.getCatalog(); this.realSchemaName = this.getDataLinkSchema(); ResultSet rs = dmd.getTables(catalog, this.realSchemaName, "%", null); if (!rs.next()) { rs = dmd.getTables(catalog, this.realSchemaName.toUpperCase(), "%", null); if (rs.next()) this.realSchemaName = this.realSchemaName.toUpperCase(); } if (!rs.next()) { rs = dmd.getTables(catalog, this.realSchemaName.toLowerCase(), "%", null); if (rs.next()) this.realSchemaName = this.realSchemaName.toLowerCase(); } rs.close(); } // Return the connection. return this.connection; }
/** * This method will send a fetch rowset command to the server. * * @param maxRowCnt the maximum rowset count to return * @param maxRowLen the maximum row length to return * @param sqlAsyncEnable a flag to enable/disable asynchronies execution * @param queryTimeout the number of seconds before the query times out * @retrun a FetchPerfReply class representing the reply from the ODBC server is returned * @exception A SQLException is thrown */ FetchReply Fetch( int sqlAsyncEnable, int queryTimeout, int stmtHandle, int stmtCharset, int maxRowCnt, String cursorName, int cursorCharset, String stmtOptions) throws SQLException { try { getInputOutput().setTimeout(m_ic.t4props_.getNetworkTimeout()); LogicalByteArray wbuffer = FetchMessage.marshal( m_dialogueId, sqlAsyncEnable, queryTimeout, stmtHandle, m_stmtLabel, stmtCharset, maxRowCnt, 0 // infinite row size , cursorName, cursorCharset, stmtOptions, this.m_ic); LogicalByteArray rbuffer = getReadBuffer(TRANSPORT.SRVR_API_SQLFETCH, wbuffer); // // Process output parameters // FetchReply frr = new FetchReply(rbuffer, m_ic); return frr; } // end try catch (SQLException se) { throw se; } catch (CharacterCodingException e) { SQLException se = HPT4Messages.createSQLException( m_ic.t4props_, m_locale, "translation_of_parameter_failed", "FetchMessage", e.getMessage()); se.initCause(e); throw se; } catch (UnsupportedCharsetException e) { SQLException se = HPT4Messages.createSQLException( m_ic.t4props_, m_locale, "unsupported_encoding", e.getCharsetName()); se.initCause(e); throw se; } catch (Exception e) { SQLException se = HPT4Messages.createSQLException( m_ic.t4props_, m_locale, "fetch_perf_message_error", e.getMessage()); se.initCause(e); throw se; } // end catch } // end FetchPerf
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; }
/** * Convert an exception to a fulltext exception. * * @param e the original exception * @return the converted SQL exception */ protected static SQLException convertException(Exception e) { SQLException e2 = new SQLException("Error while indexing document", "FULLTEXT"); e2.initCause(e); return e2; }