diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/AE.java b/src/main/java/com/microsoft/sqlserver/jdbc/AE.java index b0a8347026..fd5bc852d2 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/AE.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/AE.java @@ -95,7 +95,9 @@ void add(byte[] encryptedKey, int dbId, int keyId, int keyVersion, byte[] mdVers assert null != columnEncryptionKeyValues : "columnEncryptionKeyValues should already be initialized."; - aeLogger.fine("Retrieving CEK values"); + if (aeLogger.isLoggable(java.util.logging.Level.FINE)) { + aeLogger.fine("Retrieving CEK values"); + } EncryptionKeyInfo encryptionKey = new EncryptionKeyInfo(encryptedKey, dbId, keyId, keyVersion, mdVersion, keyPath, keyStoreName, algorithmName); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/AuthenticationJNI.java b/src/main/java/com/microsoft/sqlserver/jdbc/AuthenticationJNI.java index a59489cc72..0364a3a78d 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/AuthenticationJNI.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/AuthenticationJNI.java @@ -5,6 +5,9 @@ package com.microsoft.sqlserver.jdbc; +import java.util.logging.Level; + + class FedAuthDllInfo { byte[] accessTokenBytes = null; long expiresIn = 0; @@ -97,7 +100,9 @@ byte[] GenerateClientContext(byte[] pin, boolean[] done) throws SQLServerExcepti null, null, authLogger); if (failure != 0) { - authLogger.warning(toString() + " Authentication failed code : " + failure); + if (authLogger.isLoggable(Level.WARNING)) { + authLogger.warning(toString() + " Authentication failed code : " + failure); + } con.terminate(SQLServerException.DRIVER_ERROR_NONE, SQLServerException.getErrString("R_integratedAuthenticationFailed"), linkError); } diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/DDC.java b/src/main/java/com/microsoft/sqlserver/jdbc/DDC.java index ad306ee1b9..7e18aec104 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/DDC.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/DDC.java @@ -1195,7 +1195,8 @@ final class AsciiFilteredInputStream extends InputStream { } AsciiFilteredInputStream(BaseInputStream containedStream) throws SQLServerException { - BaseInputStream.logger.finer(containedStream.toString() + " wrapping in AsciiFilteredInputStream"); + if (BaseInputStream.logger.isLoggable(java.util.logging.Level.FINER)) + BaseInputStream.logger.finer(containedStream.toString() + " wrapping in AsciiFilteredInputStream"); this.containedStream = containedStream; } @@ -1264,7 +1265,8 @@ final class AsciiFilteredUnicodeInputStream extends InputStream { static AsciiFilteredUnicodeInputStream MakeAsciiFilteredUnicodeInputStream(BaseInputStream strm, Reader rd) throws SQLServerException { - BaseInputStream.logger.finer(strm.toString() + " wrapping in AsciiFilteredInputStream"); + if (BaseInputStream.logger.isLoggable(java.util.logging.Level.FINER)) + BaseInputStream.logger.finer(strm.toString() + " wrapping in AsciiFilteredInputStream"); return new AsciiFilteredUnicodeInputStream(rd); } diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/FailOverInfo.java b/src/main/java/com/microsoft/sqlserver/jdbc/FailOverInfo.java index 1c2e97c6ad..14f394ab3d 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/FailOverInfo.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/FailOverInfo.java @@ -6,6 +6,8 @@ package com.microsoft.sqlserver.jdbc; import java.text.MessageFormat; +import java.util.logging.Level; + /** * This class keeps the failover server info and if the mirror has become the primary. For synchronizing better and not @@ -36,8 +38,9 @@ boolean getUseFailoverPartner() { // the members of this class are not exposed so inorder to log we call this function. void log(SQLServerConnection con) { - con.getConnectionLogger().fine(con.toString() + " Failover server :" + failoverPartner - + " Failover partner is primary : " + useFailoverPartner); + if (con.getConnectionLogger().isLoggable(Level.FINE)) + con.getConnectionLogger().fine(con.toString() + " Failover server :" + failoverPartner + + " Failover partner is primary : " + useFailoverPartner); } // this function gets the failover server port and sets up the security manager @@ -56,7 +59,8 @@ private void setupInfo(SQLServerConnection con) throws SQLServerException { // found the instance name with the severname if (px >= 0) { - con.getConnectionLogger().fine(con.toString() + " Failover server :" + failoverPartner); + if (con.getConnectionLogger().isLoggable(Level.FINE)) + con.getConnectionLogger().fine(con.toString() + " Failover server :" + failoverPartner); instanceValue = failoverPartner.substring(px + 1, failoverPartner.length()); failoverPartner = failoverPartner.substring(0, px); con.ValidateMaxSQLLoginName(SQLServerDriverStringProperty.INSTANCE_NAME.toString(), instanceValue); @@ -87,8 +91,9 @@ synchronized ServerPortPlaceHolder failoverPermissionCheck(SQLServerConnection c synchronized void failoverAdd(SQLServerConnection connection, boolean actualUseFailoverPartner, String actualFailoverPartner) throws SQLServerException { if (useFailoverPartner != actualUseFailoverPartner) { - connection.getConnectionLogger() - .fine(connection.toString() + " Failover detected. failover partner=" + actualFailoverPartner); + if (connection.getConnectionLogger().isLoggable(Level.FINE)) + connection.getConnectionLogger() + .fine(connection.toString() + " Failover detected. failover partner=" + actualFailoverPartner); useFailoverPartner = actualUseFailoverPartner; } // The checking for actualUseFailoverPartner may look weird but this is required diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/FailOverMapSingleton.java b/src/main/java/com/microsoft/sqlserver/jdbc/FailOverMapSingleton.java index 87dfcca9a4..c87beb042e 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/FailOverMapSingleton.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/FailOverMapSingleton.java @@ -35,8 +35,9 @@ static FailoverInfo getFailoverInfo(SQLServerConnection connection, String prima return null; } else { String mapKey = concatPrimaryDatabase(primaryServer, instance, database); - connection.getConnectionLogger() - .finer(connection.toString() + " Looking up info in the map using key: " + mapKey); + if (connection.getConnectionLogger().isLoggable(Level.FINER)) + connection.getConnectionLogger() + .finer(connection.toString() + " Looking up info in the map using key: " + mapKey); FailoverInfo fo = failoverMap.get(mapKey); if (null != fo) fo.log(connection); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java b/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java index 3a59c1fe03..056cf721ff 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/IOBuffer.java @@ -640,7 +640,8 @@ void resetPooledConnection() { */ final void open(String host, int port, int timeoutMillis, boolean useParallel, boolean useTnir, boolean isTnirFirstAttempt, int timeoutMillisForFullTimeout) throws SQLServerException { - logger.finer(this.toString() + ": Opening TCP socket..."); + if (logger.isLoggable(Level.FINER)) + logger.finer(this.toString() + ": Opening TCP socket..."); SocketFinder socketFinder = new SocketFinder(traceID, con); channelSocket = tcpSocket = socketFinder.findSocket(host, port, timeoutMillis, useParallel, useTnir, @@ -667,7 +668,8 @@ final void open(String host, int port, int timeoutMillis, boolean useParallel, b * Disables SSL on this TDS channel. */ void disableSSL() { - logger.finer(toString() + " Disabling SSL..."); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " Disabling SSL..."); /* * The mission: To close the SSLSocket and release everything that it is holding onto other than the TCP/IP @@ -698,13 +700,15 @@ void disableSSL() { } // Rewire the proxy socket to the closed streams - logger.finest(toString() + " Rewiring proxy streams for SSL socket close"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Rewiring proxy streams for SSL socket close"); proxySocket.setStreams(is, os); // Now close the SSL socket. It will see that the proxy socket's streams // are closed and not try to do any further I/O over them. try { - logger.finer(toString() + " Closing SSL socket"); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " Closing SSL socket"); sslSocket.close(); } catch (IOException e) { @@ -724,7 +728,8 @@ void disableSSL() { channelSocket = tcpSocket; sslSocket = null; - logger.finer(toString() + " SSL disabled"); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " SSL disabled"); } /** @@ -755,8 +760,9 @@ private class SSLHandshakeInputStream extends InputStream { */ private void ensureSSLPayload() throws IOException { if (0 == tdsReader.available()) { - logger.finest( - logContext + " No handshake response bytes available. Flushing SSL handshake output stream."); + if (logger.isLoggable(Level.FINEST)) + logger.finest(logContext + + " No handshake response bytes available. Flushing SSL handshake output stream."); try { sslHandshakeOutputStream.endMessage(); @@ -765,7 +771,8 @@ private void ensureSSLPayload() throws IOException { throw new IOException(e.getMessage()); } - logger.finest(logContext + " Reading first packet of SSL handshake response"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(logContext + " Reading first packet of SSL handshake response"); try { tdsReader.readPacket(); @@ -777,7 +784,8 @@ private void ensureSSLPayload() throws IOException { } public long skip(long n) throws IOException { - logger.finest(logContext + " Skipping " + n + " bytes..."); + if (logger.isLoggable(Level.FINEST)) + logger.finest(logContext + " Skipping " + n + " bytes..."); if (n <= 0) return 0; @@ -817,7 +825,8 @@ public int read(byte b[], int offset, int maxBytes) throws IOException { } private int readInternal(byte b[], int offset, int maxBytes) throws IOException { - logger.finest(logContext + " Reading " + maxBytes + " bytes..."); + if (logger.isLoggable(Level.FINEST)) + logger.finest(logContext + " Reading " + maxBytes + " bytes..."); ensureSSLPayload(); @@ -860,14 +869,16 @@ public void flush() throws IOException { // needs to be completely encapsulated in TDS. The SSL handshake // input stream always ensures that this output stream has been flushed // before trying to read the response. - logger.finest(logContext + " Ignored a request to flush the stream"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(logContext + " Ignored a request to flush the stream"); } void endMessage() throws SQLServerException { // We should only be asked to end the message if we have started one assert messageStarted; - logger.finest(logContext + " Finishing TDS message"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(logContext + " Finishing TDS message"); // Flush any remaining bytes through the writer. Since there may be fewer bytes // ready to send than a full TDS packet, we end the message here and start a new @@ -896,13 +907,15 @@ private void writeInternal(byte[] b, int off, int len) throws IOException { // Start out the handshake request in a new prelogin message. Subsequent // writes just add handshake data to the request until flushed. if (!messageStarted) { - logger.finest(logContext + " Starting new TDS packet..."); + if (logger.isLoggable(Level.FINEST)) + logger.finest(logContext + " Starting new TDS packet..."); tdsWriter.startMessage(null, TDS.PKT_PRELOGIN); messageStarted = true; } - logger.finest(logContext + " Writing " + len + " bytes..."); + if (logger.isLoggable(Level.FINEST)) + logger.finest(logContext + " Writing " + len + " bytes..."); tdsWriter.writeBytes(b, off, len); } catch (SQLServerException e) { @@ -932,11 +945,13 @@ final void setFilteredStream(InputStream is) { public long skip(long n) throws IOException { long bytesSkipped; - logger.finest(toString() + " Skipping " + n + " bytes"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Skipping " + n + " bytes"); bytesSkipped = filteredStream.skip(n); - logger.finest(toString() + " Skipped " + n + " bytes"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Skipped " + n + " bytes"); return bytesSkipped; } @@ -944,7 +959,8 @@ public long skip(long n) throws IOException { public int available() throws IOException { int bytesAvailable = filteredStream.available(); - logger.finest(toString() + " " + bytesAvailable + " bytes available"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " " + bytesAvailable + " bytes available"); return bytesAvailable; } @@ -971,18 +987,21 @@ public int read(byte b[], int offset, int maxBytes) throws IOException { private int readInternal(byte b[], int offset, int maxBytes) throws IOException { int bytesRead; - logger.finest(toString() + " Reading " + maxBytes + " bytes"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Reading " + maxBytes + " bytes"); try { bytesRead = filteredStream.read(b, offset, maxBytes); } catch (IOException e) { - logger.finer(toString() + " " + e.getMessage()); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " " + e.getMessage()); logger.finer(toString() + " Reading bytes threw exception:" + e.getMessage()); throw e; } - logger.finest(toString() + " Read " + bytesRead + " bytes"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Read " + bytesRead + " bytes"); return bytesRead; } @@ -990,25 +1009,29 @@ private int readInternal(byte b[], int offset, int maxBytes) throws IOException public boolean markSupported() { boolean markSupported = filteredStream.markSupported(); - logger.finest(toString() + " Returning markSupported: " + markSupported); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Returning markSupported: " + markSupported); return markSupported; } public void mark(int readLimit) { - logger.finest(toString() + " Marking next " + readLimit + " bytes"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Marking next " + readLimit + " bytes"); filteredStream.mark(readLimit); } public void reset() throws IOException { - logger.finest(toString() + " Resetting to previous mark"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Resetting to previous mark"); filteredStream.reset(); } public void close() throws IOException { - logger.finest(toString() + " Closing"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Closing"); filteredStream.close(); } @@ -1032,13 +1055,15 @@ final void setFilteredStream(OutputStream os) { } public void close() throws IOException { - logger.finest(toString() + " Closing"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Closing"); filteredStream.close(); } public void flush() throws IOException { - logger.finest(toString() + " Flushing"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Flushing"); filteredStream.flush(); } @@ -1059,7 +1084,8 @@ public void write(byte[] b, int off, int len) throws IOException { } private void writeInternal(byte[] b, int off, int len) throws IOException { - logger.finest(toString() + " Writing " + len + " bytes"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Writing " + len + " bytes"); filteredStream.write(b, off, len); } @@ -1102,13 +1128,15 @@ void setStreams(InputStream is, OutputStream os) { } public InputStream getInputStream() throws IOException { - logger.finest(logContext + " Getting input stream"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(logContext + " Getting input stream"); return proxyInputStream; } public OutputStream getOutputStream() throws IOException { - logger.finest(logContext + " Getting output stream"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(logContext + " Getting output stream"); return proxyOutputStream; } @@ -1221,55 +1249,68 @@ public void connect(SocketAddress endpoint, int timeout) throws IOException { // Ignore calls to methods that would otherwise allow the SSL socket // to directly manipulate the underlying TCP socket public void close() throws IOException { - logger.finer(logContext + " Ignoring close"); + if (logger.isLoggable(Level.FINER)) + logger.finer(logContext + " Ignoring close"); } public void setReceiveBufferSize(int size) throws SocketException { - logger.finer(toString() + " Ignoring setReceiveBufferSize size:" + size); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " Ignoring setReceiveBufferSize size:" + size); } public void setSendBufferSize(int size) throws SocketException { - logger.finer(toString() + " Ignoring setSendBufferSize size:" + size); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " Ignoring setSendBufferSize size:" + size); } public void setReuseAddress(boolean on) throws SocketException { - logger.finer(toString() + " Ignoring setReuseAddress"); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " Ignoring setReuseAddress"); } public void setSoLinger(boolean on, int linger) throws SocketException { - logger.finer(toString() + " Ignoring setSoLinger"); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " Ignoring setSoLinger"); } public void setSoTimeout(int timeout) throws SocketException { - logger.finer(toString() + " Ignoring setSoTimeout"); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " Ignoring setSoTimeout"); } public void setTcpNoDelay(boolean on) throws SocketException { - logger.finer(toString() + " Ignoring setTcpNoDelay"); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " Ignoring setTcpNoDelay"); } public void setTrafficClass(int tc) throws SocketException { - logger.finer(toString() + " Ignoring setTrafficClass"); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " Ignoring setTrafficClass"); } public void shutdownInput() throws IOException { - logger.finer(toString() + " Ignoring shutdownInput"); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " Ignoring shutdownInput"); } public void shutdownOutput() throws IOException { - logger.finer(toString() + " Ignoring shutdownOutput"); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " Ignoring shutdownOutput"); } public void sendUrgentData(int data) throws IOException { - logger.finer(toString() + " Ignoring sendUrgentData"); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " Ignoring sendUrgentData"); } public void setKeepAlive(boolean on) throws SocketException { - logger.finer(toString() + " Ignoring setKeepAlive"); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " Ignoring setKeepAlive"); } public void setOOBInline(boolean on) throws SocketException { - logger.finer(toString() + " Ignoring setOOBInline"); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " Ignoring setOOBInline"); } } @@ -1291,11 +1332,13 @@ private final class PermissiveX509TrustManager implements X509TrustManager { } public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException { - logger.finer(logContext + " Trusting client certificate (!)"); + if (logger.isLoggable(Level.FINER)) + logger.finer(logContext + " Trusting client certificate (!)"); } public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException { - logger.finer(logContext + " Trusting server certificate"); + if (logger.isLoggable(Level.FINER)) + logger.finer(logContext + " Trusting server certificate"); } public X509Certificate[] getAcceptedIssuers() { @@ -1359,40 +1402,48 @@ private String parseCommonName(String distinguishedName) { private boolean validateServerName(String nameInCert) throws CertificateException { // Failed to get the common name from DN or empty CN if (null == nameInCert) { - logger.finer(logContext + " Failed to parse the name from the certificate or name is empty."); + if (logger.isLoggable(Level.FINER)) + logger.finer(logContext + " Failed to parse the name from the certificate or name is empty."); return false; } // Verify that the name in certificate matches exactly with the host name if (!nameInCert.equals(hostName)) { - logger.finer(logContext + " The name in certificate " + nameInCert - + " does not match with the server name " + hostName + "."); + if (logger.isLoggable(Level.FINER)) + logger.finer(logContext + " The name in certificate " + nameInCert + + " does not match with the server name " + hostName + "."); return false; } - logger.finer(logContext + " The name in certificate:" + nameInCert + " validated against server name " - + hostName + "."); + if (logger.isLoggable(Level.FINER)) + logger.finer(logContext + " The name in certificate:" + nameInCert + " validated against server name " + + hostName + "."); return true; } public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException { - logger.finest(logContext + " Forwarding ClientTrusted."); + if (logger.isLoggable(Level.FINEST)) + logger.finest(logContext + " Forwarding ClientTrusted."); defaultTrustManager.checkClientTrusted(chain, authType); } public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException { - logger.finest(logContext + " Forwarding Trusting server certificate"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(logContext + " Forwarding Trusting server certificate"); defaultTrustManager.checkServerTrusted(chain, authType); - logger.finest(logContext + " default serverTrusted succeeded proceeding with server name validation"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(logContext + " default serverTrusted succeeded proceeding with server name validation"); validateServerNameInCertificate(chain[0]); } private void validateServerNameInCertificate(X509Certificate cert) throws CertificateException { String nameInCertDN = cert.getSubjectX500Principal().getName("canonical"); - logger.finer(logContext + " Validating the server name:" + hostName); - logger.finer(logContext + " The DN name in certificate:" + nameInCertDN); + if (logger.isLoggable(Level.FINER)) { + logger.finer(logContext + " Validating the server name:" + hostName); + logger.finer(logContext + " The DN name in certificate:" + nameInCertDN); + } boolean isServerNameValidated; @@ -1413,9 +1464,12 @@ private void validateServerNameInCertificate(X509Certificate cert) throws Certif Object key = sanEntry.get(0); Object value = sanEntry.get(1); - logger.finer(logContext + "Key: " + key + "; KeyClass:" - + (key != null ? key.getClass() : null) + ";value: " + value + "; valueClass:" - + (value != null ? value.getClass() : null)); + if (logger.isLoggable(Level.FINER)) { + logger.finer(logContext + "Key: " + key + "; KeyClass:" + + (key != null ? key.getClass() : null) + ";value: " + value + "; valueClass:" + + (value != null ? value.getClass() : null)); + + } // From // Documentation(http://download.oracle.com/javase/6/docs/api/java/security/cert/X509Certificate.html): @@ -1443,18 +1497,25 @@ private void validateServerNameInCertificate(X509Certificate cert) throws Certif isServerNameValidated = validateServerName(dnsNameInSANCert); if (isServerNameValidated) { - logger.finer( - logContext + " found a valid name in certificate: " + dnsNameInSANCert); + if (logger.isLoggable(Level.FINER)) { + logger.finer(logContext + " found a valid name in certificate: " + + dnsNameInSANCert); + } break; } } - logger.finer(logContext - + " the following name in certificate does not match the serverName: " + value); + if (logger.isLoggable(Level.FINER)) { + logger.finer(logContext + + " the following name in certificate does not match the serverName: " + + value); + } } } else { - logger.finer(logContext + " found an invalid san entry: " + sanEntry); + if (logger.isLoggable(Level.FINER)) { + logger.finer(logContext + " found an invalid san entry: " + sanEntry); + } } } @@ -1502,7 +1563,8 @@ void enableSSL(String host, int port) throws SQLServerException { // If anything in here fails, terminate the connection and throw an exception try { - logger.finer(toString() + " Enabling SSL..."); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " Enabling SSL..."); String trustStoreFileName = con.activeConnectionProperties .getProperty(SQLServerDriverStringProperty.TRUST_STORE.toString()); @@ -1540,7 +1602,8 @@ void enableSSL(String host, int port) throws SQLServerException { TrustManager[] tm = null; if (TDS.ENCRYPT_OFF == con.getRequestedEncryptionLevel() || (TDS.ENCRYPT_ON == con.getRequestedEncryptionLevel() && con.trustServerCertificate())) { - logger.finer(toString() + " SSL handshake will trust any certificate"); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " SSL handshake will trust any certificate"); tm = new TrustManager[] {new PermissiveX509TrustManager(this)}; } @@ -1563,7 +1626,8 @@ else if (con.getTrustManagerClass() != null) { // Otherwise, we'll validate the certificate using a real TrustManager obtained // from the a security provider that is capable of validating X.509 certificates. else { - logger.finer(toString() + " SSL handshake will validate server certificate"); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " SSL handshake will validate server certificate"); KeyStore ks = null; @@ -1571,7 +1635,8 @@ else if (con.getTrustManagerClass() != null) { // then we can skip all of the KeyStore loading logic below. // The security provider's implementation takes care of everything for us. if (null == trustStoreFileName && null == trustStorePassword) { - logger.finer(toString() + " Using system default trust store and password"); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " Using system default trust store and password"); } // Otherwise either the trustStore, trustStorePassword, or both was specified. @@ -1579,7 +1644,8 @@ else if (con.getTrustManagerClass() != null) { else { // First, obtain an interface to a KeyStore that can load trust material // stored in Java Key Store (JKS) format. - logger.finest(toString() + " Finding key store interface"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Finding key store interface"); ks = KeyStore.getInstance(trustStoreType); ksProvider = ks.getProvider(); @@ -1592,7 +1658,8 @@ else if (con.getTrustManagerClass() != null) { // Finally, load the KeyStore with the trust material (if any) from the // InputStream and close the stream. - logger.finest(toString() + " Loading key store"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Loading key store"); try { ks.load(is, (null == trustStorePassword) ? null : trustStorePassword.toCharArray()); @@ -1606,7 +1673,8 @@ else if (con.getTrustManagerClass() != null) { try { is.close(); } catch (IOException e) { - logger.fine(toString() + " Ignoring error closing trust material InputStream..."); + if (logger.isLoggable(Level.FINE)) + logger.fine(toString() + " Ignoring error closing trust material InputStream..."); } } } @@ -1621,7 +1689,8 @@ else if (con.getTrustManagerClass() != null) { // that understands X.509 certificates. TrustManagerFactory tmf = null; - logger.finest(toString() + " Locating X.509 trust manager factory"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Locating X.509 trust manager factory"); tmfDefaultAlgorithm = TrustManagerFactory.getDefaultAlgorithm(); tmf = TrustManagerFactory.getInstance(tmfDefaultAlgorithm); @@ -1629,7 +1698,8 @@ else if (con.getTrustManagerClass() != null) { // Tell the TrustManagerFactory to give us TrustManagers that we can use to // validate the server certificate using the trust material in the KeyStore. - logger.finest(toString() + " Getting trust manager"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Getting trust manager"); tmf.init(ks); tm = tmf.getTrustManagers(); @@ -1650,12 +1720,14 @@ else if (con.getTrustManagerClass() != null) { // SSL sockets through a SSL socket factory. We require at least TLS support. SSLContext sslContext = null; - logger.finest(toString() + " Getting TLS or better SSL context"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Getting TLS or better SSL context"); sslContext = SSLContext.getInstance(sslProtocol); sslContextProvider = sslContext.getProvider(); - logger.finest(toString() + " Initializing SSL context"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Initializing SSL context"); sslContext.init(null, tm, null); @@ -1664,13 +1736,15 @@ else if (con.getTrustManagerClass() != null) { // Initially, the proxy is set to encapsulate the SSL handshake in TDS packets. proxySocket = new ProxySocket(this); - logger.finest(toString() + " Creating SSL socket"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Creating SSL socket"); // don't close proxy when SSL socket is closed sslSocket = (SSLSocket) sslContext.getSocketFactory().createSocket(proxySocket, host, port, false); // At long last, start the SSL handshake ... - logger.finer(toString() + " Starting SSL handshake"); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " Starting SSL handshake"); // TLS 1.2 intermittent exception happens here. handshakeState = SSLHandhsakeState.SSL_HANDHSAKE_STARTED; @@ -1678,41 +1752,48 @@ else if (con.getTrustManagerClass() != null) { handshakeState = SSLHandhsakeState.SSL_HANDHSAKE_COMPLETE; // After SSL handshake is complete, rewire proxy socket to use raw TCP/IP streams ... - logger.finest(toString() + " Rewiring proxy streams after handshake"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Rewiring proxy streams after handshake"); proxySocket.setStreams(inputStream, outputStream); // ... and rewire TDSChannel to use SSL streams. - logger.finest(toString() + " Getting SSL InputStream"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Getting SSL InputStream"); inputStream = sslSocket.getInputStream(); - logger.finest(toString() + " Getting SSL OutputStream"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Getting SSL OutputStream"); outputStream = sslSocket.getOutputStream(); // SSL is now enabled; switch over the channel socket channelSocket = sslSocket; - logger.finer(toString() + " SSL enabled"); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " SSL enabled"); } catch (Exception e) { - logger.log(Level.FINER, e.getMessage(), e); + // Log the original exception and its source at FINER level + if (logger.isLoggable(Level.FINER)) + logger.log(Level.FINER, e.getMessage(), e); // If enabling SSL fails, the following information may help diagnose the problem. // Do not use Level INFO or above which is sent to standard output/error streams. // This is because due to an intermittent TLS 1.2 connection issue, we will be retrying the connection and // do not want to print this message in console. - logger.log(Level.FINER, "java.security path: " + JAVA_SECURITY + "\n" + "Security providers: " - + Arrays.asList(Security.getProviders()) + "\n" - + ((null != sslContextProvider) ? ("SSLContext provider info: " + sslContextProvider.getInfo() - + "\n" + "SSLContext provider services:\n" + sslContextProvider.getServices() + "\n") - : "") - + ((null != tmfProvider) ? ("TrustManagerFactory provider info: " + tmfProvider.getInfo() - + "\n") : "") - + ((null != tmfDefaultAlgorithm) ? ("TrustManagerFactory default algorithm: " - + tmfDefaultAlgorithm + "\n") : "") - + ((null != ksProvider) ? ("KeyStore provider info: " + ksProvider.getInfo() + "\n") : "") - + "java.ext.dirs: " + System.getProperty("java.ext.dirs")); + if (logger.isLoggable(Level.FINER)) + logger.log(Level.FINER, "java.security path: " + JAVA_SECURITY + "\n" + "Security providers: " + + Arrays.asList(Security.getProviders()) + "\n" + + ((null != sslContextProvider) ? ("SSLContext provider info: " + sslContextProvider.getInfo() + + "\n" + "SSLContext provider services:\n" + sslContextProvider.getServices() + "\n") + : "") + + ((null != tmfProvider) ? ("TrustManagerFactory provider info: " + tmfProvider.getInfo() + + "\n") : "") + + ((null != tmfDefaultAlgorithm) ? ("TrustManagerFactory default algorithm: " + + tmfDefaultAlgorithm + "\n") : "") + + ((null != ksProvider) ? ("KeyStore provider info: " + ksProvider.getInfo() + "\n") : "") + + "java.ext.dirs: " + System.getProperty("java.ext.dirs")); // Retrieve the localized error message if possible. String localizedMessage = e.getLocalizedMessage(); String errMsg = (localizedMessage != null) ? localizedMessage : e.getMessage(); @@ -1787,7 +1868,8 @@ private void validateFips(final String trustStoreType, final String trustStoreFi if (isValidTrustStore && !isValidTrustStoreType) { // In case of valid trust store we need to check TrustStoreType. isValid = false; - logger.finer(toString() + "TrustStoreType is required alongside with TrustStore."); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + "TrustStoreType is required alongside with TrustStore."); } } @@ -1824,11 +1906,13 @@ final InputStream loadTrustStore(String trustStoreFileName) { // First case: Trust store filename was specified if (null != trustStoreFileName) { try { - logger.finest(toString() + " Opening specified trust store: " + trustStoreFileName); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Opening specified trust store: " + trustStoreFileName); is = new FileInputStream(trustStoreFileName); } catch (FileNotFoundException e) { - logger.fine(toString() + " Trust store not found: " + e.getMessage()); + if (logger.isLoggable(Level.FINE)) + logger.fine(toString() + " Trust store not found: " + e.getMessage()); // If the trustStoreFileName connection property is set, but the file is not found, // then treat it as if the file was empty so that the TrustManager reports @@ -1839,12 +1923,14 @@ final InputStream loadTrustStore(String trustStoreFileName) { // Second case: Trust store filename derived from javax.net.ssl.trustStore system property else if (null != (trustStoreFileName = System.getProperty("javax.net.ssl.trustStore"))) { try { - logger.finest(toString() + " Opening default trust store (from javax.net.ssl.trustStore): " - + trustStoreFileName); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Opening default trust store (from javax.net.ssl.trustStore): " + + trustStoreFileName); is = new FileInputStream(trustStoreFileName); } catch (FileNotFoundException e) { - logger.fine(toString() + " Trust store not found: " + e.getMessage()); + if (logger.isLoggable(Level.FINE)) + logger.fine(toString() + " Trust store not found: " + e.getMessage()); // If the javax.net.ssl.trustStore property is set, but the file is not found, // then treat it as if the file was empty so that the TrustManager reports @@ -1855,21 +1941,25 @@ else if (null != (trustStoreFileName = System.getProperty("javax.net.ssl.trustSt // Third case: No trust store specified and no system property set. Use jssecerts/cacerts. else { try { - logger.finest(toString() + " Opening default trust store: " + JSSECACERTS); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Opening default trust store: " + JSSECACERTS); is = new FileInputStream(JSSECACERTS); } catch (FileNotFoundException e) { - logger.fine(toString() + " Trust store not found: " + e.getMessage()); + if (logger.isLoggable(Level.FINE)) + logger.fine(toString() + " Trust store not found: " + e.getMessage()); } // No jssecerts. Try again with cacerts... if (null == is) { try { - logger.finest(toString() + " Opening default trust store: " + CACERTS); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Opening default trust store: " + CACERTS); is = new FileInputStream(CACERTS); } catch (FileNotFoundException e) { - logger.fine(toString() + " Trust store not found: " + e.getMessage()); + if (logger.isLoggable(Level.FINE)) + logger.fine(toString() + " Trust store not found: " + e.getMessage()); // No jssecerts or cacerts. Treat it as if the trust store is empty so that // the TrustManager reports that no certificate is found. @@ -1884,7 +1974,8 @@ final int read(byte[] data, int offset, int length) throws SQLServerException { try { return inputStream.read(data, offset, length); } catch (IOException e) { - logger.fine(toString() + " read failed:" + e.getMessage()); + if (logger.isLoggable(Level.FINE)) + logger.fine(toString() + " read failed:" + e.getMessage()); if (e instanceof SocketTimeoutException) { con.terminate(SQLServerException.ERROR_SOCKET_TIMEOUT, e.getMessage(), e); @@ -1900,7 +1991,8 @@ final void write(byte[] data, int offset, int length) throws SQLServerException try { outputStream.write(data, offset, length); } catch (IOException e) { - logger.finer(toString() + " write failed:" + e.getMessage()); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " write failed:" + e.getMessage()); con.terminate(SQLServerException.DRIVER_ERROR_IO_FAILED, e.getMessage(), e); } @@ -1910,7 +2002,8 @@ final void flush() throws SQLServerException { try { outputStream.flush(); } catch (IOException e) { - logger.finer(toString() + " flush failed:" + e.getMessage()); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " flush failed:" + e.getMessage()); con.terminate(SQLServerException.DRIVER_ERROR_IO_FAILED, e.getMessage(), e); } @@ -1921,32 +2014,38 @@ final void close() { disableSSL(); if (null != inputStream) { - logger.finest(this.toString() + ": Closing inputStream..."); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this.toString() + ": Closing inputStream..."); try { inputStream.close(); } catch (IOException e) { - logger.log(Level.FINE, this.toString() + ": Ignored error closing inputStream", e); + if (logger.isLoggable(Level.FINE)) + logger.log(Level.FINE, this.toString() + ": Ignored error closing inputStream", e); } } if (null != outputStream) { - logger.finest(this.toString() + ": Closing outputStream..."); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this.toString() + ": Closing outputStream..."); try { outputStream.close(); } catch (IOException e) { - logger.log(Level.FINE, this.toString() + ": Ignored error closing outputStream", e); + if (logger.isLoggable(Level.FINE)) + logger.log(Level.FINE, this.toString() + ": Ignored error closing outputStream", e); } } if (null != tcpSocket) { - logger.finer(this.toString() + ": Closing TCP socket..."); + if (logger.isLoggable(Level.FINER)) + logger.finer(this.toString() + ": Closing TCP socket..."); try { tcpSocket.close(); } catch (IOException e) { - logger.log(Level.FINE, this.toString() + ": Ignored error closing socket", e); + if (logger.isLoggable(Level.FINE)) + logger.log(Level.FINE, this.toString() + ": Ignored error closing socket", e); } } } @@ -2041,7 +2140,9 @@ final void close() { logMsg.append("\r\n"); } - packetLogger.finest(logMsg.toString()); + if (packetLogger.isLoggable(Level.FINEST)) { + packetLogger.finest(logMsg.toString()); + } } /** @@ -2220,10 +2321,14 @@ Socket findSocket(String hostName, int portNumber, int timeoutInMilliSeconds, bo } timeoutInMilliSeconds = Math.max(timeoutInMilliSeconds, minTimeoutForParallelConnections); if (Util.isIBM()) { - logger.finer(this.toString() + "Using Java NIO with timeout:" + timeoutInMilliSeconds); + if (logger.isLoggable(Level.FINER)) { + logger.finer(this.toString() + "Using Java NIO with timeout:" + timeoutInMilliSeconds); + } findSocketUsingJavaNIO(inetAddrs, portNumber, timeoutInMilliSeconds); } else { - logger.finer(this.toString() + "Using Threading with timeout:" + timeoutInMilliSeconds); + if (logger.isLoggable(Level.FINER)) { + logger.finer(this.toString() + "Using Threading with timeout:" + timeoutInMilliSeconds); + } findSocketUsingThreading(inetAddrs, portNumber, timeoutInMilliSeconds); } @@ -2235,7 +2340,9 @@ Socket findSocket(String hostName, int portNumber, int timeoutInMilliSeconds, bo synchronized (socketFinderlock) { if (result.equals(Result.UNKNOWN)) { result = Result.FAILURE; - logger.finer(this.toString() + " The parent thread updated the result to failure"); + if (logger.isLoggable(Level.FINER)) { + logger.finer(this.toString() + " The parent thread updated the result to failure"); + } } } } @@ -2246,8 +2353,10 @@ Socket findSocket(String hostName, int portNumber, int timeoutInMilliSeconds, bo // as their function calls would now be no-ops. if (result.equals(Result.FAILURE)) { if (selectedException == null) { - logger.finer(this.toString() - + " There is no selectedException. The wait calls timed out before any connect call returned or timed out."); + if (logger.isLoggable(Level.FINER)) { + logger.finer(this.toString() + + " There is no selectedException. The wait calls timed out before any connect call returned or timed out."); + } String message = SQLServerException.getErrString("R_connectionTimedOut"); selectedException = new IOException(message); } @@ -2321,8 +2430,9 @@ private void findSocketUsingJavaNIO(InetAddress[] inetAddrs, int portNumber, sChannel.connect(new InetSocketAddress(inetAddr, portNumber)); - logger.finer(this.toString() + " initiated connection to address: " + inetAddr + ", portNumber: " - + portNumber); + if (logger.isLoggable(Level.FINER)) + logger.finer(this.toString() + " initiated connection to address: " + inetAddr + ", portNumber: " + + portNumber); } long timerNow = System.currentTimeMillis(); @@ -2341,7 +2451,8 @@ private void findSocketUsingJavaNIO(InetAddress[] inetAddrs, int portNumber, // or encountered an exception while trying to connect int readyChannels = selector.select(timeRemaining); - logger.finer(this.toString() + " no of channels ready: " + readyChannels); + if (logger.isLoggable(Level.FINER)) + logger.finer(this.toString() + " no of channels ready: " + readyChannels); // There are no real time guarantees on the time out of the select API used above. // This check is necessary @@ -2356,8 +2467,9 @@ private void findSocketUsingJavaNIO(InetAddress[] inetAddrs, int portNumber, SelectionKey key = keyIterator.next(); SocketChannel ch = (SocketChannel) key.channel(); - logger.finer(this.toString() + " processing the channel :" + ch);// this traces the IP by - // default + if (logger.isLoggable(Level.FINER)) + logger.finer(this.toString() + " processing the channel :" + ch);// this traces the IP by + // default boolean connected = false; try { @@ -2369,12 +2481,14 @@ private void findSocketUsingJavaNIO(InetAddress[] inetAddrs, int portNumber, selectedChannel = ch; - logger.finer(this.toString() + " selected the channel :" + selectedChannel); + if (logger.isLoggable(Level.FINER)) + logger.finer(this.toString() + " selected the channel :" + selectedChannel); break; } catch (IOException ex) { - logger.finer(this.toString() + " the exception: " + ex.getClass() + " with message: " - + ex.getMessage() + " occurred while processing the channel: " + ch); + if (logger.isLoggable(Level.FINER)) + logger.finer(this.toString() + " the exception: " + ex.getClass() + " with message: " + + ex.getMessage() + " occurred while processing the channel: " + ch); updateSelectedException(ex, this.toString()); // close the channel pro-actively so that we do not // rely to network resources @@ -2497,9 +2611,11 @@ private void findSocketUsingThreading(InetAddress[] inetAddrs, int portNumber, while (true) { long timeRemaining = timerExpire - timerNow; - logger.finer(this.toString() + " TimeRemaining:" + timeRemaining + "; Result:" + result - + "; Max. open thread count: " + threadPoolExecutor.getLargestPoolSize() - + "; Current open thread count:" + threadPoolExecutor.getActiveCount()); + if (logger.isLoggable(Level.FINER)) { + logger.finer(this.toString() + " TimeRemaining:" + timeRemaining + "; Result:" + result + + "; Max. open thread count: " + threadPoolExecutor.getLargestPoolSize() + + "; Current open thread count:" + threadPoolExecutor.getActiveCount()); + } // if there is no time left or if the result is determined, break. // Note that a dirty read of result is totally fine here. @@ -2517,7 +2633,9 @@ private void findSocketUsingThreading(InetAddress[] inetAddrs, int portNumber, parentThreadLock.wait(timeRemaining); - logger.finer(this.toString() + " The parent thread wokeup."); + if (logger.isLoggable(Level.FINER)) { + logger.finer(this.toString() + " The parent thread wokeup."); + } timerNow = System.currentTimeMillis(); } @@ -2555,36 +2673,43 @@ Result getResult() { void close(Selector selector) { if (null != selector) { - logger.finer(this.toString() + ": Closing Selector"); + if (logger.isLoggable(Level.FINER)) + logger.finer(this.toString() + ": Closing Selector"); try { selector.close(); } catch (IOException e) { - logger.log(Level.FINE, this.toString() + ": Ignored the following error while closing Selector", e); + if (logger.isLoggable(Level.FINE)) + logger.log(Level.FINE, this.toString() + ": Ignored the following error while closing Selector", e); } } } void close(Socket socket) { if (null != socket) { - logger.finer(this.toString() + ": Closing TCP socket:" + socket); + if (logger.isLoggable(Level.FINER)) + logger.finer(this.toString() + ": Closing TCP socket:" + socket); try { socket.close(); } catch (IOException e) { - logger.log(Level.FINE, this.toString() + ": Ignored the following error while closing socket", e); + if (logger.isLoggable(Level.FINE)) + logger.log(Level.FINE, this.toString() + ": Ignored the following error while closing socket", e); } } } void close(SocketChannel socketChannel) { if (null != socketChannel) { - logger.finer(this.toString() + ": Closing TCP socket channel:" + socketChannel); + if (logger.isLoggable(Level.FINER)) + logger.finer(this.toString() + ": Closing TCP socket channel:" + socketChannel); try { socketChannel.close(); } catch (IOException e) { - logger.log(Level.FINE, this.toString() + "Ignored the following error while closing socketChannel", e); + if (logger.isLoggable(Level.FINE)) + logger.log(Level.FINE, this.toString() + "Ignored the following error while closing socketChannel", + e); } } } @@ -2604,10 +2729,14 @@ void close(SocketChannel socketChannel) { */ void updateResult(Socket socket, IOException exception, String threadId) { if (result.equals(Result.UNKNOWN)) { - logger.finer("The following child thread is waiting for socketFinderLock:" + threadId); + if (logger.isLoggable(Level.FINER)) { + logger.finer("The following child thread is waiting for socketFinderLock:" + threadId); + } synchronized (socketFinderlock) { - logger.finer("The following child thread acquired socketFinderLock:" + threadId); + if (logger.isLoggable(Level.FINER)) { + logger.finer("The following child thread acquired socketFinderLock:" + threadId); + } if (result.equals(Result.UNKNOWN)) { // if the connection was successful and no socket has been @@ -2615,7 +2744,9 @@ void updateResult(Socket socket, IOException exception, String threadId) { if (exception == null && selectedSocket == null) { selectedSocket = socket; result = Result.SUCCESS; - logger.finer("The socket of the following thread has been chosen:" + threadId); + if (logger.isLoggable(Level.FINER)) { + logger.finer("The socket of the following thread has been chosen:" + threadId); + } } // if an exception occurred @@ -2655,20 +2786,29 @@ void updateResult(Socket socket, IOException exception, String threadId) { // This results in better performance as it would close unnecessary // sockets and thus help child threads die quickly. - logger.finer("The following child thread is waiting for parentThreadLock:" + threadId); + if (logger.isLoggable(Level.FINER)) { + logger.finer("The following child thread is waiting for parentThreadLock:" + threadId); + } synchronized (parentThreadLock) { - logger.finer("The following child thread acquired parentThreadLock:" + threadId); + if (logger.isLoggable(Level.FINER)) { + logger.finer("The following child thread acquired parentThreadLock:" + threadId); + } parentThreadLock.notify(); } - logger.finer("The following child thread released parentThreadLock and notified the parent thread:" - + threadId); + if (logger.isLoggable(Level.FINER)) { + logger.finer( + "The following child thread released parentThreadLock and notified the parent thread:" + + threadId); + } } } - logger.finer("The following child thread released socketFinderLock:" + threadId); + if (logger.isLoggable(Level.FINER)) { + logger.finer("The following child thread released socketFinderLock:" + threadId); + } } } @@ -2698,8 +2838,10 @@ public void updateSelectedException(IOException ex, String traceId) { } if (updatedException) { - logger.finer("The selected exception is updated to the following: ExceptionType:" + ex.getClass() - + "; ExceptionMessage:" + ex.getMessage() + "; by the following thread:" + traceId); + if (logger.isLoggable(Level.FINER)) { + logger.finer("The selected exception is updated to the following: ExceptionType:" + ex.getClass() + + "; ExceptionMessage:" + ex.getMessage() + "; by the following thread:" + traceId); + } } } @@ -2766,13 +2908,17 @@ public void run() { SocketFinder.Result result = socketFinder.getResult(); if (result.equals(SocketFinder.Result.UNKNOWN)) { try { - logger.finer(this.toString() + " connecting to InetSocketAddress:" + inetSocketAddress - + " with timeout:" + timeoutInMilliseconds); + if (logger.isLoggable(Level.FINER)) { + logger.finer(this.toString() + " connecting to InetSocketAddress:" + inetSocketAddress + + " with timeout:" + timeoutInMilliseconds); + } socket.connect(inetSocketAddress, timeoutInMilliseconds); } catch (IOException ex) { - logger.finer(this.toString() + " exception:" + ex.getClass() + " with message:" + ex.getMessage() - + " occurred while connecting to InetSocketAddress:" + inetSocketAddress); + if (logger.isLoggable(Level.FINER)) { + logger.finer(this.toString() + " exception:" + ex.getClass() + " with message:" + ex.getMessage() + + " occurred while connecting to InetSocketAddress:" + inetSocketAddress); + } exception = ex; } @@ -2795,7 +2941,8 @@ public String toString() { */ private static synchronized long nextThreadID() { if (lastThreadID == Long.MAX_VALUE) { - logger.finer("Resetting the Id count"); + if (logger.isLoggable(Level.FINER)) + logger.finer("Resetting the Id count"); lastThreadID = 1; } else { lastThreadID++; @@ -2942,7 +3089,8 @@ void writeTraceHeaderData() throws SQLServerException { writeBytes(actIdByteArray, 0, actIdByteArray.length); // guid part of ActivityId writeInt((int) seqNum); // sequence number of ActivityId - logger.finer("Send Trace Header - ActivityID: " + activityId.toString()); + if (logger.isLoggable(Level.FINER)) + logger.finer("Send Trace Header - ActivityID: " + activityId.toString()); } /** @@ -2979,7 +3127,8 @@ void startMessage(TDSCommand command, byte tdsMessageType) throws SQLServerExcep } final void endMessage() throws SQLServerException { - logger.finest(toString() + " Finishing TDS message"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Finishing TDS message"); writePacket(TDS.STATUS_BIT_EOM); } @@ -2990,7 +3139,8 @@ final boolean ignoreMessage() throws SQLServerException { if (packetNum > 0 || TDS.PKT_BULK == this.tdsMessageType) { assert !isEOMSent; - logger.finest(toString() + " Finishing TDS message by sending ignore bit and end of message"); + if (logger.isLoggable(Level.FINER)) + logger.finest(toString() + " Finishing TDS message by sending ignore bit and end of message"); writePacket(TDS.STATUS_BIT_EOM | TDS.STATUS_BIT_ATTENTION); return true; } @@ -2998,7 +3148,8 @@ final boolean ignoreMessage() throws SQLServerException { } final void resetPooledConnection() { - logger.finest(toString() + " resetPooledConnection"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " resetPooledConnection"); sendResetConnection = TDS.STATUS_BIT_RESET_CONN; } @@ -3497,7 +3648,8 @@ void writeBytes(byte[] value, int offset, int length) throws SQLServerException int bytesWritten = 0; int bytesToWrite; - logger.finest(toString() + " Writing " + length + " bytes"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Writing " + length + " bytes"); while ((bytesToWrite = length - bytesWritten) > 0) { if (0 == stagingBuffer.remaining()) @@ -3815,7 +3967,8 @@ final boolean sendAttention() throws SQLServerException { // isEOMSent would be updated in writePacket everytime an EOM is sent // assert isEOMSent; - logger.fine(this + ": sending attention..."); + if (logger.isLoggable(Level.FINE)) + logger.fine(this + ": sending attention..."); ++tdsChannel.numMsgsSent; @@ -6112,12 +6265,14 @@ final boolean getServerSupportsDataClassification() { } final void throwInvalidTDS() throws SQLServerException { - logger.severe(toString() + " got unexpected value in TDS response at offset:" + payloadOffset); + if (logger.isLoggable(Level.SEVERE)) + logger.severe(toString() + " got unexpected value in TDS response at offset:" + payloadOffset); con.throwInvalidTDS(); } final void throwInvalidTDSToken(String tokenName) throws SQLServerException { - logger.severe(toString() + " got unexpected value in TDS response at offset:" + payloadOffset); + if (logger.isLoggable(Level.SEVERE)) + logger.severe(toString() + " got unexpected value in TDS response at offset:" + payloadOffset); con.throwInvalidTDSToken(tokenName); } @@ -6162,7 +6317,8 @@ private boolean nextPacket() throws SQLServerException { // before moving to allow the packet to be reclaimed. TDSPacket nextPacket = consumedPacket.next; if (isStreaming) { - logger.finest(toString() + " Moving to next packet -- unlinking consumed packet"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Moving to next packet -- unlinking consumed packet"); consumedPacket.next = null; } @@ -6188,7 +6344,6 @@ synchronized final boolean readPacket() throws SQLServerException { + " should be less than numMsgsSent:" + tdsChannel.numMsgsSent; TDSPacket newPacket = new TDSPacket(con.getTDSPacketSize()); - if (null != command) { // if cancelQueryTimeout is set, we should wait for the total amount of // queryTimeout + cancelQueryTimeout to @@ -6205,8 +6360,9 @@ synchronized final boolean readPacket() throws SQLServerException { int bytesRead = tdsChannel.read(newPacket.header, headerBytesRead, TDS.PACKET_HEADER_SIZE - headerBytesRead); if (bytesRead < 0) { - logger.finer(toString() + " Premature EOS in response. packetNum:" + packetNum + " headerBytesRead:" - + headerBytesRead); + if (logger.isLoggable(Level.FINER)) + logger.finer(toString() + " Premature EOS in response. packetNum:" + packetNum + " headerBytesRead:" + + headerBytesRead); con.terminate(SQLServerException.DRIVER_ERROR_IO_FAILED, ((0 == packetNum && 0 == headerBytesRead) ? SQLServerException.getErrString( @@ -6225,8 +6381,10 @@ synchronized final boolean readPacket() throws SQLServerException { // Make header size is properly bounded and compute length of the packet payload. if (packetLength < TDS.PACKET_HEADER_SIZE || packetLength > con.getTDSPacketSize()) { - logger.warning(toString() + " TDS header contained invalid packet length:" + packetLength + "; packet size:" - + con.getTDSPacketSize()); + if (logger.isLoggable(Level.WARNING)) { + logger.warning(toString() + " TDS header contained invalid packet length:" + packetLength + + "; packet size:" + con.getTDSPacketSize()); + } throwInvalidTDS(); } @@ -6284,13 +6442,15 @@ final TDSReaderMark mark() { TDSReaderMark mark = new TDSReaderMark(currentPacket, payloadOffset); isStreaming = false; - logger.finest(this.toString() + ": Buffering from: " + mark.toString()); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this.toString() + ": Buffering from: " + mark.toString()); return mark; } final void reset(TDSReaderMark mark) { - logger.finest(this.toString() + ": Resetting to: " + mark.toString()); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this.toString() + ": Resetting to: " + mark.toString()); currentPacket = mark.packet; payloadOffset = mark.payloadOffset; @@ -6435,7 +6595,8 @@ final void readBytes(byte[] value, int valueOffset, int valueLength) throws SQLS bytesToCopy = currentPacket.payloadLength - payloadOffset; // Copy some bytes from the current packet to the destination value. - logger.finest(toString() + " Reading " + bytesToCopy + " bytes from offset " + payloadOffset); + if (logger.isLoggable(Level.FINEST)) + logger.finest(toString() + " Reading " + bytesToCopy + " bytes from offset " + payloadOffset); System.arraycopy(currentPacket.payload, payloadOffset, value, valueOffset + bytesRead, bytesToCopy); bytesRead += bytesToCopy; @@ -6452,7 +6613,9 @@ final byte[] readWrappedBytes(int valueLength) throws SQLServerException { final Object readDecimal(int valueLength, TypeInfo typeInfo, JDBCType jdbcType, StreamType streamType) throws SQLServerException { if (valueLength > valueBytes.length) { - logger.warning(toString() + " Invalid value length:" + valueLength); + if (logger.isLoggable(Level.WARNING)) { + logger.warning(toString() + " Invalid value length:" + valueLength); + } throwInvalidTDS(); } @@ -7014,8 +7177,9 @@ boolean execute(TDSWriter tdsWriter, TDSReader tdsReader) throws SQLServerExcept close(); } } catch (SQLServerException interruptException) { - logger.fine( - this.toString() + ": Ignoring error in sending attention: " + interruptException.getMessage()); + if (logger.isLoggable(Level.FINE)) + logger.fine(this.toString() + ": Ignoring error in sending attention: " + + interruptException.getMessage()); } // throw the original exception even if trying to interrupt fails even in the case // of trying to send a cancel to the server. @@ -7029,14 +7193,16 @@ boolean execute(TDSWriter tdsWriter, TDSReader tdsReader) throws SQLServerExcept * This default implementation just consumes everything in the response message. */ void processResponse(TDSReader tdsReader) throws SQLServerException { - logger.finest(this.toString() + ": Processing response"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this.toString() + ": Processing response"); try { TDSParser.parse(tdsReader, getLogContext()); } catch (SQLServerException e) { if (SQLServerException.DRIVER_ERROR_FROM_DATABASE != e.getDriverErrorCode()) throw e; - logger.finest(this.toString() + ": Ignoring error from database: " + e.getMessage()); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this.toString() + ": Ignoring error from database: " + e.getMessage()); } } @@ -7047,7 +7213,8 @@ void processResponse(TDSReader tdsReader) throws SQLServerException { * present. */ final void detach() throws SQLServerException { - logger.finest(this + ": detaching..."); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this + ": detaching..."); // Read any remaining response packets from the server. // This operation may be timed out or cancelled from another thread. @@ -7058,15 +7225,18 @@ final void detach() throws SQLServerException { } final void close() { - logger.finest(this + ": closing..."); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this + ": closing..."); - logger.finest(this + ": processing response..."); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this + ": processing response..."); while (!processedResponse) { try { processResponse(tdsReader); } catch (SQLServerException e) { - logger.finest(this + ": close ignoring error processing response: " + e.getMessage()); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this + ": close ignoring error processing response: " + e.getMessage()); if (tdsReader.getConnection().isSessionUnAvailable()) { processedResponse = true; @@ -7076,16 +7246,19 @@ final void close() { } if (attentionPending) { - logger.finest(this + ": processing attention ack..."); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this + ": processing attention ack..."); try { TDSParser.parse(tdsReader, "attention ack"); } catch (SQLServerException e) { if (tdsReader.getConnection().isSessionUnAvailable()) { - logger.finest(this + ": giving up on attention ack after connection closed by exception: " + e); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this + ": giving up on attention ack after connection closed by exception: " + e); attentionPending = false; } else { - logger.finest(this + ": ignored exception: " + e); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this + ": ignored exception: " + e); } } @@ -7093,13 +7266,16 @@ final void close() { // then assume that no attention ack is forthcoming from the server and // terminate the connection to prevent any other command from executing. if (attentionPending) { - logger.severe( - this.toString() + ": expected attn ack missing or not processed; terminating connection..."); + if (logger.isLoggable(Level.SEVERE)) { + logger.severe(this.toString() + + ": expected attn ack missing or not processed; terminating connection..."); + } try { tdsReader.throwInvalidTDS(); } catch (SQLServerException e) { - logger.finest(this + ": ignored expected invalid TDS exception: " + e); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this + ": ignored expected invalid TDS exception: " + e); assert tdsReader.getConnection().isSessionUnAvailable(); attentionPending = false; @@ -7133,7 +7309,8 @@ void interrupt(String reason) throws SQLServerException { // Only the first one should be recognized and acted upon. synchronized (interruptLock) { if (interruptsEnabled && !wasInterrupted()) { - logger.finest(this + ": Raising interrupt for reason:" + reason); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this + ": Raising interrupt for reason:" + reason); wasInterrupted = true; interruptReason = reason; @@ -7171,7 +7348,8 @@ final void checkForInterrupt() throws SQLServerException { if (wasInterrupted() && !interruptChecked) { interruptChecked = true; - logger.finest(this + ": throwing interrupt exception, reason: " + interruptReason); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this + ": throwing interrupt exception, reason: " + interruptReason); throw new SQLServerException(interruptReason, SQLState.STATEMENT_CANCELED, DriverError.NOT_SET, null); } @@ -7190,7 +7368,8 @@ final void onRequestComplete() throws SQLServerException { synchronized (interruptLock) { assert !requestComplete; - logger.finest(this + ": request complete"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this + ": request complete"); requestComplete = true; @@ -7241,7 +7420,8 @@ final void onResponseEOM() throws SQLServerException { // an attention ack to be read. synchronized (interruptLock) { if (interruptsEnabled) { - logger.finest(this + ": disabling interrupts"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this + ": disabling interrupts"); // Determine whether we still need to read the attention ack packet. // @@ -7296,13 +7476,15 @@ final void onAttentionAck() { * on any error, including acknowledgement of an interrupt. */ final TDSWriter startRequest(byte tdsMessageType) throws SQLServerException { - logger.finest(this + ": starting request..."); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this + ": starting request..."); // Start this command's request message try { tdsWriter.startMessage(this, tdsMessageType); } catch (SQLServerException e) { - logger.finest(this + ": starting request: exception: " + e.getMessage()); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this + ": starting request: exception: " + e.getMessage()); throw e; } @@ -7339,12 +7521,14 @@ final TDSReader startResponse(boolean isAdaptive) throws SQLServerException { // at any point before endMessage() returns, then endMessage() throws an // exception with the reason for the interrupt. Request interrupts // are disabled by the time endMessage() returns. - logger.finest(this + ": finishing request"); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this + ": finishing request"); try { tdsWriter.endMessage(); } catch (SQLServerException e) { - logger.finest(this + ": finishing request: endMessage threw exception: " + e.getMessage()); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this + ": finishing request: endMessage threw exception: " + e.getMessage()); throw e; } @@ -7356,7 +7540,8 @@ final TDSReader startResponse(boolean isAdaptive) throws SQLServerException { TimeoutPoller.getTimeoutPoller().addTimeoutCommand(this.timeoutCommand); } - logger.finest(this.toString() + ": Reading response..."); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this.toString() + ": Reading response..."); try { // Wait for the server to execute the request and read the first packet @@ -7368,7 +7553,8 @@ final TDSReader startResponse(boolean isAdaptive) throws SQLServerException { while (tdsReader.readPacket()); } } catch (SQLServerException e) { - logger.finest(this.toString() + ": Exception reading response: " + e.getMessage()); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this.toString() + ": Exception reading response: " + e.getMessage()); throw e; } finally { @@ -7399,6 +7585,8 @@ abstract class UninterruptableTDSCommand extends TDSCommand { final void interrupt(String reason) throws SQLServerException { // Interrupting an uninterruptable command is a no-op. That is, // it can happen, but it should have no effect. - logger.finest(toString() + " Ignoring interrupt of uninterruptable TDS command; Reason:" + reason); + if (logger.isLoggable(Level.FINEST)) { + logger.finest(toString() + " Ignoring interrupt of uninterruptable TDS command; Reason:" + reason); + } } } diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/KerbAuthentication.java b/src/main/java/com/microsoft/sqlserver/jdbc/KerbAuthentication.java index cfd4c69a58..d0a99ba1c6 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/KerbAuthentication.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/KerbAuthentication.java @@ -5,6 +5,7 @@ package com.microsoft.sqlserver.jdbc; +import java.lang.reflect.Method; import java.net.IDN; import java.net.InetAddress; import java.net.UnknownHostException; @@ -14,6 +15,7 @@ import java.security.PrivilegedExceptionAction; import java.text.MessageFormat; import java.util.Locale; +import java.util.logging.Level; import java.util.regex.Matcher; import java.util.regex.Pattern; @@ -87,8 +89,10 @@ private void intAuthInit() throws SQLServerException { currentSubject = lc.getSubject(); } } catch (LoginException le) { - authLogger.fine(toString() + "Failed to login using Kerberos due to " + le.getClass().getName() - + ":" + le.getMessage()); + if (authLogger.isLoggable(Level.FINE)) { + authLogger.fine(toString() + "Failed to login using Kerberos due to " + le.getClass().getName() + + ":" + le.getMessage()); + } try { // Not very clean since it raises an Exception, but we are sure we are cleaning well everything con.terminate(SQLServerException.DRIVER_ERROR_NONE, @@ -109,10 +113,13 @@ private void intAuthInit() throws SQLServerException { return; } - authLogger.finer(toString() + " Getting client credentials"); - + if (authLogger.isLoggable(Level.FINER)) { + authLogger.finer(toString() + " Getting client credentials"); + } peerCredentials = getClientCredential(currentSubject, manager, kerberos); - authLogger.finer(toString() + " creating security context"); + if (authLogger.isLoggable(Level.FINER)) { + authLogger.finer(toString() + " creating security context"); + } peerContext = manager.createContext(remotePeerName, kerberos, peerCredentials, GSSContext.DEFAULT_LIFETIME); @@ -153,16 +160,20 @@ public GSSCredential run() throws GSSException { private byte[] intAuthHandShake(byte[] pin, boolean[] done) throws SQLServerException { try { - authLogger.finer(toString() + " Sending token to server over secure context"); - + if (authLogger.isLoggable(Level.FINER)) { + authLogger.finer(toString() + " Sending token to server over secure context"); + } byte[] byteToken = peerContext.initSecContext(pin, 0, pin.length); if (peerContext.isEstablished()) { done[0] = true; - authLogger.finer(toString() + "Authentication done."); + if (authLogger.isLoggable(Level.FINER)) + authLogger.finer(toString() + "Authentication done."); } else if (null == byteToken) { // The documentation is not clear on when this can happen but it does say this could happen - authLogger.info(toString() + "byteToken is null in initSecContext."); + if (authLogger.isLoggable(Level.INFO)) { + authLogger.info(toString() + "byteToken is null in initSecContext."); + } con.terminate(SQLServerException.DRIVER_ERROR_NONE, SQLServerException.getErrString("R_integratedAuthenticationFailed")); } @@ -177,8 +188,9 @@ private byte[] intAuthHandShake(byte[] pin, boolean[] done) throws SQLServerExce } private String makeSpn(String server, int port) throws SQLServerException { - authLogger.finer(toString() + " Server: " + server + " port: " + port); - + if (authLogger.isLoggable(Level.FINER)) { + authLogger.finer(toString() + " Server: " + server + " port: " + port); + } StringBuilder spn = new StringBuilder("MSSQLSvc/"); // Format is MSSQLSvc/myhost.domain.company.com:1433 // FQDN must be provided @@ -190,8 +202,9 @@ private String makeSpn(String server, int port) throws SQLServerException { spn.append(":"); spn.append(port); String strSPN = spn.toString(); - authLogger.finer(toString() + " SPN: " + strSPN); - + if (authLogger.isLoggable(Level.FINER)) { + authLogger.finer(toString() + " SPN: " + strSPN); + } return strSPN; } @@ -216,7 +229,7 @@ private String makeSpn(String server, int port) throws SQLServerException { spn = makeSpn(address, port); } this.spn = enrichSpnWithRealm(spn, null == userSuppliedServerSpn); - if (!this.spn.equals(spn)) { + if (!this.spn.equals(spn) && authLogger.isLoggable(Level.FINER)) { authLogger.finer(toString() + "SPN enriched: " + spn + " := " + this.spn); } } @@ -302,7 +315,9 @@ private String findRealmFromHostname(RealmValidator realmValidator, String hostn int index = 0; while (index != -1 && index < hostname.length() - 2) { String realm = hostname.substring(index); - authLogger.finest(toString() + " looking up REALM candidate " + realm); + if (authLogger.isLoggable(Level.FINEST)) { + authLogger.finest(toString() + " looking up REALM candidate " + realm); + } if (realmValidator.isRealmValid(realm)) { return realm.toUpperCase(); } diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerADAL4JUtils.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerADAL4JUtils.java index f9075d3798..f0418a60c9 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerADAL4JUtils.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerADAL4JUtils.java @@ -12,6 +12,7 @@ import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; +import java.util.logging.Level; import javax.security.auth.kerberos.KerberosPrincipal; @@ -73,7 +74,9 @@ static SqlFedAuthToken getSqlFedAuthTokenIntegrated(SqlFedAuthInfo fedAuthInfo, KerberosPrincipal kerberosPrincipal = new KerberosPrincipal("username"); String username = kerberosPrincipal.getName(); - adal4jLogger.fine(adal4jLogger.toString() + " realm name is:" + kerberosPrincipal.getRealm()); + if (adal4jLogger.isLoggable(Level.FINE)) { + adal4jLogger.fine(adal4jLogger.toString() + " realm name is:" + kerberosPrincipal.getRealm()); + } AuthenticationContext context = new AuthenticationContext(fedAuthInfo.stsurl, false, executorService); Future future = context.acquireToken(fedAuthInfo.spn, diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerBlob.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerBlob.java index 2453d827b1..b1e7858172 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerBlob.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerBlob.java @@ -13,6 +13,7 @@ import java.text.MessageFormat; import java.util.ArrayList; import java.util.concurrent.atomic.AtomicInteger; +import java.util.logging.Level; import java.util.logging.Logger; @@ -79,21 +80,25 @@ public SQLServerBlob(SQLServerConnection connection, byte data[]) { value = data; - logger.fine(toString() + " created by (" + ((null != connection) ? connection.toString() : "null connection") - + ")"); + if (logger.isLoggable(Level.FINE)) { + String loggingInfo = (null != connection) ? connection.toString() : "null connection"; + logger.fine(toString() + " created by (" + loggingInfo + ")"); + } } SQLServerBlob(SQLServerConnection connection) { traceID = " SQLServerBlob:" + nextInstanceID(); con = connection; value = new byte[0]; - logger.fine(toString() + " created by (" + connection.toString() + ")"); + if (logger.isLoggable(Level.FINE)) + logger.fine(toString() + " created by (" + connection.toString() + ")"); } SQLServerBlob(BaseInputStream stream) throws SQLServerException { traceID = " SQLServerBlob:" + nextInstanceID(); activeStreams.add(stream); - logger.fine(toString() + " created by (null connection)"); + if (logger.isLoggable(Level.FINE)) + logger.fine(toString() + " created by (null connection)"); } @Override diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerBulkCopy.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerBulkCopy.java index aa91e609b6..2df1e090a5 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerBulkCopy.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerBulkCopy.java @@ -652,7 +652,8 @@ final class InsertBulk extends TDSCommand { final boolean doExecute() throws SQLServerException { if (null != timeoutCommand) { - logger.finest(this.toString() + ": Starting bulk timer..."); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this.toString() + ": Starting bulk timer..."); TimeoutPoller.getTimeoutPoller().addTimeoutCommand(timeoutCommand); } @@ -679,7 +680,9 @@ final boolean doExecute() throws SQLServerException { } if (null != timeoutCommand) { - logger.finest(this.toString() + ": Stopping bulk timer..."); + if (logger.isLoggable(Level.FINEST)) + logger.finest(this.toString() + ": Stopping bulk timer..."); + TimeoutPoller.getTimeoutPoller().remove(timeoutCommand); } @@ -1472,7 +1475,8 @@ private String createInsertBulkCommand(TDSWriter tdsWriter) throws SQLServerExce bulkCmd.append(")"); } - loggerExternal.finer(this.toString() + " TDSCommand: " + bulkCmd); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.finer(this.toString() + " TDSCommand: " + bulkCmd); return bulkCmd.toString(); } @@ -1597,7 +1601,8 @@ private void writeToServer() throws SQLServerException { } long start = System.currentTimeMillis(); - loggerExternal.finer(this.toString() + " Start writeToServer: " + start); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.finer(this.toString() + " Start writeToServer: " + start); getDestinationMetadata(); @@ -1610,9 +1615,11 @@ private void writeToServer() throws SQLServerException { sendBulkLoadBCP(); long end = System.currentTimeMillis(); - loggerExternal.finer(this.toString() + " End writeToServer: " + end); - int seconds = (int) ((end - start) / 1000L); - loggerExternal.finer(this.toString() + "Time elapsed: " + seconds + " seconds"); + if (loggerExternal.isLoggable(Level.FINER)) { + loggerExternal.finer(this.toString() + " End writeToServer: " + end); + int seconds = (int) ((end - start) / 1000L); + loggerExternal.finer(this.toString() + "Time elapsed: " + seconds + " seconds"); + } } private void validateStringBinaryLengths(Object colValue, int srcCol, int destCol) throws SQLServerException { @@ -1669,8 +1676,8 @@ private void getDestinationMetadata() throws SQLServerException { ResultSet.CONCUR_READ_ONLY, connection.getHoldability(), stmtColumnEncriptionSetting); // Get destination metadata - rs = stmt.executeQueryInternal( - "sp_executesql N'SET FMTONLY ON SELECT * FROM " + escapedDestinationTableName + " '"); + rs = stmt.executeQueryInternal("sp_executesql N'SET FMTONLY ON SELECT * FROM " + + escapedDestinationTableName + " '"); } destColumnCount = rs.getMetaData().getColumnCount(); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java index a25f7506db..6331df080a 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerCallableStatement.java @@ -84,7 +84,8 @@ String getClassNameInternal() { @Override public void registerOutParameter(int index, int sqlType) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {index, sqlType}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {index, sqlType}); checkClosed(); if (index < 1 || index > inOutParam.length) { MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_indexOutOfRange")); @@ -339,7 +340,9 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException { @Override public void registerOutParameter(int index, int sqlType, String typeName) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {index, sqlType, typeName}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "registerOutParameter", + new Object[] {index, sqlType, typeName}); checkClosed(); @@ -350,7 +353,9 @@ public void registerOutParameter(int index, int sqlType, String typeName) throws @Override public void registerOutParameter(int index, int sqlType, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {index, sqlType, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "registerOutParameter", + new Object[] {index, sqlType, scale}); checkClosed(); @@ -362,8 +367,9 @@ public void registerOutParameter(int index, int sqlType, int scale) throws SQLSe @Override public void registerOutParameter(int index, int sqlType, int precision, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "registerOutParameter", - new Object[] {index, sqlType, scale, precision}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "registerOutParameter", + new Object[] {index, sqlType, scale, precision}); checkClosed(); @@ -402,7 +408,8 @@ private Parameter getterGetParam(int index) throws SQLServerException { resultsReader().getCommand().checkForInterrupt(); closeActiveStream(); - getStatementLogger().finer(toString() + " Getting Param:" + index); + if (getStatementLogger().isLoggable(java.util.logging.Level.FINER)) + getStatementLogger().finer(toString() + " Getting Param:" + index); // Dynamically load OUT params from TDS response buffer lastParamAccessed = getOutParameter(index); @@ -505,7 +512,8 @@ public final String getNString(String parameterName) throws SQLException { @Deprecated @Override public BigDecimal getBigDecimal(int parameterIndex, int scale) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "getBigDecimal", new Object[] {parameterIndex, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getBigDecimal", new Object[] {parameterIndex, scale}); checkClosed(); BigDecimal value = (BigDecimal) getValue(parameterIndex, JDBCType.DECIMAL); if (null != value) @@ -517,7 +525,8 @@ public BigDecimal getBigDecimal(int parameterIndex, int scale) throws SQLExcepti @Deprecated @Override public BigDecimal getBigDecimal(String parameterName, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getBigDecimal", new Object[] {parameterName, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getBigDecimal", new Object[] {parameterName, scale}); checkClosed(); BigDecimal value = (BigDecimal) getValue(findColumn(parameterName), JDBCType.DECIMAL); if (null != value) @@ -602,7 +611,8 @@ public Date getDate(String parameterName) throws SQLServerException { @Override public Date getDate(int index, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getDate", new Object[] {index, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getDate", new Object[] {index, cal}); checkClosed(); java.sql.Date value = (java.sql.Date) getValue(index, JDBCType.DATE, cal); loggerExternal.exiting(getClassNameLogging(), "getDate", value); @@ -611,7 +621,8 @@ public Date getDate(int index, Calendar cal) throws SQLServerException { @Override public Date getDate(String parameterName, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getDate", new Object[] {parameterName, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getDate", new Object[] {parameterName, cal}); checkClosed(); java.sql.Date value = (java.sql.Date) getValue(findColumn(parameterName), JDBCType.DATE, cal); loggerExternal.exiting(getClassNameLogging(), "getDate", value); @@ -812,7 +823,8 @@ public Time getTime(String parameterName) throws SQLServerException { @Override public Time getTime(int index, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getTime", new Object[] {index, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getTime", new Object[] {index, cal}); checkClosed(); java.sql.Time value = (java.sql.Time) getValue(index, JDBCType.TIME, cal); loggerExternal.exiting(getClassNameLogging(), "getTime", value); @@ -821,7 +833,8 @@ public Time getTime(int index, Calendar cal) throws SQLServerException { @Override public Time getTime(String parameterName, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getTime", new Object[] {parameterName, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getTime", new Object[] {parameterName, cal}); checkClosed(); java.sql.Time value = (java.sql.Time) getValue(findColumn(parameterName), JDBCType.TIME, cal); loggerExternal.exiting(getClassNameLogging(), "getTime", value); @@ -830,7 +843,8 @@ public Time getTime(String parameterName, Calendar cal) throws SQLServerExceptio @Override public Timestamp getTimestamp(int index) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getTimestamp", index); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getTimestamp", index); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue(index, JDBCType.TIMESTAMP); loggerExternal.exiting(getClassNameLogging(), "getTimestamp", value); @@ -848,7 +862,8 @@ public Timestamp getTimestamp(String parameterName) throws SQLServerException { @Override public Timestamp getTimestamp(int index, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getTimestamp", new Object[] {index, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getTimestamp", new Object[] {index, cal}); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue(index, JDBCType.TIMESTAMP, cal); loggerExternal.exiting(getClassNameLogging(), "getTimestamp", value); @@ -857,7 +872,8 @@ public Timestamp getTimestamp(int index, Calendar cal) throws SQLServerException @Override public Timestamp getTimestamp(String name, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getTimestamp", new Object[] {name, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getTimestamp", new Object[] {name, cal}); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(name), JDBCType.TIMESTAMP, cal); loggerExternal.exiting(getClassNameLogging(), "getTimestamp", value); @@ -866,7 +882,8 @@ public Timestamp getTimestamp(String name, Calendar cal) throws SQLServerExcepti @Override public Timestamp getDateTime(int index) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getDateTime", index); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getDateTime", index); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue(index, JDBCType.DATETIME); loggerExternal.exiting(getClassNameLogging(), "getDateTime", value); @@ -884,7 +901,8 @@ public Timestamp getDateTime(String parameterName) throws SQLServerException { @Override public Timestamp getDateTime(int index, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getDateTime", new Object[] {index, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getDateTime", new Object[] {index, cal}); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue(index, JDBCType.DATETIME, cal); loggerExternal.exiting(getClassNameLogging(), "getDateTime", value); @@ -893,7 +911,8 @@ public Timestamp getDateTime(int index, Calendar cal) throws SQLServerException @Override public Timestamp getDateTime(String name, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getDateTime", new Object[] {name, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getDateTime", new Object[] {name, cal}); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(name), JDBCType.DATETIME, cal); loggerExternal.exiting(getClassNameLogging(), "getDateTime", value); @@ -902,7 +921,8 @@ public Timestamp getDateTime(String name, Calendar cal) throws SQLServerExceptio @Override public Timestamp getSmallDateTime(int index) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getSmallDateTime", index); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getSmallDateTime", index); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue(index, JDBCType.SMALLDATETIME); loggerExternal.exiting(getClassNameLogging(), "getSmallDateTime", value); @@ -920,7 +940,8 @@ public Timestamp getSmallDateTime(String parameterName) throws SQLServerExceptio @Override public Timestamp getSmallDateTime(int index, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getSmallDateTime", new Object[] {index, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getSmallDateTime", new Object[] {index, cal}); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue(index, JDBCType.SMALLDATETIME, cal); loggerExternal.exiting(getClassNameLogging(), "getSmallDateTime", value); @@ -929,7 +950,8 @@ public Timestamp getSmallDateTime(int index, Calendar cal) throws SQLServerExcep @Override public Timestamp getSmallDateTime(String name, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getSmallDateTime", new Object[] {name, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getSmallDateTime", new Object[] {name, cal}); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(name), JDBCType.SMALLDATETIME, cal); loggerExternal.exiting(getClassNameLogging(), "getSmallDateTime", value); @@ -938,7 +960,8 @@ public Timestamp getSmallDateTime(String name, Calendar cal) throws SQLServerExc @Override public microsoft.sql.DateTimeOffset getDateTimeOffset(int index) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getDateTimeOffset", index); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getDateTimeOffset", index); checkClosed(); // DateTimeOffset is not supported with SQL Server versions earlier than Katmai @@ -1331,7 +1354,9 @@ private int findColumn(String columnName) throws SQLServerException { @Override public void setTimestamp(String parameterName, java.sql.Timestamp value, Calendar calendar) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTimeStamp", new Object[] {parameterName, value, calendar}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTimeStamp", + new Object[] {parameterName, value, calendar}); checkClosed(); setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, calendar, false); loggerExternal.exiting(getClassNameLogging(), "setTimeStamp"); @@ -1340,8 +1365,9 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, @Override public void setTimestamp(String parameterName, java.sql.Timestamp value, Calendar calendar, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTimeStamp", - new Object[] {parameterName, value, calendar, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTimeStamp", + new Object[] {parameterName, value, calendar, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, calendar, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTimeStamp"); @@ -1349,7 +1375,8 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, Calenda @Override public void setTime(String parameterName, java.sql.Time value, Calendar calendar) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value, calendar}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value, calendar}); checkClosed(); setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, calendar, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); @@ -1358,8 +1385,9 @@ public void setTime(String parameterName, java.sql.Time value, Calendar calendar @Override public void setTime(String parameterName, java.sql.Time value, Calendar calendar, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTime", - new Object[] {parameterName, value, calendar, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTime", + new Object[] {parameterName, value, calendar, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, calendar, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTime"); @@ -1367,7 +1395,8 @@ public void setTime(String parameterName, java.sql.Time value, Calendar calendar @Override public void setDate(String parameterName, java.sql.Date value, Calendar calendar) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {parameterName, value, calendar}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {parameterName, value, calendar}); checkClosed(); setValue(findColumn(parameterName), JDBCType.DATE, value, JavaType.DATE, calendar, false); loggerExternal.exiting(getClassNameLogging(), "setDate"); @@ -1376,8 +1405,9 @@ public void setDate(String parameterName, java.sql.Date value, Calendar calendar @Override public void setDate(String parameterName, java.sql.Date value, Calendar calendar, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDate", - new Object[] {parameterName, value, calendar, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDate", + new Object[] {parameterName, value, calendar, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.DATE, value, JavaType.DATE, calendar, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDate"); @@ -1385,7 +1415,8 @@ public void setDate(String parameterName, java.sql.Date value, Calendar calendar @Override public final void setCharacterStream(String parameterName, Reader reader) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {parameterName, reader}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {parameterName, reader}); checkClosed(); setStream(findColumn(parameterName), StreamType.CHARACTER, reader, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); @@ -1394,8 +1425,9 @@ public final void setCharacterStream(String parameterName, Reader reader) throws @Override public final void setCharacterStream(String parameterName, Reader value, int length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setCharacterStream", - new Object[] {parameterName, value, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setCharacterStream", + new Object[] {parameterName, value, length}); checkClosed(); setStream(findColumn(parameterName), StreamType.CHARACTER, value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setCharacterStream"); @@ -1404,8 +1436,9 @@ public final void setCharacterStream(String parameterName, Reader value, int len @Override public final void setCharacterStream(String parameterName, Reader reader, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setCharacterStream", - new Object[] {parameterName, reader, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setCharacterStream", + new Object[] {parameterName, reader, length}); checkClosed(); setStream(findColumn(parameterName), StreamType.CHARACTER, reader, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setCharacterStream"); @@ -1413,7 +1446,8 @@ public final void setCharacterStream(String parameterName, Reader reader, long l @Override public final void setNCharacterStream(String parameterName, Reader value) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setNCharacterStream", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setNCharacterStream", new Object[] {parameterName, value}); checkClosed(); setStream(findColumn(parameterName), StreamType.NCHARACTER, value, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); @@ -1422,8 +1456,9 @@ public final void setNCharacterStream(String parameterName, Reader value) throws @Override public final void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setNCharacterStream", - new Object[] {parameterName, value, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setNCharacterStream", + new Object[] {parameterName, value, length}); checkClosed(); setStream(findColumn(parameterName), StreamType.NCHARACTER, value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setNCharacterStream"); @@ -1431,7 +1466,8 @@ public final void setNCharacterStream(String parameterName, Reader value, long l @Override public final void setClob(String parameterName, Clob value) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.CLOB, value, JavaType.CLOB, false); loggerExternal.exiting(getClassNameLogging(), "setClob"); @@ -1439,7 +1475,8 @@ public final void setClob(String parameterName, Clob value) throws SQLException @Override public final void setClob(String parameterName, Reader reader) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterName, reader}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterName, reader}); checkClosed(); setStream(findColumn(parameterName), StreamType.CHARACTER, reader, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); @@ -1448,7 +1485,8 @@ public final void setClob(String parameterName, Reader reader) throws SQLExcepti @Override public final void setClob(String parameterName, Reader value, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterName, value, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterName, value, length}); checkClosed(); setStream(findColumn(parameterName), StreamType.CHARACTER, value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setClob"); @@ -1456,7 +1494,8 @@ public final void setClob(String parameterName, Reader value, long length) throw @Override public final void setNClob(String parameterName, NClob value) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.NCLOB, value, JavaType.NCLOB, false); loggerExternal.exiting(getClassNameLogging(), "setNClob"); @@ -1464,7 +1503,8 @@ public final void setNClob(String parameterName, NClob value) throws SQLExceptio @Override public final void setNClob(String parameterName, Reader reader) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, reader}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, reader}); checkClosed(); setStream(findColumn(parameterName), StreamType.NCHARACTER, reader, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); @@ -1473,7 +1513,8 @@ public final void setNClob(String parameterName, Reader reader) throws SQLExcept @Override public final void setNClob(String parameterName, Reader reader, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, reader, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterName, reader, length}); checkClosed(); setStream(findColumn(parameterName), StreamType.NCHARACTER, reader, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setNClob"); @@ -1481,7 +1522,8 @@ public final void setNClob(String parameterName, Reader reader, long length) thr @Override public final void setNString(String parameterName, String value) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setNString", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setNString", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.NVARCHAR, value, JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setNString"); @@ -1489,7 +1531,9 @@ public final void setNString(String parameterName, String value) throws SQLExcep @Override public final void setNString(String parameterName, String value, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setNString", new Object[] {parameterName, value, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setNString", + new Object[] {parameterName, value, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.NVARCHAR, value, JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setNString"); @@ -1497,7 +1541,8 @@ public final void setNString(String parameterName, String value, boolean forceEn @Override public void setObject(String parameterName, Object value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterName, value}); checkClosed(); setObjectNoType(findColumn(parameterName), value, false); loggerExternal.exiting(getClassNameLogging(), "setObject"); @@ -1506,7 +1551,8 @@ public void setObject(String parameterName, Object value) throws SQLServerExcept @Override public void setObject(String parameterName, Object value, int sqlType) throws SQLServerException { String tvpName = null; - loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterName, value, sqlType}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterName, value, sqlType}); checkClosed(); if (microsoft.sql.Types.STRUCTURED == sqlType) { tvpName = getTVPNameIfNull(findColumn(parameterName), null); @@ -1520,8 +1566,9 @@ public void setObject(String parameterName, Object value, int sqlType) throws SQ @Override public void setObject(String parameterName, Object value, int sqlType, int decimals) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setObject", - new Object[] {parameterName, value, sqlType, decimals}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setObject", + new Object[] {parameterName, value, sqlType, decimals}); checkClosed(); setObject(setterGetParam(findColumn(parameterName)), value, JavaType.of(value), JDBCType.of(sqlType), decimals, null, false, findColumn(parameterName), null); @@ -1531,8 +1578,9 @@ public void setObject(String parameterName, Object value, int sqlType, int decim @Override public void setObject(String parameterName, Object value, int sqlType, int decimals, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setObject", - new Object[] {parameterName, value, sqlType, decimals, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setObject", + new Object[] {parameterName, value, sqlType, decimals, forceEncrypt}); checkClosed(); // scale - for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types, @@ -1549,8 +1597,9 @@ public void setObject(String parameterName, Object value, int sqlType, int decim @Override public final void setObject(String parameterName, Object value, int targetSqlType, Integer precision, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setObject", - new Object[] {parameterName, value, targetSqlType, precision, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setObject", + new Object[] {parameterName, value, targetSqlType, precision, scale}); checkClosed(); // scale - for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types, @@ -1568,7 +1617,8 @@ public final void setObject(String parameterName, Object value, int targetSqlTyp @Override public final void setAsciiStream(String parameterName, InputStream value) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterName, value}); checkClosed(); setStream(findColumn(parameterName), StreamType.ASCII, value, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); @@ -1577,7 +1627,9 @@ public final void setAsciiStream(String parameterName, InputStream value) throws @Override public final void setAsciiStream(String parameterName, InputStream value, int length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterName, value, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setAsciiStream", + new Object[] {parameterName, value, length}); checkClosed(); setStream(findColumn(parameterName), StreamType.ASCII, value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); @@ -1585,7 +1637,9 @@ public final void setAsciiStream(String parameterName, InputStream value, int le @Override public final void setAsciiStream(String parameterName, InputStream value, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterName, value, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setAsciiStream", + new Object[] {parameterName, value, length}); checkClosed(); setStream(findColumn(parameterName), StreamType.ASCII, value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); @@ -1594,7 +1648,8 @@ public final void setAsciiStream(String parameterName, InputStream value, long l @Override public final void setBinaryStream(String parameterName, InputStream value) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterName, value}); checkClosed(); setStream(findColumn(parameterName), StreamType.BINARY, value, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); @@ -1603,7 +1658,9 @@ public final void setBinaryStream(String parameterName, InputStream value) throw @Override public final void setBinaryStream(String parameterName, InputStream value, int length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterName, value, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBinaryStream", + new Object[] {parameterName, value, length}); checkClosed(); setStream(findColumn(parameterName), StreamType.BINARY, value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); @@ -1611,7 +1668,9 @@ public final void setBinaryStream(String parameterName, InputStream value, int l @Override public final void setBinaryStream(String parameterName, InputStream value, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterName, value, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBinaryStream", + new Object[] {parameterName, value, length}); checkClosed(); setStream(findColumn(parameterName), StreamType.BINARY, value, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); @@ -1619,7 +1678,8 @@ public final void setBinaryStream(String parameterName, InputStream value, long @Override public final void setBlob(String parameterName, Blob inputStream) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, inputStream}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, inputStream}); checkClosed(); setValue(findColumn(parameterName), JDBCType.BLOB, inputStream, JavaType.BLOB, false); loggerExternal.exiting(getClassNameLogging(), "setBlob"); @@ -1627,7 +1687,8 @@ public final void setBlob(String parameterName, Blob inputStream) throws SQLExce @Override public final void setBlob(String parameterName, InputStream value) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, value}); checkClosed(); setStream(findColumn(parameterName), StreamType.BINARY, value, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); @@ -1636,7 +1697,9 @@ public final void setBlob(String parameterName, InputStream value) throws SQLExc @Override public final void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterName, inputStream, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBlob", + new Object[] {parameterName, inputStream, length}); checkClosed(); setStream(findColumn(parameterName), StreamType.BINARY, inputStream, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBlob"); @@ -1644,7 +1707,8 @@ public final void setBlob(String parameterName, InputStream inputStream, long le @Override public void setTimestamp(String parameterName, java.sql.Timestamp value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); @@ -1652,7 +1716,8 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value) throws @Override public void setTimestamp(String parameterName, java.sql.Timestamp value, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, null, scale, false); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); @@ -1661,8 +1726,9 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, int sca @Override public void setTimestamp(String parameterName, java.sql.Timestamp value, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTimestamp", - new Object[] {parameterName, value, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTimestamp", + new Object[] {parameterName, value, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.TIMESTAMP, value, JavaType.TIMESTAMP, null, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); @@ -1670,7 +1736,8 @@ public void setTimestamp(String parameterName, java.sql.Timestamp value, int sca @Override public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, false); loggerExternal.exiting(getClassNameLogging(), "setDateTimeOffset"); @@ -1679,7 +1746,8 @@ public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset @Override public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset value, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, null, scale, false); @@ -1689,8 +1757,9 @@ public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset @Override public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset value, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", - new Object[] {parameterName, value, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", + new Object[] {parameterName, value, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.DATETIMEOFFSET, value, JavaType.DATETIMEOFFSET, null, scale, forceEncrypt); @@ -1699,7 +1768,8 @@ public void setDateTimeOffset(String parameterName, microsoft.sql.DateTimeOffset @Override public void setDate(String parameterName, java.sql.Date value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.DATE, value, JavaType.DATE, false); loggerExternal.exiting(getClassNameLogging(), "setDate"); @@ -1707,7 +1777,8 @@ public void setDate(String parameterName, java.sql.Date value) throws SQLServerE @Override public void setTime(String parameterName, java.sql.Time value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); @@ -1715,7 +1786,8 @@ public void setTime(String parameterName, java.sql.Time value) throws SQLServerE @Override public void setTime(String parameterName, java.sql.Time value, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, null, scale, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); @@ -1724,7 +1796,9 @@ public void setTime(String parameterName, java.sql.Time value, int scale) throws @Override public void setTime(String parameterName, java.sql.Time value, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {parameterName, value, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTime", + new Object[] {parameterName, value, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.TIME, value, JavaType.TIME, null, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTime"); @@ -1732,7 +1806,8 @@ public void setTime(String parameterName, java.sql.Time value, int scale, @Override public void setDateTime(String parameterName, java.sql.Timestamp value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDateTime", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDateTime", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.DATETIME, value, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setDateTime"); @@ -1741,8 +1816,9 @@ public void setDateTime(String parameterName, java.sql.Timestamp value) throws S @Override public void setDateTime(String parameterName, java.sql.Timestamp value, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDateTime", - new Object[] {parameterName, value, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDateTime", + new Object[] {parameterName, value, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.DATETIME, value, JavaType.TIMESTAMP, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDateTime"); @@ -1750,7 +1826,8 @@ public void setDateTime(String parameterName, java.sql.Timestamp value, @Override public void setSmallDateTime(String parameterName, java.sql.Timestamp value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.SMALLDATETIME, value, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setSmallDateTime"); @@ -1759,8 +1836,9 @@ public void setSmallDateTime(String parameterName, java.sql.Timestamp value) thr @Override public void setSmallDateTime(String parameterName, java.sql.Timestamp value, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", - new Object[] {parameterName, value, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", + new Object[] {parameterName, value, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.SMALLDATETIME, value, JavaType.TIMESTAMP, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setSmallDateTime"); @@ -1768,7 +1846,8 @@ public void setSmallDateTime(String parameterName, java.sql.Timestamp value, @Override public void setUniqueIdentifier(String parameterName, String guid) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", new Object[] {parameterName, guid}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", new Object[] {parameterName, guid}); checkClosed(); setValue(findColumn(parameterName), JDBCType.GUID, guid, JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setUniqueIdentifier"); @@ -1776,8 +1855,9 @@ public void setUniqueIdentifier(String parameterName, String guid) throws SQLSer @Override public void setUniqueIdentifier(String parameterName, String guid, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", - new Object[] {parameterName, guid, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", + new Object[] {parameterName, guid, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.GUID, guid, JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setUniqueIdentifier"); @@ -1785,7 +1865,8 @@ public void setUniqueIdentifier(String parameterName, String guid, boolean force @Override public void setBytes(String parameterName, byte[] value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setBytes", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBytes", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.BINARY, value, JavaType.BYTEARRAY, false); loggerExternal.exiting(getClassNameLogging(), "setBytes"); @@ -1793,7 +1874,9 @@ public void setBytes(String parameterName, byte[] value) throws SQLServerExcepti @Override public void setBytes(String parameterName, byte[] value, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setBytes", new Object[] {parameterName, value, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBytes", + new Object[] {parameterName, value, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.BINARY, value, JavaType.BYTEARRAY, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBytes"); @@ -1801,7 +1884,8 @@ public void setBytes(String parameterName, byte[] value, boolean forceEncrypt) t @Override public void setByte(String parameterName, byte value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setByte", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setByte", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.TINYINT, value, JavaType.BYTE, false); loggerExternal.exiting(getClassNameLogging(), "setByte"); @@ -1809,7 +1893,9 @@ public void setByte(String parameterName, byte value) throws SQLServerException @Override public void setByte(String parameterName, byte value, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setByte", new Object[] {parameterName, value, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setByte", + new Object[] {parameterName, value, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.TINYINT, value, JavaType.BYTE, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setByte"); @@ -1817,7 +1903,8 @@ public void setByte(String parameterName, byte value, boolean forceEncrypt) thro @Override public void setString(String parameterName, String value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setString", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setString", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.VARCHAR, value, JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setString"); @@ -1825,7 +1912,9 @@ public void setString(String parameterName, String value) throws SQLServerExcept @Override public void setString(String parameterName, String value, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setString", new Object[] {parameterName, value, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setString", + new Object[] {parameterName, value, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.VARCHAR, value, JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setString"); @@ -1833,7 +1922,8 @@ public void setString(String parameterName, String value, boolean forceEncrypt) @Override public void setMoney(String parameterName, BigDecimal value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setMoney", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setMoney", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.MONEY, value, JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setMoney"); @@ -1841,7 +1931,9 @@ public void setMoney(String parameterName, BigDecimal value) throws SQLServerExc @Override public void setMoney(String parameterName, BigDecimal value, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setMoney", new Object[] {parameterName, value, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setMoney", + new Object[] {parameterName, value, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.MONEY, value, JavaType.BIGDECIMAL, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setMoney"); @@ -1849,7 +1941,8 @@ public void setMoney(String parameterName, BigDecimal value, boolean forceEncryp @Override public void setSmallMoney(String parameterName, BigDecimal value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setSmallMoney", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setSmallMoney", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.SMALLMONEY, value, JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setSmallMoney"); @@ -1857,8 +1950,9 @@ public void setSmallMoney(String parameterName, BigDecimal value) throws SQLServ @Override public void setSmallMoney(String parameterName, BigDecimal value, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setSmallMoney", - new Object[] {parameterName, value, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setSmallMoney", + new Object[] {parameterName, value, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.SMALLMONEY, value, JavaType.BIGDECIMAL, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setSmallMoney"); @@ -1866,7 +1960,8 @@ public void setSmallMoney(String parameterName, BigDecimal value, boolean forceE @Override public void setBigDecimal(String parameterName, BigDecimal value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); @@ -1875,8 +1970,9 @@ public void setBigDecimal(String parameterName, BigDecimal value) throws SQLServ @Override public void setBigDecimal(String parameterName, BigDecimal value, int precision, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setBigDecimal", - new Object[] {parameterName, value, precision, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBigDecimal", + new Object[] {parameterName, value, precision, scale}); checkClosed(); setValue(findColumn(parameterName), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, precision, scale, false); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); @@ -1885,8 +1981,9 @@ public void setBigDecimal(String parameterName, BigDecimal value, int precision, @Override public void setBigDecimal(String parameterName, BigDecimal value, int precision, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setBigDecimal", - new Object[] {parameterName, value, precision, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBigDecimal", + new Object[] {parameterName, value, precision, scale, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.DECIMAL, value, JavaType.BIGDECIMAL, precision, scale, forceEncrypt); @@ -1895,7 +1992,8 @@ public void setBigDecimal(String parameterName, BigDecimal value, int precision, @Override public void setDouble(String parameterName, double value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDouble", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDouble", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.DOUBLE, value, JavaType.DOUBLE, false); loggerExternal.exiting(getClassNameLogging(), "setDouble"); @@ -1903,7 +2001,9 @@ public void setDouble(String parameterName, double value) throws SQLServerExcept @Override public void setDouble(String parameterName, double value, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDouble", new Object[] {parameterName, value, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDouble", + new Object[] {parameterName, value, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.DOUBLE, value, JavaType.DOUBLE, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDouble"); @@ -1911,7 +2011,8 @@ public void setDouble(String parameterName, double value, boolean forceEncrypt) @Override public void setFloat(String parameterName, float value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setFloat", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setFloat", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.REAL, value, JavaType.FLOAT, false); loggerExternal.exiting(getClassNameLogging(), "setFloat"); @@ -1919,7 +2020,9 @@ public void setFloat(String parameterName, float value) throws SQLServerExceptio @Override public void setFloat(String parameterName, float value, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setFloat", new Object[] {parameterName, value, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setFloat", + new Object[] {parameterName, value, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.REAL, value, JavaType.FLOAT, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setFloat"); @@ -1927,7 +2030,8 @@ public void setFloat(String parameterName, float value, boolean forceEncrypt) th @Override public void setInt(String parameterName, int value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.INTEGER, value, JavaType.INTEGER, false); loggerExternal.exiting(getClassNameLogging(), "setInt"); @@ -1935,7 +2039,8 @@ public void setInt(String parameterName, int value) throws SQLServerException { @Override public void setInt(String parameterName, int value, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {parameterName, value, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {parameterName, value, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.INTEGER, value, JavaType.INTEGER, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setInt"); @@ -1943,7 +2048,8 @@ public void setInt(String parameterName, int value, boolean forceEncrypt) throws @Override public void setLong(String parameterName, long value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setLong", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setLong", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.BIGINT, value, JavaType.LONG, false); loggerExternal.exiting(getClassNameLogging(), "setLong"); @@ -1951,7 +2057,9 @@ public void setLong(String parameterName, long value) throws SQLServerException @Override public void setLong(String parameterName, long value, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setLong", new Object[] {parameterName, value, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setLong", + new Object[] {parameterName, value, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.BIGINT, value, JavaType.LONG, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setLong"); @@ -1959,7 +2067,8 @@ public void setLong(String parameterName, long value, boolean forceEncrypt) thro @Override public void setShort(String parameterName, short value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setShort", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setShort", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.SMALLINT, value, JavaType.SHORT, false); loggerExternal.exiting(getClassNameLogging(), "setShort"); @@ -1967,7 +2076,9 @@ public void setShort(String parameterName, short value) throws SQLServerExceptio @Override public void setShort(String parameterName, short value, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setShort", new Object[] {parameterName, value, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setShort", + new Object[] {parameterName, value, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.SMALLINT, value, JavaType.SHORT, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setShort"); @@ -1975,7 +2086,8 @@ public void setShort(String parameterName, short value, boolean forceEncrypt) th @Override public void setBoolean(String parameterName, boolean value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setBoolean", new Object[] {parameterName, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBoolean", new Object[] {parameterName, value}); checkClosed(); setValue(findColumn(parameterName), JDBCType.BIT, value, JavaType.BOOLEAN, false); loggerExternal.exiting(getClassNameLogging(), "setBoolean"); @@ -1983,7 +2095,9 @@ public void setBoolean(String parameterName, boolean value) throws SQLServerExce @Override public void setBoolean(String parameterName, boolean value, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setBoolean", new Object[] {parameterName, value, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBoolean", + new Object[] {parameterName, value, forceEncrypt}); checkClosed(); setValue(findColumn(parameterName), JDBCType.BIT, value, JavaType.BOOLEAN, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBoolean"); @@ -1991,7 +2105,8 @@ public void setBoolean(String parameterName, boolean value, boolean forceEncrypt @Override public void setNull(String parameterName, int nType) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {parameterName, nType}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {parameterName, nType}); checkClosed(); setObject(setterGetParam(findColumn(parameterName)), null, JavaType.OBJECT, JDBCType.of(nType), null, null, false, findColumn(parameterName), null); @@ -2000,7 +2115,8 @@ public void setNull(String parameterName, int nType) throws SQLServerException { @Override public void setNull(String parameterName, int nType, String sTypeName) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {parameterName, nType, sTypeName}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {parameterName, nType, sTypeName}); checkClosed(); setObject(setterGetParam(findColumn(parameterName)), null, JavaType.OBJECT, JDBCType.of(nType), null, null, false, findColumn(parameterName), sTypeName); @@ -2019,8 +2135,9 @@ public void setURL(String parameterName, URL url) throws SQLException { public final void setStructured(String parameterName, String tvpName, SQLServerDataTable tvpDataTable) throws SQLServerException { tvpName = getTVPNameIfNull(findColumn(parameterName), tvpName); - loggerExternal.entering(getClassNameLogging(), "setStructured", - new Object[] {parameterName, tvpName, tvpDataTable}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setStructured", + new Object[] {parameterName, tvpName, tvpDataTable}); checkClosed(); setValue(findColumn(parameterName), JDBCType.TVP, tvpDataTable, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); @@ -2030,8 +2147,9 @@ public final void setStructured(String parameterName, String tvpName, public final void setStructured(String parameterName, String tvpName, ResultSet tvpResultSet) throws SQLServerException { tvpName = getTVPNameIfNull(findColumn(parameterName), tvpName); - loggerExternal.entering(getClassNameLogging(), "setStructured", - new Object[] {parameterName, tvpName, tvpResultSet}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setStructured", + new Object[] {parameterName, tvpName, tvpResultSet}); checkClosed(); setValue(findColumn(parameterName), JDBCType.TVP, tvpResultSet, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); @@ -2041,8 +2159,9 @@ public final void setStructured(String parameterName, String tvpName, public final void setStructured(String parameterName, String tvpName, ISQLServerDataRecord tvpDataRecord) throws SQLServerException { tvpName = getTVPNameIfNull(findColumn(parameterName), tvpName); - loggerExternal.entering(getClassNameLogging(), "setStructured", - new Object[] {parameterName, tvpName, tvpDataRecord}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setStructured", + new Object[] {parameterName, tvpName, tvpDataRecord}); checkClosed(); setValue(findColumn(parameterName), JDBCType.TVP, tvpDataRecord, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); @@ -2062,7 +2181,8 @@ public URL getURL(String parameterName) throws SQLException { @Override public final void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setSQLXML", new Object[] {parameterName, xmlObject}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setSQLXML", new Object[] {parameterName, xmlObject}); checkClosed(); setSQLXMLInternal(findColumn(parameterName), xmlObject); loggerExternal.exiting(getClassNameLogging(), "setSQLXML"); @@ -2105,8 +2225,9 @@ public final RowId getRowId(String parameterName) throws SQLException { @Override public void registerOutParameter(String parameterName, int sqlType, String typeName) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "registerOutParameter", - new Object[] {parameterName, sqlType, typeName}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "registerOutParameter", + new Object[] {parameterName, sqlType, typeName}); checkClosed(); registerOutParameter(findColumn(parameterName), sqlType, typeName); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); @@ -2114,8 +2235,9 @@ public void registerOutParameter(String parameterName, int sqlType, String typeN @Override public void registerOutParameter(String parameterName, int sqlType, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "registerOutParameter", - new Object[] {parameterName, sqlType, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "registerOutParameter", + new Object[] {parameterName, sqlType, scale}); checkClosed(); registerOutParameter(findColumn(parameterName), sqlType, scale); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); @@ -2124,8 +2246,9 @@ public void registerOutParameter(String parameterName, int sqlType, int scale) t @Override public void registerOutParameter(String parameterName, int sqlType, int precision, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "registerOutParameter", - new Object[] {parameterName, sqlType, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "registerOutParameter", + new Object[] {parameterName, sqlType, scale}); checkClosed(); registerOutParameter(findColumn(parameterName), sqlType, precision, scale); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); @@ -2133,7 +2256,9 @@ public void registerOutParameter(String parameterName, int sqlType, int precisio @Override public void registerOutParameter(String parameterName, int sqlType) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "registerOutParameter", + new Object[] {parameterName, sqlType}); checkClosed(); registerOutParameter(findColumn(parameterName), sqlType); loggerExternal.exiting(getClassNameLogging(), "registerOutParameter"); @@ -2142,7 +2267,9 @@ public void registerOutParameter(String parameterName, int sqlType) throws SQLSe @Override public void registerOutParameter(int parameterIndex, SQLType sqlType) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterIndex, sqlType}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "registerOutParameter", + new Object[] {parameterIndex, sqlType}); // getVendorTypeNumber() returns the same constant integer values as in java.sql.Types registerOutParameter(parameterIndex, sqlType.getVendorTypeNumber()); @@ -2152,8 +2279,9 @@ public void registerOutParameter(int parameterIndex, SQLType sqlType) throws SQL @Override public void registerOutParameter(int parameterIndex, SQLType sqlType, String typeName) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "registerOutParameter", - new Object[] {parameterIndex, sqlType, typeName}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "registerOutParameter", + new Object[] {parameterIndex, sqlType, typeName}); // getVendorTypeNumber() returns the same constant integer values as in java.sql.Types registerOutParameter(parameterIndex, sqlType.getVendorTypeNumber(), typeName); @@ -2163,8 +2291,9 @@ public void registerOutParameter(int parameterIndex, SQLType sqlType, String typ @Override public void registerOutParameter(int parameterIndex, SQLType sqlType, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "registerOutParameter", - new Object[] {parameterIndex, sqlType, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "registerOutParameter", + new Object[] {parameterIndex, sqlType, scale}); // getVendorTypeNumber() returns the same constant integer values as in java.sql.Types registerOutParameter(parameterIndex, sqlType.getVendorTypeNumber(), scale); @@ -2175,8 +2304,9 @@ public void registerOutParameter(int parameterIndex, SQLType sqlType, int scale) public void registerOutParameter(int parameterIndex, SQLType sqlType, int precision, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "registerOutParameter", - new Object[] {parameterIndex, sqlType, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "registerOutParameter", + new Object[] {parameterIndex, sqlType, scale}); // getVendorTypeNumber() returns the same constant integer values as in java.sql.Types registerOutParameter(parameterIndex, sqlType.getVendorTypeNumber(), precision, scale); @@ -2186,7 +2316,8 @@ public void registerOutParameter(int parameterIndex, SQLType sqlType, int precis @Override public void setObject(String parameterName, Object value, SQLType jdbcType) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterName, value, jdbcType}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {parameterName, value, jdbcType}); // getVendorTypeNumber() returns the same constant integer values as in java.sql.Types setObject(parameterName, value, jdbcType.getVendorTypeNumber()); @@ -2196,8 +2327,9 @@ public void setObject(String parameterName, Object value, SQLType jdbcType) thro @Override public void setObject(String parameterName, Object value, SQLType jdbcType, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setObject", - new Object[] {parameterName, value, jdbcType, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setObject", + new Object[] {parameterName, value, jdbcType, scale}); // getVendorTypeNumber() returns the same constant integer values as in java.sql.Types setObject(parameterName, value, jdbcType.getVendorTypeNumber(), scale); @@ -2208,8 +2340,9 @@ public void setObject(String parameterName, Object value, SQLType jdbcType, int public void setObject(String parameterName, Object value, SQLType jdbcType, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setObject", - new Object[] {parameterName, value, jdbcType, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setObject", + new Object[] {parameterName, value, jdbcType, scale, forceEncrypt}); // getVendorTypeNumber() returns the same constant integer values as in java.sql.Types setObject(parameterName, value, jdbcType.getVendorTypeNumber(), scale, forceEncrypt); @@ -2219,8 +2352,9 @@ public void setObject(String parameterName, Object value, SQLType jdbcType, int @Override public void registerOutParameter(String parameterName, SQLType sqlType, String typeName) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "registerOutParameter", - new Object[] {parameterName, sqlType, typeName}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "registerOutParameter", + new Object[] {parameterName, sqlType, typeName}); // getVendorTypeNumber() returns the same constant integer values as in java.sql.Types registerOutParameter(parameterName, sqlType.getVendorTypeNumber(), typeName); @@ -2230,8 +2364,9 @@ public void registerOutParameter(String parameterName, SQLType sqlType, String t @Override public void registerOutParameter(String parameterName, SQLType sqlType, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "registerOutParameter", - new Object[] {parameterName, sqlType, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "registerOutParameter", + new Object[] {parameterName, sqlType, scale}); // getVendorTypeNumber() returns the same constant integer values as in java.sql.Types registerOutParameter(parameterName, sqlType.getVendorTypeNumber(), scale); @@ -2242,8 +2377,9 @@ public void registerOutParameter(String parameterName, SQLType sqlType, int scal public void registerOutParameter(String parameterName, SQLType sqlType, int precision, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "registerOutParameter", - new Object[] {parameterName, sqlType, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "registerOutParameter", + new Object[] {parameterName, sqlType, scale}); // getVendorTypeNumber() returns the same constant integer values as in java.sql.Types registerOutParameter(parameterName, sqlType.getVendorTypeNumber(), precision, scale); @@ -2253,7 +2389,9 @@ public void registerOutParameter(String parameterName, SQLType sqlType, int prec @Override public void registerOutParameter(String parameterName, SQLType sqlType) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "registerOutParameter", new Object[] {parameterName, sqlType}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "registerOutParameter", + new Object[] {parameterName, sqlType}); // getVendorTypeNumber() returns the same constant integer values as in java.sql.Types registerOutParameter(parameterName, sqlType.getVendorTypeNumber()); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerClob.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerClob.java index c76ee2484d..5cc302ec73 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerClob.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerClob.java @@ -25,6 +25,7 @@ import java.text.MessageFormat; import java.util.ArrayList; import java.util.concurrent.atomic.AtomicInteger; +import java.util.logging.Level; import java.util.logging.Logger; @@ -181,7 +182,7 @@ final public String toString() { static private final AtomicInteger baseID = new AtomicInteger(0); private Charset defaultCharset = null; - + // Returns unique id for each instance. private static int nextInstanceID() { return baseID.incrementAndGet(); @@ -219,8 +220,10 @@ private String getDisplayClassName() { this.sqlCollation = collation; this.logger = logger; this.typeInfo = typeInfo; - logger.fine(toString() + " created by (" + ((null != connection) ? connection.toString() : "null connection") - + ")"); + if (logger.isLoggable(Level.FINE)) { + String loggingInfo = (null != connection) ? connection.toString() : "null connection"; + logger.fine(toString() + " created by (" + loggingInfo + ")"); + } } /** @@ -675,7 +678,7 @@ public int setString(long pos, String str, int offset, int len) throws SQLExcept return len; } - + protected void setDefaultCharset(Charset c) { this.defaultCharset = c; } diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerColumnEncryptionJavaKeyStoreProvider.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerColumnEncryptionJavaKeyStoreProvider.java index 06d0091ffe..41d012b65e 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerColumnEncryptionJavaKeyStoreProvider.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerColumnEncryptionJavaKeyStoreProvider.java @@ -76,7 +76,9 @@ public SQLServerColumnEncryptionJavaKeyStoreProvider(String keyStoreLocation, this.keyStorePath = keyStoreLocation; - javaKeyStoreLogger.fine("Path of key store provider is set."); + if (javaKeyStoreLogger.isLoggable(java.util.logging.Level.FINE)) { + javaKeyStoreLogger.fine("Path of key store provider is set."); + } // Password can be null or empty, PKCS12 type allows that. if (null == keyStoreSecret) { @@ -86,7 +88,9 @@ public SQLServerColumnEncryptionJavaKeyStoreProvider(String keyStoreLocation, this.keyStorePwd = new char[keyStoreSecret.length]; System.arraycopy(keyStoreSecret, 0, this.keyStorePwd, 0, keyStoreSecret.length); - javaKeyStoreLogger.fine("Password for key store provider is set."); + if (javaKeyStoreLogger.isLoggable(java.util.logging.Level.FINE)) { + javaKeyStoreLogger.fine("Password for key store provider is set."); + } javaKeyStoreLogger.exiting(SQLServerColumnEncryptionJavaKeyStoreProvider.class.getName(), "SQLServerColumnEncryptionJavaKeyStoreProvider"); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java index fbc18c5b3e..92355d90fe 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnection.java @@ -845,7 +845,7 @@ final boolean isSessionUnAvailable() { final void setMaxFieldSize(int limit) throws SQLServerException { // assert limit >= 0; if (maxFieldSize != limit) { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } // If no limit on field size, set text size to max (2147483647), NOT default (0 --> 4K) @@ -875,7 +875,7 @@ final void initResettableValues() { final void setMaxRows(int limit) throws SQLServerException { // assert limit >= 0; if (maxRows != limit) { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } connectionCommand("SET ROWCOUNT " + limit, "setMaxRows"); @@ -976,7 +976,8 @@ final boolean attachConnId() { int connectionID = nextConnectionID(); // sequential connection id traceID = "ConnectionID:" + connectionID; loggingClassName = "com.microsoft.sqlserver.jdbc.SQLServerConnection:" + connectionID; - connectionlogger.fine(toString() + " created by (" + parentInfo + ")"); + if (connectionlogger.isLoggable(Level.FINE)) + connectionlogger.fine(toString() + " created by (" + parentInfo + ")"); initResettableValues(); // Caching turned on? @@ -1147,19 +1148,25 @@ Connection connect(Properties propsIn, SQLServerPooledConnection pooledConnectio if (INTERMITTENT_TLS_MAX_RETRY < retryAttempt) { // Re-throw the exception if we have reached the maximum retry attempts. - connectionlogger.fine("Connection failed during SSL handshake. Maximum retry attempt (" - + INTERMITTENT_TLS_MAX_RETRY + ") reached. "); + if (connectionlogger.isLoggable(Level.FINE)) { + connectionlogger.fine("Connection failed during SSL handshake. Maximum retry attempt (" + + INTERMITTENT_TLS_MAX_RETRY + ") reached. "); + } throw e; } else if (elapsedSeconds >= loginTimeoutSeconds) { // Re-throw the exception if we do not have any time left to retry. - connectionlogger - .fine("Connection failed during SSL handshake. Not retrying as timeout expired."); + if (connectionlogger.isLoggable(Level.FINE)) { + connectionlogger + .fine("Connection failed during SSL handshake. Not retrying as timeout expired."); + } throw e; } else { // Retry the connection. - connectionlogger.fine( - "Connection failed during SSL handshake. Retrying due to an intermittent TLS 1.2 failure issue. Retry attempt = " - + retryAttempt + "."); + if (connectionlogger.isLoggable(Level.FINE)) { + connectionlogger.fine( + "Connection failed during SSL handshake. Retrying due to an intermittent TLS 1.2 failure issue. Retry attempt = " + + retryAttempt + "."); + } } } } @@ -1523,9 +1530,11 @@ Connection connectInternal(Properties propsIn, authenticationString = SqlAuthentication.valueOfString(sPropValue).toString(); if (integratedSecurity - && (!authenticationString.equalsIgnoreCase(SqlAuthentication.NotSpecified.toString()))) { - connectionlogger.severe(toString() + " " - + SQLServerException.getErrString("R_SetAuthenticationWhenIntegratedSecurityTrue")); + && !authenticationString.equalsIgnoreCase(SqlAuthentication.NotSpecified.toString())) { + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe(toString() + " " + + SQLServerException.getErrString("R_SetAuthenticationWhenIntegratedSecurityTrue")); + } throw new SQLServerException( SQLServerException.getErrString("R_SetAuthenticationWhenIntegratedSecurityTrue"), null); } @@ -1535,8 +1544,10 @@ Connection connectInternal(Properties propsIn, .isEmpty()) || (!activeConnectionProperties .getProperty(SQLServerDriverStringProperty.PASSWORD.toString()).isEmpty()))) { - connectionlogger.severe(toString() + " " - + SQLServerException.getErrString("R_IntegratedAuthenticationWithUserPassword")); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe(toString() + " " + + SQLServerException.getErrString("R_IntegratedAuthenticationWithUserPassword")); + } throw new SQLServerException( SQLServerException.getErrString("R_IntegratedAuthenticationWithUserPassword"), null); } @@ -1546,8 +1557,10 @@ Connection connectInternal(Properties propsIn, .isEmpty()) || (activeConnectionProperties .getProperty(SQLServerDriverStringProperty.PASSWORD.toString()).isEmpty()))) { - connectionlogger.severe( - toString() + " " + SQLServerException.getErrString("R_NoUserPasswordForActivePassword")); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe( + toString() + " " + SQLServerException.getErrString("R_NoUserPasswordForActivePassword")); + } throw new SQLServerException(SQLServerException.getErrString("R_NoUserPasswordForActivePassword"), null); } @@ -1557,8 +1570,10 @@ Connection connectInternal(Properties propsIn, .isEmpty()) || (activeConnectionProperties .getProperty(SQLServerDriverStringProperty.PASSWORD.toString()).isEmpty()))) { - connectionlogger - .severe(toString() + " " + SQLServerException.getErrString("R_NoUserPasswordForSqlPassword")); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe( + toString() + " " + SQLServerException.getErrString("R_NoUserPasswordForSqlPassword")); + } throw new SQLServerException(SQLServerException.getErrString("R_NoUserPasswordForSqlPassword"), null); } @@ -1569,22 +1584,28 @@ Connection connectInternal(Properties propsIn, } if ((null != accessTokenInByte) && 0 == accessTokenInByte.length) { - connectionlogger - .severe(toString() + " " + SQLServerException.getErrString("R_AccessTokenCannotBeEmpty")); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger + .severe(toString() + " " + SQLServerException.getErrString("R_AccessTokenCannotBeEmpty")); + } throw new SQLServerException(SQLServerException.getErrString("R_AccessTokenCannotBeEmpty"), null); } if (integratedSecurity && (null != accessTokenInByte)) { - connectionlogger.severe(toString() + " " - + SQLServerException.getErrString("R_SetAccesstokenWhenIntegratedSecurityTrue")); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe(toString() + " " + + SQLServerException.getErrString("R_SetAccesstokenWhenIntegratedSecurityTrue")); + } throw new SQLServerException( SQLServerException.getErrString("R_SetAccesstokenWhenIntegratedSecurityTrue"), null); } if ((!authenticationString.equalsIgnoreCase(SqlAuthentication.NotSpecified.toString())) && (null != accessTokenInByte)) { - connectionlogger.severe( - toString() + " " + SQLServerException.getErrString("R_SetBothAuthenticationAndAccessToken")); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe(toString() + " " + + SQLServerException.getErrString("R_SetBothAuthenticationAndAccessToken")); + } throw new SQLServerException(SQLServerException.getErrString("R_SetBothAuthenticationAndAccessToken"), null); } @@ -1593,8 +1614,10 @@ Connection connectInternal(Properties propsIn, .getProperty(SQLServerDriverStringProperty.USER.toString()).isEmpty()) || (!activeConnectionProperties.getProperty(SQLServerDriverStringProperty.PASSWORD.toString()) .isEmpty()))) { - connectionlogger - .severe(toString() + " " + SQLServerException.getErrString("R_AccessTokenWithUserPassword")); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe( + toString() + " " + SQLServerException.getErrString("R_AccessTokenWithUserPassword")); + } throw new SQLServerException(SQLServerException.getErrString("R_AccessTokenWithUserPassword"), null); } @@ -1873,10 +1896,11 @@ else if (0 == requestedPacketSize) int sslRecordSize = Util.isIBM() ? 8192 : 16384; if (tdsPacketSize > sslRecordSize) { - connectionlogger.finer(toString() + " Negotiated tdsPacketSize " + tdsPacketSize - + " is too large for SSL with JRE " + Util.SYSTEM_JRE + " (max size is " + sslRecordSize - + ")"); - + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger.finer(toString() + " Negotiated tdsPacketSize " + tdsPacketSize + + " is too large for SSL with JRE " + Util.SYSTEM_JRE + " (max size is " + sslRecordSize + + ")"); + } MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_packetSizeTooBigForSSL")); Object[] msgArgs = {Integer.toString(sslRecordSize)}; terminate(SQLServerException.DRIVER_ERROR_UNSUPPORTED_CONFIG, form.format(msgArgs)); @@ -1885,8 +1909,9 @@ else if (0 == requestedPacketSize) state = State.Opened; - connectionlogger.finer(toString() + " End of connect"); - + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger.finer(toString() + " End of connect"); + } } finally { // once we exit the connect function, the connection can be only in one of two // states, Opened or Closed(if an exception occurred) @@ -1958,8 +1983,10 @@ private void login(String primary, String primaryInstanceName, int primaryPortNu // and the original timeout is used instead of the timeout slice. long intervalExpireFullTimeout = timerStart + timerTimeout; - connectionlogger.finer(toString() + " Start time: " + timerStart + " Time out time: " + timerExpire - + " Timeout Unit Interval: " + timeoutUnitInterval); + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger.finer(toString() + " Start time: " + timerStart + " Time out time: " + timerExpire + + " Timeout Unit Interval: " + timeoutUnitInterval); + } // Initialize loop variables int attemptNumber = 0; @@ -1999,12 +2026,14 @@ private void login(String primary, String primaryInstanceName, int primaryPortNu } // logging code - connectionlogger - .fine(toString() + " This attempt server name: " + currentConnectPlaceHolder.getServerName() - + " port: " + currentConnectPlaceHolder.getPortNumber() + " InstanceName: " - + currentConnectPlaceHolder.getInstanceName() + " useParallel: " + useParallel); - connectionlogger.fine(toString() + " This attempt endtime: " + intervalExpire); - connectionlogger.fine(toString() + " This attempt No: " + attemptNumber); + if (connectionlogger.isLoggable(Level.FINE)) { + connectionlogger + .fine(toString() + " This attempt server name: " + currentConnectPlaceHolder.getServerName() + + " port: " + currentConnectPlaceHolder.getPortNumber() + " InstanceName: " + + currentConnectPlaceHolder.getInstanceName() + " useParallel: " + useParallel); + connectionlogger.fine(toString() + " This attempt endtime: " + intervalExpire); + connectionlogger.fine(toString() + " This attempt No: " + attemptNumber); + } // end logging code // Attempt login. @@ -2132,7 +2161,9 @@ private void login(String primary, String primaryInstanceName, int primaryPortNu // We have to sleep for every attempt in case of non-dbMirroring scenarios (including multisubnetfailover), // Whereas for dbMirroring, we sleep for every two attempts as each attempt is to a different server. if (!isDBMirroring || (1 == attemptNumber % 2)) { - connectionlogger.fine(toString() + " sleeping milisec: " + sleepInterval); + if (connectionlogger.isLoggable(Level.FINE)) { + connectionlogger.fine(toString() + " sleeping milisec: " + sleepInterval); + } try { Thread.sleep(sleepInterval); } catch (InterruptedException e) { @@ -2213,11 +2244,13 @@ private void login(String primary, String primaryInstanceName, int primaryPortNu String instanceNameProperty = SQLServerDriverStringProperty.INSTANCE_NAME.toString(); String serverNameProperty = SQLServerDriverStringProperty.SERVER_NAME.toString(); - connectionlogger.fine(toString() + " adding new failover info server: " - + activeConnectionProperties.getProperty(serverNameProperty) + " instance: " - + activeConnectionProperties.getProperty(instanceNameProperty) + " database: " - + activeConnectionProperties.getProperty(databaseNameProperty) + " server provided failover: " - + failoverPartnerServerProvided); + if (connectionlogger.isLoggable(Level.FINE)) { + connectionlogger.fine(toString() + " adding new failover info server: " + + activeConnectionProperties.getProperty(serverNameProperty) + " instance: " + + activeConnectionProperties.getProperty(instanceNameProperty) + " database: " + + activeConnectionProperties.getProperty(databaseNameProperty) + + " server provided failover: " + failoverPartnerServerProvided); + } tempFailover.failoverAdd(this, useFailoverHost, failoverPartnerServerProvided); FailoverMapSingleton.putFailoverInfo(this, primary, @@ -2251,7 +2284,8 @@ ServerPortPlaceHolder primaryPermissionCheck(String primary, String primaryInsta if (0 == primaryPortNumber) { if (null != primaryInstanceName) { instancePort = getInstancePort(primary, primaryInstanceName); - connectionlogger.fine(toString() + " SQL Server port returned by SQL Browser: " + instancePort); + if (connectionlogger.isLoggable(Level.FINER)) + connectionlogger.fine(toString() + " SQL Server port returned by SQL Browser: " + instancePort); try { if (null != instancePort) { primaryPortNumber = Integer.parseInt(instancePort); @@ -2322,9 +2356,11 @@ private void connectHelper(ServerPortPlaceHolder serverInfo, int timeOutsliceInM int timeOutsliceInMillisForFullTimeout) throws SQLServerException { // Make the initial tcp-ip connection. - connectionlogger.fine(toString() + " Connecting with server: " + serverInfo.getServerName() + " port: " - + serverInfo.getPortNumber() + " Timeout slice: " + timeOutsliceInMillis + " Timeout Full: " - + timeOutFullInSeconds); + if (connectionlogger.isLoggable(Level.FINE)) { + connectionlogger.fine(toString() + " Connecting with server: " + serverInfo.getServerName() + " port: " + + serverInfo.getPortNumber() + " Timeout slice: " + timeOutsliceInMillis + " Timeout Full: " + + timeOutFullInSeconds); + } // Before opening the TDSChannel, calculate local hostname // as the InetAddress.getLocalHost() takes more than usual time in certain OS and JVM combination, it avoids @@ -2469,9 +2505,11 @@ void Prelogin(String serverName, int portNumber) throws SQLServerException { Util.writeInt((int) seqNum, preloginRequest, offset); offset += 4; - connectionlogger - .finer(toString() + " Requesting encryption level:" + TDS.getEncryptionLevel(requestedEncryptionLevel)); - connectionlogger.finer(toString() + " ActivityId " + activityId.toString()); + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger.finer( + toString() + " Requesting encryption level:" + TDS.getEncryptionLevel(requestedEncryptionLevel)); + connectionlogger.finer(toString() + " ActivityId " + activityId.toString()); + } // Write the entire prelogin request if (tdsChannel.isLoggingPackets()) @@ -2509,8 +2547,10 @@ void Prelogin(String serverName, int portNumber) throws SQLServerException { // then maybe we are just trying to talk to an older server that doesn't support prelogin // (and that we don't support with this driver). if (-1 == bytesRead) { - connectionlogger.warning(toString() + preloginErrorLogString - + " Unexpected end of prelogin response after " + responseBytesRead + " bytes read"); + if (connectionlogger.isLoggable(Level.WARNING)) { + connectionlogger.warning(toString() + preloginErrorLogString + + " Unexpected end of prelogin response after " + responseBytesRead + " bytes read"); + } MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_tcpipConnectionFailed")); Object[] msgArgs = {serverName, Integer.toString(portNumber), SQLServerException.getErrString("R_notSQLServer")}; @@ -2531,8 +2571,10 @@ void Prelogin(String serverName, int portNumber) throws SQLServerException { if (!processedResponseHeader && responseBytesRead >= TDS.PACKET_HEADER_SIZE) { // Verify that the response is actually a response... if (TDS.PKT_REPLY != preloginResponse[0]) { - connectionlogger.warning( - toString() + preloginErrorLogString + " Unexpected response type:" + preloginResponse[0]); + if (connectionlogger.isLoggable(Level.WARNING)) { + connectionlogger.warning(toString() + preloginErrorLogString + " Unexpected response type:" + + preloginResponse[0]); + } MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_tcpipConnectionFailed")); Object[] msgArgs = {serverName, Integer.toString(portNumber), SQLServerException.getErrString("R_notSQLServer")}; @@ -2543,8 +2585,10 @@ void Prelogin(String serverName, int portNumber) throws SQLServerException { // In theory, it can be longer, but in current practice it isn't, as all of the // prelogin response items easily fit into a single 4K packet. if (TDS.STATUS_BIT_EOM != (TDS.STATUS_BIT_EOM & preloginResponse[1])) { - connectionlogger.warning( - toString() + preloginErrorLogString + " Unexpected response status:" + preloginResponse[1]); + if (connectionlogger.isLoggable(Level.WARNING)) { + connectionlogger.warning(toString() + preloginErrorLogString + " Unexpected response status:" + + preloginResponse[1]); + } MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_tcpipConnectionFailed")); Object[] msgArgs = {serverName, Integer.toString(portNumber), SQLServerException.getErrString("R_notSQLServer")}; @@ -2556,8 +2600,10 @@ void Prelogin(String serverName, int portNumber) throws SQLServerException { assert responseLength >= 0; if (responseLength >= preloginResponse.length) { - connectionlogger.warning(toString() + preloginErrorLogString + " Response length:" + responseLength - + " is greater than allowed length:" + preloginResponse.length); + if (connectionlogger.isLoggable(Level.WARNING)) { + connectionlogger.warning(toString() + preloginErrorLogString + " Response length:" + + responseLength + " is greater than allowed length:" + preloginResponse.length); + } MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_tcpipConnectionFailed")); Object[] msgArgs = {serverName, Integer.toString(portNumber), SQLServerException.getErrString("R_notSQLServer")}; @@ -2577,7 +2623,9 @@ void Prelogin(String serverName, int portNumber) throws SQLServerException { while (true) { // Get the option token if (responseIndex >= responseLength) { - connectionlogger.warning(toString() + " Option token not found"); + if (connectionlogger.isLoggable(Level.WARNING)) { + connectionlogger.warning(toString() + " Option token not found"); + } throwInvalidTDS(); } byte optionToken = preloginResponse[responseIndex++]; @@ -2588,7 +2636,9 @@ void Prelogin(String serverName, int portNumber) throws SQLServerException { // Get the offset and length that follows the option token if (responseIndex + 4 >= responseLength) { - connectionlogger.warning(toString() + " Offset/Length not found for option:" + optionToken); + if (connectionlogger.isLoggable(Level.WARNING)) { + connectionlogger.warning(toString() + " Offset/Length not found for option:" + optionToken); + } throwInvalidTDS(); } @@ -2602,49 +2652,62 @@ void Prelogin(String serverName, int portNumber) throws SQLServerException { assert optionLength >= 0; if (optionOffset + optionLength > responseLength) { - connectionlogger.warning(toString() + " Offset:" + optionOffset + " and length:" + optionLength - + " exceed response length:" + responseLength); + if (connectionlogger.isLoggable(Level.WARNING)) { + connectionlogger.warning(toString() + " Offset:" + optionOffset + " and length:" + optionLength + + " exceed response length:" + responseLength); + } throwInvalidTDS(); } switch (optionToken) { case TDS.B_PRELOGIN_OPTION_VERSION: if (receivedVersionOption) { - connectionlogger.warning(toString() + " Version option already received"); + if (connectionlogger.isLoggable(Level.WARNING)) { + connectionlogger.warning(toString() + " Version option already received"); + } throwInvalidTDS(); } if (6 != optionLength) { - connectionlogger.warning(toString() + " Version option length:" + optionLength - + " is incorrect. Correct value is 6."); + if (connectionlogger.isLoggable(Level.WARNING)) { + connectionlogger.warning(toString() + " Version option length:" + optionLength + + " is incorrect. Correct value is 6."); + } throwInvalidTDS(); } serverMajorVersion = preloginResponse[optionOffset]; if (serverMajorVersion < 9) { - connectionlogger.warning(toString() + " Server major version:" + serverMajorVersion - + " is not supported by this driver."); + if (connectionlogger.isLoggable(Level.WARNING)) { + connectionlogger.warning(toString() + " Server major version:" + serverMajorVersion + + " is not supported by this driver."); + } MessageFormat form = new MessageFormat( SQLServerException.getErrString("R_unsupportedServerVersion")); Object[] msgArgs = {Integer.toString(preloginResponse[optionOffset])}; terminate(SQLServerException.DRIVER_ERROR_UNSUPPORTED_CONFIG, form.format(msgArgs)); } - connectionlogger - .fine(toString() + " Server returned major version:" + preloginResponse[optionOffset]); + if (connectionlogger.isLoggable(Level.FINE)) + connectionlogger + .fine(toString() + " Server returned major version:" + preloginResponse[optionOffset]); receivedVersionOption = true; break; case TDS.B_PRELOGIN_OPTION_ENCRYPTION: if (TDS.ENCRYPT_INVALID != negotiatedEncryptionLevel) { - connectionlogger.warning(toString() + " Encryption option already received"); + if (connectionlogger.isLoggable(Level.WARNING)) { + connectionlogger.warning(toString() + " Encryption option already received"); + } throwInvalidTDS(); } if (1 != optionLength) { - connectionlogger.warning(toString() + " Encryption option length:" + optionLength - + " is incorrect. Correct value is 1."); + if (connectionlogger.isLoggable(Level.WARNING)) { + connectionlogger.warning(toString() + " Encryption option length:" + optionLength + + " is incorrect. Correct value is 1."); + } throwInvalidTDS(); } @@ -2654,13 +2717,16 @@ void Prelogin(String serverName, int portNumber) throws SQLServerException { if (TDS.ENCRYPT_OFF != negotiatedEncryptionLevel && TDS.ENCRYPT_ON != negotiatedEncryptionLevel && TDS.ENCRYPT_REQ != negotiatedEncryptionLevel && TDS.ENCRYPT_NOT_SUP != negotiatedEncryptionLevel) { - connectionlogger.warning( - toString() + " Server returned " + TDS.getEncryptionLevel(negotiatedEncryptionLevel)); + if (connectionlogger.isLoggable(Level.WARNING)) { + connectionlogger.warning(toString() + " Server returned " + + TDS.getEncryptionLevel(negotiatedEncryptionLevel)); + } throwInvalidTDS(); } - connectionlogger.finer(toString() + " Negotiated encryption level:" - + TDS.getEncryptionLevel(negotiatedEncryptionLevel)); + if (connectionlogger.isLoggable(Level.FINER)) + connectionlogger.finer(toString() + " Negotiated encryption level:" + + TDS.getEncryptionLevel(negotiatedEncryptionLevel)); // If we requested SSL encryption and the server does not support it, then terminate the connection. if (TDS.ENCRYPT_ON == requestedEncryptionLevel && TDS.ENCRYPT_ON != negotiatedEncryptionLevel @@ -2678,10 +2744,12 @@ void Prelogin(String serverName, int portNumber) throws SQLServerException { terminate(SQLServerException.DRIVER_ERROR_SSL_FAILED, SQLServerException.getErrString("R_sslRequiredByServer")); - connectionlogger.warning(toString() + " Client requested encryption level: " - + TDS.getEncryptionLevel(requestedEncryptionLevel) - + " Server returned unexpected encryption level: " - + TDS.getEncryptionLevel(negotiatedEncryptionLevel)); + if (connectionlogger.isLoggable(Level.WARNING)) { + connectionlogger.warning(toString() + " Client requested encryption level: " + + TDS.getEncryptionLevel(requestedEncryptionLevel) + + " Server returned unexpected encryption level: " + + TDS.getEncryptionLevel(negotiatedEncryptionLevel)); + } throwInvalidTDS(); } break; @@ -2689,9 +2757,11 @@ void Prelogin(String serverName, int portNumber) throws SQLServerException { case TDS.B_PRELOGIN_OPTION_FEDAUTHREQUIRED: // Only 0x00 and 0x01 are accepted values from the server. if (0 != preloginResponse[optionOffset] && 1 != preloginResponse[optionOffset]) { - connectionlogger.severe(toString() - + " Server sent an unexpected value for FedAuthRequired PreLogin Option. Value was " - + preloginResponse[optionOffset]); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe(toString() + + " Server sent an unexpected value for FedAuthRequired PreLogin Option. Value was " + + preloginResponse[optionOffset]); + } MessageFormat form = new MessageFormat( SQLServerException.getErrString("R_FedAuthRequiredPreLoginResponseInvalidValue")); throw new SQLServerException(form.format(new Object[] {preloginResponse[optionOffset]}), null); @@ -2709,13 +2779,17 @@ void Prelogin(String serverName, int portNumber) throws SQLServerException { break; default: - connectionlogger.finer(toString() + " Ignoring prelogin response option:" + optionToken); + if (connectionlogger.isLoggable(Level.FINER)) + connectionlogger.finer(toString() + " Ignoring prelogin response option:" + optionToken); break; } } if (!receivedVersionOption || TDS.ENCRYPT_INVALID == negotiatedEncryptionLevel) { - connectionlogger.warning(toString() + " Prelogin response is missing version and/or encryption option."); + if (connectionlogger.isLoggable(Level.WARNING)) { + connectionlogger + .warning(toString() + " Prelogin response is missing version and/or encryption option."); + } throwInvalidTDS(); } } @@ -2946,9 +3020,11 @@ public String nativeSQL(String sql) throws SQLServerException { @Override public void setAutoCommit(boolean newAutoCommitMode) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setAutoCommit", newAutoCommitMode); - if (Util.IsActivityTraceOn()) - loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); + if (loggerExternal.isLoggable(Level.FINER)) { + loggerExternal.entering(getClassNameLogging(), "setAutoCommit", newAutoCommitMode); + if (Util.IsActivityTraceOn()) + loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); + } String commitPendingTransaction = ""; checkClosed(); @@ -2960,8 +3036,10 @@ public void setAutoCommit(boolean newAutoCommitMode) throws SQLServerException { if (newAutoCommitMode) commitPendingTransaction = "IF @@TRANCOUNT > 0 COMMIT TRAN "; - connectionlogger.finer( - toString() + " Autocommitmode current :" + databaseAutoCommitMode + " new: " + newAutoCommitMode); + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger.finer( + toString() + " Autocommitmode current :" + databaseAutoCommitMode + " new: " + newAutoCommitMode); + } rolledBackTransaction = false; connectionCommand(sqlStatementToSetCommit(newAutoCommitMode) + commitPendingTransaction, "setAutoCommit"); @@ -2974,7 +3052,8 @@ public boolean getAutoCommit() throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getAutoCommit"); checkClosed(); boolean res = !inXATransaction && databaseAutoCommitMode; - loggerExternal.exiting(getClassNameLogging(), "getAutoCommit", res); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.exiting(getClassNameLogging(), "getAutoCommit", res); return res; } @@ -2985,7 +3064,7 @@ final byte[] getTransactionDescriptor() { @Override public void commit() throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "commit"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } @@ -2998,7 +3077,7 @@ public void commit() throws SQLServerException { @Override public void rollback() throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "rollback"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -3094,7 +3173,9 @@ final void poolCloseEventNotify() throws SQLServerException { } notifyPooledConnection(null); ActivityCorrelator.cleanupActivityId(); - connectionlogger.finer(toString() + " Connection closed and returned to connection pool"); + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger.finer(toString() + " Connection closed and returned to connection pool"); + } } } @@ -3119,7 +3200,8 @@ public DatabaseMetaData getMetaData() throws SQLServerException { @Override public void setReadOnly(boolean readOnly) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setReadOnly", readOnly); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setReadOnly", readOnly); checkClosed(); // do nothing per spec loggerExternal.exiting(getClassNameLogging(), "setReadOnly"); @@ -3129,14 +3211,15 @@ public void setReadOnly(boolean readOnly) throws SQLServerException { public boolean isReadOnly() throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "isReadOnly"); checkClosed(); - loggerExternal.exiting(getClassNameLogging(), "isReadOnly", Boolean.FALSE); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.exiting(getClassNameLogging(), "isReadOnly", Boolean.FALSE); return false; } @Override public void setCatalog(String catalog) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "setCatalog", catalog); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -3161,9 +3244,11 @@ String getSCatalog() throws SQLServerException { @Override public void setTransactionIsolation(int level) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTransactionIsolation", level); - if (Util.IsActivityTraceOn()) { - loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); + if (loggerExternal.isLoggable(Level.FINER)) { + loggerExternal.entering(getClassNameLogging(), "setTransactionIsolation", level); + if (Util.IsActivityTraceOn()) { + loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); + } } checkClosed(); @@ -3180,7 +3265,8 @@ public void setTransactionIsolation(int level) throws SQLServerException { public int getTransactionIsolation() throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getTransactionIsolation"); checkClosed(); - loggerExternal.exiting(getClassNameLogging(), "getTransactionIsolation", transactionIsolationLevel); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.exiting(getClassNameLogging(), "getTransactionIsolation", transactionIsolationLevel); return transactionIsolationLevel; } @@ -3223,8 +3309,9 @@ public void clearWarnings() throws SQLServerException { // --------------------------JDBC 2.0----------------------------- @Override public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "createStatement", - new Object[] {resultSetType, resultSetConcurrency}); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "createStatement", + new Object[] {resultSetType, resultSetConcurrency}); checkClosed(); Statement st = new SQLServerStatement(this, resultSetType, resultSetConcurrency, SQLServerStatementColumnEncryptionSetting.UseConnectionSetting); @@ -3238,8 +3325,9 @@ public Statement createStatement(int resultSetType, int resultSetConcurrency) th @Override public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "prepareStatement", - new Object[] {sql, resultSetType, resultSetConcurrency}); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "prepareStatement", + new Object[] {sql, resultSetType, resultSetConcurrency}); checkClosed(); PreparedStatement st = new SQLServerPreparedStatement(this, sql, resultSetType, resultSetConcurrency, @@ -3254,8 +3342,9 @@ public PreparedStatement prepareStatement(String sql, int resultSetType, private PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, SQLServerStatementColumnEncryptionSetting stmtColEncSetting) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "prepareStatement", - new Object[] {sql, resultSetType, resultSetConcurrency, stmtColEncSetting}); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "prepareStatement", + new Object[] {sql, resultSetType, resultSetConcurrency, stmtColEncSetting}); checkClosed(); PreparedStatement st = new SQLServerPreparedStatement(this, sql, resultSetType, resultSetConcurrency, @@ -3272,8 +3361,9 @@ private PreparedStatement prepareStatement(String sql, int resultSetType, int re @Override public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "prepareCall", - new Object[] {sql, resultSetType, resultSetConcurrency}); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "prepareCall", + new Object[] {sql, resultSetType, resultSetConcurrency}); checkClosed(); CallableStatement st = new SQLServerCallableStatement(this, sql, resultSetType, resultSetConcurrency, @@ -3549,7 +3639,8 @@ final void processEnvChange(TDSReader tdsReader) throws SQLServerException { } catch (NumberFormatException e) { tdsReader.throwInvalidTDS(); } - connectionlogger.finer(toString() + " Network packet size is " + tdsPacketSize + " bytes"); + if (connectionlogger.isLoggable(Level.FINER)) + connectionlogger.finer(toString() + " Network packet size is " + tdsPacketSize + " bytes"); break; case ENVCHANGE_SQLCOLLATION: @@ -3574,14 +3665,23 @@ final void processEnvChange(TDSReader tdsReader) throws SQLServerException { tdsReader.readBytes(transactionDescriptor, 0, transactionDescriptor.length); - connectionlogger.finer(toString() + ((ENVCHANGE_XACT_BEGIN == envchange) ? " started" : " enlisted")); + if (connectionlogger.isLoggable(Level.FINER)) { + String op; + if (ENVCHANGE_XACT_BEGIN == envchange) + op = " started"; + else + op = " enlisted"; + + connectionlogger.finer(toString() + op); + } break; case ENVCHANGE_XACT_ROLLBACK: rolledBackTransaction = true; if (inXATransaction) { - connectionlogger.finer(toString() + " rolled back. (DTC)"); + if (connectionlogger.isLoggable(Level.FINER)) + connectionlogger.finer(toString() + " rolled back. (DTC)"); // Do not clear the transaction descriptor if the connection is in DT. // For a DTC transaction, a ENV_ROLLBACKTRAN token won't cleanup the xactID previously cached on the @@ -3589,7 +3689,8 @@ final void processEnvChange(TDSReader tdsReader) throws SQLServerException { // because user is required to explicitly un-enlist/defect a connection from a DTC. // A ENV_DEFECTTRAN token though will clean the DTC xactID on the connection. } else { - connectionlogger.finer(toString() + " rolled back"); + if (connectionlogger.isLoggable(Level.FINER)) + connectionlogger.finer(toString() + " rolled back"); Arrays.fill(getTransactionDescriptor(), (byte) 0); } @@ -3597,14 +3698,16 @@ final void processEnvChange(TDSReader tdsReader) throws SQLServerException { break; case ENVCHANGE_XACT_COMMIT: - connectionlogger.finer(toString() + " committed"); + if (connectionlogger.isLoggable(Level.FINER)) + connectionlogger.finer(toString() + " committed"); Arrays.fill(getTransactionDescriptor(), (byte) 0); break; case ENVCHANGE_DTC_DEFECT: - connectionlogger.finer(toString() + " defected"); + if (connectionlogger.isLoggable(Level.FINER)) + connectionlogger.finer(toString() + " defected"); Arrays.fill(getTransactionDescriptor(), (byte) 0); @@ -3627,7 +3730,8 @@ final void processEnvChange(TDSReader tdsReader) throws SQLServerException { case ENVCHANGE_XACT_ENDED: case ENVCHANGE_RESET_COMPLETE: case ENVCHANGE_USER_INFO: - connectionlogger.finer(toString() + " Ignored env change: " + envchange); + if (connectionlogger.isLoggable(Level.FINER)) + connectionlogger.finer(toString() + " Ignored env change: " + envchange); break; case ENVCHANGE_ROUTING: @@ -3664,10 +3768,12 @@ final void processEnvChange(TDSReader tdsReader) throws SQLServerException { assert routingServerName != null; } finally { - connectionlogger.finer(toString() + " Received routing ENVCHANGE with the following values." - + " routingDataValueLength:" + routingDataValueLength + " protocol:" + routingProtocol - + " portNumber:" + routingPortNumber + " serverNameLength:" + routingServerNameLength - + " serverName:" + ((routingServerName != null) ? routingServerName : "null")); + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger.finer(toString() + " Received routing ENVCHANGE with the following values." + + " routingDataValueLength:" + routingDataValueLength + " protocol:" + routingProtocol + + " portNumber:" + routingPortNumber + " serverNameLength:" + routingServerNameLength + + " serverName:" + ((routingServerName != null) ? routingServerName : "null")); + } } // Check if the hostNameInCertificate needs to be updated to handle the rerouted subdomain in Azure @@ -3704,7 +3810,9 @@ final void processEnvChange(TDSReader tdsReader) throws SQLServerException { String newHostName = "*" + routingServerName.substring(routingServerName.indexOf('.')); activeConnectionProperties.setProperty("hostNameInCertificate", newHostName); - connectionlogger.finer(toString() + "Using new host to validate the SSL certificate"); + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger.finer(toString() + "Using new host to validate the SSL certificate"); + } } } @@ -3715,7 +3823,9 @@ final void processEnvChange(TDSReader tdsReader) throws SQLServerException { // Error on unrecognized, unused ENVCHANGES default: - connectionlogger.warning(toString() + " Unknown environment change: " + envchange); + if (connectionlogger.isLoggable(Level.WARNING)) { + connectionlogger.warning(toString() + " Unknown environment change: " + envchange); + } throwInvalidTDS(); break; } @@ -3734,11 +3844,15 @@ final void processFedAuthInfo(TDSReader tdsReader, TDSTokenHandler tdsTokenHandl // TdsParser.TryGetTokenLength, for FEDAUTHINFO, it uses TryReadInt32() int tokenLen = tdsReader.readInt(); - connectionlogger.fine(toString() + " FEDAUTHINFO token stream length = " + tokenLen); + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger.fine(toString() + " FEDAUTHINFO token stream length = " + tokenLen); + } if (tokenLen < 4) { // the token must at least contain a DWORD(length is 4 bytes) indicating the number of info IDs - connectionlogger.severe(toString() + "FEDAUTHINFO token stream length too short for CountOfInfoIDs."); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe(toString() + "FEDAUTHINFO token stream length too short for CountOfInfoIDs."); + } throw new SQLServerException( SQLServerException.getErrString("R_FedAuthInfoLengthTooShortForCountOfInfoIds"), null); } @@ -3748,7 +3862,9 @@ final void processFedAuthInfo(TDSReader tdsReader, TDSTokenHandler tdsTokenHandl tokenLen = tokenLen - 4; // remaining length is shortened since we read optCount, 4 is the size of int - connectionlogger.fine(toString() + " CountOfInfoIDs = " + optionsCount); + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger.fine(toString() + " CountOfInfoIDs = " + optionsCount); + } if (tokenLen > 0) { // read the rest of the token @@ -3756,7 +3872,10 @@ final void processFedAuthInfo(TDSReader tdsReader, TDSTokenHandler tdsTokenHandl tdsReader.readBytes(tokenData, 0, tokenLen); - connectionlogger.fine(toString() + " Read rest of FEDAUTHINFO token stream: " + Arrays.toString(tokenData)); + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger + .fine(toString() + " Read rest of FEDAUTHINFO token stream: " + Arrays.toString(tokenData)); + } // each FedAuthInfoOpt is 9 bytes: // 1 byte for FedAuthInfoID @@ -3788,8 +3907,10 @@ final void processFedAuthInfo(TDSReader tdsReader, TDSTokenHandler tdsTokenHandl wrapped = java.nio.ByteBuffer.wrap(buffer); // big-endian by default int dataOffset = wrapped.getInt(); - connectionlogger.fine( - toString() + " FedAuthInfoOpt: ID=" + id + ", DataLen=" + dataLen + ", Offset=" + dataOffset); + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger.fine(toString() + " FedAuthInfoOpt: ID=" + id + ", DataLen=" + dataLen + + ", Offset=" + dataOffset); + } // offset is measured from optCount, so subtract to make offset measured // from the beginning of tokenData, 4 is the size of int @@ -3797,7 +3918,9 @@ final void processFedAuthInfo(TDSReader tdsReader, TDSTokenHandler tdsTokenHandl // if dataOffset points to a region within FedAuthInfoOpt or after the end of the token, throw if (dataOffset < totalOptionsSize || dataOffset >= tokenLen) { - connectionlogger.severe(toString() + "FedAuthInfoDataOffset points to an invalid location."); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe(toString() + "FedAuthInfoDataOffset points to an invalid location."); + } MessageFormat form = new MessageFormat( SQLServerException.getErrString("R_FedAuthInfoInvalidOffset")); throw new SQLServerException(form.format(new Object[] {dataOffset}), null); @@ -3814,7 +3937,9 @@ final void processFedAuthInfo(TDSReader tdsReader, TDSTokenHandler tdsTokenHandl throw new SQLServerException(SQLServerException.getErrString("R_FedAuthInfoFailedToReadData"), e); } - connectionlogger.fine(toString() + " FedAuthInfoData: " + data); + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger.fine(toString() + " FedAuthInfoData: " + data); + } // store data in tempFedAuthInfo switch (id) { @@ -3825,14 +3950,18 @@ final void processFedAuthInfo(TDSReader tdsReader, TDSTokenHandler tdsTokenHandl sqlFedAuthInfo.stsurl = data; break; default: - connectionlogger - .fine(toString() + " Ignoring unknown federated authentication info option: " + id); + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger + .fine(toString() + " Ignoring unknown federated authentication info option: " + id); + } break; } } } else { - connectionlogger.severe( - toString() + "FEDAUTHINFO token stream is not long enough to contain the data it claims to."); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe( + toString() + "FEDAUTHINFO token stream is not long enough to contain the data it claims to."); + } MessageFormat form = new MessageFormat( SQLServerException.getErrString("R_FedAuthInfoLengthTooShortForData")); throw new SQLServerException(form.format(new Object[] {tokenLen}), null); @@ -3841,7 +3970,9 @@ final void processFedAuthInfo(TDSReader tdsReader, TDSTokenHandler tdsTokenHandl if (null == sqlFedAuthInfo.spn || null == sqlFedAuthInfo.stsurl || sqlFedAuthInfo.spn.trim().isEmpty() || sqlFedAuthInfo.stsurl.trim().isEmpty()) { // We should be receiving both stsurl and spn - connectionlogger.severe(toString() + "FEDAUTHINFO token stream does not contain both STSURL and SPN."); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe(toString() + "FEDAUTHINFO token stream does not contain both STSURL and SPN."); + } throw new SQLServerException(SQLServerException.getErrString("R_FedAuthInfoDoesNotContainStsurlAndSpn"), null); } @@ -3946,9 +4077,11 @@ private SqlFedAuthToken getFedAuthToken(SqlFedAuthInfo fedAuthInfo) throws SQLSe String errorStatus = Integer.toHexString(adalException.GetStatus()); - connectionlogger - .fine(toString() + " SQLServerConnection.getFedAuthToken.AdalException category:" - + errorCategory + " error: " + errorStatus); + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger.fine( + toString() + " SQLServerConnection.getFedAuthToken.AdalException category:" + + errorCategory + " error: " + errorStatus); + } MessageFormat form1 = new MessageFormat( SQLServerException.getErrString("R_ADALAuthenticationMiddleErrorMessage")); @@ -3962,10 +4095,12 @@ private SqlFedAuthToken getFedAuthToken(SqlFedAuthInfo fedAuthInfo) throws SQLSe throw new SQLServerException(form.format(msgArgs), null, 0, middleException); } - connectionlogger.fine(toString() + " SQLServerConnection.getFedAuthToken sleeping: " - + sleepInterval + " milliseconds."); - connectionlogger.fine(toString() + " SQLServerConnection.getFedAuthToken remaining: " - + millisecondsRemaining + " milliseconds."); + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger.fine(toString() + " SQLServerConnection.getFedAuthToken sleeping: " + + sleepInterval + " milliseconds."); + connectionlogger.fine(toString() + " SQLServerConnection.getFedAuthToken remaining: " + + millisecondsRemaining + " milliseconds."); + } try { Thread.sleep(sleepInterval); @@ -3998,7 +4133,9 @@ private void sendFedAuthToken(FedAuthTokenCommand fedAuthCommand, SqlFedAuthToke assert null != fedAuthToken; assert null != fedAuthToken.accessToken; - connectionlogger.fine(toString() + " Sending federated authentication token."); + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger.fine(toString() + " Sending federated authentication token."); + } TDSWriter tdsWriter = fedAuthCommand.startRequest(TDS.PKT_FEDAUTH_TOKEN_MESSAGE); @@ -4050,11 +4187,15 @@ private void onFeatureExtAck(byte featureId, byte[] data) throws SQLServerExcept switch (featureId) { case TDS.TDS_FEATURE_EXT_FEDAUTH: { - connectionlogger - .fine(toString() + " Received feature extension acknowledgement for federated authentication."); + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger.fine( + toString() + " Received feature extension acknowledgement for federated authentication."); + } if (!federatedAuthenticationRequested) { - connectionlogger.severe(toString() + " Did not request federated authentication."); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe(toString() + " Did not request federated authentication."); + } MessageFormat form = new MessageFormat( SQLServerException.getErrString("R_UnrequestedFeatureAckReceived")); Object[] msgArgs = {featureId}; @@ -4069,8 +4210,10 @@ private void onFeatureExtAck(byte featureId, byte[] data) throws SQLServerExcept case TDS.TDS_FEDAUTH_LIBRARY_SECURITYTOKEN: // The server shouldn't have sent any additional data with the ack (like a nonce) if (0 != data.length) { - connectionlogger.severe(toString() - + " Federated authentication feature extension ack for ADAL and Security Token includes extra data."); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe(toString() + + " Federated authentication feature extension ack for ADAL and Security Token includes extra data."); + } throw new SQLServerException( SQLServerException.getErrString("R_FedAuthFeatureAckContainsExtraData"), null); } @@ -4078,8 +4221,10 @@ private void onFeatureExtAck(byte featureId, byte[] data) throws SQLServerExcept default: assert false; // Unknown _fedAuthLibrary type - connectionlogger - .severe(toString() + " Attempting to use unknown federated authentication library."); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe( + toString() + " Attempting to use unknown federated authentication library."); + } MessageFormat form = new MessageFormat( SQLServerException.getErrString("R_FedAuthFeatureAckUnknownLibraryType")); Object[] msgArgs = {fedAuthFeatureExtensionData.libraryType}; @@ -4088,16 +4233,22 @@ private void onFeatureExtAck(byte featureId, byte[] data) throws SQLServerExcept break; } case TDS.TDS_FEATURE_EXT_AE: { - connectionlogger.fine(toString() + " Received feature extension acknowledgement for AE."); + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger.fine(toString() + " Received feature extension acknowledgement for AE."); + } if (1 > data.length) { - connectionlogger.severe(toString() + " Unknown version number for AE."); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe(toString() + " Unknown version number for AE."); + } throw new SQLServerException(SQLServerException.getErrString("R_InvalidAEVersionNumber"), null); } byte supportedTceVersion = data[0]; if (0 == supportedTceVersion || supportedTceVersion > TDS.MAX_SUPPORTED_TCE_VERSION) { - connectionlogger.severe(toString() + " Invalid version number for AE."); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe(toString() + " Invalid version number for AE."); + } throw new SQLServerException(SQLServerException.getErrString("R_InvalidAEVersionNumber"), null); } @@ -4105,18 +4256,24 @@ private void onFeatureExtAck(byte featureId, byte[] data) throws SQLServerExcept break; } case TDS.TDS_FEATURE_EXT_DATACLASSIFICATION: { - connectionlogger - .fine(toString() + " Received feature extension acknowledgement for Data Classification."); + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger + .fine(toString() + " Received feature extension acknowledgement for Data Classification."); + } if (2 != data.length) { - connectionlogger.severe(toString() + " Unknown token for Data Classification."); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe(toString() + " Unknown token for Data Classification."); + } throw new SQLServerException(SQLServerException.getErrString("R_UnknownDataClsTokenNumber"), null); } byte supportedDataClassificationVersion = data[0]; if ((0 == supportedDataClassificationVersion) || (supportedDataClassificationVersion > TDS.MAX_SUPPORTED_DATA_CLASSIFICATION_VERSION)) { - connectionlogger.severe(toString() + " Invalid version number for Data Classification"); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe(toString() + " Invalid version number for Data Classification"); + } throw new SQLServerException(SQLServerException.getErrString("R_InvalidDataClsVersionNumber"), null); } @@ -4125,17 +4282,23 @@ private void onFeatureExtAck(byte featureId, byte[] data) throws SQLServerExcept serverSupportsDataClassification = enabled != 0; } case TDS.TDS_FEATURE_EXT_UTF8SUPPORT: { - connectionlogger.fine(toString() + " Received feature extension acknowledgement for UTF8 support."); + if (connectionlogger.isLoggable(Level.FINER)) { + connectionlogger.fine(toString() + " Received feature extension acknowledgement for UTF8 support."); + } if (1 > data.length) { - connectionlogger.severe(toString() + " Unknown value for UTF8 support."); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe(toString() + " Unknown value for UTF8 support."); + } throw new SQLServerException(SQLServerException.getErrString("R_unknownUTF8SupportValue"), null); } break; } default: { // Unknown feature ack - connectionlogger.severe(toString() + " Unknown feature ack."); + if (connectionlogger.isLoggable(Level.SEVERE)) { + connectionlogger.severe(toString() + " Unknown feature ack."); + } throw new SQLServerException(SQLServerException.getErrString("R_UnknownFeatureAck"), null); } } @@ -4837,7 +5000,7 @@ final private Savepoint setNamedSavepoint(String sName) throws SQLServerExceptio @Override public Savepoint setSavepoint(String sName) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "setSavepoint", sName); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -4849,7 +5012,7 @@ public Savepoint setSavepoint(String sName) throws SQLServerException { @Override public Savepoint setSavepoint() throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "setSavepoint"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -4861,7 +5024,7 @@ public Savepoint setSavepoint() throws SQLServerException { @Override public void rollback(Savepoint s) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "rollback", s); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -4877,7 +5040,8 @@ public void rollback(Savepoint s) throws SQLServerException { @Override public int getHoldability() throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "getHoldability"); - loggerExternal.exiting(getClassNameLogging(), "getHoldability", holdability); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.exiting(getClassNameLogging(), "getHoldability", holdability); return holdability; } @@ -4885,7 +5049,7 @@ public int getHoldability() throws SQLServerException { public void setHoldability(int holdability) throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "setHoldability", holdability); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkValidHoldability(holdability); @@ -5039,7 +5203,8 @@ public SQLXML createSQLXML() throws SQLException { loggerExternal.entering(getClassNameLogging(), "createSQLXML"); SQLXML sqlxml = new SQLServerSQLXML(this); - loggerExternal.exiting(getClassNameLogging(), "createSQLXML", sqlxml); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.exiting(getClassNameLogging(), "createSQLXML", sqlxml); return sqlxml; } @@ -5475,8 +5640,9 @@ String getInstancePort(String server, String instanceName) throws SQLServerExcep DatagramPacket udpResponse = new DatagramPacket(receiveBuffer, receiveBuffer.length); datagramSocket.receive(udpResponse); browserResult = new String(receiveBuffer, 3, receiveBuffer.length - 3); - connectionlogger.fine(toString() + " Received SSRP UDP response from IP address: " - + udpResponse.getAddress().getHostAddress()); + if (connectionlogger.isLoggable(Level.FINER)) + connectionlogger.fine(toString() + " Received SSRP UDP response from IP address: " + + udpResponse.getAddress().getHostAddress()); } catch (IOException ioException) { // Warn and retry lastErrorMessage = "Error receiving SQL Server Browser Service UDP response from server: " + server; @@ -5562,7 +5728,9 @@ final void enqueueUnprepareStatementHandle(PreparedStatementHandle statementHand if (null == statementHandle) return; - loggerExternal.finer(this + ": Adding PreparedHandle to queue for un-prepare:" + statementHandle.getHandle()); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal + .finer(this + ": Adding PreparedHandle to queue for un-prepare:" + statementHandle.getHandle()); // Add the new handle to the discarding queue and find out current # enqueued. this.discardedPreparedStatementHandles.add(statementHandle); @@ -5658,9 +5826,11 @@ final void unprepareUnreferencedPreparedStatementHandles(boolean force) { stmt.execute(sql.toString()); } - loggerExternal.finer(this + ": Finished un-preparing handle count:" + handlesRemoved); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.finer(this + ": Finished un-preparing handle count:" + handlesRemoved); } catch (SQLException e) { - loggerExternal.log(Level.FINER, this + ": Error batch-closing at least one prepared handle", e); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.log(Level.FINER, this + ": Error batch-closing at least one prepared handle", e); } // Decrement threshold counter diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionPoolDataSource.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionPoolDataSource.java index f9c4351350..4ac11100fd 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionPoolDataSource.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionPoolDataSource.java @@ -6,6 +6,7 @@ package com.microsoft.sqlserver.jdbc; import java.sql.SQLException; +import java.util.logging.Level; import javax.naming.Reference; import javax.sql.ConnectionPoolDataSource; @@ -22,18 +23,22 @@ public class SQLServerConnectionPoolDataSource extends SQLServerDataSource imple // Get a new physical connection that the pool manager will issue logical connections from @Override public PooledConnection getPooledConnection() throws SQLException { - loggerExternal.entering(getClassNameLogging(), "getPooledConnection"); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getPooledConnection"); PooledConnection pcon = getPooledConnection(getUser(), getPassword()); - loggerExternal.exiting(getClassNameLogging(), "getPooledConnection", pcon); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.exiting(getClassNameLogging(), "getPooledConnection", pcon); return pcon; } @Override public PooledConnection getPooledConnection(String user, String password) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "getPooledConnection", - new Object[] {user, "Password not traced"}); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getPooledConnection", + new Object[] {user, "Password not traced"}); SQLServerPooledConnection pc = new SQLServerPooledConnection(this, user, password); - loggerExternal.exiting(getClassNameLogging(), "getPooledConnection", pc); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.exiting(getClassNameLogging(), "getPooledConnection", pc); return pc; } @@ -41,9 +46,11 @@ public PooledConnection getPooledConnection(String user, String password) throws @Override public Reference getReference() { - loggerExternal.entering(getClassNameLogging(), "getReference"); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getReference"); Reference ref = getReferenceInternal("com.microsoft.sqlserver.jdbc.SQLServerConnectionPoolDataSource"); - loggerExternal.exiting(getClassNameLogging(), "getReference", ref); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.exiting(getClassNameLogging(), "getReference", ref); return ref; } diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionPoolProxy.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionPoolProxy.java index 73630e7156..1ee3d0128d 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionPoolProxy.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerConnectionPoolProxy.java @@ -148,7 +148,8 @@ public void abort(Executor executor) throws SQLException { executor.execute(new Runnable() { public void run() { - wrappedConnection.getConnectionLogger().finer(toString() + " Connection proxy aborted "); + if (wrappedConnection.getConnectionLogger().isLoggable(java.util.logging.Level.FINER)) + wrappedConnection.getConnectionLogger().finer(toString() + " Connection proxy aborted "); try { wrappedConnection.poolCloseEventNotify(); wrappedConnection = null; @@ -162,7 +163,8 @@ public void run() { @Override public void close() throws SQLServerException { if (bIsOpen && (null != wrappedConnection)) { - wrappedConnection.getConnectionLogger().finer(toString() + " Connection proxy closed "); + if (wrappedConnection.getConnectionLogger().isLoggable(java.util.logging.Level.FINER)) + wrappedConnection.getConnectionLogger().finer(toString() + " Connection proxy closed "); wrappedConnection.poolCloseEventNotify(); wrappedConnection = null; diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDataSource.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDataSource.java index 689a87553b..e20b0a8e87 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDataSource.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDataSource.java @@ -11,6 +11,7 @@ import java.util.Enumeration; import java.util.Properties; import java.util.concurrent.atomic.AtomicInteger; +import java.util.logging.Level; import java.util.logging.Logger; import javax.naming.Reference; @@ -88,7 +89,9 @@ public Connection getConnection() throws SQLServerException { @Override public Connection getConnection(String username, String password) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getConnection", new Object[] {username, "Password not traced"}); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getConnection", + new Object[] {username, "Password not traced"}); Connection con = getConnectionInternal(username, password, null); loggerExternal.exiting(getClassNameLogging(), "getConnection", con); return con; @@ -601,7 +604,8 @@ public void setWorkstationID(String workstationID) { @Override public String getWorkstationID() { - loggerExternal.entering(getClassNameLogging(), "getWorkstationID"); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getWorkstationID"); String getWSID = connectionProps.getProperty(SQLServerDriverStringProperty.WORKSTATION_ID.toString()); // Per spec, return what the logon will send here if workstationID // property is not set. @@ -872,7 +876,8 @@ public String getJASSConfigurationName() { * no property value is set. */ private void setStringProperty(Properties props, String propKey, String propValue) { - if (!propKey.contains("password") && !propKey.contains("Password")) { + if (loggerExternal.isLoggable(java.util.logging.Level.FINER) && !propKey.contains("password") + && !propKey.contains("Password")) { loggerExternal.entering(getClassNameLogging(), "set" + propKey, propValue); } else loggerExternal.entering(getClassNameLogging(), "set" + propKey); @@ -891,11 +896,13 @@ private void setStringProperty(Properties props, String propKey, String propValu * not set. */ private String getStringProperty(Properties props, String propKey, String defaultValue) { - loggerExternal.entering(getClassNameLogging(), "get" + propKey); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "get" + propKey); String propValue = props.getProperty(propKey); if (null == propValue) propValue = defaultValue; - if (!propKey.contains("password") && !propKey.contains("Password")) + if (loggerExternal.isLoggable(java.util.logging.Level.FINER) && !propKey.contains("password") + && !propKey.contains("Password")) loggerExternal.exiting(getClassNameLogging(), "get" + propKey, propValue); return propValue; } @@ -909,7 +916,8 @@ private String getStringProperty(Properties props, String propKey, String defaul * Caller will always supply a non-null props and propKey. */ private void setIntProperty(Properties props, String propKey, int propValue) { - loggerExternal.entering(getClassNameLogging(), "set" + propKey, propValue); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "set" + propKey, propValue); props.setProperty(propKey, Integer.valueOf(propValue).toString()); loggerExternal.exiting(getClassNameLogging(), "set" + propKey); } @@ -919,7 +927,8 @@ private void setIntProperty(Properties props, String propKey, int propValue) { * defaultValue if the specific property value is not set. */ private int getIntProperty(Properties props, String propKey, int defaultValue) { - loggerExternal.entering(getClassNameLogging(), "get" + propKey); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "get" + propKey); String propValue = props.getProperty(propKey); int value = defaultValue; if (null != propValue) { @@ -931,7 +940,8 @@ private int getIntProperty(Properties props, String propKey, int defaultValue) { assert false : "Bad portNumber:-" + propValue; } } - loggerExternal.exiting(getClassNameLogging(), "get" + propKey, value); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.exiting(getClassNameLogging(), "get" + propKey, value); return value; } @@ -939,7 +949,8 @@ private int getIntProperty(Properties props, String propKey, int defaultValue) { * Set a boolean property value. Caller will always supply a non-null props and propKey. */ private void setBooleanProperty(Properties props, String propKey, boolean propValue) { - loggerExternal.entering(getClassNameLogging(), "set" + propKey, propValue); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "set" + propKey, propValue); props.setProperty(propKey, (propValue) ? "true" : "false"); loggerExternal.exiting(getClassNameLogging(), "set" + propKey); } @@ -949,7 +960,8 @@ private void setBooleanProperty(Properties props, String propKey, boolean propVa * defaultValue if the specific property value is not set. */ private boolean getBooleanProperty(Properties props, String propKey, boolean defaultValue) { - loggerExternal.entering(getClassNameLogging(), "get" + propKey); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "get" + propKey); String propValue = props.getProperty(propKey); Boolean value; if (null == propValue) { @@ -964,7 +976,9 @@ private boolean getBooleanProperty(Properties props, String propKey, boolean def } private void setObjectProperty(Properties props, String propKey, Object propValue) { - loggerExternal.entering(getClassNameLogging(), "set" + propKey); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) { + loggerExternal.entering(getClassNameLogging(), "set" + propKey); + } if (null != propValue) { props.put(propKey, propValue); } @@ -972,7 +986,8 @@ private void setObjectProperty(Properties props, String propKey, Object propValu } private Object getObjectProperty(Properties props, String propKey, Object defaultValue) { - loggerExternal.entering(getClassNameLogging(), "get" + propKey); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "get" + propKey); Object propValue = props.get(propKey); if (null == propValue) propValue = defaultValue; @@ -1030,7 +1045,8 @@ SQLServerConnection getConnectionInternal(String username, String password, } // Create new connection and connect. - dsLogger.finer(toString() + " Begin create new connection."); + if (dsLogger.isLoggable(Level.FINER)) + dsLogger.finer(toString() + " Begin create new connection."); SQLServerConnection result = null; if (Util.use43Wrapper()) { result = new SQLServerConnection43(toString()); @@ -1038,7 +1054,8 @@ SQLServerConnection getConnectionInternal(String username, String password, result = new SQLServerConnection(toString()); } result.connect(mergedProps, pooledConnection); - dsLogger.finer(toString() + " End create new connection " + result.toString()); + if (dsLogger.isLoggable(Level.FINER)) + dsLogger.finer(toString() + " End create new connection " + result.toString()); return result; } @@ -1053,7 +1070,8 @@ public Reference getReference() { } Reference getReferenceInternal(String dataSourceClassString) { - dsLogger.finer(toString() + " creating reference for " + dataSourceClassString + "."); + if (dsLogger.isLoggable(Level.FINER)) + dsLogger.finer(toString() + " creating reference for " + dataSourceClassString + "."); Reference ref = new Reference(this.getClass().getName(), "com.microsoft.sqlserver.jdbc.SQLServerDataSourceObjectFactory", null); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDatabaseMetaData.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDatabaseMetaData.java index bf68951fa5..51132018f7 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDatabaseMetaData.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDatabaseMetaData.java @@ -18,6 +18,7 @@ import java.util.Map; import java.util.Properties; import java.util.concurrent.atomic.AtomicInteger; +import java.util.logging.Level; /** @@ -138,7 +139,9 @@ final public String toString() { public SQLServerDatabaseMetaData(SQLServerConnection con) { traceID = " SQLServerDatabaseMetaData:" + nextInstanceID(); connection = con; - logger.fine(toString() + " created by (" + connection.toString() + ")"); + if (logger.isLoggable(java.util.logging.Level.FINE)) { + logger.fine(toString() + " created by (" + connection.toString() + ")"); + } } @Override @@ -441,7 +444,7 @@ public boolean supportsSharding() throws SQLException { @Override public java.sql.ResultSet getCatalogs() throws SQLException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -474,7 +477,7 @@ public String getCatalogTerm() throws SQLServerException { @Override public java.sql.ResultSet getColumnPrivileges(String catalog, String schema, String table, String col) throws SQLServerException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -500,7 +503,7 @@ public java.sql.ResultSet getColumnPrivileges(String catalog, String schema, Str @Override public java.sql.ResultSet getTables(String catalog, String schema, String table, String types[]) throws SQLServerException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -612,7 +615,7 @@ private static String EscapeIDName(String inID) throws SQLServerException { @Override public java.sql.ResultSet getColumns(String catalog, String schema, String table, String col) throws SQLServerException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -755,7 +758,7 @@ public java.sql.ResultSet getClientInfoProperties() throws SQLException { @Override public java.sql.ResultSet getBestRowIdentifier(String catalog, String schema, String table, int scope, boolean nullable) throws SQLServerException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -791,7 +794,7 @@ public java.sql.ResultSet getBestRowIdentifier(String catalog, String schema, St @Override public java.sql.ResultSet getCrossReference(String cat1, String schem1, String tab1, String cat2, String schem2, String tab2) throws SQLException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -921,7 +924,7 @@ private ResultSet executeSPFkeys(String[] procParams) throws SQLException, SQLTi @Override public java.sql.ResultSet getIndexInfo(String cat, String schema, String table, boolean unique, boolean approximate) throws SQLServerException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -1097,7 +1100,7 @@ public String getNumericFunctions() throws SQLServerException { @Override public java.sql.ResultSet getPrimaryKeys(String cat, String schema, String table) throws SQLServerException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -1120,7 +1123,7 @@ public java.sql.ResultSet getPrimaryKeys(String cat, String schema, @Override public java.sql.ResultSet getProcedureColumns(String catalog, String schema, String proc, String col) throws SQLServerException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -1163,7 +1166,7 @@ public java.sql.ResultSet getProcedureColumns(String catalog, String schema, Str @Override public java.sql.ResultSet getProcedures(String catalog, String schema, String proc) throws SQLServerException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } @@ -1189,7 +1192,7 @@ public String getProcedureTerm() throws SQLServerException { @Override public ResultSet getPseudoColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) throws SQLException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } @@ -1216,7 +1219,7 @@ public ResultSet getPseudoColumns(String catalog, String schemaPattern, String t @Override public java.sql.ResultSet getSchemas() throws SQLException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -1274,7 +1277,9 @@ private java.sql.ResultSet getSchemasInternal(String catalog, s += " where " + schemaName + " like ? "; s += " order by 2, 1"; - logger.fine(toString() + " schema query (" + s + ")"); + if (logger.isLoggable(java.util.logging.Level.FINE)) { + logger.fine(toString() + " schema query (" + s + ")"); + } SQLServerResultSet rs; if (null == schemaPattern) { catalog = null; @@ -1294,7 +1299,7 @@ private java.sql.ResultSet getSchemasInternal(String catalog, @Override public java.sql.ResultSet getSchemas(String catalog, String schemaPattern) throws SQLException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } return getSchemasInternal(catalog, schemaPattern); @@ -1319,26 +1324,34 @@ public String getSQLKeywords() throws SQLServerException { } private static String createSqlKeyWords() { - return "ADD,ALL,ALTER,AND,ANY,AS,ASC,AUTHORIZATION," + "BACKUP,BEGIN,BETWEEN,BREAK,BROWSE,BULK,BY," - + "CASCADE,CASE,CHECK,CHECKPOINT,CLOSE,CLUSTERED,COALESCE,COLLATE,COLUMN,COMMIT," - + "COMPUTE,CONSTRAINT,CONTAINS,CONTAINSTABLE,CONTINUE,CONVERT,CREATE,CROSS,CURRENT," - + "CURRENT_DATE,CURRENT_TIME,CURRENT_TIMESTAMP,CURRENT_USER,CURSOR," - + "DATABASE,DBCC,DEALLOCATE,DECLARE,DEFAULT,DELETE,DENY,DESC,DISK," - + "DISTINCT,DISTRIBUTED,DOUBLE,DROP,DUMP," - + "ELSE,END,ERRLVL,ESCAPE,EXCEPT,EXEC,EXECUTE,EXISTS,EXIT,EXTERNAL," - + "FETCH,FILE,FILLFACTOR,FOR,FOREIGN,FREETEXT,FREETEXTTABLE,FROM,FULL,FUNCTION," + "GOTO,GRANT,GROUP," - + "HAVING,HOLDLOCK," - + "IDENTITY,IDENTITY_INSERT,IDENTITYCOL,IF,IN,INDEX,INNER,INSERT,INTERSECT,INTO,IS," + "JOIN," - + "KEY,KILL," + "LEFT,LIKE,LINENO,LOAD," + "MERGE," + "NATIONAL,NOCHECK,NONCLUSTERED,NOT,NULL,NULLIF," - + "OF,OFF,OFFSETS,ON,OPEN,OPENDATASOURCE,OPENQUERY," + "OPENROWSET,OPENXML,OPTION,OR,ORDER,OUTER,OVER," - + "PERCENT,PIVOT,PLAN,PRECISION,PRIMARY,PRINT,PROC,PROCEDURE,PUBLIC," - + "RAISERROR,READ,READTEXT,RECONFIGURE,REFERENCES,REPLICATION,RESTORE,RESTRICT," - + "RETURN,REVERT,REVOKE,RIGHT,ROLLBACK,ROWCOUNT,ROWGUIDCOL,RULE," - + "SAVE,SCHEMA,SECURITYAUDIT,SELECT,SEMANTICKEYPHRASETABLE,SEMANTICSIMILARITYDETAILSTABLE," - + "SEMANTICSIMILARITYTABLE,SESSION_USER,SET,SETUSER,SHUTDOWN,SOME,STATISTICS,SYSTEM_USER," - + "TABLE,TABLESAMPLE,TEXTSIZE,THEN,TO,TOP,TRAN,TRANSACTION,TRIGGER,TRUNCATE,TRY_CONVERT,TSEQUAL," - + "UNION,UNIQUE,UNPIVOT,UPDATE,UPDATETEXT,USE,USER," + "VALUES,VARYING,VIEW," - + "WAITFOR,WHEN,WHERE,WHILE,WITH,WITHIN GROUP,WRITETEXT"; + return "ADD,ALL,ALTER,AND,ANY,AS,ASC,AUTHORIZATION," + + "BACKUP,BEGIN,BETWEEN,BREAK,BROWSE,BULK,BY," + + "CASCADE,CASE,CHECK,CHECKPOINT,CLOSE,CLUSTERED,COALESCE,COLLATE,COLUMN,COMMIT," + + "COMPUTE,CONSTRAINT,CONTAINS,CONTAINSTABLE,CONTINUE,CONVERT,CREATE,CROSS,CURRENT," + + "CURRENT_DATE,CURRENT_TIME,CURRENT_TIMESTAMP,CURRENT_USER,CURSOR," + + "DATABASE,DBCC,DEALLOCATE,DECLARE,DEFAULT,DELETE,DENY,DESC,DISK," + + "DISTINCT,DISTRIBUTED,DOUBLE,DROP,DUMP," + + "ELSE,END,ERRLVL,ESCAPE,EXCEPT,EXEC,EXECUTE,EXISTS,EXIT,EXTERNAL," + + "FETCH,FILE,FILLFACTOR,FOR,FOREIGN,FREETEXT,FREETEXTTABLE,FROM,FULL,FUNCTION," + + "GOTO,GRANT,GROUP," + + "HAVING,HOLDLOCK," + + "IDENTITY,IDENTITY_INSERT,IDENTITYCOL,IF,IN,INDEX,INNER,INSERT,INTERSECT,INTO,IS," + + "JOIN," + + "KEY,KILL," + + "LEFT,LIKE,LINENO,LOAD," + + "MERGE," + + "NATIONAL,NOCHECK,NONCLUSTERED,NOT,NULL,NULLIF," + + "OF,OFF,OFFSETS,ON,OPEN,OPENDATASOURCE,OPENQUERY," + + "OPENROWSET,OPENXML,OPTION,OR,ORDER,OUTER,OVER," + + "PERCENT,PIVOT,PLAN,PRECISION,PRIMARY,PRINT,PROC,PROCEDURE,PUBLIC," + + "RAISERROR,READ,READTEXT,RECONFIGURE,REFERENCES,REPLICATION,RESTORE,RESTRICT," + + "RETURN,REVERT,REVOKE,RIGHT,ROLLBACK,ROWCOUNT,ROWGUIDCOL,RULE," + + "SAVE,SCHEMA,SECURITYAUDIT,SELECT,SEMANTICKEYPHRASETABLE,SEMANTICSIMILARITYDETAILSTABLE," + + "SEMANTICSIMILARITYTABLE,SESSION_USER,SET,SETUSER,SHUTDOWN,SOME,STATISTICS,SYSTEM_USER," + + "TABLE,TABLESAMPLE,TEXTSIZE,THEN,TO,TOP,TRAN,TRANSACTION,TRIGGER,TRUNCATE,TRY_CONVERT,TSEQUAL," + + "UNION,UNIQUE,UNPIVOT,UPDATE,UPDATETEXT,USE,USER," + + "VALUES,VARYING,VIEW," + + "WAITFOR,WHEN,WHERE,WHILE,WITH,WITHIN GROUP,WRITETEXT"; } @Override @@ -1360,7 +1373,7 @@ public String getSystemFunctions() throws SQLServerException { @Override public java.sql.ResultSet getTablePrivileges(String catalog, String schema, String table) throws SQLServerException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -1381,7 +1394,7 @@ public java.sql.ResultSet getTablePrivileges(String catalog, String schema, @Override public java.sql.ResultSet getTableTypes() throws SQLException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -1398,7 +1411,7 @@ public String getTimeDateFunctions() throws SQLServerException { @Override public java.sql.ResultSet getTypeInfo() throws SQLException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -1483,7 +1496,7 @@ public String getURL() throws SQLServerException { @Override public String getUserName() throws SQLServerException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -1505,7 +1518,7 @@ public String getUserName() throws SQLServerException, SQLTimeoutException { @Override public java.sql.ResultSet getVersionColumns(String catalog, String schema, String table) throws SQLServerException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -2137,7 +2150,7 @@ public boolean supportsBatchUpdates() throws SQLServerException { @Override public java.sql.ResultSet getUDTs(String catalog, String schemaPattern, String typeNamePattern, int[] types) throws SQLException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -2239,7 +2252,7 @@ public boolean supportsResultSetHoldability(int holdability) throws SQLServerExc @Override public ResultSet getAttributes(String catalog, String schemaPattern, String typeNamePattern, String attributeNamePattern) throws SQLException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -2270,7 +2283,7 @@ public ResultSet getAttributes(String catalog, String schemaPattern, String type @Override public ResultSet getSuperTables(String catalog, String schemaPattern, String tableNamePattern) throws SQLException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -2284,7 +2297,7 @@ public ResultSet getSuperTables(String catalog, String schemaPattern, @Override public ResultSet getSuperTypes(String catalog, String schemaPattern, String typeNamePattern) throws SQLException, SQLTimeoutException { - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java index dddb83e542..30a0c4d761 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerDriver.java @@ -14,6 +14,7 @@ import java.util.Locale; import java.util.Properties; import java.util.concurrent.atomic.AtomicInteger; +import java.util.logging.Level; import java.util.logging.Logger; import org.ietf.jgss.GSSCredential; @@ -552,7 +553,7 @@ String getClassNameLogging() { try { java.sql.DriverManager.registerDriver(new SQLServerDriver()); } catch (SQLException e) { - if (Util.IsActivityTraceOn()) { + if (drLogger.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { drLogger.finer("Error registering driver: " + e); } } @@ -656,7 +657,8 @@ static String getNormalizedPropertyName(String name, Logger logger) { } } - logger.finer("Unknown property" + name); + if (logger.isLoggable(Level.FINER)) + logger.finer("Unknown property" + name); return null; } @@ -678,7 +680,8 @@ static String getPropertyOnlyName(String name, Logger logger) { } } - logger.finer("Unknown property" + name); + if (logger.isLoggable(Level.FINER)) + logger.finer("Unknown property" + name); return null; } diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerException.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerException.java index 93a2f7d0a4..bdea428d6d 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerException.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerException.java @@ -108,7 +108,8 @@ private void logException(Object o, String errText, boolean bStack) { if (o != null) id = o.toString(); - exLogger.fine("*** SQLException:" + id + " " + this.toString() + " " + errText); + if (exLogger.isLoggable(Level.FINE)) + exLogger.fine("*** SQLException:" + id + " " + this.toString() + " " + errText); if (bStack) { if (exLogger.isLoggable(Level.FINE)) { StringBuilder sb = new StringBuilder(100); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerParameterMetaData.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerParameterMetaData.java index b5a32bef25..c2bea2755e 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerParameterMetaData.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerParameterMetaData.java @@ -553,7 +553,9 @@ private void checkClosed() throws SQLServerException { assert null != st; stmtParent = st; con = st.connection; - logger.fine(toString() + " created by (" + st.toString() + ")"); + if (logger.isLoggable(java.util.logging.Level.FINE)) { + logger.fine(toString() + " created by (" + st.toString() + ")"); + } try { // If the CallableStatement/PreparedStatement is a stored procedure call diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPooledConnection.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPooledConnection.java index 783717a098..91b8a51442 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPooledConnection.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPooledConnection.java @@ -9,6 +9,7 @@ import java.sql.SQLException; import java.util.Vector; import java.util.concurrent.atomic.AtomicInteger; +import java.util.logging.Level; import javax.sql.ConnectionEvent; import javax.sql.ConnectionEventListener; @@ -43,13 +44,15 @@ public class SQLServerPooledConnection implements PooledConnection { factoryUser = user; factoryPassword = password; - pcLogger.finer(toString() + " Start create new connection for pool."); + if (pcLogger.isLoggable(Level.FINER)) + pcLogger.finer(toString() + " Start create new connection for pool."); physicalConnection = createNewConnection(); String nameL = getClass().getName(); traceID = nameL.substring(1 + nameL.lastIndexOf('.')) + ":" + nextPooledConnectionID(); - pcLogger.fine(toString() + " created by (" + ds.toString() + ")" + " Physical connection " + safeCID() - + ", End create new connection for pool"); + if (pcLogger.isLoggable(Level.FINE)) + pcLogger.fine(toString() + " created by (" + ds.toString() + ")" + " Physical connection " + safeCID() + + ", End create new connection for pool"); } /** @@ -76,7 +79,8 @@ private SQLServerConnection createNewConnection() throws SQLException { */ @Override public Connection getConnection() throws SQLException { - pcLogger.finer(toString() + " user:(default)."); + if (pcLogger.isLoggable(Level.FINER)) + pcLogger.finer(toString() + " user:(default)."); synchronized (this) { // If physical connection is closed, throw exception per spec, this PooledConnection is dead. if (physicalConnection == null) { @@ -87,7 +91,8 @@ public Connection getConnection() throws SQLException { // Check with security manager to insure caller has rights to connect. // This will throw a SecurityException if the caller does not have proper rights. physicalConnection.doSecurityCheck(); - pcLogger.fine(toString() + " Physical connection, " + safeCID()); + if (pcLogger.isLoggable(Level.FINE)) + pcLogger.fine(toString() + " Physical connection, " + safeCID()); if (null != physicalConnection.getAuthenticationResult()) { if (Util.checkIfNeedNewAccessToken(physicalConnection)) { @@ -100,7 +105,7 @@ public Connection getConnection() throws SQLException { if (null != lastProxyConnection) { // if there was a last proxy connection send reset physicalConnection.resetPooledConnection(); - if (!lastProxyConnection.isClosed()) + if (pcLogger.isLoggable(Level.FINE) && !lastProxyConnection.isClosed()) pcLogger.fine(toString() + "proxy " + lastProxyConnection.toString() + " is not closed before getting the connection."); // use internal close so there wont be an event due to us closing the connection, if not closed already. @@ -108,7 +113,7 @@ public Connection getConnection() throws SQLException { } lastProxyConnection = new SQLServerConnectionPoolProxy(physicalConnection); - if (!lastProxyConnection.isClosed()) + if (pcLogger.isLoggable(Level.FINE) && !lastProxyConnection.isClosed()) pcLogger.fine(toString() + " proxy " + lastProxyConnection.toString() + " is returned."); return lastProxyConnection; @@ -121,7 +126,8 @@ public Connection getConnection() throws SQLException { * is used to notify the pooling manager that the connection is bad and should be removed from the pool. */ void notifyEvent(SQLServerException e) { - pcLogger.finer(toString() + " Exception:" + e + safeCID()); + if (pcLogger.isLoggable(Level.FINER)) + pcLogger.finer(toString() + " Exception:" + e + safeCID()); // close the proxy on fatal error event. Note exception is null then the event comes from the proxy close. if (null != e) { @@ -143,10 +149,12 @@ void notifyEvent(SQLServerException e) { ConnectionEvent ev = new ConnectionEvent(this, e); if (null == e) { - pcLogger.finer(toString() + " notifyEvent:connectionClosed " + safeCID()); + if (pcLogger.isLoggable(Level.FINER)) + pcLogger.finer(toString() + " notifyEvent:connectionClosed " + safeCID()); listener.connectionClosed(ev); } else { - pcLogger.finer(toString() + " notifyEvent:connectionErrorOccurred " + safeCID()); + if (pcLogger.isLoggable(Level.FINER)) + pcLogger.finer(toString() + " notifyEvent:connectionErrorOccurred " + safeCID()); listener.connectionErrorOccurred(ev); } } @@ -155,7 +163,8 @@ void notifyEvent(SQLServerException e) { @Override public void addConnectionEventListener(ConnectionEventListener listener) { - pcLogger.finer(toString() + safeCID()); + if (pcLogger.isLoggable(Level.FINER)) + pcLogger.finer(toString() + safeCID()); synchronized (listeners) { listeners.add(listener); } @@ -163,7 +172,8 @@ public void addConnectionEventListener(ConnectionEventListener listener) { @Override public void close() throws SQLException { - pcLogger.finer(toString() + " Closing physical connection, " + safeCID()); + if (pcLogger.isLoggable(Level.FINER)) + pcLogger.finer(toString() + " Closing physical connection, " + safeCID()); synchronized (this) { // First close the last proxy if (null != lastProxyConnection) @@ -183,7 +193,8 @@ public void close() throws SQLException { @Override public void removeConnectionEventListener(ConnectionEventListener listener) { - pcLogger.finer(toString() + safeCID()); + if (pcLogger.isLoggable(Level.FINER)) + pcLogger.finer(toString() + safeCID()); synchronized (listeners) { listeners.remove(listener); } diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java index bedaeb80f2..fea6c22e36 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerPreparedStatement.java @@ -247,8 +247,9 @@ private void closePreparedHandle() { // the prepared handle. We won't be able to, and it's already closed // on the server anyway. if (connection.isSessionUnAvailable()) { - loggerExternal - .finer(this + ": Not closing PreparedHandle:" + prepStmtHandle + "; connection is already closed."); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.finer( + this + ": Not closing PreparedHandle:" + prepStmtHandle + "; connection is already closed."); } else { isExecutedAtLeastOnce = false; final int handleToClose = prepStmtHandle; @@ -264,7 +265,8 @@ else if (connection.isPreparedStatementUnprepareBatchingEnabled()) { connection.new PreparedStatementHandle(null, handleToClose, executedSqlDirectly, true)); } else { // Non batched behavior (same as pre batch clean-up implementation) - loggerExternal.finer(this + ": Closing PreparedHandle:" + handleToClose); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.finer(this + ": Closing PreparedHandle:" + handleToClose); final class PreparedHandleClose extends UninterruptableTDSCommand { PreparedHandleClose() { @@ -288,11 +290,13 @@ final boolean doExecute() throws SQLServerException { try { executeCommand(new PreparedHandleClose()); } catch (SQLServerException e) { - loggerExternal.log(Level.FINER, this + ": Error (ignored) closing PreparedHandle:" + handleToClose, - e); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.log(Level.FINER, + this + ": Error (ignored) closing PreparedHandle:" + handleToClose, e); } - loggerExternal.finer(this + ": Closed PreparedHandle:" + handleToClose); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.finer(this + ": Closed PreparedHandle:" + handleToClose); } // Always run any outstanding discard actions as statement pooling always uses batched sp_unprepare. @@ -319,8 +323,9 @@ final void closeInternal() { if (null != internalStmt) internalStmt.close(); } catch (SQLServerException e) { - loggerExternal - .finer("Ignored error closing internal statement: " + e.getErrorCode() + " " + e.getMessage()); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal + .finer("Ignored error closing internal statement: " + e.getErrorCode() + " " + e.getMessage()); } finally { internalStmt = null; } @@ -422,7 +427,7 @@ private String buildParamTypeDefinitions(Parameter[] params, boolean renewDefini @Override public java.sql.ResultSet executeQuery() throws SQLServerException, SQLTimeoutException { loggerExternal.entering(getClassNameLogging(), "executeQuery"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -447,7 +452,7 @@ final java.sql.ResultSet executeQueryInternal() throws SQLServerException, SQLTi @Override public int executeUpdate() throws SQLServerException, SQLTimeoutException { loggerExternal.entering(getClassNameLogging(), "executeUpdate"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } @@ -469,7 +474,7 @@ public int executeUpdate() throws SQLServerException, SQLTimeoutException { public long executeLargeUpdate() throws SQLServerException, SQLTimeoutException { loggerExternal.entering(getClassNameLogging(), "executeLargeUpdate"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -481,7 +486,7 @@ public long executeLargeUpdate() throws SQLServerException, SQLTimeoutException @Override public boolean execute() throws SQLServerException, SQLTimeoutException { loggerExternal.entering(getClassNameLogging(), "execute"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -525,7 +530,7 @@ final void doExecutePreparedStatement(PrepStmtExecCmd command) throws SQLServerE // Note: similar logic in SQLServerStatement.doExecuteStatement setMaxRowsAndMaxFieldSize(); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } @@ -638,7 +643,8 @@ boolean onRetValue(TDSReader tdsReader) throws SQLServerException { } param.skipValue(tdsReader, true); - getStatementLogger().finer(toString() + ": Setting PreparedHandle:" + prepStmtHandle); + if (getStatementLogger().isLoggable(java.util.logging.Level.FINER)) + getStatementLogger().finer(toString() + ": Setting PreparedHandle:" + prepStmtHandle); return true; } @@ -669,8 +675,9 @@ void sendParamsByRPC(TDSWriter tdsWriter, Parameter[] params) throws SQLServerEx } private void buildServerCursorPrepExecParams(TDSWriter tdsWriter) throws SQLServerException { - getStatementLogger().fine(toString() + ": calling sp_cursorprepexec: PreparedHandle:" - + getPreparedStatementHandle() + ", SQL:" + preparedSQL); + if (getStatementLogger().isLoggable(java.util.logging.Level.FINE)) + getStatementLogger().fine(toString() + ": calling sp_cursorprepexec: PreparedHandle:" + + getPreparedStatementHandle() + ", SQL:" + preparedSQL); expectPrepStmtHandle = true; executedSqlDirectly = false; @@ -711,8 +718,9 @@ private void buildServerCursorPrepExecParams(TDSWriter tdsWriter) throws SQLServ } private void buildPrepExecParams(TDSWriter tdsWriter) throws SQLServerException { - getStatementLogger().fine(toString() + ": calling sp_prepexec: PreparedHandle:" + getPreparedStatementHandle() - + ", SQL:" + preparedSQL); + if (getStatementLogger().isLoggable(java.util.logging.Level.FINE)) + getStatementLogger().fine(toString() + ": calling sp_prepexec: PreparedHandle:" + + getPreparedStatementHandle() + ", SQL:" + preparedSQL); expectPrepStmtHandle = true; executedSqlDirectly = true; @@ -738,7 +746,8 @@ private void buildPrepExecParams(TDSWriter tdsWriter) throws SQLServerException } private void buildExecSQLParams(TDSWriter tdsWriter) throws SQLServerException { - getStatementLogger().fine(toString() + ": calling sp_executesql: SQL:" + preparedSQL); + if (getStatementLogger().isLoggable(java.util.logging.Level.FINE)) + getStatementLogger().fine(toString() + ": calling sp_executesql: SQL:" + preparedSQL); expectPrepStmtHandle = false; executedSqlDirectly = true; @@ -762,8 +771,9 @@ private void buildExecSQLParams(TDSWriter tdsWriter) throws SQLServerException { } private void buildServerCursorExecParams(TDSWriter tdsWriter) throws SQLServerException { - getStatementLogger().fine(toString() + ": calling sp_cursorexecute: PreparedHandle:" - + getPreparedStatementHandle() + ", SQL:" + preparedSQL); + if (getStatementLogger().isLoggable(java.util.logging.Level.FINE)) + getStatementLogger().fine(toString() + ": calling sp_cursorexecute: PreparedHandle:" + + getPreparedStatementHandle() + ", SQL:" + preparedSQL); expectPrepStmtHandle = false; executedSqlDirectly = false; @@ -793,8 +803,9 @@ private void buildServerCursorExecParams(TDSWriter tdsWriter) throws SQLServerEx } private void buildExecParams(TDSWriter tdsWriter) throws SQLServerException { - getStatementLogger().fine(toString() + ": calling sp_execute: PreparedHandle:" + getPreparedStatementHandle() - + ", SQL:" + preparedSQL); + if (getStatementLogger().isLoggable(java.util.logging.Level.FINE)) + getStatementLogger().fine(toString() + ": calling sp_execute: PreparedHandle:" + + getPreparedStatementHandle() + ", SQL:" + preparedSQL); expectPrepStmtHandle = false; executedSqlDirectly = true; @@ -823,8 +834,10 @@ private void getParameterEncryptionMetadata(Parameter[] params) throws SQLServer assert connection != null : "Connection should not be null"; try { - getStatementLogger().fine( - "Calling stored procedure sp_describe_parameter_encryption to get parameter encryption information."); + if (getStatementLogger().isLoggable(java.util.logging.Level.FINE)) { + getStatementLogger().fine( + "Calling stored procedure sp_describe_parameter_encryption to get parameter encryption information."); + } stmt = (SQLServerCallableStatement) connection.prepareCall("exec sp_describe_parameter_encryption ?,?"); stmt.isInternalEncryptionQuery = true; @@ -866,7 +879,9 @@ private void getParameterEncryptionMetadata(Parameter[] params) throws SQLServer rs.getString(DescribeParameterEncryptionResultSet1.ProviderName.value()), rs.getString(DescribeParameterEncryptionResultSet1.KeyEncryptionAlgorithm.value())); } - getStatementLogger().fine("Matadata of CEKs is retrieved."); + if (getStatementLogger().isLoggable(java.util.logging.Level.FINE)) { + getStatementLogger().fine("Matadata of CEKs is retrieved."); + } } catch (SQLException e) { if (e instanceof SQLServerException) { throw (SQLServerException) e; @@ -918,7 +933,9 @@ private void getParameterEncryptionMetadata(Parameter[] params) throws SQLServer } } } - getStatementLogger().fine("Parameter encryption metadata is set."); + if (getStatementLogger().isLoggable(java.util.logging.Level.FINE)) { + getStatementLogger().fine("Parameter encryption metadata is set."); + } } catch (SQLException e) { if (e instanceof SQLServerException) { throw (SQLServerException) e; @@ -1135,7 +1152,8 @@ final void setSQLXMLInternal(int parameterIndex, SQLXML value) throws SQLServerE @Override public final void setAsciiStream(int parameterIndex, InputStream x) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterIndex, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterIndex, x}); checkClosed(); setStream(parameterIndex, StreamType.ASCII, x, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); @@ -1143,7 +1161,8 @@ public final void setAsciiStream(int parameterIndex, InputStream x) throws SQLEx @Override public final void setAsciiStream(int n, java.io.InputStream x, int length) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {n, x, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {n, x, length}); checkClosed(); setStream(n, StreamType.ASCII, x, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); @@ -1151,7 +1170,8 @@ public final void setAsciiStream(int n, java.io.InputStream x, int length) throw @Override public final void setAsciiStream(int parameterIndex, InputStream x, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterIndex, x, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setAsciiStream", new Object[] {parameterIndex, x, length}); checkClosed(); setStream(parameterIndex, StreamType.ASCII, x, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setAsciiStream"); @@ -1159,7 +1179,8 @@ public final void setAsciiStream(int parameterIndex, InputStream x, long length) @Override public final void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterIndex, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBigDecimal", new Object[] {parameterIndex, x}); checkClosed(); setValue(parameterIndex, JDBCType.DECIMAL, x, JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); @@ -1168,8 +1189,9 @@ public final void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLServ @Override public final void setBigDecimal(int parameterIndex, BigDecimal x, int precision, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setBigDecimal", - new Object[] {parameterIndex, x, precision, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBigDecimal", + new Object[] {parameterIndex, x, precision, scale}); checkClosed(); setValue(parameterIndex, JDBCType.DECIMAL, x, JavaType.BIGDECIMAL, precision, scale, false); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); @@ -1178,8 +1200,9 @@ public final void setBigDecimal(int parameterIndex, BigDecimal x, int precision, @Override public final void setBigDecimal(int parameterIndex, BigDecimal x, int precision, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setBigDecimal", - new Object[] {parameterIndex, x, precision, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBigDecimal", + new Object[] {parameterIndex, x, precision, scale, forceEncrypt}); checkClosed(); setValue(parameterIndex, JDBCType.DECIMAL, x, JavaType.BIGDECIMAL, precision, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBigDecimal"); @@ -1187,7 +1210,8 @@ public final void setBigDecimal(int parameterIndex, BigDecimal x, int precision, @Override public final void setMoney(int n, BigDecimal x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setMoney", new Object[] {n, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setMoney", new Object[] {n, x}); checkClosed(); setValue(n, JDBCType.MONEY, x, JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setMoney"); @@ -1195,7 +1219,8 @@ public final void setMoney(int n, BigDecimal x) throws SQLServerException { @Override public final void setMoney(int n, BigDecimal x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setMoney", new Object[] {n, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setMoney", new Object[] {n, x, forceEncrypt}); checkClosed(); setValue(n, JDBCType.MONEY, x, JavaType.BIGDECIMAL, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setMoney"); @@ -1203,7 +1228,8 @@ public final void setMoney(int n, BigDecimal x, boolean forceEncrypt) throws SQL @Override public final void setSmallMoney(int n, BigDecimal x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setSmallMoney", new Object[] {n, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setSmallMoney", new Object[] {n, x}); checkClosed(); setValue(n, JDBCType.SMALLMONEY, x, JavaType.BIGDECIMAL, false); loggerExternal.exiting(getClassNameLogging(), "setSmallMoney"); @@ -1211,7 +1237,8 @@ public final void setSmallMoney(int n, BigDecimal x) throws SQLServerException { @Override public final void setSmallMoney(int n, BigDecimal x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setSmallMoney", new Object[] {n, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setSmallMoney", new Object[] {n, x, forceEncrypt}); checkClosed(); setValue(n, JDBCType.SMALLMONEY, x, JavaType.BIGDECIMAL, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setSmallMoney"); @@ -1219,7 +1246,8 @@ public final void setSmallMoney(int n, BigDecimal x, boolean forceEncrypt) throw @Override public final void setBinaryStream(int parameterIndex, InputStream x) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setBinaryStreaml", new Object[] {parameterIndex, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBinaryStreaml", new Object[] {parameterIndex, x}); checkClosed(); setStream(parameterIndex, StreamType.BINARY, x, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); @@ -1227,7 +1255,8 @@ public final void setBinaryStream(int parameterIndex, InputStream x) throws SQLE @Override public final void setBinaryStream(int n, java.io.InputStream x, int length) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {n, x, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {n, x, length}); checkClosed(); setStream(n, StreamType.BINARY, x, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); @@ -1235,7 +1264,8 @@ public final void setBinaryStream(int n, java.io.InputStream x, int length) thro @Override public final void setBinaryStream(int parameterIndex, InputStream x, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterIndex, x, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBinaryStream", new Object[] {parameterIndex, x, length}); checkClosed(); setStream(parameterIndex, StreamType.BINARY, x, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBinaryStream"); @@ -1243,7 +1273,8 @@ public final void setBinaryStream(int parameterIndex, InputStream x, long length @Override public final void setBoolean(int n, boolean x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setBoolean", new Object[] {n, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBoolean", new Object[] {n, x}); checkClosed(); setValue(n, JDBCType.BIT, x, JavaType.BOOLEAN, false); loggerExternal.exiting(getClassNameLogging(), "setBoolean"); @@ -1251,7 +1282,8 @@ public final void setBoolean(int n, boolean x) throws SQLServerException { @Override public final void setBoolean(int n, boolean x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setBoolean", new Object[] {n, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBoolean", new Object[] {n, x, forceEncrypt}); checkClosed(); setValue(n, JDBCType.BIT, x, JavaType.BOOLEAN, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBoolean"); @@ -1259,7 +1291,8 @@ public final void setBoolean(int n, boolean x, boolean forceEncrypt) throws SQLS @Override public final void setByte(int n, byte x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setByte", new Object[] {n, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setByte", new Object[] {n, x}); checkClosed(); setValue(n, JDBCType.TINYINT, x, JavaType.BYTE, false); loggerExternal.exiting(getClassNameLogging(), "setByte"); @@ -1267,7 +1300,8 @@ public final void setByte(int n, byte x) throws SQLServerException { @Override public final void setByte(int n, byte x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setByte", new Object[] {n, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setByte", new Object[] {n, x, forceEncrypt}); checkClosed(); setValue(n, JDBCType.TINYINT, x, JavaType.BYTE, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setByte"); @@ -1275,7 +1309,8 @@ public final void setByte(int n, byte x, boolean forceEncrypt) throws SQLServerE @Override public final void setBytes(int n, byte x[]) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setBytes", new Object[] {n, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBytes", new Object[] {n, x}); checkClosed(); setValue(n, JDBCType.BINARY, x, JavaType.BYTEARRAY, false); loggerExternal.exiting(getClassNameLogging(), "setBytes"); @@ -1283,7 +1318,8 @@ public final void setBytes(int n, byte x[]) throws SQLServerException { @Override public final void setBytes(int n, byte x[], boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setBytes", new Object[] {n, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBytes", new Object[] {n, x, forceEncrypt}); checkClosed(); setValue(n, JDBCType.BINARY, x, JavaType.BYTEARRAY, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setBytes"); @@ -1291,7 +1327,8 @@ public final void setBytes(int n, byte x[], boolean forceEncrypt) throws SQLServ @Override public final void setUniqueIdentifier(int index, String guid) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", new Object[] {index, guid}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", new Object[] {index, guid}); checkClosed(); setValue(index, JDBCType.GUID, guid, JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setUniqueIdentifier"); @@ -1299,7 +1336,9 @@ public final void setUniqueIdentifier(int index, String guid) throws SQLServerEx @Override public final void setUniqueIdentifier(int index, String guid, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", new Object[] {index, guid, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setUniqueIdentifier", + new Object[] {index, guid, forceEncrypt}); checkClosed(); setValue(index, JDBCType.GUID, guid, JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setUniqueIdentifier"); @@ -1307,7 +1346,8 @@ public final void setUniqueIdentifier(int index, String guid, boolean forceEncry @Override public final void setDouble(int n, double x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDouble", new Object[] {n, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDouble", new Object[] {n, x}); checkClosed(); setValue(n, JDBCType.DOUBLE, x, JavaType.DOUBLE, false); loggerExternal.exiting(getClassNameLogging(), "setDouble"); @@ -1315,7 +1355,8 @@ public final void setDouble(int n, double x) throws SQLServerException { @Override public final void setDouble(int n, double x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDouble", new Object[] {n, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDouble", new Object[] {n, x, forceEncrypt}); checkClosed(); setValue(n, JDBCType.DOUBLE, x, JavaType.DOUBLE, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDouble"); @@ -1323,7 +1364,8 @@ public final void setDouble(int n, double x, boolean forceEncrypt) throws SQLSer @Override public final void setFloat(int n, float x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setFloat", new Object[] {n, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setFloat", new Object[] {n, x}); checkClosed(); setValue(n, JDBCType.REAL, x, JavaType.FLOAT, false); loggerExternal.exiting(getClassNameLogging(), "setFloat"); @@ -1331,7 +1373,8 @@ public final void setFloat(int n, float x) throws SQLServerException { @Override public final void setFloat(int n, float x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setFloat", new Object[] {n, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setFloat", new Object[] {n, x, forceEncrypt}); checkClosed(); setValue(n, JDBCType.REAL, x, JavaType.FLOAT, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setFloat"); @@ -1339,7 +1382,8 @@ public final void setFloat(int n, float x, boolean forceEncrypt) throws SQLServe @Override public final void setGeometry(int n, Geometry x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setGeometry", new Object[] {n, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setGeometry", new Object[] {n, x}); checkClosed(); setValue(n, JDBCType.GEOMETRY, x, JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setGeometry"); @@ -1347,7 +1391,8 @@ public final void setGeometry(int n, Geometry x) throws SQLServerException { @Override public final void setGeography(int n, Geography x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setGeography", new Object[] {n, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setGeography", new Object[] {n, x}); checkClosed(); setValue(n, JDBCType.GEOGRAPHY, x, JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setGeography"); @@ -1355,7 +1400,8 @@ public final void setGeography(int n, Geography x) throws SQLServerException { @Override public final void setInt(int n, int value) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {n, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {n, value}); checkClosed(); setValue(n, JDBCType.INTEGER, value, JavaType.INTEGER, false); loggerExternal.exiting(getClassNameLogging(), "setInt"); @@ -1363,7 +1409,8 @@ public final void setInt(int n, int value) throws SQLServerException { @Override public final void setInt(int n, int value, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {n, value, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setInt", new Object[] {n, value, forceEncrypt}); checkClosed(); setValue(n, JDBCType.INTEGER, value, JavaType.INTEGER, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setInt"); @@ -1371,7 +1418,8 @@ public final void setInt(int n, int value, boolean forceEncrypt) throws SQLServe @Override public final void setLong(int n, long x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setLong", new Object[] {n, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setLong", new Object[] {n, x}); checkClosed(); setValue(n, JDBCType.BIGINT, x, JavaType.LONG, false); loggerExternal.exiting(getClassNameLogging(), "setLong"); @@ -1379,7 +1427,8 @@ public final void setLong(int n, long x) throws SQLServerException { @Override public final void setLong(int n, long x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setLong", new Object[] {n, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setLong", new Object[] {n, x, forceEncrypt}); checkClosed(); setValue(n, JDBCType.BIGINT, x, JavaType.LONG, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setLong"); @@ -1387,7 +1436,8 @@ public final void setLong(int n, long x, boolean forceEncrypt) throws SQLServerE @Override public final void setNull(int index, int jdbcType) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {index, jdbcType}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {index, jdbcType}); checkClosed(); setObject(setterGetParam(index), null, JavaType.OBJECT, JDBCType.of(jdbcType), null, null, false, index, null); loggerExternal.exiting(getClassNameLogging(), "setNull"); @@ -1432,7 +1482,8 @@ final void setObjectNoType(int index, Object obj, boolean forceEncrypt) throws S @Override public final void setObject(int index, Object obj) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {index, obj}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {index, obj}); checkClosed(); setObjectNoType(index, obj, false); loggerExternal.exiting(getClassNameLogging(), "setObject"); @@ -1441,7 +1492,8 @@ public final void setObject(int index, Object obj) throws SQLServerException { @Override public final void setObject(int n, Object obj, int jdbcType) throws SQLServerException { String tvpName = null; - loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {n, obj, jdbcType}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setObject", new Object[] {n, obj, jdbcType}); checkClosed(); if (microsoft.sql.Types.STRUCTURED == jdbcType) tvpName = getTVPNameIfNull(n, null); @@ -1452,8 +1504,9 @@ public final void setObject(int n, Object obj, int jdbcType) throws SQLServerExc @Override public final void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setObject", - new Object[] {parameterIndex, x, targetSqlType, scaleOrLength}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setObject", + new Object[] {parameterIndex, x, targetSqlType, scaleOrLength}); checkClosed(); // scaleOrLength - for java.sql.Types.DECIMAL, java.sql.Types.NUMERIC or temporal types, @@ -1474,8 +1527,9 @@ public final void setObject(int parameterIndex, Object x, int targetSqlType, @Override public final void setObject(int parameterIndex, Object x, int targetSqlType, Integer precision, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setObject", - new Object[] {parameterIndex, x, targetSqlType, precision, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setObject", + new Object[] {parameterIndex, x, targetSqlType, precision, scale}); checkClosed(); // scale - for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types, @@ -1494,8 +1548,9 @@ public final void setObject(int parameterIndex, Object x, int targetSqlType, Int @Override public final void setObject(int parameterIndex, Object x, int targetSqlType, Integer precision, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setObject", - new Object[] {parameterIndex, x, targetSqlType, precision, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setObject", + new Object[] {parameterIndex, x, targetSqlType, precision, scale, forceEncrypt}); checkClosed(); // scale - for java.sql.Types.DECIMAL or java.sql.Types.NUMERIC types, @@ -1590,7 +1645,8 @@ public final void setObject(int parameterIndex, Object x, SQLType targetSqlType, @Override public final void setShort(int index, short x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setShort", new Object[] {index, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setShort", new Object[] {index, x}); checkClosed(); setValue(index, JDBCType.SMALLINT, x, JavaType.SHORT, false); loggerExternal.exiting(getClassNameLogging(), "setShort"); @@ -1598,7 +1654,8 @@ public final void setShort(int index, short x) throws SQLServerException { @Override public final void setShort(int index, short x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setShort", new Object[] {index, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setShort", new Object[] {index, x, forceEncrypt}); checkClosed(); setValue(index, JDBCType.SMALLINT, x, JavaType.SHORT, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setShort"); @@ -1606,7 +1663,8 @@ public final void setShort(int index, short x, boolean forceEncrypt) throws SQLS @Override public final void setString(int index, String str) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setString", new Object[] {index, str}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setString", new Object[] {index, str}); checkClosed(); setValue(index, JDBCType.VARCHAR, str, JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setString"); @@ -1614,7 +1672,8 @@ public final void setString(int index, String str) throws SQLServerException { @Override public final void setString(int index, String str, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setString", new Object[] {index, str, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setString", new Object[] {index, str, forceEncrypt}); checkClosed(); setValue(index, JDBCType.VARCHAR, str, JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setString"); @@ -1622,7 +1681,8 @@ public final void setString(int index, String str, boolean forceEncrypt) throws @Override public final void setNString(int parameterIndex, String value) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setNString", new Object[] {parameterIndex, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setNString", new Object[] {parameterIndex, value}); checkClosed(); setValue(parameterIndex, JDBCType.NVARCHAR, value, JavaType.STRING, false); loggerExternal.exiting(getClassNameLogging(), "setNString"); @@ -1630,8 +1690,9 @@ public final void setNString(int parameterIndex, String value) throws SQLExcepti @Override public final void setNString(int parameterIndex, String value, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setNString", - new Object[] {parameterIndex, value, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setNString", + new Object[] {parameterIndex, value, forceEncrypt}); checkClosed(); setValue(parameterIndex, JDBCType.NVARCHAR, value, JavaType.STRING, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setNString"); @@ -1639,7 +1700,8 @@ public final void setNString(int parameterIndex, String value, boolean forceEncr @Override public final void setTime(int n, java.sql.Time x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {n, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {n, x}); checkClosed(); setValue(n, JDBCType.TIME, x, JavaType.TIME, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); @@ -1647,7 +1709,8 @@ public final void setTime(int n, java.sql.Time x) throws SQLServerException { @Override public final void setTime(int n, java.sql.Time x, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {n, x, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {n, x, scale}); checkClosed(); setValue(n, JDBCType.TIME, x, JavaType.TIME, null, scale, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); @@ -1655,7 +1718,8 @@ public final void setTime(int n, java.sql.Time x, int scale) throws SQLServerExc @Override public final void setTime(int n, java.sql.Time x, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {n, x, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {n, x, scale, forceEncrypt}); checkClosed(); setValue(n, JDBCType.TIME, x, JavaType.TIME, null, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTime"); @@ -1663,7 +1727,8 @@ public final void setTime(int n, java.sql.Time x, int scale, boolean forceEncryp @Override public final void setTimestamp(int n, java.sql.Timestamp x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {n, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {n, x}); checkClosed(); setValue(n, JDBCType.TIMESTAMP, x, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); @@ -1671,7 +1736,8 @@ public final void setTimestamp(int n, java.sql.Timestamp x) throws SQLServerExce @Override public final void setTimestamp(int n, java.sql.Timestamp x, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {n, x, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {n, x, scale}); checkClosed(); setValue(n, JDBCType.TIMESTAMP, x, JavaType.TIMESTAMP, null, scale, false); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); @@ -1680,7 +1746,8 @@ public final void setTimestamp(int n, java.sql.Timestamp x, int scale) throws SQ @Override public final void setTimestamp(int n, java.sql.Timestamp x, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {n, x, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {n, x, scale, forceEncrypt}); checkClosed(); setValue(n, JDBCType.TIMESTAMP, x, JavaType.TIMESTAMP, null, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); @@ -1688,7 +1755,8 @@ public final void setTimestamp(int n, java.sql.Timestamp x, int scale, @Override public final void setDateTimeOffset(int n, microsoft.sql.DateTimeOffset x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {n, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {n, x}); checkClosed(); setValue(n, JDBCType.DATETIMEOFFSET, x, JavaType.DATETIMEOFFSET, false); loggerExternal.exiting(getClassNameLogging(), "setDateTimeOffset"); @@ -1696,7 +1764,8 @@ public final void setDateTimeOffset(int n, microsoft.sql.DateTimeOffset x) throw @Override public final void setDateTimeOffset(int n, microsoft.sql.DateTimeOffset x, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {n, x, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {n, x, scale}); checkClosed(); setValue(n, JDBCType.DATETIMEOFFSET, x, JavaType.DATETIMEOFFSET, null, scale, false); loggerExternal.exiting(getClassNameLogging(), "setDateTimeOffset"); @@ -1705,7 +1774,9 @@ public final void setDateTimeOffset(int n, microsoft.sql.DateTimeOffset x, int s @Override public final void setDateTimeOffset(int n, microsoft.sql.DateTimeOffset x, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", new Object[] {n, x, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDateTimeOffset", + new Object[] {n, x, scale, forceEncrypt}); checkClosed(); setValue(n, JDBCType.DATETIMEOFFSET, x, JavaType.DATETIMEOFFSET, null, scale, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDateTimeOffset"); @@ -1713,7 +1784,8 @@ public final void setDateTimeOffset(int n, microsoft.sql.DateTimeOffset x, int s @Override public final void setDate(int n, java.sql.Date x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {n, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {n, x}); checkClosed(); setValue(n, JDBCType.DATE, x, JavaType.DATE, false); loggerExternal.exiting(getClassNameLogging(), "setDate"); @@ -1721,7 +1793,8 @@ public final void setDate(int n, java.sql.Date x) throws SQLServerException { @Override public final void setDateTime(int n, java.sql.Timestamp x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDateTime", new Object[] {n, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDateTime", new Object[] {n, x}); checkClosed(); setValue(n, JDBCType.DATETIME, x, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setDateTime"); @@ -1729,7 +1802,8 @@ public final void setDateTime(int n, java.sql.Timestamp x) throws SQLServerExcep @Override public final void setDateTime(int n, java.sql.Timestamp x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDateTime", new Object[] {n, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDateTime", new Object[] {n, x, forceEncrypt}); checkClosed(); setValue(n, JDBCType.DATETIME, x, JavaType.TIMESTAMP, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDateTime"); @@ -1737,7 +1811,8 @@ public final void setDateTime(int n, java.sql.Timestamp x, boolean forceEncrypt) @Override public final void setSmallDateTime(int n, java.sql.Timestamp x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", new Object[] {n, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", new Object[] {n, x}); checkClosed(); setValue(n, JDBCType.SMALLDATETIME, x, JavaType.TIMESTAMP, false); loggerExternal.exiting(getClassNameLogging(), "setSmallDateTime"); @@ -1745,7 +1820,8 @@ public final void setSmallDateTime(int n, java.sql.Timestamp x) throws SQLServer @Override public final void setSmallDateTime(int n, java.sql.Timestamp x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", new Object[] {n, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setSmallDateTime", new Object[] {n, x, forceEncrypt}); checkClosed(); setValue(n, JDBCType.SMALLDATETIME, x, JavaType.TIMESTAMP, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setSmallDateTime"); @@ -1754,7 +1830,8 @@ public final void setSmallDateTime(int n, java.sql.Timestamp x, boolean forceEnc @Override public final void setStructured(int n, String tvpName, SQLServerDataTable tvpDataTable) throws SQLServerException { tvpName = getTVPNameIfNull(n, tvpName); - loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {n, tvpName, tvpDataTable}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {n, tvpName, tvpDataTable}); checkClosed(); setValue(n, JDBCType.TVP, tvpDataTable, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); @@ -1763,7 +1840,8 @@ public final void setStructured(int n, String tvpName, SQLServerDataTable tvpDat @Override public final void setStructured(int n, String tvpName, ResultSet tvpResultSet) throws SQLServerException { tvpName = getTVPNameIfNull(n, tvpName); - loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {n, tvpName, tvpResultSet}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {n, tvpName, tvpResultSet}); checkClosed(); setValue(n, JDBCType.TVP, tvpResultSet, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); @@ -1773,7 +1851,8 @@ public final void setStructured(int n, String tvpName, ResultSet tvpResultSet) t public final void setStructured(int n, String tvpName, ISQLServerDataRecord tvpBulkRecord) throws SQLServerException { tvpName = getTVPNameIfNull(n, tvpName); - loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {n, tvpName, tvpBulkRecord}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setStructured", new Object[] {n, tvpName, tvpBulkRecord}); checkClosed(); setValue(n, JDBCType.TVP, tvpBulkRecord, JavaType.TVP, tvpName); loggerExternal.exiting(getClassNameLogging(), "setStructured"); @@ -1845,7 +1924,7 @@ public final void clearBatch() throws SQLServerException { @Override public int[] executeBatch() throws SQLServerException, BatchUpdateException, SQLTimeoutException { loggerExternal.entering(getClassNameLogging(), "executeBatch"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -1947,8 +2026,10 @@ public int[] executeBatch() throws SQLServerException, BatchUpdateException, SQL throw new BatchUpdateException(e.getMessage(), null, 0, null); } catch (IllegalArgumentException e) { // If we fail with IllegalArgumentException, fall back to the original batch insert logic. - getStatementLogger().fine("Parsing user's Batch Insert SQL Query failed: " + e.getMessage()); - getStatementLogger().fine("Falling back to the original implementation for Batch Insert."); + if (getStatementLogger().isLoggable(java.util.logging.Level.FINE)) { + getStatementLogger().fine("Parsing user's Batch Insert SQL Query failed: " + e.getMessage()); + getStatementLogger().fine("Falling back to the original implementation for Batch Insert."); + } } if (batchParamValues == null) @@ -2000,7 +2081,7 @@ public int[] executeBatch() throws SQLServerException, BatchUpdateException, SQL @Override public long[] executeLargeBatch() throws SQLServerException, BatchUpdateException, SQLTimeoutException { loggerExternal.entering(getClassNameLogging(), "executeLargeBatch"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -2102,8 +2183,10 @@ public long[] executeLargeBatch() throws SQLServerException, BatchUpdateExceptio throw new BatchUpdateException(e.getMessage(), null, 0, null); } catch (IllegalArgumentException e) { // If we fail with IllegalArgumentException, fall back to the original batch insert logic. - getStatementLogger().fine("Parsing user's Batch Insert SQL Query failed: " + e.getMessage()); - getStatementLogger().fine("Falling back to the original implementation for Batch Insert."); + if (getStatementLogger().isLoggable(java.util.logging.Level.FINE)) { + getStatementLogger().fine("Parsing user's Batch Insert SQL Query failed: " + e.getMessage()); + getStatementLogger().fine("Falling back to the original implementation for Batch Insert."); + } } if (batchParamValues == null) @@ -2594,7 +2677,7 @@ final void doExecutePreparedStatementBatch(PrepStmtBatchExecCmd batchCommand) th // Make sure any previous maxRows limitation on the connection is removed. connection.setMaxRows(0); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } // Create the parameter array that we'll use for all the items in this batch. @@ -2759,7 +2842,8 @@ final void doExecutePreparedStatementBatch(PrepStmtBatchExecCmd batchCommand) th @Override public final void setCharacterStream(int parameterIndex, Reader reader) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {parameterIndex, reader}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {parameterIndex, reader}); checkClosed(); setStream(parameterIndex, StreamType.CHARACTER, reader, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setCharacterStream"); @@ -2767,7 +2851,8 @@ public final void setCharacterStream(int parameterIndex, Reader reader) throws S @Override public final void setCharacterStream(int n, java.io.Reader reader, int length) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {n, reader, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setCharacterStream", new Object[] {n, reader, length}); checkClosed(); setStream(n, StreamType.CHARACTER, reader, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setCharacterStream"); @@ -2775,8 +2860,9 @@ public final void setCharacterStream(int n, java.io.Reader reader, int length) t @Override public final void setCharacterStream(int parameterIndex, Reader reader, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setCharacterStream", - new Object[] {parameterIndex, reader, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setCharacterStream", + new Object[] {parameterIndex, reader, length}); checkClosed(); setStream(parameterIndex, StreamType.CHARACTER, reader, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setCharacterStream"); @@ -2784,7 +2870,8 @@ public final void setCharacterStream(int parameterIndex, Reader reader, long len @Override public final void setNCharacterStream(int parameterIndex, Reader value) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setNCharacterStream", new Object[] {parameterIndex, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setNCharacterStream", new Object[] {parameterIndex, value}); checkClosed(); setStream(parameterIndex, StreamType.NCHARACTER, value, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setNCharacterStream"); @@ -2792,8 +2879,9 @@ public final void setNCharacterStream(int parameterIndex, Reader value) throws S @Override public final void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setNCharacterStream", - new Object[] {parameterIndex, value, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setNCharacterStream", + new Object[] {parameterIndex, value, length}); checkClosed(); setStream(parameterIndex, StreamType.NCHARACTER, value, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setNCharacterStream"); @@ -2806,7 +2894,8 @@ public final void setRef(int i, java.sql.Ref x) throws SQLException { @Override public final void setBlob(int i, java.sql.Blob x) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {i, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {i, x}); checkClosed(); setValue(i, JDBCType.BLOB, x, JavaType.BLOB, false); loggerExternal.exiting(getClassNameLogging(), "setBlob"); @@ -2814,7 +2903,8 @@ public final void setBlob(int i, java.sql.Blob x) throws SQLException { @Override public final void setBlob(int parameterIndex, InputStream inputStream) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterIndex, inputStream}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterIndex, inputStream}); checkClosed(); setStream(parameterIndex, StreamType.BINARY, inputStream, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); @@ -2823,7 +2913,9 @@ public final void setBlob(int parameterIndex, InputStream inputStream) throws SQ @Override public final void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setBlob", new Object[] {parameterIndex, inputStream, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setBlob", + new Object[] {parameterIndex, inputStream, length}); checkClosed(); setStream(parameterIndex, StreamType.BINARY, inputStream, JavaType.INPUTSTREAM, length); loggerExternal.exiting(getClassNameLogging(), "setBlob"); @@ -2831,7 +2923,8 @@ public final void setBlob(int parameterIndex, InputStream inputStream, long leng @Override public final void setClob(int parameterIndex, java.sql.Clob clobValue) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterIndex, clobValue}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterIndex, clobValue}); checkClosed(); setValue(parameterIndex, JDBCType.CLOB, clobValue, JavaType.CLOB, false); loggerExternal.exiting(getClassNameLogging(), "setClob"); @@ -2839,7 +2932,8 @@ public final void setClob(int parameterIndex, java.sql.Clob clobValue) throws SQ @Override public final void setClob(int parameterIndex, Reader reader) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterIndex, reader}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterIndex, reader}); checkClosed(); setStream(parameterIndex, StreamType.CHARACTER, reader, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setClob"); @@ -2847,7 +2941,8 @@ public final void setClob(int parameterIndex, Reader reader) throws SQLException @Override public final void setClob(int parameterIndex, Reader reader, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterIndex, reader, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setClob", new Object[] {parameterIndex, reader, length}); checkClosed(); setStream(parameterIndex, StreamType.CHARACTER, reader, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setClob"); @@ -2855,7 +2950,8 @@ public final void setClob(int parameterIndex, Reader reader, long length) throws @Override public final void setNClob(int parameterIndex, NClob value) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterIndex, value}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterIndex, value}); checkClosed(); setValue(parameterIndex, JDBCType.NCLOB, value, JavaType.NCLOB, false); loggerExternal.exiting(getClassNameLogging(), "setNClob"); @@ -2863,7 +2959,8 @@ public final void setNClob(int parameterIndex, NClob value) throws SQLException @Override public final void setNClob(int parameterIndex, Reader reader) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterIndex, reader}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterIndex, reader}); checkClosed(); setStream(parameterIndex, StreamType.NCHARACTER, reader, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); loggerExternal.exiting(getClassNameLogging(), "setNClob"); @@ -2871,7 +2968,8 @@ public final void setNClob(int parameterIndex, Reader reader) throws SQLExceptio @Override public final void setNClob(int parameterIndex, Reader reader, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterIndex, reader, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setNClob", new Object[] {parameterIndex, reader, length}); checkClosed(); setStream(parameterIndex, StreamType.NCHARACTER, reader, JavaType.READER, length); loggerExternal.exiting(getClassNameLogging(), "setNClob"); @@ -2884,7 +2982,8 @@ public final void setArray(int i, java.sql.Array x) throws SQLException { @Override public final void setDate(int n, java.sql.Date x, java.util.Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {n, x, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {n, x, cal}); checkClosed(); setValue(n, JDBCType.DATE, x, JavaType.DATE, cal, false); loggerExternal.exiting(getClassNameLogging(), "setDate"); @@ -2893,7 +2992,8 @@ public final void setDate(int n, java.sql.Date x, java.util.Calendar cal) throws @Override public final void setDate(int n, java.sql.Date x, java.util.Calendar cal, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {n, x, cal, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setDate", new Object[] {n, x, cal, forceEncrypt}); checkClosed(); setValue(n, JDBCType.DATE, x, JavaType.DATE, cal, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setDate"); @@ -2901,7 +3001,8 @@ public final void setDate(int n, java.sql.Date x, java.util.Calendar cal, @Override public final void setTime(int n, java.sql.Time x, java.util.Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {n, x, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {n, x, cal}); checkClosed(); setValue(n, JDBCType.TIME, x, JavaType.TIME, cal, false); loggerExternal.exiting(getClassNameLogging(), "setTime"); @@ -2910,7 +3011,8 @@ public final void setTime(int n, java.sql.Time x, java.util.Calendar cal) throws @Override public final void setTime(int n, java.sql.Time x, java.util.Calendar cal, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {n, x, cal, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTime", new Object[] {n, x, cal, forceEncrypt}); checkClosed(); setValue(n, JDBCType.TIME, x, JavaType.TIME, cal, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTime"); @@ -2918,7 +3020,8 @@ public final void setTime(int n, java.sql.Time x, java.util.Calendar cal, @Override public final void setTimestamp(int n, java.sql.Timestamp x, java.util.Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {n, x, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {n, x, cal}); checkClosed(); setValue(n, JDBCType.TIMESTAMP, x, JavaType.TIMESTAMP, cal, false); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); @@ -2927,7 +3030,8 @@ public final void setTimestamp(int n, java.sql.Timestamp x, java.util.Calendar c @Override public final void setTimestamp(int n, java.sql.Timestamp x, java.util.Calendar cal, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {n, x, cal, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setTimestamp", new Object[] {n, x, cal, forceEncrypt}); checkClosed(); setValue(n, JDBCType.TIMESTAMP, x, JavaType.TIMESTAMP, cal, forceEncrypt); loggerExternal.exiting(getClassNameLogging(), "setTimestamp"); @@ -2935,7 +3039,8 @@ public final void setTimestamp(int n, java.sql.Timestamp x, java.util.Calendar c @Override public final void setNull(int paramIndex, int sqlType, String typeName) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {paramIndex, sqlType, typeName}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setNull", new Object[] {paramIndex, sqlType, typeName}); checkClosed(); if (microsoft.sql.Types.STRUCTURED == sqlType) { setObject(setterGetParam(paramIndex), null, JavaType.TVP, JDBCType.of(sqlType), null, null, false, @@ -2983,7 +3088,8 @@ public final void setRowId(int parameterIndex, RowId x) throws SQLException { @Override public final void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "setSQLXML", new Object[] {parameterIndex, xmlObject}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setSQLXML", new Object[] {parameterIndex, xmlObject}); checkClosed(); setSQLXMLInternal(parameterIndex, xmlObject); loggerExternal.exiting(getClassNameLogging(), "setSQLXML"); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResultSet.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResultSet.java index ee5b363f24..8a6e3391c9 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResultSet.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResultSet.java @@ -27,6 +27,7 @@ import java.util.Calendar; import java.util.UUID; import java.util.concurrent.atomic.AtomicInteger; +import java.util.logging.Level; import com.microsoft.sqlserver.jdbc.dataclassification.SensitivityClassification; @@ -404,7 +405,9 @@ boolean onDone(TDSReader tdsReader) throws SQLServerException { // increment opened resultset counter stmtIn.incrResultSetCount(); - logger.fine(toString() + " created by (" + stmt.toString() + ")"); + if (logger.isLoggable(java.util.logging.Level.FINE)) { + logger.fine(toString() + " created by (" + stmt.toString() + ")"); + } } @Override @@ -620,7 +623,7 @@ private void closeInternal() { @Override public void close() throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "close"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } closeInternal(); @@ -781,9 +784,11 @@ private void moverInit() throws SQLServerException { @Override public boolean relative(int rows) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "relative", rows); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "relative", rows); - logger.finer(toString() + " rows:" + rows + logCursorState()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + " rows:" + rows + logCursorState()); checkClosed(); @@ -967,10 +972,11 @@ private void updateCurrentRow(int rowsToMove) { @Override public boolean next() throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "next"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } - logger.finer(toString() + logCursorState()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + logCursorState()); checkClosed(); @@ -1079,7 +1085,8 @@ public boolean wasNull() throws SQLServerException { @Override public boolean isBeforeFirst() throws SQLException { loggerExternal.entering(getClassNameLogging(), "isBeforeFirst"); - logger.finer(toString() + logCursorState()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + logCursorState()); checkClosed(); @@ -1138,7 +1145,8 @@ public boolean isBeforeFirst() throws SQLException { @Override public boolean isAfterLast() throws SQLException { loggerExternal.entering(getClassNameLogging(), "isAfterLast"); - logger.finer(toString() + logCursorState()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + logCursorState()); checkClosed(); @@ -1189,7 +1197,8 @@ public boolean isAfterLast() throws SQLException { @Override public boolean isFirst() throws SQLException { loggerExternal.entering(getClassNameLogging(), "isFirst"); - logger.finer(toString() + logCursorState()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + logCursorState()); checkClosed(); @@ -1238,7 +1247,8 @@ public boolean isFirst() throws SQLException { @Override public boolean isLast() throws SQLException { loggerExternal.entering(getClassNameLogging(), "isLast"); - logger.finer(toString() + logCursorState()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + logCursorState()); checkClosed(); @@ -1288,10 +1298,11 @@ public boolean isLast() throws SQLException { @Override public void beforeFirst() throws SQLException { loggerExternal.entering(getClassNameLogging(), "beforeFirst"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } - logger.finer(toString() + logCursorState()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + logCursorState()); checkClosed(); @@ -1318,11 +1329,12 @@ private void moveBeforeFirst() throws SQLServerException { @Override public void afterLast() throws SQLException { loggerExternal.entering(getClassNameLogging(), "afterLast"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } - logger.finer(toString() + logCursorState()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + logCursorState()); checkClosed(); @@ -1366,7 +1378,8 @@ private void moveAfterLast() throws SQLServerException { @Override public boolean first() throws SQLException { loggerExternal.entering(getClassNameLogging(), "first"); - logger.finer(toString() + logCursorState()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + logCursorState()); checkClosed(); @@ -1422,7 +1435,8 @@ private void moveFirst() throws SQLServerException { @Override public boolean last() throws SQLException { loggerExternal.entering(getClassNameLogging(), "last"); - logger.finer(toString() + logCursorState()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + logCursorState()); checkClosed(); @@ -1468,7 +1482,8 @@ private void moveLast() throws SQLServerException { @Override public int getRow() throws SQLException { loggerExternal.entering(getClassNameLogging(), "getRow"); - logger.finer(toString() + logCursorState()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + logCursorState()); checkClosed(); @@ -1538,10 +1553,11 @@ public int getRow() throws SQLException { @Override public boolean absolute(int row) throws SQLException { loggerExternal.entering(getClassNameLogging(), "absolute"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } - logger.finer(toString() + " row:" + row + logCursorState()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + " row:" + row + logCursorState()); checkClosed(); @@ -1858,7 +1874,8 @@ private int clientMoveAbsolute(int row) throws SQLServerException { @Override public boolean previous() throws SQLException { loggerExternal.entering(getClassNameLogging(), "previous"); - logger.finer(toString() + logCursorState()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + logCursorState()); checkClosed(); @@ -2000,7 +2017,8 @@ Column getterGetColumn(int index) throws SQLServerException { verifyResultSetHasCurrentRow(); } - logger.finer(toString() + " Getting Column:" + index); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + " Getting Column:" + index); fillLOBs(); return loadColumn(index); @@ -2072,7 +2090,8 @@ public java.io.InputStream getAsciiStream(String columnName) throws SQLServerExc @Deprecated @Override public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getBigDecimal", new Object[] {columnIndex, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getBigDecimal", new Object[] {columnIndex, scale}); checkClosed(); BigDecimal value = (BigDecimal) getValue(columnIndex, JDBCType.DECIMAL); if (null != value) @@ -2084,7 +2103,8 @@ public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLServerExce @Deprecated @Override public BigDecimal getBigDecimal(String columnName, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "columnName", new Object[] {columnName, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "columnName", new Object[] {columnName, scale}); checkClosed(); BigDecimal value = (BigDecimal) getValue(findColumn(columnName), JDBCType.DECIMAL); if (null != value) @@ -2185,7 +2205,8 @@ public java.sql.Date getDate(String columnName) throws SQLServerException { @Override public java.sql.Date getDate(int columnIndex, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getDate", new Object[] {columnIndex, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getDate", new Object[] {columnIndex, cal}); checkClosed(); java.sql.Date value = (java.sql.Date) getValue(columnIndex, JDBCType.DATE, cal); loggerExternal.exiting(getClassNameLogging(), "getDate", value); @@ -2194,7 +2215,8 @@ public java.sql.Date getDate(int columnIndex, Calendar cal) throws SQLServerExce @Override public java.sql.Date getDate(String colName, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getDate", new Object[] {colName, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getDate", new Object[] {colName, cal}); checkClosed(); java.sql.Date value = (java.sql.Date) getValue(findColumn(colName), JDBCType.DATE, cal); loggerExternal.exiting(getClassNameLogging(), "getDate", value); @@ -2529,7 +2551,8 @@ public java.sql.Time getTime(String columnName) throws SQLServerException { @Override public java.sql.Time getTime(int columnIndex, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getTime", new Object[] {columnIndex, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getTime", new Object[] {columnIndex, cal}); checkClosed(); java.sql.Time value = (java.sql.Time) getValue(columnIndex, JDBCType.TIME, cal); loggerExternal.exiting(getClassNameLogging(), "getTime", value); @@ -2538,7 +2561,8 @@ public java.sql.Time getTime(int columnIndex, Calendar cal) throws SQLServerExce @Override public java.sql.Time getTime(String colName, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getTime", new Object[] {colName, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getTime", new Object[] {colName, cal}); checkClosed(); java.sql.Time value = (java.sql.Time) getValue(findColumn(colName), JDBCType.TIME, cal); loggerExternal.exiting(getClassNameLogging(), "getTime", value); @@ -2565,7 +2589,8 @@ public java.sql.Timestamp getTimestamp(String columnName) throws SQLServerExcept @Override public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getTimestamp", new Object[] {columnIndex, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getTimestamp", new Object[] {columnIndex, cal}); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue(columnIndex, JDBCType.TIMESTAMP, cal); loggerExternal.exiting(getClassNameLogging(), "getTimeStamp", value); @@ -2574,7 +2599,8 @@ public java.sql.Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQL @Override public java.sql.Timestamp getTimestamp(String colName, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getTimestamp", new Object[] {colName, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getTimestamp", new Object[] {colName, cal}); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(colName), JDBCType.TIMESTAMP, cal); loggerExternal.exiting(getClassNameLogging(), "getTimestamp", value); @@ -2601,7 +2627,8 @@ public java.sql.Timestamp getDateTime(String columnName) throws SQLServerExcepti @Override public java.sql.Timestamp getDateTime(int columnIndex, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getDateTime", new Object[] {columnIndex, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getDateTime", new Object[] {columnIndex, cal}); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue(columnIndex, JDBCType.TIMESTAMP, cal); loggerExternal.exiting(getClassNameLogging(), "getDateTime", value); @@ -2610,7 +2637,8 @@ public java.sql.Timestamp getDateTime(int columnIndex, Calendar cal) throws SQLS @Override public java.sql.Timestamp getDateTime(String colName, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getDateTime", new Object[] {colName, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getDateTime", new Object[] {colName, cal}); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(colName), JDBCType.TIMESTAMP, cal); loggerExternal.exiting(getClassNameLogging(), "getDateTime", value); @@ -2637,7 +2665,8 @@ public java.sql.Timestamp getSmallDateTime(String columnName) throws SQLServerEx @Override public java.sql.Timestamp getSmallDateTime(int columnIndex, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getSmallDateTime", new Object[] {columnIndex, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getSmallDateTime", new Object[] {columnIndex, cal}); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue(columnIndex, JDBCType.TIMESTAMP, cal); loggerExternal.exiting(getClassNameLogging(), "getSmallDateTime", value); @@ -2646,7 +2675,8 @@ public java.sql.Timestamp getSmallDateTime(int columnIndex, Calendar cal) throws @Override public java.sql.Timestamp getSmallDateTime(String colName, Calendar cal) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "getSmallDateTime", new Object[] {colName, cal}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getSmallDateTime", new Object[] {colName, cal}); checkClosed(); java.sql.Timestamp value = (java.sql.Timestamp) getValue(findColumn(colName), JDBCType.TIMESTAMP, cal); loggerExternal.exiting(getClassNameLogging(), "getSmallDateTime", value); @@ -2703,7 +2733,8 @@ public java.io.InputStream getUnicodeStream(String columnName) throws SQLExcepti @Override public Object getObject(int i, java.util.Map> map) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "getObject", new Object[] {i, map}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getObject", new Object[] {i, map}); SQLServerException.throwNotSupportedException(stmt.connection, stmt); return null; } @@ -3074,11 +3105,9 @@ public void updateNull(int index) throws SQLServerException { @Override public void updateBoolean(int index, boolean x) throws SQLException { - - loggerExternal.entering(getClassNameLogging(), "updateBoolean", new Object[] {index, x}); - + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBoolean", new Object[] {index, x}); checkClosed(); - updateValue(index, JDBCType.BIT, x, JavaType.BOOLEAN, false); loggerExternal.exiting(getClassNameLogging(), "updateBoolean"); @@ -3086,7 +3115,8 @@ public void updateBoolean(int index, boolean x) throws SQLException { @Override public void updateBoolean(int index, boolean x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateBoolean", new Object[] {index, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBoolean", new Object[] {index, x, forceEncrypt}); checkClosed(); updateValue(index, JDBCType.BIT, x, JavaType.BOOLEAN, forceEncrypt); @@ -3095,7 +3125,8 @@ public void updateBoolean(int index, boolean x, boolean forceEncrypt) throws SQL @Override public void updateByte(int index, byte x) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateByte", new Object[] {index, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateByte", new Object[] {index, x}); checkClosed(); updateValue(index, JDBCType.TINYINT, x, JavaType.BYTE, false); @@ -3105,7 +3136,8 @@ public void updateByte(int index, byte x) throws SQLException { @Override public void updateByte(int index, byte x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateByte", new Object[] {index, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateByte", new Object[] {index, x, forceEncrypt}); checkClosed(); updateValue(index, JDBCType.TINYINT, x, JavaType.BYTE, forceEncrypt); @@ -3115,7 +3147,8 @@ public void updateByte(int index, byte x, boolean forceEncrypt) throws SQLServer @Override public void updateShort(int index, short x) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateShort", new Object[] {index, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateShort", new Object[] {index, x}); checkClosed(); updateValue(index, JDBCType.SMALLINT, x, JavaType.SHORT, false); @@ -3125,7 +3158,8 @@ public void updateShort(int index, short x) throws SQLException { @Override public void updateShort(int index, short x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateShort", new Object[] {index, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateShort", new Object[] {index, x, forceEncrypt}); checkClosed(); updateValue(index, JDBCType.SMALLINT, x, JavaType.SHORT, forceEncrypt); @@ -3135,7 +3169,8 @@ public void updateShort(int index, short x, boolean forceEncrypt) throws SQLServ @Override public void updateInt(int index, int x) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateInt", new Object[] {index, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateInt", new Object[] {index, x}); checkClosed(); updateValue(index, JDBCType.INTEGER, x, JavaType.INTEGER, false); @@ -3145,7 +3180,8 @@ public void updateInt(int index, int x) throws SQLException { @Override public void updateInt(int index, int x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateInt", new Object[] {index, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateInt", new Object[] {index, x, forceEncrypt}); checkClosed(); updateValue(index, JDBCType.INTEGER, x, JavaType.INTEGER, forceEncrypt); @@ -3155,7 +3191,8 @@ public void updateInt(int index, int x, boolean forceEncrypt) throws SQLServerEx @Override public void updateLong(int index, long x) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateLong", new Object[] {index, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateLong", new Object[] {index, x}); checkClosed(); updateValue(index, JDBCType.BIGINT, x, JavaType.LONG, false); @@ -3165,7 +3202,8 @@ public void updateLong(int index, long x) throws SQLException { @Override public void updateLong(int index, long x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateLong", new Object[] {index, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateLong", new Object[] {index, x, forceEncrypt}); checkClosed(); updateValue(index, JDBCType.BIGINT, x, JavaType.LONG, forceEncrypt); @@ -3175,7 +3213,8 @@ public void updateLong(int index, long x, boolean forceEncrypt) throws SQLServer @Override public void updateFloat(int index, float x) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateFloat", new Object[] {index, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateFloat", new Object[] {index, x}); checkClosed(); updateValue(index, JDBCType.REAL, x, JavaType.FLOAT, false); @@ -3185,7 +3224,8 @@ public void updateFloat(int index, float x) throws SQLException { @Override public void updateFloat(int index, float x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateFloat", new Object[] {index, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateFloat", new Object[] {index, x, forceEncrypt}); checkClosed(); updateValue(index, JDBCType.REAL, x, JavaType.FLOAT, forceEncrypt); @@ -3195,7 +3235,8 @@ public void updateFloat(int index, float x, boolean forceEncrypt) throws SQLServ @Override public void updateDouble(int index, double x) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateDouble", new Object[] {index, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDouble", new Object[] {index, x}); checkClosed(); updateValue(index, JDBCType.DOUBLE, x, JavaType.DOUBLE, false); @@ -3205,7 +3246,8 @@ public void updateDouble(int index, double x) throws SQLException { @Override public void updateDouble(int index, double x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateDouble", new Object[] {index, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDouble", new Object[] {index, x, forceEncrypt}); checkClosed(); updateValue(index, JDBCType.DOUBLE, x, JavaType.DOUBLE, forceEncrypt); @@ -3215,7 +3257,8 @@ public void updateDouble(int index, double x, boolean forceEncrypt) throws SQLSe @Override public void updateMoney(int index, BigDecimal x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateMoney", new Object[] {index, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateMoney", new Object[] {index, x}); checkClosed(); updateValue(index, JDBCType.MONEY, x, JavaType.BIGDECIMAL, false); @@ -3224,7 +3267,8 @@ public void updateMoney(int index, BigDecimal x) throws SQLServerException { @Override public void updateMoney(int index, BigDecimal x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateMoney", new Object[] {index, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateMoney", new Object[] {index, x, forceEncrypt}); checkClosed(); updateValue(index, JDBCType.MONEY, x, JavaType.BIGDECIMAL, forceEncrypt); @@ -3233,7 +3277,8 @@ public void updateMoney(int index, BigDecimal x, boolean forceEncrypt) throws SQ @Override public void updateMoney(String columnName, BigDecimal x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateMoney", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateMoney", new Object[] {columnName, x}); checkClosed(); updateValue(findColumn(columnName), JDBCType.MONEY, x, JavaType.BIGDECIMAL, false); @@ -3242,7 +3287,8 @@ public void updateMoney(String columnName, BigDecimal x) throws SQLServerExcepti @Override public void updateMoney(String columnName, BigDecimal x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateMoney", new Object[] {columnName, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateMoney", new Object[] {columnName, x, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.MONEY, x, JavaType.BIGDECIMAL, forceEncrypt); @@ -3251,7 +3297,8 @@ public void updateMoney(String columnName, BigDecimal x, boolean forceEncrypt) t @Override public void updateSmallMoney(int index, BigDecimal x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateSmallMoney", new Object[] {index, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateSmallMoney", new Object[] {index, x}); checkClosed(); updateValue(index, JDBCType.SMALLMONEY, x, JavaType.BIGDECIMAL, false); @@ -3260,7 +3307,8 @@ public void updateSmallMoney(int index, BigDecimal x) throws SQLServerException @Override public void updateSmallMoney(int index, BigDecimal x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateSmallMoney", new Object[] {index, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateSmallMoney", new Object[] {index, x, forceEncrypt}); checkClosed(); updateValue(index, JDBCType.SMALLMONEY, x, JavaType.BIGDECIMAL, forceEncrypt); @@ -3269,7 +3317,8 @@ public void updateSmallMoney(int index, BigDecimal x, boolean forceEncrypt) thro @Override public void updateSmallMoney(String columnName, BigDecimal x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateSmallMoney", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateSmallMoney", new Object[] {columnName, x}); checkClosed(); updateValue(findColumn(columnName), JDBCType.SMALLMONEY, x, JavaType.BIGDECIMAL, false); @@ -3278,7 +3327,9 @@ public void updateSmallMoney(String columnName, BigDecimal x) throws SQLServerEx @Override public void updateSmallMoney(String columnName, BigDecimal x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateSmallMoney", new Object[] {columnName, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateSmallMoney", + new Object[] {columnName, x, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.SMALLMONEY, x, JavaType.BIGDECIMAL, forceEncrypt); @@ -3287,7 +3338,8 @@ public void updateSmallMoney(String columnName, BigDecimal x, boolean forceEncry @Override public void updateBigDecimal(int index, BigDecimal x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateBigDecimal", new Object[] {index, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBigDecimal", new Object[] {index, x}); checkClosed(); updateValue(index, JDBCType.DECIMAL, x, JavaType.BIGDECIMAL, false); @@ -3297,7 +3349,8 @@ public void updateBigDecimal(int index, BigDecimal x) throws SQLServerException @Override public void updateBigDecimal(int index, BigDecimal x, Integer precision, Integer scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateBigDecimal", new Object[] {index, x, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBigDecimal", new Object[] {index, x, scale}); checkClosed(); updateValue(index, JDBCType.DECIMAL, x, JavaType.BIGDECIMAL, precision, scale, false); @@ -3308,8 +3361,9 @@ public void updateBigDecimal(int index, BigDecimal x, Integer precision, Integer @Override public void updateBigDecimal(int index, BigDecimal x, Integer precision, Integer scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateBigDecimal", - new Object[] {index, x, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBigDecimal", + new Object[] {index, x, scale, forceEncrypt}); checkClosed(); updateValue(index, JDBCType.DECIMAL, x, JavaType.BIGDECIMAL, precision, scale, forceEncrypt); @@ -3319,7 +3373,8 @@ public void updateBigDecimal(int index, BigDecimal x, Integer precision, Integer @Override public void updateString(int columnIndex, String stringValue) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateString", new Object[] {columnIndex, stringValue}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateString", new Object[] {columnIndex, stringValue}); checkClosed(); updateValue(columnIndex, JDBCType.VARCHAR, stringValue, JavaType.STRING, false); @@ -3329,8 +3384,9 @@ public void updateString(int columnIndex, String stringValue) throws SQLServerEx @Override public void updateString(int columnIndex, String stringValue, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateString", - new Object[] {columnIndex, stringValue, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateString", + new Object[] {columnIndex, stringValue, forceEncrypt}); checkClosed(); updateValue(columnIndex, JDBCType.VARCHAR, stringValue, JavaType.STRING, forceEncrypt); @@ -3340,7 +3396,8 @@ public void updateString(int columnIndex, String stringValue, boolean forceEncry @Override public void updateNString(int columnIndex, String nString) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateNString", new Object[] {columnIndex, nString}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateNString", new Object[] {columnIndex, nString}); checkClosed(); updateValue(columnIndex, JDBCType.NVARCHAR, nString, JavaType.STRING, false); @@ -3350,8 +3407,9 @@ public void updateNString(int columnIndex, String nString) throws SQLException { @Override public void updateNString(int columnIndex, String nString, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateNString", - new Object[] {columnIndex, nString, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateNString", + new Object[] {columnIndex, nString, forceEncrypt}); checkClosed(); updateValue(columnIndex, JDBCType.NVARCHAR, nString, JavaType.STRING, forceEncrypt); @@ -3361,7 +3419,8 @@ public void updateNString(int columnIndex, String nString, boolean forceEncrypt) @Override public void updateNString(String columnLabel, String nString) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateNString", new Object[] {columnLabel, nString}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateNString", new Object[] {columnLabel, nString}); checkClosed(); updateValue(findColumn(columnLabel), JDBCType.NVARCHAR, nString, JavaType.STRING, false); @@ -3371,8 +3430,9 @@ public void updateNString(String columnLabel, String nString) throws SQLExceptio @Override public void updateNString(String columnLabel, String nString, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateNString", - new Object[] {columnLabel, nString, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateNString", + new Object[] {columnLabel, nString, forceEncrypt}); checkClosed(); updateValue(findColumn(columnLabel), JDBCType.NVARCHAR, nString, JavaType.STRING, forceEncrypt); @@ -3382,7 +3442,8 @@ public void updateNString(String columnLabel, String nString, boolean forceEncry @Override public void updateBytes(int index, byte x[]) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateBytes", new Object[] {index, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBytes", new Object[] {index, x}); checkClosed(); updateValue(index, JDBCType.BINARY, x, JavaType.BYTEARRAY, false); @@ -3392,7 +3453,8 @@ public void updateBytes(int index, byte x[]) throws SQLException { @Override public void updateBytes(int index, byte x[], boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateBytes", new Object[] {index, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBytes", new Object[] {index, x, forceEncrypt}); checkClosed(); updateValue(index, JDBCType.BINARY, x, JavaType.BYTEARRAY, forceEncrypt); @@ -3402,7 +3464,8 @@ public void updateBytes(int index, byte x[], boolean forceEncrypt) throws SQLSer @Override public void updateDate(int index, java.sql.Date x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateDate", new Object[] {index, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDate", new Object[] {index, x}); checkClosed(); updateValue(index, JDBCType.DATE, x, JavaType.DATE, false); @@ -3412,7 +3475,8 @@ public void updateDate(int index, java.sql.Date x) throws SQLServerException { @Override public void updateDate(int index, java.sql.Date x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateDate", new Object[] {index, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDate", new Object[] {index, x, forceEncrypt}); checkClosed(); updateValue(index, JDBCType.DATE, x, JavaType.DATE, forceEncrypt); @@ -3422,7 +3486,8 @@ public void updateDate(int index, java.sql.Date x, boolean forceEncrypt) throws @Override public void updateTime(int index, java.sql.Time x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateTime", new Object[] {index, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateTime", new Object[] {index, x}); checkClosed(); updateValue(index, JDBCType.TIME, x, JavaType.TIME, false); @@ -3432,7 +3497,8 @@ public void updateTime(int index, java.sql.Time x) throws SQLServerException { @Override public void updateTime(int index, java.sql.Time x, Integer scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateTime", new Object[] {index, x, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateTime", new Object[] {index, x, scale}); checkClosed(); updateValue(index, JDBCType.TIME, x, JavaType.TIME, null, scale, false); @@ -3442,7 +3508,8 @@ public void updateTime(int index, java.sql.Time x, Integer scale) throws SQLServ @Override public void updateTime(int index, java.sql.Time x, Integer scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateTime", new Object[] {index, x, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateTime", new Object[] {index, x, scale, forceEncrypt}); checkClosed(); updateValue(index, JDBCType.TIME, x, JavaType.TIME, null, scale, forceEncrypt); @@ -3452,7 +3519,8 @@ public void updateTime(int index, java.sql.Time x, Integer scale, boolean forceE @Override public void updateTimestamp(int index, java.sql.Timestamp x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateTimestamp", new Object[] {index, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateTimestamp", new Object[] {index, x}); checkClosed(); updateValue(index, JDBCType.TIMESTAMP, x, JavaType.TIMESTAMP, false); @@ -3462,7 +3530,8 @@ public void updateTimestamp(int index, java.sql.Timestamp x) throws SQLServerExc @Override public void updateTimestamp(int index, java.sql.Timestamp x, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateTimestamp", new Object[] {index, x, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateTimestamp", new Object[] {index, x, scale}); checkClosed(); updateValue(index, JDBCType.TIMESTAMP, x, JavaType.TIMESTAMP, null, scale, false); @@ -3473,7 +3542,9 @@ public void updateTimestamp(int index, java.sql.Timestamp x, int scale) throws S @Override public void updateTimestamp(int index, java.sql.Timestamp x, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateTimestamp", new Object[] {index, x, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateTimestamp", + new Object[] {index, x, scale, forceEncrypt}); checkClosed(); updateValue(index, JDBCType.TIMESTAMP, x, JavaType.TIMESTAMP, null, scale, forceEncrypt); @@ -3483,7 +3554,8 @@ public void updateTimestamp(int index, java.sql.Timestamp x, int scale, @Override public void updateDateTime(int index, java.sql.Timestamp x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateDateTime", new Object[] {index, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDateTime", new Object[] {index, x}); checkClosed(); updateValue(index, JDBCType.DATETIME, x, JavaType.TIMESTAMP, false); @@ -3493,7 +3565,8 @@ public void updateDateTime(int index, java.sql.Timestamp x) throws SQLServerExce @Override public void updateDateTime(int index, java.sql.Timestamp x, Integer scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateDateTime", new Object[] {index, x, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDateTime", new Object[] {index, x, scale}); checkClosed(); updateValue(index, JDBCType.DATETIME, x, JavaType.TIMESTAMP, null, scale, false); @@ -3504,7 +3577,9 @@ public void updateDateTime(int index, java.sql.Timestamp x, Integer scale) throw @Override public void updateDateTime(int index, java.sql.Timestamp x, Integer scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateDateTime", new Object[] {index, x, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDateTime", + new Object[] {index, x, scale, forceEncrypt}); checkClosed(); updateValue(index, JDBCType.DATETIME, x, JavaType.TIMESTAMP, null, scale, forceEncrypt); @@ -3514,7 +3589,8 @@ public void updateDateTime(int index, java.sql.Timestamp x, Integer scale, @Override public void updateSmallDateTime(int index, java.sql.Timestamp x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateSmallDateTime", new Object[] {index, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateSmallDateTime", new Object[] {index, x}); checkClosed(); updateValue(index, JDBCType.SMALLDATETIME, x, JavaType.TIMESTAMP, false); @@ -3524,7 +3600,8 @@ public void updateSmallDateTime(int index, java.sql.Timestamp x) throws SQLServe @Override public void updateSmallDateTime(int index, java.sql.Timestamp x, Integer scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateSmallDateTime", new Object[] {index, x, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateSmallDateTime", new Object[] {index, x, scale}); checkClosed(); updateValue(index, JDBCType.SMALLDATETIME, x, JavaType.TIMESTAMP, null, scale, false); @@ -3535,8 +3612,9 @@ public void updateSmallDateTime(int index, java.sql.Timestamp x, Integer scale) @Override public void updateSmallDateTime(int index, java.sql.Timestamp x, Integer scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateSmallDateTime", - new Object[] {index, x, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateSmallDateTime", + new Object[] {index, x, scale, forceEncrypt}); checkClosed(); updateValue(index, JDBCType.SMALLDATETIME, x, JavaType.TIMESTAMP, null, scale, forceEncrypt); @@ -3546,7 +3624,8 @@ public void updateSmallDateTime(int index, java.sql.Timestamp x, Integer scale, @Override public void updateDateTimeOffset(int index, microsoft.sql.DateTimeOffset x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateDateTimeOffset", new Object[] {index, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDateTimeOffset", new Object[] {index, x}); checkClosed(); updateValue(index, JDBCType.DATETIMEOFFSET, x, JavaType.DATETIMEOFFSET, false); @@ -3557,7 +3636,8 @@ public void updateDateTimeOffset(int index, microsoft.sql.DateTimeOffset x) thro @Override public void updateDateTimeOffset(int index, microsoft.sql.DateTimeOffset x, Integer scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateDateTimeOffset", new Object[] {index, x, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDateTimeOffset", new Object[] {index, x, scale}); checkClosed(); updateValue(index, JDBCType.DATETIMEOFFSET, x, JavaType.DATETIMEOFFSET, null, scale, false); @@ -3568,8 +3648,9 @@ public void updateDateTimeOffset(int index, microsoft.sql.DateTimeOffset x, @Override public void updateDateTimeOffset(int index, microsoft.sql.DateTimeOffset x, Integer scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateDateTimeOffset", - new Object[] {index, x, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDateTimeOffset", + new Object[] {index, x, scale, forceEncrypt}); checkClosed(); updateValue(index, JDBCType.DATETIMEOFFSET, x, JavaType.DATETIMEOFFSET, null, scale, forceEncrypt); @@ -3579,7 +3660,8 @@ public void updateDateTimeOffset(int index, microsoft.sql.DateTimeOffset x, Inte @Override public void updateUniqueIdentifier(int index, String x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateUniqueIdentifier", new Object[] {index, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateUniqueIdentifier", new Object[] {index, x}); checkClosed(); updateValue(index, JDBCType.GUID, x, JavaType.STRING, null, false); @@ -3589,7 +3671,9 @@ public void updateUniqueIdentifier(int index, String x) throws SQLServerExceptio @Override public void updateUniqueIdentifier(int index, String x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateUniqueIdentifier", new Object[] {index, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateUniqueIdentifier", + new Object[] {index, x, forceEncrypt}); checkClosed(); updateValue(index, JDBCType.GUID, x, JavaType.STRING, null, forceEncrypt); @@ -3599,7 +3683,8 @@ public void updateUniqueIdentifier(int index, String x, boolean forceEncrypt) th @Override public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateAsciiStream", new Object[] {columnIndex, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateAsciiStream", new Object[] {columnIndex, x}); checkClosed(); updateStream(columnIndex, StreamType.ASCII, x, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); @@ -3609,7 +3694,8 @@ public void updateAsciiStream(int columnIndex, InputStream x) throws SQLExceptio @Override public void updateAsciiStream(int index, InputStream x, int length) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateAsciiStream", new Object[] {index, x, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateAsciiStream", new Object[] {index, x, length}); checkClosed(); updateStream(index, StreamType.ASCII, x, JavaType.INPUTSTREAM, length); @@ -3629,7 +3715,8 @@ public void updateAsciiStream(int columnIndex, InputStream x, long length) throw @Override public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateAsciiStream", new Object[] {columnLabel, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateAsciiStream", new Object[] {columnLabel, x}); checkClosed(); updateStream(findColumn(columnLabel), StreamType.ASCII, x, JavaType.INPUTSTREAM, @@ -3640,7 +3727,8 @@ public void updateAsciiStream(String columnLabel, InputStream x) throws SQLExcep @Override public void updateAsciiStream(java.lang.String columnName, InputStream x, int length) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateAsciiStream", new Object[] {columnName, x, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateAsciiStream", new Object[] {columnName, x, length}); checkClosed(); updateStream(findColumn(columnName), StreamType.ASCII, x, JavaType.INPUTSTREAM, length); @@ -3650,8 +3738,9 @@ public void updateAsciiStream(java.lang.String columnName, InputStream x, int le @Override public void updateAsciiStream(String columnName, InputStream streamValue, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateAsciiStream", - new Object[] {columnName, streamValue, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateAsciiStream", + new Object[] {columnName, streamValue, length}); checkClosed(); updateStream(findColumn(columnName), StreamType.ASCII, streamValue, JavaType.INPUTSTREAM, length); @@ -3661,7 +3750,8 @@ public void updateAsciiStream(String columnName, InputStream streamValue, long l @Override public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateBinaryStream", new Object[] {columnIndex, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBinaryStream", new Object[] {columnIndex, x}); checkClosed(); updateStream(columnIndex, StreamType.BINARY, x, JavaType.INPUTSTREAM, DataTypes.UNKNOWN_STREAM_LENGTH); @@ -3671,8 +3761,9 @@ public void updateBinaryStream(int columnIndex, InputStream x) throws SQLExcepti @Override public void updateBinaryStream(int columnIndex, InputStream streamValue, int length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateBinaryStream", - new Object[] {columnIndex, streamValue, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBinaryStream", + new Object[] {columnIndex, streamValue, length}); checkClosed(); updateStream(columnIndex, StreamType.BINARY, streamValue, JavaType.INPUTSTREAM, length); @@ -3682,7 +3773,8 @@ public void updateBinaryStream(int columnIndex, InputStream streamValue, int len @Override public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateBinaryStream", new Object[] {columnIndex, x, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBinaryStream", new Object[] {columnIndex, x, length}); checkClosed(); updateStream(columnIndex, StreamType.BINARY, x, JavaType.INPUTSTREAM, length); @@ -3692,7 +3784,8 @@ public void updateBinaryStream(int columnIndex, InputStream x, long length) thro @Override public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateBinaryStream", new Object[] {columnLabel, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBinaryStream", new Object[] {columnLabel, x}); checkClosed(); updateStream(findColumn(columnLabel), StreamType.BINARY, x, JavaType.INPUTSTREAM, @@ -3703,8 +3796,9 @@ public void updateBinaryStream(String columnLabel, InputStream x) throws SQLExce @Override public void updateBinaryStream(String columnName, InputStream streamValue, int length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateBinaryStream", - new Object[] {columnName, streamValue, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBinaryStream", + new Object[] {columnName, streamValue, length}); checkClosed(); updateStream(findColumn(columnName), StreamType.BINARY, streamValue, JavaType.INPUTSTREAM, length); @@ -3714,7 +3808,8 @@ public void updateBinaryStream(String columnName, InputStream streamValue, int l @Override public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateBinaryStream", new Object[] {columnLabel, x, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBinaryStream", new Object[] {columnLabel, x, length}); checkClosed(); updateStream(findColumn(columnLabel), StreamType.BINARY, x, JavaType.INPUTSTREAM, length); @@ -3724,7 +3819,8 @@ public void updateBinaryStream(String columnLabel, InputStream x, long length) t @Override public void updateCharacterStream(int columnIndex, Reader x) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateCharacterStream", new Object[] {columnIndex, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateCharacterStream", new Object[] {columnIndex, x}); checkClosed(); updateStream(columnIndex, StreamType.CHARACTER, x, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); @@ -3734,8 +3830,9 @@ public void updateCharacterStream(int columnIndex, Reader x) throws SQLException @Override public void updateCharacterStream(int columnIndex, Reader readerValue, int length) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateCharacterStream", - new Object[] {columnIndex, readerValue, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateCharacterStream", + new Object[] {columnIndex, readerValue, length}); checkClosed(); updateStream(columnIndex, StreamType.CHARACTER, readerValue, JavaType.READER, length); @@ -3745,7 +3842,9 @@ public void updateCharacterStream(int columnIndex, Reader readerValue, int lengt @Override public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateCharacterStream", new Object[] {columnIndex, x, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateCharacterStream", + new Object[] {columnIndex, x, length}); checkClosed(); updateStream(columnIndex, StreamType.CHARACTER, x, JavaType.READER, length); @@ -3755,7 +3854,8 @@ public void updateCharacterStream(int columnIndex, Reader x, long length) throws @Override public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateCharacterStream", new Object[] {columnLabel, reader}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateCharacterStream", new Object[] {columnLabel, reader}); checkClosed(); updateStream(findColumn(columnLabel), StreamType.CHARACTER, reader, JavaType.READER, @@ -3766,8 +3866,9 @@ public void updateCharacterStream(String columnLabel, Reader reader) throws SQLE @Override public void updateCharacterStream(String columnName, Reader readerValue, int length) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateCharacterStream", - new Object[] {columnName, readerValue, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateCharacterStream", + new Object[] {columnName, readerValue, length}); checkClosed(); updateStream(findColumn(columnName), StreamType.CHARACTER, readerValue, JavaType.READER, length); @@ -3777,8 +3878,9 @@ public void updateCharacterStream(String columnName, Reader readerValue, int len @Override public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateCharacterStream", - new Object[] {columnLabel, reader, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateCharacterStream", + new Object[] {columnLabel, reader, length}); checkClosed(); updateStream(findColumn(columnLabel), StreamType.CHARACTER, reader, JavaType.READER, length); @@ -3788,7 +3890,8 @@ public void updateCharacterStream(String columnLabel, Reader reader, long length @Override public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateNCharacterStream", new Object[] {columnIndex, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateNCharacterStream", new Object[] {columnIndex, x}); checkClosed(); updateStream(columnIndex, StreamType.NCHARACTER, x, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); @@ -3798,7 +3901,9 @@ public void updateNCharacterStream(int columnIndex, Reader x) throws SQLExceptio @Override public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateNCharacterStream", new Object[] {columnIndex, x, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateNCharacterStream", + new Object[] {columnIndex, x, length}); checkClosed(); updateStream(columnIndex, StreamType.NCHARACTER, x, JavaType.READER, length); @@ -3808,7 +3913,9 @@ public void updateNCharacterStream(int columnIndex, Reader x, long length) throw @Override public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateNCharacterStream", new Object[] {columnLabel, reader}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateNCharacterStream", + new Object[] {columnLabel, reader}); checkClosed(); updateStream(findColumn(columnLabel), StreamType.NCHARACTER, reader, JavaType.READER, @@ -3819,8 +3926,9 @@ public void updateNCharacterStream(String columnLabel, Reader reader) throws SQL @Override public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateNCharacterStream", - new Object[] {columnLabel, reader, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateNCharacterStream", + new Object[] {columnLabel, reader, length}); checkClosed(); updateStream(findColumn(columnLabel), StreamType.NCHARACTER, reader, JavaType.READER, length); @@ -3830,7 +3938,8 @@ public void updateNCharacterStream(String columnLabel, Reader reader, long lengt @Override public void updateObject(int index, Object obj) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateObject", new Object[] {index, obj}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateObject", new Object[] {index, obj}); checkClosed(); updateObject(index, obj, null, null, null, false); @@ -3840,7 +3949,8 @@ public void updateObject(int index, Object obj) throws SQLServerException { @Override public void updateObject(int index, Object x, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateObject", new Object[] {index, x, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateObject", new Object[] {index, x, scale}); checkClosed(); updateObject(index, x, scale, null, null, false); @@ -3850,7 +3960,8 @@ public void updateObject(int index, Object x, int scale) throws SQLServerExcepti @Override public void updateObject(int index, Object x, int precision, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateObject", new Object[] {index, x, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateObject", new Object[] {index, x, scale}); checkClosed(); updateObject(index, x, scale, null, precision, false); @@ -3861,7 +3972,9 @@ public void updateObject(int index, Object x, int precision, int scale) throws S @Override public void updateObject(int index, Object x, int precision, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateObject", new Object[] {index, x, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateObject", + new Object[] {index, x, scale, forceEncrypt}); checkClosed(); updateObject(index, x, scale, null, precision, forceEncrypt); @@ -3935,7 +4048,8 @@ public void updateNull(String columnName) throws SQLServerException { @Override public void updateBoolean(String columnName, boolean x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateBoolean", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBoolean", new Object[] {columnName, x}); checkClosed(); updateValue(findColumn(columnName), JDBCType.BIT, x, JavaType.BOOLEAN, false); @@ -3945,7 +4059,8 @@ public void updateBoolean(String columnName, boolean x) throws SQLServerExceptio @Override public void updateBoolean(String columnName, boolean x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateBoolean", new Object[] {columnName, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBoolean", new Object[] {columnName, x, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.BIT, x, JavaType.BOOLEAN, forceEncrypt); @@ -3955,7 +4070,8 @@ public void updateBoolean(String columnName, boolean x, boolean forceEncrypt) th @Override public void updateByte(String columnName, byte x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateByte", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateByte", new Object[] {columnName, x}); checkClosed(); updateValue(findColumn(columnName), JDBCType.BINARY, x, JavaType.BYTE, false); @@ -3965,7 +4081,8 @@ public void updateByte(String columnName, byte x) throws SQLServerException { @Override public void updateByte(String columnName, byte x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateByte", new Object[] {columnName, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateByte", new Object[] {columnName, x, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.BINARY, x, JavaType.BYTE, forceEncrypt); @@ -3975,7 +4092,8 @@ public void updateByte(String columnName, byte x, boolean forceEncrypt) throws S @Override public void updateShort(String columnName, short x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateShort", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateShort", new Object[] {columnName, x}); checkClosed(); updateValue(findColumn(columnName), JDBCType.SMALLINT, x, JavaType.SHORT, false); @@ -3985,7 +4103,8 @@ public void updateShort(String columnName, short x) throws SQLServerException { @Override public void updateShort(String columnName, short x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateShort", new Object[] {columnName, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateShort", new Object[] {columnName, x, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.SMALLINT, x, JavaType.SHORT, forceEncrypt); @@ -3995,7 +4114,8 @@ public void updateShort(String columnName, short x, boolean forceEncrypt) throws @Override public void updateInt(String columnName, int x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateInt", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateInt", new Object[] {columnName, x}); checkClosed(); updateValue(findColumn(columnName), JDBCType.INTEGER, x, JavaType.INTEGER, false); @@ -4005,7 +4125,8 @@ public void updateInt(String columnName, int x) throws SQLServerException { @Override public void updateInt(String columnName, int x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateInt", new Object[] {columnName, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateInt", new Object[] {columnName, x, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.INTEGER, x, JavaType.INTEGER, forceEncrypt); @@ -4015,7 +4136,8 @@ public void updateInt(String columnName, int x, boolean forceEncrypt) throws SQL @Override public void updateLong(String columnName, long x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateLong", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateLong", new Object[] {columnName, x}); checkClosed(); updateValue(findColumn(columnName), JDBCType.BIGINT, x, JavaType.LONG, false); @@ -4025,7 +4147,8 @@ public void updateLong(String columnName, long x) throws SQLServerException { @Override public void updateLong(String columnName, long x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateLong", new Object[] {columnName, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateLong", new Object[] {columnName, x, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.BIGINT, x, JavaType.LONG, forceEncrypt); @@ -4035,7 +4158,8 @@ public void updateLong(String columnName, long x, boolean forceEncrypt) throws S @Override public void updateFloat(String columnName, float x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateFloat", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateFloat", new Object[] {columnName, x}); checkClosed(); updateValue(findColumn(columnName), JDBCType.REAL, x, JavaType.FLOAT, false); @@ -4045,7 +4169,8 @@ public void updateFloat(String columnName, float x) throws SQLServerException { @Override public void updateFloat(String columnName, float x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateFloat", new Object[] {columnName, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateFloat", new Object[] {columnName, x, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.REAL, x, JavaType.FLOAT, forceEncrypt); @@ -4055,7 +4180,8 @@ public void updateFloat(String columnName, float x, boolean forceEncrypt) throws @Override public void updateDouble(String columnName, double x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateDouble", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDouble", new Object[] {columnName, x}); checkClosed(); updateValue(findColumn(columnName), JDBCType.DOUBLE, x, JavaType.DOUBLE, false); @@ -4065,7 +4191,8 @@ public void updateDouble(String columnName, double x) throws SQLServerException @Override public void updateDouble(String columnName, double x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateDouble", new Object[] {columnName, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDouble", new Object[] {columnName, x, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.DOUBLE, x, JavaType.DOUBLE, forceEncrypt); @@ -4075,7 +4202,8 @@ public void updateDouble(String columnName, double x, boolean forceEncrypt) thro @Override public void updateBigDecimal(String columnName, BigDecimal x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateBigDecimal", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBigDecimal", new Object[] {columnName, x}); checkClosed(); updateValue(findColumn(columnName), JDBCType.DECIMAL, x, JavaType.BIGDECIMAL, false); @@ -4085,7 +4213,9 @@ public void updateBigDecimal(String columnName, BigDecimal x) throws SQLServerEx @Override public void updateBigDecimal(String columnName, BigDecimal x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateBigDecimal", new Object[] {columnName, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBigDecimal", + new Object[] {columnName, x, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.DECIMAL, x, JavaType.BIGDECIMAL, forceEncrypt); @@ -4096,8 +4226,9 @@ public void updateBigDecimal(String columnName, BigDecimal x, boolean forceEncry @Override public void updateBigDecimal(String columnName, BigDecimal x, Integer precision, Integer scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateBigDecimal", - new Object[] {columnName, x, precision, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBigDecimal", + new Object[] {columnName, x, precision, scale}); checkClosed(); updateValue(findColumn(columnName), JDBCType.DECIMAL, x, JavaType.BIGDECIMAL, precision, scale, false); @@ -4108,8 +4239,9 @@ public void updateBigDecimal(String columnName, BigDecimal x, Integer precision, @Override public void updateBigDecimal(String columnName, BigDecimal x, Integer precision, Integer scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateBigDecimal", - new Object[] {columnName, x, precision, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBigDecimal", + new Object[] {columnName, x, precision, scale, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.DECIMAL, x, JavaType.BIGDECIMAL, precision, scale, forceEncrypt); @@ -4119,7 +4251,8 @@ public void updateBigDecimal(String columnName, BigDecimal x, Integer precision, @Override public void updateString(String columnName, String x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateString", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateString", new Object[] {columnName, x}); checkClosed(); updateValue(findColumn(columnName), JDBCType.VARCHAR, x, JavaType.STRING, false); @@ -4129,7 +4262,8 @@ public void updateString(String columnName, String x) throws SQLServerException @Override public void updateString(String columnName, String x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateString", new Object[] {columnName, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateString", new Object[] {columnName, x, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.VARCHAR, x, JavaType.STRING, forceEncrypt); @@ -4139,7 +4273,8 @@ public void updateString(String columnName, String x, boolean forceEncrypt) thro @Override public void updateBytes(String columnName, byte x[]) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateBytes", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBytes", new Object[] {columnName, x}); checkClosed(); updateValue(findColumn(columnName), JDBCType.BINARY, x, JavaType.BYTEARRAY, false); @@ -4149,7 +4284,8 @@ public void updateBytes(String columnName, byte x[]) throws SQLServerException { @Override public void updateBytes(String columnName, byte x[], boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateBytes", new Object[] {columnName, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBytes", new Object[] {columnName, x, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.BINARY, x, JavaType.BYTEARRAY, forceEncrypt); @@ -4159,7 +4295,8 @@ public void updateBytes(String columnName, byte x[], boolean forceEncrypt) throw @Override public void updateDate(String columnName, java.sql.Date x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateDate", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDate", new Object[] {columnName, x}); checkClosed(); updateValue(findColumn(columnName), JDBCType.DATE, x, JavaType.DATE, false); @@ -4169,7 +4306,8 @@ public void updateDate(String columnName, java.sql.Date x) throws SQLServerExcep @Override public void updateDate(String columnName, java.sql.Date x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateDate", new Object[] {columnName, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDate", new Object[] {columnName, x, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.DATE, x, JavaType.DATE, forceEncrypt); @@ -4179,7 +4317,8 @@ public void updateDate(String columnName, java.sql.Date x, boolean forceEncrypt) @Override public void updateTime(String columnName, java.sql.Time x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateTime", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateTime", new Object[] {columnName, x}); checkClosed(); updateValue(findColumn(columnName), JDBCType.TIME, x, JavaType.TIME, false); @@ -4189,7 +4328,8 @@ public void updateTime(String columnName, java.sql.Time x) throws SQLServerExcep @Override public void updateTime(String columnName, java.sql.Time x, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateTime", new Object[] {columnName, x, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateTime", new Object[] {columnName, x, scale}); checkClosed(); updateValue(findColumn(columnName), JDBCType.TIME, x, JavaType.TIME, null, scale, false); @@ -4200,7 +4340,9 @@ public void updateTime(String columnName, java.sql.Time x, int scale) throws SQL @Override public void updateTime(String columnName, java.sql.Time x, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateTime", new Object[] {columnName, x, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateTime", + new Object[] {columnName, x, scale, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.TIME, x, JavaType.TIME, null, scale, forceEncrypt); @@ -4210,7 +4352,8 @@ public void updateTime(String columnName, java.sql.Time x, int scale, @Override public void updateTimestamp(String columnName, java.sql.Timestamp x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateTimestamp", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateTimestamp", new Object[] {columnName, x}); checkClosed(); updateValue(findColumn(columnName), JDBCType.TIMESTAMP, x, JavaType.TIMESTAMP, false); @@ -4220,7 +4363,8 @@ public void updateTimestamp(String columnName, java.sql.Timestamp x) throws SQLS @Override public void updateTimestamp(String columnName, java.sql.Timestamp x, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateTimestamp", new Object[] {columnName, x, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateTimestamp", new Object[] {columnName, x, scale}); checkClosed(); updateValue(findColumn(columnName), JDBCType.TIMESTAMP, x, JavaType.TIMESTAMP, null, scale, false); @@ -4231,8 +4375,9 @@ public void updateTimestamp(String columnName, java.sql.Timestamp x, int scale) @Override public void updateTimestamp(String columnName, java.sql.Timestamp x, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateTimestamp", - new Object[] {columnName, x, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateTimestamp", + new Object[] {columnName, x, scale, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.TIMESTAMP, x, JavaType.TIMESTAMP, null, scale, forceEncrypt); @@ -4242,7 +4387,8 @@ public void updateTimestamp(String columnName, java.sql.Timestamp x, int scale, @Override public void updateDateTime(String columnName, java.sql.Timestamp x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateDateTime", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDateTime", new Object[] {columnName, x}); checkClosed(); updateValue(findColumn(columnName), JDBCType.DATETIME, x, JavaType.TIMESTAMP, false); @@ -4252,7 +4398,8 @@ public void updateDateTime(String columnName, java.sql.Timestamp x) throws SQLSe @Override public void updateDateTime(String columnName, java.sql.Timestamp x, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateDateTime", new Object[] {columnName, x, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDateTime", new Object[] {columnName, x, scale}); checkClosed(); updateValue(findColumn(columnName), JDBCType.DATETIME, x, JavaType.TIMESTAMP, null, scale, false); @@ -4263,8 +4410,9 @@ public void updateDateTime(String columnName, java.sql.Timestamp x, int scale) t @Override public void updateDateTime(String columnName, java.sql.Timestamp x, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateDateTime", - new Object[] {columnName, x, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDateTime", + new Object[] {columnName, x, scale, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.DATETIME, x, JavaType.TIMESTAMP, null, scale, forceEncrypt); @@ -4274,7 +4422,8 @@ public void updateDateTime(String columnName, java.sql.Timestamp x, int scale, @Override public void updateSmallDateTime(String columnName, java.sql.Timestamp x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateSmallDateTime", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateSmallDateTime", new Object[] {columnName, x}); checkClosed(); updateValue(findColumn(columnName), JDBCType.SMALLDATETIME, x, JavaType.TIMESTAMP, false); @@ -4284,7 +4433,8 @@ public void updateSmallDateTime(String columnName, java.sql.Timestamp x) throws @Override public void updateSmallDateTime(String columnName, java.sql.Timestamp x, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateSmallDateTime", new Object[] {columnName, x, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateSmallDateTime", new Object[] {columnName, x, scale}); checkClosed(); updateValue(findColumn(columnName), JDBCType.SMALLDATETIME, x, JavaType.TIMESTAMP, null, scale, false); @@ -4295,8 +4445,9 @@ public void updateSmallDateTime(String columnName, java.sql.Timestamp x, int sca @Override public void updateSmallDateTime(String columnName, java.sql.Timestamp x, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateSmallDateTime", - new Object[] {columnName, x, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateSmallDateTime", + new Object[] {columnName, x, scale, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.SMALLDATETIME, x, JavaType.TIMESTAMP, null, scale, forceEncrypt); @@ -4306,7 +4457,8 @@ public void updateSmallDateTime(String columnName, java.sql.Timestamp x, int sca @Override public void updateDateTimeOffset(String columnName, microsoft.sql.DateTimeOffset x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateDateTimeOffset", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDateTimeOffset", new Object[] {columnName, x}); checkClosed(); updateValue(findColumn(columnName), JDBCType.DATETIMEOFFSET, x, JavaType.DATETIMEOFFSET, false); @@ -4317,7 +4469,8 @@ public void updateDateTimeOffset(String columnName, microsoft.sql.DateTimeOffset @Override public void updateDateTimeOffset(String columnName, microsoft.sql.DateTimeOffset x, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateDateTimeOffset", new Object[] {columnName, x, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDateTimeOffset", new Object[] {columnName, x, scale}); checkClosed(); updateValue(findColumn(columnName), JDBCType.DATETIMEOFFSET, x, JavaType.DATETIMEOFFSET, null, scale, false); @@ -4328,8 +4481,9 @@ public void updateDateTimeOffset(String columnName, microsoft.sql.DateTimeOffset @Override public void updateDateTimeOffset(String columnName, microsoft.sql.DateTimeOffset x, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateDateTimeOffset", - new Object[] {columnName, x, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateDateTimeOffset", + new Object[] {columnName, x, scale, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.DATETIMEOFFSET, x, JavaType.DATETIMEOFFSET, null, scale, @@ -4340,7 +4494,8 @@ public void updateDateTimeOffset(String columnName, microsoft.sql.DateTimeOffset @Override public void updateUniqueIdentifier(String columnName, String x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateUniqueIdentifier", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateUniqueIdentifier", new Object[] {columnName, x}); checkClosed(); updateValue(findColumn(columnName), JDBCType.GUID, x, JavaType.STRING, null, false); @@ -4350,8 +4505,9 @@ public void updateUniqueIdentifier(String columnName, String x) throws SQLServer @Override public void updateUniqueIdentifier(String columnName, String x, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateUniqueIdentifier", - new Object[] {columnName, x, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateUniqueIdentifier", + new Object[] {columnName, x, forceEncrypt}); checkClosed(); updateValue(findColumn(columnName), JDBCType.GUID, x, JavaType.STRING, null, forceEncrypt); @@ -4361,7 +4517,8 @@ public void updateUniqueIdentifier(String columnName, String x, boolean forceEnc @Override public void updateObject(String columnName, Object x, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateObject", new Object[] {columnName, x, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateObject", new Object[] {columnName, x, scale}); checkClosed(); updateObject(findColumn(columnName), x, scale, null, null, false); @@ -4371,7 +4528,9 @@ public void updateObject(String columnName, Object x, int scale) throws SQLServe @Override public void updateObject(String columnName, Object x, int precision, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateObject", new Object[] {columnName, x, precision, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateObject", + new Object[] {columnName, x, precision, scale}); checkClosed(); updateObject(findColumn(columnName), x, scale, null, precision, false); @@ -4382,8 +4541,9 @@ public void updateObject(String columnName, Object x, int precision, int scale) @Override public void updateObject(String columnName, Object x, int precision, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateObject", - new Object[] {columnName, x, precision, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateObject", + new Object[] {columnName, x, precision, scale, forceEncrypt}); checkClosed(); updateObject(findColumn(columnName), x, scale, null, precision, forceEncrypt); @@ -4393,7 +4553,8 @@ public void updateObject(String columnName, Object x, int precision, int scale, @Override public void updateObject(String columnName, Object x) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateObject", new Object[] {columnName, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateObject", new Object[] {columnName, x}); checkClosed(); updateObject(findColumn(columnName), x, null, null, null, false); @@ -4413,14 +4574,16 @@ public void updateRowId(String columnLabel, RowId x) throws SQLException { @Override public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateSQLXML", new Object[] {columnIndex, xmlObject}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateSQLXML", new Object[] {columnIndex, xmlObject}); updateSQLXMLInternal(columnIndex, xmlObject); loggerExternal.exiting(getClassNameLogging(), "updateSQLXML"); } @Override public void updateSQLXML(String columnLabel, SQLXML x) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateSQLXML", new Object[] {columnLabel, x}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateSQLXML", new Object[] {columnLabel, x}); updateSQLXMLInternal(findColumn(columnLabel), x); loggerExternal.exiting(getClassNameLogging(), "updateSQLXML"); } @@ -4452,7 +4615,7 @@ public int getHoldability() throws SQLException { @Override public void insertRow() throws SQLException { loggerExternal.entering(getClassNameLogging(), "insertRow"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } @@ -4470,7 +4633,8 @@ final boolean doExecute() throws SQLServerException { } } - logger.finer(toString() + logCursorState()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + logCursorState()); checkClosed(); @@ -4554,7 +4718,7 @@ private void doInsertRowRPC(TDSCommand command, String tableName) throws SQLServ @Override public void updateRow() throws SQLException { loggerExternal.entering(getClassNameLogging(), "updateRow"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } final class UpdateRowRPC extends TDSCommand { @@ -4568,7 +4732,8 @@ final boolean doExecute() throws SQLServerException { } } - logger.finer(toString() + logCursorState()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + logCursorState()); checkClosed(); @@ -4633,7 +4798,7 @@ final boolean hasUpdatedColumns() { @Override public void deleteRow() throws SQLException { loggerExternal.entering(getClassNameLogging(), "deleteRow"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } final class DeleteRowRPC extends TDSCommand { @@ -4647,7 +4812,8 @@ final boolean doExecute() throws SQLServerException { } } - logger.finer(toString() + logCursorState()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + logCursorState()); checkClosed(); @@ -4691,11 +4857,12 @@ private void doDeleteRowRPC(TDSCommand command) throws SQLServerException { @Override public void refreshRow() throws SQLException { loggerExternal.entering(getClassNameLogging(), "refreshRow"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } - logger.finer(toString() + logCursorState()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + logCursorState()); checkClosed(); @@ -4786,7 +4953,8 @@ public void cancelRowUpdates() throws SQLServerException { @Override public void moveToInsertRow() throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "moveToInsertRow"); - logger.finer(toString() + logCursorState()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + logCursorState()); checkClosed(); @@ -4802,7 +4970,8 @@ public void moveToInsertRow() throws SQLServerException { @Override public void moveToCurrentRow() throws SQLServerException { loggerExternal.entering(getClassNameLogging(), "moveToCurrentRow"); - logger.finer(toString() + logCursorState()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + logCursorState()); checkClosed(); @@ -4831,7 +5000,8 @@ public java.sql.Statement getStatement() throws SQLServerException { @Override public void updateClob(int columnIndex, Clob clobValue) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateClob", new Object[] {columnIndex, clobValue}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateClob", new Object[] {columnIndex, clobValue}); checkClosed(); updateValue(columnIndex, JDBCType.CLOB, clobValue, JavaType.CLOB, false); @@ -4841,7 +5011,8 @@ public void updateClob(int columnIndex, Clob clobValue) throws SQLException { @Override public void updateClob(int columnIndex, Reader reader) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateClob", new Object[] {columnIndex, reader}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateClob", new Object[] {columnIndex, reader}); checkClosed(); updateStream(columnIndex, StreamType.CHARACTER, reader, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); @@ -4851,7 +5022,8 @@ public void updateClob(int columnIndex, Reader reader) throws SQLException { @Override public void updateClob(int columnIndex, Reader reader, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateClob", new Object[] {columnIndex, reader, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateClob", new Object[] {columnIndex, reader, length}); checkClosed(); updateStream(columnIndex, StreamType.CHARACTER, reader, JavaType.READER, length); @@ -4861,7 +5033,8 @@ public void updateClob(int columnIndex, Reader reader, long length) throws SQLEx @Override public void updateClob(String columnName, Clob clobValue) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateClob", new Object[] {columnName, clobValue}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateClob", new Object[] {columnName, clobValue}); checkClosed(); updateValue(findColumn(columnName), JDBCType.CLOB, clobValue, JavaType.CLOB, false); @@ -4871,7 +5044,8 @@ public void updateClob(String columnName, Clob clobValue) throws SQLException { @Override public void updateClob(String columnLabel, Reader reader) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateClob", new Object[] {columnLabel, reader}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateClob", new Object[] {columnLabel, reader}); checkClosed(); updateStream(findColumn(columnLabel), StreamType.CHARACTER, reader, JavaType.READER, @@ -4882,7 +5056,8 @@ public void updateClob(String columnLabel, Reader reader) throws SQLException { @Override public void updateClob(String columnLabel, Reader reader, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateClob", new Object[] {columnLabel, reader, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateClob", new Object[] {columnLabel, reader, length}); checkClosed(); updateStream(findColumn(columnLabel), StreamType.CHARACTER, reader, JavaType.READER, length); @@ -4892,7 +5067,8 @@ public void updateClob(String columnLabel, Reader reader, long length) throws SQ @Override public void updateNClob(int columnIndex, NClob nClob) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateClob", new Object[] {columnIndex, nClob}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateClob", new Object[] {columnIndex, nClob}); checkClosed(); updateValue(columnIndex, JDBCType.NCLOB, nClob, JavaType.NCLOB, false); @@ -4902,7 +5078,8 @@ public void updateNClob(int columnIndex, NClob nClob) throws SQLException { @Override public void updateNClob(int columnIndex, Reader reader) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateNClob", new Object[] {columnIndex, reader}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateNClob", new Object[] {columnIndex, reader}); checkClosed(); updateStream(columnIndex, StreamType.NCHARACTER, reader, JavaType.READER, DataTypes.UNKNOWN_STREAM_LENGTH); @@ -4912,7 +5089,8 @@ public void updateNClob(int columnIndex, Reader reader) throws SQLException { @Override public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateNClob", new Object[] {columnIndex, reader, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateNClob", new Object[] {columnIndex, reader, length}); checkClosed(); updateStream(columnIndex, StreamType.NCHARACTER, reader, JavaType.READER, length); @@ -4922,7 +5100,8 @@ public void updateNClob(int columnIndex, Reader reader, long length) throws SQLE @Override public void updateNClob(String columnLabel, NClob nClob) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateNClob", new Object[] {columnLabel, nClob}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateNClob", new Object[] {columnLabel, nClob}); checkClosed(); updateValue(findColumn(columnLabel), JDBCType.NCLOB, nClob, JavaType.NCLOB, false); @@ -4932,7 +5111,8 @@ public void updateNClob(String columnLabel, NClob nClob) throws SQLException { @Override public void updateNClob(String columnLabel, Reader reader) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateNClob", new Object[] {columnLabel, reader}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateNClob", new Object[] {columnLabel, reader}); checkClosed(); updateStream(findColumn(columnLabel), StreamType.NCHARACTER, reader, JavaType.READER, @@ -4943,7 +5123,8 @@ public void updateNClob(String columnLabel, Reader reader) throws SQLException { @Override public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateNClob", new Object[] {columnLabel, reader, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateNClob", new Object[] {columnLabel, reader, length}); checkClosed(); updateStream(findColumn(columnLabel), StreamType.NCHARACTER, reader, JavaType.READER, length); @@ -4953,7 +5134,8 @@ public void updateNClob(String columnLabel, Reader reader, long length) throws S @Override public void updateBlob(int columnIndex, Blob blobValue) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateBlob", new Object[] {columnIndex, blobValue}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBlob", new Object[] {columnIndex, blobValue}); checkClosed(); updateValue(columnIndex, JDBCType.BLOB, blobValue, JavaType.BLOB, false); @@ -4963,7 +5145,8 @@ public void updateBlob(int columnIndex, Blob blobValue) throws SQLException { @Override public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateBlob", new Object[] {columnIndex, inputStream}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBlob", new Object[] {columnIndex, inputStream}); checkClosed(); updateStream(columnIndex, StreamType.BINARY, inputStream, JavaType.INPUTSTREAM, @@ -4974,7 +5157,9 @@ public void updateBlob(int columnIndex, InputStream inputStream) throws SQLExcep @Override public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateBlob", new Object[] {columnIndex, inputStream, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBlob", + new Object[] {columnIndex, inputStream, length}); checkClosed(); updateStream(columnIndex, StreamType.BINARY, inputStream, JavaType.INPUTSTREAM, length); @@ -4984,7 +5169,8 @@ public void updateBlob(int columnIndex, InputStream inputStream, long length) th @Override public void updateBlob(String columnName, Blob blobValue) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateBlob", new Object[] {columnName, blobValue}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBlob", new Object[] {columnName, blobValue}); checkClosed(); updateValue(findColumn(columnName), JDBCType.BLOB, blobValue, JavaType.BLOB, false); @@ -4994,7 +5180,8 @@ public void updateBlob(String columnName, Blob blobValue) throws SQLException { @Override public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateBlob", new Object[] {columnLabel, inputStream}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBlob", new Object[] {columnLabel, inputStream}); checkClosed(); updateStream(findColumn(columnLabel), StreamType.BINARY, inputStream, JavaType.INPUTSTREAM, @@ -5005,7 +5192,9 @@ public void updateBlob(String columnLabel, InputStream inputStream) throws SQLEx @Override public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "updateBlob", new Object[] {columnLabel, inputStream, length}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateBlob", + new Object[] {columnLabel, inputStream, length}); checkClosed(); updateStream(findColumn(columnLabel), StreamType.BINARY, inputStream, JavaType.INPUTSTREAM, length); @@ -5167,7 +5356,8 @@ final boolean needsServerCursorFixup() { final void ensureStartMark() { if (null == startMark && !isForwardOnly()) { - logger.finest(toString() + " Setting fetch buffer start mark"); + if (logger.isLoggable(java.util.logging.Level.FINEST)) + logger.finest(toString() + " Setting fetch buffer start mark"); startMark = tdsReader.mark(); } @@ -5273,7 +5463,8 @@ final void processResponse(TDSReader responseTDSReader) throws SQLServerExceptio * The cursor was invalid. */ final void doServerFetch(int fetchType, int startRow, int numRows) throws SQLServerException { - logger.finer(toString() + " fetchType:" + fetchType + " startRow:" + startRow + " numRows:" + numRows); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + " fetchType:" + fetchType + " startRow:" + startRow + " numRows:" + numRows); // Discard the current fetch buffer contents discardFetchBuffer(); @@ -5309,8 +5500,9 @@ final void doServerFetch(int fetchType, int startRow, int numRows) throws SQLSer // If there is a row error in the results, don't throw an exception from here. // Ignore it for now and defer the exception until the app encounters the // error through normal cursor movement. - logger.finer( - toString() + " Ignored exception from row error during server cursor fixup: " + e.getMessage()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + " Ignored exception from row error during server cursor fixup: " + + e.getMessage()); } // Force the cursor to move to before the first row if necessary. @@ -5333,12 +5525,13 @@ private void fillLOBs() { try { activeLOB.fillFromStream(); } catch (SQLException e) { - logger.finer(toString() + "Filling Lobs before closing: " + e.getMessage()); + if (logger.isLoggable(java.util.logging.Level.FINER)) { + logger.finer(toString() + "Filling Lobs before closing: " + e.getMessage()); + } } finally { activeLOB = null; } } - } /** @@ -5369,7 +5562,8 @@ private void discardFetchBuffer() { try { while (fetchBufferNext()); } catch (SQLServerException e) { - logger.finer(this + " Encountered exception discarding fetch buffer: " + e.getMessage()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(this + " Encountered exception discarding fetch buffer: " + e.getMessage()); } } @@ -5385,9 +5579,11 @@ final void closeServerCursor() { // If the connection is already closed, don't bother trying to close the server cursor. // We won't be able to, and it's already closed on the server anyway. if (stmt.connection.isSessionUnAvailable()) { - logger.finer(this + ": Not closing cursor:" + serverCursorId + "; connection is already closed."); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(this + ": Not closing cursor:" + serverCursorId + "; connection is already closed."); } else { - logger.finer(toString() + " Closing cursor:" + serverCursorId); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + " Closing cursor:" + serverCursorId); final class CloseServerCursorCommand extends UninterruptableTDSCommand { CloseServerCursorCommand() { @@ -5410,17 +5606,20 @@ final boolean doExecute() throws SQLServerException { try { stmt.executeCommand(new CloseServerCursorCommand()); } catch (SQLServerException e) { - logger.finer(toString() + " Ignored error closing cursor:" + serverCursorId + " " + e.getMessage()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + " Ignored error closing cursor:" + serverCursorId + " " + e.getMessage()); } - logger.finer(toString() + " Closed cursor:" + serverCursorId); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + " Closed cursor:" + serverCursorId); } } @Override public void updateObject(int index, Object obj, SQLType targetSqlType) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateObject", new Object[] {index, obj, targetSqlType}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateObject", new Object[] {index, obj, targetSqlType}); checkClosed(); // getVendorTypeNumber() returns the same constant integer values as in java.sql.Types @@ -5432,7 +5631,9 @@ public void updateObject(int index, Object obj, SQLType targetSqlType) throws SQ @Override public void updateObject(int index, Object obj, SQLType targetSqlType, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateObject", new Object[] {index, obj, targetSqlType, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateObject", + new Object[] {index, obj, targetSqlType, scale}); checkClosed(); // getVendorTypeNumber() returns the same constant integer values as in java.sql.Types @@ -5445,8 +5646,9 @@ public void updateObject(int index, Object obj, SQLType targetSqlType, int scale public void updateObject(int index, Object obj, SQLType targetSqlType, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateObject", - new Object[] {index, obj, targetSqlType, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateObject", + new Object[] {index, obj, targetSqlType, scale, forceEncrypt}); checkClosed(); // getVendorTypeNumber() returns the same constant integer values as in java.sql.Types @@ -5459,8 +5661,9 @@ public void updateObject(int index, Object obj, SQLType targetSqlType, int scale public void updateObject(String columnName, Object obj, SQLType targetSqlType, int scale) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateObject", - new Object[] {columnName, obj, targetSqlType, scale}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateObject", + new Object[] {columnName, obj, targetSqlType, scale}); checkClosed(); @@ -5474,8 +5677,9 @@ public void updateObject(String columnName, Object obj, SQLType targetSqlType, public void updateObject(String columnName, Object obj, SQLType targetSqlType, int scale, boolean forceEncrypt) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateObject", - new Object[] {columnName, obj, targetSqlType, scale, forceEncrypt}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateObject", + new Object[] {columnName, obj, targetSqlType, scale, forceEncrypt}); checkClosed(); @@ -5489,7 +5693,9 @@ public void updateObject(String columnName, Object obj, SQLType targetSqlType, i @Override public void updateObject(String columnName, Object obj, SQLType targetSqlType) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "updateObject", new Object[] {columnName, obj, targetSqlType}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "updateObject", + new Object[] {columnName, obj, targetSqlType}); checkClosed(); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResultSetMetaData.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResultSetMetaData.java index c69529b84b..5f36d2d75f 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResultSetMetaData.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerResultSetMetaData.java @@ -48,7 +48,9 @@ final public String toString() { this.con = con; this.rs = rs; assert rs != null; - logger.fine(toString() + " created by (" + rs.toString() + ")"); + if (logger.isLoggable(java.util.logging.Level.FINE)) { + logger.fine(toString() + " created by (" + rs.toString() + ")"); + } } /* ------------------ JDBC API Methods --------------------- */ diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerSQLXML.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerSQLXML.java index 79dcb06f16..b58a715c31 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerSQLXML.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerSQLXML.java @@ -1,6 +1,6 @@ /* - * Microsoft JDBC Driver for SQL Server Copyright(c)Microsoft Corporation All rights reserved.This program is - * made*available under the terms of the MIT License.See the LICENSE file in the project root for more information. + * Microsoft JDBC Driver for SQL Server Copyright(c) Microsoft Corporation All rights reserved. This program is made + * available under the terms of the MIT License. See the LICENSE file in the project root for more information. */ package com.microsoft.sqlserver.jdbc; @@ -139,7 +139,8 @@ InputStream getValue() throws SQLServerException { traceID = " SQLServerSQLXML:" + nextInstanceID(); con = connection; - logger.fine(toString() + " created by (" + connection.toString() + ")"); + if (logger.isLoggable(java.util.logging.Level.FINE)) + logger.fine(toString() + " created by (" + connection.toString() + ")"); getterArgs = null; // make the compiler happy typeInfo = null; } @@ -150,7 +151,8 @@ InputStream getValue() throws SQLServerException { this.con = null; this.getterArgs = getterArgs; this.typeInfo = typeInfo; - logger.fine(toString() + " created by (null connection)"); + if (logger.isLoggable(java.util.logging.Level.FINE)) + logger.fine(toString() + " created by (null connection)"); } InputStream getStream() { diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java index 7c3c28685b..7f166b0723 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerStatement.java @@ -21,6 +21,7 @@ import java.util.StringTokenizer; import java.util.Vector; import java.util.concurrent.atomic.AtomicInteger; +import java.util.logging.Level; import java.util.regex.Matcher; import java.util.regex.Pattern; @@ -603,11 +604,15 @@ private static int nextStatementID() { setDefaultQueryTimeout(); setDefaultQueryCancelTimeout(); - stmtlogger.finer("Properties for " + toString() + ":" + " Result type:" + appResultSetType + " (" - + resultSetType + ")" + " Concurrency:" + resultSetConcurrency + " Fetchsize:" + nFetchSize - + " bIsClosed:" + bIsClosed + " useLastUpdateCount:" + connection.useLastUpdateCount()); + if (stmtlogger.isLoggable(java.util.logging.Level.FINER)) { + stmtlogger.finer("Properties for " + toString() + ":" + " Result type:" + appResultSetType + " (" + + resultSetType + ")" + " Concurrency:" + resultSetConcurrency + " Fetchsize:" + nFetchSize + + " bIsClosed:" + bIsClosed + " useLastUpdateCount:" + connection.useLastUpdateCount()); + } - stmtlogger.fine(toString() + " created by (" + connection.toString() + ")"); + if (stmtlogger.isLoggable(java.util.logging.Level.FINE)) { + stmtlogger.fine(toString() + " created by (" + connection.toString() + ")"); + } } private void setDefaultQueryCancelTimeout() { @@ -676,7 +681,7 @@ public void closeOnCompletion() throws SQLException { @Override public java.sql.ResultSet executeQuery(String sql) throws SQLServerException, SQLTimeoutException { loggerExternal.entering(getClassNameLogging(), "executeQuery", sql); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -694,7 +699,7 @@ final SQLServerResultSet executeQueryInternal(String sql) throws SQLServerExcept @Override public int executeUpdate(String sql) throws SQLServerException, SQLTimeoutException { loggerExternal.entering(getClassNameLogging(), "executeUpdate", sql); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -714,7 +719,7 @@ public int executeUpdate(String sql) throws SQLServerException, SQLTimeoutExcept public long executeLargeUpdate(String sql) throws SQLServerException, SQLTimeoutException { loggerExternal.entering(getClassNameLogging(), "executeLargeUpdate", sql); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -727,7 +732,7 @@ public long executeLargeUpdate(String sql) throws SQLServerException, SQLTimeout @Override public boolean execute(String sql) throws SQLServerException, SQLTimeoutException { loggerExternal.entering(getClassNameLogging(), "execute", sql); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -820,11 +825,12 @@ final void doExecuteStatement(StmtExecCmd execCmd) throws SQLServerException { // Note: similar logic in SQLServerPreparedStatement.doExecutePreparedStatement setMaxRowsAndMaxFieldSize(); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } if (isCursorable(executeMethod) && isSelect(sql)) { - stmtlogger.fine(toString() + " Executing server side cursor " + sql); + if (stmtlogger.isLoggable(java.util.logging.Level.FINE)) + stmtlogger.fine(toString() + " Executing server side cursor " + sql); doExecuteCursored(execCmd, sql); } else // Non-cursored execution (includes EXECUTE_QUERY_INTERNAL) @@ -844,7 +850,8 @@ final void doExecuteStatement(StmtExecCmd execCmd) throws SQLServerException { tdsWriter.writeString(identityQuery); } - stmtlogger.fine(toString() + " Executing (not server cursor) " + sql); + if (stmtlogger.isLoggable(java.util.logging.Level.FINE)) + stmtlogger.fine(toString() + " Executing (not server cursor) " + sql); // Start the response ensureExecuteResultsReader(execCmd.startResponse(isResponseBufferingAdaptive)); @@ -894,7 +901,7 @@ private void doExecuteStatementBatch(StmtBatchExecCmd execCmd) throws SQLServerE // Make sure any previous maxRows limitation on the connection is removed. connection.setMaxRows(0); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } @@ -1087,7 +1094,8 @@ public final long getLargeMaxRows() throws SQLServerException { @Override public final void setMaxRows(int max) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setMaxRows", max); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setMaxRows", max); checkClosed(); if (max < 0) { MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_invalidRowcount")); @@ -1106,7 +1114,8 @@ public final void setMaxRows(int max) throws SQLServerException { @Override public final void setLargeMaxRows(long max) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setLargeMaxRows", max); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setLargeMaxRows", max); // SQL server only supports integer limits for setting max rows. // If is bigger than integer limits then throw an exception, otherwise call setMaxRows(int) @@ -1119,7 +1128,8 @@ public final void setLargeMaxRows(long max) throws SQLServerException { @Override public final void setEscapeProcessing(boolean enable) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setEscapeProcessing", enable); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setEscapeProcessing", enable); checkClosed(); escapeProcessing = enable; loggerExternal.exiting(getClassNameLogging(), "setEscapeProcessing"); @@ -1273,8 +1283,10 @@ final void processResults() throws SQLServerException { if (moreResults) { // Silently discard database errors and continue processing the remaining results if (SQLServerException.DRIVER_ERROR_FROM_DATABASE == e.getDriverErrorCode()) { - stmtlogger - .finest(this + " ignoring database error: " + e.getErrorCode() + " " + e.getMessage()); + if (stmtlogger.isLoggable(java.util.logging.Level.FINEST)) { + stmtlogger.finest( + this + " ignoring database error: " + e.getErrorCode() + " " + e.getMessage()); + } continue; } @@ -1659,7 +1671,8 @@ boolean consumeExecOutParam(TDSReader tdsReader) throws SQLServerException { @Override public final void setFetchDirection(int nDir) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setFetchDirection", nDir); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setFetchDirection", nDir); checkClosed(); if ((ResultSet.FETCH_FORWARD != nDir && ResultSet.FETCH_REVERSE != nDir && ResultSet.FETCH_UNKNOWN != nDir) || @@ -1684,7 +1697,8 @@ public final int getFetchDirection() throws SQLServerException { @Override public final void setFetchSize(int rows) throws SQLServerException { - loggerExternal.entering(getClassNameLogging(), "setFetchSize", rows); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "setFetchSize", rows); checkClosed(); if (rows < 0) SQLServerException.makeFromDriverError(connection, this, @@ -1746,7 +1760,7 @@ public void clearBatch() throws SQLServerException { @Override public int[] executeBatch() throws SQLServerException, BatchUpdateException, SQLTimeoutException { loggerExternal.entering(getClassNameLogging(), "executeBatch"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -1823,7 +1837,7 @@ public int[] executeBatch() throws SQLServerException, BatchUpdateException, SQL public long[] executeLargeBatch() throws SQLServerException, BatchUpdateException, SQLTimeoutException { loggerExternal.entering(getClassNameLogging(), "executeLargeBatch"); - if (Util.IsActivityTraceOn()) { + if (loggerExternal.isLoggable(Level.FINER) && Util.IsActivityTraceOn()) { loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); } checkClosed(); @@ -1960,8 +1974,10 @@ final int getResultSetCCOpt() { } private void doExecuteCursored(StmtExecCmd execCmd, String sql) throws SQLServerException { - stmtlogger.finer(toString() + " Execute for cursor open" + " SQL:" + sql + " Scrollability:" - + getResultSetScrollOpt() + " Concurrency:" + getResultSetCCOpt()); + if (stmtlogger.isLoggable(java.util.logging.Level.FINER)) { + stmtlogger.finer(toString() + " Execute for cursor open" + " SQL:" + sql + " Scrollability:" + + getResultSetScrollOpt() + " Concurrency:" + getResultSetCCOpt()); + } executedSqlDirectly = false; expectCursorOutParams = true; @@ -2005,9 +2021,11 @@ public final int getResultSetHoldability() throws SQLException { @Override public final boolean execute(java.lang.String sql, int autoGeneratedKeys) throws SQLServerException, SQLTimeoutException { - loggerExternal.entering(getClassNameLogging(), "execute", new Object[] {sql, autoGeneratedKeys}); - if (Util.IsActivityTraceOn()) { - loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) { + loggerExternal.entering(getClassNameLogging(), "execute", new Object[] {sql, autoGeneratedKeys}); + if (Util.IsActivityTraceOn()) { + loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); + } } checkClosed(); if (autoGeneratedKeys != Statement.RETURN_GENERATED_KEYS && autoGeneratedKeys != Statement.NO_GENERATED_KEYS) { @@ -2024,7 +2042,8 @@ public final boolean execute(java.lang.String sql, @Override public final boolean execute(java.lang.String sql, int[] columnIndexes) throws SQLServerException, SQLTimeoutException { - loggerExternal.entering(getClassNameLogging(), "execute", new Object[] {sql, columnIndexes}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "execute", new Object[] {sql, columnIndexes}); checkClosed(); if (columnIndexes == null || columnIndexes.length != 1) { SQLServerException.makeFromDriverError(connection, this, @@ -2038,7 +2057,8 @@ public final boolean execute(java.lang.String sql, @Override public final boolean execute(java.lang.String sql, java.lang.String[] columnNames) throws SQLServerException, SQLTimeoutException { - loggerExternal.entering(getClassNameLogging(), "execute", new Object[] {sql, columnNames}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "execute", new Object[] {sql, columnNames}); checkClosed(); if (columnNames == null || columnNames.length != 1) { SQLServerException.makeFromDriverError(connection, this, @@ -2051,9 +2071,11 @@ public final boolean execute(java.lang.String sql, @Override public final int executeUpdate(String sql, int autoGeneratedKeys) throws SQLServerException, SQLTimeoutException { - loggerExternal.entering(getClassNameLogging(), "executeUpdate", new Object[] {sql, autoGeneratedKeys}); - if (Util.IsActivityTraceOn()) { - loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) { + loggerExternal.entering(getClassNameLogging(), "executeUpdate", new Object[] {sql, autoGeneratedKeys}); + if (Util.IsActivityTraceOn()) { + loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); + } } checkClosed(); if (autoGeneratedKeys != Statement.RETURN_GENERATED_KEYS && autoGeneratedKeys != Statement.NO_GENERATED_KEYS) { @@ -2077,9 +2099,11 @@ public final int executeUpdate(String sql, int autoGeneratedKeys) throws SQLServ public final long executeLargeUpdate(String sql, int autoGeneratedKeys) throws SQLServerException, SQLTimeoutException { - loggerExternal.entering(getClassNameLogging(), "executeLargeUpdate", new Object[] {sql, autoGeneratedKeys}); - if (Util.IsActivityTraceOn()) { - loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) { + loggerExternal.entering(getClassNameLogging(), "executeLargeUpdate", new Object[] {sql, autoGeneratedKeys}); + if (Util.IsActivityTraceOn()) { + loggerExternal.finer(toString() + " ActivityId: " + ActivityCorrelator.getNext().toString()); + } } checkClosed(); if (autoGeneratedKeys != Statement.RETURN_GENERATED_KEYS && autoGeneratedKeys != Statement.NO_GENERATED_KEYS) { @@ -2095,7 +2119,8 @@ public final long executeLargeUpdate(String sql, @Override public final int executeUpdate(java.lang.String sql, int[] columnIndexes) throws SQLServerException, SQLTimeoutException { - loggerExternal.entering(getClassNameLogging(), "executeUpdate", new Object[] {sql, columnIndexes}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "executeUpdate", new Object[] {sql, columnIndexes}); checkClosed(); if (columnIndexes == null || columnIndexes.length != 1) { SQLServerException.makeFromDriverError(connection, this, @@ -2110,7 +2135,8 @@ public final int executeUpdate(java.lang.String sql, public final long executeLargeUpdate(java.lang.String sql, int[] columnIndexes) throws SQLServerException, SQLTimeoutException { - loggerExternal.entering(getClassNameLogging(), "executeLargeUpdate", new Object[] {sql, columnIndexes}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "executeLargeUpdate", new Object[] {sql, columnIndexes}); checkClosed(); if (columnIndexes == null || columnIndexes.length != 1) { SQLServerException.makeFromDriverError(connection, this, @@ -2124,7 +2150,8 @@ public final long executeLargeUpdate(java.lang.String sql, @Override public final int executeUpdate(java.lang.String sql, String[] columnNames) throws SQLServerException, SQLTimeoutException { - loggerExternal.entering(getClassNameLogging(), "executeUpdate", new Object[] {sql, columnNames}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "executeUpdate", new Object[] {sql, columnNames}); checkClosed(); if (columnNames == null || columnNames.length != 1) { SQLServerException.makeFromDriverError(connection, this, @@ -2139,7 +2166,8 @@ public final int executeUpdate(java.lang.String sql, public final long executeLargeUpdate(java.lang.String sql, String[] columnNames) throws SQLServerException, SQLTimeoutException { - loggerExternal.entering(getClassNameLogging(), "executeLargeUpdate", new Object[] {sql, columnNames}); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "executeLargeUpdate", new Object[] {sql, columnNames}); checkClosed(); if (columnNames == null || columnNames.length != 1) { SQLServerException.makeFromDriverError(connection, this, @@ -2175,7 +2203,8 @@ public final ResultSet getGeneratedKeys() throws SQLServerException { @Override public final boolean getMoreResults(int mode) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "getMoreResults", mode); + if (loggerExternal.isLoggable(java.util.logging.Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getMoreResults", mode); checkClosed(); if (KEEP_CURRENT_RESULT == mode) { SQLServerException.throwNotSupportedException(connection, this); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerSymmetricKeyCache.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerSymmetricKeyCache.java index f780a23001..bebb43e98b 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerSymmetricKeyCache.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerSymmetricKeyCache.java @@ -36,7 +36,9 @@ public void run() { if (instance.getCache().containsKey(keylookupValue)) { instance.getCache().get(keylookupValue).zeroOutKey(); instance.getCache().remove(keylookupValue); - aeLogger.fine("Removed encryption key from cache..."); + if (aeLogger.isLoggable(java.util.logging.Level.FINE)) { + aeLogger.fine("Removed encryption key from cache..."); + } } } } @@ -102,7 +104,9 @@ SQLServerSymmetricKey getKey(EncryptionKeyInfo keyInfo, SQLServerConnection conn keyLookupValue = keyLookupValuebuffer.toString(); keyLookupValuebuffer.setLength(0); // Get rid of the buffer, will be garbage collected. - aeLogger.fine("Checking trusted master key path..."); + if (aeLogger.isLoggable(java.util.logging.Level.FINE)) { + aeLogger.fine("Checking trusted master key path..."); + } Boolean[] hasEntry = new Boolean[1]; List trustedKeyPaths = SQLServerConnection.getColumnEncryptionTrustedMasterKeyPaths(serverName, hasEntry); @@ -115,7 +119,9 @@ SQLServerSymmetricKey getKey(EncryptionKeyInfo keyInfo, SQLServerConnection conn } } - aeLogger.fine("Checking Symmetric key cache..."); + if (aeLogger.isLoggable(java.util.logging.Level.FINE)) { + aeLogger.fine("Checking Symmetric key cache..."); + } // if ColumnEncryptionKeyCacheTtl is 0 no caching at all if (!cache.containsKey(keyLookupValue)) { @@ -160,7 +166,9 @@ SQLServerSymmetricKey getKey(EncryptionKeyInfo keyInfo, SQLServerConnection conn long columnEncryptionKeyCacheTtl = SQLServerConnection.getColumnEncryptionKeyCacheTtl(); if (0 != columnEncryptionKeyCacheTtl) { cache.putIfAbsent(keyLookupValue, encryptionKey); - aeLogger.fine("Adding encryption key to cache..."); + if (aeLogger.isLoggable(java.util.logging.Level.FINE)) { + aeLogger.fine("Adding encryption key to cache..."); + } scheduler.schedule(new CacheClear(keyLookupValue), columnEncryptionKeyCacheTtl, SECONDS); } } else { diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAConnection.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAConnection.java index e85f251b5c..bfb18780ca 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAConnection.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAConnection.java @@ -7,6 +7,7 @@ import java.sql.SQLException; import java.util.Properties; +import java.util.logging.Level; import java.util.logging.Logger; import javax.sql.XAConnection; @@ -39,7 +40,8 @@ public final class SQLServerXAConnection extends SQLServerPooledConnection imple .setProperty(SQLServerDriverBooleanProperty.SEND_STRING_PARAMETERS_AS_UNICODE.toString(), "true"); controlConnectionProperties.remove(SQLServerDriverStringProperty.SELECT_METHOD.toString()); - xaLogger.finer("Creating an internal control connection for" + toString()); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer("Creating an internal control connection for" + toString()); physicalControlConnection = null; if (Util.use43Wrapper()) { physicalControlConnection = new SQLServerConnection43(toString()); @@ -47,10 +49,12 @@ public final class SQLServerXAConnection extends SQLServerPooledConnection imple physicalControlConnection = new SQLServerConnection(toString()); } physicalControlConnection.connect(controlConnectionProperties, null); - xaLogger.finer("Created an internal control connection" + physicalControlConnection.toString() + " for " - + toString() + " Physical connection:" + getPhysicalConnection().toString()); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer("Created an internal control connection" + physicalControlConnection.toString() + " for " + + toString() + " Physical connection:" + getPhysicalConnection().toString()); - xaLogger.finer(ds.toString() + " user:" + user); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(ds.toString() + " user:" + user); } @Override diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXADataSource.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXADataSource.java index c53ac404ff..6ba0504b7a 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXADataSource.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXADataSource.java @@ -6,6 +6,7 @@ package com.microsoft.sqlserver.jdbc; import java.sql.SQLException; +import java.util.logging.Level; import java.util.logging.Logger; import javax.naming.Reference; @@ -53,20 +54,26 @@ public final class SQLServerXADataSource extends SQLServerConnectionPoolDataSour */ @Override public XAConnection getXAConnection(String user, String password) throws SQLException { - loggerExternal.entering(getClassNameLogging(), "getXAConnection", new Object[] {user, "Password not traced"}); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getXAConnection", + new Object[] {user, "Password not traced"}); SQLServerXAConnection pooledXAConnection = new SQLServerXAConnection(this, user, password); - xaLogger.finer(toString() + " user:" + user + pooledXAConnection.toString()); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString() + " user:" + user + pooledXAConnection.toString()); // Don't start a transaction here but do mark the connection as autocommit false. // We cannot start a transaction since XA transaction type 'NEVER' does not start a transaction // Autocommit of false is required to ensure that the transaction manager's calls to commit and // rollback work correctly. - xaLogger.finer(toString() + " Start get physical connection."); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString() + " Start get physical connection."); SQLServerConnection physicalConnection = pooledXAConnection.getPhysicalConnection(); - xaLogger.fine(toString() + " End get physical connection, " + physicalConnection.toString()); - loggerExternal.exiting(getClassNameLogging(), "getXAConnection", pooledXAConnection); + if (xaLogger.isLoggable(Level.FINE)) + xaLogger.fine(toString() + " End get physical connection, " + physicalConnection.toString()); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.exiting(getClassNameLogging(), "getXAConnection", pooledXAConnection); return pooledXAConnection; } @@ -80,7 +87,8 @@ public XAConnection getXAConnection(String user, String password) throws SQLExce */ @Override public XAConnection getXAConnection() throws SQLException { - loggerExternal.entering(getClassNameLogging(), "getXAConnection"); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getXAConnection"); return getXAConnection(getUser(), getPassword()); } @@ -88,9 +96,11 @@ public XAConnection getXAConnection() throws SQLException { @Override public Reference getReference() { - loggerExternal.entering(getClassNameLogging(), "getReference"); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.entering(getClassNameLogging(), "getReference"); Reference ref = getReferenceInternal("com.microsoft.sqlserver.jdbc.SQLServerXADataSource"); - loggerExternal.exiting(getClassNameLogging(), "getReference", ref); + if (loggerExternal.isLoggable(Level.FINER)) + loggerExternal.exiting(getClassNameLogging(), "getReference", ref); return ref; } diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAResource.java b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAResource.java index cde82b0869..224996a90f 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAResource.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SQLServerXAResource.java @@ -194,7 +194,8 @@ public String toString() { + p.getProperty(SQLServerDriverStringProperty.DATABASE_NAME.toString()) + "." + p.getProperty(SQLServerDriverIntProperty.PORT_NUMBER.toString()); } - xaLogger.fine(toString() + " created by (" + loginfo + ")"); + if (xaLogger.isLoggable(Level.FINE)) + xaLogger.fine(toString() + " created by (" + loginfo + ")"); // Information about the server, needed for XA timeout logic in the DLL. serverInfoRetrieved = false; @@ -266,7 +267,8 @@ final synchronized void close() throws SQLServerException { try { closeXAStatements(); } catch (Exception e) { - xaLogger.warning(toString() + "Closing exception ignored: " + e); + if (xaLogger.isLoggable(Level.WARNING)) + xaLogger.warning(toString() + "Closing exception ignored: " + e); } if (null != controlConnection) @@ -360,8 +362,9 @@ private String typeDisplay(int type) { private XAReturnValue DTC_XA_Interface(int nType, Xid xid, int xaFlags) throws XAException { - xaLogger.finer(toString() + " Calling XA function for type:" + typeDisplay(nType) + " flags:" - + flagsDisplay(xaFlags) + " xid:" + XidImpl.xidDisplay(xid)); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString() + " Calling XA function for type:" + typeDisplay(nType) + " flags:" + + flagsDisplay(xaFlags) + " xid:" + XidImpl.xidDisplay(xid)); int formatId = 0; byte gid[] = null; @@ -399,13 +402,16 @@ private XAReturnValue DTC_XA_Interface(int nType, Xid xid, int xaFlags) throws X controlConnection.close(); } catch (SQLException e3) { // we really want to ignore this failue - xaLogger.finer(toString() - + " Ignoring exception when closing failed execution. exception:" + e3); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString() + + " Ignoring exception when closing failed execution. exception:" + e3); } - xaLogger.finer(toString() + " exception:" + eX); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString() + " exception:" + eX); throw eX; } catch (SQLTimeoutException e4) { - xaLogger.finer(toString() + " exception:" + e4); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString() + " exception:" + e4); throw new SQLServerException(e4.getMessage(), SQLState.STATEMENT_CANCELED, DriverError.NOT_SET, null); } @@ -414,7 +420,8 @@ private XAReturnValue DTC_XA_Interface(int nType, Xid xid, int xaFlags) throws X int initStatus = initCS.getInt(1); String initErr = initCS.getString(2); String versionNumberXADLL = initCS.getString(3); - xaLogger.fine(toString() + " Server XA DLL version:" + versionNumberXADLL); + if (xaLogger.isLoggable(Level.FINE)) + xaLogger.fine(toString() + " Server XA DLL version:" + versionNumberXADLL); initCS.close(); if (XA_OK != initStatus) { assert null != initErr && initErr.length() > 1; @@ -425,7 +432,8 @@ private XAReturnValue DTC_XA_Interface(int nType, Xid xid, int xaFlags) throws X Object[] msgArgs = {String.valueOf(initStatus), initErr}; XAException xex = new XAException(form.format(msgArgs)); xex.errorCode = initStatus; - xaLogger.finer(toString() + " exception:" + xex); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString() + " exception:" + xex); throw xex; } } @@ -433,7 +441,8 @@ private XAReturnValue DTC_XA_Interface(int nType, Xid xid, int xaFlags) throws X MessageFormat form = new MessageFormat( SQLServerException.getErrString("R_failedToCreateXAConnection")); Object[] msgArgs = {e1.getMessage()}; - xaLogger.finer(toString() + " exception:" + form.format(msgArgs)); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString() + " exception:" + form.format(msgArgs)); SQLServerException.makeFromDriverError(null, null, form.format(msgArgs), null, true); } xaInitDone = true; @@ -480,13 +489,16 @@ private XAReturnValue DTC_XA_Interface(int nType, Xid xid, int xaFlags) throws X // Got caught in static analysis. Catch only the thrown exceptions, do not catch // run time exceptions. catch (Exception e) { - xaLogger.warning(toString() + " Cannot retrieve server information: :" + e.getMessage()); + if (xaLogger.isLoggable(Level.WARNING)) + xaLogger.warning( + toString() + " Cannot retrieve server information: :" + e.getMessage()); } finally { if (null != stmt) try { stmt.close(); } catch (SQLException e) { - xaLogger.finer(toString()); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString()); } } } @@ -652,13 +664,16 @@ private XAReturnValue DTC_XA_Interface(int nType, Xid xid, int xaFlags) throws X // if the request is end make sure we delist from the DTC transaction on rm failure. if (nType == XA_END && (XAException.XAER_RMFAIL == nStatus)) { try { - xaLogger.finer(toString() + " Begin un-enlist, enlisted count:" + enlistedTransactionCount); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString() + " Begin un-enlist, enlisted count:" + enlistedTransactionCount); con.JTAUnenlistConnection(); enlistedTransactionCount--; - xaLogger.finer(toString() + " End un-enlist, enlisted count:" + enlistedTransactionCount); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString() + " End un-enlist, enlisted count:" + enlistedTransactionCount); } catch (SQLServerException e1) { // ignore this message as the previous error message is more important. - xaLogger.finer(toString() + " Ignoring exception:" + e1); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString() + " Ignoring exception:" + e1); } } throw e; @@ -674,12 +689,15 @@ private XAReturnValue DTC_XA_Interface(int nType, Xid xid, int xaFlags) throws X } else { try { - xaLogger.finer(toString() + " Begin enlisting, cookie:" + cookieDisplay(transactionCookie) - + " enlisted count:" + enlistedTransactionCount); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer( + toString() + " Begin enlisting, cookie:" + cookieDisplay(transactionCookie) + + " enlisted count:" + enlistedTransactionCount); con.JTAEnlistConnection(transactionCookie); enlistedTransactionCount++; - xaLogger.finer(toString() + " End enlisting, cookie:" + cookieDisplay(transactionCookie) - + " enlisted count:" + enlistedTransactionCount); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString() + " End enlisting, cookie:" + cookieDisplay(transactionCookie) + + " enlisted count:" + enlistedTransactionCount); } catch (SQLServerException e1) { MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_failedToEnlist")); Object[] msgArgs = {e1.getMessage()}; @@ -689,10 +707,12 @@ private XAReturnValue DTC_XA_Interface(int nType, Xid xid, int xaFlags) throws X } if (nType == XA_END) { try { - xaLogger.finer(toString() + " Begin un-enlist, enlisted count:" + enlistedTransactionCount); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString() + " Begin un-enlist, enlisted count:" + enlistedTransactionCount); con.JTAUnenlistConnection(); enlistedTransactionCount--; - xaLogger.finer(toString() + " End un-enlist, enlisted count:" + enlistedTransactionCount); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString() + " End un-enlist, enlisted count:" + enlistedTransactionCount); } catch (SQLServerException e1) { MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_failedToUnEnlist")); Object[] msgArgs = {e1.getMessage()}; @@ -713,13 +733,15 @@ private XAReturnValue DTC_XA_Interface(int nType, Xid xid, int xaFlags) throws X } } } catch (SQLServerException | SQLTimeoutException ex) { - xaLogger.finer(toString() + " exception:" + ex); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString() + " exception:" + ex); XAException e = new XAException(ex.toString()); e.errorCode = XAException.XAER_RMERR; throw e; } - xaLogger.finer(toString() + " Status:" + nStatus); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString() + " Status:" + nStatus); returnStatus.nStatus = nStatus; return returnStatus; @@ -837,7 +859,8 @@ public Xid[] recover(int flags) throws XAException { XidImpl xids[] = new XidImpl[al.size()]; for (int i = 0; i < al.size(); i++) { xids[i] = al.get(i); - xaLogger.finer(toString() + xids[i].toString()); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString() + xids[i].toString()); } return xids; } @@ -846,7 +869,8 @@ public Xid[] recover(int flags) throws XAException { public boolean isSameRM(XAResource xares) throws XAException { // A Resource Manager (RM) is an instance of a connection to a DB - xaLogger.finer(toString() + " xares:" + xares); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString() + " xares:" + xares); // Change to return true if its the same database physical connection if (!(xares instanceof SQLServerXAResource)) @@ -860,7 +884,8 @@ public boolean setTransactionTimeout(int seconds) throws XAException { isTransacrionTimeoutSet = 1; timeoutSeconds = seconds; - xaLogger.finer(toString() + " TransactionTimeout:" + seconds); + if (xaLogger.isLoggable(Level.FINER)) + xaLogger.finer(toString() + " TransactionTimeout:" + seconds); return true; } diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/ScrollWindow.java b/src/main/java/com/microsoft/sqlserver/jdbc/ScrollWindow.java index 9862ebc7a2..3ae4f6053f 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/ScrollWindow.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/ScrollWindow.java @@ -89,7 +89,8 @@ final String logCursorState() { } final boolean next(SQLServerResultSet rs) throws SQLServerException { - SQLServerResultSet.logger.finer(rs.toString() + logCursorState()); + if (SQLServerResultSet.logger.isLoggable(java.util.logging.Level.FINER)) + SQLServerResultSet.logger.finer(rs.toString() + logCursorState()); // Precondition: // Current position should always be on a row in the window or @@ -145,8 +146,9 @@ final boolean next(SQLServerResultSet rs) throws SQLServerException { rowMark[currentRow - 1] = rs.fetchBufferMark(); rowType[currentRow - 1] = rs.getCurrentRowType(); - SQLServerResultSet.logger.finest(rs.toString() + " Set mark " + rowMark[currentRow - 1] + " for row " - + currentRow + " of type " + rowType[currentRow - 1]); + if (SQLServerResultSet.logger.isLoggable(java.util.logging.Level.FINEST)) + SQLServerResultSet.logger.finest(rs.toString() + " Set mark " + rowMark[currentRow - 1] + " for row " + + currentRow + " of type " + rowType[currentRow - 1]); return true; } @@ -159,7 +161,8 @@ final boolean next(SQLServerResultSet rs) throws SQLServerException { } final void previous(SQLServerResultSet rs) throws SQLServerException { - SQLServerResultSet.logger.finer(rs.toString() + logCursorState()); + if (SQLServerResultSet.logger.isLoggable(java.util.logging.Level.FINER)) + SQLServerResultSet.logger.finer(rs.toString() + logCursorState()); // Precondition: // Current position should always be on a row in the window or diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/SimpleInputStream.java b/src/main/java/com/microsoft/sqlserver/jdbc/SimpleInputStream.java index 93aadb7413..4586ef3895 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/SimpleInputStream.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/SimpleInputStream.java @@ -24,7 +24,7 @@ abstract class BaseInputStream extends InputStream { // Flag indicating whether the stream consumes and discards data as it reads it final boolean isStreaming; - + // Stated length of the payload int payloadLength; @@ -48,7 +48,8 @@ final public String toString() { final void setLoggingInfo(String info) { parentLoggingInfo = info; - logger.finer(toString()); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString()); } int streamPos = 0; @@ -80,7 +81,8 @@ final void clearCurrentMark() { void closeHelper() throws IOException { if (isAdaptive && null != dtv) { - logger.finer(toString() + " closing the adaptive stream."); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + " closing the adaptive stream."); dtv.setPositionAfterStreamed(tdsReader); } currentMark = null; @@ -151,7 +153,8 @@ final class SimpleInputStream extends BaseInputStream { public void close() throws IOException { if (null == tdsReader) return; - logger.finer(toString() + "Enter Closing SimpleInputStream."); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + "Enter Closing SimpleInputStream."); // Discard the remainder of the stream, positioning the TDSReader // at the next item in the TDS response. Once the stream is closed, @@ -159,7 +162,8 @@ public void close() throws IOException { skip(payloadLength - streamPos); closeHelper(); - logger.finer(toString() + "Exit Closing SimpleInputStream."); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + "Exit Closing SimpleInputStream."); } /** @@ -186,7 +190,8 @@ private boolean isEOS() throws IOException { */ public long skip(long n) throws IOException { checkClosed(); - logger.finer(toString() + " Skipping :" + n); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + " Skipping :" + n); if (n < 0) return 0L; if (isEOS()) @@ -277,8 +282,9 @@ public int read(byte[] b) throws IOException { */ public int read(byte b[], int offset, int maxBytes) throws IOException { checkClosed(); - logger.finer(toString() + " Reading " + maxBytes + " from stream offset " + streamPos + " payload length " - + payloadLength); + if (logger.isLoggable(java.util.logging.Level.FINER)) + logger.finer(toString() + " Reading " + maxBytes + " from stream offset " + streamPos + " payload length " + + payloadLength); if (offset < 0 || maxBytes < 0 || offset + maxBytes > b.length) throw new IndexOutOfBoundsException(); diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/Util.java b/src/main/java/com/microsoft/sqlserver/jdbc/Util.java index a7689bf439..76617d31a0 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/Util.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/Util.java @@ -285,7 +285,9 @@ static void writeLong(long value, byte valueBytes[], int offset) { result = result.trim(); if (result.length() > 0) { p.put(SQLServerDriverStringProperty.SERVER_NAME.toString(), result); - logger.fine("Property:serverName " + "Value:" + result); + if (logger.isLoggable(Level.FINE)) { + logger.fine("Property:serverName " + "Value:" + result); + } } result = ""; @@ -308,7 +310,9 @@ else if (ch == ':') case inPort: { if (ch == ';') { result = result.trim(); - logger.fine("Property:portNumber " + "Value:" + result); + if (logger.isLoggable(Level.FINE)) { + logger.fine("Property:portNumber " + "Value:" + result); + } p.put(SQLServerDriverIntProperty.PORT_NUMBER.toString(), result); result = ""; state = inName; @@ -325,7 +329,9 @@ else if (ch == ':') if (ch == ';' || ch == ':') { // non escaped trim the string result = result.trim(); - logger.fine("Property:instanceName " + "Value:" + result); + if (logger.isLoggable(Level.FINE)) { + logger.fine("Property:instanceName " + "Value:" + result); + } p.put(SQLServerDriverStringProperty.INSTANCE_NAME.toString(), result.toLowerCase(Locale.US)); result = ""; @@ -455,18 +461,24 @@ else if (ch == ':') case inServerName: result = result.trim(); if (result.length() > 0) { - logger.fine("Property:serverName " + "Value:" + result); + if (logger.isLoggable(Level.FINE)) { + logger.fine("Property:serverName " + "Value:" + result); + } p.put(SQLServerDriverStringProperty.SERVER_NAME.toString(), result); } break; case inPort: result = result.trim(); - logger.fine("Property:portNumber " + "Value:" + result); + if (logger.isLoggable(Level.FINE)) { + logger.fine("Property:portNumber " + "Value:" + result); + } p.put(SQLServerDriverIntProperty.PORT_NUMBER.toString(), result); break; case inInstanceName: result = result.trim(); - logger.fine("Property:instanceName " + "Value:" + result); + if (logger.isLoggable(Level.FINE)) { + logger.fine("Property:instanceName " + "Value:" + result); + } p.put(SQLServerDriverStringProperty.INSTANCE_NAME.toString(), result); break; case inValue: diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java b/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java index f65be702e5..657cb7e798 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/dtv.java @@ -857,7 +857,7 @@ private void sendTemporal(DTV dtv, JavaType javaType, Object value) throws SQLSe // - java.sql.Types.DATE, use DATE SQL Server data type // - microsoft.sql.Types.DATETIMEOFFSET, use DATETIMEOFFSET SQL Server data type if (conn.isKatmaiOrLater()) { - if (null != cryptoMeta) { + if (aeLogger.isLoggable(java.util.logging.Level.FINE) && (null != cryptoMeta)) { aeLogger.fine("Encrypting temporal data type."); } @@ -1592,7 +1592,7 @@ final void executeOp(DTVExecuteOp op) throws SQLServerException { } } else // null != value { - if (null != cryptoMeta) { + if (aeLogger.isLoggable(java.util.logging.Level.FINE) && (null != cryptoMeta)) { aeLogger.fine("Encrypting java data type: " + javaType); } @@ -3421,8 +3421,10 @@ Object denormalizedValue(byte[] decryptedValue, JDBCType jdbcType, TypeInfo base throw new SQLServerException(form.format(new Object[] {normalizeRuleVersion, 1}), null, 0, null); } - aeLogger.fine("Denormalizing decrypted data based on its SQL Server type(" + baseTypeInfo.getSSType() - + ") and JDBC type(" + jdbcType + ")."); + if (aeLogger.isLoggable(java.util.logging.Level.FINE)) { + aeLogger.fine("Denormalizing decrypted data based on its SQL Server type(" + baseTypeInfo.getSSType() + + ") and JDBC type(" + jdbcType + ")."); + } SSType baseSSType = baseTypeInfo.getSSType(); switch (baseSSType) { @@ -3657,8 +3659,10 @@ Object getValue(DTV dtv, JDBCType jdbcType, int scale, InputStreamGetterArgs str baseSSType = cryptoMetadata.baseTypeInfo.getSSType(); encrypted = true; - aeLogger.fine("Data is encrypted, SQL Server Data Type: " + baseSSType + ", Encryption Type: " - + cryptoMetadata.getEncryptionType()); + if (aeLogger.isLoggable(java.util.logging.Level.FINE)) { + aeLogger.fine("Data is encrypted, SQL Server Data Type: " + baseSSType + ", Encryption Type: " + + cryptoMetadata.getEncryptionType()); + } } // Note that the value should be prepped @@ -3711,7 +3715,9 @@ Object getValue(DTV dtv, JDBCType jdbcType, int scale, InputStreamGetterArgs str JDBCType.VARBINARY, streamGetterArgs); } - aeLogger.fine("Encrypted data is retrieved."); + if (aeLogger.isLoggable(java.util.logging.Level.FINE)) { + aeLogger.fine("Encrypted data is retrieved."); + } // AE does not support streaming types if ((convertedValue instanceof SimpleInputStream) || (convertedValue instanceof PLPInputStream)) { diff --git a/src/main/java/com/microsoft/sqlserver/jdbc/tdsparser.java b/src/main/java/com/microsoft/sqlserver/jdbc/tdsparser.java index 90e42569a1..abfae2a839 100644 --- a/src/main/java/com/microsoft/sqlserver/jdbc/tdsparser.java +++ b/src/main/java/com/microsoft/sqlserver/jdbc/tdsparser.java @@ -5,6 +5,7 @@ package com.microsoft.sqlserver.jdbc; +import java.util.logging.Level; import java.util.logging.Logger; @@ -26,6 +27,7 @@ static void parse(TDSReader tdsReader, String logContext) throws SQLServerExcept } static void parse(TDSReader tdsReader, TDSTokenHandler tdsTokenHandler) throws SQLServerException { + final boolean isLogging = logger.isLoggable(Level.FINEST); // Process TDS tokens from the token stream until we're told to stop. boolean parsing = true; @@ -35,8 +37,10 @@ static void parse(TDSReader tdsReader, TDSTokenHandler tdsTokenHandler) throws S boolean isFeatureExtAck = false; while (parsing) { int tdsTokenType = tdsReader.peekTokenType(); - logger.finest(tdsReader.toString() + ": " + tdsTokenHandler.logContext + ": Processing " - + ((-1 == tdsTokenType) ? "EOF" : TDS.getTokenName(tdsTokenType))); + if (isLogging) { + logger.finest(tdsReader.toString() + ": " + tdsTokenHandler.logContext + ": Processing " + + ((-1 == tdsTokenType) ? "EOF" : TDS.getTokenName(tdsTokenType))); + } switch (tdsTokenType) { case TDS.TDS_SSPI: @@ -114,8 +118,9 @@ static void parse(TDSReader tdsReader, TDSTokenHandler tdsTokenHandler) throws S /* Handle unexpected tokens - throw an exception */ static void throwUnexpectedTokenException(TDSReader tdsReader, String logContext) throws SQLServerException { - logger.severe(tdsReader.toString() + ": " + logContext + ": Encountered unexpected " - + TDS.getTokenName(tdsReader.peekTokenType())); + if (logger.isLoggable(Level.SEVERE)) + logger.severe(tdsReader.toString() + ": " + logContext + ": Encountered unexpected " + + TDS.getTokenName(tdsReader.peekTokenType())); tdsReader.throwInvalidTDSToken(TDS.getTokenName(tdsReader.peekTokenType())); } @@ -222,8 +227,9 @@ boolean onOrder(TDSReader tdsReader) throws SQLServerException { boolean onColMetaData(TDSReader tdsReader) throws SQLServerException { // SHOWPLAN might be ON, instead of throwing an exception, ignore the column meta data - logger.severe(tdsReader.toString() + ": " + logContext + ": Encountered " - + TDS.getTokenName(tdsReader.peekTokenType()) + ". SHOWPLAN is ON, ignoring."); + if (logger.isLoggable(Level.SEVERE)) + logger.severe(tdsReader.toString() + ": " + logContext + ": Encountered " + + TDS.getTokenName(tdsReader.peekTokenType()) + ". SHOWPLAN is ON, ignoring."); return false; } diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/bvt/BvtTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/bvt/BvtTest.java index 6dd760f28e..0d5f768d4e 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/bvt/BvtTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/bvt/BvtTest.java @@ -14,21 +14,23 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; -import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.BeforeAll; -import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Test; import org.junit.platform.runner.JUnitPlatform; import org.junit.runner.RunWith; -import com.microsoft.sqlserver.jdbc.TestResource; import com.microsoft.sqlserver.testframework.AbstractTest; import com.microsoft.sqlserver.testframework.DBConnection; +import com.microsoft.sqlserver.testframework.DBStatement; +import com.microsoft.sqlserver.testframework.DBTable; + +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import com.microsoft.sqlserver.jdbc.TestResource; import com.microsoft.sqlserver.testframework.DBPreparedStatement; import com.microsoft.sqlserver.testframework.DBResultSet; import com.microsoft.sqlserver.testframework.DBResultSetTypes; -import com.microsoft.sqlserver.testframework.DBStatement; -import com.microsoft.sqlserver.testframework.DBTable; @RunWith(JUnitPlatform.class) diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java index 4cac1a8e46..fde8003532 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/callablestatement/CallableStatementTest.java @@ -24,8 +24,8 @@ import com.microsoft.sqlserver.jdbc.SQLServerDataSource; import com.microsoft.sqlserver.jdbc.TestResource; import com.microsoft.sqlserver.jdbc.TestUtils; -import com.microsoft.sqlserver.testframework.AbstractSQLGenerator; import com.microsoft.sqlserver.testframework.AbstractTest; +import com.microsoft.sqlserver.testframework.AbstractSQLGenerator; /** diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/databasemetadata/DatabaseMetaDataTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/databasemetadata/DatabaseMetaDataTest.java index 5bcbcfc672..3a4a054e28 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/databasemetadata/DatabaseMetaDataTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/databasemetadata/DatabaseMetaDataTest.java @@ -22,6 +22,7 @@ import java.sql.Connection; import java.sql.DatabaseMetaData; import java.sql.DriverManager; +import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPNumericTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPNumericTest.java index 49dafa04d6..0cde147303 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPNumericTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPNumericTest.java @@ -4,11 +4,11 @@ */ package com.microsoft.sqlserver.jdbc.tvp; -import java.sql.Connection; -import java.sql.DriverManager; import java.sql.SQLException; import java.sql.SQLTimeoutException; +import java.sql.Connection; import java.sql.Statement; +import java.sql.DriverManager; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach; diff --git a/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPSchemaTest.java b/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPSchemaTest.java index d3165489eb..a375fe044d 100644 --- a/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPSchemaTest.java +++ b/src/test/java/com/microsoft/sqlserver/jdbc/tvp/TVPSchemaTest.java @@ -9,9 +9,9 @@ import java.io.IOException; import java.sql.Connection; import java.sql.DriverManager; -import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; +import java.sql.ResultSet; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.BeforeEach;