-
Notifications
You must be signed in to change notification settings - Fork 34
/
Copy pathCHANGES
4640 lines (3269 loc) · 198 KB
/
CHANGES
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
# Changelog
# $Id$
10-03-11 - Version 5.1.18
- Fix for Bug#12565726, not putting the space between VALUES() and ON DUPLICATE KEY UPDATE
causes C/J a) enter rewriting the query altrhough it has ON UPDATE
and b) to generate the wrong query with multiple ON DUPLICATE KEY
- Fix for Bug#12784170, "process fork failure" errors while running test suite via ant on Windows.
Added new ant flag, com.mysql.jdbc.junit.fork, which controls whether JUnit will fork new processes
for testing ("on", default and legacy behavior) or not ("off", required for Windows).
- Reverting changes made to ConnectionImpl.java,
private boolean characterSetNamesMatches function.
- Added function MYSQL_INDEX_TO_MYSQL_CHARSET to retrieve server charset name
using index instead of parsing variables to CharsetMapping.java
- Completed fix for Bug#61201/12649557, fixed tests failures.
- Fix for Bug#61201/12649557, Can't establish connection when url has
sessionVariables and characterEncoding. Fix covers only MySQL server 4.1+
- Fix for Bug#61501 - Calling Statement.cancel() on a statement that isn't
currently executing will cause some later-executed query on the same
connection to be cancelled unexpectedly. The driver now guards against this
condition, but it is an underlying server issue. The MySQL statement "KILL QUERY"
(which is what the driver uses to implement Statement.cancel()) is rather
non-deterministic, and thus the use of Statement.cancel() should be avoided
if possible.
- Fix for Bug#61866/12791594 - Calling Statement.getWarnings() after
Statement.clearWarnings() has been called, returns the "old" warnings.
- Fix for Bug#13036537 - LRUCache was really a least-recently-added cache.
- Fix for Bug#13036309, Correcting parameter name in maxPerformance.properties
07-04-11 - Version 5.1.17
- Fix for Bug#61332 - LIKE not optimized in server when run against I__S tables and no wildcards used.
Databases/tables with "_" and/or "%" in their names (escaped or not) will be handled by this code path,
although slower, since it's rare to find these characters in table names in SQL. If there's a "_" or "%"
in the string, LIKE will take care of that, otherwise we now use = . The only exception is
information_schema database which is handled separately. Patch covers both getTables() and getColumns().
- Fix for Bug#61150 - First call to stored procedure fails with "No Database Selected".
The workaround introduced in DatabaseMetaData.getCallStmtParameterTypes to fix
the bug in server where SHOW CREATE PROCEDURE was not respecting lower-case table names
is misbehaving when connection is not attached to database and on non-casesensitive OS.
- Fix for Bug#61105 - Avoid a concurrent bottleneck in Java's character set
encoding/decoding when converting bytes to/from Strings.
04-21-11 - Version 5.1.16
- Partial fix for BUG#54135 - setQueryTimeout unsafe across VIP. Fix prevents c/J from
killing the right ConnectionID but on wrong server.
- Fix for BUG#57808 - wasNull not set for DATE field with value 0000-00-00
in getDate() although zeroDateTimeBehavior is convertToNull.
- Fix for Bug#54425 - Bypassing the server protocol bug where DB should be null-terminated
whether it exists or not. Affects COM_CHANGE_USER.
- Fix for Bug#60313 (11890729), bug in
com.mysql.jdbc.ResultSetRow.getTimestampFast().
- Fix for bug 11782297, DBMD.getTables (so thus getColumns too) fails with
table names containing dot (like "junk_[Sp:e,c/ C-h+a=.r]").
- Added the ability to determine if the connection is against a server on the
same host via the Connection.isServerLocal() method.
- Fix for bug 12325877, Setting "autoReconnect=true" and
"cacheServerConfiguration=true" would cause connections created after
an existing connection fails to have non-existent values for server
variables which lead to exceeding of max allowed packet exceptions when the
new connections were used.
02-08-11 - Version 5.1.15
- Fix for Bug#38367, parameters metadata did not reflect the fact that NULL is allowed
parameter value. So DatabaseMetaData.getProcedureColumns will set isNullable member to
java.sql.DatabaseMetaData.procedureNullable now.
- Completed fix for Bug#27916.
- Fix for Bug#59224, adding 5.5 reserved words to DatabaseMetaData.getSQLKeywords().
- Fixed an issue where statement comments set via Connection.setStatementComment()
weren't represented in autoGenerateTestcaseScript=true output.
- Added ability to include the current java thread dump in the exception message
given for deadlock/wait lock timeout exceptions, enable with
"includeThreadDumpInDeadlockExceptions=true" in your JDBC url.
- Added ability to include current thread name as a statement comment visible
in MySQL's "SHOW PROCESSLIST" and Innodb deadlock diagnostics, enable with
"includeThreadNamesAsStatementComment=true".
- Added an SLF4J logging adapter. Enable by adding setting the connection
property "logger" to "Slf4JLogger" and placing the appropriate bridge
from SLF4J to the logging framework of choice in your CLASSPATH. As with
other Connector/J logging adapters, the log category name used by the
driver is "MySQL". See http://www.slf4j.org/manual.html for more details.
12-06-10 - Version 5.1.14
- Fix for Bug#58728, NPE in com.mysql.jdbc.jdbc2.optional.StatementWrappe.getResultSet()
if rs is null. Regression test case added to Statement regression tests.
- Fix for Bug#58751, DatabaseMetadata.getIndexInfo() CARDINALITY now clamped
to Integer.MAX_VALUE.
- Fix for BUG#58590
- Testsuite.Simple.DateTest, MetadataTest, NumbersTest and StatementsTest cleaned and fixed.
- Testsuite.simple, ConenctionTest & DataSourceTest are up to date. Major rework on
ConnectionTest.testDeadlockDetection (Sveta) and testUseCompress.
- Testsuite.simple, CallableStatementTest & CharsetTests are up to date.
- Testsuite.regression SubqueriesRegressionTest and StringRegressionTest are up to date.
- Testsuite.regression MicroPerformanceRegressionTest, NumbersRegressionTest, PooledConnectionRegressionTest,
ResultSetRegressionTest are up to date.
- Testsuite.regression.MetaDataRegressionTest up to date.
- Typo in StatementRegressionTest.testLikeWithBackslashes fixed. StatementRegressionTest
is up to date.
- Fix for Bug#58232 - CallableStatement fails to fetch OUT parameter against 5.5 server
- Testsuite.regression.Connection, tests for BUG#45419 refined by Todd so not to cause failures.
- Testsuite.regression.CallableStatement, tests for BUG#26959 failing against 5.5+ server.
- Bringing testsuite.regression.CachedRowsetTest up to date.
- Bringing BLOBregression tests up to date.
- Fix for Bug#58042 - Statements test failure not handled.
- Fix for Bug#57850 - Refresh SELECT statement doesn't use correct data type.
Added Field.valueNeedsQuoting (private final boolean) and protected boolean getvalueNeedsQuoting().
UpdatableResultSet refresher and updater call upon this value now.
- Removing commented source in fix for Bug#57697
- Fix for Bug#57697 - Metadata getTables() was not checking for table_name already been quoted.
- Fix for Bug#57694 - 3byte UTF8 can not be used with 5.5.3+ server.
- Fix for Bug#57701 - StatementsTest.testBatchRewriteErrors() failing on new servers.
- Fix for Bug#54756 - Cannot retrieve data from ResultSet by column name from a Sphinx daemon.
We were relying only on "server version string" passed. Now, determining
server version is done via protocol flags too, where applicable.
- Fix for Bug#57022 - cannot execute a store procedure with output parameters,
database parameter was ignored in db.sp notation. The fix is to "sanitize"
db.sp call just like in patch for noAccessToProcedureBodies. BaseTestCase
extended with createDatabase and dropDatabase. Regression test added.
- Fix for Bug#57262 - "useOldUTF8Behavior" behavior was broken since 5.1.3,
now explicitly sets connection character set to latin1 ("SET NAMES latin1")
during connection post-handshake process.
- Patch for problem where "noAccessToProcedureBodies=true" was causing
"underprivileged" user not to have access to procedures created by him.
- Patch for Bug#56305, unhandled NPE in DatabaseMetaData.java when calling
wrong-cased function without access to mysql.proc. Although simple by
itself, some more enhancements were needed for everything to function
properly. So, along with catching potential NPE due to server bug, a
guard against calling JDBC functions with db_name.proc_name notation was
also added. Necessary changes added to StringUtils.java too.
- Added ability to load-balance while auto-commit is enabled. This
introduces two new properties:
loadBalanceAutoCommitStatementThreshold defines the number of matching
statements which will trigger the driver to (potentially) swap physical
server connections,
loadBalanceAutoCommitStatementRegex defines the regular expression
against which statements must match. The default values (0 and blank,
respectively) retain the previously-established behavior that
connections with auto-commit enabled are never balanced. Feature
request documented in Bug#55723.
- Minor fix in getProcedureColumns() DisplaySize for Bug#51712. Fix for
Bug#41269 is not complete without this. getColumnDisplaySize on a
ResultSet already consisting of metadata is now functional thanks to
Bogdan.
- Minor fix for Bug#55217, return 4 as a result of DataBaseMetadata.getJDBCMajorVersion() as per manual.
- Added support for hosts specified in the URL of the form:
address=(key=value), supported keys are:
(protocol=tcp or pipe (for named pipes on Windows)
(path=[] for named pipes)
(host=[]) for TCP connections
(port=[]) for TCP connections
An example would be:
jdbc:mysql://address=(protocol=tcp)(host=localhost)(port=3306)(user=test)/db
Any other parameters are treated as host-specific properties that follow
the conventions of the JDBC URL properties. This now allows per-host
overrides of any configuration property for multi-host connections
(failover, loadbalance, replication). We do recommend that the overrides
are limited to user, password, network timeouts and statement and
metadata cache sizes. Unexpected behavior may be observed with other
per-host overrides.
- Fix for Bug#56099 - Added support for JDBC4-specific functionality when
using load-balanced connections.
- Fix for Bug#56200 - Added diagnostic information to SQLException message
thrown when a closed load-balanced connection is reused. This
information will identify the conditions which caused the connection to
be closed.
- Fix for Bug#56429 - When using Connector/J configured for failover
(jdbc:mysql://host1,host2,... URLs), the non-primary servers re-balance
and spawned new idle connections when the transactions on the master were
committed or rolled-back, eventually exceeding max_connections. It was
also discovered that session state (autocommit, isolation level, catalog)
wasn't being copied from the primary connection to secondary
connections correctly because of the same changes that caused this bug,
and this was fixed as well.
- Fix for Bug#56706 - Ensure read-only state is synchronized when new
load-balanced connections are selected.
- Fixed Bug#56955 - Connection properties "trustCertificateKeyStoreType"
and "clientCertificateKeyStoreType" have invalid defaults, therefore
connections that specify "useSSL" will sometimes fail with exceptions
from JSSE unless "JKS" has been specified for both of these properties.
The default value for these properties is now "JKS", and thus it no
longer has to be specified.
- Fixed Bug#56979 - Improper connection closing logic leads to TIME_WAIT
sockets on server
- Fixed Bug#57380 - DatabaseMetaData.supportsMultipleResultSets() now returns
true when connected to a 4.1 version or later server.
- Fixed Bug#58706 - Failover connections didn't honor "failOverReadOnly=false", and in some
situations would not fall back.
- Removed logging integrations with log4j and apache-commons-logging due to license
incompatibility. Replacing with SLF4J integration in next release.
06-24-10 - Version 5.1.13
- Minor fix in previous patch for Bug#51904. Function ConnectionImpl.setCatalog() was passed quoted argument thus breaking with "...for the right syntax to use near 'test``'"
- Fix for Bug#51912 - Passing NULL as cat. param to getProcedureColumns with !nullCatalogMeansCurrent
- Fix for Bug#52167 - Can't parse parameter list with special characters inside
- Fix for Bug#51904 - getProcedureColumns() always returns PROCEDURE_CAT result column as NULL
- Fix for Bug#51712 - Display Size is always 0 for columns returned by getProcedureColumns()
- Fix for Bug#51908 - db variable might have end up unassigned when calling
getProcedureColumns()/Functions(). This is a followup on code changes made
for Bug#51022.
- Fixed Bug#51266 - jdbc:mysql:loadbalance:// would stick to the first
host in the list in some cases, especially exacerbated if the host was
down.
- Replaced URLs of the form jdbc:mysql://host-1,host-2 with a composite of
a normal connection and a jdbc:mysql:loadbalance:// connection for more
robustness and cleaner code.
- Fixed BUG#51643 - Connections using jdbc:mysql:loadbalance:// would
have statements (and prepared statements) that did not have their connections
changed upon commit()/rollback(), and thus applications that held statement
instances past commit()/rollback() could have data written to or read from
un-intended connections.
- Fixed BUG#51666 - StatementInterceptors were never "un-safed" after connection
establishment, causing interceptors which returned result sets pre/post execution
would not work.
- Fixed BUG#51783 - Load-balanced connections could throw a SQLException
incorrectly on commit() or rollback(). This was not caused by failures in commit
or rollback, but rather by the possibility that the newly-selected physical
connection was stale. Added logic to catch and retry if this happens, up to
the number of hosts specified for load-balancing. Also added new property,
loadBalanceValidateConnectionOnSwapServer, which controls whether to explicitly
ping the selected host (otherwise, the host is presumed to be up, and will only
be noticed if auto-commit or transaction isolation state needs to be set and
fails).
- Added loadBalancePingTimeout property to allow a specific timeout to be set
for each ping executed against the servers. This ping is executed when the
physical connections are rebalanced (commit/rollback or communication exception),
or when a query starting with (exactly) "/* ping */" is executed. The latter
causes each open underlying physical connection to be pinged.
- Fixed BUG#51776 - Connection.rollback() could swallow exceptions incorrectly.
- Fixed BUG#52231 - Differences in definitions of which SQLExceptions trigger
a failover event could result in failure to try more than a single host in
certain situations.
- Fixed BUG#52534 - Performance regression using load-balanced connection.
- More aggressively purge the statement timeout timers after they've been cancelled to
trade time for memory. This purge only happens if statement timeouts are in use.
- Added management of running load-balanced connections. Statistics can be obtained,
and hosts added/dropped via com.mysql.jdbc.ConnectionGroupManager or the JMX
implementation. This functionality is enabled by setting the new paramenter,
loadBalanceConnectionGroup to the name of the logical grouping of connections.
All load-balanced connections sharing the same loadBalanceConnectionGroup value,
regardless of how the application creates them, will be managed together. To
enable JMX-based management, set loadBalanceEnableJMX=true and ensure that remote
JMX is enabled in the JRE (eg, use -Dcom.sun.management.jmxremote).
- Added loadBalanceExceptionChecker property, which takes a fully-qualified class
name implementing com.mysql.jdbc.LoadBalancedExceptionChecker interface. This
allows custom evaluation of SQLExceptions thrown to determine whether they should
trigger failover to an alternate host in load-balanced deployments. The default
is com.mysql.jdbc.StandardLoadBalanceExceptionChecker.
- Added two new properties which allow more flexibility in determining which
SQLExceptions should trigger failover in a load-balanced deployment. The new
loadBalanceSQLStateFailover property takes a comma-delimited list of SQLState
codes which are compared to the SQLState of the SQLException (matching done
with trailing wildcard), while loadBalanceSQLExceptionSubclassFailover takes
a comma-delimited list of fully-qualified class/interface names, against
which the SQLException is checked to determine if it is an instance of any.
Matches trigger failover to an alternate host.
- Fixed Bug#51704 - Re-written batched statements don't honor escape processing
flag of their creator.
- Fixed Bug#43576 - Sometimes not able to register OUT parameters for
CallableStatements.
- Fixed Bug#54175 - Driver doesn't support utf8mb4 for servers 5.5.2 and newer. The
driver now auto-detects servers configured with character_set_server=utf8mb4 or
treats the Java encoding "utf-8" passed via "characterEncoding=..." as utf8mb4 in
the "SET NAMES=" calls it makes when establishing the connection.
02-18-10 - Version 5.1.12
- NO_INDEX_USED and NO_GOOD_INDEX used were only being set when profileSQL
was set to "true", and in some cases their values were reversed.
- Fix for Bug#51022 - conn.getMetaData().getProcedures("schema",null,"%");
returns all stored procedures from all databases and not only for given
one.
- Fixed Bug#50538 - ${svn.revno} shows up in DBMD.getDriverVersion().
- Removed usage of timestamp nanoseconds in PreparedStatement.setTimestamp(),
as long as Bug#50774 exists in the server and there's no real support
for nanos/micros in TIMESTAMPs, avoid the performance regression usage of
them causes.
01-20-10 - Version 5.1.11
- Fix for BUG#50288 - NullPointerException possible during invalidateCurrentConnection() for load-balanced
connections.
- Fix for BUG#49745 - deleteRow() for updatable result sets can cause full table scan because escaped hex
values are used for primary key identifiers.
- Fix for BUG#49607 - Provide Connection context in ExceptionInterceptor.
- Fix for BUG#48605 - Ping leaves closed connections in liveConnections, causing subsequent Exceptions when
that connection is used.
- Fix for BUG#48442 - Load-balanced Connection object returns inconsistent results for hashCode() and equals()
dependent upon state of underlying connections.
- Fix for BUG#48172 - Batch rewrite requires space immediately after "VALUES"
- Statement Interceptors didn't completely intercept server-side prepared statements.
- Fix for BUG#48486 Cannot use load balanced connections with MysqlConnectionPoolDataSource.
- Fix for Bug#32525 - "noDatetimeStringSync" doesn't work for server-side prepared statements. Now it does.
- Hooked up exception interceptors so they get called now.
- Rev'd the statement interceptor interface to pass on some server flags, warning counts and errors. See
the com.mysql.jdbc.StatementInteceptorsV2 interface for more details. The driver will create adaptors to
transparently convert older implementations to the newer interface at runtime.
- Statement Interceptors are now enabled at connection instantiation, but
can not return result sets (they will be ignored) until the connection
has bootstrapped itself. If during the init() method your interceptor
requires access to the connection itself, it should ensure that methods
that might throw exceptions if the connection is closed should handle
this in a robust manner.
- "Replication" connections (those with URLs that start with
jdbc:mysql:replication) now use a jdbc:mysql:loadbalance connection
under the hood for the slave "pool". This also means that one can set
load balancing properties such as "loadBalanceBlacklistTimeout" and
"loadBalanceStrategy" to choose a mechanism for balancing the load and
failover/fault tolerance strategy for the slave pool. This work was done
in order to fix Bug#49537.
- Fixed Bug#36565 - permgen leak from java.util.Timer. Unfortunately no great
fix exists that lets us keep the timer shared amongst connection instances, so
instead it's lazily created if need be per-instance, and torn down when the
connection is closed.
- Fixed BUG#49700 - Connections from ConnectionPoolDataSource don't
maintain any values set with "sesssionVariables=...". This was a bug
in Connection.changeUser()/resetServerState(), we now resubmit the
session variables during the execution of these methods.
09-22-09 - Version 5.1.10
- Fix for BUG#47494 - Non standard port numbers in the URL are not honored.
09-16-09 - Version 5.1.9
- The driver has been OSGi-ified. The bundle symbolic name is "com.mysql.jdbc", see META-INF/MANIFEST.MF to see
what interfaces we export.
- Fixed BUG#45040, adding missing tags from SVN import to BZR branch for
5.1.
- Fix for a variant of Bug#41484 - ResultSet.find*(String) failed when using cached result set
metadata.
- Fixed BUG#46637 - When the driver encounters an error condition that causes it to create a
CommunicationsException, it tries to build a friendly error message that helps diagnose
what is wrong. However, if there has been no network packets received from the server,
the error message contains bogus information like:
"The last packet successfully received from the server was 1,249,932,468,916 milliseconds ago.
The last packet sent successfully to the server was 0 milliseconds ago."
Now the error message states that it has never received any packets from the server in this
scenario.
- Added a new option, "queryTimeoutKillsConnection", when set to "true" will cause timeouts set
by Statement.setQueryTimeout() to forcibly kill the connection, not just the query.
- Fixed BUG#32216, "PORT" property filled in by Driver.parseURL() not always present. The driver
will now always fill in the "PORT" (using 3306 if not specified) property, and the "HOST" property
(using "localhost" if not specified) when parseURL() is called. The driver also parses a list of hosts
into HOST.n and PORT.n properties as well as adding a property "NUM_HOSTS" for the number of hosts
it has found. If a list of hosts is passed to the driver, "HOST" and "PORT" will be set to the
values given by "HOST.1" and "PORT.1" respectively. This change has centralized and cleaned up a large
swath of code used to generate lists of hosts, both for load-balanced and fault tolerant connections and
their tests.
- Fixed the ResultSet side of BUG#23584 - Calendar discared when retrieving dates from server-side prepared
statements. The other cases of this bug were fixed when "useLegacyDatetimeCode=false" became the default.
- Fixed Bug#44324 - Data truncation exceptions did not return the vendor error code from the server. Note that
the vendor error code is not hard-coded to 1265 as in the bug report, because the server returns different
error codes for different types of truncations, and we did not want to mask those.
- Fixed Bug#27431 - ResultSet.deleteRow() advances the cursor. The driver now places the cursor on the prior
row in the result set, or before the start of the result set if the result set is empty after the deletion.
- Fixed Bug#43759 - ResultSet.deleteRow() generates corrupt DELETE statement for primary keys with binary
data.
- Fixed Bug#46925 - Suspendable XA connections were not pinned to the XID for the global transaction, leading
to failure when attempting to suspend/resume/commit from different logical XA connections.
- Fixed Bug#44508 - DatabaseMetadata.getSuperTypes() returns result set with incorrect column names.
- Fixed Bug#46788 - Batched prepared statements with ON DUPLICATE KEY UPDATE are rewritten incorrectly when
when there are parameters as part of the UPDATE clause. Statements of this form can not be rewritten
as multi-value INSERTs so they are rewritten into multi-statements instead.
07-16-09 - Version 5.1.8
- Fixed BUG#44588 - Fixed error message for connection exceptions when
streaming result sets are used.
- Modified/fixed test cases using UnreliableSocketFactory.
- Fixed BUG#43421 - Made doPing() global blacklist-aware, so that it does not
throw Exceptions when at least a single load-balanced server is available.
- Fixed BUG#43071 - Specifying ASCII encoding for converting seed String to
byte array; allowing system default encoding to be used causes auth failures
on EBCDIC platforms.
- Fixed BUG#43070 - traceProtocol parameter isn't configured early enough to
capture handshake protocol.
- Fixed BUG#41161 - PreparedStatement.addBatch() doesn't check for all parameters
being set, which leads to a NullPointerException when calling executeBatch() and
rewriting batched statements into multi-value or multi-statement statements.
- Fixed BUG#42055 - ConcurrentModificationException possible when removing items
from global blacklist.
- Fixed Bug #42309 - Statement.getGeneratedKeys() returns 2 keys when
using ON DUPLICATE KEY UPDATE
- Fixed some quoting of substituted parameter issues in localized error messages.
- Added a version check around getting the variable 'auto_increment_increment' for
servers < 5.0.2, which quiets down a warning message that the driver would log
when connecting to MySQL-4.1 or older.
- The driver will automatically disable elideSetAutoCommit and useLocalTransactionState
if it detects a MySQL server version older than 6.0.10 with the query cache enabled, due
to Bug#36326 which can cause the server to report bogus transaction state.
- Fixed a performance regression (Bug#41532) in rewritten batched inserts when "ON DUPLICATE KEY"
was present.
Fixes include an improvement to token searching in the statement, and the ability for the driver
to rewrite prepared statements that include "ON DUPLICATE KEY UPDATE" into multi-valued inserts as
long as there is no use of LAST_INSERT_ID() in the update clause (as this would render
getGeneratedKey() values incorrect).
- Fixed Bug#44056 - Statement.getGeneratedKeys() retains result set instances until statement is closed,
thus causing memory leaks for long-lived statements, or statements used in tight loops.
- Fixed issues with server-side prepared statement batch re-writing caused by the fix to Bug#41532.
Rewriting of batched statements now works the same between normal prepared statements and server-side
prepared statements.
- Fixed Bug#44862 - getBestRowIdentifier does not return resultset as per JDBC API specifications
- Fixed Bug#44683 - getVersionColumns does not return resultset as per JDBC API specifications
- Fixed Bug#44865 - getColumns does not return resultset as per JDBC API specifications
- Fixed Bug#44868 - getTypeInfo does not return resultset as per JDBC API specifications
- Fixed Bug#44869 - getIndexInfo does not return resultset as per JDBC API specifications
- Fixed Bug#44867 - getImportedKeys/exportedKeys/crossReference doesn't have correct type for DEFERRABILITY
- Fixed Bug#41730 - SQL Injection when using U+00A5 and SJIS
- Fixed Bug#43196 - Statement.getGeneratedKeys() doesn't return values for UNSIGNED BIGINTS with values > Long.MAX_VALUE.
Unfortunately, because the server doesn't tell clients what TYPE the auto increment value is, the driver can't consistently
return BigIntegers for the result set returned from getGeneratedKeys(), it will only return them if the value is > Long.MAX_VALUE.
If your application needs this consistency, it will need to check the class of the return value from .getObject() on the
ResultSet returned by Statement.getGeneratedKeys() and if it's not a BigInteger, create one based on the java.lang.Long that
is returned.
- Fixed Bug#38387 - "functionsNeverReturnBlobs=true" now works for SQL functions that return binary/binary collation VAR_STRINGS.
- Fixed Bug#45171 - Connection.serverPrepareStatement() returns wrong default result set types
- Fixed Bug #43714 - useInformationSchema with
DatabaseMetaData.getExportedKeys() throws exception
- Fixed Bug #42253 - multiple escaped quotes cause exception from
EscapeProcessor
- Fixed Bug #41566 - Quotes within comments not correctly ignored by
statement parser
- Fixed Bug #41269 - DatabaseMetadata.getProcedureColumns() returns
wrong value for column length
- Fixed Bug #40439 - Error rewriting batched statement if table name
ends with "values".
- Fixed Bug #41484 Accessing fields by name after the ResultSet is closed throws
NullPointerException.
- Fixed Bug #39426 - executeBatch passes most recent PreparedStatement params
to StatementInterceptor
- Support use of INFORMATION_SCHEMA.PARAMETERS when "useInformationSchema" is set "true" and the view exists
for DatabaseMetaData.getProcedureColumns() and getFunctionColumns().
- When "logSlowQueries" is set to "true", and the driver has made a connection to a server that has suport
for the SERVER_QUERY_WAS_SLOW flag in the protocol, the query will be logged if the server indicates the
query has passed the slow query threshold.
- Added new property, "maxAllowedPacket" to set maximum allowed packet size to
send to server.
10-22-08 - Version 5.1.7
- Fixed BUG#33861 - Added global blacklist for LoadBalancingConnectionProxy and
implemented in RandomBalanceStrategy and BestResponseTimeBalanceStrategy.
Added new property, "loadBalanceBlacklistTimeout", to control how long a
server lives in the global blacklist.
- Fixed BUG#38782 - Possible IndexOutOfBoundsException in random load balancing
strategy.
- Fixed BUG#39784 - invalidateCurrentConnection() does not manage global blacklist
when handling connection exceptions.
- Fixed BUG#40031 - Adding support for CallableStatement.execute() to call
stored procedures that are defined as NO SQL or SQL READ DATA when failed
over to a read-only slave with replication driver.
- Fixed BUG#35170- ResultSet.isAfterLast() doesn't work with for
streaming result sets.
- Fixed BUG#35199 - Parse error for metadata in stored function.
- Fixed BUG#35415 - When result set is from views without access to underlying
columns and is opened with CONCUR_UPDATABLE, don't throw SQLExceptions when
checking updatability due to access permissions, instead return
CONCUR_READONLY from getConcurrency.
- Fixed BUG#35666 - NullPointerException when using "logSlowQueries=true" with
server-side prepared statements enabled.
- Fixed BUG#35660 - Calling equals() on connections created with "jdbc:mysql:loadbalance:"
URLs did not have the same behavior as "plain" connections. The behavior we use
is the implementation in java.lang.Object, load-balanced connections just happened
to be using a java.lang.reflect.Proxy which required some custom behavior in
equals() to make it work the same as "plain" connections.
Note that there is no *specified* equals contract for JDBC connections in the
JDBC specification itself, but the test makes sure that our implementation is
at least consistent.
- Fixed BUG#35810 - Properties set in URLs and then passed to DataSources via setUrl()
did not take effect in certain circumstances. This also fixes related bugs BUG#13261 and
BUG#35753.
- Fixed BUG#36051 - ResultSet.getTime() won't accept value of '24' for hours component of
a java.sql.Time.
- Fixed BUG#36830 - DBMD.getColumns() doesn't return correct COLUMN_SIZE for SET columns. The
logic wasn't accounting for the ","s in the column size.
- Fixed BUG#35610, BUG#35150- ResultSet.findColumn() and ResultSet.get...(String) doesn't allow
column names to be used, and isn't congruent with ResultSetMetadata.getColumnName().
By default, we follow the JDBC Specification here, in that the 4.0 behavior
is correct. Calling programs should use ResultSetMetaData.getColumnLabel() to dynamically determine
the correct "name" to pass to ResultSet.findColumn() or ResultSet.get...(String) whether or not the
query specifies an alias via "AS" for the column. ResultSetMetaData.getColumnName() will return the
actual name of the column, if it exists, and this name can *not* be used as input to ResultSet.findColumn()
or ResultSet.get...(String).
The JDBC-3.0 (and earlier) specification has a bug, but you can get the buggy behavior
(allowing column names *and* labels to be used for ResultSet.findColumn() and get...(String)) by setting
"useColumnNamesInFindColumn" to "true".
- Fixed BUG#35489 - Prepared statements from pooled connections cause NPE when closed() under JDBC-4.0.
- Added connection property "useLocalTransactionState" which configures if the driver use the in-transaction
state provided by the MySQL protocol to determine if a commit() or rollback() should actually be sent to the database.
(disabled by default).
- Use socket timeouts for JDBC-4.0's Connection.isValid(int timeout) instead of timer tasks, for scalability. As a side effect
internally, any communications with the database can use a timeout different than the configured timeout, but this isn't currently
used.
- The number and position of columns for "SHOW INNODB STATUS" changed in MySQL-5.1, which caused the
"includeInnodbStatusInDeadlockExceptions" feature to not show data about the deadlock.
- Implemented support of INFORMATION_SCHEMA for DatabaseMetadata.getTables() (views there are available as "SYSTEM TABLE"), and thus
also made INFORMATION_SCHEMA tables available via DatabaseMetadata.getColumns().
- Fixed BUG#39352, "INSERT ... ON DUPLICATE KEY UPDATE" doesn't return "0" for un-affected rows. This requires the driver to not
send the "CLIENT_FOUND_ROWS" flag to the server when it connects if the connection property "useAffectedRows" is set to "true",
which breaks JDBC-compliance, but currently there is no other way to get correct return values from the server.
- Fixed BUG#38747 - ResultSets in "streaming" mode throw an exception when closed when the connection is set as "read-only".
- Fixed BUG#37570 - Can't use non-latin1 passwords. Added connection property "passwordCharacterEncoding". Leaving this set to
the default value (null), uses the platform character set, which works for ISO8859_1 (i.e. "latin1") passwords. For passwords
in other character encodings, the encoding will have to be specified with this property, as it's not possible for the driver to
auto-detect this.
- Fixed BUG#39911 - We don't retrieve nanos correctly when -parsing- a string for a TIMESTAMP. MySQL itself doesn't support micros
or nanos in timestamp values, but if they're stored as strings, historically we try and parse the nanos portion as well.
Unfortunately we -interpreted- them as micros. This fix includes correcting that behavior, and setting the milliseconds portion of
such TIMESTAMPs to a correct value as well.
- Fixed BUG#39962 - ResultSet.findColumn() is slow for applications that call it too often (we're looking at -you- Hibernate). We're
using TreeMaps to get case-insensitive comparisons (required for JDBC compliance), but they can be slower than hash maps, so using the
approach Alex Burgel points out in this bug seems to help.
- Fixed BUG#39956 - Statement.getGeneratedKeys() doesn't respect the 'auto_increment_increment' value. We now grab the *session-scoped*
value, and use that. Beware that using "cacheServerConfig=true" will cause us to cache this value, so new connections won't see changes
that are applied via something like "init-sql".
- Fixed BUG#39611 - ReplicationConnection never sends queries to last host in slave list.
- Fixed BUG#34185 - Statement.getGeneratedKeys() does not raise exception when statement was not
created with Statement.RETURN_GENERATED_KEYS flags.
- Using autoGenerateTestcaseScript=true now logs all statements, regardless or not if they cause errors when processed by MySQL.
A "clock" value (millis since epoch) was added in the comment that is pre-pended with the idea that it can then be used
when post-processing output to sequence things correctly for a multi-threaded testcase, or to replay the test case with the
correct think times.
03-06-08 - Version 5.1.6
- JDBC-4.0-ized XAConnections and datasources.
- Fixed BUG#31790 MysqlValidConnectionChecker
doesn't properly handle ReplicationConnection
- Fixed Bug#20491 - DatabaseMetadata.getColumns() doesn't
return correct column names if connection character set
isn't UTF-8. (There was a server-side component of this that
was fixed late in the 5.0 development cycle, it seems, this
is the last piece that fixes some loose ends in the JDBC
driver). This fix touches *all* metadata information coming
from the MySQL server itself.
- Fixed MysqlIO.nextRowFast() to only attempt to read server
warning counts and status if talking to a 4.1 or newer server
(fixes a hang when reading data from 4.0 servers).
- Made profiler event handling extensible via the "profilerEventHandler"
connection property.
- Fixed Bug#31823 - CallableStatement.setNull() on a stored function would
throw an ArrayIndexOutOfBounds when setting the last parameter to null when calling setNull().
- Added SSL-related configuration property "verifyServerCertificate". If set to "false", the driver won't verify
the server's certificate when "useSSL" is set to "true".
When using this feature, the keystore parameters should be specified by the
"clientCertificateKeyStore*" properties, rather than system properties, as the JSSE doesn't
make it straightforward to have a non-verifying trust store and the "default" key store.
- Fixed ResultSetMetadata.getColumnName() for result sets returned from
Statement.getGeneratedKeys() - it was returning null instead of
"GENERATED_KEY" as in 5.0.x.
- More applicable fix for the "random" load balance strategy in the face
of node non-responsive, it re-tries a *different* random node, rather
than waiting for the node to recover (for BUG#31053)
- Fixed BUG#32577 - no way to store two timestamp/datetime values that happens
over the DST switchover, as the hours end up being the same when sent as
the literal that MySQL requires.
Note that to get this scenario to work with MySQL (since it doesn't support
per-value timezones), you need to configure your server (or session) to be in UTC,
and tell the driver not to use the legacy date/time code by setting
"useLegacyDatetimeCode" to "false". This will cause the driver to always convert
to/from the server and client timezone consistently.
This bug fix also fixes BUG#15604, by adding entirely new date/time handling
code that can be switched on by "useLegacyDatetimeCode" being set to "false" as
a JDBC configuration property. For Connector/J 5.1.x, the default is "true",
in trunk and beyond it will be "false" (i.e. the old date/time handling code, warts
and all will be deprecated).
- Fixed BUG#32877 - Load balancing connection using best response time would incorrectly
"stick" to hosts that were down when the connection was first created.
We solve this problem with a black list that is used during the picking of new hosts.
If the black list ends up including all configured hosts, the driver will retry for
a configurable number of times (the "retriesAllDown" configuration property, with a default
of 120 times), sleeping 250ms between attempts to pick a new connection.
We've also went ahead and made the balancing strategy extensible. To create a new strategy,
implement the interface com.mysql.jdbc.BalanceStrategy (which also includes our standard
"extension" interface), and tell the driver to use it by passing in the
class name via the "loadBalanceStrategy" configuration property.
- Fixed BUG#30508 - ResultSet returned by Statement.getGeneratedKeys() is not closed
automatically when statement that created it is closed.
- Added two new connection properties, "selfDestructOnPingSecondsLifetime" and
"selfDestructOnPingMaxOperations" designed to control overall connection lifetime
(useful to reclaim resources on the server side) for connection pools that don't have such a
facility.
The driver will consult the values of these properties when a ping is sent, either through
calling Connection.ping(), issuing the "ping marker" query (any query that starts with
"/* ping */"), or when using JDBC-4.0, calling Connection.isValid().
If the connection has issued too many operations, or is too old, the driver will
throw a SQLException with the SQLState of "08S01" at the time of the ping, which
will cause the connection to be invalidated with most pools in use today.
- Fixed issue where driver could send invalid server-side prepared statement
IDs to the server when the driver was setup to do auto-reconnect as the
connection could get set up enough to start sending queries on one thread,
while the thread that "noticed" the connection was down hasn't completed
re-preparing all of the server-side prepared statements that were open when
the connection died.
Potentially fixes cause for bug 28934. Potentially fixes other possible race
conditions where one thread that has created a connection "shares" it with other
threads if the connection is reconnected due to auto-reconnect functionality.
- Fixed BUG#33823 - Public interface ResultSetInternalMethods with reference to
non-public class com.mysql.jdbc.CachedResultSetMetaData.
- For any SQLException caused by another Throwable, besides dumping the message or stack
trace as a string into the message, set the underlying Throwable as the cause for
the SQLException, making it accessible via getCause().
- Fixed BUG#34093 - Statements with batched values do not return correct values for
getGeneratedKeys() when "rewriteBatchedStatements" is set to "true", and the
statement has an "ON DUPLICATE KEY UPDATE" clause.
- Fixed BUG#31192 - Encoding Issue retrieving serverVersion in MysqlIO in the
method doHandshake when encoding doesn't contain ASCII characters in the "standard"
place (i.e. ebcdic).
- Fixed issue where META-INF in the binary .jar file wasn't packed correctly,
leading to failure of the JDBC-4.0 SPI mechanism.
- CallableStatements that aren't really stored procedure or stored function calls can
now be used, for tools such as Oracle JDeveloper ADF that issue statements such as
DDL through CallableStatements.
- Fixed BUG#34518 - Statements using cursor fetch leaked internal prepared statements
until connection was closed. The internal prepared statement is now held open while
the result set is open, and closed by the result set itself being closed.
- Fixed BUG#34677 - Blob.truncate() wouldn't take "0" as an argument.
- CommunicationExceptions now carry information about the last time a packet
was received from the MySQL server, as well as when the last packet was sent
to one, in an effort to make it easier to debug communications errors caused
by network timeouts.
- Reverted a change to DatabaseMetadata.getColumns() from 5.0, where
getColumns() would report NULL for COLUMN_SIZE for TIME, DATE, DATETIME
and TIMESTAMP types. It now reports the column size, in the
DatabaseMetadata implementations that use "SHOW" commands, and the
INFORMATION_SCHEMA.
- Fixed Bug#34762 - RowDataStatic does't always set the metadata in
ResultSetRow, which can lead to failures when unpacking DATE,
TIME, DATETIME and TIMESTAMP types when using absolute, relative,
and previous result set navigation methods.
- Fixed BUG#34703 - Connection.isValid() invalidates connection after
timeout, even if connection is actually valid.
- Fixed BUG#34194 - ResultSetMetaData.getColumnTypeName() returns
"UNKNOWN" for GEOMETRY type.
- Fixed BUG#33162 - NullPointerException instead of SQLException
thrown for ResultSet.getTimestamp() when not positioned on a
row.
- The ConnectionLifecycleInterceptor interface now has callback methods for
transaction initiation (transactionBegun()), and completion
(transactionCompleted()), as reported by the *server* (i.e.
calling Connection.setAutoCommit(false) will not trigger
transactionBegun() being called, however the first statement
which causes a transaction to start on the server will cause
transactionBegun() to be called *after* the statement has been processed
on the server).
- Fixed Bug#34913 - ResultSet.getTimestamp() returns incorrect
values for month/day of TIMESTAMPs when using server-side
prepared statements (not enabled by default).
- Fixed BUG#34937 - MysqlConnectionPoolDataSource does not support
ReplicationConnection. Notice that we implemented com.mysql.jdbc.Connection
for ReplicationConnection, however, only accessors from ConnectionProperties
are implemented (not the mutators), and they return values from the currently
active connection. All other methods from com.mysql.jdbc.Connection are
implemented, and operate on the currently active connection, with the exception of
resetServerState() and changeUser().
- Connections created with jdbc:mysql:replication:// URLs now force
roundRobinLoadBalance=true on the slaves, and round-robin loadbalancing
now uses a "random" choice to more evenly distribute load across slave
servers, especially in connection pools. Connections that are configured
with "roundRobinLoadBalance=true" no longer set the failover state,
as it's assumed that we're not attempting to fall-back to a master
server. This fixes BUG#34963.
10-09-07 - Version 5.1.5
- Released instead of 5.1.4 to pickup patch for BUG#31053
from 5.0.8.
10-09-07 - Version 5.1.4
- Added "autoSlowLog" configuration property, overrides
"slowQueryThreshold*" properties, driver determines slow
queries by those that are slower than 5 * stddev of the mean
query time (outside the 96% percentile).
- Fixed BUG#28256 - When connection is in read-only mode,
queries that are wrapped in parentheses incorrectly identified
as DML.
09-07-07 - Version 5.1.3 RC
- Setting "useBlobToStoreUTF8OutsideBMP" to "true" tells the
driver to treat [MEDIUM/LONG/TINY]BLOB columns as [LONG]VARCHAR
columns holding text encoded in UTF-8 that has characters
outside the BMP (4-byte encodings), which MySQL server
can't handle natively.
Set "utf8OutsideBmpExcludedColumnNamePattern" to a regex so that
column names matching the given regex will still be treated
as BLOBs The regex must follow the patterns used for the
java.util.regex package. The default is to exclude no columns,
and include all columns.
Set "utf8OutsideBmpIncludedColumnNamePattern" to specify exclusion
rules to "utf8OutsideBmpExcludedColumnNamePattern". The regex must
follow the patterns used for the java.util.regex package.
- New methods on com.mysql.jdbc.Statement: setLocalInfileInputStream()
and getLocalInfileInputStream().
setLocalInfileInputStream() sets an InputStream instance that will be used to send data
to the MySQL server for a "LOAD DATA LOCAL INFILE" statement
rather than a FileInputStream or URLInputStream that represents
the path given as an argument to the statement.
This stream will be read to completion upon execution of a
"LOAD DATA LOCAL INFILE" statement, and will automatically
be closed by the driver, so it needs to be reset
before each call to execute*() that would cause the MySQL
server to request data to fulfill the request for
"LOAD DATA LOCAL INFILE".
If this value is set to NULL, the driver will revert to using
a FileInputStream or URLInputStream as required.
getLocalInfileInputStream() returns the InputStream instance that will be used to send
data in response to a "LOAD DATA LOCAL INFILE" statement.
This method returns NULL if no such stream has been set
via setLocalInfileInputStream().
- The driver now connects with an initial character set
of "utf-8" solely for the purposes of authentication to
allow usernames and database names in any character set to
be used in the JDBC URL.
- Errors encountered during Statement/PreparedStatement/CallableStatement.executeBatch()
when "rewriteBatchStatements" has been set to "true" now return
BatchUpdateExceptions according to the setting of "continueBatchOnError".
If "continueBatchOnError" is set to "true", the update counts for the
"chunk" that were sent as one unit will all be set to EXECUTE_FAILED, but
the driver will attempt to process the remainder of the batch. You can determine which
"chunk" failed by looking at the update counts returned in the BatchUpdateException.
If "continueBatchOnError" is set to "false", the update counts returned
will contain the failed "chunk", and stop with the failed chunk, with all
counts for the failed "chunk" set to EXECUTE_FAILED.
Since MySQL doesn't return multiple error codes for multiple-statements, or
for multi-value INSERT/REPLACE, it is the application's responsibility to handle
determining which item(s) in the "chunk" actually failed.
- Statement.setQueryTimeout()s now affect the entire batch for batched
statements, rather than the individual statements that make up the batch.
06-29-07 - Version 5.1.2 Beta
- Setting the configuration property "rewriteBatchedStatements"
to "true" will now cause the driver to rewrite batched prepared
statements with more than 3 parameter sets in a batch into
multi-statements (separated by ";") if they are not plain
(i.e. without SELECT or ON DUPLICATE KEY UPDATE clauses) INSERT
or REPLACE statements.
06-22-07 - Version 5.1.1 Alpha
- Pulled vendor-extension methods of Connection implementation out
into an interface to support java.sql.Wrapper functionality from
ConnectionPoolDataSource. The vendor extensions are javadoc'd in
the com.mysql.jdbc.Connection interface.
For those looking further into the driver implementation, it is not
an API that is used for plugability of implementations inside our driver
(which is why there are still references to ConnectionImpl throughout the
code).
Incompatible change: Connection.serverPrepare(String) has been re-named
to Connection.serverPrepareStatement() for consistency with
Connection.clientPrepareStatement().
We've also added server and client prepareStatement() methods that cover
all of the variants in the JDBC API.
- Similar to Connection, we pulled out vendor extensions to Statement
into an interface named "com.mysql.Statement", and moved the Statement
class into com.mysql.StatementImpl. The two methods (javadoc'd in
"com.mysql.Statement" are enableStreamingResults(), which already existed,