~maxb/connectorj/5.0

« back to all changes in this revision

Viewing changes to CHANGES

  • Committer: mmatthews
  • Date: 2007-10-11 20:04:05 UTC
  • Revision ID: svn-v3-trunk0:bce1ec22-edf6-0310-a851-a6aae2aa6c29:branches%2Fbranch_5_0:6637
Changed layout

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# Changelog
 
2
# $Id$
 
3
 
 
4
nn-nn-07 - Version 5.0.8
 
5
 
 
6
    - Fixed BUG#30550, executeBatch() would fail with an ArithmeticException
 
7
      and/or NullPointerException when the batch had zero members and
 
8
      "rewriteBatchedStatements" was set to "true" for the connection.
 
9
    
 
10
    - Added two configuration parameters (both default to "false")
 
11
    
 
12
            * blobsAreStrings  - Should the driver always treat BLOBs as Strings 
 
13
                                 specifically to work around dubious metadata returned 
 
14
                                 by the server for GROUP BY clauses?
 
15
            
 
16
            * functionsNeverReturnBlobs - Should the driver always treat data from 
 
17
                                          functions returning BLOBs as Strings - 
 
18
                                          specifically to work around dubious metadata 
 
19
                                          returned by the server for GROUP BY clauses?
 
20
 
 
21
    - Fixed BUG#29106 - Connection checker for JBoss didn't use same method parameters
 
22
      via reflection, causing connections to always seem "bad".
 
23
      
 
24
    - Fixed BUG#30664 - Note that this fix only works for MySQL server 
 
25
      versions 5.0.25 and newer, since earlier versions didn't consistently 
 
26
      return correct metadata for functions, and thus results from 
 
27
      subqueries and functions were indistinguishable from each other, 
 
28
      leading to type-related bugs.
 
29
 
 
30
    - Fixed BUG#28972 - DatabaseMetaData.getTypeInfo() for the types DECIMAL
 
31
      and NUMERIC will return a precision of 254 for server versions older than
 
32
      5.0.3, 64 for versions 5.0.3-5.0.5 and 65 for versions newer than 5.0.5.
 
33
    
 
34
    - Fixed BUG#29852 - Closing a load-balanced connection would cause a
 
35
      ClassCastException.
 
36
    
 
37
    - Fixed BUG#27867 - Schema objects with identifiers other than
 
38
      the connection character aren't retrieved correctly in 
 
39
      ResultSetMetadata.
 
40
      
 
41
    - Fixed BUG#28689 - CallableStatement.executeBatch() doesn't work when 
 
42
      connection property "noAccessToProcedureBodies" has been set to "true".
 
43
     
 
44
      The fix involves changing the behavior of "noAccessToProcedureBodies",in 
 
45
      that the driver will now report all paramters as "IN" paramters
 
46
      but allow callers to call registerOutParameter() on them without throwing
 
47
      an exception.
 
48
      
 
49
    - Fixed BUG#27182 - Connection.getServerCharacterEncoding() doesn't work
 
50
      for servers with version >= 4.1.
 
51
 
 
52
    - Fixed BUG#27915 - DatabaseMetaData.getColumns() doesn't
 
53
      contain SCOPE_* or IS_AUTOINCREMENT columns.
 
54
 
 
55
    - Fixed BUG#30851, NPE with null column values when
 
56
      "padCharsWithSpace" is set to "true".
 
57
    
 
58
    - Specifying a "validation query" in your connection pool 
 
59
      that starts with "/* ping */" _exactly_ will cause the driver to 
 
60
      instead send a ping to the server and return a fake result set (much 
 
61
      lighter weight), and when using a ReplicationConnection or a LoadBalancedConnection, 
 
62
      will send the ping across all active connections.
 
63
      
 
64
    - Fixed Bug#30892 setObject(int, Object, int, int) delegate in
 
65
      PreparedStatmentWrapper delegates to wrong method.
 
66
      
 
67
07-19-07 - Version 5.0.7
 
68
 
 
69
    - Setting the configuration parameter "useCursorFetch" to "true" for 
 
70
      MySQL-5.0+ enables the use of cursors that allow Connector/J to save 
 
71
      memory by fetching result set rows in chunks (where the chunk size 
 
72
      is set by calling setFetchSize() on a Statement or ResultSet) by 
 
73
      using fully-materialized cursors on the server. 
 
74
      
 
75
      The driver will will now automatically set "useServerPrepStmts" to 
 
76
      "true" when "useCursorFetch" has been set to "true", since the feature 
 
77
      requires server-side prepared statements in order to function.
 
78
 
 
79
        - Fixed BUG#28469 - PreparedStatement.getMetaData() for statements 
 
80
          containing leading one-line comments is not returned correctly.
 
81
         
 
82
          As part of this fix, we also overhauled detection of DML for 
 
83
          executeQuery() and SELECTs for executeUpdate() in plain and 
 
84
          prepared statements to be aware of the same  types of comments.
 
85
 
 
86
    - Added configuration property "useNanosForElapsedTime" - for 
 
87
      profiling/debugging functionality that measures elapsed time, 
 
88
      should the driver try to use nanoseconds resolution if available 
 
89
      (requires JDK >= 1.5)?
 
90
    
 
91
    - Added configuration property "slowQueryThresholdNanos" - if 
 
92
      "useNanosForElapsedTime" is set to "true", and this property 
 
93
      is set to a non-zero value the driver will use this threshold 
 
94
      (in nanosecond units) to determine if a query was slow, instead
 
95
      of using millisecond units.
 
96
      
 
97
      Note, that if "useNanosForElapsedTime" is set to "true", and this 
 
98
      property is set to "0" (or left default), then elapsed times will 
 
99
      still be measured in nanoseconds (if possible), but the slow query 
 
100
      threshold will be converted from milliseconds to nanoseconds, and thus
 
101
      have an upper bound of approximately 2000 millesconds (as that threshold
 
102
      is represented as an integer, not a long).
 
103
      
 
104
        - Added configuration properties to allow tuning of TCP/IP socket
 
105
          parameters:
 
106
          
 
107
                "tcpNoDelay" - Should the driver set SO_TCP_NODELAY (disabling the 
 
108
                               Nagle Algorithm, default "true")?
 
109
        
 
110
                "tcpKeepAlive" - Should the driver set SO_KEEPALIVE (default "true")?
 
111
        
 
112
                "tcpRcvBuf" - Should the driver set SO_RCV_BUF to the given value?
 
113
                              The default value of '0', means use the platform default 
 
114
                              value for this property.
 
115
                
 
116
                "tcpSndBuf" - Should the driver set SO_SND_BUF to the given value?
 
117
                              The default value of '0', means use the platform default 
 
118
                              value for this property.
 
119
        
 
120
                "tcpTrafficClass" - Should the driver set traffic class or 
 
121
                                    type-of-service fields? See the documentation 
 
122
                                    for java.net.Socket.setTrafficClass() for more 
 
123
                                    information.
 
124
                                    
 
125
        - Give more information in EOFExceptions thrown out of MysqlIO (how many
 
126
          bytes the driver expected to read, how many it actually read, say that
 
127
          communications with the server were unexpectedly lost).
 
128
          
 
129
        - Setting "useDynamicCharsetInfo" to "false" now causes driver to use
 
130
          static lookups for collations as well (makes 
 
131
          ResultSetMetadata.isCaseSensitive() much more efficient, which leads
 
132
          to performance increase for ColdFusion, which calls this method for
 
133
          every column on every table it sees, it appears).
 
134
          
 
135
        - Driver detects when it is running in a ColdFusion MX server (tested
 
136
          with version 7), and uses the configuration bundle "coldFusion",
 
137
          which sets useDynamicCharsetInfo to "false" (see previous entry), and 
 
138
          sets useLocalSessionState and autoReconnect to "true".
 
139
 
 
140
        - Fixed BUG#28851 - parser in client-side prepared statements
 
141
          eats character following '/' if it's not a multi-line comment.
 
142
          
 
143
        - Fixed BUG#28956 - parser in client-side prepared statements
 
144
          runs to end of statement, rather than end-of-line for '#' comments.
 
145
         
 
146
          Also added support for '--' single-line comments.
 
147
          
 
148
        - Don't send any file data in response to LOAD DATA LOCAL INFILE
 
149
          if the feature is disabled at the client side. This is to prevent
 
150
          a malicious server or man-in-the-middle from asking the client for
 
151
          data that the client is not expecting. Thanks to Jan Kneschke for
 
152
          discovering the exploit and Andrey "Poohie" Hristov, Konstantin Osipov
 
153
          and Sergei Golubchik for discussions about implications and possible
 
154
          fixes. This fixes BUG 29605 for JDBC.
 
155
         
 
156
        - Added new debugging functionality - Setting configuration property
 
157
          "includeInnodbStatusInDeadlockExceptions" to "true" will cause the driver
 
158
          to append the output of "SHOW ENGINE INNODB STATUS" to deadlock-related
 
159
          exceptions, which will enumerate the current locks held inside InnoDB.
 
160
                                    
 
161
05-15-07 - Version 5.0.6
 
162
 
 
163
        - Fixed BUG#25545 - Client options not sent correctly when using SSL,
 
164
          leading to stored procedures not being able to return results. Thanks
 
165
          to Don Cohen for the bug report, testcase and patch.
 
166
 
 
167
        - Fixed BUG#26592 - PreparedStatement is not closed in 
 
168
          BlobFromLocator.getBytes().
 
169
 
 
170
        - Fixed BUG#25624 - Whitespace surrounding storage/size specifiers in 
 
171
          stored procedure parameters declaration causes NumberFormatException to 
 
172
          be thrown when calling stored procedure on JDK-1.5 or newer, as the Number
 
173
          classes in JDK-1.5+ are whitespace intolerant.          
 
174
          
 
175
        - Fixed BUG#26173 - When useCursorFetch=true, sometimes server would return
 
176
          new, more exact metadata during the execution of the server-side prepared
 
177
          statement that enables this functionality, which the driver ignored (using
 
178
          the original metadata returned during prepare()), causing corrupt reading
 
179
          of data due to type mismatch when the actual rows were returned.
 
180
 
 
181
        - Fixed BUG#26959 - comments in DDL of stored procedures/functions confuse 
 
182
          procedure parser, and thus metadata about them can not be created, leading to
 
183
          inability to retrieve said metadata, or execute procedures that have certain
 
184
          comments in them.
 
185
          
 
186
        - Give better error message when "streaming" result sets, and the connection
 
187
          gets clobbered because of exceeding net_write_timeout on the server. (which is
 
188
          basically what the error message says too).
 
189
 
 
190
        - Fixed BUG#26789 - fast date/time parsing doesn't take into
 
191
          account 00:00:00 as a legal value.
 
192
         
 
193
        - Fixed BUG#27317 - ResultSet.get*() with a column index < 1 returns 
 
194
          misleading error message.
 
195
          
 
196
        - Fixed BUG#25517 - Statement.setMaxRows() is not effective on result 
 
197
          sets materialized from cursors.
 
198
          
 
199
        - New configuration property, "enableQueryTimeouts" (default "true"). 
 
200
          When enabled, query timeouts set via Statement.setQueryTimeout() use a 
 
201
          shared java.util.Timer instance for scheduling. Even if the timeout 
 
202
          doesn't expire before the query is processed, there will be 
 
203
          memory used by the TimerTask for the given timeout which won't be 
 
204
          reclaimed until the time the timeout would have expired if it 
 
205
          hadn't been cancelled by the driver. High-load environments 
 
206
          might want to consider disabling this functionality. (this configuration 
 
207
          property is part of the "maxPerformance" configuration bundle).
 
208
        
 
209
        - Fixed BUG#27400 - CALL /* ... */ some_proc() doesn't work. As a side effect
 
210
          of this fix, you can now use /* */ and # comments when preparing statements using
 
211
          client-side prepared statement emulation.
 
212
          
 
213
          If the comments happen to contain parameter markers '?', they will be treated
 
214
          as belonging to the comment (i.e. not recognized) rather than being a parameter
 
215
          of the statement.
 
216
          
 
217
          Note that the statement when sent to the server will contain the comments
 
218
          as-is, they're not stripped during the process of preparing the PreparedStatement
 
219
          or CallableStatement.
 
220
          
 
221
        - Fixed BUG#25328 - BIT(> 1) is returned as java.lang.String from ResultSet.getObject()
 
222
          rather than byte[].
 
223
          
 
224
        - Fixed BUG#25715 - CallableStatements with OUT/INOUT parameters that
 
225
          are "binary" (blobs, bits, (var)binary, java_object) have extra 7 bytes 
 
226
          (which happens to be the _binary introducer!)
 
227
        
 
228
        - Added configuration property "padCharsWithSpace" (defaults to "false"). If set
 
229
          to "true", and a result set column has the CHAR type and the value does not 
 
230
          fill the amount of characters specified in the DDL for the column, the driver 
 
231
          will pad the remaining characters with space (for ANSI compliance).
 
232
          
 
233
        - Fixed BUG#27655 - Connection.getTransactionIsolation() uses
 
234
          "SHOW VARIABLES LIKE" which is very inefficient on MySQL-5.0+
 
235
          
 
236
        - Added configuration property "useDynamicCharsetInfo". If set to "false"
 
237
          (the default), the driver will use a per-connection cache of character set 
 
238
          information queried from the server when necessary, or when set to "true",
 
239
          use a built-in static mapping that is more efficient, but isn't aware of 
 
240
          custom character sets or character sets implemented after the release of 
 
241
          the JDBC driver.
 
242
          
 
243
          Note: this only affects the "padCharsWithSpace" configuration property and the 
 
244
            ResultSetMetaData.getColumnDisplayWidth() method.
 
245
         
 
246
        - More intelligent initial packet sizes for the "shared" packets are used 
 
247
          (512 bytes, rather than 16K), and initial packets used during handshake are
 
248
          now sized appropriately as to not require reallocation.
 
249
        
 
250
        - Fixed issue where calling getGeneratedKeys() on a prepared statement after 
 
251
          calling execute() didn't always return the generated keys (executeUpdate() 
 
252
          worked fine however).
 
253
        
 
254
        - Fixed issue where a failed-over connection would let an application call 
 
255
          setReadOnly(false), when that call should be ignored until the connection 
 
256
          is reconnected to a writable master unless "failoverReadOnly" had been set
 
257
          to "false".
 
258
            
 
259
        - Fixed BUG#28085 - Generate more useful error messages for diagnostics
 
260
          when the driver thinks a result set isn't updatable. (Thanks to Ashley Martens
 
261
          for the patch).
 
262
          
 
263
        - Driver will now use INSERT INTO ... VALUES (DEFAULT) form of statement
 
264
          for updatable result sets for ResultSet.insertRow(), rather than 
 
265
          pre-populating the insert row with values from DatabaseMetaData.getColumns()
 
266
          (which results in a "SHOW FULL COLUMNS" on the server for every result
 
267
          set). If an application requires access to the default values before
 
268
          insertRow() has been called, the JDBC URL should be configured with 
 
269
          "populateInsertRowWithDefaultValues" set to "true".
 
270
          
 
271
          This fix specifically targets performance issues with ColdFusion and the 
 
272
          fact that it seems to ask for updatable result sets no matter what the 
 
273
          application does with them.
 
274
          
 
275
        - com.mysql.jdbc.[NonRegistering]Driver now understands URLs of the format
 
276
          "jdbc:mysql:replication://" and "jdbc:mysql:loadbalance://" which will
 
277
          create a ReplicationConnection (exactly like when 
 
278
          using [NonRegistering]ReplicationDriver) and an experimenal load-balanced
 
279
          connection designed for use with SQL nodes in a MySQL Cluster/NDB environment, 
 
280
          respectively.
 
281
          
 
282
          In an effort to simplify things, we're working on deprecating multiple 
 
283
          drivers, and instead specifying different core behavior based upon JDBC URL 
 
284
          prefixes, so watch for [NonRegistering]ReplicationDriver to eventually 
 
285
          disappear, to be replaced with com.mysql.jdbc[NonRegistering]Driver with 
 
286
          the new URL prefix.
 
287
          
 
288
        - Added an experimental load-balanced connection designed for use with SQL nodes
 
289
      in a MySQL Cluster/NDB environment (This is not for master-slave replication.
 
290
      For that, we suggest you look at ReplicationConnection or "lbpool").
 
291
          
 
292
          If the JDBC URL starts with "jdbc:mysql:loadbalance://host-1,host-2,...host-n", 
 
293
          the driver will create an implementation of java.sql.Connection that load 
 
294
          balances requests across a series of MySQL JDBC connections to the given hosts, 
 
295
          where the balancing takes place after transaction commit.
 
296
 
 
297
      Therefore, for this to work (at all), you must use transactions, even if only
 
298
      reading data.
 
299
 
 
300
      Physical connections to the given hosts will not be created until needed.
 
301
      
 
302
      The driver will invalidate connections that it detects have had
 
303
      communication errors when processing a request. A new connection to the
 
304
      problematic host will be attempted the next time it is selected by the load
 
305
      balancing algorithm.
 
306
      
 
307
      There are two choices for load balancing algorithms, which may be specified
 
308
      by the "loadBalanceStrategy" JDBC URL configuration property:
 
309
      
 
310
      * "random" - the driver will pick a random host for each request. This tends
 
311
        to work better than round-robin, as the randomness will somewhat account for
 
312
        spreading loads where requests vary in response time, while round-robin
 
313
        can sometimes lead to overloaded nodes if there are variations in response times
 
314
        across the workload.
 
315
        
 
316
      * "bestResponseTime" - the driver will route the request to the host that had
 
317
        the best response time for the previous transaction.
 
318
        
 
319
    - When "useLocalSessionState" is set to "true" and connected to a MySQL-5.0 or 
 
320
      later server, the JDBC driver will now determine whether an actual "commit" or 
 
321
      "rollback" statement needs to be sent to the database when Connection.commit() 
 
322
      or Connection.rollback() is called.
 
323
      
 
324
      This is especially helpful for high-load situations with connection pools that
 
325
      always call Connection.rollback() on connection check-in/check-out because it
 
326
      avoids a round-trip to the server.
 
327
      
 
328
03-01-07 - Version 5.0.5
 
329
 
 
330
    - Fixed BUG#23645 - Some collations/character sets reported as "unknown"
 
331
          (specifically cias variants of existing character sets), and inability to override
 
332
          the detected server character set.
 
333
 
 
334
    - Performance enhancement of initial character set configuration, driver
 
335
      will only send commands required to configure connection character set
 
336
      session variables if the current values on the server do not match
 
337
      what is required.
 
338
      
 
339
    - Usage advisor now detects "empty" result sets and doesn't report on 
 
340
      columns not referenced in them.
 
341
      
 
342
    - Fixed BUG#24360 .setFetchSize() breaks prepared SHOW and other commands.
 
343
   
 
344
    - Fixed BUG#24344 - useJDBCCompliantTimezoneShift with server-side prepared
 
345
          statements gives different behavior than when using client-side prepared
 
