source: Ballon/out/artifacts/geisa_artifact/WEB-INF/lib/mysql-connector-java-5.1.21/src/com/mysql/jdbc/LoadBalancedMySQLConnection.java @ 848

Last change on this file since 848 was 766, checked in by npipsl, 11 years ago
File size: 71.5 KB
Line 
1/*
2  Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved.
3
4  The MySQL Connector/J is licensed under the terms of the GPLv2
5  <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most MySQL Connectors.
6  There are special exceptions to the terms and conditions of the GPLv2 as it is applied to
7  this software, see the FLOSS License Exception
8  <http://www.mysql.com/about/legal/licensing/foss-exception.html>.
9
10  This program is free software; you can redistribute it and/or modify it under the terms
11  of the GNU General Public License as published by the Free Software Foundation; version 2
12  of the License.
13
14  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
15  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16  See the GNU General Public License for more details.
17
18  You should have received a copy of the GNU General Public License along with this
19  program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth
20  Floor, Boston, MA 02110-1301  USA
21 
22 */
23package com.mysql.jdbc;
24
25import java.sql.CallableStatement;
26import java.sql.DatabaseMetaData;
27import java.sql.PreparedStatement;
28import java.sql.SQLException;
29import java.sql.SQLWarning;
30import java.sql.Savepoint;
31import java.sql.Statement;
32import java.util.Calendar;
33import java.util.List;
34import java.util.Map;
35import java.util.Properties;
36import java.util.TimeZone;
37import java.util.Timer;
38import java.util.concurrent.Executor;
39
40import com.mysql.jdbc.log.Log;
41
42public class LoadBalancedMySQLConnection implements MySQLConnection {
43
44        protected LoadBalancingConnectionProxy proxy;
45       
46        public LoadBalancingConnectionProxy getProxy(){
47                return this.proxy;
48        }
49
50        protected synchronized MySQLConnection getActiveMySQLConnection() {
51                return this.proxy.currentConn;
52        }
53
54        public LoadBalancedMySQLConnection(LoadBalancingConnectionProxy proxy) {
55                this.proxy = proxy;
56        }
57
58        public void abortInternal() throws SQLException {
59                getActiveMySQLConnection().abortInternal();
60        }
61
62        public void changeUser(String userName, String newPassword)
63                        throws SQLException {
64                getActiveMySQLConnection().changeUser(userName, newPassword);
65        }
66
67        public void checkClosed() throws SQLException {
68                getActiveMySQLConnection().checkClosed();
69        }
70
71        public void clearHasTriedMaster() {
72                getActiveMySQLConnection().clearHasTriedMaster();
73        }
74
75        public void clearWarnings() throws SQLException {
76                getActiveMySQLConnection().clearWarnings();
77        }
78
79        public PreparedStatement clientPrepareStatement(String sql,
80                        int resultSetType, int resultSetConcurrency,
81                        int resultSetHoldability) throws SQLException {
82                return getActiveMySQLConnection().clientPrepareStatement(sql,
83                                resultSetType, resultSetConcurrency, resultSetHoldability);
84        }
85
86        public PreparedStatement clientPrepareStatement(String sql,
87                        int resultSetType, int resultSetConcurrency) throws SQLException {
88                return getActiveMySQLConnection().clientPrepareStatement(sql,
89                                resultSetType, resultSetConcurrency);
90        }
91
92        public PreparedStatement clientPrepareStatement(String sql,
93                        int autoGenKeyIndex) throws SQLException {
94                return getActiveMySQLConnection().clientPrepareStatement(sql,
95                                autoGenKeyIndex);
96        }
97
98        public PreparedStatement clientPrepareStatement(String sql,
99                        int[] autoGenKeyIndexes) throws SQLException {
100                return getActiveMySQLConnection().clientPrepareStatement(sql,
101                                autoGenKeyIndexes);
102        }
103
104        public PreparedStatement clientPrepareStatement(String sql,
105                        String[] autoGenKeyColNames) throws SQLException {
106                return getActiveMySQLConnection().clientPrepareStatement(sql,
107                                autoGenKeyColNames);
108        }
109
110        public PreparedStatement clientPrepareStatement(String sql)
111                        throws SQLException {
112                return getActiveMySQLConnection().clientPrepareStatement(sql);
113        }
114
115        public synchronized void close() throws SQLException {
116                getActiveMySQLConnection().close();
117        }
118
119        public void commit() throws SQLException {
120                getActiveMySQLConnection().commit();
121        }
122
123        public void createNewIO(boolean isForReconnect) throws SQLException {
124                getActiveMySQLConnection().createNewIO(isForReconnect);
125        }
126
127        public Statement createStatement() throws SQLException {
128                return getActiveMySQLConnection().createStatement();
129        }
130
131        public Statement createStatement(int resultSetType,
132                        int resultSetConcurrency, int resultSetHoldability)
133                        throws SQLException {
134                return getActiveMySQLConnection().createStatement(resultSetType,
135                                resultSetConcurrency, resultSetHoldability);
136        }
137
138        public Statement createStatement(int resultSetType, int resultSetConcurrency)
139                        throws SQLException {
140                return getActiveMySQLConnection().createStatement(resultSetType,
141                                resultSetConcurrency);
142        }
143
144        public void dumpTestcaseQuery(String query) {
145                getActiveMySQLConnection().dumpTestcaseQuery(query);
146        }
147
148        public Connection duplicate() throws SQLException {
149                return getActiveMySQLConnection().duplicate();
150        }
151
152        public ResultSetInternalMethods execSQL(StatementImpl callingStatement,
153                        String sql, int maxRows, Buffer packet, int resultSetType,
154                        int resultSetConcurrency, boolean streamResults, String catalog,
155                        Field[] cachedMetadata, boolean isBatch) throws SQLException {
156                return getActiveMySQLConnection().execSQL(callingStatement, sql,
157                                maxRows, packet, resultSetType, resultSetConcurrency,
158                                streamResults, catalog, cachedMetadata, isBatch);
159        }
160
161        public ResultSetInternalMethods execSQL(StatementImpl callingStatement,
162                        String sql, int maxRows, Buffer packet, int resultSetType,
163                        int resultSetConcurrency, boolean streamResults, String catalog,
164                        Field[] cachedMetadata) throws SQLException {
165                return getActiveMySQLConnection().execSQL(callingStatement, sql,
166                                maxRows, packet, resultSetType, resultSetConcurrency,
167                                streamResults, catalog, cachedMetadata);
168        }
169
170        public String extractSqlFromPacket(String possibleSqlQuery,
171                        Buffer queryPacket, int endOfQueryPacketPosition)
172                        throws SQLException {
173                return getActiveMySQLConnection().extractSqlFromPacket(
174                                possibleSqlQuery, queryPacket, endOfQueryPacketPosition);
175        }
176
177        public String exposeAsXml() throws SQLException {
178                return getActiveMySQLConnection().exposeAsXml();
179        }
180
181        public boolean getAllowLoadLocalInfile() {
182                return getActiveMySQLConnection().getAllowLoadLocalInfile();
183        }
184
185        public boolean getAllowMultiQueries() {
186                return getActiveMySQLConnection().getAllowMultiQueries();
187        }
188
189        public boolean getAllowNanAndInf() {
190                return getActiveMySQLConnection().getAllowNanAndInf();
191        }
192
193        public boolean getAllowUrlInLocalInfile() {
194                return getActiveMySQLConnection().getAllowUrlInLocalInfile();
195        }
196
197        public boolean getAlwaysSendSetIsolation() {
198                return getActiveMySQLConnection().getAlwaysSendSetIsolation();
199        }
200
201        public boolean getAutoClosePStmtStreams() {
202                return getActiveMySQLConnection().getAutoClosePStmtStreams();
203        }
204
205        public boolean getAutoDeserialize() {
206                return getActiveMySQLConnection().getAutoDeserialize();
207        }
208
209        public boolean getAutoGenerateTestcaseScript() {
210                return getActiveMySQLConnection().getAutoGenerateTestcaseScript();
211        }
212
213        public boolean getAutoReconnectForPools() {
214                return getActiveMySQLConnection().getAutoReconnectForPools();
215        }
216
217        public boolean getAutoSlowLog() {
218                return getActiveMySQLConnection().getAutoSlowLog();
219        }
220
221        public int getBlobSendChunkSize() {
222                return getActiveMySQLConnection().getBlobSendChunkSize();
223        }
224
225        public boolean getBlobsAreStrings() {
226                return getActiveMySQLConnection().getBlobsAreStrings();
227        }
228
229        public boolean getCacheCallableStatements() {
230                return getActiveMySQLConnection().getCacheCallableStatements();
231        }
232
233        public boolean getCacheCallableStmts() {
234                return getActiveMySQLConnection().getCacheCallableStmts();
235        }
236
237        public boolean getCachePrepStmts() {
238                return getActiveMySQLConnection().getCachePrepStmts();
239        }
240
241        public boolean getCachePreparedStatements() {
242                return getActiveMySQLConnection().getCachePreparedStatements();
243        }
244
245        public boolean getCacheResultSetMetadata() {
246                return getActiveMySQLConnection().getCacheResultSetMetadata();
247        }
248
249        public boolean getCacheServerConfiguration() {
250                return getActiveMySQLConnection().getCacheServerConfiguration();
251        }
252
253        public int getCallableStatementCacheSize() {
254                return getActiveMySQLConnection().getCallableStatementCacheSize();
255        }
256
257        public int getCallableStmtCacheSize() {
258                return getActiveMySQLConnection().getCallableStmtCacheSize();
259        }
260
261        public boolean getCapitalizeTypeNames() {
262                return getActiveMySQLConnection().getCapitalizeTypeNames();
263        }
264
265        public String getCharacterSetResults() {
266                return getActiveMySQLConnection().getCharacterSetResults();
267        }
268
269        public String getClientCertificateKeyStorePassword() {
270                return getActiveMySQLConnection()
271                                .getClientCertificateKeyStorePassword();
272        }
273
274        public String getClientCertificateKeyStoreType() {
275                return getActiveMySQLConnection().getClientCertificateKeyStoreType();
276        }
277
278        public String getClientCertificateKeyStoreUrl() {
279                return getActiveMySQLConnection().getClientCertificateKeyStoreUrl();
280        }
281
282        public String getClientInfoProvider() {
283                return getActiveMySQLConnection().getClientInfoProvider();
284        }
285
286        public String getClobCharacterEncoding() {
287                return getActiveMySQLConnection().getClobCharacterEncoding();
288        }
289
290        public boolean getClobberStreamingResults() {
291                return getActiveMySQLConnection().getClobberStreamingResults();
292        }
293
294        public boolean getCompensateOnDuplicateKeyUpdateCounts() {
295                return getActiveMySQLConnection()
296                                .getCompensateOnDuplicateKeyUpdateCounts();
297        }
298
299        public int getConnectTimeout() {
300                return getActiveMySQLConnection().getConnectTimeout();
301        }
302
303        public String getConnectionCollation() {
304                return getActiveMySQLConnection().getConnectionCollation();
305        }
306
307        public String getConnectionLifecycleInterceptors() {
308                return getActiveMySQLConnection().getConnectionLifecycleInterceptors();
309        }
310
311        public boolean getContinueBatchOnError() {
312                return getActiveMySQLConnection().getContinueBatchOnError();
313        }
314
315        public boolean getCreateDatabaseIfNotExist() {
316                return getActiveMySQLConnection().getCreateDatabaseIfNotExist();
317        }
318
319        public int getDefaultFetchSize() {
320                return getActiveMySQLConnection().getDefaultFetchSize();
321        }
322
323        public boolean getDontTrackOpenResources() {
324                return getActiveMySQLConnection().getDontTrackOpenResources();
325        }
326
327        public boolean getDumpMetadataOnColumnNotFound() {
328                return getActiveMySQLConnection().getDumpMetadataOnColumnNotFound();
329        }
330
331        public boolean getDumpQueriesOnException() {
332                return getActiveMySQLConnection().getDumpQueriesOnException();
333        }
334
335        public boolean getDynamicCalendars() {
336                return getActiveMySQLConnection().getDynamicCalendars();
337        }
338
339        public boolean getElideSetAutoCommits() {
340                return getActiveMySQLConnection().getElideSetAutoCommits();
341        }
342
343        public boolean getEmptyStringsConvertToZero() {
344                return getActiveMySQLConnection().getEmptyStringsConvertToZero();
345        }
346
347        public boolean getEmulateLocators() {
348                return getActiveMySQLConnection().getEmulateLocators();
349        }
350
351        public boolean getEmulateUnsupportedPstmts() {
352                return getActiveMySQLConnection().getEmulateUnsupportedPstmts();
353        }
354
355        public boolean getEnablePacketDebug() {
356                return getActiveMySQLConnection().getEnablePacketDebug();
357        }
358
359        public boolean getEnableQueryTimeouts() {
360                return getActiveMySQLConnection().getEnableQueryTimeouts();
361        }
362
363        public String getEncoding() {
364                return getActiveMySQLConnection().getEncoding();
365        }
366
367        public String getExceptionInterceptors() {
368                return getActiveMySQLConnection().getExceptionInterceptors();
369        }
370
371        public boolean getExplainSlowQueries() {
372                return getActiveMySQLConnection().getExplainSlowQueries();
373        }
374
375        public boolean getFailOverReadOnly() {
376                return getActiveMySQLConnection().getFailOverReadOnly();
377        }
378
379        public boolean getFunctionsNeverReturnBlobs() {
380                return getActiveMySQLConnection().getFunctionsNeverReturnBlobs();
381        }
382
383        public boolean getGatherPerfMetrics() {
384                return getActiveMySQLConnection().getGatherPerfMetrics();
385        }
386
387        public boolean getGatherPerformanceMetrics() {
388                return getActiveMySQLConnection().getGatherPerformanceMetrics();
389        }
390
391        public boolean getGenerateSimpleParameterMetadata() {
392                return getActiveMySQLConnection().getGenerateSimpleParameterMetadata();
393        }
394
395        public boolean getIgnoreNonTxTables() {
396                return getActiveMySQLConnection().getIgnoreNonTxTables();
397        }
398
399        public boolean getIncludeInnodbStatusInDeadlockExceptions() {
400                return getActiveMySQLConnection()
401                                .getIncludeInnodbStatusInDeadlockExceptions();
402        }
403
404        public int getInitialTimeout() {
405                return getActiveMySQLConnection().getInitialTimeout();
406        }
407
408        public boolean getInteractiveClient() {
409                return getActiveMySQLConnection().getInteractiveClient();
410        }
411
412        public boolean getIsInteractiveClient() {
413                return getActiveMySQLConnection().getIsInteractiveClient();
414        }
415
416        public boolean getJdbcCompliantTruncation() {
417                return getActiveMySQLConnection().getJdbcCompliantTruncation();
418        }
419
420        public boolean getJdbcCompliantTruncationForReads() {
421                return getActiveMySQLConnection().getJdbcCompliantTruncationForReads();
422        }
423
424        public String getLargeRowSizeThreshold() {
425                return getActiveMySQLConnection().getLargeRowSizeThreshold();
426        }
427
428        public int getLoadBalanceBlacklistTimeout() {
429                return getActiveMySQLConnection().getLoadBalanceBlacklistTimeout();
430        }
431
432        public int getLoadBalancePingTimeout() {
433                return getActiveMySQLConnection().getLoadBalancePingTimeout();
434        }
435
436        public String getLoadBalanceStrategy() {
437                return getActiveMySQLConnection().getLoadBalanceStrategy();
438        }
439
440        public boolean getLoadBalanceValidateConnectionOnSwapServer() {
441                return getActiveMySQLConnection()
442                                .getLoadBalanceValidateConnectionOnSwapServer();
443        }
444
445        public String getLocalSocketAddress() {
446                return getActiveMySQLConnection().getLocalSocketAddress();
447        }
448
449        public int getLocatorFetchBufferSize() {
450                return getActiveMySQLConnection().getLocatorFetchBufferSize();
451        }
452
453        public boolean getLogSlowQueries() {
454                return getActiveMySQLConnection().getLogSlowQueries();
455        }
456
457        public boolean getLogXaCommands() {
458                return getActiveMySQLConnection().getLogXaCommands();
459        }
460
461        public String getLogger() {
462                return getActiveMySQLConnection().getLogger();
463        }
464
465        public String getLoggerClassName() {
466                return getActiveMySQLConnection().getLoggerClassName();
467        }
468
469        public boolean getMaintainTimeStats() {
470                return getActiveMySQLConnection().getMaintainTimeStats();
471        }
472
473        public int getMaxAllowedPacket() {
474                return getActiveMySQLConnection().getMaxAllowedPacket();
475        }
476
477        public int getMaxQuerySizeToLog() {
478                return getActiveMySQLConnection().getMaxQuerySizeToLog();
479        }
480
481        public int getMaxReconnects() {
482                return getActiveMySQLConnection().getMaxReconnects();
483        }
484
485        public int getMaxRows() {
486                return getActiveMySQLConnection().getMaxRows();
487        }
488
489        public int getMetadataCacheSize() {
490                return getActiveMySQLConnection().getMetadataCacheSize();
491        }
492
493        public int getNetTimeoutForStreamingResults() {
494                return getActiveMySQLConnection().getNetTimeoutForStreamingResults();
495        }
496
497        public boolean getNoAccessToProcedureBodies() {
498                return getActiveMySQLConnection().getNoAccessToProcedureBodies();
499        }
500
501        public boolean getNoDatetimeStringSync() {
502                return getActiveMySQLConnection().getNoDatetimeStringSync();
503        }
504
505        public boolean getNoTimezoneConversionForTimeType() {
506                return getActiveMySQLConnection().getNoTimezoneConversionForTimeType();
507        }
508
509        public boolean getNullCatalogMeansCurrent() {
510                return getActiveMySQLConnection().getNullCatalogMeansCurrent();
511        }
512
513        public boolean getNullNamePatternMatchesAll() {
514                return getActiveMySQLConnection().getNullNamePatternMatchesAll();
515        }
516
517        public boolean getOverrideSupportsIntegrityEnhancementFacility() {
518                return getActiveMySQLConnection()
519                                .getOverrideSupportsIntegrityEnhancementFacility();
520        }
521
522        public int getPacketDebugBufferSize() {
523                return getActiveMySQLConnection().getPacketDebugBufferSize();
524        }
525
526        public boolean getPadCharsWithSpace() {
527                return getActiveMySQLConnection().getPadCharsWithSpace();
528        }
529
530        public boolean getParanoid() {
531                return getActiveMySQLConnection().getParanoid();
532        }
533
534        public String getPasswordCharacterEncoding() {
535                return getActiveMySQLConnection().getPasswordCharacterEncoding();
536        }
537
538        public boolean getPedantic() {
539                return getActiveMySQLConnection().getPedantic();
540        }
541
542        public boolean getPinGlobalTxToPhysicalConnection() {
543                return getActiveMySQLConnection().getPinGlobalTxToPhysicalConnection();
544        }
545
546        public boolean getPopulateInsertRowWithDefaultValues() {
547                return getActiveMySQLConnection()
548                                .getPopulateInsertRowWithDefaultValues();
549        }
550
551        public int getPrepStmtCacheSize() {
552                return getActiveMySQLConnection().getPrepStmtCacheSize();
553        }
554
555        public int getPrepStmtCacheSqlLimit() {
556                return getActiveMySQLConnection().getPrepStmtCacheSqlLimit();
557        }
558
559        public int getPreparedStatementCacheSize() {
560                return getActiveMySQLConnection().getPreparedStatementCacheSize();
561        }
562
563        public int getPreparedStatementCacheSqlLimit() {
564                return getActiveMySQLConnection().getPreparedStatementCacheSqlLimit();
565        }
566
567        public boolean getProcessEscapeCodesForPrepStmts() {
568                return getActiveMySQLConnection().getProcessEscapeCodesForPrepStmts();
569        }
570
571        public boolean getProfileSQL() {
572                return getActiveMySQLConnection().getProfileSQL();
573        }
574
575        public boolean getProfileSql() {
576                return getActiveMySQLConnection().getProfileSql();
577        }
578
579        public String getProfilerEventHandler() {
580                return getActiveMySQLConnection().getProfilerEventHandler();
581        }
582
583        public String getPropertiesTransform() {
584                return getActiveMySQLConnection().getPropertiesTransform();
585        }
586
587        public int getQueriesBeforeRetryMaster() {
588                return getActiveMySQLConnection().getQueriesBeforeRetryMaster();
589        }
590
591        public boolean getQueryTimeoutKillsConnection() {
592                return getActiveMySQLConnection().getQueryTimeoutKillsConnection();
593        }
594
595        public boolean getReconnectAtTxEnd() {
596                return getActiveMySQLConnection().getReconnectAtTxEnd();
597        }
598
599        public boolean getRelaxAutoCommit() {
600                return getActiveMySQLConnection().getRelaxAutoCommit();
601        }
602
603        public int getReportMetricsIntervalMillis() {
604                return getActiveMySQLConnection().getReportMetricsIntervalMillis();
605        }
606
607        public boolean getRequireSSL() {
608                return getActiveMySQLConnection().getRequireSSL();
609        }
610
611        public String getResourceId() {
612                return getActiveMySQLConnection().getResourceId();
613        }
614
615        public int getResultSetSizeThreshold() {
616                return getActiveMySQLConnection().getResultSetSizeThreshold();
617        }
618
619        public boolean getRetainStatementAfterResultSetClose() {
620                return getActiveMySQLConnection()
621                                .getRetainStatementAfterResultSetClose();
622        }
623
624        public int getRetriesAllDown() {
625                return getActiveMySQLConnection().getRetriesAllDown();
626        }
627
628        public boolean getRewriteBatchedStatements() {
629                return getActiveMySQLConnection().getRewriteBatchedStatements();
630        }
631
632        public boolean getRollbackOnPooledClose() {
633                return getActiveMySQLConnection().getRollbackOnPooledClose();
634        }
635
636        public boolean getRoundRobinLoadBalance() {
637                return getActiveMySQLConnection().getRoundRobinLoadBalance();
638        }
639
640        public boolean getRunningCTS13() {
641                return getActiveMySQLConnection().getRunningCTS13();
642        }
643
644        public int getSecondsBeforeRetryMaster() {
645                return getActiveMySQLConnection().getSecondsBeforeRetryMaster();
646        }
647
648        public int getSelfDestructOnPingMaxOperations() {
649                return getActiveMySQLConnection().getSelfDestructOnPingMaxOperations();
650        }
651
652        public int getSelfDestructOnPingSecondsLifetime() {
653                return getActiveMySQLConnection()
654                                .getSelfDestructOnPingSecondsLifetime();
655        }
656
657        public String getServerTimezone() {
658                return getActiveMySQLConnection().getServerTimezone();
659        }
660
661        public String getSessionVariables() {
662                return getActiveMySQLConnection().getSessionVariables();
663        }
664
665        public int getSlowQueryThresholdMillis() {
666                return getActiveMySQLConnection().getSlowQueryThresholdMillis();
667        }
668
669        public long getSlowQueryThresholdNanos() {
670                return getActiveMySQLConnection().getSlowQueryThresholdNanos();
671        }
672
673        public String getSocketFactory() {
674                return getActiveMySQLConnection().getSocketFactory();
675        }
676
677        public String getSocketFactoryClassName() {
678                return getActiveMySQLConnection().getSocketFactoryClassName();
679        }
680
681        public int getSocketTimeout() {
682                return getActiveMySQLConnection().getSocketTimeout();
683        }
684
685        public String getStatementInterceptors() {
686                return getActiveMySQLConnection().getStatementInterceptors();
687        }
688
689        public boolean getStrictFloatingPoint() {
690                return getActiveMySQLConnection().getStrictFloatingPoint();
691        }
692
693        public boolean getStrictUpdates() {
694                return getActiveMySQLConnection().getStrictUpdates();
695        }
696
697        public boolean getTcpKeepAlive() {
698                return getActiveMySQLConnection().getTcpKeepAlive();
699        }
700
701        public boolean getTcpNoDelay() {
702                return getActiveMySQLConnection().getTcpNoDelay();
703        }
704
705        public int getTcpRcvBuf() {
706                return getActiveMySQLConnection().getTcpRcvBuf();
707        }
708
709        public int getTcpSndBuf() {
710                return getActiveMySQLConnection().getTcpSndBuf();
711        }
712
713        public int getTcpTrafficClass() {
714                return getActiveMySQLConnection().getTcpTrafficClass();
715        }
716
717        public boolean getTinyInt1isBit() {
718                return getActiveMySQLConnection().getTinyInt1isBit();
719        }
720
721        public boolean getTraceProtocol() {
722                return getActiveMySQLConnection().getTraceProtocol();
723        }
724
725        public boolean getTransformedBitIsBoolean() {
726                return getActiveMySQLConnection().getTransformedBitIsBoolean();
727        }
728
729        public boolean getTreatUtilDateAsTimestamp() {
730                return getActiveMySQLConnection().getTreatUtilDateAsTimestamp();
731        }
732
733        public String getTrustCertificateKeyStorePassword() {
734                return getActiveMySQLConnection().getTrustCertificateKeyStorePassword();
735        }
736
737        public String getTrustCertificateKeyStoreType() {
738                return getActiveMySQLConnection().getTrustCertificateKeyStoreType();
739        }
740
741        public String getTrustCertificateKeyStoreUrl() {
742                return getActiveMySQLConnection().getTrustCertificateKeyStoreUrl();
743        }
744
745        public boolean getUltraDevHack() {
746                return getActiveMySQLConnection().getUltraDevHack();
747        }
748
749        public boolean getUseAffectedRows() {
750                return getActiveMySQLConnection().getUseAffectedRows();
751        }
752
753        public boolean getUseBlobToStoreUTF8OutsideBMP() {
754                return getActiveMySQLConnection().getUseBlobToStoreUTF8OutsideBMP();
755        }
756
757        public boolean getUseColumnNamesInFindColumn() {
758                return getActiveMySQLConnection().getUseColumnNamesInFindColumn();
759        }
760
761        public boolean getUseCompression() {
762                return getActiveMySQLConnection().getUseCompression();
763        }
764
765        public String getUseConfigs() {
766                return getActiveMySQLConnection().getUseConfigs();
767        }
768
769        public boolean getUseCursorFetch() {
770                return getActiveMySQLConnection().getUseCursorFetch();
771        }
772
773        public boolean getUseDirectRowUnpack() {
774                return getActiveMySQLConnection().getUseDirectRowUnpack();
775        }
776
777        public boolean getUseDynamicCharsetInfo() {
778                return getActiveMySQLConnection().getUseDynamicCharsetInfo();
779        }
780
781        public boolean getUseFastDateParsing() {
782                return getActiveMySQLConnection().getUseFastDateParsing();
783        }
784
785        public boolean getUseFastIntParsing() {
786                return getActiveMySQLConnection().getUseFastIntParsing();
787        }
788
789        public boolean getUseGmtMillisForDatetimes() {
790                return getActiveMySQLConnection().getUseGmtMillisForDatetimes();
791        }
792
793        public boolean getUseHostsInPrivileges() {
794                return getActiveMySQLConnection().getUseHostsInPrivileges();
795        }
796
797        public boolean getUseInformationSchema() {
798                return getActiveMySQLConnection().getUseInformationSchema();
799        }
800
801        public boolean getUseJDBCCompliantTimezoneShift() {
802                return getActiveMySQLConnection().getUseJDBCCompliantTimezoneShift();
803        }
804
805        public boolean getUseJvmCharsetConverters() {
806                return getActiveMySQLConnection().getUseJvmCharsetConverters();
807        }
808
809        public boolean getUseLegacyDatetimeCode() {
810                return getActiveMySQLConnection().getUseLegacyDatetimeCode();
811        }
812
813        public boolean getUseLocalSessionState() {
814                return getActiveMySQLConnection().getUseLocalSessionState();
815        }
816
817        public boolean getUseLocalTransactionState() {
818                return getActiveMySQLConnection().getUseLocalTransactionState();
819        }
820
821        public boolean getUseNanosForElapsedTime() {
822                return getActiveMySQLConnection().getUseNanosForElapsedTime();
823        }
824
825        public boolean getUseOldAliasMetadataBehavior() {
826                return getActiveMySQLConnection().getUseOldAliasMetadataBehavior();
827        }
828
829        public boolean getUseOldUTF8Behavior() {
830                return getActiveMySQLConnection().getUseOldUTF8Behavior();
831        }
832
833        public boolean getUseOnlyServerErrorMessages() {
834                return getActiveMySQLConnection().getUseOnlyServerErrorMessages();
835        }
836
837        public boolean getUseReadAheadInput() {
838                return getActiveMySQLConnection().getUseReadAheadInput();
839        }
840
841        public boolean getUseSSL() {
842                return getActiveMySQLConnection().getUseSSL();
843        }
844
845        public boolean getUseSSPSCompatibleTimezoneShift() {
846                return getActiveMySQLConnection().getUseSSPSCompatibleTimezoneShift();
847        }
848
849        public boolean getUseServerPrepStmts() {
850                return getActiveMySQLConnection().getUseServerPrepStmts();
851        }
852
853        public boolean getUseServerPreparedStmts() {
854                return getActiveMySQLConnection().getUseServerPreparedStmts();
855        }
856
857        public boolean getUseSqlStateCodes() {
858                return getActiveMySQLConnection().getUseSqlStateCodes();
859        }
860
861        public boolean getUseStreamLengthsInPrepStmts() {
862                return getActiveMySQLConnection().getUseStreamLengthsInPrepStmts();
863        }
864
865        public boolean getUseTimezone() {
866                return getActiveMySQLConnection().getUseTimezone();
867        }
868
869        public boolean getUseUltraDevWorkAround() {
870                return getActiveMySQLConnection().getUseUltraDevWorkAround();
871        }
872
873        public boolean getUseUnbufferedInput() {
874                return getActiveMySQLConnection().getUseUnbufferedInput();
875        }
876
877        public boolean getUseUnicode() {
878                return getActiveMySQLConnection().getUseUnicode();
879        }
880
881        public boolean getUseUsageAdvisor() {
882                return getActiveMySQLConnection().getUseUsageAdvisor();
883        }
884
885        public String getUtf8OutsideBmpExcludedColumnNamePattern() {
886                return getActiveMySQLConnection()
887                                .getUtf8OutsideBmpExcludedColumnNamePattern();
888        }
889
890        public String getUtf8OutsideBmpIncludedColumnNamePattern() {
891                return getActiveMySQLConnection()
892                                .getUtf8OutsideBmpIncludedColumnNamePattern();
893        }
894
895        public boolean getVerifyServerCertificate() {
896                return getActiveMySQLConnection().getVerifyServerCertificate();
897        }
898
899        public boolean getYearIsDateType() {
900                return getActiveMySQLConnection().getYearIsDateType();
901        }
902
903        public String getZeroDateTimeBehavior() {
904                return getActiveMySQLConnection().getZeroDateTimeBehavior();
905        }
906
907        public void setAllowLoadLocalInfile(boolean property) {
908                getActiveMySQLConnection().setAllowLoadLocalInfile(property);
909        }
910
911        public void setAllowMultiQueries(boolean property) {
912                getActiveMySQLConnection().setAllowMultiQueries(property);
913        }
914
915        public void setAllowNanAndInf(boolean flag) {
916                getActiveMySQLConnection().setAllowNanAndInf(flag);
917        }
918
919        public void setAllowUrlInLocalInfile(boolean flag) {
920                getActiveMySQLConnection().setAllowUrlInLocalInfile(flag);
921        }
922
923        public void setAlwaysSendSetIsolation(boolean flag) {
924                getActiveMySQLConnection().setAlwaysSendSetIsolation(flag);
925        }
926
927        public void setAutoClosePStmtStreams(boolean flag) {
928                getActiveMySQLConnection().setAutoClosePStmtStreams(flag);
929        }
930
931        public void setAutoDeserialize(boolean flag) {
932                getActiveMySQLConnection().setAutoDeserialize(flag);
933        }
934
935        public void setAutoGenerateTestcaseScript(boolean flag) {
936                getActiveMySQLConnection().setAutoGenerateTestcaseScript(flag);
937        }
938
939        public void setAutoReconnect(boolean flag) {
940                getActiveMySQLConnection().setAutoReconnect(flag);
941        }
942
943        public void setAutoReconnectForConnectionPools(boolean property) {
944                getActiveMySQLConnection().setAutoReconnectForConnectionPools(property);
945        }
946
947        public void setAutoReconnectForPools(boolean flag) {
948                getActiveMySQLConnection().setAutoReconnectForPools(flag);
949        }
950
951        public void setAutoSlowLog(boolean flag) {
952                getActiveMySQLConnection().setAutoSlowLog(flag);
953        }
954
955        public void setBlobSendChunkSize(String value) throws SQLException {
956                getActiveMySQLConnection().setBlobSendChunkSize(value);
957        }
958
959        public void setBlobsAreStrings(boolean flag) {
960                getActiveMySQLConnection().setBlobsAreStrings(flag);
961        }
962
963        public void setCacheCallableStatements(boolean flag) {
964                getActiveMySQLConnection().setCacheCallableStatements(flag);
965        }
966
967        public void setCacheCallableStmts(boolean flag) {
968                getActiveMySQLConnection().setCacheCallableStmts(flag);
969        }
970
971        public void setCachePrepStmts(boolean flag) {
972                getActiveMySQLConnection().setCachePrepStmts(flag);
973        }
974
975        public void setCachePreparedStatements(boolean flag) {
976                getActiveMySQLConnection().setCachePreparedStatements(flag);
977        }
978
979        public void setCacheResultSetMetadata(boolean property) {
980                getActiveMySQLConnection().setCacheResultSetMetadata(property);
981        }
982
983        public void setCacheServerConfiguration(boolean flag) {
984                getActiveMySQLConnection().setCacheServerConfiguration(flag);
985        }
986
987        public void setCallableStatementCacheSize(int size) {
988                getActiveMySQLConnection().setCallableStatementCacheSize(size);
989        }
990
991        public void setCallableStmtCacheSize(int cacheSize) {
992                getActiveMySQLConnection().setCallableStmtCacheSize(cacheSize);
993        }
994
995        public void setCapitalizeDBMDTypes(boolean property) {
996                getActiveMySQLConnection().setCapitalizeDBMDTypes(property);
997        }
998
999        public void setCapitalizeTypeNames(boolean flag) {
1000                getActiveMySQLConnection().setCapitalizeTypeNames(flag);
1001        }
1002
1003        public void setCharacterEncoding(String encoding) {
1004                getActiveMySQLConnection().setCharacterEncoding(encoding);
1005        }
1006
1007        public void setCharacterSetResults(String characterSet) {
1008                getActiveMySQLConnection().setCharacterSetResults(characterSet);
1009        }
1010
1011        public void setClientCertificateKeyStorePassword(String value) {
1012                getActiveMySQLConnection().setClientCertificateKeyStorePassword(value);
1013        }
1014
1015        public void setClientCertificateKeyStoreType(String value) {
1016                getActiveMySQLConnection().setClientCertificateKeyStoreType(value);
1017        }
1018
1019        public void setClientCertificateKeyStoreUrl(String value) {
1020                getActiveMySQLConnection().setClientCertificateKeyStoreUrl(value);
1021        }
1022
1023        public void setClientInfoProvider(String classname) {
1024                getActiveMySQLConnection().setClientInfoProvider(classname);
1025        }
1026
1027        public void setClobCharacterEncoding(String encoding) {
1028                getActiveMySQLConnection().setClobCharacterEncoding(encoding);
1029        }
1030
1031        public void setClobberStreamingResults(boolean flag) {
1032                getActiveMySQLConnection().setClobberStreamingResults(flag);
1033        }
1034
1035        public void setCompensateOnDuplicateKeyUpdateCounts(boolean flag) {
1036                getActiveMySQLConnection()
1037                                .setCompensateOnDuplicateKeyUpdateCounts(flag);
1038        }
1039
1040        public void setConnectTimeout(int timeoutMs) {
1041                getActiveMySQLConnection().setConnectTimeout(timeoutMs);
1042        }
1043
1044        public void setConnectionCollation(String collation) {
1045                getActiveMySQLConnection().setConnectionCollation(collation);
1046        }
1047
1048        public void setConnectionLifecycleInterceptors(String interceptors) {
1049                getActiveMySQLConnection().setConnectionLifecycleInterceptors(
1050                                interceptors);
1051        }
1052
1053        public void setContinueBatchOnError(boolean property) {
1054                getActiveMySQLConnection().setContinueBatchOnError(property);
1055        }
1056
1057        public void setCreateDatabaseIfNotExist(boolean flag) {
1058                getActiveMySQLConnection().setCreateDatabaseIfNotExist(flag);
1059        }
1060
1061        public void setDefaultFetchSize(int n) {
1062                getActiveMySQLConnection().setDefaultFetchSize(n);
1063        }
1064
1065        public void setDetectServerPreparedStmts(boolean property) {
1066                getActiveMySQLConnection().setDetectServerPreparedStmts(property);
1067        }
1068
1069        public void setDontTrackOpenResources(boolean flag) {
1070                getActiveMySQLConnection().setDontTrackOpenResources(flag);
1071        }
1072
1073        public void setDumpMetadataOnColumnNotFound(boolean flag) {
1074                getActiveMySQLConnection().setDumpMetadataOnColumnNotFound(flag);
1075        }
1076
1077        public void setDumpQueriesOnException(boolean flag) {
1078                getActiveMySQLConnection().setDumpQueriesOnException(flag);
1079        }
1080
1081        public void setDynamicCalendars(boolean flag) {
1082                getActiveMySQLConnection().setDynamicCalendars(flag);
1083        }
1084
1085        public void setElideSetAutoCommits(boolean flag) {
1086                getActiveMySQLConnection().setElideSetAutoCommits(flag);
1087        }
1088
1089        public void setEmptyStringsConvertToZero(boolean flag) {
1090                getActiveMySQLConnection().setEmptyStringsConvertToZero(flag);
1091        }
1092
1093        public void setEmulateLocators(boolean property) {
1094                getActiveMySQLConnection().setEmulateLocators(property);
1095        }
1096
1097        public void setEmulateUnsupportedPstmts(boolean flag) {
1098                getActiveMySQLConnection().setEmulateUnsupportedPstmts(flag);
1099        }
1100
1101        public void setEnablePacketDebug(boolean flag) {
1102                getActiveMySQLConnection().setEnablePacketDebug(flag);
1103        }
1104
1105        public void setEnableQueryTimeouts(boolean flag) {
1106                getActiveMySQLConnection().setEnableQueryTimeouts(flag);
1107        }
1108
1109        public void setEncoding(String property) {
1110                getActiveMySQLConnection().setEncoding(property);
1111        }
1112
1113        public void setExceptionInterceptors(String exceptionInterceptors) {
1114                getActiveMySQLConnection().setExceptionInterceptors(
1115                                exceptionInterceptors);
1116        }
1117
1118        public void setExplainSlowQueries(boolean flag) {
1119                getActiveMySQLConnection().setExplainSlowQueries(flag);
1120        }
1121
1122        public void setFailOverReadOnly(boolean flag) {
1123                getActiveMySQLConnection().setFailOverReadOnly(flag);
1124        }
1125
1126        public void setFunctionsNeverReturnBlobs(boolean flag) {
1127                getActiveMySQLConnection().setFunctionsNeverReturnBlobs(flag);
1128        }
1129
1130        public void setGatherPerfMetrics(boolean flag) {
1131                getActiveMySQLConnection().setGatherPerfMetrics(flag);
1132        }
1133
1134        public void setGatherPerformanceMetrics(boolean flag) {
1135                getActiveMySQLConnection().setGatherPerformanceMetrics(flag);
1136        }
1137
1138        public void setGenerateSimpleParameterMetadata(boolean flag) {
1139                getActiveMySQLConnection().setGenerateSimpleParameterMetadata(flag);
1140        }
1141
1142        public void setHoldResultsOpenOverStatementClose(boolean flag) {
1143                getActiveMySQLConnection().setHoldResultsOpenOverStatementClose(flag);
1144        }
1145
1146        public void setIgnoreNonTxTables(boolean property) {
1147                getActiveMySQLConnection().setIgnoreNonTxTables(property);
1148        }
1149
1150        public void setIncludeInnodbStatusInDeadlockExceptions(boolean flag) {
1151                getActiveMySQLConnection().setIncludeInnodbStatusInDeadlockExceptions(
1152                                flag);
1153        }
1154
1155        public void setInitialTimeout(int property) {
1156                getActiveMySQLConnection().setInitialTimeout(property);
1157        }
1158
1159        public void setInteractiveClient(boolean property) {
1160                getActiveMySQLConnection().setInteractiveClient(property);
1161        }
1162
1163        public void setIsInteractiveClient(boolean property) {
1164                getActiveMySQLConnection().setIsInteractiveClient(property);
1165        }
1166
1167        public void setJdbcCompliantTruncation(boolean flag) {
1168                getActiveMySQLConnection().setJdbcCompliantTruncation(flag);
1169        }
1170
1171        public void setJdbcCompliantTruncationForReads(
1172                        boolean jdbcCompliantTruncationForReads) {
1173                getActiveMySQLConnection().setJdbcCompliantTruncationForReads(
1174                                jdbcCompliantTruncationForReads);
1175        }
1176
1177        public void setLargeRowSizeThreshold(String value) {
1178                getActiveMySQLConnection().setLargeRowSizeThreshold(value);
1179        }
1180
1181        public void setLoadBalanceBlacklistTimeout(int loadBalanceBlacklistTimeout) {
1182                getActiveMySQLConnection().setLoadBalanceBlacklistTimeout(
1183                                loadBalanceBlacklistTimeout);
1184        }
1185
1186        public void setLoadBalancePingTimeout(int loadBalancePingTimeout) {
1187                getActiveMySQLConnection().setLoadBalancePingTimeout(
1188                                loadBalancePingTimeout);
1189        }
1190
1191        public void setLoadBalanceStrategy(String strategy) {
1192                getActiveMySQLConnection().setLoadBalanceStrategy(strategy);
1193        }
1194
1195        public void setLoadBalanceValidateConnectionOnSwapServer(
1196                        boolean loadBalanceValidateConnectionOnSwapServer) {
1197
1198                getActiveMySQLConnection()
1199                                .setLoadBalanceValidateConnectionOnSwapServer(
1200                                                loadBalanceValidateConnectionOnSwapServer);
1201        }
1202
1203        public void setLocalSocketAddress(String address) {
1204
1205                getActiveMySQLConnection().setLocalSocketAddress(address);
1206        }
1207
1208        public void setLocatorFetchBufferSize(String value) throws SQLException {
1209
1210                getActiveMySQLConnection().setLocatorFetchBufferSize(value);
1211        }
1212
1213        public void setLogSlowQueries(boolean flag) {
1214
1215                getActiveMySQLConnection().setLogSlowQueries(flag);
1216        }
1217
1218        public void setLogXaCommands(boolean flag) {
1219
1220                getActiveMySQLConnection().setLogXaCommands(flag);
1221        }
1222
1223        public void setLogger(String property) {
1224
1225                getActiveMySQLConnection().setLogger(property);
1226        }
1227
1228        public void setLoggerClassName(String className) {
1229
1230                getActiveMySQLConnection().setLoggerClassName(className);
1231        }
1232
1233        public void setMaintainTimeStats(boolean flag) {
1234
1235                getActiveMySQLConnection().setMaintainTimeStats(flag);
1236        }
1237
1238        public void setMaxQuerySizeToLog(int sizeInBytes) {
1239
1240                getActiveMySQLConnection().setMaxQuerySizeToLog(sizeInBytes);
1241        }
1242
1243        public void setMaxReconnects(int property) {
1244
1245                getActiveMySQLConnection().setMaxReconnects(property);
1246        }
1247
1248        public void setMaxRows(int property) {
1249
1250                getActiveMySQLConnection().setMaxRows(property);
1251        }
1252
1253        public void setMetadataCacheSize(int value) {
1254
1255                getActiveMySQLConnection().setMetadataCacheSize(value);
1256        }
1257
1258        public void setNetTimeoutForStreamingResults(int value) {
1259
1260                getActiveMySQLConnection().setNetTimeoutForStreamingResults(value);
1261        }
1262
1263        public void setNoAccessToProcedureBodies(boolean flag) {
1264
1265                getActiveMySQLConnection().setNoAccessToProcedureBodies(flag);
1266        }
1267
1268        public void setNoDatetimeStringSync(boolean flag) {
1269
1270                getActiveMySQLConnection().setNoDatetimeStringSync(flag);
1271        }
1272
1273        public void setNoTimezoneConversionForTimeType(boolean flag) {
1274
1275                getActiveMySQLConnection().setNoTimezoneConversionForTimeType(flag);
1276        }
1277
1278        public void setNullCatalogMeansCurrent(boolean value) {
1279
1280                getActiveMySQLConnection().setNullCatalogMeansCurrent(value);
1281        }
1282
1283        public void setNullNamePatternMatchesAll(boolean value) {
1284
1285                getActiveMySQLConnection().setNullNamePatternMatchesAll(value);
1286        }
1287
1288        public void setOverrideSupportsIntegrityEnhancementFacility(boolean flag) {
1289
1290                getActiveMySQLConnection()
1291                                .setOverrideSupportsIntegrityEnhancementFacility(flag);
1292        }
1293
1294        public void setPacketDebugBufferSize(int size) {
1295
1296                getActiveMySQLConnection().setPacketDebugBufferSize(size);
1297        }
1298
1299        public void setPadCharsWithSpace(boolean flag) {
1300
1301                getActiveMySQLConnection().setPadCharsWithSpace(flag);
1302        }
1303
1304        public void setParanoid(boolean property) {
1305
1306                getActiveMySQLConnection().setParanoid(property);
1307        }
1308
1309        public void setPasswordCharacterEncoding(String characterSet) {
1310
1311                getActiveMySQLConnection().setPasswordCharacterEncoding(characterSet);
1312        }
1313
1314        public void setPedantic(boolean property) {
1315
1316                getActiveMySQLConnection().setPedantic(property);
1317        }
1318
1319        public void setPinGlobalTxToPhysicalConnection(boolean flag) {
1320
1321                getActiveMySQLConnection().setPinGlobalTxToPhysicalConnection(flag);
1322        }
1323
1324        public void setPopulateInsertRowWithDefaultValues(boolean flag) {
1325
1326                getActiveMySQLConnection().setPopulateInsertRowWithDefaultValues(flag);
1327        }
1328
1329        public void setPrepStmtCacheSize(int cacheSize) {
1330
1331                getActiveMySQLConnection().setPrepStmtCacheSize(cacheSize);
1332        }
1333
1334        public void setPrepStmtCacheSqlLimit(int sqlLimit) {
1335
1336                getActiveMySQLConnection().setPrepStmtCacheSqlLimit(sqlLimit);
1337        }
1338
1339        public void setPreparedStatementCacheSize(int cacheSize) {
1340
1341                getActiveMySQLConnection().setPreparedStatementCacheSize(cacheSize);
1342        }
1343
1344        public void setPreparedStatementCacheSqlLimit(int cacheSqlLimit) {
1345
1346                getActiveMySQLConnection().setPreparedStatementCacheSqlLimit(
1347                                cacheSqlLimit);
1348        }
1349
1350        public void setProcessEscapeCodesForPrepStmts(boolean flag) {
1351
1352                getActiveMySQLConnection().setProcessEscapeCodesForPrepStmts(flag);
1353        }
1354
1355        public void setProfileSQL(boolean flag) {
1356
1357                getActiveMySQLConnection().setProfileSQL(flag);
1358        }
1359
1360        public void setProfileSql(boolean property) {
1361
1362                getActiveMySQLConnection().setProfileSql(property);
1363        }
1364
1365        public void setProfilerEventHandler(String handler) {
1366
1367                getActiveMySQLConnection().setProfilerEventHandler(handler);
1368        }
1369
1370        public void setPropertiesTransform(String value) {
1371
1372                getActiveMySQLConnection().setPropertiesTransform(value);
1373        }
1374
1375        public void setQueriesBeforeRetryMaster(int property) {
1376
1377                getActiveMySQLConnection().setQueriesBeforeRetryMaster(property);
1378        }
1379
1380        public void setQueryTimeoutKillsConnection(
1381                        boolean queryTimeoutKillsConnection) {
1382
1383                getActiveMySQLConnection().setQueryTimeoutKillsConnection(
1384                                queryTimeoutKillsConnection);
1385        }
1386
1387        public void setReconnectAtTxEnd(boolean property) {
1388
1389                getActiveMySQLConnection().setReconnectAtTxEnd(property);
1390        }
1391
1392        public void setRelaxAutoCommit(boolean property) {
1393
1394                getActiveMySQLConnection().setRelaxAutoCommit(property);
1395        }
1396
1397        public void setReportMetricsIntervalMillis(int millis) {
1398
1399                getActiveMySQLConnection().setReportMetricsIntervalMillis(millis);
1400        }
1401
1402        public void setRequireSSL(boolean property) {
1403
1404                getActiveMySQLConnection().setRequireSSL(property);
1405        }
1406
1407        public void setResourceId(String resourceId) {
1408
1409                getActiveMySQLConnection().setResourceId(resourceId);
1410        }
1411
1412        public void setResultSetSizeThreshold(int threshold) {
1413
1414                getActiveMySQLConnection().setResultSetSizeThreshold(threshold);
1415        }
1416
1417        public void setRetainStatementAfterResultSetClose(boolean flag) {
1418
1419                getActiveMySQLConnection().setRetainStatementAfterResultSetClose(flag);
1420        }
1421
1422        public void setRetriesAllDown(int retriesAllDown) {
1423
1424                getActiveMySQLConnection().setRetriesAllDown(retriesAllDown);
1425        }
1426
1427        public void setRewriteBatchedStatements(boolean flag) {
1428
1429                getActiveMySQLConnection().setRewriteBatchedStatements(flag);
1430        }
1431
1432        public void setRollbackOnPooledClose(boolean flag) {
1433
1434                getActiveMySQLConnection().setRollbackOnPooledClose(flag);
1435        }
1436
1437        public void setRoundRobinLoadBalance(boolean flag) {
1438
1439                getActiveMySQLConnection().setRoundRobinLoadBalance(flag);
1440        }
1441
1442        public void setRunningCTS13(boolean flag) {
1443
1444                getActiveMySQLConnection().setRunningCTS13(flag);
1445        }
1446
1447        public void setSecondsBeforeRetryMaster(int property) {
1448
1449                getActiveMySQLConnection().setSecondsBeforeRetryMaster(property);
1450        }
1451
1452        public void setSelfDestructOnPingMaxOperations(int maxOperations) {
1453
1454                getActiveMySQLConnection().setSelfDestructOnPingMaxOperations(
1455                                maxOperations);
1456        }
1457
1458        public void setSelfDestructOnPingSecondsLifetime(int seconds) {
1459
1460                getActiveMySQLConnection()
1461                                .setSelfDestructOnPingSecondsLifetime(seconds);
1462        }
1463
1464        public void setServerTimezone(String property) {
1465
1466                getActiveMySQLConnection().setServerTimezone(property);
1467        }
1468
1469        public void setSessionVariables(String variables) {
1470
1471                getActiveMySQLConnection().setSessionVariables(variables);
1472        }
1473
1474        public void setSlowQueryThresholdMillis(int millis) {
1475
1476                getActiveMySQLConnection().setSlowQueryThresholdMillis(millis);
1477        }
1478
1479        public void setSlowQueryThresholdNanos(long nanos) {
1480
1481                getActiveMySQLConnection().setSlowQueryThresholdNanos(nanos);
1482        }
1483
1484        public void setSocketFactory(String name) {
1485
1486                getActiveMySQLConnection().setSocketFactory(name);
1487        }
1488
1489        public void setSocketFactoryClassName(String property) {
1490
1491                getActiveMySQLConnection().setSocketFactoryClassName(property);
1492        }
1493
1494        public void setSocketTimeout(int property) {
1495
1496                getActiveMySQLConnection().setSocketTimeout(property);
1497        }
1498
1499        public void setStatementInterceptors(String value) {
1500
1501                getActiveMySQLConnection().setStatementInterceptors(value);
1502        }
1503
1504        public void setStrictFloatingPoint(boolean property) {
1505
1506                getActiveMySQLConnection().setStrictFloatingPoint(property);
1507        }
1508
1509        public void setStrictUpdates(boolean property) {
1510
1511                getActiveMySQLConnection().setStrictUpdates(property);
1512        }
1513
1514        public void setTcpKeepAlive(boolean flag) {
1515
1516                getActiveMySQLConnection().setTcpKeepAlive(flag);
1517        }
1518
1519        public void setTcpNoDelay(boolean flag) {
1520
1521                getActiveMySQLConnection().setTcpNoDelay(flag);
1522        }
1523
1524        public void setTcpRcvBuf(int bufSize) {
1525
1526                getActiveMySQLConnection().setTcpRcvBuf(bufSize);
1527        }
1528
1529        public void setTcpSndBuf(int bufSize) {
1530
1531                getActiveMySQLConnection().setTcpSndBuf(bufSize);
1532        }
1533
1534        public void setTcpTrafficClass(int classFlags) {
1535
1536                getActiveMySQLConnection().setTcpTrafficClass(classFlags);
1537        }
1538
1539        public void setTinyInt1isBit(boolean flag) {
1540
1541                getActiveMySQLConnection().setTinyInt1isBit(flag);
1542        }
1543
1544        public void setTraceProtocol(boolean flag) {
1545
1546                getActiveMySQLConnection().setTraceProtocol(flag);
1547        }
1548
1549        public void setTransformedBitIsBoolean(boolean flag) {
1550
1551                getActiveMySQLConnection().setTransformedBitIsBoolean(flag);
1552        }
1553
1554        public void setTreatUtilDateAsTimestamp(boolean flag) {
1555
1556                getActiveMySQLConnection().setTreatUtilDateAsTimestamp(flag);
1557        }
1558
1559        public void setTrustCertificateKeyStorePassword(String value) {
1560
1561                getActiveMySQLConnection().setTrustCertificateKeyStorePassword(value);
1562        }
1563
1564        public void setTrustCertificateKeyStoreType(String value) {
1565
1566                getActiveMySQLConnection().setTrustCertificateKeyStoreType(value);
1567        }
1568
1569        public void setTrustCertificateKeyStoreUrl(String value) {
1570
1571                getActiveMySQLConnection().setTrustCertificateKeyStoreUrl(value);
1572        }
1573
1574        public void setUltraDevHack(boolean flag) {
1575
1576                getActiveMySQLConnection().setUltraDevHack(flag);
1577        }
1578
1579        public void setUseAffectedRows(boolean flag) {
1580
1581                getActiveMySQLConnection().setUseAffectedRows(flag);
1582        }
1583
1584        public void setUseBlobToStoreUTF8OutsideBMP(boolean flag) {
1585
1586                getActiveMySQLConnection().setUseBlobToStoreUTF8OutsideBMP(flag);
1587        }
1588
1589        public void setUseColumnNamesInFindColumn(boolean flag) {
1590
1591                getActiveMySQLConnection().setUseColumnNamesInFindColumn(flag);
1592        }
1593
1594        public void setUseCompression(boolean property) {
1595
1596                getActiveMySQLConnection().setUseCompression(property);
1597        }
1598
1599        public void setUseConfigs(String configs) {
1600
1601                getActiveMySQLConnection().setUseConfigs(configs);
1602        }
1603
1604        public void setUseCursorFetch(boolean flag) {
1605
1606                getActiveMySQLConnection().setUseCursorFetch(flag);
1607        }
1608
1609        public void setUseDirectRowUnpack(boolean flag) {
1610
1611                getActiveMySQLConnection().setUseDirectRowUnpack(flag);
1612        }
1613
1614        public void setUseDynamicCharsetInfo(boolean flag) {
1615
1616                getActiveMySQLConnection().setUseDynamicCharsetInfo(flag);
1617        }
1618
1619        public void setUseFastDateParsing(boolean flag) {
1620
1621                getActiveMySQLConnection().setUseFastDateParsing(flag);
1622        }
1623
1624        public void setUseFastIntParsing(boolean flag) {
1625
1626                getActiveMySQLConnection().setUseFastIntParsing(flag);
1627        }
1628
1629        public void setUseGmtMillisForDatetimes(boolean flag) {
1630
1631                getActiveMySQLConnection().setUseGmtMillisForDatetimes(flag);
1632        }
1633
1634        public void setUseHostsInPrivileges(boolean property) {
1635
1636                getActiveMySQLConnection().setUseHostsInPrivileges(property);
1637        }
1638
1639        public void setUseInformationSchema(boolean flag) {
1640
1641                getActiveMySQLConnection().setUseInformationSchema(flag);
1642        }
1643
1644        public void setUseJDBCCompliantTimezoneShift(boolean flag) {
1645
1646                getActiveMySQLConnection().setUseJDBCCompliantTimezoneShift(flag);
1647        }
1648
1649        public void setUseJvmCharsetConverters(boolean flag) {
1650
1651                getActiveMySQLConnection().setUseJvmCharsetConverters(flag);
1652        }
1653
1654        public void setUseLegacyDatetimeCode(boolean flag) {
1655
1656                getActiveMySQLConnection().setUseLegacyDatetimeCode(flag);
1657        }
1658
1659        public void setUseLocalSessionState(boolean flag) {
1660
1661                getActiveMySQLConnection().setUseLocalSessionState(flag);
1662        }
1663
1664        public void setUseLocalTransactionState(boolean flag) {
1665
1666                getActiveMySQLConnection().setUseLocalTransactionState(flag);
1667        }
1668
1669        public void setUseNanosForElapsedTime(boolean flag) {
1670
1671                getActiveMySQLConnection().setUseNanosForElapsedTime(flag);
1672        }
1673
1674        public void setUseOldAliasMetadataBehavior(boolean flag) {
1675
1676                getActiveMySQLConnection().setUseOldAliasMetadataBehavior(flag);
1677        }
1678
1679        public void setUseOldUTF8Behavior(boolean flag) {
1680
1681                getActiveMySQLConnection().setUseOldUTF8Behavior(flag);
1682        }
1683
1684        public void setUseOnlyServerErrorMessages(boolean flag) {
1685
1686                getActiveMySQLConnection().setUseOnlyServerErrorMessages(flag);
1687        }
1688
1689        public void setUseReadAheadInput(boolean flag) {
1690
1691                getActiveMySQLConnection().setUseReadAheadInput(flag);
1692        }
1693
1694        public void setUseSSL(boolean property) {
1695
1696                getActiveMySQLConnection().setUseSSL(property);
1697        }
1698
1699        public void setUseSSPSCompatibleTimezoneShift(boolean flag) {
1700
1701                getActiveMySQLConnection().setUseSSPSCompatibleTimezoneShift(flag);
1702        }
1703
1704        public void setUseServerPrepStmts(boolean flag) {
1705
1706                getActiveMySQLConnection().setUseServerPrepStmts(flag);
1707        }
1708
1709        public void setUseServerPreparedStmts(boolean flag) {
1710
1711                getActiveMySQLConnection().setUseServerPreparedStmts(flag);
1712        }
1713
1714        public void setUseSqlStateCodes(boolean flag) {
1715
1716                getActiveMySQLConnection().setUseSqlStateCodes(flag);
1717        }
1718
1719        public void setUseStreamLengthsInPrepStmts(boolean property) {
1720
1721                getActiveMySQLConnection().setUseStreamLengthsInPrepStmts(property);
1722        }
1723
1724        public void setUseTimezone(boolean property) {
1725
1726                getActiveMySQLConnection().setUseTimezone(property);
1727        }
1728
1729        public void setUseUltraDevWorkAround(boolean property) {
1730
1731                getActiveMySQLConnection().setUseUltraDevWorkAround(property);
1732        }
1733
1734        public void setUseUnbufferedInput(boolean flag) {
1735
1736                getActiveMySQLConnection().setUseUnbufferedInput(flag);
1737        }
1738
1739        public void setUseUnicode(boolean flag) {
1740
1741                getActiveMySQLConnection().setUseUnicode(flag);
1742        }
1743
1744        public void setUseUsageAdvisor(boolean useUsageAdvisorFlag) {
1745
1746                getActiveMySQLConnection().setUseUsageAdvisor(useUsageAdvisorFlag);
1747        }
1748
1749        public void setUtf8OutsideBmpExcludedColumnNamePattern(String regexPattern) {
1750
1751                getActiveMySQLConnection().setUtf8OutsideBmpExcludedColumnNamePattern(
1752                                regexPattern);
1753        }
1754
1755        public void setUtf8OutsideBmpIncludedColumnNamePattern(String regexPattern) {
1756
1757                getActiveMySQLConnection().setUtf8OutsideBmpIncludedColumnNamePattern(
1758                                regexPattern);
1759        }
1760
1761        public void setVerifyServerCertificate(boolean flag) {
1762
1763                getActiveMySQLConnection().setVerifyServerCertificate(flag);
1764        }
1765
1766        public void setYearIsDateType(boolean flag) {
1767
1768                getActiveMySQLConnection().setYearIsDateType(flag);
1769        }
1770
1771        public void setZeroDateTimeBehavior(String behavior) {
1772
1773                getActiveMySQLConnection().setZeroDateTimeBehavior(behavior);
1774        }
1775
1776        public boolean useUnbufferedInput() {
1777
1778                return getActiveMySQLConnection().useUnbufferedInput();
1779        }
1780
1781        public StringBuffer generateConnectionCommentBlock(StringBuffer buf) {
1782
1783                return getActiveMySQLConnection().generateConnectionCommentBlock(buf);
1784        }
1785
1786        public int getActiveStatementCount() {
1787
1788                return getActiveMySQLConnection().getActiveStatementCount();
1789        }
1790
1791        public boolean getAutoCommit() throws SQLException {
1792
1793                return getActiveMySQLConnection().getAutoCommit();
1794        }
1795
1796        public int getAutoIncrementIncrement() {
1797
1798                return getActiveMySQLConnection().getAutoIncrementIncrement();
1799        }
1800
1801        public CachedResultSetMetaData getCachedMetaData(String sql) {
1802
1803                return getActiveMySQLConnection().getCachedMetaData(sql);
1804        }
1805
1806        public Calendar getCalendarInstanceForSessionOrNew() {
1807
1808                return getActiveMySQLConnection().getCalendarInstanceForSessionOrNew();
1809        }
1810
1811        public synchronized Timer getCancelTimer() {
1812
1813                return getActiveMySQLConnection().getCancelTimer();
1814        }
1815
1816        public String getCatalog() throws SQLException {
1817
1818                return getActiveMySQLConnection().getCatalog();
1819        }
1820
1821        public String getCharacterSetMetadata() {
1822
1823                return getActiveMySQLConnection().getCharacterSetMetadata();
1824        }
1825
1826        public SingleByteCharsetConverter getCharsetConverter(
1827                        String javaEncodingName) throws SQLException {
1828
1829                return getActiveMySQLConnection().getCharsetConverter(javaEncodingName);
1830        }
1831
1832        public String getCharsetNameForIndex(int charsetIndex) throws SQLException {
1833
1834                return getActiveMySQLConnection().getCharsetNameForIndex(charsetIndex);
1835        }
1836
1837        public TimeZone getDefaultTimeZone() {
1838
1839                return getActiveMySQLConnection().getDefaultTimeZone();
1840        }
1841
1842        public String getErrorMessageEncoding() {
1843
1844                return getActiveMySQLConnection().getErrorMessageEncoding();
1845        }
1846
1847        public ExceptionInterceptor getExceptionInterceptor() {
1848
1849                return getActiveMySQLConnection().getExceptionInterceptor();
1850        }
1851
1852        public int getHoldability() throws SQLException {
1853
1854                return getActiveMySQLConnection().getHoldability();
1855        }
1856
1857        public String getHost() {
1858
1859                return getActiveMySQLConnection().getHost();
1860        }
1861
1862        public long getId() {
1863
1864                return getActiveMySQLConnection().getId();
1865        }
1866
1867        public long getIdleFor() {
1868
1869                return getActiveMySQLConnection().getIdleFor();
1870        }
1871
1872        public MysqlIO getIO() throws SQLException {
1873
1874                return getActiveMySQLConnection().getIO();
1875        }
1876
1877        public MySQLConnection getLoadBalanceSafeProxy() {
1878
1879                return getActiveMySQLConnection().getLoadBalanceSafeProxy();
1880        }
1881
1882        public Log getLog() throws SQLException {
1883
1884                return getActiveMySQLConnection().getLog();
1885        }
1886
1887        public int getMaxBytesPerChar(String javaCharsetName) throws SQLException {
1888
1889                return getActiveMySQLConnection().getMaxBytesPerChar(javaCharsetName);
1890        }
1891
1892        public int getMaxBytesPerChar(Integer charsetIndex, String javaCharsetName) throws SQLException {
1893
1894                return getActiveMySQLConnection().getMaxBytesPerChar(charsetIndex, javaCharsetName);
1895        }
1896
1897        public DatabaseMetaData getMetaData() throws SQLException {
1898
1899                return getActiveMySQLConnection().getMetaData();
1900        }
1901
1902        public Statement getMetadataSafeStatement() throws SQLException {
1903
1904                return getActiveMySQLConnection().getMetadataSafeStatement();
1905        }
1906
1907        public int getNetBufferLength() {
1908
1909                return getActiveMySQLConnection().getNetBufferLength();
1910        }
1911
1912        public Properties getProperties() {
1913
1914                return getActiveMySQLConnection().getProperties();
1915        }
1916
1917        public boolean getRequiresEscapingEncoder() {
1918
1919                return getActiveMySQLConnection().getRequiresEscapingEncoder();
1920        }
1921
1922        public String getServerCharacterEncoding() {
1923
1924                return getActiveMySQLConnection().getServerCharacterEncoding();
1925        }
1926
1927        public int getServerMajorVersion() {
1928
1929                return getActiveMySQLConnection().getServerMajorVersion();
1930        }
1931
1932        public int getServerMinorVersion() {
1933
1934                return getActiveMySQLConnection().getServerMinorVersion();
1935        }
1936
1937        public int getServerSubMinorVersion() {
1938
1939                return getActiveMySQLConnection().getServerSubMinorVersion();
1940        }
1941
1942        public TimeZone getServerTimezoneTZ() {
1943
1944                return getActiveMySQLConnection().getServerTimezoneTZ();
1945        }
1946
1947        public String getServerVariable(String variableName) {
1948
1949                return getActiveMySQLConnection().getServerVariable(variableName);
1950        }
1951
1952        public String getServerVersion() {
1953
1954                return getActiveMySQLConnection().getServerVersion();
1955        }
1956
1957        public Calendar getSessionLockedCalendar() {
1958
1959                return getActiveMySQLConnection().getSessionLockedCalendar();
1960        }
1961
1962        public String getStatementComment() {
1963
1964                return getActiveMySQLConnection().getStatementComment();
1965        }
1966
1967        public List<StatementInterceptorV2> getStatementInterceptorsInstances() {
1968
1969                return getActiveMySQLConnection().getStatementInterceptorsInstances();
1970        }
1971
1972        public synchronized int getTransactionIsolation() throws SQLException {
1973
1974                return getActiveMySQLConnection().getTransactionIsolation();
1975        }
1976
1977        public synchronized Map<String, Class<?>> getTypeMap() throws SQLException {
1978
1979                return getActiveMySQLConnection().getTypeMap();
1980        }
1981
1982        public String getURL() {
1983
1984                return getActiveMySQLConnection().getURL();
1985        }
1986
1987        public String getUser() {
1988
1989                return getActiveMySQLConnection().getUser();
1990        }
1991
1992        public Calendar getUtcCalendar() {
1993
1994                return getActiveMySQLConnection().getUtcCalendar();
1995        }
1996
1997        public SQLWarning getWarnings() throws SQLException {
1998
1999                return getActiveMySQLConnection().getWarnings();
2000        }
2001
2002        public boolean hasSameProperties(Connection c) {
2003
2004                return getActiveMySQLConnection().hasSameProperties(c);
2005        }
2006
2007        public boolean hasTriedMaster() {
2008
2009                return getActiveMySQLConnection().hasTriedMaster();
2010        }
2011
2012        public void incrementNumberOfPreparedExecutes() {
2013
2014                getActiveMySQLConnection().incrementNumberOfPreparedExecutes();
2015        }
2016
2017        public void incrementNumberOfPrepares() {
2018
2019                getActiveMySQLConnection().incrementNumberOfPrepares();
2020        }
2021
2022        public void incrementNumberOfResultSetsCreated() {
2023
2024                getActiveMySQLConnection().incrementNumberOfResultSetsCreated();
2025        }
2026
2027        public void initializeExtension(Extension ex) throws SQLException {
2028
2029                getActiveMySQLConnection().initializeExtension(ex);
2030        }
2031
2032        public void initializeResultsMetadataFromCache(String sql,
2033                        CachedResultSetMetaData cachedMetaData,
2034                        ResultSetInternalMethods resultSet) throws SQLException {
2035
2036                getActiveMySQLConnection().initializeResultsMetadataFromCache(sql,
2037                                cachedMetaData, resultSet);
2038        }
2039
2040        public void initializeSafeStatementInterceptors() throws SQLException {
2041
2042                getActiveMySQLConnection().initializeSafeStatementInterceptors();
2043        }
2044
2045        public synchronized boolean isAbonormallyLongQuery(long millisOrNanos) {
2046
2047                return getActiveMySQLConnection().isAbonormallyLongQuery(millisOrNanos);
2048        }
2049
2050        public boolean isClientTzUTC() {
2051
2052                return getActiveMySQLConnection().isClientTzUTC();
2053        }
2054
2055        public boolean isCursorFetchEnabled() throws SQLException {
2056
2057                return getActiveMySQLConnection().isCursorFetchEnabled();
2058        }
2059
2060        public boolean isInGlobalTx() {
2061
2062                return getActiveMySQLConnection().isInGlobalTx();
2063        }
2064
2065        public synchronized boolean isMasterConnection() {
2066
2067                return getActiveMySQLConnection().isMasterConnection();
2068        }
2069
2070        public boolean isNoBackslashEscapesSet() {
2071
2072                return getActiveMySQLConnection().isNoBackslashEscapesSet();
2073        }
2074
2075        public boolean isReadInfoMsgEnabled() {
2076
2077                return getActiveMySQLConnection().isReadInfoMsgEnabled();
2078        }
2079
2080        public boolean isReadOnly() throws SQLException {
2081
2082                return getActiveMySQLConnection().isReadOnly();
2083        }
2084
2085        public boolean isRunningOnJDK13() {
2086
2087                return getActiveMySQLConnection().isRunningOnJDK13();
2088        }
2089
2090        public synchronized boolean isSameResource(Connection otherConnection) {
2091
2092                return getActiveMySQLConnection().isSameResource(otherConnection);
2093        }
2094
2095        public boolean isServerTzUTC() {
2096
2097                return getActiveMySQLConnection().isServerTzUTC();
2098        }
2099
2100        public boolean lowerCaseTableNames() {
2101
2102                return getActiveMySQLConnection().lowerCaseTableNames();
2103        }
2104
2105        public void maxRowsChanged(com.mysql.jdbc.Statement stmt) {
2106
2107                getActiveMySQLConnection().maxRowsChanged(stmt);
2108        }
2109
2110        public String nativeSQL(String sql) throws SQLException {
2111
2112                return getActiveMySQLConnection().nativeSQL(sql);
2113        }
2114
2115        public boolean parserKnowsUnicode() {
2116
2117                return getActiveMySQLConnection().parserKnowsUnicode();
2118        }
2119
2120        public void ping() throws SQLException {
2121
2122                getActiveMySQLConnection().ping();
2123        }
2124
2125        public void pingInternal(boolean checkForClosedConnection, int timeoutMillis)
2126                        throws SQLException {
2127
2128                getActiveMySQLConnection().pingInternal(checkForClosedConnection,
2129                                timeoutMillis);
2130        }
2131
2132        public CallableStatement prepareCall(String sql, int resultSetType,
2133                        int resultSetConcurrency, int resultSetHoldability)
2134                        throws SQLException {
2135
2136                return getActiveMySQLConnection().prepareCall(sql, resultSetType,
2137                                resultSetConcurrency, resultSetHoldability);
2138        }
2139
2140        public CallableStatement prepareCall(String sql, int resultSetType,
2141                        int resultSetConcurrency) throws SQLException {
2142
2143                return getActiveMySQLConnection().prepareCall(sql, resultSetType,
2144                                resultSetConcurrency);
2145        }
2146
2147        public CallableStatement prepareCall(String sql) throws SQLException {
2148
2149                return getActiveMySQLConnection().prepareCall(sql);
2150        }
2151
2152        public PreparedStatement prepareStatement(String sql, int resultSetType,
2153                        int resultSetConcurrency, int resultSetHoldability)
2154                        throws SQLException {
2155
2156                return getActiveMySQLConnection().prepareStatement(sql, resultSetType,
2157                                resultSetConcurrency, resultSetHoldability);
2158        }
2159
2160        public PreparedStatement prepareStatement(String sql, int resultSetType,
2161                        int resultSetConcurrency) throws SQLException {
2162
2163                return getActiveMySQLConnection().prepareStatement(sql, resultSetType,
2164                                resultSetConcurrency);
2165        }
2166
2167        public PreparedStatement prepareStatement(String sql, int autoGenKeyIndex)
2168                        throws SQLException {
2169
2170                return getActiveMySQLConnection()
2171                                .prepareStatement(sql, autoGenKeyIndex);
2172        }
2173
2174        public PreparedStatement prepareStatement(String sql,
2175                        int[] autoGenKeyIndexes) throws SQLException {
2176
2177                return getActiveMySQLConnection().prepareStatement(sql,
2178                                autoGenKeyIndexes);
2179        }
2180
2181        public PreparedStatement prepareStatement(String sql,
2182                        String[] autoGenKeyColNames) throws SQLException {
2183
2184                return getActiveMySQLConnection().prepareStatement(sql,
2185                                autoGenKeyColNames);
2186        }
2187
2188        public PreparedStatement prepareStatement(String sql) throws SQLException {
2189
2190                return getActiveMySQLConnection().prepareStatement(sql);
2191        }
2192
2193        public void realClose(boolean calledExplicitly, boolean issueRollback,
2194                        boolean skipLocalTeardown, Throwable reason) throws SQLException {
2195
2196                getActiveMySQLConnection().realClose(calledExplicitly, issueRollback,
2197                                skipLocalTeardown, reason);
2198        }
2199
2200        public void recachePreparedStatement(ServerPreparedStatement pstmt)
2201                        throws SQLException {
2202
2203                getActiveMySQLConnection().recachePreparedStatement(pstmt);
2204        }
2205
2206        public void registerQueryExecutionTime(long queryTimeMs) {
2207
2208                getActiveMySQLConnection().registerQueryExecutionTime(queryTimeMs);
2209        }
2210
2211        public void registerStatement(com.mysql.jdbc.Statement stmt) {
2212
2213                getActiveMySQLConnection().registerStatement(stmt);
2214        }
2215
2216        public void releaseSavepoint(Savepoint arg0) throws SQLException {
2217
2218                getActiveMySQLConnection().releaseSavepoint(arg0);
2219        }
2220
2221        public void reportNumberOfTablesAccessed(int numTablesAccessed) {
2222
2223                getActiveMySQLConnection().reportNumberOfTablesAccessed(
2224                                numTablesAccessed);
2225        }
2226
2227        public synchronized void reportQueryTime(long millisOrNanos) {
2228
2229                getActiveMySQLConnection().reportQueryTime(millisOrNanos);
2230        }
2231
2232        public void resetServerState() throws SQLException {
2233
2234                getActiveMySQLConnection().resetServerState();
2235        }
2236
2237        public void rollback() throws SQLException {
2238
2239                getActiveMySQLConnection().rollback();
2240        }
2241
2242        public void rollback(Savepoint savepoint) throws SQLException {
2243
2244                getActiveMySQLConnection().rollback(savepoint);
2245        }
2246
2247        public PreparedStatement serverPrepareStatement(String sql,
2248                        int resultSetType, int resultSetConcurrency,
2249                        int resultSetHoldability) throws SQLException {
2250
2251                return getActiveMySQLConnection().serverPrepareStatement(sql,
2252                                resultSetType, resultSetConcurrency, resultSetHoldability);
2253        }
2254
2255        public PreparedStatement serverPrepareStatement(String sql,
2256                        int resultSetType, int resultSetConcurrency) throws SQLException {
2257
2258                return getActiveMySQLConnection().serverPrepareStatement(sql,
2259                                resultSetType, resultSetConcurrency);
2260        }
2261
2262        public PreparedStatement serverPrepareStatement(String sql,
2263                        int autoGenKeyIndex) throws SQLException {
2264
2265                return getActiveMySQLConnection().serverPrepareStatement(sql,
2266                                autoGenKeyIndex);
2267        }
2268
2269        public PreparedStatement serverPrepareStatement(String sql,
2270                        int[] autoGenKeyIndexes) throws SQLException {
2271
2272                return getActiveMySQLConnection().serverPrepareStatement(sql,
2273                                autoGenKeyIndexes);
2274        }
2275
2276        public PreparedStatement serverPrepareStatement(String sql,
2277                        String[] autoGenKeyColNames) throws SQLException {
2278
2279                return getActiveMySQLConnection().serverPrepareStatement(sql,
2280                                autoGenKeyColNames);
2281        }
2282
2283        public PreparedStatement serverPrepareStatement(String sql)
2284                        throws SQLException {
2285
2286                return getActiveMySQLConnection().serverPrepareStatement(sql);
2287        }
2288
2289        public boolean serverSupportsConvertFn() throws SQLException {
2290
2291                return getActiveMySQLConnection().serverSupportsConvertFn();
2292        }
2293
2294        public void setAutoCommit(boolean autoCommitFlag) throws SQLException {
2295
2296                getActiveMySQLConnection().setAutoCommit(autoCommitFlag);
2297        }
2298
2299        public void setCatalog(String catalog) throws SQLException {
2300
2301                getActiveMySQLConnection().setCatalog(catalog);
2302        }
2303
2304        public synchronized void setFailedOver(boolean flag) {
2305
2306                getActiveMySQLConnection().setFailedOver(flag);
2307        }
2308
2309        public void setHoldability(int arg0) throws SQLException {
2310
2311                getActiveMySQLConnection().setHoldability(arg0);
2312        }
2313
2314        public void setInGlobalTx(boolean flag) {
2315
2316                getActiveMySQLConnection().setInGlobalTx(flag);
2317        }
2318
2319        public void setPreferSlaveDuringFailover(boolean flag) {
2320
2321                getActiveMySQLConnection().setPreferSlaveDuringFailover(flag);
2322        }
2323
2324        public void setProxy(MySQLConnection proxy) {
2325
2326                getActiveMySQLConnection().setProxy(proxy);
2327        }
2328
2329        public void setReadInfoMsgEnabled(boolean flag) {
2330
2331                getActiveMySQLConnection().setReadInfoMsgEnabled(flag);
2332        }
2333
2334        public void setReadOnly(boolean readOnlyFlag) throws SQLException {
2335
2336                getActiveMySQLConnection().setReadOnly(readOnlyFlag);
2337        }
2338
2339        public void setReadOnlyInternal(boolean readOnlyFlag) throws SQLException {
2340                getActiveMySQLConnection().setReadOnlyInternal(readOnlyFlag);
2341        }
2342
2343        public Savepoint setSavepoint() throws SQLException {
2344                return getActiveMySQLConnection().setSavepoint();
2345        }
2346
2347        public synchronized Savepoint setSavepoint(String name) throws SQLException {
2348                return getActiveMySQLConnection().setSavepoint(name);
2349        }
2350
2351        public void setStatementComment(String comment) {
2352                getActiveMySQLConnection().setStatementComment(comment);
2353        }
2354
2355        public synchronized void setTransactionIsolation(int level)
2356                        throws SQLException {
2357                getActiveMySQLConnection().setTransactionIsolation(level);
2358        }
2359
2360
2361        public void shutdownServer() throws SQLException {
2362                getActiveMySQLConnection().shutdownServer();
2363        }
2364
2365        public boolean storesLowerCaseTableName() {
2366                return getActiveMySQLConnection().storesLowerCaseTableName();
2367        }
2368
2369        public boolean supportsIsolationLevel() {
2370                return getActiveMySQLConnection().supportsIsolationLevel();
2371        }
2372
2373        public boolean supportsQuotedIdentifiers() {
2374                return getActiveMySQLConnection().supportsQuotedIdentifiers();
2375        }
2376
2377        public boolean supportsTransactions() {
2378                return getActiveMySQLConnection().supportsTransactions();
2379        }
2380
2381        public void throwConnectionClosedException() throws SQLException {
2382                getActiveMySQLConnection().throwConnectionClosedException();
2383        }
2384
2385        public void transactionBegun() throws SQLException {
2386                getActiveMySQLConnection().transactionBegun();
2387        }
2388
2389        public void transactionCompleted() throws SQLException {
2390                getActiveMySQLConnection().transactionCompleted();
2391        }
2392
2393        public void unregisterStatement(com.mysql.jdbc.Statement stmt) {
2394                getActiveMySQLConnection().unregisterStatement(stmt);
2395        }
2396
2397        public void unSafeStatementInterceptors() throws SQLException {
2398                getActiveMySQLConnection().unSafeStatementInterceptors();
2399        }
2400
2401        public void unsetMaxRows(com.mysql.jdbc.Statement stmt) throws SQLException {
2402                getActiveMySQLConnection().unsetMaxRows(stmt);
2403        }
2404
2405        public boolean useAnsiQuotedIdentifiers() {
2406                return getActiveMySQLConnection().useAnsiQuotedIdentifiers();
2407        }
2408
2409        public boolean useMaxRows() {
2410                return getActiveMySQLConnection().useMaxRows();
2411        }
2412
2413        public boolean versionMeetsMinimum(int major, int minor, int subminor)
2414                        throws SQLException {
2415                return getActiveMySQLConnection().versionMeetsMinimum(major, minor,
2416                                subminor);
2417        }
2418
2419        public boolean isClosed() throws SQLException {
2420                return getActiveMySQLConnection().isClosed();
2421        }
2422
2423        public boolean getHoldResultsOpenOverStatementClose() {
2424                return getActiveMySQLConnection()
2425                                .getHoldResultsOpenOverStatementClose();
2426        }
2427
2428        public String getLoadBalanceConnectionGroup() {
2429                return getActiveMySQLConnection().getLoadBalanceConnectionGroup();
2430        }
2431
2432        public boolean getLoadBalanceEnableJMX() {
2433                return getActiveMySQLConnection().getLoadBalanceEnableJMX();
2434        }
2435
2436        public String getLoadBalanceExceptionChecker() {
2437                return getActiveMySQLConnection()
2438                                .getLoadBalanceExceptionChecker();
2439        }
2440
2441        public String getLoadBalanceSQLExceptionSubclassFailover() {
2442                return getActiveMySQLConnection()
2443                                .getLoadBalanceSQLExceptionSubclassFailover();
2444        }
2445
2446        public String getLoadBalanceSQLStateFailover() {
2447                return getActiveMySQLConnection()
2448                                .getLoadBalanceSQLStateFailover();
2449        }
2450
2451        public void setLoadBalanceConnectionGroup(String loadBalanceConnectionGroup) {
2452                getActiveMySQLConnection()
2453                                .setLoadBalanceConnectionGroup(loadBalanceConnectionGroup);
2454               
2455        }
2456
2457        public void setLoadBalanceEnableJMX(boolean loadBalanceEnableJMX) {
2458                getActiveMySQLConnection()
2459                                .setLoadBalanceEnableJMX(loadBalanceEnableJMX);
2460               
2461        }
2462
2463        public void setLoadBalanceExceptionChecker(
2464                        String loadBalanceExceptionChecker) {
2465                getActiveMySQLConnection()
2466                                .setLoadBalanceExceptionChecker(loadBalanceExceptionChecker);
2467               
2468        }
2469
2470        public void setLoadBalanceSQLExceptionSubclassFailover(
2471                        String loadBalanceSQLExceptionSubclassFailover) {
2472                getActiveMySQLConnection()
2473                                .setLoadBalanceSQLExceptionSubclassFailover(loadBalanceSQLExceptionSubclassFailover);
2474               
2475        }
2476
2477        public void setLoadBalanceSQLStateFailover(
2478                        String loadBalanceSQLStateFailover) {
2479                getActiveMySQLConnection()
2480                                .setLoadBalanceSQLStateFailover(loadBalanceSQLStateFailover);
2481               
2482        }
2483       
2484        /**
2485         *
2486         * @param SQL
2487         * @return
2488         */
2489        public boolean shouldExecutionTriggerServerSwapAfter(String SQL){
2490                return false;
2491        }
2492
2493        public boolean isProxySet() {
2494                return this.getActiveMySQLConnection().isProxySet();
2495        }
2496
2497
2498        public String getLoadBalanceAutoCommitStatementRegex() {
2499                return getActiveMySQLConnection()
2500                        .getLoadBalanceAutoCommitStatementRegex();
2501        }
2502
2503        public int getLoadBalanceAutoCommitStatementThreshold() {
2504                return getActiveMySQLConnection()
2505                        .getLoadBalanceAutoCommitStatementThreshold();
2506        }
2507
2508        public void setLoadBalanceAutoCommitStatementRegex(
2509                        String loadBalanceAutoCommitStatementRegex) {
2510                getActiveMySQLConnection()
2511                        .setLoadBalanceAutoCommitStatementRegex(loadBalanceAutoCommitStatementRegex);
2512               
2513        }
2514
2515        public void setLoadBalanceAutoCommitStatementThreshold(
2516                        int loadBalanceAutoCommitStatementThreshold) {
2517                getActiveMySQLConnection()
2518                        .setLoadBalanceAutoCommitStatementThreshold(loadBalanceAutoCommitStatementThreshold);
2519               
2520        }
2521
2522        public boolean getIncludeThreadDumpInDeadlockExceptions() {
2523                return getActiveMySQLConnection().getIncludeThreadDumpInDeadlockExceptions();
2524        }
2525
2526        public void setIncludeThreadDumpInDeadlockExceptions(boolean flag) {
2527                getActiveMySQLConnection().setIncludeThreadDumpInDeadlockExceptions(flag);
2528        }
2529
2530        public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
2531                getActiveMySQLConnection().setTypeMap(map);
2532        }
2533
2534        public boolean getIncludeThreadNamesAsStatementComment() {
2535                return getActiveMySQLConnection().getIncludeThreadNamesAsStatementComment();
2536        }
2537
2538        public void setIncludeThreadNamesAsStatementComment(boolean flag) {
2539                getActiveMySQLConnection().setIncludeThreadNamesAsStatementComment(flag);
2540        }
2541
2542        public synchronized boolean isServerLocal() throws SQLException {
2543                return getActiveMySQLConnection().isServerLocal();
2544        }
2545
2546        public void setAuthenticationPlugins(String authenticationPlugins) {
2547                getActiveMySQLConnection().setAuthenticationPlugins(authenticationPlugins);
2548        }
2549
2550        public String getAuthenticationPlugins() {
2551                return getActiveMySQLConnection().getAuthenticationPlugins();
2552        }
2553
2554        public void setDisabledAuthenticationPlugins(
2555                        String disabledAuthenticationPlugins) {
2556                getActiveMySQLConnection().setDisabledAuthenticationPlugins(disabledAuthenticationPlugins);
2557        }
2558
2559        public String getDisabledAuthenticationPlugins() {
2560                return getActiveMySQLConnection().getDisabledAuthenticationPlugins();
2561        }
2562
2563        public void setDefaultAuthenticationPlugin(
2564                        String defaultAuthenticationPlugin) {
2565                getActiveMySQLConnection().setDefaultAuthenticationPlugin(defaultAuthenticationPlugin);
2566        }
2567
2568        public String getDefaultAuthenticationPlugin() {
2569                return getActiveMySQLConnection().getDefaultAuthenticationPlugin();
2570        }
2571       
2572        public void setParseInfoCacheFactory(String factoryClassname) {
2573                getActiveMySQLConnection().setParseInfoCacheFactory(factoryClassname);
2574        }
2575
2576        public String getParseInfoCacheFactory() {
2577                return getActiveMySQLConnection().getParseInfoCacheFactory();
2578        }
2579
2580        public void setSchema(String schema) throws SQLException {
2581                getActiveMySQLConnection().setSchema(schema);
2582        }
2583
2584        public String getSchema() throws SQLException {
2585                return getActiveMySQLConnection().getSchema();
2586        }
2587
2588        public void abort(Executor executor) throws SQLException {
2589                getActiveMySQLConnection().abort(executor);
2590        }
2591
2592        public void setNetworkTimeout(Executor executor, int milliseconds)
2593                        throws SQLException {
2594                getActiveMySQLConnection().setNetworkTimeout(executor, milliseconds);
2595        }
2596
2597        public int getNetworkTimeout() throws SQLException {
2598                return getActiveMySQLConnection().getNetworkTimeout();
2599        }
2600}
Note: See TracBrowser for help on using the repository browser.