346
          statements. (this is now fixed if moving from server-side prepared statements
 
347
          to client-side prepared statements by setting "useSSPSCompatibleTimezoneShift" to
 
348
          true", as the driver can't tell if this is a new deployment that never used 
 
349
          server-side prepared statements, or if it is an existing deployment that is
 
350
          switching to client-side prepared statements from server-side prepared statements.
 
351
    
 
352
    - Fixed BUG#23304 - DBMD using "show" and DBMD using information_schema do 
 
353
      not return results consistent with each other. (note this fix only 
 
354
      addresses the inconsistencies, not the issue that the driver is 
 
355
      treating schemas differently than some users expect. We will revisit 
 
356
      this behavior when there is full support for schemas in MySQL).  
 
357
            
 
358
        - Fixed BUG#25073 - rewriting batched statements leaks internal statement
 
359
          instances, and causes a memory leak.    
 
360
          
 
361
        - Fixed issue where field-level for metadata from DatabaseMetaData when using 
 
362
          INFORMATION_SCHEMA didn't have references to current connections,
 
363
          sometimes leading to NullPointerExceptions when intropsecting them via
 
364
          ResultSetMetaData.       
 
365
 
 
366
        - Fixed BUG#25025 - Client-side prepared statement parser gets confused by
 
367
          in-line (/* ... */) comments and therefore can't rewrite batched statements 
 
368
          or reliably detect type of statements when they're used.
 
369
          
 
370
        - Fixed BUG#24065 - Better error message when server doesn't return enough
 
371
          information to determine stored procedure/function parameter types.
 
372
          
 
373
        - Fixed BUG#21438 - Driver sending nanoseconds to server for timestamps when
 
374
          using server-side prepared statements, when server expects microseconds.
 
375
 
 
376
        - Fixed BUG#25514 - Timer instance used for Statement.setQueryTimeout()
 
377
          created per-connection, rather than per-VM, causing memory leak.
 
378
        
 
379
        - Fixed BUG#25009 - Results from updates not handled correctly in 
 
380
          multi-statement queries, leading to erroneous "Result is from UPDATE" 
 
381
          exceptions.
 
382
 
 
383
        - Fixed BUG#25047 - StringUtils.indexOfIgnoreCaseRespectQuotes() isn't
 
384
          case-insensitive on the first character of the target. This bug broke
 
385
          rewriteBatchedStatements functionality when prepared statements don't
 
386
          use upper-case for the VALUES clause in their statements.
 
387
 
 
388
        - Fixed BUG#21480 - Some exceptions thrown out of StandardSocketFactory
 
389
          were needlessly wrapped, obscurring their true cause, especially when
 
390
          using socket timeouts.
 
391
 
 
392
        - Fixed BUG#23303 - DatabaseMetaData.getSchemas() doesn't return a 
 
393
          TABLE_CATALOG column.
 
394
 
 
395
    - Fixed BUG#25399 - EscapeProcessor gets confused by multiple 
 
396
      backslashes. We now push the responsibility of syntax errors back
 
397
      on to the server for most escape sequences.
 
398
  
 
399
        - Fixed BUG#25379 - INOUT parameters in CallableStatements get 
 
400
          doubly-escaped.
 
401
          
 
402
        - Removed non-short-circuited logical ORs from "if" statements.
 
403
        
 
404
        - Re-worked stored procedure parameter parser to be more robust. Driver no
 
405
          longer requires "BEGIN" in stored procedure definition, but does have 
 
406
          requirement that if a stored function begins with a label directly after the 
 
407
          "returns" clause, that the label is not a quoted identifier.
 
408
 
 
409
    - Reverted back to internal character conversion routines for single-byte 
 
410
      character sets, as the ones internal to the JVM are using much more CPU 
 
411
      time than our internal implementation.
 
412
      
 
413
        - Changed cached result set metadata (when using 
 
414
          "cacheResultSetMetadata=true") to be cached per-connection rather
 
415
          than per-statement as previously implemented.
 
416
          
 
417
        - Use a java.util.TreeMap to map column names to ordinal indexes for
 
418
          ResultSet.findColumn() instead of a HashMap. This allows us to have
 
419
          case-insensitive lookups (required by the JDBC specification) without
 
420
          resorting to the many transient object instances needed to support this
 
421
          requirement with a normal HashMap with either case-adjusted keys, or
 
422
          case-insensitive keys. (In the worst case scenario for lookups of a 1000
 
423
          column result set, TreeMaps are about half as fast wall-clock time as
 
424
          a HashMap, however in normal applications their use gives many orders
 
425
          of magnitude reduction in transient object instance creation which pays
 
426
          off later for CPU usage in garbage collection).
 
427
          
 
428
        - Avoid static synchronized code in JVM class libraries for dealing with
 
429
          default timezones.
 
430
          
 
431
        - Fixed cases where ServerPreparedStatements weren't using cached metadata
 
432
          when "cacheResultSetMetadata=true" was configured.
 
433
          
 
434
        - Use faster datetime parsing for ResultSets that come from plain or 
 
435
          non-server-side prepared statements. (Enable old implementation with
 
436
          "useFastDateParsing=false" as a configuration parameter).
 
437
          
 
438
        - Fixed BUG#24794 - DatabaseMetaData.getSQLKeywords() doesn't return
 
439
          all reserved words for current MySQL version. The current fix/implementation
 
440
          returns keywords for MySQL-5.1, and doesn't distinguish between different
 
441
          versions of the server.
 
442
          
 
443
        - When using cached metadata, skip field-level metadata packets coming from
 
444
          the server, rather than reading them and discarding them without creating
 
445
          com.mysql.jdbc.Field instances.
 
446
         
 
447
        - Fixed BUG#25836 - Statement execution which timed out doesn't always 
 
448
          throw MySQLTimeoutException.
 
449
          
 
450
        - Throw exceptions encountered during timeout to thread 
 
451
          calling Statement.execute*(), rather than RuntimeException.
 
452
 
 
453
        - Added configuration property "localSocketAddress",which is the hostname or 
 
454
          IP address given to explicitly configure the interface that the driver will 
 
455
          bind the client side of the TCP/IP connection to when connecting.
 
456
          
 
457
        - Take "localSocketAddress" property into account when creating instances
 
458
          of CommunicationsException when the underyling exception is a 
 
459
          java.net.BindException, so that a friendlier error message is given with
 
460
          a little internal diagnostics.
 
461
          
 
462
        - Fixed some NPEs when cached metadata was used with UpdatableResultSets.
 
463
        
 
464
        - The "rewriteBatchedStatements" feature can now be used with server-side
 
465
          prepared statements.
 
466
          
 
467
        - Fixed BUG#26326 - Connection property "socketFactory" wasn't exposed via
 
468
          correctly named mutator/accessor, causing data source implementations that
 
469
          use JavaBean naming conventions to set properties to fail to set the property
 
470
          (and in the case of SJAS, fail silently when trying to set this parameter).
 
471
        
 
472
        - Fixed BUG#25787 - java.util.Date should be serialized for 
 
473
          PreparedStatement.setObject(). 
 
474
          
 
475
          We've added a new configuration option "treatUtilDateAsTimestamp", which is 
 
476
          false by default, as (1) We already had specific behavior to treat 
 
477
          java.util.Date as a java.sql.Timestamp because it's useful to many folks, 
 
478
          and (2) that behavior will very likely be required for drivers JDBC-post-4.0.
 
479
          
 
480
    - Fixed BUG#22628 - Driver.getPropertyInfo() throws NullPointerException for 
 
481
      URL that only specifies host and/or port.
 
482
 
 
483
        - Fixed BUG#21267, ParameterMetaData throws NullPointerException when 
 
484
          prepared SQL actually has a syntax error. Added 
 
485
          "generateSimpleParameterMetadata" configuration property, which when set
 
486
          to "true" will generate metadata reflecting VARCHAR for every parameter
 
487
          (the default is "false", which will cause an exception to be thrown if no
 
488
          parameter metadata for the statement is actually available).
 
489
 
 
490
        - When extracting foreign key information from "SHOW CREATE TABLE " in 
 
491
          DatabaseMetaData, ignore exceptions relating to tables being missing
 
492
          (which could happen for cross-reference or imported-key requests, as 
 
493
          the list of tables is generated first, then iterated).
 
494
          
 
495
        - Fixed logging of XA commands sent to server, it's now configurable
 
496
          via "logXaCommands" property (defaults to "false").
 
497
          
 
498
        - Fixed issue where XADataSources couldn't be bound into JNDI,
 
499
          as the DataSourceFactory didn't know how to create instances
 
500
          of them.
 
501
 
 
502
        - Usage advisor will now issue warnings for result sets with large numbers
 
503
          of rows (size configured by "resultSetSizeThreshold" property, default
 
504
          value is 100).
 
505
                          
 
506
10-20-06 - Version 5.0.4
 
507
 
 
508
    - Fixed BUG#21379 - column names don't match metadata in cases 
 
509
      where server doesn't return original column names (column functions)
 
510
          thus breaking compatibility with applications that expect 1-1 mappings
 
511
          between findColumn() and rsmd.getColumnName(), usually manifests itself
 
512
          as "Can't find column ('')" exceptions.
 
513
         
 
514
    - Fixed BUG#21544 - When using information_schema for metadata, 
 
515
          COLUMN_SIZE for getColumns() is not clamped to range of 
 
516
          java.lang.Integer as is the case when not using 
 
517
          information_schema, thus leading to a truncation exception that 
 
518
          isn't present when not using information_schema.
 
519
         
 
520
    - Fixed configuration property "jdbcCompliantTruncation" was not
 
521
      being used for reads of result set values.
 
522
      
 
523
    - Fixed BUG#22024 - Newlines causing whitespace to span confuse
 
524
          procedure parser when getting parameter metadata for stored 
 
525
          procedures.
 
526
          
 
527
        - Driver now supports {call sp} (without "()" if procedure has no
 
528
          arguments).
 
529
          
 
530
        - Fixed BUG#22359 - Driver was using milliseconds for
 
531
          Statement.setQueryTimeout() when specification says argument is
 
532
          to be in seconds.
 
533
          
 
534
        - Workaround for server crash when calling stored procedures
 
535
          via a server-side prepared statement (driver now detects 
 
536
          prepare(stored procedure) and substitutes client-side prepared 
 
537
          statement), addresses BUG#22297.
 
538
          
 
539
        - Added new _ci collations to CharsetMapping, fixing 
 
540
          Bug#22456 - utf8_unicode_ci not working.
 
541
          
 
542
        - Fixed BUG#22290 - Driver issues truncation on write exception when
 
543
          it shouldn't (due to sending big decimal incorrectly to server with
 
544
          server-side prepared statement).
 
545
          
 
546
        - Fixed BUG#22613 - DBMD.getColumns() does not return expected
 
547
          COLUMN_SIZE for the SET type, now returns length of largest possible
 
548
          set disregarding whitespace or the "," delimitters to be consistent 
 
549
          with the ODBC driver.
 
550
          
 
551
        - Driver now sends numeric 1 or 0 for client-prepared statement
 
552
          setBoolean() calls instead of '1' or '0'.
 
553
          
 
554
        - DatabaseMetaData correctly reports true for supportsCatalog*()
 
555
          methods.
 
556
                  
 
557
07-26-06 - Version 5.0.3
 
558
 
 
559
    - Fixed BUG#20650 - Statement.cancel() causes NullPointerException
 
560
      if underlying connection has been closed due to server failure.
 
561
    
 
562
    - Added configuration option "noAccessToProcedureBodies" which will
 
563
      cause the driver to create basic parameter metadata for
 
564
      CallableStatements when the user does not have access to procedure
 
565
      bodies via "SHOW CREATE PROCEDURE" or selecting from mysql.proc
 
566
      instead of throwing an exception. The default value for this option
 
567
      is "false".
 
568
      
 
569
07-11-06 - Version 5.0.2-beta (5.0.1 not released due to packaging error)
 
570
 
 
571
    - Fixed BUG#17401 - Can't use XAConnection for local transactions when
 
572
      no global transaction is in progress.
 
573
      
 
574
    - Fixed BUG#18086 - Driver fails on non-ASCII platforms. The driver
 
575
      was assuming that the platform character set would be a superset 
 
576
      of MySQL's "latin1" when doing the handshake for authentication,
 
577
      and when reading error messages. We now use Cp1252 for all strings
 
578
      sent to the server during the handshake phase, and a hard-coded mapping
 
579
      of the "language" server variable to the character set that 
 
580
      is used for error messages.
 
581
      
 
582
    - Fixed BUG#19169 - ConnectionProperties (and thus some
 
583
          subclasses) are not serializable, even though some J2EE containers
 
584
          expect them to be.
 
585
          
 
586
        - Fixed BUG#20242 - MysqlValidConnectionChecker for JBoss doesn't
 
587
          work with MySQLXADataSources.
 
588
          
 
589
        - Better caching of character set converters (per-connection)
 
590
          to remove a bottleneck for multibyte character sets.
 
591
          
 
592
        - Added connection/datasource property  "pinGlobalTxToPhysicalConnection" 
 
593
          (defaults to "false"). When set to "true", when using XAConnections, the 
 
594
          driver ensures that operations on a given XID are always routed to the 
 
595
          same physical connection. This allows the XAConnection to support 
 
596
          "XA START ... JOIN" after "XA END" has been called, and is also a 
 
597
          workaround for transaction managers that don't maintain thread affinity
 
598
          for a global transaction (most either always maintain thread affinity, 
 
599
          or have it as a configuration option).
 
600
          
 
601
        - MysqlXaConnection.recover(int flags) now allows combinations of 
 
602
          XAResource.TMSTARTRSCAN and TMENDRSCAN. To simulate the "scanning"
 
603
          nature of the interface, we return all prepared XIDs for TMSTARTRSCAN,
 
604
          and no new XIDs for calls with TMNOFLAGS, or TMENDRSCAN when not in
 
605
          combination with TMSTARTRSCAN. This change was made for API compliance,
 
606
          as well as integration with IBM WebSphere's transaction manager.
 
607
          
 
608
12-23-05 - Version 5.0.0-beta
 
609
 
 
610
    - XADataSource implemented (ported from 3.2 branch which won't be 
 
611
      released as a product). Use 
 
612
      "com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" as your datasource
 
613
      class name in your application server to utilize XA transactions
 
614
      in MySQL-5.0.10 and newer.
 
615
      
 
616
    - PreparedStatement.setString() didn't work correctly when
 
617
      sql_mode on server contained NO_BACKSLASH_ESCAPES, and no characters
 
618
      that needed escaping were present in the string.
 
619
      
 
620
    - Attempt detection of the MySQL type "BINARY" (it's an alias, so this isn't
 
621
      always reliable), and use the java.sql.Types.BINARY type mapping for it.
 
622
      
 
623
    - Moved -bin-g.jar file into separate "debug" subdirectory to avoid confusion.
 
624
      
 
625
    - Don't allow .setAutoCommit(true), or .commit() or .rollback() on an XA-managed
 
626
      connection as-per the JDBC specification.
 
627
      
 
628
    - If the connection "useTimezone" is set to "true", then also respect timezone
 
629
      conversions in escape-processed string literals (e.g. "{ts ...}" and 
 
630
      "{t ...}").
 
631
      
 
632
    - Return original column name for RSMD.getColumnName() if the column was aliased,
 
633
      alias name for .getColumnLabel() (if aliased), and original table name
 
634
      for .getTableName(). Note this only works for MySQL-4.1 and newer, as
 
635
      older servers don't make this information available to clients.
 
636
      
 
637
    - Setting "useJDBCCompliantTimezoneShift=true" (it's not the default)
 
638
      causes the driver to use GMT for _all_ TIMESTAMP/DATETIME timezones,
 
639
      and the current VM timezone for any other type that refers to timezones.
 
640
      This feature can not be used when "useTimezone=true" to convert between
 
641
      server and client timezones.
 
642
      
 
643
    - Add one level of indirection of internal representation of CallableStatement
 
644
      parameter metadata to avoid class not found issues on JDK-1.3 for
 
645
      ParameterMetadata interface (which doesn't exist prior to JDBC-3.0).
 
646
      
 
647
    - Added unit tests for XADatasource, as well as friendlier exceptions
 
648
      for XA failures compared to the "stock" XAException (which has no
 
649
      messages).
 
650
      
 
651
    - Fixed BUG#14279 - Idle timeouts cause XAConnections to whine about rolling 
 
652
      themselves back
 
653
      
 
654
    - Added support for Connector/MXJ integration via url subprotocol
 
655
      "jdbc:mysql:mxj://....".
 
656
      
 
657
    - Moved all SQLException constructor usage to a factory in SQLError
 
658
      (ground-work for JDBC-4.0 SQLState-based exception classes).
 
659
      
 
660
    - Removed Java5-specific calls to BigDecimal constructor (when
 
661
      result set value is '', (int)0 was being used as an argument
 
662
      in-directly via method return value. This signature doesn't exist
 
663
      prior to Java5.)
 
664
      
 
665
    - Moved all SQLException creation to a factory method in SQLError,
 
666
      groundwork for JDBC-4.0 SQLState class-based exceptions.
 
667
      
 
668
    - Added service-provider entry to META-INF/services/java.sql.Driver
 
669
      for JDBC-4.0 support.
 
670
      
 
671
    - Return "[VAR]BINARY" for RSMD.getColumnTypeName() when that is actually
 
672
      the type, and it can be distinguished (MySQL-4.1 and newer).
 
673
      
 
674
    - When fix for BUG#14562 was merged from 3.1.12, added functionality 
 
675
      for CallableStatement's parameter metadata to return correct
 
676
      information for .getParameterClassName().
 
677
      
 
678
    - Fuller synchronization of Connection to avoid deadlocks when
 
679
      using multithreaded frameworks that multithread a single connection
 
680
      (usually not recommended, but the JDBC spec allows it anyways), 
 
681
      part of fix to BUG#14972).
 
682
      
 
683
    - Implementation of Statement.cancel() and Statement.setQueryTimeout().
 
684
      Both require MySQL-5.0.0 or newer server, require a separate connection
 
685
      to issue the "KILL QUERY" command, and in the case of setQueryTimeout()
 
686
      creates an additional thread to handle the timeout functionality.
 
687
      
 
688
      Note: Failures to cancel the statement for setQueryTimeout() may manifest
 
689
      themselves as RuntimeExceptions rather than failing silently, as there
 
690
      is currently no way to unblock the thread that is executing the query being
 
691
      cancelled due to timeout expiration and have it throw the exception
 
692
      instead.
 
693
      
 
694
    - Removed dead code in com.mysql.jdbc.Connection. 
 
695
    
 
696
    - Made construction of com.mysql.jdbc.Field (result set metadata)
 
697
      instances more efficient for non-string types by not doing
 
698
      character set initialization, or detection of type changes due to
 
699
      temporary tables.
 
700
      
 
701
    - Removed redundant code in com.mysql.jdbc.MysqlIO.
 
702
    
 
703
    - Removed work done for BUG#14652, and instead loosened synchronization
 
704
      to solve a number of deadlock issues in BUG#18719, BUG#18367, BUG#17709
 
705
      and BUG#15067. New strategy basically makes Connection instances threadsafe
 
706
      and thus shareable across threads, and anything else threadsafe, but not 
 
707
      necessarily shareable across threads due to JDBC API interactions that 
 
708
      can cause non-obvious behavior and/or deadlock scenarios to occur since
 
709
      the API is not designed to be used from multiple threads at once. 
 
710
      
 
711
      Therefore, unless external synchronization is provided, clients should
 
712
      not allow multiple threads to share a given statement or result set. Examples
 
713
      of issues with the API itself not being multi-thread suitable include, 
 
714
      but are not limited to race conditions between modifiers and execution and 
 
715
      retrieval methods on statements and result sets that are not synchronizable 
 
716
      such as ResultSet.get*() and traversal methods, or Statement.execute*() closing 
 
717
      result sets without effectively making the driver itself serializable across the 
 
718
      board.
 
719
      
 
720
      These changes should not have any effect on "normal" J(2)EE use cases
 
721
      where only one thread ever uses a connection instance and the objects created by
 
722
      it.
 
723
      
 
724
    - Use a java.util.Timer to schedule cancellation of queries via
 
725
      Statement.setQueryTimeout() rather than one thread per potential cancellation.
 
726
      
 
727
      A new thread will be used to actually cancel a running query, as there's potential
 
728
      for a cancel request to block other cancel requests if all run from the
 
729
      same thread.
 
730
      
 
731
nn-nn-07 - Version 3.1.15
 
732
 
 
733
        - Fixed BUG#23281 - Downed slave caused round-robin load balance to
 
734
          not cycle back to first host in list.
 
735
          
 
736
        - Disabled use of server-side prepared statements by default.
 
737
        
 
738
        - Handle YYYY-MM-DD hh:mm:ss format of timestamp in 
 
739
          ResultSet.getTimeFromString().
 
740
 
 
741
        - Fixed BUG#24840 - character encoding of "US-ASCII" doesn't map correctly 
 
742
          for 4.1 or newer
 
743
          
 
744
        - Added Implementation-Vendor-Id attribute to jar manifest per request
 
745
          in BUG#15641.
 
746
          
 
747
        - C3P0 >= version 0.9.1 passes non-proxied connections to 
 
748
          MysqlConnectionTester,  thus it began throwing ClassCastExceptions.  
 
749
          MysqlConnectionTester now checks if it has a plain Connection and uses
 
750
          that if possible. Thanks to Brian Skrab for the fix.
 
751
                          
 
752
10-19-06 - Version 3.1.14
 
753
 
 
754
    - Fixed BUG#20479 - Updatable result set throws ClassCastException
 
755
          when there is row data and moveToInsertRow() is called.
 
756
          
 
757
        - Fixed BUG#20485 - Updatable result set that contains
 
758
          a BIT column fails when server-side prepared statements are used.
 
759
          
 
760
        - Fixed BUG#16987 - Memory leak with profileSQL=true.
 
761
        
 
762
        - Fixed BUG#19726 - Connection fails to localhost when using 
 
763
          timeout and IPv6 is configured.
 
764
          
 
765
        - Fixed BUG#16791 - NullPointerException in MysqlDataSourceFactory
 
766
          due to Reference containing RefAddrs with null content.
 
767
          
 
768
        - Fixed BUG#20306 - ResultSet.getShort() for UNSIGNED TINYINT
 
769
          returns incorrect values when using server-side prepared statements.
 
770
          
 
771
        - Fixed BUG#20687 - Can't pool server-side prepared statements, exception
 
772
          raised when re-using them.
 
773
          
 
774
        - Fixed BUG#21062 - ResultSet.getSomeInteger() doesn't work for BIT(>1).
 
775
        
 
776
        - Fixed BUG#18880 - ResultSet.getFloatFromString() can't retrieve
 
777
          values near Float.MIN/MAX_VALUE.
 
778
          
 
779
        - Fixed BUG#20888 - escape of quotes in client-side prepared 
 
780
          statements parsing not respected. Patch covers more than bug report, 
 
781
          including NO_BACKSLASH_ESCAPES being set, and stacked quote characters
 
782
          forms of escaping (i.e. '' or "").
 
783
          
 
784
        - Fixed BUG#19993 - ReplicationDriver does not always round-robin load
 
785
          balance depending on URL used for slaves list.
 
786
        
 
787
        - Fixed calling toString() on ResultSetMetaData for driver-generated
 
788
          (i.e. from DatabaseMetaData method calls, or from getGeneratedKeys())
 
789
          result sets would raise a NullPointerException.
 
790
          
 
791
        - Fixed Bug#21207 - Driver throws NPE when tracing prepared statements that
 
792
          have been closed (in asSQL()).
 
793
          
 
794
        - Removed logger autodectection altogether, must now specify logger 
 
795
          explitly if you want to use a logger other than one that logs
 
796
          to STDERR.
 
797
          
 
798
        - Fixed BUG#22290 - Driver issues truncation on write exception when
 
799
          it shouldn't (due to sending big decimal incorrectly to server with
 
800
          server-side prepared statement).
 
801
          
 
802
        - Driver now sends numeric 1 or 0 for client-prepared statement
 
803
          setBoolean() calls instead of '1' or '0'.
 
804
          
 
805
        - Fixed bug where driver would not advance to next host if 
 
806
          roundRobinLoadBalance=true and the last host in the list is down.
 
807
 
 
808
        - Fixed BUG#18258 - DatabaseMetaData.getTables(), columns() with bad
 
809
          catalog parameter threw exception rather than return empty result
 
810
          set (as required by spec).
 
811
        
 
812
        - Check and store value for continueBatchOnError property in constructor
 
813
      of Statements, rather than when executing batches, so that Connections
 
814
      closed out from underneath statements don't cause NullPointerExceptions
 
815
      when it's required to check this property.
 
816
      
 
817
    - Fixed bug when calling stored functions, where parameters weren't 
 
818
      numbered correctly (first parameter is now the return value, subsequent
 
819
      parameters if specified start at index "2").
 
820
       
 
821
        - Fixed BUG#21814 - time values outside valid range silently wrap.
 
822
                                
 
823
    - Fixed bug when calling stored functions, where parameters weren't 
 
824
      numbered correctly (first parameter is now the return value, subsequent
 
825
      parameters if specified start at index "2").
 
826
       
 
827
        - Fixed BUG#21814 - time values outside valid range silently wrap.
 
828
                                                          
 
829
05-26-06 - Version 3.1.13
 
830
 
 
831
    - Fixed BUG#15464 - INOUT parameter does not store IN value.
 
832
    
 
833
    - Fixed BUG#14609 - Exception thrown for new decimal type when 
 
834
      using updatable result sets.
 
835
            
 
836
    - Fixed BUG#15544, no "dos" character set in MySQL > 4.1.0
 
837
    
 
838
    - Fixed BUG#15383 - PreparedStatement.setObject() serializes 
 
839
      BigInteger as object, rather than sending as numeric value 
 
840
      (and is thus not complementary to .getObject() on an UNSIGNED 
 
841
      LONG type).
 
842
      
 
843
    - Fixed BUG#11874 - ResultSet.getShort() for UNSIGNED TINYINT
 
844
      returned wrong values. 
 
845
      
 
846
    - Fixed BUG#15676 - lib-nodist directory missing from  
 
847
      package breaks out-of-box build   
 
848
      
 
849
    - Fixed BUG#15854 - DBMD.getColumns() returns wrong type for BIT.  
 
850
    
 
851
    - Fixed BUG#16169 - ResultSet.getNativeShort() causes stack overflow error
 
852
      via recurisve calls.
 
853
      
 
854
    - Fixed BUG#14938 - Unable to initialize character set mapping tables. 
 
855
      Removed reliance on .properties files to hold this information, as it
 
856
      turns out to be too problematic to code around class loader hierarchies
 
857
      that change depending on how an application is deployed. Moved information
 
858
      back into the CharsetMapping class.      
 
859
      
 
860
    - Fixed BUG#16841 - updatable result set doesn't return AUTO_INCREMENT 
 
861
      values for insertRow() when multiple column primary keys are used. (the
 
862
      driver was checking for the existence of single-column primary keys and
 
863
      an autoincrement value > 0 instead of a straightforward isAutoIncrement() 
 
864
      check).
 
865
      
 
866
    - Fixed BUG#17099 - Statement.getGeneratedKeys() throws NullPointerException 
 
867
      when no query has been processed.
 
868
      
 
869
    - Fixed BUG#13469 - Driver tries to call methods that don't exist on older and
 
870
      newer versions of Log4j. The fix is not trying to auto-detect presense of log4j, 
 
871
      too many different incompatible versions out there in the wild to do this reliably.
 
872
      
 
873
      If you relied on autodetection before, you will need to add 
 
874
      "logger=com.mysql.jdbc.log.Log4JLogger" to your JDBC URL to enable Log4J usage,
 
875
      or alternatively use the new "CommonsLogger" class to take care of this.
 
876
      
 
877
    - Added support for Apache Commons logging, use "com.mysql.jdbc.log.CommonsLogger"
 
878
      as the value for the "logger" configuration property.
 
879
      
 
880
    - LogFactory now prepends "com.mysql.jdbc.log" to log class name if it can't be
 
881
      found as-specified. This allows you to use "short names" for the built-in log
 
882
      factories, for example "logger=CommonsLogger" instead of 
 
883
      "logger=com.mysql.jdbc.log.CommonsLogger".
 
884
      
 
885
    - Fixed BUG#15570 - ReplicationConnection incorrectly copies state,
 
886
          doesn't transfer connection context correctly when transitioning between 
 
887
          the same read-only states.
 
888
                  
 
889
        - Fixed BUG#18041 - Server-side prepared statements don't cause 
 
890
          truncation exceptions to be thrown when truncation happens.
 
891
          
 
892
        - Added performance feature, re-writing of batched executes for
 
893
          Statement.executeBatch() (for all DML statements) and 
 
894
          PreparedStatement.executeBatch() (for INSERTs with VALUE clauses 
 
895
          only). Enable by using "rewriteBatchedStatements=true" in your JDBC URL.
 
896
          
 
897
        - Fixed BUG#17898 - registerOutParameter not working when some 
 
898
          parameters pre-populated. Still waiting for feedback from JDBC experts
 
899
          group to determine what correct parameter count from getMetaData() 
 
900
          should be, however.
 
901
 
 
902
        - Fixed BUG#17587 - clearParameters() on a closed prepared statement
 
903
          causes NPE.
 
904
          
 
905
        - Map "latin1" on MySQL server to CP1252 for MySQL > 4.1.0.
 
906
        
 
907
        - Added additional accessor and mutator methods on ConnectionProperties
 
908
          so that DataSource users can use same naming as regular URL properties.
 
909
          
 
910
        - Fixed BUG#18740 - Data truncation and getWarnings() only returns last 
 
911
          warning in set.
 
912
          
 
913
        - Improved performance of retrieving BigDecimal, Time, Timestamp and Date
 
914
          values from server-side prepared statements by creating fewer short-lived
 
915
          instances of Strings when the native type is not an exact match for
 
916
          the requested type. Fixes BUG#18496 for BigDecimals.
 
917
          
 
918
        - Fixed BUG#18554 - Aliased column names where length of name > 251 
 
919
          are corrupted.
 
920
                  
 
921
        - Fixed BUG#17450 - ResultSet.wasNull() not always reset
 
922
          correctly for booleans when done via conversion for server-side
 
923
          prepared statements.
 
924
        
 
925
        - Fixed BUG#16277 - Invalid classname returned for 
 
926
          RSMD.getColumnClassName() for BIGINT type.
 
927
          
 
928
        - Fixed case where driver wasn't reading server status correctly when 
 
929
          fetching server-side prepared statement rows, which in some cases 
 
930
          could cause warning counts to be off, or multiple result sets to not 
 
931
          be read off the wire.
 
932
          
 
933
        - Driver now aware of fix for BIT type metadata that went into 
 
934
          MySQL-5.0.21 for server not reporting length consistently (bug 
 
935
          number 13601).
 
936
          
 
937
        - Fixed BUG#19282 - ResultSet.wasNull() returns incorrect value 
 
938
          when extracting native string from server-side prepared statement 
 
939
          generated result set.
 
940
          
 
941
11-30-05 - Version 3.1.12
 
942
 
 
943
    - Fixed client-side prepared statement bug with embedded ? inside
 
944
      quoted identifiers (it was recognized as a placeholder, when it
 
945
      was not).
 
946
      
 
947
    - Don't allow executeBatch() for CallableStatements with registered
 
948
      OUT/INOUT parameters (JDBC compliance).
 
949
      
 
950
    - Fall back to platform-encoding for URLDecoder.decode() when
 
951
      parsing driver URL properties if the platform doesn't have a 
 
952
      two-argument version of this method.
 
953
      
 
954
    - Fixed BUG#14562 - Java type conversion may be incorrect for 
 
955
      mediumint.
 
956
      
 
957
    - Added configuration property "useGmtMillisForDatetimes" which
 
958
      when set to true causes ResultSet.getDate(), .getTimestamp() to
 
959
      return correct millis-since GMT when .getTime() is called on 
 
960
      the return value (currently default is "false" for legacy
 
961
      behavior).
 
962
 
 
963
    - Fixed DatabaseMetaData.stores*Identifiers():
 
964
    
 
965
        * if lower_case_table_names=0 (on server):
 
966
        
 
967
            storesLowerCaseIdentifiers() returns false
 
968
            storesLowerCaseQuotedIdentifiers() returns false
 
969
            storesMixedCaseIdentifiers() returns true
 
970
            storesMixedCaseQuotedIdentifiers() returns true
 
971
            storesUpperCaseIdentifiers() returns false
 
972
            storesUpperCaseQuotedIdentifiers() returns true 
 
973
                
 
974
        * if lower_case_table_names=1 (on server):
 
975
        
 
976
            storesLowerCaseIdentifiers() returns true
 
977
            storesLowerCaseQuotedIdentifiers() returns true
 
978
            storesMixedCaseIdentifiers() returns false
 
979
            storesMixedCaseQuotedIdentifiers() returns false
 
980
            storesUpperCaseIdentifiers() returns false
 
981
            storesUpperCaseQuotedIdentifiers() returns true 
 
982
 
 
983
    - Fixed BUG#14815 - DatabaseMetaData.getColumns() doesn't
 
984
      return TABLE_NAME correctly.
 
985
      
 
986
    - Fixed BUG#14909 - escape processor replaces quote character 
 
987
      in quoted string with string delimiter.
 
988
      
 
989
    - Fixed BUG#12975 - OpenOffice expects 
 
990
      DBMD.supportsIntegrityEnhancementFacility() to return "true" 
 
991
      if foreign keys are supported by the datasource, even though 
 
992
      this method also covers support for check constraints,
 
993
          which MySQL _doesn't_ have. Setting the configuration property
 
994
          "overrideSupportsIntegrityEnhancementFacility" to "true" causes
 
995
          the driver to return "true" for this method.
 
996
          
 
997
    - Added "com.mysql.jdbc.testsuite.url.default" system property to
 
998
          set default JDBC url for testsuite (to speed up bug resolution
 
999
          when I'm working in Eclipse).
 
1000
        
 
1001
        - Fixed BUG#14938 - Unable to initialize character set mapping 
 
1002
          tables (due to J2EE classloader differences).
 
1003
          
 
1004
        - Fixed BUG#14972 - Deadlock while closing server-side prepared
 
1005
          statements from multiple threads sharing one connection.
 
1006
          
 
1007
        - Fixed BUG#12230 -     logSlowQueries should give better info.
 
1008
        
 
1009
        - Fixed BUG#13775 - Extraneous sleep on autoReconnect.
 
1010
        
 
1011
        - Fixed BUG#15024 - Driver incorrectly closes streams passed as 
 
1012
          arguments to PreparedStatements. Reverts to legacy behavior by
 
1013
          setting the JDBC configuration property "autoClosePStmtStreams"
 
1014
          to "true" (also included in the 3-0-Compat configuration "bundle").
 
1015
          
 
1016
        - Fixed BUG#13048 - maxQuerySizeToLog is not respected. Added logging of
 
1017
          bound values for execute() phase of server-side prepared statements
 
1018
          when profileSQL=true as well.
 
1019
          
 
1020
        - Fixed BUG#15065 - Usage advisor complains about unreferenced 
 
1021
          columns, even though they've been referenced.
 
1022
          
 
1023
        - Don't increase timeout for failover/reconnect (BUG#6577)
 
1024
        
 
1025
        - Process escape tokens in Connection.prepareStatement(...), fix
 
1026
          for BUG#15141. You can disable this behavior by setting 
 
1027
          the JDBC URL configuration property "processEscapeCodesForPrepStmts"
 
1028
          to "false".
 
1029
          
 
1030
        - Fixed BUG#13255 - Reconnect during middle of executeBatch() 
 
1031
          should not occur if autoReconnect is enabled.
 
1032
      
 
1033
10-07-05 - Version 3.1.11
 
1034
 
 
1035
    - Fixed BUG#11629 - Spurious "!" on console when character
 
1036
      encoding is "utf8".
 
1037
      
 
1038
    - Fixed statements generated for testcases missing ";" for
 
1039
      "plain" statements.
 
1040
      
 
1041
    - Fixed BUG#11663 - Incorrect generation of testcase scripts 
 
1042
      for server-side prepared statements.
 
1043
      
 
1044
    - Fixed regression caused by fix for BUG#11552 that caused driver
 
1045
      to return incorrect values for unsigned integers when those 
 
1046
      integers where within the range of the positive signed type.
 
1047
    
 
1048
    - Moved source code to svn repo.
 
1049
    
 
1050
    - Fixed BUG#11797 - Escape tokenizer doesn't respect stacked single quotes
 
1051
          for escapes.
 
1052
          
 
1053
        - GEOMETRY type not recognized when using server-side prepared statements.
 
1054
    
 
1055
    - Fixed BUG#11879 -- ReplicationConnection won't switch to slave, throws 
 
1056
      "Catalog can't be null" exception.
 
1057
      
 
1058
    - Fixed BUG#12218, properties shared between master and slave with 
 
1059
      replication connection.
 
1060
      
 
1061
    - Fixed BUG#10630, Statement.getWarnings() fails with NPE if statement 
 
1062
      has been closed.
 
1063
      
 
1064
    - Only get char[] from SQL in PreparedStatement.ParseInfo() when needed.
 
1065
    
 
1066
    - Fixed BUG#12104 - Geometry types not handled with server-side prepared 
 
1067
      statements.
 
1068
      
 
1069
    - Fixed BUG#11614 - StringUtils.getBytes() doesn't work when using 
 
1070
      multibyte character encodings and a length in  _characters_ is 
 
1071
      specified.
 
1072
      
 
1073
    - Fixed BUG#11798 - Pstmt.setObject(...., Types.BOOLEAN) throws exception.
 
1074
    
 
1075
    - Fixed BUG#11976 - maxPerformance.properties mis-spells 
 
1076
          "elideSetAutoCommits".
 
1077
          
 
1078
        - Fixed BUG#11575 -- DBMD.storesLower/Mixed/UpperIdentifiers()
 
1079
          reports incorrect values for servers deployed on Windows.
 
1080
          
 
1081
        - Fixed BUG#11190 - ResultSet.moveToCurrentRow() fails to work when 
 
1082
          preceeded by a call to ResultSet.moveToInsertRow().
 
1083
          
 
1084
        - Fixed BUG#11115, VARBINARY data corrupted when using server-side
 
1085
          prepared statements and .setBytes().
 
1086
        
 
1087
        - Fixed BUG#12229 - explainSlowQueries hangs with server-side
 
1088
          prepared statements.
 
1089
          
 
1090
        - Fixed BUG#11498 - Escape processor didn't honor strings demarcated
 
1091
          with double quotes.
 
1092
          
 
1093
        - Lifted restriction of changing streaming parameters with server-side
 
1094
          prepared statements. As long as _all_ streaming parameters were set
 
1095
          before execution, .clearParameters() does not have to be called. 
 
1096
          (due to limitation of client/server protocol, prepared statements
 
1097
           can not reset _individual_ stream data on the server side).
 
1098
           
 
1099
        - Reworked Field class, *Buffer, and MysqlIO to be aware of field
 
1100
          lengths > Integer.MAX_VALUE.
 
1101
          
 
1102
        - Updated DBMD.supportsCorrelatedQueries() to return true for versions > 
 
1103
          4.1, supportsGroupByUnrelated() to return true and 
 
1104
          getResultSetHoldability() to return HOLD_CURSORS_OVER_COMMIT.
 
1105
          
 
1106
        - Fixed BUG#12541 - Handling of catalog argument in 
 
1107
          DatabaseMetaData.getIndexInfo(), which also means changes to the following
 
1108
          methods in DatabaseMetaData:
 
1109
          
 
1110
            - getBestRowIdentifier()
 
1111
            - getColumns()
 
1112
            - getCrossReference()
 
1113
            - getExportedKeys()
 
1114
            - getImportedKeys()
 
1115
            - getIndexInfo()
 
1116
            - getPrimaryKeys()
 
1117
            - getProcedures() (and thus indirectly getProcedureColumns())
 
1118
            - getTables()
 
1119
          
 
1120
          The "catalog" argument in all of these methods now behaves in the following
 
1121
          way:
 
1122
          
 
1123
            - Specifying NULL means that catalog will not be used to filter the
 
1124
              results (thus all databases will be searched), unless you've
 
1125
              set "nullCatalogMeansCurrent=true" in your JDBC URL properties.
 
1126
              
 
1127
            - Specifying "" means "current" catalog, even though this isn't quite
 
1128
              JDBC spec compliant, it's there for legacy users.
 
1129
              
 
1130
            - Specifying a catalog works as stated in the API docs.
 
1131
            
 
1132
        - Made Connection.clientPrepare() available from "wrapped" connections
 
1133
          in the jdbc2.optional package (connections built by 
 
1134
          ConnectionPoolDataSource instances).
 
1135
      
 
1136
    - Added Connection.isMasterConnection() for clients to be able to determine
 
1137
      if a multi-host master/slave connection is connected to the first host
 
1138
      in the list.
 
1139
      
 
1140
    - Fixed BUG#12753 - Tokenizer for "=" in URL properties was causing
 
1141
      sessionVariables=.... to be parameterized incorrectly.
 
1142
 
 
1143
    - Fixed BUG#11781, foreign key information that is quoted is 
 
1144
      parsed incorrectly when DatabaseMetaData methods use that
 
1145
      information.
 
1146
      
 
1147
    - The "sendBlobChunkSize" property is now clamped to "max_allowed_packet"
 
1148
      with consideration of stream buffer size and packet headers to avoid
 
1149
      PacketTooBigExceptions when "max_allowed_packet" is similar in size
 
1150
      to the default "sendBlobChunkSize" which is 1M.
 
1151
      
 
1152
    - CallableStatement.clearParameters() now clears resources associated
 
1153
      with INOUT/OUTPUT parameters as well as INPUT parameters.
 
1154
      
 
1155
    - Fixed BUG#12417 - Connection.prepareCall() is database name 
 
1156
      case-sensitive (on Windows systems).
 
1157
      
 
1158
    - Fixed BUG#12752 - Cp1251 incorrectly mapped to win1251 for 
 
1159
      servers newer than 4.0.x.
 
1160
      
 
1161
    - Fixed BUG#12970 - java.sql.Types.OTHER returned for 
 
1162
          BINARY and VARBINARY columns when using 
 
1163
          DatabaseMetaData.getColumns(). 
 
1164
          
 
1165
        - ServerPreparedStatement.getBinding() now checks if the statement
 
1166
          is closed before attempting to reference the list of parameter
 
1167
          bindings, to avoid throwing a NullPointerException.
 
1168
    
 
1169
    - Fixed BUG#13277 - ResultSetMetaData from 
 
1170
      Statement.getGeneratedKeys() caused NullPointerExceptions to be
 
1171
      thrown whenever a method that required a connection reference
 
1172
      was called.
 
1173
      
 
1174
    - Removed support for java.nio I/O. Too many implementations
 
1175
      turned out to be buggy, and there was no performance difference
 
1176
      since MySQL is a blocking protocol anyway.
 
1177
      
 
1178
06-23-05 - Version 3.1.10-stable
 
1179
 
 
1180
        - Fixed connecting without a database specified raised an exception
 
1181
          in MysqlIO.changeDatabaseTo().
 
1182
          
 
1183
        - Initial implemention of ParameterMetadata for 
 
1184
          PreparedStatement.getParameterMetadata(). Only works fully
 
1185
          for CallableStatements, as current server-side prepared statements
 
1186
          return every parameter as a VARCHAR type.
 
1187
          
 
1188
        - Fixed BUG#11552 - Server-side prepared statements return incorrect
 
1189
          values for unsigned TINYINT, SMALLINT, INT and Long.
 
1190
          
 
1191
        - Fixed BUG#11540 - Incorrect year conversion in setDate(..) for 
 
1192
          system that use B.E. year in default locale.
 
1193
          
 
1194
06-22-05 - Version 3.1.9-stable
 
1195
        
 
1196
        - Overhaul of character set configuration, everything now
 
1197
          lives in a properties file.
 
1198
          
 
1199
        - Driver now correctly uses CP932 if available on the server
 
1200
          for Windows-31J, CP932 and MS932 java encoding names, 
 
1201
          otherwise it resorts to SJIS, which is only a close 
 
1202
          approximation. Currently only MySQL-5.0.3 and newer (and
 
1203
          MySQL-4.1.12 or .13, depending on when the character set
 
1204
          gets backported) can reliably support any variant of CP932.
 
1205
          
 
1206
        - Fixed BUG#9064 - com.mysql.jdbc.PreparedStatement.ParseInfo 
 
1207
          does unnecessary call to toCharArray().
 
1208
          
 
1209
        - Fixed Bug#10144 - Memory leak in ServerPreparedStatement if 
 
1210
          serverPrepare() fails.
 
1211
          
 
1212
        - Actually write manifest file to correct place so it ends up
 
1213
          in the binary jar file.
 
1214
          
 
1215
        - Added "createDatabaseIfNotExist" property (default is "false"),
 
1216
          which will cause the driver to ask the server to create the 
 
1217
          database specified in the URL if it doesn't exist. You must have
 
1218
          the appropriate privileges for database creation for this to
 
1219
          work.
 
1220
          
 
1221
        - Fixed BUG#10156 - Unsigned SMALLINT treated as signed for ResultSet.getInt(),
 
1222
          fixed all cases for UNSIGNED integer values and server-side prepared statements,
 
1223
          as well as ResultSet.getObject() for UNSIGNED TINYINT.
 
1224
          
 
1225
        - Fixed BUG#10155, double quotes not recognized when parsing 
 
1226
          client-side prepared statements.
 
1227
          
 
1228
        - Made enableStreamingResults() visible on 
 
1229
          com.mysql.jdbc.jdbc2.optional.StatementWrapper.
 
1230
          
 
1231
        - Made ServerPreparedStatement.asSql() work correctly so auto-explain
 
1232
          functionality would work with server-side prepared statements.
 
1233
          
 
1234
        - Made JDBC2-compliant wrappers public in order to allow access to
 
1235
          vendor extensions.
 
1236
          
 
1237
        - Cleaned up logging of profiler events, moved code to dump a profiler
 
1238
          event as a string to com.mysql.jdbc.log.LogUtils so that third
 
1239
          parties can use it.
 
1240
          
 
1241
        - DatabaseMetaData.supportsMultipleOpenResults() now returns true. The
 
1242
          driver has supported this for some time, DBMD just missed that fact.
 
1243
          
 
1244
        - Fixed BUG#10310 - Driver doesn't support {?=CALL(...)} for calling
 
1245
          stored functions. This involved adding support for function retrieval
 
1246
          to DatabaseMetaData.getProcedures() and getProcedureColumns() as well.
 
1247
          
 
1248
        - Fixed BUG#10485, SQLException thrown when retrieving YEAR(2) 
 
1249
          with ResultSet.getString(). The driver will now always treat YEAR types
 
1250
          as java.sql.Dates and return the correct values for getString(). 
 
1251
          Alternatively, the "yearIsDateType" connection property can be set to
 
1252
          "false" and the values will be treated as SHORTs.
 
1253
          
 
1254
        - The datatype returned for TINYINT(1) columns when "tinyInt1isBit=true" 
 
1255
          (the default) can be switched between Types.BOOLEAN and Types.BIT
 
1256
          using the new configuration property "transformedBitIsBoolean", which
 
1257
          defaults to "false". If set to "false" (the default), 
 
1258
          DatabaseMetaData.getColumns() and ResultSetMetaData.getColumnType() 
 
1259
          will return Types.BOOLEAN for TINYINT(1) columns. If "true", 
 
1260
          Types.BOOLEAN will be returned instead. Irregardless of this configuration
 
1261
          property, if "tinyInt1isBit" is enabled, columns with the type TINYINT(1)
 
1262
          will be returned as java.lang.Boolean instances from 
 
1263
          ResultSet.getObject(..), and ResultSetMetaData.getColumnClassName()
 
1264
          will return "java.lang.Boolean".
 
1265
         
 
1266
        - Fixed BUG#10496 - SQLException is thrown when using property 
 
1267
          "characterSetResults" with cp932 or eucjpms.
 
1268
          
 
1269
        - Reorganized directory layout, sources now in "src" folder,
 
1270
          don't pollute parent directory when building, now output goes
 
1271
          to "./build", distribution goes to "./dist".
 
1272
          
 
1273
        - Added support/bug hunting feature that generates .sql test
 
1274
          scripts to STDERR when "autoGenerateTestcaseScript" is set
 
1275
          to "true".
 
1276
          
 
1277
        - Fixed BUG#10850 - 0-length streams not sent to server when
 
1278
          using server-side prepared statements.
 
1279
        
 
1280
        - Setting "cachePrepStmts=true" now causes the Connection to also 
 
1281
          cache the check the driver performs to determine if a prepared 
 
1282
          statement can be server-side or not, as well as caches server-side
 
1283
          prepared statements for the lifetime of a connection. As before,
 
1284
          the "prepStmtCacheSize" parameter controls the size of these
 
1285
          caches.
 
1286
          
 
1287
        - Try to handle OutOfMemoryErrors more gracefully. Although not
 
1288
          much can be done, they will in most cases close the connection
 
1289
          they happened on so that further operations don't run into 
 
1290
          a connection in some unknown state. When an OOM has happened, 
 
1291
          any further operations on the connection will fail with a 
 
1292
          "Connection closed" exception that will also list the OOM exception
 
1293
          as the reason for the implicit connection close event.
 
1294
          
 
1295
        - Don't send COM_RESET_STMT for each execution of a server-side
 
1296
          prepared statement if it isn't required.
 
1297
          
 
1298
        - Driver detects if you're running MySQL-5.0.7 or later, and does
 
1299
          not scan for "LIMIT ?[,?]" in statements being prepared, as the
 
1300
          server supports those types of queries now.
 
1301
          
 
1302
        - Fixed BUG#11115, Varbinary data corrupted when using server-side
 
1303
          prepared statements and ResultSet.getBytes().
 
1304
          
 
1305
        - Connection.setCatalog() is now aware of the "useLocalSessionState"
 
1306
          configuration property, which when set to true will prevent
 
1307
          the driver from sending "USE ..." to the server if the requested
 
1308
          catalog is the same as the current catalog.
 
1309
          
 
1310
        - Added the following configuration bundles, use one or many via
 
1311
          the "useConfigs" configuration property:
 
1312
        
 
1313
            * maxPerformance -- maximum performance without being reckless
 
1314
            * solarisMaxPerformance -- maximum performance for Solaris,
 
1315
                                       avoids syscalls where it can
 
1316
            * 3-0-Compat -- Compatibility with Connector/J 3.0.x functionality
 
1317
            
 
1318
        - Added "maintainTimeStats" configuration property (defaults to "true"),
 
1319
          which tells the driver whether or not to keep track of the last query time
 
1320
          and the last successful packet sent to the server's time. If set to
 
1321
          false, removes two syscalls per query.
 
1322
        
 
1323
        - Fixed BUG#11259, autoReconnect ping causes exception on connection 
 
1324
          startup.
 
1325
          
 
1326
        - Fixed BUG#11360 Connector/J dumping query into SQLException twice
 
1327
        
 
1328
        - Fixed PreparedStatement.setClob() not accepting null as a parameter.
 
1329
        
 
1330
        - Fixed BUG#11411 - Production package doesn't include JBoss integration 
 
1331
          classes.
 
1332
          
 
1333
        - Removed nonsensical "costly type conversion" warnings when using 
 
1334
          usage advisor.
 
1335
 
 
1336
04-14-05 - Version 3.1.8-stable
 
1337
 
 
1338
        - Fixed DatabaseMetaData.getTables() returning views when they were 
 
1339
          not asked for as one of the requested table types.
 
1340
          
 
1341
        - Added support for new precision-math DECIMAL type in MySQL >= 5.0.3.
 
1342
        
 
1343
        - Fixed ResultSet.getTime() on a NULL value for server-side prepared
 
1344
          statements throws NPE.
 
1345
          
 
1346
        - Made Connection.ping() a public method.
 
1347
        
 
1348
        - Fixed Bug#8868, DATE_FORMAT() queries returned as BLOBs from getObject().
 
1349
        
 
1350
        - ServerPreparedStatements now correctly 'stream' BLOB/CLOB data to the
 
1351
          server. You can configure the threshold chunk size using the
 
1352
          JDBC URL property 'blobSendChunkSize' (the default is one megabyte).
 
1353
          
 
1354
    - BlobFromLocator now uses correct identifier quoting when generating
 
1355
      prepared statements.
 
1356
      
 
1357
    - Server-side session variables can be preset at connection time by
 
1358
      passing them as a comma-delimited list for the connection property 
 
1359
      'sessionVariables'.
 
1360
 
 
1361
        - Fixed regression in ping() for users using autoReconnect=true.
 
1362
        
 
1363
        - Fixed BUG#9040 - PreparedStatement.addBatch() doesn't work with server-side 
 
1364
          prepared statements and streaming BINARY data.
 
1365
          
 
1366
        - Fixed BUG#8800 - DBMD.supportsMixedCase*Identifiers() returns wrong
 
1367
          value on servers running on case-sensitive filesystems.
 
1368
        
 
1369
        - Fixed BUG#9206, can not use 'UTF-8' for characterSetResults
 
1370
      configuration property.
 
1371
      
 
1372
    - Fixed BUG#9236, a continuation of BUG#8868, where functions used in queries 
 
1373
      that should return non-string types when resolved by temporary tables suddenly 
 
1374
      become opaque binary strings (work-around for server limitation). Also fixed
 
1375
      fields with type of CHAR(n) CHARACTER SET BINARY to return correct/matching
 
1376
      classes for RSMD.getColumnClassName() and ResultSet.getObject().
 
1377
    
 
1378
    - Fixed BUG#8792 - DBMD.supportsResultSetConcurrency() not returning
 
1379
          true for forward-only/read-only result sets (we obviously support this).
 
1380
          
 
1381
        - Fixed BUG#8803, 'DATA_TYPE' column from DBMD.getBestRowIdentifier()
 
1382
          causes ArrayIndexOutOfBoundsException when accessed (and in fact, didn't
 
1383
          return any value).
 
1384
          
 
1385
        - Check for empty strings ('') when converting char/varchar column data to numbers,
 
1386
          throw exception if 'emptyStringsConvertToZero' configuration property is set
 
1387
          to 'false' (for backwards-compatibility with 3.0, it is now set to 'true' 
 
1388
          by default, but will most likely default to 'false' in 3.2).
 
1389
          
 
1390
        - Fixed BUG#9320 - PreparedStatement.getMetaData() inserts blank row in database 
 
1391
          under certain conditions when not using server-side prepared statements.
 
1392
          
 
1393
        - Connection.canHandleAsPreparedStatement() now makes 'best effort' to distinguish
 
1394
          LIMIT clauses with placeholders in them from ones without in order to have fewer
 
1395
          false positives when generating work-arounds for statements the server cannot 
 
1396
          currently handle as server-side prepared statements.
 
1397
          
 
1398
        - Fixed build.xml to not compile log4j logging if log4j not available.
 
1399
        
 
1400
        - Added support for the c3p0 connection pool's (http://c3p0.sf.net/) 
 
1401
          validation/connection checker interface which uses the lightweight 
 
1402
          'COM_PING' call to the server if available. To use it, configure your
 
1403
          c3p0 connection pool's 'connectionTesterClassName' property to use
 
1404
          'com.mysql.jdbc.integration.c3p0.MysqlConnectionTester'.
 
1405
          
 
1406
        - Better detection of LIMIT inside/outside of quoted strings so that
 
1407
          the driver can more correctly determine whether a prepared statement
 
1408
          can be prepared on the server or not.
 
1409
        
 
1410
        - Fixed BUG#9319 - Stored procedures with same name in 
 
1411
          different databases confuse the driver when it tries to determine
 
1412
          parameter counts/types.
 
1413
  
 
1414
    - Added finalizers to ResultSet and Statement implementations to be JDBC
 
1415
      spec-compliant, which requires that if not explicitly closed, these 
 
1416
      resources should be closed upon garbage collection.
 
1417
      
 
1418
    - Fixed BUG#9682 - Stored procedures with DECIMAL parameters with
 
1419
          storage specifications that contained "," in them would fail.
 
1420
          
 
1421
        - PreparedStatement.setObject(int, Object, int type, int scale) now 
 
1422
          uses scale value for BigDecimal instances.
 
1423
          
 
1424
        - Fixed BUG#9704 - Statement.getMoreResults() could throw NPE when
 
1425
          existing result set was .close()d.
 
1426
          
 
1427
        - The performance metrics feature now gathers information about
 
1428
          number of tables referenced in a SELECT.
 
1429
        
 
1430
        - The logging system is now automatically configured. If the value has 
 
1431
          been set by the user, via the URL property "logger" or the system 
 
1432
          property "com.mysql.jdbc.logger", then use that, otherwise, autodetect 
 
1433
          it using the following steps:
 
1434
          
 
1435
         Log4j, if it's available,
 
1436
         Then JDK1.4 logging,
 
1437
         Then fallback to our STDERR logging.
 
1438
         
 
1439
        - Fixed BUG#9778, DBMD.getTables() shouldn't return tables if views
 
1440
          are asked for, even if the database version doesn't support views.
 
1441
          
 
1442
        - Fixed driver not returning 'true' for '-1' when ResultSet.getBoolean()
 
1443
          was called on result sets returned from server-side prepared statements.
 
1444
          
 
1445
        - Added a Manifest.MF file with implementation information to the .jar
 
1446
          file.
 
1447
          
 
1448
        - More tests in Field.isOpaqueBinary() to distinguish opaque binary (i.e. 
 
1449
          fields with type CHAR(n) and CHARACTER SET BINARY) from output of 
 
1450
          various scalar and aggregate functions that return strings.
 
1451
          
 
1452
        - Fixed BUG#9917 - Should accept null for catalog (meaning use current) 
 
1453
          in DBMD methods, even though it's not JDBC-compliant for legacy's sake.
 
1454
          Disable by setting connection property "nullCatalogMeansCurrent" to "false"
 
1455
          (which will be the default value in C/J 3.2.x).
 
1456
          
 
1457
        - Fixed BUG#9769 - Should accept null for name patterns in DBMD (meaning "%"), 
 
1458
          even though it isn't JDBC compliant, for legacy's sake. Disable by setting
 
1459
          connection property "nullNamePatternMatchesAll" to "false" (which will be 
 
1460
          the default value in C/J 3.2.x).
 
1461
                 
 
1462
02-18-05 - Version 3.1.7-stable
 
1463
 
 
1464
 
 
1465
    - Fixed BUG#7686, Timestamp key column data needed "_binary'"
 
1466
      stripped for UpdatableResultSet.refreshRow().
 
1467
 
 
1468
    - Fixed BUG#7715 - Timestamps converted incorrectly to strings
 
1469
      with Server-side prepared statements and updatable result sets.
 
1470
 
 
1471
    - Detect new sql_mode variable in string form (it used to be 
 
1472
      integer) and adjust quoting method for strings appropriately.
 
1473
 
 
1474
    - Added 'holdResultsOpenOverStatementClose' property (default is
 
1475
      false), that keeps result sets open over statement.close() or new
 
1476
      execution on same statement (suggested by Kevin Burton).
 
1477
 
 
1478
    - Fixed BUG#7952 -- Infinite recursion when 'falling back' to master
 
1479
      in failover configuration.
 
1480
 
 
1481
    - Disable multi-statements (if enabled) for MySQL-4.1 versions prior
 
1482
      to version 4.1.10 if the query cache is enabled, as the server
 
1483
      returns wrong results in this configuration.
 
1484
 
 
1485
    - Fixed duplicated code in configureClientCharset() that prevented
 
1486
      useOldUTF8Behavior=true from working properly.
 
1487
 
 
1488
    - Removed 'dontUnpackBinaryResults' functionality, the driver now
 
1489
      always stores results from server-side prepared statements as-is
 
1490
      from the server and unpacks them on demand.
 
1491
 
 
1492
    - Fixed BUG#8096 where emulated locators corrupt binary data
 
1493
      when using server-side prepared statements.
 
1494
 
 
1495
    - Fixed synchronization issue with
 
1496
      ServerPreparedStatement.serverPrepare() that could cause
 
1497
      deadlocks/crashes if connection was shared between threads.
 
1498
 
 
1499
    - By default, the driver now scans SQL you are preparing via all
 
1500
      variants of Connection.prepareStatement() to determine if it is a
 
1501
      supported type of statement to prepare on the server side, and if
 
1502
      it is not supported by the server, it instead prepares it as a
 
1503
      client-side emulated prepared statement (BUG#4718). You can
 
1504
      disable this by passing 'emulateUnsupportedPstmts=false' in your
 
1505
      JDBC URL.
 
1506
 
 
1507
    - Remove _binary introducer from parameters used as in/out
 
1508
      parameters in CallableStatement.
 
1509
 
 
1510
    - Always return byte[]s for output parameters registered as *BINARY.
 
1511
 
 
1512
    - Send correct value for 'boolean' "true" to server for
 
1513
      PreparedStatement.setObject(n, "true", Types.BIT).
 
1514
 
 
1515
    - Fixed bug with Connection not caching statements from
 
1516
      prepareStatement() when the statement wasn't a server-side
 
1517
      prepared statement.
 
1518
 
 
1519
    - Choose correct 'direction' to apply time adjustments when both
 
1520
      client and server are in GMT timezone when using
 
1521
      ResultSet.get(..., cal) and PreparedStatement.set(...., cal).
 
1522
 
 
1523
    - Added 'dontTrackOpenResources' option (default is false, to be
 
1524
      JDBC compliant), which helps with memory use for non-well-behaved
 
1525
      apps (i.e applications which don't close Statements when they
 
1526
      should).
 
1527
 
 
1528
    - Fixed BUG#8428 - ResultSet.getString() doesn't maintain format
 
1529
      stored on server, bug fix only enabled when 'noDatetimeStringSync'
 
1530
      property is set to 'true' (the default is 'false').
 
1531
 
 
1532
    - Fixed NPE in ResultSet.realClose() when using usage advisor and
 
1533
      result set was already closed.
 
1534
 
 
1535
    - Fixed BUG#8487 - PreparedStatements not creating streaming result
 
1536
      sets.
 
1537
 
 
1538
    - Don't pass NULL to String.valueOf() in
 
1539
      ResultSet.getNativeConvertToString(), as it stringifies it (i.e.
 
1540
      returns "null"), which is not correct for the method in question.
 
1541
 
 
1542
    - Fixed BUG#8484 - ResultSet.getBigDecimal() throws exception
 
1543
      when rounding would need to occur to set scale. The driver now
 
1544
      chooses a rounding mode of 'half up' if non-rounding
 
1545
      BigDecimal.setScale() fails.
 
1546
 
 
1547
    - Added 'useLocalSessionState' configuration property, when set to
 
1548
      'true' the JDBC driver trusts that the application is well-behaved
 
1549
      and only sets autocommit and transaction isolation levels using
 
1550
      the methods provided on java.sql.Connection, and therefore can
 
1551
      manipulate these values in many cases without incurring
 
1552
      round-trips to the database server.
 
1553
 
 
1554
    - Added enableStreamingResults() to Statement for connection pool
 
1555
      implementations that check Statement.setFetchSize() for 
 
1556
      specification-compliant values. Call Statement.setFetchSize(>=0) 
 
1557
      to disable the streaming results for that statement.
 
1558
 
 
1559
    - Added support for BIT type in MySQL-5.0.3. The driver will treat
 
1560
      BIT(1-8) as the JDBC standard BIT type (which maps to
 
1561
      java.lang.Boolean), as the server does not currently send enough
 
1562
      information to determine the size of a bitfield when < 9 bits are
 
1563
      declared. BIT(>9) will be treated as VARBINARY, and will return
 
1564
      byte[] when getObject() is called.
 
1565
      
 
1566
12-23-04 - Version 3.1.6-stable
 
1567
 
 
1568
    - Fixed hang on SocketInputStream.read() with Statement.setMaxRows() and 
 
1569
      multiple result sets when driver has to truncate result set directly, 
 
1570
      rather than tacking a 'LIMIT n' on the end of it.
 
1571
      
 
1572
    - Fixed BUG#7026 - DBMD.getProcedures() doesn't respect catalog parameter.
 
1573
    
 
1574
    - Respect bytes-per-character for RSMD.getPrecision().
 
1575
      
 
1576
12-02-04 - Version 3.1.5-gamma
 
1577
 
 
1578
        - Fix comparisons made between string constants and dynamic strings that
 
1579
          are either toUpperCase()d or toLowerCase()d to use Locale.ENGLISH, as 
 
1580
          some locales 'override' case rules for English. Also use 
 
1581
          StringUtils.indexOfIgnoreCase() instead of .toUpperCase().indexOf(), 
 
1582
          avoids creating a very short-lived transient String instance.
 
1583
        
 
1584
        - Fixed BUG#5235 - Server-side prepared statements did not honor
 
1585
      'zeroDateTimeBehavior' property, and would cause class-cast
 
1586
      exceptions when using ResultSet.getObject(), as the all-zero string
 
1587
      was always returned.
 
1588
      
 
1589
    - Fixed batched updates with server prepared statements weren't looking if
 
1590
      the types had changed for a given batched set of parameters compared
 
1591
      to the previous set, causing the server to return the error 
 
1592
      'Wrong arguments to mysql_stmt_execute()'.
 
1593
      
 
1594
    - Handle case when string representation of timestamp contains trailing '.'
 
1595
      with no numbers following it.
 
1596
      
 
1597
    - Fixed BUG#5706 - Inefficient detection of pre-existing string instances
 
1598
      in ResultSet.getNativeString().
 
1599
      
 
1600
    - Don't throw exceptions for Connection.releaseSavepoint().
 
1601
    
 
1602
    - Use a per-session Calendar instance by default when decoding dates
 
1603
      from ServerPreparedStatements (set to old, less performant behavior by 
 
1604
      setting property 'dynamicCalendars=true').
 
1605
      
 
1606
    - Added experimental configuration property 'dontUnpackBinaryResults', 
 
1607
      which delays unpacking binary result set values until they're asked for, 
 
1608
      and only creates object instances for non-numerical values (it is set 
 
1609
      to 'false' by default). For some usecase/jvm combinations, this is 
 
1610
      friendlier on the garbage collector.
 
1611
      
 
1612
    - Fixed BUG#5729 - UNSIGNED BIGINT unpacked incorrectly from
 
1613
      server-side prepared statement result sets.
 
1614
      
 
1615
    - Fixed BUG#6225 - ServerSidePreparedStatement allocating short-lived
 
1616
      objects un-necessarily.
 
1617
      
 
1618
    - Removed un-wanted new Throwable() in ResultSet constructor due to bad
 
1619
      merge (caused a new object instance that was never used for every result
 
1620
      set created) - Found while profiling for BUG#6359.
 
1621
      
 
1622
    - Fixed too-early creation of StringBuffer in EscapeProcessor.escapeSQL(),
 
1623
      also return String when escaping not needed (to avoid unnecssary object
 
1624
      allocations). Found while profiling for BUG#6359.
 
1625
      
 
1626
    - Use null-safe-equals for key comparisons in updatable result sets.
 
1627
    
 
1628
    - Fixed BUG#6537, SUM() on Decimal with server-side prepared statement ignores
 
1629
      scale if zero-padding is needed (this ends up being due to conversion to DOUBLE
 
1630
      by server, which when converted to a string to parse into BigDecimal, loses all
 
1631
      'padding' zeros).
 
1632
 
 
1633
    - Use DatabaseMetaData.getIdentifierQuoteString() when building DBMD
 
1634
      queries.
 
1635
      
 
1636
    - Use 1MB packet for sending file for LOAD DATA LOCAL INFILE if that
 
1637
      is < 'max_allowed_packet' on server.
 
1638
      
 
1639
    - Fixed BUG#6399, ResultSetMetaData.getColumnDisplaySize() returns incorrect
 
1640
      values for multibyte charsets.
 
1641
      
 
1642
    - Make auto-deserialization of java.lang.Objects stored in BLOBs 
 
1643
      configurable via 'autoDeserialize' property (defaults to 'false').
 
1644
      
 
1645
    - Re-work Field.isOpaqueBinary() to detect 'CHAR(n) CHARACTER SET BINARY'
 
1646
      to support fixed-length binary fields for ResultSet.getObject().
 
1647
      
 
1648
    - Use our own implementation of buffered input streams to get around 
 
1649
      blocking behavior of java.io.BufferedInputStream. Disable this with
 
1650
      'useReadAheadInput=false'.
 
1651
    
 
1652
    - Fixed BUG#6348, failing to connect to the server when one of the
 
1653
      addresses for the given host name is IPV6 (which the server does
 
1654
      not yet bind on). The driver now loops through _all_ IP addresses
 
1655
      for a given host, and stops on the first one that accepts() a 
 
1656
      socket.connect().
 
1657
      
 
1658
09-04-04 - Version 3.1.4-beta
 
1659
 
 
1660
    - Fixed BUG#4510 - connector/j 3.1.3 beta does not handle integers 
 
1661
      correctly (caused by changes to support unsigned reads in
 
1662
      Buffer.readInt() -> Buffer.readShort()).
 
1663
    
 
1664
    - Added support in DatabaseMetaData.getTables() and getTableTypes() 
 
1665
      for VIEWs which are now available in MySQL server version 5.0.x.
 
1666
    
 
1667
    - Fixed BUG#4642 -- ServerPreparedStatement.execute*() sometimes
 
1668
      threw ArrayIndexOutOfBoundsException when unpacking field metadata.
 
1669
    
 
1670
    - Optimized integer number parsing, enable 'old' slower integer parsing 
 
1671
      using JDK classes via 'useFastIntParsing=false' property.
 
1672
    
 
1673
    - Added 'useOnlyServerErrorMessages' property, which causes message text
 
1674
      in exceptions generated by the server to only contain the text sent by
 
1675
      the server (as opposed to the SQLState's 'standard' description, followed
 
1676
      by the server's error message). This property is set to 'true' by default.
 
1677
    
 
1678
    - Fixed BUG#4689 - ResultSet.wasNull() does not work for primatives if a 
 
1679
      previous null was returned.
 
1680
    
 
1681
    - Track packet sequence numbers if enablePacketDebug=true, and throw an
 
1682
      exception if packets received out-of-order.
 
1683
    
 
1684
    - Fixed BUG#4482, ResultSet.getObject() returns wrong type for strings
 
1685
      when using prepared statements.
 
1686
    
 
1687
    - Calling MysqlPooledConnection.close() twice (even though an application
 
1688
      error), caused NPE. Fixed.
 
1689
    
 
1690
    - Fixed BUG#5012 -- ServerPreparedStatements dealing with return of 
 
1691
          DECIMAL type don't work.
 
1692
          
 
1693
        - Fixed BUG#5032 -- ResultSet.getObject() doesn't return 
 
1694
      type Boolean for pseudo-bit types from prepared statements on 4.1.x
 
1695
      (shortcut for avoiding extra type conversion when using binary-encoded
 
1696
      result sets obscurred test in getObject() for 'pseudo' bit type)
 
1697
      
 
1698
    - You can now use URLs in 'LOAD DATA LOCAL INFILE' statements, and the
 
1699
      driver will use Java's built-in handlers for retreiving the data and
 
1700
      sending it to the server. This feature is not enabled by default, 
 
1701
      you must set the 'allowUrlInLocalInfile' connection property to 'true'.
 
1702
      
 
1703
    - The driver is more strict about truncation of numerics on 
 
1704
      ResultSet.get*(), and will throw a SQLException when truncation is
 
1705
      detected. You can disable this by setting 'jdbcCompliantTruncation' to
 
1706
      false (it is enabled by default, as this functionality is required
 
1707
      for JDBC compliance).
 
1708
      
 
1709
    - Added three ways to deal with all-zero datetimes when reading them from
 
1710
      a ResultSet, 'exception' (the default), which throws a SQLException 
 
1711
      with a SQLState of 'S1009', 'convertToNull', which returns NULL instead of
 
1712
      the date, and 'round', which rounds the date to the nearest closest value
 
1713
      which is '0001-01-01'.
 
1714
      
 
1715
    - Fixed ServerPreparedStatement to read prepared statement metadata off 
 
1716
      the wire, even though it's currently a placeholder instead of using
 
1717
      MysqlIO.clearInputStream() which didn't work at various times because
 
1718
      data wasn't available to read from the server yet. This fixes sporadic
 
1719
      errors users were having with ServerPreparedStatements throwing 
 
1720
      ArrayIndexOutOfBoundExceptions.
 
1721
     
 
1722
    - Use com.mysql.jdbc.Message's classloader when loading resource bundle,
 
1723
      should fix sporadic issues when the caller's classloader can't locate
 
1724
      the resource bundle.
 
1725
 
 
1726
07-07-04 - Version 3.1.3-beta
 
1727
        
 
1728
        - Mangle output parameter names for CallableStatements so they 
 
1729
          will not clash with user variable names.
 
1730
          
 
1731
        - Added support for INOUT parameters in CallableStatements.
 
1732
        
 
1733
        - Fix for BUG#4119, null bitmask sent for server-side prepared
 
1734
          statements was incorrect.
 
1735
          
 
1736
        - Use SQL Standard SQL states by default, unless 'useSqlStateCodes' 
 
1737
          property is set to 'false'.
 
1738
          
 
1739
        - Added packet debuging code (see the 'enablePacketDebug' property
 
1740
          documentation).
 
1741
          
 
1742
        - Added constants for MySQL error numbers (publicly-accessible,
 
1743
          see com.mysql.jdbc.MysqlErrorNumbers), and the ability to
 
1744
          generate the mappings of vendor error codes to SQLStates
 
1745
          that the driver uses (for documentation purposes).
 
1746
          
 
1747
        - Externalized more messages (on-going effort).
 
1748
        
 
1749
        - Fix for BUG#4311 - Error in retrieval of mediumint column with
 
1750
          prepared statements and binary protocol.
 
1751
          
 
1752
        - Support new timezone variables in MySQL-4.1.3 when 
 
1753
          'useTimezone=true'
 
1754
          
 
1755
        - Support for unsigned numerics as return types from prepared statements.
 
1756
          This also causes a change in ResultSet.getObject() for the 'bigint unsigned'
 
1757
          type, which used to return BigDecimal instances, it now returns instances
 
1758
          of java.lang.BigInteger.
 
1759
           
 
1760
06-09-04 - Version 3.1.2-alpha
 
1761
 
 
1762
        - Fixed stored procedure parameter parsing info when size was
 
1763
          specified for a parameter (i.e. char(), varchar()).
 
1764
          
 
1765
        - Enabled callable statement caching via 'cacheCallableStmts'
 
1766
          property.
 
1767
          
 
1768
        - Fixed case when no output parameters specified for a 
 
1769
          stored procedure caused a bogus query to be issued 
 
1770
          to retrieve out parameters, leading to a syntax error
 
1771
          from the server.
 
1772
          
 
1773
        - Fixed case when no parameters could cause a NullPointerException
 
1774
          in CallableStatement.setOutputParameters().
 
1775
                  
 
1776
        - Removed wrapping of exceptions in MysqlIO.changeUser().
 
1777
        
 
1778
        - Fixed sending of split packets for large queries, enabled nio
 
1779
          ability to send large packets as well.
 
1780
          
 
1781
        - Added .toString() functionality to ServerPreparedStatement,
 
1782
          which should help if you're trying to debug a query that is
 
1783
          a prepared statement (it shows SQL as the server would process).
 
1784
          
 
1785
        - Added 'gatherPerformanceMetrics' property, along with properties
 
1786
          to control when/where this info gets logged (see docs for more 
 
1787
          info).
 
1788
          
 
1789
        - ServerPreparedStatements weren't actually de-allocating
 
1790
          server-side resources when .close() was called.
 
1791
          
 
1792
        - Added 'logSlowQueries' property, along with property 
 
1793
          'slowQueriesThresholdMillis' to control when a query should
 
1794
          be considered 'slow'.
 
1795
          
 
1796
        - Correctly map output parameters to position given in
 
1797
          prepareCall() vs. order implied during registerOutParameter() -
 
1798
          fixes BUG#3146.
 
1799
          
 
1800
        - Correctly detect initial character set for servers >= 4.1.0
 
1801
        
 
1802
        - Cleaned up detection of server properties. 
 
1803
        
 
1804
        - Support placeholder for parameter metadata for server >= 4.1.2
 
1805
        
 
1806
        - Fix for BUG#3539 getProcedures() does not return any procedures in 
 
1807
          result set
 
1808
        
 
1809
        - Fix for BUG#3540 getProcedureColumns() doesn't work with wildcards 
 
1810
          for procedure name
 
1811
          
 
1812
        - Fixed BUG#3520 -- DBMD.getSQLStateType() returns incorrect value.
 
1813
        
 
1814
        - Added 'connectionCollation' property to cause driver to issue 
 
1815
          'set collation_connection=...' query on connection init if default
 
1816
          collation for given charset is not appropriate.
 
1817
          
 
1818
        - Fixed DatabaseMetaData.getProcedures() when run on MySQL-5.0.0 (output of
 
1819
        'show procedure status' changed between 5.0.1 and 5.0.0.
 
1820
        
 
1821
        - Fixed BUG#3804 -- getWarnings() returns SQLWarning instead of DataTruncation
 
1822
        
 
1823
        - Don't enable server-side prepared statements for server version 5.0.0 or 5.0.1,
 
1824
        as they aren't compatible with the '4.1.2+' style that the driver uses (the driver
 
1825
        expects information to come back that isn't there, so it hangs).
 
1826
        
 
1827
          
 
1828
02-14-04 - Version 3.1.1-alpha
 
1829
 
 
1830
    - Fixed bug with UpdatableResultSets not using client-side
 
1831
          prepared statements.
 
1832
          
 
1833
        - Fixed character encoding issues when converting bytes to
 
1834
          ASCII when MySQL doesn't provide the character set, and
 
1835
          the JVM is set to a multibyte encoding (usually affecting
 
1836
          retrieval of numeric values).
 
1837
        
 
1838
        - Unpack 'unknown' data types from server prepared statements
 
1839
          as Strings.
 
1840
          
 
1841
        - Implemented long data (Blobs, Clobs, InputStreams, Readers)
 
1842
          for server prepared statements.
 
1843
          
 
1844
        - Implemented Statement.getWarnings() for MySQL-4.1 and newer
 
1845
          (using 'SHOW WARNINGS').
 
1846
        
 
1847
        - Default result set type changed to TYPE_FORWARD_ONLY
 
1848
          (JDBC compliance).
 
1849
          
 
1850
        - Centralized setting of result set type and concurrency.
 
1851
        
 
1852
        - Re-factored how connection properties are set and exposed
 
1853
          as DriverPropertyInfo as well as Connection and DataSource
 
1854
          properties.
 
1855
          
 
1856
        - Support for NIO. Use 'useNIO=true' on platforms that support
 
1857
          NIO.
 
1858
          
 
1859
        - Support for SAVEPOINTs (MySQL >= 4.0.14 or 4.1.1).
 
1860
        
 
1861
        - Support for mysql_change_user()...See the changeUser() method
 
1862
          in com.mysql.jdbc.Connection.
 
1863
          
 
1864
        - Reduced number of methods called in average query to be more
 
1865
          efficient.
 
1866
          
 
1867
        - Prepared Statements will be re-prepared on auto-reconnect. Any errors
 
1868
          encountered are postponed until first attempt to re-execute the
 
1869
          re-prepared statement.
 
1870
          
 
1871
        - Ensure that warnings are cleared before executing queries
 
1872
          on prepared statements, as-per JDBC spec (now that we support
 
1873
          warnings).
 
1874
         
 
1875
        - Support 'old' profileSql capitalization in ConnectionProperties.
 
1876
          This property is deprecated, you should use 'profileSQL' if possible.
 
1877
          
 
1878
        - Optimized Buffer.readLenByteArray() to return shared empty byte array 
 
1879
          when length is 0.
 
1880
         
 
1881
        - Allow contents of PreparedStatement.setBlob() to be retained
 
1882
          between calls to .execute*().
 
1883
          
 
1884
        - Deal with 0-length tokens in EscapeProcessor (caused by callable
 
1885
          statement escape syntax).
 
1886
          
 
1887
        - Check for closed connection on delete/update/insert row operations in 
 
1888
          UpdatableResultSet. 
 
1889
        
 
1890
        - Fix support for table aliases when checking for all primary keys in 
 
1891
          UpdatableResultSet.
 
1892
        
 
1893
        - Removed useFastDates connection property. 
 
1894
        
 
1895
        - Correctly initialize datasource properties from JNDI Refs, including 
 
1896
          explicitly specified URLs.
 
1897
          
 
1898
        - DatabaseMetaData now reports supportsStoredProcedures() for 
 
1899
          MySQL versions >= 5.0.0
 
1900
          
 
1901
        - Fixed stack overflow in Connection.prepareCall() (bad merge).
 
1902
        
 
1903
        - Fixed IllegalAccessError to Calendar.getTimeInMillis() in DateTimeValue
 
1904
          (for JDK < 1.4). 
 
1905
          
 
1906
        - Fix for BUG#1673, where DatabaseMetaData.getColumns() is not
 
1907
      returning correct column ordinal info for non '%' column name patterns.
 
1908
      
 
1909
    - Merged fix of datatype mapping from MySQL type 'FLOAT' to 
 
1910
      java.sql.Types.REAL from 3.0 branch.
 
1911
      
 
1912
    - Detect collation of column for RSMD.isCaseSensitive().
 
1913
    
 
1914
    - Fixed sending of queries > 16M.
 
1915
    
 
1916
    - Added named and indexed input/output parameter support to CallableStatement.
 
1917
      MySQL-5.0.x or newer.
 
1918
      
 
1919
    - Fixed NullPointerException in ServerPreparedStatement.setTimestamp(),
 
1920
      as well as year and month descrepencies in 
 
1921
      ServerPreparedStatement.setTimestamp(), setDate().
 
1922
      
 
1923
    - Added ability to have multiple database/JVM targets for compliance
 
1924
      and regression/unit tests in build.xml.
 
1925
      
 
1926
    - Fixed NPE and year/month bad conversions when accessing some 
 
1927
      datetime functionality in ServerPreparedStatements and their 
 
1928
      resultant result sets.
 
1929
      
 
1930
    - Display where/why a connection was implicitly closed (to
 
1931
      aid debugging).
 
1932
      
 
1933
    - CommunicationsException implemented, that tries to determine
 
1934
      why communications was lost with a server, and displays
 
1935
      possible reasons when .getMessage() is called.
 
1936
      
 
1937
    - Fixed BUG#2359, NULL values for numeric types in binary
 
1938
      encoded result sets causing NullPointerExceptions.
 
1939
      
 
1940
    - Implemented Connection.prepareCall(), and DatabaseMetaData.
 
1941
      getProcedures() and getProcedureColumns().
 
1942
      
 
1943
    - Reset 'long binary' parameters in ServerPreparedStatement when
 
1944
      clearParameters() is called, by sending COM_RESET_STMT to the 
 
1945
      server.
 
1946
      
 
1947
    - Merged prepared statement caching, and .getMetaData() support
 
1948
      from 3.0 branch.
 
1949
    
 
1950
    - Fixed off-by-1900 error in some cases for 
 
1951
      years in TimeUtil.fastDate/TimeCreate() when unpacking results
 
1952
      from server-side prepared statements.
 
1953
      
 
1954
    - Fixed BUG#2502 -- charset conversion issue in getTables().
 
1955
    
 
1956
    - Implemented multiple result sets returned from a statement 
 
1957
      or stored procedure.
 
1958
      
 
1959
    - Fixed BUG#2606 -- Server side prepared statements not returning
 
1960
      datatype 'YEAR' correctly.
 
1961
      
 
1962
    - Enabled streaming of result sets from server-side prepared
 
1963
      statements.
 
1964
      
 
1965
    - Fixed BUG#2623 -- Class-cast exception when using 
 
1966
      scrolling result sets and server-side prepared statements.
 
1967
          
 
1968
        - Merged unbuffered input code from 3.0.
 
1969
        
 
1970
        - Fixed ConnectionProperties that weren't properly exposed
 
1971
          via accessors, cleaned up ConnectionProperties code.
 
1972
          
 
1973
        - Fixed BUG#2671, NULL fields not being encoded correctly in
 
1974
          all cases in server side prepared statements.
 
1975
          
 
1976
        - Fixed rare buffer underflow when writing numbers into buffers
 
1977
          for sending prepared statement execution requests.
 
1978
          
 
1979
        - Use DocBook version of docs for shipped versions of drivers.
 
1980
        
 
1981
          
 
1982
02-18-03 - Version 3.1.0-alpha
 
1983
 
 
1984
    - Added 'requireSSL' property.
 
1985
    
 
1986
    - Added 'useServerPrepStmts' property (default 'false'). The
 
1987
      driver will use server-side prepared statements when the
 
1988
      server version supports them (4.1 and newer) when this
 
1989
      property is set to 'true'. It is currently set to 'false' 
 
1990
      by default until all bind/fetch functionality has been 
 
1991
      implemented. Currently only DML prepared statements are
 
1992
      implemented for 4.1 server-side prepared statements.
 
1993
  
 
1994
    - Track open Statements, close all when Connection.close()
 
1995
      is called (JDBC compliance).
 
1996
 
 
1997
06-22-05 - Version 3.0.17-ga
 
1998
    
 
1999
    - Fixed BUG#5874, Timestamp/Time conversion goes in the wrong 'direction' 
 
2000
      when useTimeZone='true' and server timezone differs from client timezone.
 
2001
        
 
2002
        - Fixed BUG#7081, DatabaseMetaData.getIndexInfo() ignoring 'unique' 
 
2003
          parameter.
 
2004
        
 
2005
        - Support new protocol type 'MYSQL_TYPE_VARCHAR'.
 
2006
        
 
2007
        - Added 'useOldUTF8Behavoior' configuration property, which causes
 
2008
          JDBC driver to act like it did with MySQL-4.0.x and earlier when
 
2009
          the character encoding is 'utf-8' when connected to MySQL-4.1 or 
 
2010
          newer.
 
2011
        
 
2012
        - Fixed BUG#7316 - Statements created from a pooled connection were
 
2013
          returning physical connection instead of logical connection when
 
2014
          getConnection() was called.
 
2015
          
 
2016
        - Fixed BUG#7033 - PreparedStatements don't encode Big5 (and other 
 
2017
          multibyte) character sets correctly in static SQL strings.
 
2018
          
 
2019
        - Fixed BUG#6966, connections starting up failed-over (due to down master)
 
2020
      never retry master.
 
2021
      
 
2022
    - Fixed BUG#7061, PreparedStatement.fixDecimalExponent() adding extra 
 
2023
      '+', making number unparseable by MySQL server.
 
2024
 
 
2025
    - Fixed BUG#7686, Timestamp key column data needed "_binary'" stripped for 
 
2026
      UpdatableResultSet.refreshRow().
 
2027
    
 
2028
    - Backported SQLState codes mapping from Connector/J 3.1, enable with
 
2029
      'useSqlStateCodes=true' as a connection property, it defaults to
 
2030
      'false' in this release, so that we don't break legacy applications (it
 
2031
      defaults to 'true' starting with Connector/J 3.1).
 
2032
      
 
2033
    - Fixed BUG#7601, PreparedStatement.fixDecimalExponent() adding extra 
 
2034
      '+', making number unparseable by MySQL server.
 
2035
      
 
2036
    - Escape sequence {fn convert(..., type)} now supports ODBC-style types
 
2037
      that are prepended by 'SQL_'.
 
2038
    
 
2039
    - Fixed duplicated code in configureClientCharset() that prevented
 
2040
      useOldUTF8Behavior=true from working properly.
 
2041
    
 
2042
    - Handle streaming result sets with > 2 billion rows properly by fixing
 
2043
      wraparound of row number counter.
 
2044
    
 
2045
    - Fixed BUG#7607 - MS932, SHIFT_JIS and Windows_31J not recog. as 
 
2046
      aliases for sjis.
 
2047
    
 
2048
    - Fixed BUG#6549 (while fixing #7607), adding 'CP943' to aliases for
 
2049
      sjis.
 
2050
    
 
2051
    - Fixed BUG#8064, which requires hex escaping of binary data when using
 
2052
      multibyte charsets with prepared statements.
 
2053
      
 
2054
    - Fixed BUG#8812, NON_UNIQUE column from DBMD.getIndexInfo() returned 
 
2055
      inverted value.
 
2056
      
 
2057
    - Workaround for server BUG#9098 - default values of CURRENT_* for 
 
2058
      DATE/TIME/TIMESTAMP/TIMESTAMP columns can't be distinguished from
 
2059
      'string' values, so UpdatableResultSet.moveToInsertRow() generates
 
2060
      bad SQL for inserting default values.
 
2061
      
 
2062
    - Fixed BUG#8629 - 'EUCKR' charset is sent as 'SET NAMES euc_kr' which
 
2063
      MySQL-4.1 and newer doesn't understand.
 
2064
      
 
2065
    - DatabaseMetaData.supportsSelectForUpdate() returns correct value based
 
2066
      on server version.
 
2067
      
 
2068
    - Use hex escapes for PreparedStatement.setBytes() for double-byte charsets
 
2069
      including 'aliases' Windows-31J, CP934, MS932.
 
2070
      
 
2071
    - Added support for the "EUC_JP_Solaris" character encoding, which maps
 
2072
      to a MySQL encoding of "eucjpms" (backported from 3.1 branch). This only
 
2073
      works on servers that support eucjpms, namely 5.0.3 or later.
 
2074
 
 
2075
11-15-04 - Version 3.0.16-ga
 
2076
 
 
2077
        - Re-issue character set configuration commands when re-using pooled
 
2078
          connections and/or Connection.changeUser() when connected to MySQL-4.1
 
2079
          or newer.
 
2080
          
 
2081
        - Fixed ResultSetMetaData.isReadOnly() to detect non-writable columns
 
2082
          when connected to MySQL-4.1 or newer, based on existence of 'original'
 
2083
          table and column names.
 
2084
          
 
2085
        - Fixed BUG#5664, ResultSet.updateByte() when on insert row
 
2086
      throws ArrayOutOfBoundsException.
 
2087
      
 
2088
    - Fixed DatabaseMetaData.getTypes() returning incorrect (i.e. non-negative)
 
2089
      scale for the 'NUMERIC' type.
 
2090
      
 
2091
    - Fixed BUG#6198, off-by-one bug in Buffer.readString(string).
 
2092
    
 
2093
    - Made TINYINT(1) -> BIT/Boolean conversion configurable via 'tinyInt1isBit'
 
2094
      property (default 'true' to be JDBC compliant out of the box).
 
2095
      
 
2096
    - Only set 'character_set_results' during connection establishment if
 
2097
      server version >= 4.1.1.
 
2098
      
 
2099
    - Fixed regression where useUnbufferedInput was defaulting to 'false'.
 
2100
    
 
2101
    - Fixed BUG#6231, ResultSet.getTimestamp() on a column with TIME in it
 
2102
      fails.
 
2103
      
 
2104
09-04-04 - Version 3.0.15-ga
 
2105
 
 
2106
        - Fixed BUG#4010 - StringUtils.escapeEasternUnicodeByteStream is still
 
2107
          broken for GBK
 
2108
          
 
2109
        - Fixed BUG#4334 - Failover for autoReconnect not using port #'s for any
 
2110
          hosts, and not retrying all hosts. (WARN: This required a change to 
 
2111
          the SocketFactory connect() method signature, which is now
 
2112
          
 
2113
            public Socket connect(String host, int portNumber, Properties props),
 
2114
          
 
2115
          therefore any third-party socket factories will have to be changed
 
2116
          to support this signature.
 
2117
          
 
2118
        - Logical connections created by MysqlConnectionPoolDataSource will
 
2119
          now issue a rollback() when they are closed and sent back to the pool.
 
2120
          If your application server/connection pool already does this for you, you 
 
2121
          can set the 'rollbackOnPooledClose' property to false to avoid the
 
2122
          overhead of an extra rollback().
 
2123
         
 
2124
        - Removed redundant calls to checkRowPos() in ResultSet.
 
2125
        
 
2126
        - Fixed BUG#4742, 'DOUBLE' mapped twice in DBMD.getTypeInfo().
 
2127
 
 
2128
        - Added FLOSS license exemption.
 
2129
        
 
2130
        - Fixed BUG#4808, calling .close() twice on a PooledConnection causes NPE.
 
2131
        
 
2132
        - Fixed BUG#4138 and BUG#4860, DBMD.getColumns() returns incorrect JDBC 
 
2133
          type for unsigned columns. This affects type mappings for all numeric 
 
2134
          types in the RSMD.getColumnType() and RSMD.getColumnTypeNames() methods 
 
2135
          as well, to ensure that 'like' types from DBMD.getColumns() match up 
 
2136
          with what RSMD.getColumnType() and getColumnTypeNames() return.
 
2137
          
 
2138
        - 'Production' - 'GA' in naming scheme of distributions.
 
2139
        
 
2140
        - Fix for BUG#4880, RSMD.getPrecision() returning 0 for non-numeric types
 
2141
          (should return max length in chars for non-binary types, max length
 
2142
          in bytes for binary types). This fix also fixes mapping of 
 
2143
          RSMD.getColumnType() and RSMD.getColumnTypeName() for the BLOB types based
 
2144
          on the length sent from the server (the server doesn't distinguish between
 
2145
          TINYBLOB, BLOB, MEDIUMBLOB or LONGBLOB at the network protocol level).
 
2146
          
 
2147
        - Fixed BUG#5022 - ResultSet should release Field[] instance in .close().
 
2148
               
 
2149
    - Fixed BUG#5069 -- ResultSet.getMetaData() should not return 
 
2150
          incorrectly-initialized metadata if the result set has been closed, but 
 
2151
          should instead throw a SQLException. Also fixed for getRow() and 
 
2152
          getWarnings() and traversal methods by calling checkClosed() before
 
2153
          operating on instance-level fields that are nullified during .close().
 
2154
          
 
2155
        - Parse new timezone variables from 4.1.x servers.
 
2156
        
 
2157
        - Use _binary introducer for PreparedStatement.setBytes() and 
 
2158
          set*Stream() when connected to MySQL-4.1.x or newer to avoid 
 
2159
          misinterpretation during character conversion.
 
2160
          
 
2161
05-28-04 - Version 3.0.14-production
 
2162
 
 
2163
        - Fixed URL parsing error
 
2164
        
 
2165
05-27-04 - Version 3.0.13-production
 
2166
 
 
2167
        - Fixed BUG#3848 - Using a MySQLDatasource without server name fails
 
2168
        
 
2169
        - Fixed BUG#3920 - "No Database Selected" when using 
 
2170
          MysqlConnectionPoolDataSource.
 
2171
          
 
2172
        - Fixed BUG#3873 - PreparedStatement.getGeneratedKeys() method returns only 
 
2173
          1 result for batched insertions
 
2174
          
 
2175
05-18-04 - Version 3.0.12-production
 
2176
 
 
2177
        - Add unsigned attribute to DatabaseMetaData.getColumns() output
 
2178
          in the TYPE_NAME column.
 
2179
          
 
2180
        - Added 'failOverReadOnly' property, to allow end-user to configure
 
2181
          state of connection (read-only/writable) when failed over.
 
2182
          
 
2183
        - Backported 'change user' and 'reset server state' functionality
 
2184
      from 3.1 branch, to allow clients of MysqlConnectionPoolDataSource
 
2185
      to reset server state on getConnection() on a pooled connection.
 
2186
      
 
2187
    - Don't escape SJIS/GBK/BIG5 when using MySQL-4.1 or newer.
 
2188
    
 
2189
    - Allow 'url' parameter for MysqlDataSource and MysqlConnectionPool
 
2190
      DataSource so that passing of other properties is possible from
 
2191
      inside appservers.
 
2192
      
 
2193
    - Map duplicate key and foreign key errors to SQLState of
 
2194
      '23000'.
 
2195
      
 
2196
    - Backport documentation tooling from 3.1 branch.
 
2197
    
 
2198
    - Return creating statement for ResultSets created by
 
2199
      getGeneratedKeys() (BUG#2957)
 
2200
      
 
2201
    - Allow java.util.Date to be sent in as parameter to
 
2202
      PreparedStatement.setObject(), converting it to a Timestamp
 
2203
      to maintain full precision (BUG#3103).
 
2204
      
 
2205
    - Don't truncate BLOBs/CLOBs when using setBytes() and/or
 
2206
      setBinary/CharacterStream() (BUG#2670).
 
2207
      
 
2208
    - Dynamically configure character set mappings for field-level
 
2209
      character sets on MySQL-4.1.0 and newer using 'SHOW COLLATION'
 
2210
      when connecting.
 
2211
      
 
2212
    - Map 'binary' character set to 'US-ASCII' to support DATETIME
 
2213
      charset recognition for servers >= 4.1.2
 
2214
      
 
2215
    - Use 'SET character_set_results" during initialization to allow any 
 
2216
      charset to be returned to the driver for result sets.
 
2217
      
 
2218
    - Use charsetnr returned during connect to encode queries before
 
2219
      issuing 'SET NAMES' on MySQL >= 4.1.0.
 
2220
      
 
2221
    - Add helper methods to ResultSetMetaData (getColumnCharacterEncoding()
 
2222
      and getColumnCharacterSet()) to allow end-users to see what charset
 
2223
      the driver thinks it should be using for the column.
 
2224
      
 
2225
    - Only set character_set_results for MySQL >= 4.1.0.
 
2226
    
 
2227
    - Fixed BUG#3511, StringUtils.escapeSJISByteStream() not covering all
 
2228
      eastern double-byte charsets correctly.
 
2229
      
 
2230
    - Renamed StringUtils.escapeSJISByteStream() to more appropriate
 
2231
      escapeEasternUnicodeByteStream().
 
2232
      
 
2233
    - Fixed BUG#3554 - Not specifying database in URL caused MalformedURL
 
2234
      exception.
 
2235
      
 
2236
    - Auto-convert MySQL encoding names to Java encoding names if used
 
2237
      for characterEncoding property.
 
2238
      
 
2239
    - Added encoding names that are recognized on some JVMs to fix case
 
2240
      where they were reverse-mapped to MySQL encoding names incorrectly.
 
2241
      
 
2242
    - Use junit.textui.TestRunner for all unit tests (to allow them to be
 
2243
      run from the command line outside of Ant or Eclipse).
 
2244
      
 
2245
    - Fixed BUG#3557 - UpdatableResultSet not picking up default values
 
2246
      for moveToInsertRow().
 
2247
      
 
2248
    - Fixed BUG#3570 - inconsistent reporting of column type. The server
 
2249
      still doesn't return all types for *BLOBs *TEXT correctly, so the
 
2250
      driver won't return those correctly.
 
2251
      
 
2252
    - Fixed BUG#3520 -- DBMD.getSQLStateType() returns incorrect value.
 
2253
    
 
2254
    - Fixed regression in PreparedStatement.setString() and eastern character
 
2255
      encodings.
 
2256
      
 
2257
    - Made StringRegressionTest 4.1-unicode aware.
 
2258
 
 
2259
02-19-04 - Version 3.0.11-stable
 
2260
 
 
2261
        - Trigger a 'SET NAMES utf8' when encoding is forced to 'utf8' _or_
 
2262
          'utf-8' via the 'characterEncoding' property. Previously, only the
 
2263
          Java-style encoding name of 'utf-8' would trigger this.
 
2264
          
 
2265
        - AutoReconnect time was growing faster than exponentially (BUG#2447).
 
2266
        
 
2267
        - Fixed failover always going to last host in list (BUG#2578)
 
2268
        
 
2269
        - Added 'useUnbufferedInput' parameter, and now use it by default
 
2270
          (due to JVM issue 
 
2271
          http://developer.java.sun.com/developer/bugParade/bugs/4401235.html)
 
2272
          
 
2273
        - Detect 'on/off' or '1','2','3' form of lower_case_table_names on 
 
2274
          server.
 
2275
          
 
2276
        - Return 'java.lang.Integer' for TINYINT and SMALLINT types from
 
2277
          ResultSetMetaData.getColumnClassName() (fix for BUG#2852).
 
2278
          
 
2279
        - Return 'java.lang.Double' for FLOAT type from ResultSetMetaData.
 
2280
          getColumnClassName() (fix for BUG#2855).
 
2281
          
 
2282
        - Return '[B' instead of java.lang.Object for BINARY, VARBINARY and 
 
2283
          LONGVARBINARY types from ResultSetMetaData.getColumnClassName() 
 
2284
          (JDBC compliance).
 
2285
          
 
2286
01-13-04 - Version 3.0.10-stable
 
2287
 
 
2288
    - Don't count quoted id's when inside a 'string' in PreparedStatement
 
2289
      parsing (fix for BUG#1511).
 
2290
      
 
2291
    - 'Friendlier' exception message for PacketTooLargeException
 
2292
       (BUG#1534).
 
2293
       
 
2294
    - Backported fix for aliased tables and UpdatableResultSets in 
 
2295
      checkUpdatability() method from 3.1 branch.
 
2296
      
 
2297
    - Fix for ArrayIndexOutOfBounds exception when using Statement.setMaxRows()
 
2298
      (BUG#1695).
 
2299
      
 
2300
    - Fixed BUG#1576, dealing with large blobs and split packets not being 
 
2301
      read correctly.
 
2302
      
 
2303
    - Fixed regression of Statement.getGeneratedKeys() and REPLACE statements.
 
2304
    
 
2305
    - Fixed BUG#1630, subsequent call to ResultSet.updateFoo() causes NPE if
 
2306
      result set is not updatable.
 
2307
      
 
2308
    - Fix for 4.1.1-style auth with no password.
 
2309
    
 
2310
    - Fix for BUG#1731, Foreign Keys column sequence is not consistent in
 
2311
      DatabaseMetaData.getImported/Exported/CrossReference().
 
2312
      
 
2313
    - Fix for BUG#1775 - DatabaseMetaData.getSystemFunction() returning 
 
2314
      bad function 'VResultsSion'.
 
2315
      
 
2316
    - Fix for BUG#1592 -- cross-database updatable result sets
 
2317
      are not checked for updatability correctly.
 
2318
      
 
2319
    - DatabaseMetaData.getColumns() should return Types.LONGVARCHAR for
 
2320
      MySQL LONGTEXT type.
 
2321
      
 
2322
    - ResultSet.getObject() on TINYINT and SMALLINT columns should return 
 
2323
      Java type 'Integer' (BUG#1913)
 
2324
      
 
2325
    - Added 'alwaysClearStream' connection property, which causes the driver
 
2326
      to always empty any remaining data on the input stream before
 
2327
      each query.
 
2328
      
 
2329
    - Added more descriptive error message 'Server Configuration Denies 
 
2330
      Access to DataSource', as well as retrieval of message from server.
 
2331
      
 
2332
    - Autoreconnect code didn't set catalog upon reconnect if it had been 
 
2333
      changed.
 
2334
      
 
2335
    - Implement ResultSet.updateClob().
 
2336
    
 
2337
    - ResultSetMetaData.isCaseSensitive() returned wrong value for CHAR/VARCHAR
 
2338
      columns.
 
2339
      
 
2340
    - Fix for BUG#1933 -- Connection property "maxRows" not honored.
 
2341
    
 
2342
    - Fix for BUG#1925 -- Statements being created too many times in 
 
2343
      DBMD.extractForeignKeyFromCreateTable().
 
2344
      
 
2345
    - Fix for BUG#1914 -- Support escape sequence {fn convert ... }
 
2346
    
 
2347
    - Fix for BUG#1958 -- ArrayIndexOutOfBounds when parameter number == 
 
2348
      number of parameters + 1.
 
2349
      
 
2350
    - Fix for BUG#2006 -- ResultSet.findColumn() should use first matching
 
2351
      column name when there are duplicate column names in SELECT query 
 
2352
      (JDBC-compliance).
 
2353
      
 
2354
    - Removed static synchronization bottleneck from 
 
2355
      PreparedStatement.setTimestamp().
 
2356
      
 
2357
    - Removed static synchronization bottleneck from instance factory 
 
2358
      method of SingleByteCharsetConverter.
 
2359
      
 
2360
    - Enable caching of the parsing stage of prepared statements via 
 
2361
      the 'cachePrepStmts', 'prepStmtCacheSize' and 'prepStmtCacheSqlLimit'
 
2362
      properties (disabled by default).
 
2363
      
 
2364
    - Speed up parsing of PreparedStatements, try to use one-pass whenever
 
2365
      possible.
 
2366
      
 
2367
    - Fixed security exception when used in Applets (applets can't
 
2368
      read the system property 'file.encoding' which is needed
 
2369
      for LOAD DATA LOCAL INFILE).
 
2370
      
 
2371
    - Use constants for SQLStates.
 
2372
    
 
2373
    - Map charset 'ko18_ru' to 'ko18r' when connected to MySQL-4.1.0 or
 
2374
      newer.
 
2375
      
 
2376
    - Ensure that Buffer.writeString() saves room for the \0.
 
2377
    
 
2378
    - Fixed exception 'Unknown character set 'danish' on connect w/ JDK-1.4.0
 
2379
    
 
2380
    - Fixed mappings in SQLError to report deadlocks with SQLStates of '41000'.
 
2381
    
 
2382
    - 'maxRows' property would affect internal statements, so check it for all 
 
2383
      statement creation internal to the driver, and set to 0 when it is not.
 
2384
    
 
2385
10-07-03 - Version 3.0.9-stable
 
2386
 
 
2387
        - Faster date handling code in ResultSet and PreparedStatement (no longer
 
2388
          uses Date methods that synchronize on static calendars).
 
2389
        
 
2390
        - Fixed test for end of buffer in Buffer.readString().
 
2391
        
 
2392
        - Fixed ResultSet.previous() behavior to move current 
 
2393
          position to before result set when on first row
 
2394
          of result set (bugs.mysql.com BUG#496)
 
2395
        
 
2396
        - Fixed Statement and PreparedStatement issuing bogus queries
 
2397
          when setMaxRows() had been used and a LIMIT clause was present
 
2398
          in the query.
 
2399
        
 
2400
        - Fixed BUG#661 - refreshRow didn't work when primary key values
 
2401
          contained values that needed to be escaped (they ended up being
 
2402
          doubly-escaped).
 
2403
        
 
2404
        - Support InnoDB contraint names when extracting foreign key info
 
2405
          in DatabaseMetaData BUG#517 and BUG#664
 
2406
          (impl. ideas from Parwinder Sekhon)
 
2407
        
 
2408
        - Backported 4.1 protocol changes from 3.1 branch (server-side SQL
 
2409
          states, new field info, larger client capability flags, 
 
2410
          connect-with-database, etc).
 
2411
        
 
2412
        - Fix UpdatableResultSet to return values for getXXX() when on
 
2413
          insert row (BUG#675).
 
2414
        
 
2415
        - The insertRow in an UpdatableResultSet is now loaded with 
 
2416
          the default column values when moveToInsertRow() is called
 
2417
          (BUG#688)
 
2418
        
 
2419
        - DatabaseMetaData.getColumns() wasn't returning NULL for 
 
2420
          default values that are specified as NULL.
 
2421
        
 
2422
        - Change default statement type/concurrency to TYPE_FORWARD_ONLY
 
2423
          and CONCUR_READ_ONLY (spec compliance).
 
2424
        
 
2425
        - Don't try and reset isolation level on reconnect if MySQL doesn't
 
2426
          support them.
 
2427
        
 
2428
        - Don't wrap SQLExceptions in RowDataDynamic.
 
2429
        
 
2430
        - Don't change timestamp TZ twice if useTimezone==true (BUG#774)
 
2431
        
 
2432
        - Fixed regression in large split-packet handling (BUG#848).
 
2433
        
 
2434
        - Better diagnostic error messages in exceptions for 'streaming'
 
2435
          result sets.
 
2436
        
 
2437
        - Issue exception on ResultSet.getXXX() on empty result set (wasn't
 
2438
          caught in some cases).
 
2439
        
 
2440
        - Don't hide messages from exceptions thrown in I/O layers.
 
2441
        
 
2442
        - Don't fire connection closed events when closing pooled connections, or
 
2443
          on PooledConnection.getConnection() with already open connections (BUG#884).
 
2444
        
 
2445
        - Clip +/- INF (to smallest and largest representative values for the type in 
 
2446
          MySQL) and NaN (to 0) for setDouble/setFloat(), and issue a warning on the
 
2447
          statement when the server does not support +/- INF or NaN.
 
2448
          
 
2449
        - Fix for BUG#879, double-escaping of '\' when charset is SJIS or GBK and '\'
 
2450
          appears in non-escaped input.
 
2451
          
 
2452
        - When emptying input stream of unused rows for 'streaming' result sets,
 
2453
          have the current thread yield() every 100 rows in order to not monopolize 
 
2454
          CPU time.
 
2455
          
 
2456
        - Fixed BUG#1099, DatabaseMetaData.getColumns() getting confused about the
 
2457
          keyword 'set' in character columns.
 
2458
          
 
2459
        - Fixed deadlock issue with Statement.setMaxRows().
 
2460
        
 
2461
        - Fixed CLOB.truncate(), BUG#1130
 
2462
        
 
2463
        - Optimized CLOB.setChracterStream(), BUG#1131
 
2464
        
 
2465
        - Made databaseName, portNumber and serverName optional parameters
 
2466
          for MysqlDataSourceFactory (BUG#1246)
 
2467
          
 
2468
        - Fix for BUG#1247 -- ResultSet.get/setString mashing char 127
 
2469
        
 
2470
        - Backported auth. changes for 4.1.1 and newer from 3.1 branch. 
 
2471
        
 
2472
        - Added com.mysql.jdbc.util.BaseBugReport to help creation of testcases
 
2473
          for bug reports.
 
2474
          
 
2475
        - Added property to 'clobber' streaming results, by setting the 
 
2476
          'clobberStreamingResults' property to 'true' (the default is 'false'). 
 
2477
          This will cause a 'streaming' ResultSet to be automatically
 
2478
          closed, and any oustanding data still streaming from the server to
 
2479
          be discarded if another query is executed before all the data has been
 
2480
          read from the server.
 
2481
       
 
2482
05-23-03 - Version 3.0.8-stable
 
2483
 
 
2484
        - Allow bogus URLs in Driver.getPropertyInfo().
 
2485
        
 
2486
        - Return list of generated keys when using multi-value INSERTS
 
2487
          with Statement.getGeneratedKeys().
 
2488
          
 
2489
        - Use JVM charset with filenames and 'LOAD DATA [LOCAL] INFILE'
 
2490
        
 
2491
        - Fix infinite loop with Connection.cleanup().
 
2492
        
 
2493
        - Changed Ant target 'compile-core' to 'compile-driver', and 
 
2494
          made testsuite compilation a separate target.
 
2495
          
 
2496
        - Fixed result set not getting set for Statement.executeUpdate(),
 
2497
          which affected getGeneratedKeys() and getUpdateCount() in
 
2498
          some cases.
 
2499
          
 
2500
        - Unicode character 0xFFFF in a string would cause the driver to
 
2501
          throw an ArrayOutOfBoundsException (Bug #378)
 
2502
          
 
2503
        - Return correct amount of generated keys when using 'REPLACE' 
 
2504
          statements.
 
2505
          
 
2506
        - Fix problem detecting server character set in some cases.
 
2507
        
 
2508
        - Fix row data decoding error when using _very_ large packets.
 
2509
        
 
2510
        - Optimized row data decoding.
 
2511
        
 
2512
        - Issue exception when operating on an already-closed
 
2513
          prepared statement.
 
2514
          
 
2515
        - Fixed SJIS encoding bug, thanks to Naoto Sato.
 
2516
        
 
2517
    - Optimized usage of EscapeProcessor.
 
2518
    
 
2519
    - Allow multiple calls to Statement.close()
 
2520
        
 
2521
04-08-03 - Version 3.0.7-stable
 
2522
 
 
2523
    - Fixed MysqlPooledConnection.close() calling wrong event type.
 
2524
    
 
2525
    - Fixed StringIndexOutOfBoundsException in PreparedStatement.
 
2526
      setClob().
 
2527
      
 
2528
    - 4.1 Column Metadata fixes
 
2529
    
 
2530
    - Remove synchronization from Driver.connect() and 
 
2531
      Driver.acceptsUrl().
 
2532
      
 
2533
    - IOExceptions during a transaction now cause the Connection to 
 
2534
      be closed.
 
2535
      
 
2536
    - Fixed missing conversion for 'YEAR' type in ResultSetMetaData.
 
2537
      getColumnTypeName().
 
2538
      
 
2539
    - Don't pick up indexes that start with 'pri' as primary keys
 
2540
      for DBMD.getPrimaryKeys().
 
2541
      
 
2542
    - Throw SQLExceptions when trying to do operations on a forcefully
 
2543
      closed Connection (i.e. when a communication link failure occurs).
 
2544
      
 
2545
    - You can now toggle profiling on/off using 
 
2546
      Connection.setProfileSql(boolean).
 
2547
      
 
2548
    - Fixed charset issues with database metadata (charset was not
 
2549
      getting set correctly).
 
2550
      
 
2551
    - Updatable ResultSets can now be created for aliased tables/columns
 
2552
      when connected to MySQL-4.1 or newer.
 
2553
      
 
2554
    - Fixed 'LOAD DATA LOCAL INFILE' bug when file > max_allowed_packet.
 
2555
    
 
2556
    - Fixed escaping of 0x5c ('\') character for GBK and Big5 charsets.
 
2557
    
 
2558
    - Fixed ResultSet.getTimestamp() when underlying field is of type DATE.
 
2559
    
 
2560
    - Ensure that packet size from alignPacketSize() does not
 
2561
      exceed MAX_ALLOWED_PACKET (JVM bug)
 
2562
      
 
2563
    - Don't reset Connection.isReadOnly() when autoReconnecting.
 
2564
      
 
2565
02-18-03 - Version 3.0.6-stable
 
2566
 
 
2567
    - Fixed ResultSetMetaData to return "" when catalog not known.
 
2568
      Fixes NullPointerExceptions with Sun's CachedRowSet.
 
2569
      
 
2570
    - Fixed DBMD.getTypeInfo() and DBMD.getColumns() returning 
 
2571
      different value for precision in TEXT/BLOB types.
 
2572
      
 
2573
    - Allow ignoring of warning for 'non transactional tables' during
 
2574
      rollback (compliance/usability) by setting 'ignoreNonTxTables'
 
2575
      property to 'true'.
 
2576
      
 
2577
    - Fixed SQLExceptions getting swallowed on initial connect.
 
2578
    
 
2579
    - Fixed Statement.setMaxRows() to stop sending 'LIMIT' type queries
 
2580
      when not needed (performance)
 
2581
      
 
2582
    - Clean up Statement query/method mismatch tests (i.e. INSERT not
 
2583
      allowed with .executeQuery()).
 
2584
      
 
2585
    - More checks added in ResultSet traversal method to catch
 
2586
      when in closed state.
 
2587
      
 
2588
    - Fixed ResultSetMetaData.isWritable() to return correct value.
 
2589
    
 
2590
    - Add 'window' of different NULL sorting behavior to 
 
2591
      DBMD.nullsAreSortedAtStart (4.0.2 to 4.0.10, true, otherwise,
 
2592
      no).
 
2593
      
 
2594
    - Implemented Blob.setBytes(). You still need to pass the 
 
2595
      resultant Blob back into an updatable ResultSet or
 
2596
      PreparedStatement to persist the changes, as MySQL does
 
2597
      not support 'locators'.
 
2598
      
 
2599
    - Backported 4.1 charset field info changes from Connector/J 3.1
 
2600
      
 
2601
01-22-03 - Version 3.0.5-gamma
 
2602
 
 
2603
    - Fixed Buffer.fastSkipLenString() causing ArrayIndexOutOfBounds
 
2604
      exceptions with some queries when unpacking fields.
 
2605
      
 
2606
    - Implemented an empty TypeMap for Connection.getTypeMap() so that
 
2607
      some third-party apps work with MySQL (IBM WebSphere 5.0 Connection
 
2608
      pool).
 
2609
      
 
2610
    - Added missing LONGTEXT type to DBMD.getColumns().
 
2611
    
 
2612
    - Retrieve TX_ISOLATION from database for 
 
2613
      Connection.getTransactionIsolation() when the MySQL version 
 
2614
      supports it, instead of an instance variable.
 
2615
      
 
2616
    - Quote table names in DatabaseMetaData.getColumns(),
 
2617
      getPrimaryKeys(), getIndexInfo(), getBestRowIdentifier()
 
2618
      
 
2619
    - Greatly reduce memory required for setBinaryStream() in
 
2620
      PreparedStatements.
 
2621
      
 
2622
    - Fixed ResultSet.isBeforeFirst() for empty result sets.
 
2623
    
 
2624
    - Added update options for foreign key metadata.
 
2625
    
 
2626
      
 
2627
01-06-03 - Version 3.0.4-gamma
 
2628
 
 
2629
    - Added quoted identifiers to database names for 
 
2630
      Connection.setCatalog.
 
2631
      
 
2632
    - Added support for quoted identifiers in PreparedStatement
 
2633
      parser.
 
2634
      
 
2635
    - Streamlined character conversion and byte[] handling in 
 
2636
      PreparedStatements for setByte().
 
2637
      
 
2638
    - Reduce memory footprint of PreparedStatements by sharing 
 
2639
      outbound packet with MysqlIO.
 
2640
      
 
2641
    - Added 'strictUpdates' property to allow control of amount
 
2642
      of checking for 'correctness' of updatable result sets. Set this
 
2643
      to 'false' if you want faster updatable result sets and you know
 
2644
      that you create them from SELECTs on tables with primary keys and
 
2645
      that you have selected all primary keys in your query.
 
2646
      
 
2647
    - Added support for 4.0.8-style large packets. 
 
2648
    
 
2649
    - Fixed PreparedStatement.executeBatch() parameter overwriting.
 
2650
          
 
2651
12-17-02 - Version 3.0.3-dev
 
2652
 
 
2653
    - Changed charsToByte in SingleByteCharConverter to be non-static
 
2654
    
 
2655
    - Changed SingleByteCharConverter to use lazy initialization of each
 
2656
      converter.
 
2657
      
 
2658
    - Fixed charset handling in Fields.java
 
2659
    
 
2660
    - Implemented Connection.nativeSQL()
 
2661
    
 
2662
    - More robust escape tokenizer -- recognize '--' comments, and allow
 
2663
      nested escape sequences (see testsuite.EscapeProcessingTest)
 
2664
      
 
2665
    - DBMD.getImported/ExportedKeys() now handles multiple foreign keys 
 
2666
      per table.
 
2667
      
 
2668
    - Fixed ResultSetMetaData.getPrecision() returning incorrect values 
 
2669
      for some floating point types.
 
2670
      
 
2671
    - Fixed ResultSetMetaData.getColumnTypeName() returning BLOB for 
 
2672
      TEXT and TEXT for BLOB types.
 
2673
      
 
2674
    - Fixed Buffer.isLastDataPacket() for 4.1 and newer servers.
 
2675
    
 
2676
    - Added CLIENT_LONG_FLAG to be able to get more column flags 
 
2677
      (isAutoIncrement() being the most important)
 
2678
      
 
2679
    - Because of above, implemented ResultSetMetaData.isAutoIncrement()
 
2680
      to use Field.isAutoIncrement().
 
2681
      
 
2682
    - Honor 'lower_case_table_names' when enabled in the server when
 
2683
      doing table name comparisons in DatabaseMetaData methods.
 
2684
      
 
2685
    - Some MySQL-4.1 protocol support (extended field info from selects)
 
2686
    
 
2687
    - Use non-aliased table/column names and database names to fullly 
 
2688
      qualify tables and columns in UpdatableResultSet (requires 
 
2689
      MySQL-4.1 or newer)
 
2690
      
 
2691
    - Allow user to alter behavior of Statement/
 
2692
      PreparedStatement.executeBatch() via 'continueBatchOnError' property
 
2693
      (defaults to 'true').
 
2694
      
 
2695
    - Check for connection closed in more Connection methods 
 
2696
      (createStatement, prepareStatement, setTransactionIsolation,
 
2697
      setAutoCommit).
 
2698
      
 
2699
    - More robust implementation of updatable result sets. Checks that
 
2700
      _all_ primary keys of the table have been selected.
 
2701
      
 
2702
    - 'LOAD DATA LOCAL INFILE ...' now works, if your server is configured
 
2703
      to allow it. Can be turned off with the 'allowLoadLocalInfile' 
 
2704
      property (see the README).
 
2705
      
 
2706
    - Substitute '?' for unknown character conversions in single-byte
 
2707
      character sets instead of '\0'.
 
2708
      
 
2709
    - NamedPipeSocketFactory now works (only intended for Windows), see
 
2710
      README for instructions.
 
2711
          
 
2712
11-08-02 - Version 3.0.2-dev
 
2713
 
 
2714
    - Fixed issue with updatable result sets and PreparedStatements not 
 
2715
      working
 
2716
      
 
2717
    - Fixed ResultSet.setFetchDirection(FETCH_UNKNOWN)
 
2718
    
 
2719
    - Fixed issue when calling Statement.setFetchSize() when using 
 
2720
      arbitrary values
 
2721
      
 
2722
    - Fixed incorrect conversion in ResultSet.getLong()
 
2723
    
 
2724
    - Implemented ResultSet.updateBlob().
 
2725
    
 
2726
    - Removed duplicate code from UpdatableResultSet (it can be inherited 
 
2727
      from ResultSet, the extra code for each method to handle updatability
 
2728
      I thought might someday be necessary has not been needed).
 
2729
      
 
2730
    - Fixed "UnsupportedEncodingException" thrown when "forcing" a 
 
2731
      character encoding via properties.
 
2732
      
 
2733
    - Fixed various non-ASCII character encoding issues.
 
2734
    
 
2735
    - Added driver property 'useHostsInPrivileges'. Defaults to true. 
 
2736
      Affects whether or not '@hostname' will be used in 
 
2737
      DBMD.getColumn/TablePrivileges.
 
2738
      
 
2739
    - All DBMD result set columns describing schemas now return NULL
 
2740
      to be more compliant with the behavior of other JDBC drivers
 
2741
      for other databases (MySQL does not support schemas).
 
2742
      
 
2743
    - Added SSL support. See README for information on how to use it.
 
2744
    
 
2745
    - Properly restore connection properties when autoReconnecting
 
2746
      or failing-over, including autoCommit state, and isolation level.
 
2747
      
 
2748
    - Use 'SHOW CREATE TABLE' when possible for determining foreign key
 
2749
      information for DatabaseMetaData...also allows cascade options for
 
2750
      DELETE information to be returned
 
2751
      
 
2752
    - Escape 0x5c character in strings for the SJIS charset.
 
2753
    
 
2754
    - Fixed start position off-by-1 error in Clob.getSubString()
 
2755
    
 
2756
    - Implemented Clob.truncate()
 
2757
    
 
2758
    - Implemented Clob.setString()
 
2759
    
 
2760
    - Implemented Clob.setAsciiStream()
 
2761
    
 
2762
    - Implemented Clob.setCharacterStream()
 
2763
    
 
2764
    - Added com.mysql.jdbc.MiniAdmin class, which allows you to send
 
2765
      'shutdown' command to MySQL server...Intended to be used when 'embedding'
 
2766
      Java and MySQL server together in an end-user application.
 
2767
      
 
2768
    - Added 'connectTimeout' parameter that allows users of JDK-1.4 and newer
 
2769
      to specify a maxium time to wait to establish a connection.
 
2770
      
 
2771
    - Failover and autoReconnect only work when the connection is in a 
 
2772
      autoCommit(false) state, in order to stay transaction safe
 
2773
      
 
2774
    - Added 'queriesBeforeRetryMaster' property that specifies how many
 
2775
      queries to issue when failed over before attempting to reconnect 
 
2776
      to the master (defaults to 50)
 
2777
      
 
2778
    - Fixed DBMD.supportsResultSetConcurrency() so that it returns true
 
2779
      for ResultSet.TYPE_SCROLL_INSENSITIVE and ResultSet.CONCUR_READ_ONLY or
 
2780
      ResultSet.CONCUR_UPDATABLE
 
2781
      
 
2782
    - Fixed ResultSet.isLast() for empty result sets (should return false).
 
2783
    
 
2784
    - PreparedStatement now honors stream lengths in setBinary/Ascii/Character
 
2785
      Stream() unless you set the connection property 
 
2786
      'useStreamLengthsInPrepStmts' to 'false'.
 
2787
      
 
2788
    - Removed some not-needed temporary object creation by using Strings
 
2789
      smarter in EscapeProcessor, Connection and DatabaseMetaData classes.
 
2790
                
 
2791
09-21-02 - Version 3.0.1-dev
 
2792
        
 
2793
    - Fixed ResultSet.getRow() off-by-one bug.
 
2794
    
 
2795
    - Fixed RowDataStatic.getAt() off-by-one bug.
 
2796
    
 
2797
    - Added limited Clob functionality (ResultSet.getClob(),
 
2798
      PreparedStatemtent.setClob(), 
 
2799
      PreparedStatement.setObject(Clob).
 
2800
      
 
2801
    - Added socketTimeout parameter to URL.
 
2802
    
 
2803
    - Connection.isClosed() no longer "pings" the server.
 
2804
    
 
2805
    - Connection.close() issues rollback() when getAutoCommit() == false
 
2806
    
 
2807
    - Added "paranoid" parameter...sanitizes error messages removing
 
2808
      "sensitive" information from them (i.e. hostnames, ports,
 
2809
      usernames, etc.), as well as clearing "sensitive" data structures
 
2810
      when possible.
 
2811
      
 
2812
    - Fixed ResultSetMetaData.isSigned() for TINYINT and BIGINT.
 
2813
    
 
2814
    - Charsets now automatically detected. Optimized code for single-byte
 
2815
      character set conversion.
 
2816
      
 
2817
    - Implemented ResultSet.getCharacterStream()
 
2818
    
 
2819
    - Added "LOCAL TEMPORARY" to table types in DatabaseMetaData.getTableTypes()
 
2820
    
 
2821
    - Massive code clean-up to follow Java coding conventions (the time had come)
 
2822
  
 
2823
        
 
2824
07-31-02 - Version 3.0.0-dev
 
2825
 
 
2826
    - !!! LICENSE CHANGE !!! The driver is now GPL. If you need
 
2827
      non-GPL licenses, please contact me <mark@mysql.com>
 
2828
      
 
2829
    - JDBC-3.0 functionality including 
 
2830
      Statement/PreparedStatement.getGeneratedKeys() and
 
2831
      ResultSet.getURL()
 
2832
      
 
2833
    - Performance enchancements - driver is now 50-100% faster
 
2834
      in most situations, and creates fewer temporary objects
 
2835
      
 
2836
    - Repackaging...new driver name is "com.mysql.jdbc.Driver",
 
2837
      old name still works, though (the driver is now provided 
 
2838
      by MySQL-AB)
 
2839
      
 
2840
    - Better checking for closed connections in Statement
 
2841
      and PreparedStatement.
 
2842
      
 
2843
    - Support for streaming (row-by-row) result sets (see README)
 
2844
      Thanks to Doron.
 
2845
      
 
2846
    - Support for large packets (new addition to MySQL-4.0 protocol),
 
2847
      see README for more information.
 
2848
      
 
2849
    - JDBC Compliance -- Passes all tests besides stored procedure tests
 
2850
    
 
2851
    
 
2852
    - Fix and sort primary key names in DBMetaData (SF bugs 582086 and 582086)
 
2853
    
 
2854
    - Float types now reported as java.sql.Types.FLOAT (SF bug 579573)
 
2855
    
 
2856
    - ResultSet.getTimestamp() now works for DATE types (SF bug 559134)
 
2857
    
 
2858
    - ResultSet.getDate/Time/Timestamp now recognizes all forms of invalid
 
2859
      values that have been set to all zeroes by MySQL (SF bug 586058)
 
2860
      
 
2861
    - Testsuite now uses Junit (which you can get from www.junit.org)
 
2862
    
 
2863
    - The driver now only works with JDK-1.2 or newer.
 
2864
    
 
2865
    - Added multi-host failover support (see README)
 
2866
    
 
2867
    - General source-code cleanup.
 
2868
    
 
2869
    - Overall speed improvements via controlling transient object
 
2870
      creation in MysqlIO class when reading packets
 
2871
      
 
2872
    - Performance improvements in  string handling and field 
 
2873
      metadata creation (lazily instantiated) contributed by
 
2874
      Alex Twisleton-Wykeham-Fiennes
 
2875
      
 
2876
    
 
2877
05-16-02 - Version 2.0.14
 
2878
 
 
2879
    - More code cleanup
 
2880
    
 
2881
    - PreparedStatement now releases resources on .close() (SF bug 553268)
 
2882
    
 
2883
    - Quoted identifiers not used if server version does not support them. Also,
 
2884
      if server started with --ansi or --sql-mode=ANSI_QUOTES then '"' will be 
 
2885
      used as an identifier quote, otherwise '`' will be used.
 
2886
      
 
2887
    - ResultSet.getDouble() now uses code built into JDK to be more precise (but slower)
 
2888
    
 
2889
    - LogicalHandle.isClosed() calls through to physical connection
 
2890
    
 
2891
    - Added SQL profiling (to STDERR). Set "profileSql=true" in your JDBC url. 
 
2892
      See README for more information.
 
2893
      
 
2894
    - Fixed typo for relaxAutoCommit parameter.
 
2895
        
 
2896
04-24-02 - Version 2.0.13
 
2897
 
 
2898
    - More code cleanup.
 
2899
    
 
2900
    - Fixed unicode chars being read incorrectly (SF bug 541088)
 
2901
    
 
2902
    - Faster blob escaping for PrepStmt
 
2903
    
 
2904
    - Added set/getPortNumber() to DataSource(s) (SF bug 548167)
 
2905
    
 
2906
    - Added setURL() to MySQLXADataSource (SF bug 546019)
 
2907
    
 
2908
    - PreparedStatement.toString() fixed (SF bug 534026)
 
2909
    
 
2910
    - ResultSetMetaData.getColumnClassName() now implemented
 
2911
    
 
2912
    - Rudimentary version of Statement.getGeneratedKeys() from JDBC-3.0
 
2913
      now implemented (you need to be using JDK-1.4 for this to work, I
 
2914
      believe)
 
2915
          
 
2916
    - DBMetaData.getIndexInfo() - bad PAGES fixed (SF BUG 542201)
 
2917
        
 
2918
04-07-02 - Version 2.0.12
 
2919
 
 
2920
    - General code cleanup. 
 
2921
    
 
2922
    - Added getIdleFor() method to Connection and MysqlLogicalHandle.
 
2923
    
 
2924
    - Relaxed synchronization in all classes, should fix 520615 and 520393.
 
2925
    
 
2926
    - Added getTable/ColumnPrivileges() to DBMD (fixes 484502).
 
2927
    
 
2928
    - Added new types to getTypeInfo(), fixed existing types thanks to
 
2929
      Al Davis and Kid Kalanon.
 
2930
      
 
2931
    - Added support for BIT types (51870) to PreparedStatement.
 
2932
    
 
2933
    - Fixed getRow() bug (527165) in ResultSet
 
2934
    
 
2935
    - Fixes for ResultSet updatability in PreparedStatement.
 
2936
    - Fixed timezone off by 1-hour bug in PreparedStatement (538286, 528785).
 
2937
    
 
2938
    - ResultSet: Fixed updatability (values being set to null 
 
2939
      if not updated).
 
2940
      
 
2941
    - DataSources - fixed setUrl bug (511614, 525565), 
 
2942
      wrong datasource class name (532816, 528767)
 
2943
      
 
2944
    - Added identifier quoting to all DatabaseMetaData methods
 
2945
      that need them (should fix 518108)
 
2946
      
 
2947
    - Added support for YEAR type (533556)
 
2948
    
 
2949
    - ResultSet.insertRow() should now detect auto_increment fields
 
2950
      in most cases and use that value in the new row. This detection
 
2951
      will not work in multi-valued keys, however, due to the fact that
 
2952
      the MySQL protocol does not return this information.
 
2953
      
 
2954
    - ResultSet.refreshRow() implemented.
 
2955
    
 
2956
    - Fixed testsuite.Traversal afterLast() bug, thanks to Igor Lastric.
 
2957
        
 
2958
01-27-02 - Version 2.0.11
 
2959
 
 
2960
    - Fixed missing DELETE_RULE value in 
 
2961
      DBMD.getImported/ExportedKeys() and getCrossReference().
 
2962
      
 
2963
    - Full synchronization of Statement.java.
 
2964
    
 
2965
    - More changes to fix "Unexpected end of input stream"
 
2966
      errors when reading BLOBs. This should be the last fix.
 
2967
       
 
2968
01-24-02 - Version 2.0.10
 
2969
 
 
2970
     - Fixed spurious "Unexpected end of input stream" errors in 
 
2971
       MysqlIO (bug 507456).
 
2972
       
 
2973
     - Fixed null-pointer-exceptions when using 
 
2974
       MysqlConnectionPoolDataSource with Websphere 4 (bug 505839).
 
2975
       
 
2976
01-13-02 - Version 2.0.9
 
2977
 
 
2978
     - Ant build was corrupting included jar files, fixed 
 
2979
       (bug 487669).
 
2980
       
 
2981
     - Fixed extra memory allocation in MysqlIO.readPacket() 
 
2982
       (bug 488663).
 
2983
       
 
2984
     - Implementation of DatabaseMetaData.getExported/ImportedKeys() and
 
2985
       getCrossReference().
 
2986
       
 
2987
     - Full synchronization on methods modifying instance and class-shared
 
2988
       references, driver should be entirely thread-safe now (please
 
2989
       let me know if you have problems)
 
2990
       
 
2991
     - DataSource implementations moved to org.gjt.mm.mysql.jdbc2.optional
 
2992
       package, and (initial) implementations of PooledConnectionDataSource
 
2993
       and XADataSource are in place (thanks to Todd Wolff for the 
 
2994
       implementation and testing of PooledConnectionDataSource with 
 
2995
       IBM WebSphere 4).
 
2996
       
 
2997
     - Added detection of network connection being closed when reading packets
 
2998
       (thanks to Todd Lizambri).
 
2999
       
 
3000
     - Fixed quoting error with escape processor (bug 486265).
 
3001
     
 
3002
     - Report batch update support through DatabaseMetaData (bug 495101).
 
3003
     
 
3004
     - Fixed off-by-one-hour error in PreparedStatement.setTimestamp() 
 
3005
       (bug 491577).
 
3006
       
 
3007
     - Removed concatenation support from driver (the '||' operator),
 
3008
       as older versions of VisualAge seem to be the only thing that
 
3009
       use it, and it conflicts with the logical '||' operator. You will
 
3010
       need to start mysqld with the "--ansi" flag to use the '||' 
 
3011
       operator as concatenation (bug 491680)
 
3012
       
 
3013
     - Fixed casting bug in PreparedStatement (bug 488663).
 
3014
     
 
3015
11-25-01 - Version 2.0.8
 
3016
 
 
3017
     - Batch updates now supported (thanks to some inspiration 
 
3018
       from Daniel Rall).
 
3019
       
 
3020
     - XADataSource/ConnectionPoolDataSource code (experimental)
 
3021
     
 
3022
     - PreparedStatement.setAnyNumericType() now handles positive
 
3023
       exponents correctly (adds "+" so MySQL can understand it).
 
3024
       
 
3025
     - DatabaseMetaData.getPrimaryKeys() and getBestRowIdentifier()
 
3026
       are now more robust in identifying primary keys (matches 
 
3027
       regardless of case or abbreviation/full spelling of Primary Key
 
3028
       in Key_type column).
 
3029
       
 
3030
10-24-01 - Version 2.0.7
 
3031
 
 
3032
     - PreparedStatement.setCharacterStream() now implemented
 
3033
         
 
3034
     - Fixed dangling socket problem when in high availability
 
3035
       (autoReconnect=true) mode, and finalizer for Connection will
 
3036
       close any dangling sockets on GC.
 
3037
       
 
3038
     - Fixed ResultSetMetaData.getPrecision() returning one
 
3039
       less than actual on newer versions of MySQL.
 
3040
       
 
3041
     - ResultSet.getBlob() now returns null if column value
 
3042
       was null.
 
3043
       
 
3044
     - Character sets read from database if useUnicode=true
 
3045
       and characterEncoding is not set. (thanks to 
 
3046
       Dmitry Vereshchagin)
 
3047
       
 
3048
     - Initial transaction isolation level read from 
 
3049
       database (if avaialable) (thanks to Dmitry Vereshchagin)
 
3050
       
 
3051
     - Fixed DatabaseMetaData.supportsTransactions(), and
 
3052
       supportsTransactionIsolationLevel() and getTypeInfo()
 
3053
       SQL_DATETIME_SUB and SQL_DATA_TYPE fields not being
 
3054
       readable.
 
3055
        
 
3056
     - Fixed PreparedStatement generating SQL that would end
 
3057
       up with syntax errors for some queries.
 
3058
       
 
3059
     - Fixed ResultSet.isAfterLast() always returning false.
 
3060
         
 
3061
     - Fixed timezone issue in PreparedStatement.setTimestamp()
 
3062
       (thanks to Erik Olofsson)
 
3063
         
 
3064
     - Captialize type names when "captializeTypeNames=true"
 
3065
       is passed in URL or properties (for WebObjects, thanks
 
3066
       to Anjo Krank)
 
3067
         
 
3068
     - Updatable result sets now correctly handle NULL
 
3069
       values in fields.
 
3070
       
 
3071
     - PreparedStatement.setDouble() now uses full-precision
 
3072
       doubles (reverting a fix made earlier to truncate them).
 
3073
       
 
3074
     - PreparedStatement.setBoolean() will use 1/0 for values
 
3075
       if your MySQL Version >= 3.21.23.
 
3076
 
 
3077
06-16-01 - Version 2.0.6
 
3078
 
 
3079
Fixed PreparedStatement parameter checking
 
3080
         
 
3081
     - Fixed case-sensitive column names in ResultSet.java
 
3082
 
 
3083
06-13-01 - Version 2.0.5
 
3084
 
 
3085
     - Fixed ResultSet.getBlob() ArrayIndex out-of-bounds
 
3086
 
 
3087
     - Fixed ResultSetMetaData.getColumnTypeName for TEXT/BLOB
 
3088
 
 
3089
     - Fixed ArrayIndexOutOfBounds when sending large BLOB queries 
 
3090
       (Max size packet was not being set)
 
3091
 
 
3092
     - Added ISOLATION level support to Connection.setIsolationLevel()
 
3093
 
 
3094
     - Fixed NPE on PreparedStatement.executeUpdate() when all columns
 
3095
       have not been set.
 
3096
 
 
3097
     - Fixed data parsing of TIMESTAMPs with 2-digit years
 
3098
 
 
3099
     - Added Byte to PreparedStatement.setObject()
 
3100
 
 
3101
     - ResultSet.getBoolean() now recognizes '-1' as 'true'
 
3102
 
 
3103
     - ResultSet has +/-Inf/inf support
 
3104
 
 
3105
     - ResultSet.insertRow() works now, even if not all columns are
 
3106
       set (they will be set to "NULL")
 
3107
 
 
3108
     - DataBaseMetaData.getCrossReference() no longer ArrayIndexOOB
 
3109
 
 
3110
     - getObject() on ResultSet correctly does TINYINT->Byte and
 
3111
       SMALLINT->Short
 
3112
 
 
3113
12-03-00 - Version 2.0.3
 
3114
 
 
3115
     - Implemented getBigDecimal() without scale component
 
3116
       for JDBC2.
 
3117
 
 
3118
     - Fixed composite key problem with updateable result sets.
 
3119
 
 
3120
     - Added detection of -/+INF for doubles.
 
3121
 
 
3122
     - Faster ASCII string operations.
 
3123
 
 
3124
     - Fixed incorrect detection of MAX_ALLOWED_PACKET, so sending
 
3125
       large blobs should work now.
 
3126
 
 
3127
     - Fixed off-by-one error in java.sql.Blob implementation code.
 
3128
 
 
3129
     - Added "ultraDevHack" URL parameter, set to "true" to allow 
 
3130
       (broken) Macromedia UltraDev to use the driver.
 
3131
 
 
3132
04-06-00 - Version 2.0.1
 
3133
 
 
3134
     - Fixed RSMD.isWritable() returning wrong value. 
 
3135
       Thanks to Moritz Maass.
 
3136
 
 
3137
     - Cleaned up exception handling when driver connects
 
3138
 
 
3139
     - Columns that are of type TEXT now return as Strings
 
3140
       when you use getObject()
 
3141
 
 
3142
     - DatabaseMetaData.getPrimaryKeys() now works correctly wrt
 
3143
       to key_seq. Thanks to Brian Slesinsky.
 
3144
 
 
3145
     - No escape processing is done on PreparedStatements anymore
 
3146
       per JDBC spec.
 
3147
 
 
3148
     - Fixed many JDBC-2.0 traversal, positioning bugs, especially
 
3149
       wrt to empty result sets. Thanks to Ron Smits, Nick Brook,
 
3150
       Cessar Garcia and Carlos Martinez.
 
3151
 
 
3152
     - Fixed some issues with updatability support in ResultSet when
 
3153
       using multiple primary keys.
 
3154
 
 
3155
02-21-00 - Version 2.0pre5
 
3156
 
 
3157
     - Fixed Bad Handshake problem.
 
3158
 
 
3159
01-10-00 - Version 2.0pre4
 
3160
 
 
3161
     - Fixes to ResultSet for insertRow() - Thanks to
 
3162
       Cesar Garcia
 
3163
 
 
3164
     - Fix to Driver to recognize JDBC-2.0 by loading a JDBC-2.0
 
3165
       class, instead of relying on JDK version numbers. Thanks
 
3166
       to John Baker.
 
3167
 
 
3168
     - Fixed ResultSet to return correct row numbers
 
3169
     
 
3170
     - Statement.getUpdateCount() now returns rows matched,
 
3171
       instead of rows actually updated, which is more SQL-92
 
3172
       like.
 
3173
 
 
3174
10-29-99 
 
3175
 
 
3176
     - Statement/PreparedStatement.getMoreResults() bug fixed. 
 
3177
       Thanks to Noel J. Bergman.
 
3178
 
 
3179
     - Added Short as a type to PreparedStatement.setObject().
 
3180
       Thanks to Jeff Crowder
 
3181
 
 
3182
     - Driver now automagically configures maximum/preferred packet
 
3183
       sizes by querying server.
 
3184
 
 
3185
     - Autoreconnect code uses fast ping command if server supports
 
3186
       it.
 
3187
 
 
3188
     - Fixed various bugs wrt. to packet sizing when reading from
 
3189
       the server and when alloc'ing to write to the server.
 
3190
 
 
3191
08-17-99 - Version 2.0pre
 
3192
 
 
3193
     - Now compiles under JDK-1.2. The driver supports both JDK-1.1
 
3194
       and JDK-1.2 at the same time through a core set of classes.
 
3195
       The driver will load the appropriate interface classes at
 
3196
       runtime by figuring out which JVM version you are using.
 
3197
 
 
3198
     - Fixes for result sets with all nulls in the first row.
 
3199
       (Pointed out by Tim Endres)
 
3200
 
 
3201
     - Fixes to column numbers in SQLExceptions in ResultSet
 
3202
       (Thanks to Blas Rodriguez Somoza)
 
3203
 
 
3204
     - The database no longer needs to specified to connect.
 
3205
       (Thanks to Christian Motschke)
 
3206
 
 
3207
07-04-99 - Version 1.2b
 
3208
 
 
3209
     - Better Documentation (in progress), in doc/mm.doc/book1.html
 
3210
 
 
3211
     - DBMD now allows null for a column name pattern (not in 
 
3212
       spec), which it changes to '%'.
 
3213
 
 
3214
     - DBMD now has correct types/lengths for getXXX().
 
3215
 
 
3216
     - ResultSet.getDate(), getTime(), and getTimestamp() fixes. 
 
3217
       (contributed by Alan Wilken)
 
3218
 
 
3219
     - EscapeProcessor now handles \{ \} and { or } inside quotes
 
3220
       correctly. (thanks to Alik for some ideas on how to fix it)
 
3221
 
 
3222
     - Fixes to properties handling in Connection.
 
3223
       (contributed by Juho Tikkala)
 
3224
 
 
3225
     - ResultSet.getObject() now returns null for NULL columns
 
3226
       in the table, rather than bombing out.
 
3227
       (thanks to Ben Grosman)
 
3228
 
 
3229
     - ResultSet.getObject() now returns Strings for types
 
3230
       from MySQL that it doesn't know about. (Suggested by
 
3231
       Chris Perdue)
 
3232
 
 
3233
     - Removed DataInput/Output streams, not needed, 1/2 number
 
3234
       of method calls per IO operation.
 
3235
 
 
3236
     - Use default character encoding if one is not specified. This
 
3237
       is a work-around for broken JVMs, because according to spec,
 
3238
       EVERY JVM must support "ISO8859_1", but they don't.
 
3239
 
 
3240
     - Fixed Connection to use the platform character encoding
 
3241
       instead of "ISO8859_1" if one isn't explicitly set. This 
 
3242
       fixes problems people were having loading the character-
 
3243
       converter classes that didn't always exist (JVM bug).
 
3244
       (thanks to Fritz Elfert for pointing out this problem)
 
3245
 
 
3246
     - Changed MysqlIO to re-use packets where possible to reduce
 
3247
       memory usage.
 
3248
 
 
3249
     - Fixed escape-processor bugs pertaining to {} inside
 
3250
       quotes.
 
3251
 
 
3252
04-14-99 - Version 1.2a
 
3253
 
 
3254
     - Fixed character-set support for non-Javasoft JVMs
 
3255
       (thanks to many people for pointing it out)
 
3256
 
 
3257
     - Fixed ResultSet.getBoolean() to recognize 'y' & 'n'
 
3258
       as well as '1' & '0' as boolean flags.
 
3259
       (thanks to Tim Pizey)
 
3260
 
 
3261
     - Fixed ResultSet.getTimestamp() to give better performance.
 
3262
       (thanks to Richard Swift)
 
3263
 
 
3264
     - Fixed getByte() for numeric types.
 
3265
       (thanks to Ray Bellis)
 
3266
 
 
3267
     - Fixed DatabaseMetaData.getTypeInfo() for DATE type.
 
3268
       (thanks to Paul Johnston)
 
3269
 
 
3270
     - Fixed EscapeProcessor for "fn" calls.
 
3271
       (thanks to Piyush Shah at locomotive.org)
 
3272
 
 
3273
     - Fixed EscapeProcessor to not do extraneous work if there
 
3274
       are no escape codes.
 
3275
       (thanks to Ryan Gustafson)
 
3276
 
 
3277
     - Fixed Driver to parse URLs of the form "jdbc:mysql://host:port"
 
3278
       (thanks to Richard Lobb)
 
3279
 
 
3280
03-24-99 - Version 1.1i
 
3281
 
 
3282
     - Fixed Timestamps for PreparedStatements
 
3283
    
 
3284
     - Fixed null pointer exceptions in RSMD and RS
 
3285
 
 
3286
     - Re-compiled with jikes for valid class files (thanks ms!)
 
3287
 
 
3288
03-08-99 - Version 1.1h
 
3289
 
 
3290
     - Fixed escape processor to deal with un-matched { and }
 
3291
       (thanks to Craig Coles)
 
3292
       
 
3293
     - Fixed escape processor to create more portable (between
 
3294
       DATETIME and TIMESTAMP types) representations so that
 
3295
       it will work with BETWEEN clauses.
 
3296
       (thanks to Craig Longman)
 
3297
       
 
3298
     - MysqlIO.quit() now closes the socket connection. Before,
 
3299
       after many failed connections some OS's would run out
 
3300
       of file descriptors. (thanks to Michael Brinkman)
 
3301
       
 
3302
     - Fixed NullPointerException in Driver.getPropertyInfo.
 
3303
       (thanks to Dave Potts)
 
3304
        
 
3305
     - Fixes to MysqlDefs to allow all *text fields to be
 
3306
       retrieved as Strings.
 
3307
       (thanks to Chris at Leverage)
 
3308
       
 
3309
     - Fixed setDouble in PreparedStatement for large numbers
 
3310
       to avoid sending scientific notation to the database.
 
3311
       (thanks to J.S. Ferguson)
 
3312
       
 
3313
     - Fixed getScale() and getPrecision() in RSMD.
 
3314
       (contrib'd by James Klicman)
 
3315
       
 
3316
     - Fixed getObject() when field was DECIMAL or NUMERIC
 
3317
       (thanks to Bert Hobbs)
 
3318
       
 
3319
     - DBMD.getTables() bombed when passed a null table-name
 
3320
       pattern. Fixed. (thanks to Richard Lobb)
 
3321
       
 
3322
     - Added check for "client not authorized" errors during
 
3323
       connect. (thanks to Hannes Wallnoefer)
 
3324
       
 
3325
02-19-99 - Version 1.1g
 
3326
 
 
3327
     - Result set rows are now byte arrays. Blobs and Unicode
 
3328
       work bidriectonally now. The useUnicode and encoding
 
3329
       options are implemented now.
 
3330
       
 
3331
     - Fixes to PreparedStatement to send binary set by
 
3332
       setXXXStream to be sent un-touched to the MySQL server.
 
3333
       
 
3334
     - Fixes to getDriverPropertyInfo().
 
3335
       
 
3336
12-31-98 - Version 1.1f
 
3337
 
 
3338
     - Changed all ResultSet fields to Strings, this should allow
 
3339
       Unicode to work, but your JVM must be able to convert
 
3340
       between the character sets. This should also make reading
 
3341
       data from the server be a bit quicker, because there is now
 
3342
       no conversion from StringBuffer to String.
 
3343
 
 
3344
     - Changed PreparedStatement.streamToString() to be more
 
3345
       efficient (code from Uwe Schaefer).
 
3346
 
 
3347
     - URL parsing is more robust (throws SQL exceptions on errors
 
3348
       rather than NullPointerExceptions)
 
3349
 
 
3350
     - PreparedStatement now can convert Strings to Time/Date values
 
3351
       via setObject() (code from Robert Currey).
 
3352
 
 
3353
     - IO no longer hangs in Buffer.readInt(), that bug was
 
3354
       introduced in 1.1d when changing to all byte-arrays for
 
3355
       result sets. (Pointed out by Samo Login)
 
3356
 
 
3357
11-03-98 - Version 1.1b 
 
3358
 
 
3359
     - Fixes to DatabaseMetaData to allow both IBM VA and J-Builder
 
3360
       to work. Let me know how it goes. (thanks to Jac Kersing)
 
3361
 
 
3362
     - Fix to ResultSet.getBoolean() for NULL strings 
 
3363
       (thanks to Barry Lagerweij)
 
3364
 
 
3365
     - Beginning of code cleanup, and formatting. Getting ready
 
3366
       to branch this off to a parallel JDBC-2.0 source tree.
 
3367
 
 
3368
     - Added "final" modifier to critical sections in MysqlIO and
 
3369
       Buffer to allow compiler to inline methods for speed.
 
3370
 
 
3371
9-29-98 
 
3372
 
 
3373
     - If object references passed to setXXX() in PreparedStatement are
 
3374
       null, setNull() is automatically called for you. (Thanks for the
 
3375
       suggestion goes to Erik Ostrom)
 
3376
 
 
3377
     - setObject() in PreparedStatement will now attempt to write a 
 
3378
       serialized  representation of the object to the database for
 
3379
       objects of Types.OTHER and objects of unknown type.
 
3380
 
 
3381
     - Util now has a static method readObject() which given a ResultSet
 
3382
       and a column index will re-instantiate an object serialized in
 
3383
       the above manner.
 
3384
 
 
3385
9-02-98 - Vesion 1.1
 
3386
 
 
3387
     - Got rid of "ugly hack" in MysqlIO.nextRow(). Rather than
 
3388
       catch an exception, Buffer.isLastDataPacket() was fixed.
 
3389
          
 
3390
     - Connection.getCatalog() and Connection.setCatalog()
 
3391
       should work now.
 
3392
 
 
3393
     - Statement.setMaxRows() works, as well as setting
 
3394
       by property maxRows. Statement.setMaxRows() overrides
 
3395
       maxRows set via properties or url parameters.
 
3396
 
 
3397
     - Automatic re-connection is available. Because it has
 
3398
       to "ping" the database before each query, it is
 
3399
       turned off by default. To use it, pass in "autoReconnect=true"
 
3400
       in the connection URL. You may also change the number of
 
3401
       reconnect tries, and the initial timeout value via 
 
3402
       "maxReconnects=n" (default 3) and "initialTimeout=n" 
 
3403
       (seconds, default 2) parameters. The timeout is an 
 
3404
       exponential backoff type of timeout, e.g. if you have initial 
 
3405
       timeout of 2 seconds, and maxReconnects of 3, then the driver
 
3406
       will timeout 2 seconds, 4 seconds, then 16 seconds between each
 
3407
       re-connection attempt.
 
3408
 
 
3409
8-24-98 - Version 1.0 
 
3410
 
 
3411
     - Fixed handling of blob data in Buffer.java
 
3412
        
 
3413
     - Fixed bug with authentication packet being
 
3414
       sized too small.
 
3415
 
 
3416
     - The JDBC Driver is now under the LPGL
 
3417
        
 
3418
8-14-98 - 
 
3419
 
 
3420
     - Fixed Buffer.readLenString() to correctly
 
3421
          read data for BLOBS.
 
3422
          
 
3423
     - Fixed PreparedStatement.stringToStream to
 
3424
          correctly read data for BLOBS.
 
3425
          
 
3426
     - Fixed PreparedStatement.setDate() to not
 
3427
       add a day.
 
3428
       (above fixes thanks to Vincent Partington)
 
3429
          
 
3430
     - Added URL parameter parsing (?user=... etc).
 
3431
      
 
3432
 
 
3433
8-04-98 - Version 0.9d
 
3434
 
 
3435
     - Big news! New package name. Tim Endres from ICE
 
3436
       Engineering is starting a new source tree for
 
3437
       GNU GPL'd Java software. He's graciously given
 
3438
       me the org.gjt.mm package directory to use, so now 
 
3439
       the driver is in the org.gjt.mm.mysql package scheme.
 
3440
       I'm "legal" now. Look for more information on Tim's
 
3441
       project soon.
 
3442
          
 
3443
     - Now using dynamically sized packets to reduce
 
3444
       memory usage when sending commands to the DB.
 
3445
          
 
3446
     - Small fixes to getTypeInfo() for parameters, etc.
 
3447
          
 
3448
     - DatabaseMetaData is now fully implemented. Let me
 
3449
       know if these drivers work with the various IDEs
 
3450
       out there. I've heard that they're working with
 
3451
       JBuilder right now.
 
3452
          
 
3453
     - Added JavaDoc documentation to the package.
 
3454
          
 
3455
     - Package now available in .zip or .tar.gz.
 
3456
          
 
3457
7-28-98 - Version 0.9
 
3458
 
 
3459
     - Implemented getTypeInfo(). 
 
3460
       Connection.rollback() now throws an SQLException
 
3461
       per the JDBC spec.
 
3462
          
 
3463
     - Added PreparedStatement that supports all JDBC API
 
3464
       methods for PreparedStatement including InputStreams.
 
3465
       Please check this out and let me know if anything is
 
3466
       broken.
 
3467
          
 
3468
     - Fixed a bug in ResultSet that would break some
 
3469
       queries that only returned 1 row.
 
3470
          
 
3471
     - Fixed bugs in DatabaseMetaData.getTables(), 
 
3472
       DatabaseMetaData.getColumns() and
 
3473
       DatabaseMetaData.getCatalogs().
 
3474
          
 
3475
     - Added functionality to Statement that allows
 
3476
       executeUpdate() to store values for IDs that are
 
3477
       automatically generated for AUTO_INCREMENT fields.
 
3478
       Basically, after an executeUpdate(), look at the
 
3479
       SQLWarnings for warnings like "LAST_INSERTED_ID =
 
3480
       'some number', COMMAND = 'your SQL query'".
 
3481
          
 
3482
       If you are using AUTO_INCREMENT fields in your
 
3483
       tables and are executing a lot of executeUpdate()s
 
3484
       on one Statement, be sure to clearWarnings() every
 
3485
       so often to save memory.
 
3486
 
 
3487
7-06-98 - Version 0.8
 
3488
 
 
3489
     - Split MysqlIO and Buffer to separate classes. Some
 
3490
       ClassLoaders gave an IllegalAccess error for some
 
3491
       fields in those two classes. Now mm.mysql works in 
 
3492
       applets and all classloaders.
 
3493
 
 
3494
       Thanks to Joe Ennis <jce@mail.boone.com> for pointing
 
3495
       out the problem and working on a fix with me.
 
3496
 
 
3497
7-01-98 - Version 0.7
 
3498
 
 
3499
     - Fixed DatabaseMetadata problems in getColumns() and
 
3500
       bug in switch statement in the Field constructor.
 
3501
 
 
3502
       Thanks to Costin Manolache <costin@tdiinc.com> for 
 
3503
       pointing these out.
 
3504
 
 
3505
5-21-98 - Version 0.6
 
3506
 
 
3507
     - Incorporated efficiency changes from 
 
3508
       Richard Swift <Richard.Swift@kanatek.ca> in
 
3509
       MysqlIO.java and ResultSet.java
 
3510
 
 
3511
     - We're now 15% faster than gwe's driver.
 
3512
 
 
3513
     - Started working on DatabaseMetaData.
 
3514
          
 
3515
       The following methods are implemented:
 
3516
        * getTables() 
 
3517
        * getTableTypes()
 
3518
        * getColumns
 
3519
        * getCatalogs()