Showing the changes to java/pkg/javax/sql/rowset/RowSetMetaDataImpl.java (1 of 18352 files). Show all
Unified · Split
| @@ -0,0 +1,1095 @@ | |||
| 1 | /* | ||
| 2 | * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. | ||
| 3 | * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | ||
| 4 | * | ||
| 5 | * This code is free software; you can redistribute it and/or modify it | ||
| 6 | * under the terms of the GNU General Public License version 2 only, as | ||
| 7 | * published by the Free Software Foundation. Oracle designates this | ||
| 8 | * particular file as subject to the "Classpath" exception as provided | ||
| 9 | * by Oracle in the LICENSE file that accompanied this code. | ||
| 10 | * | ||
| 11 | * This code is distributed in the hope that it will be useful, but WITHOUT | ||
| 12 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | ||
| 13 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | ||
| 14 | * version 2 for more details (a copy is included in the LICENSE file that | ||
| 15 | * accompanied this code). | ||
| 16 | * | ||
| 17 | * You should have received a copy of the GNU General Public License version | ||
| 18 | * 2 along with this work; if not, write to the Free Software Foundation, | ||
| 19 | * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | ||
| 20 | * | ||
| 21 | * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | ||
| 22 | * or visit www.oracle.com if you need additional information or have any | ||
| 23 | * questions. | ||
| 24 | */ | ||
| 25 | |||
| 26 | package javax.sql.rowset; | ||
| 27 | |||
| 28 | import java.sql.*; | ||
| 29 | import javax.sql.*; | ||
| 30 | import java.io.*; | ||
| 31 | |||
| 32 | import java.lang.reflect.*; | ||
| 33 | |||
| 34 | /** | ||
| 35 | * Provides implementations for the methods that set and get | ||
| 36 | * metadata information about a <code>RowSet</code> object's columns. | ||
| 37 | * A <code>RowSetMetaDataImpl</code> object keeps track of the | ||
| 38 | * number of columns in the rowset and maintains an internal array | ||
| 39 | * of column attributes for each column. | ||
| 40 | * <P> | ||
| 41 | * A <code>RowSet</code> object creates a <code>RowSetMetaDataImpl</code> | ||
| 42 | * object internally in order to set and retrieve information about | ||
| 43 | * its columns. | ||
| 44 | * <P> | ||
| 45 | * NOTE: All metadata in a <code>RowSetMetaDataImpl</code> object | ||
| 46 | * should be considered as unavailable until the <code>RowSet</code> object | ||
| 47 | * that it describes is populated. | ||
| 48 | * Therefore, any <code>RowSetMetaDataImpl</code> method that retrieves information | ||
| 49 | * is defined as having unspecified behavior when it is called | ||
| 50 | * before the <code>RowSet</code> object contains data. | ||
| 51 | */ | ||
| 52 | public class RowSetMetaDataImpl implements RowSetMetaData, Serializable { | ||
| 53 | |||
| 54 | /** | ||
| 55 | * The number of columns in the <code>RowSet</code> object that created | ||
| 56 | * this <code>RowSetMetaDataImpl</code> object. | ||
| 57 | * @serial | ||
| 58 | */ | ||
| 59 | private int colCount; | ||
| 60 | |||
| 61 | /** | ||
| 62 | * An array of <code>ColInfo</code> objects used to store information | ||
| 63 | * about each column in the <code>RowSet</code> object for which | ||
| 64 | * this <code>RowSetMetaDataImpl</code> object was created. The first | ||
| 65 | * <code>ColInfo</code> object in this array contains information about | ||
| 66 | * the first column in the <code>RowSet</code> object, the second element | ||
| 67 | * contains information about the second column, and so on. | ||
| 68 | * @serial | ||
| 69 | */ | ||
| 70 | private ColInfo[] colInfo; | ||
| 71 | |||
| 72 | /** | ||
| 73 | * Checks to see that the designated column is a valid column number for | ||
| 74 | * the <code>RowSet</code> object for which this <code>RowSetMetaDataImpl</code> | ||
| 75 | * was created. To be valid, a column number must be greater than | ||
| 76 | * <code>0</code> and less than or equal to the number of columns in a row. | ||
| 77 | * @throws <code>SQLException</code> with the message "Invalid column index" | ||
| 78 | * if the given column number is out of the range of valid column | ||
| 79 | * numbers for the <code>RowSet</code> object | ||
| 80 | */ | ||
| 81 | private void checkColRange(int col) throws SQLException { | ||
| 82 | if (col <= 0 || col > colCount) { | ||
| 83 | throw new SQLException("Invalid column index :"+col); | ||
| 84 | } | ||
| 85 | } | ||
| 86 | |||
| 87 | /** | ||
| 88 | * Checks to see that the given SQL type is a valid column type and throws an | ||
| 89 | * <code>SQLException</code> object if it is not. | ||
| 90 | * To be valid, a SQL type must be one of the constant values | ||
| 91 | * in the <code><a href="../../sql/Types.html">java.sql.Types</a></code> | ||
| 92 | * class. | ||
| 93 | * | ||
| 94 | * @param SQLType an <code>int</code> defined in the class <code>java.sql.Types</code> | ||
| 95 | * @throws SQLException if the given <code>int</code> is not a constant defined in the | ||
| 96 | * class <code>java.sql.Types</code> | ||
| 97 | */ | ||
| 98 | private void checkColType(int SQLType) throws SQLException { | ||
| 99 | try { | ||
| 100 | Class c = java.sql.Types.class; | ||
| 101 | Field[] publicFields = c.getFields(); | ||
| 102 | int fieldValue = 0; | ||
| 103 | for (int i = 0; i < publicFields.length; i++) { | ||
| 104 | fieldValue = publicFields[i].getInt(c); | ||
| 105 | if (fieldValue == SQLType) { | ||
| 106 | return; | ||
| 107 | } | ||
| 108 | } | ||
| 109 | } catch (Exception e) { | ||
| 110 | throw new SQLException(e.getMessage()); | ||
| 111 | } | ||
| 112 | throw new SQLException("Invalid SQL type for column"); | ||
| 113 | } | ||
| 114 | |||
| 115 | /** | ||
| 116 | * Sets to the given number the number of columns in the <code>RowSet</code> | ||
| 117 | * object for which this <code>RowSetMetaDataImpl</code> object was created. | ||
| 118 | * | ||
| 119 | * @param columnCount an <code>int</code> giving the number of columns in the | ||
| 120 | * <code>RowSet</code> object | ||
| 121 | * @throws SQLException if the given number is equal to or less than zero | ||
| 122 | */ | ||
| 123 | public void setColumnCount(int columnCount) throws SQLException { | ||
| 124 | |||
| 125 | if (columnCount <= 0) { | ||
| 126 | throw new SQLException("Invalid column count. Cannot be less " + | ||
| 127 | "or equal to zero"); | ||
| 128 | } | ||
| 129 | |||
| 130 | colCount = columnCount; | ||
| 131 | |||
| 132 | // If the colCount is Integer.MAX_VALUE, | ||
| 133 | // we do not initialize the colInfo object. | ||
| 134 | // even if we try to initialize the colCount with | ||
| 135 | // colCount = Integer.MAx_VALUE-1, the colInfo | ||
| 136 | // initialization fails throwing an ERROR | ||
| 137 | // OutOfMemory Exception. So we do not initialize | ||
| 138 | // colInfo at Integer.MAX_VALUE. This is to pass TCK. | ||
| 139 | |||
| 140 | if(!(colCount == Integer.MAX_VALUE)) { | ||
| 141 | colInfo = new ColInfo[colCount + 1]; | ||
| 142 | |||
| 143 | for (int i=1; i <= colCount; i++) { | ||
| 144 | colInfo[i] = new ColInfo(); | ||
| 145 | } | ||
| 146 | } | ||
| 147 | |||
| 148 | |||
| 149 | } | ||
| 150 | |||
| 151 | /** | ||
| 152 | * Sets whether the designated column is automatically | ||
| 153 | * numbered, thus read-only, to the given <code>boolean</code> | ||
| 154 | * value. | ||
| 155 | * | ||
| 156 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 157 | * must be between <code>1</code> and the number of columns | ||
| 158 | * in the rowset, inclusive | ||
| 159 | * @param property <code>true</code> if the given column is | ||
| 160 | * automatically incremented; <code>false</code> | ||
| 161 | * otherwise | ||
| 162 | * @throws <code>SQLException</code> if a database access error occurs or | ||
| 163 | * the given index is out of bounds | ||
| 164 | */ | ||
| 165 | public void setAutoIncrement(int columnIndex, boolean property) throws SQLException { | ||
| 166 | checkColRange(columnIndex); | ||
| 167 | colInfo[columnIndex].autoIncrement = property; | ||
| 168 | } | ||
| 169 | |||
| 170 | /** | ||
| 171 | * Sets whether the name of the designated column is case sensitive to | ||
| 172 | * the given <code>boolean</code>. | ||
| 173 | * | ||
| 174 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 175 | * must be between <code>1</code> and the number of columns | ||
| 176 | * in the rowset, inclusive | ||
| 177 | * @param property <code>true</code> to indicate that the column | ||
| 178 | * name is case sensitive; <code>false</code> otherwise | ||
| 179 | * @throws SQLException if a database access error occurs or | ||
| 180 | * the given column number is out of bounds | ||
| 181 | */ | ||
| 182 | public void setCaseSensitive(int columnIndex, boolean property) throws SQLException { | ||
| 183 | checkColRange(columnIndex); | ||
| 184 | colInfo[columnIndex].caseSensitive = property; | ||
| 185 | } | ||
| 186 | |||
| 187 | /** | ||
| 188 | * Sets whether a value stored in the designated column can be used | ||
| 189 | * in a <code>WHERE</code> clause to the given <code>boolean</code> value. | ||
| 190 | * | ||
| 191 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 192 | * must be between <code>1</code> and the number | ||
| 193 | * of columns in the rowset, inclusive | ||
| 194 | * @param property <code>true</code> to indicate that a column | ||
| 195 | * value can be used in a <code>WHERE</code> clause; | ||
| 196 | * <code>false</code> otherwise | ||
| 197 | * | ||
| 198 | * @throws <code>SQLException</code> if a database access error occurs or | ||
| 199 | * the given column number is out of bounds | ||
| 200 | */ | ||
| 201 | public void setSearchable(int columnIndex, boolean property) | ||
| 202 | throws SQLException { | ||
| 203 | checkColRange(columnIndex); | ||
| 204 | colInfo[columnIndex].searchable = property; | ||
| 205 | } | ||
| 206 | |||
| 207 | /** | ||
| 208 | * Sets whether a value stored in the designated column is a cash | ||
| 209 | * value to the given <code>boolean</code>. | ||
| 210 | * | ||
| 211 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 212 | * must be between <code>1</code> and the number of columns, | ||
| 213 | * inclusive between <code>1</code> and the number of columns, inclusive | ||
| 214 | * @param property true if the value is a cash value; false otherwise. | ||
| 215 | * @throws <code>SQLException</code> if a database access error occurs | ||
| 216 | * or the given column number is out of bounds | ||
| 217 | */ | ||
| 218 | public void setCurrency(int columnIndex, boolean property) | ||
| 219 | throws SQLException { | ||
| 220 | checkColRange(columnIndex); | ||
| 221 | colInfo[columnIndex].currency = property; | ||
| 222 | } | ||
| 223 | |||
| 224 | /** | ||
| 225 | * Sets whether a value stored in the designated column can be set | ||
| 226 | * to <code>NULL</code> to the given constant from the interface | ||
| 227 | * <code>ResultSetMetaData</code>. | ||
| 228 | * | ||
| 229 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 230 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 231 | * @param property one of the following <code>ResultSetMetaData</code> constants: | ||
| 232 | * <code>columnNoNulls</code>, | ||
| 233 | * <code>columnNullable</code>, or | ||
| 234 | * <code>columnNullableUnknown</code> | ||
| 235 | * | ||
| 236 | * @throws <code>SQLException</code> if a database access error occurs, | ||
| 237 | * the given column number is out of bounds, or the value supplied | ||
| 238 | * for the <i>property</i> parameter is not one of the following | ||
| 239 | * constants: | ||
| 240 | * <code>ResultSetMetaData.columnNoNulls</code>, | ||
| 241 | * <code>ResultSetMetaData.columnNullable</code>, or | ||
| 242 | * <code>ResultSetMetaData.columnNullableUnknown</code> | ||
| 243 | */ | ||
| 244 | public void setNullable(int columnIndex, int property) throws SQLException { | ||
| 245 | if ((property < ResultSetMetaData.columnNoNulls) || | ||
| 246 | property > ResultSetMetaData.columnNullableUnknown) { | ||
| 247 | throw new SQLException("Invalid nullable constant set. Must be " + | ||
| 248 | "either columnNoNulls, columnNullable or columnNullableUnknown"); | ||
| 249 | } | ||
| 250 | checkColRange(columnIndex); | ||
| 251 | colInfo[columnIndex].nullable = property; | ||
| 252 | } | ||
| 253 | |||
| 254 | /** | ||
| 255 | * Sets whether a value stored in the designated column is a signed | ||
| 256 | * number to the given <code>boolean</code>. | ||
| 257 | * | ||
| 258 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 259 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 260 | * @param property <code>true</code> to indicate that a column | ||
| 261 | * value is a signed number; | ||
| 262 | * <code>false</code> to indicate that it is not | ||
| 263 | * @throws SQLException if a database access error occurs | ||
| 264 | * or the given column number is out of bounds | ||
| 265 | */ | ||
| 266 | public void setSigned(int columnIndex, boolean property) throws SQLException { | ||
| 267 | checkColRange(columnIndex); | ||
| 268 | colInfo[columnIndex].signed = property; | ||
| 269 | } | ||
| 270 | |||
| 271 | /** | ||
| 272 | * Sets the normal maximum number of chars in the designated column | ||
| 273 | * to the given number. | ||
| 274 | * | ||
| 275 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 276 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 277 | * @param size the maximum size of the column in chars; must be | ||
| 278 | * <code>0</code> or more | ||
| 279 | * @throws SQLException if a database access error occurs, | ||
| 280 | * the given column number is out of bounds, or <i>size</i> is | ||
| 281 | * less than <code>0</code> | ||
| 282 | */ | ||
| 283 | public void setColumnDisplaySize(int columnIndex, int size) throws SQLException { | ||
| 284 | if (size < 0) { | ||
| 285 | throw new SQLException("Invalid column display size. Cannot be less " + | ||
| 286 | "than zero"); | ||
| 287 | } | ||
| 288 | checkColRange(columnIndex); | ||
| 289 | colInfo[columnIndex].columnDisplaySize = size; | ||
| 290 | } | ||
| 291 | |||
| 292 | /** | ||
| 293 | * Sets the suggested column label for use in printouts and | ||
| 294 | * displays, if any, to <i>label</i>. If <i>label</i> is | ||
| 295 | * <code>null</code>, the column label is set to an empty string | ||
| 296 | * (""). | ||
| 297 | * | ||
| 298 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 299 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 300 | * @param label the column label to be used in printouts and displays; if the | ||
| 301 | * column label is <code>null</code>, an empty <code>String</code> is | ||
| 302 | * set | ||
| 303 | * @throws SQLException if a database access error occurs | ||
| 304 | * or the given column index is out of bounds | ||
| 305 | */ | ||
| 306 | public void setColumnLabel(int columnIndex, String label) throws SQLException { | ||
| 307 | checkColRange(columnIndex); | ||
| 308 | if (label != null) { | ||
| 309 | colInfo[columnIndex].columnLabel = label; | ||
| 310 | } else { | ||
| 311 | colInfo[columnIndex].columnLabel = ""; | ||
| 312 | } | ||
| 313 | } | ||
| 314 | |||
| 315 | /** | ||
| 316 | * Sets the column name of the designated column to the given name. | ||
| 317 | * | ||
| 318 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 319 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 320 | * @param columnName a <code>String</code> object indicating the column name; | ||
| 321 | * if the given name is <code>null</code>, an empty <code>String</code> | ||
| 322 | * is set | ||
| 323 | * @throws SQLException if a database access error occurs or the given column | ||
| 324 | * index is out of bounds | ||
| 325 | */ | ||
| 326 | public void setColumnName(int columnIndex, String columnName) throws SQLException { | ||
| 327 | checkColRange(columnIndex); | ||
| 328 | if (columnName != null) { | ||
| 329 | colInfo[columnIndex].columnName = columnName; | ||
| 330 | } else { | ||
| 331 | colInfo[columnIndex].columnName = ""; | ||
| 332 | } | ||
| 333 | } | ||
| 334 | |||
| 335 | /** | ||
| 336 | * Sets the designated column's table's schema name, if any, to | ||
| 337 | * <i>schemaName</i>. If <i>schemaName</i> is <code>null</code>, | ||
| 338 | * the schema name is set to an empty string (""). | ||
| 339 | * | ||
| 340 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 341 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 342 | * @param schemaName the schema name for the table from which a value in the | ||
| 343 | * designated column was derived; may be an empty <code>String</code> | ||
| 344 | * or <code>null</code> | ||
| 345 | * @throws SQLException if a database access error occurs | ||
| 346 | * or the given column number is out of bounds | ||
| 347 | */ | ||
| 348 | public void setSchemaName(int columnIndex, String schemaName) throws SQLException { | ||
| 349 | checkColRange(columnIndex); | ||
| 350 | if (schemaName != null ) { | ||
| 351 | colInfo[columnIndex].schemaName = schemaName; | ||
| 352 | } else { | ||
| 353 | colInfo[columnIndex].schemaName = ""; | ||
| 354 | } | ||
| 355 | } | ||
| 356 | |||
| 357 | /** | ||
| 358 | * Sets the total number of decimal digits in a value stored in the | ||
| 359 | * designated column to the given number. | ||
| 360 | * | ||
| 361 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 362 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 363 | * @param precision the total number of decimal digits; must be <code>0</code> | ||
| 364 | * or more | ||
| 365 | * @throws SQLException if a database access error occurs, | ||
| 366 | * <i>columnIndex</i> is out of bounds, or <i>precision</i> | ||
| 367 | * is less than <code>0</code> | ||
| 368 | */ | ||
| 369 | public void setPrecision(int columnIndex, int precision) throws SQLException { | ||
| 370 | |||
| 371 | if (precision < 0) { | ||
| 372 | throw new SQLException("Invalid precision value. Cannot be less " + | ||
| 373 | "than zero"); | ||
| 374 | } | ||
| 375 | checkColRange(columnIndex); | ||
| 376 | colInfo[columnIndex].colPrecision = precision; | ||
| 377 | } | ||
| 378 | |||
| 379 | /** | ||
| 380 | * Sets the number of digits to the right of the decimal point in a value | ||
| 381 | * stored in the designated column to the given number. | ||
| 382 | * | ||
| 383 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 384 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 385 | * @param scale the number of digits to the right of the decimal point; must be | ||
| 386 | * zero or greater | ||
| 387 | * @throws SQLException if a database access error occurs, | ||
| 388 | * <i>columnIndex</i> is out of bounds, or <i>scale</i> | ||
| 389 | * is less than <code>0</code> | ||
| 390 | */ | ||
| 391 | public void setScale(int columnIndex, int scale) throws SQLException { | ||
| 392 | if (scale < 0) { | ||
| 393 | throw new SQLException("Invalid scale size. Cannot be less " + | ||
| 394 | "than zero"); | ||
| 395 | } | ||
| 396 | checkColRange(columnIndex); | ||
| 397 | colInfo[columnIndex].colScale = scale; | ||
| 398 | } | ||
| 399 | |||
| 400 | /** | ||
| 401 | * Sets the name of the table from which the designated column | ||
| 402 | * was derived to the given table name. | ||
| 403 | * | ||
| 404 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 405 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 406 | * @param tableName the column's table name; may be <code>null</code> or an | ||
| 407 | * empty string | ||
| 408 | * @throws SQLException if a database access error occurs | ||
| 409 | * or the given column number is out of bounds | ||
| 410 | */ | ||
| 411 | public void setTableName(int columnIndex, String tableName) throws SQLException { | ||
| 412 | checkColRange(columnIndex); | ||
| 413 | if (tableName != null) { | ||
| 414 | colInfo[columnIndex].tableName = tableName; | ||
| 415 | } else { | ||
| 416 | colInfo[columnIndex].tableName = ""; | ||
| 417 | } | ||
| 418 | } | ||
| 419 | |||
| 420 | /** | ||
| 421 | * Sets the catalog name of the table from which the designated | ||
| 422 | * column was derived to <i>catalogName</i>. If <i>catalogName</i> | ||
| 423 | * is <code>null</code>, the catalog name is set to an empty string. | ||
| 424 | * | ||
| 425 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 426 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 427 | * @param catalogName the column's table's catalog name; if the catalogName | ||
| 428 | * is <code>null</code>, an empty <code>String</code> is set | ||
| 429 | * @throws SQLException if a database access error occurs | ||
| 430 | * or the given column number is out of bounds | ||
| 431 | */ | ||
| 432 | public void setCatalogName(int columnIndex, String catalogName) throws SQLException { | ||
| 433 | checkColRange(columnIndex); | ||
| 434 | if (catalogName != null) | ||
| 435 | colInfo[columnIndex].catName = catalogName; | ||
| 436 | else | ||
| 437 | colInfo[columnIndex].catName = ""; | ||
| 438 | } | ||
| 439 | |||
| 440 | /** | ||
| 441 | * Sets the SQL type code for values stored in the designated column | ||
| 442 | * to the given type code from the class <code>java.sql.Types</code>. | ||
| 443 | * | ||
| 444 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 445 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 446 | * @param SQLType the designated column's SQL type, which must be one of the | ||
| 447 | * constants in the class <code>java.sql.Types</code> | ||
| 448 | * @throws SQLException if a database access error occurs, | ||
| 449 | * the given column number is out of bounds, or the column type | ||
| 450 | * specified is not one of the constants in | ||
| 451 | * <code>java.sql.Types</code> | ||
| 452 | * @see java.sql.Types | ||
| 453 | */ | ||
| 454 | public void setColumnType(int columnIndex, int SQLType) throws SQLException { | ||
| 455 | // examine java.sql.Type reflectively, loop on the fields and check | ||
| 456 | // this. Separate out into a private method | ||
| 457 | checkColType(SQLType); | ||
| 458 | checkColRange(columnIndex); | ||
| 459 | colInfo[columnIndex].colType = SQLType; | ||
| 460 | } | ||
| 461 | |||
| 462 | /** | ||
| 463 | * Sets the type name used by the data source for values stored in the | ||
| 464 | * designated column to the given type name. | ||
| 465 | * | ||
| 466 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 467 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 468 | * @param typeName the data source-specific type name; if <i>typeName</i> is | ||
| 469 | * <code>null</code>, an empty <code>String</code> is set | ||
| 470 | * @throws SQLException if a database access error occurs | ||
| 471 | * or the given column number is out of bounds | ||
| 472 | */ | ||
| 473 | public void setColumnTypeName(int columnIndex, String typeName) | ||
| 474 | throws SQLException { | ||
| 475 | checkColRange(columnIndex); | ||
| 476 | if (typeName != null) { | ||
| 477 | colInfo[columnIndex].colTypeName = typeName; | ||
| 478 | } else { | ||
| 479 | colInfo[columnIndex].colTypeName = ""; | ||
| 480 | } | ||
| 481 | } | ||
| 482 | |||
| 483 | /** | ||
| 484 | * Retrieves the number of columns in the <code>RowSet</code> object | ||
| 485 | * for which this <code>RowSetMetaDataImpl</code> object was created. | ||
| 486 | * | ||
| 487 | * @return the number of columns | ||
| 488 | * @throws SQLException if an error occurs determining the column count | ||
| 489 | */ | ||
| 490 | public int getColumnCount() throws SQLException { | ||
| 491 | return colCount; | ||
| 492 | } | ||
| 493 | |||
| 494 | /** | ||
| 495 | * Retrieves whether a value stored in the designated column is | ||
| 496 | * automatically numbered, and thus readonly. | ||
| 497 | * | ||
| 498 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 499 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 500 | * @return <code>true</code> if the column is automatically numbered; | ||
| 501 | * <code>false</code> otherwise | ||
| 502 | * @throws SQLException if a database access error occurs | ||
| 503 | * or the given column number is out of bounds | ||
| 504 | */ | ||
| 505 | public boolean isAutoIncrement(int columnIndex) throws SQLException { | ||
| 506 | checkColRange(columnIndex); | ||
| 507 | return colInfo[columnIndex].autoIncrement; | ||
| 508 | } | ||
| 509 | |||
| 510 | /** | ||
| 511 | * Indicates whether the case of the designated column's name | ||
| 512 | * matters. | ||
| 513 | * | ||
| 514 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 515 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 516 | * @return <code>true</code> if the column name is case sensitive; | ||
| 517 | * <code>false</code> otherwise | ||
| 518 | * @throws SQLException if a database access error occurs | ||
| 519 | * or the given column number is out of bounds | ||
| 520 | */ | ||
| 521 | public boolean isCaseSensitive(int columnIndex) throws SQLException { | ||
| 522 | checkColRange(columnIndex); | ||
| 523 | return colInfo[columnIndex].caseSensitive; | ||
| 524 | } | ||
| 525 | |||
| 526 | /** | ||
| 527 | * Indicates whether a value stored in the designated column | ||
| 528 | * can be used in a <code>WHERE</code> clause. | ||
| 529 | * | ||
| 530 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 531 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 532 | * @return <code>true</code> if a value in the designated column can be used in a | ||
| 533 | * <code>WHERE</code> clause; <code>false</code> otherwise | ||
| 534 | * @throws SQLException if a database access error occurs | ||
| 535 | * or the given column number is out of bounds | ||
| 536 | */ | ||
| 537 | public boolean isSearchable(int columnIndex) throws SQLException { | ||
| 538 | checkColRange(columnIndex); | ||
| 539 | return colInfo[columnIndex].searchable; | ||
| 540 | } | ||
| 541 | |||
| 542 | /** | ||
| 543 | * Indicates whether a value stored in the designated column | ||
| 544 | * is a cash value. | ||
| 545 | * | ||
| 546 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 547 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 548 | * @return <code>true</code> if a value in the designated column is a cash value; | ||
| 549 | * <code>false</code> otherwise | ||
| 550 | * @throws SQLException if a database access error occurs | ||
| 551 | * or the given column number is out of bounds | ||
| 552 | */ | ||
| 553 | public boolean isCurrency(int columnIndex) throws SQLException { | ||
| 554 | checkColRange(columnIndex); | ||
| 555 | return colInfo[columnIndex].currency; | ||
| 556 | } | ||
| 557 | |||
| 558 | /** | ||
| 559 | * Retrieves a constant indicating whether it is possible | ||
| 560 | * to store a <code>NULL</code> value in the designated column. | ||
| 561 | * | ||
| 562 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 563 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 564 | * @return a constant from the <code>ResultSetMetaData</code> interface; | ||
| 565 | * either <code>columnNoNulls</code>, | ||
| 566 | * <code>columnNullable</code>, or | ||
| 567 | * <code>columnNullableUnknown</code> | ||
| 568 | * @throws SQLException if a database access error occurs | ||
| 569 | * or the given column number is out of bounds | ||
| 570 | */ | ||
| 571 | public int isNullable(int columnIndex) throws SQLException { | ||
| 572 | checkColRange(columnIndex); | ||
| 573 | return colInfo[columnIndex].nullable; | ||
| 574 | } | ||
| 575 | |||
| 576 | /** | ||
| 577 | * Indicates whether a value stored in the designated column is | ||
| 578 | * a signed number. | ||
| 579 | * | ||
| 580 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 581 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 582 | * @return <code>true</code> if if a value in the designated column is a signed | ||
| 583 | * number; <code>false</code> otherwise | ||
| 584 | * @throws SQLException if a database access error occurs | ||
| 585 | * or the given column number is out of bounds | ||
| 586 | */ | ||
| 587 | public boolean isSigned(int columnIndex) throws SQLException { | ||
| 588 | checkColRange(columnIndex); | ||
| 589 | return colInfo[columnIndex].signed; | ||
| 590 | } | ||
| 591 | |||
| 592 | /** | ||
| 593 | * Retrieves the normal maximum width in chars of the designated column. | ||
| 594 | * | ||
| 595 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 596 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 597 | * @return the maximum number of chars that can be displayed in the designated | ||
| 598 | * column | ||
| 599 | * @throws SQLException if a database access error occurs | ||
| 600 | * or the given column number is out of bounds | ||
| 601 | */ | ||
| 602 | public int getColumnDisplaySize(int columnIndex) throws SQLException { | ||
| 603 | checkColRange(columnIndex); | ||
| 604 | return colInfo[columnIndex].columnDisplaySize; | ||
| 605 | } | ||
| 606 | |||
| 607 | /** | ||
| 608 | * Retrieves the the suggested column title for the designated | ||
| 609 | * column for use in printouts and displays. | ||
| 610 | * | ||
| 611 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 612 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 613 | * @return the suggested column name to use in printouts and displays | ||
| 614 | * @throws SQLException if a database access error occurs | ||
| 615 | * or the given column number is out of bounds | ||
| 616 | */ | ||
| 617 | public String getColumnLabel(int columnIndex) throws SQLException { | ||
| 618 | checkColRange(columnIndex); | ||
| 619 | return colInfo[columnIndex].columnLabel; | ||
| 620 | } | ||
| 621 | |||
| 622 | /** | ||
| 623 | * Retrieves the name of the designated column. | ||
| 624 | * | ||
| 625 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 626 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 627 | * @return the column name of the designated column | ||
| 628 | * @throws SQLException if a database access error occurs | ||
| 629 | * or the given column number is out of bounds | ||
| 630 | */ | ||
| 631 | public String getColumnName(int columnIndex) throws SQLException { | ||
| 632 | checkColRange(columnIndex); | ||
| 633 | return colInfo[columnIndex].columnName; | ||
| 634 | } | ||
| 635 | |||
| 636 | /** | ||
| 637 | * Retrieves the schema name of the table from which the value | ||
| 638 | * in the designated column was derived. | ||
| 639 | * | ||
| 640 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 641 | * must be between <code>1</code> and the number of columns, | ||
| 642 | * inclusive | ||
| 643 | * @return the schema name or an empty <code>String</code> if no schema | ||
| 644 | * name is available | ||
| 645 | * @throws SQLException if a database access error occurs | ||
| 646 | * or the given column number is out of bounds | ||
| 647 | */ | ||
| 648 | public String getSchemaName(int columnIndex) throws SQLException { | ||
| 649 | checkColRange(columnIndex); | ||
| 650 | String str =""; | ||
| 651 | if(colInfo[columnIndex].schemaName == null){ | ||
| 652 | } else { | ||
| 653 | str = colInfo[columnIndex].schemaName; | ||
| 654 | } | ||
| 655 | return str; | ||
| 656 | } | ||
| 657 | |||
| 658 | /** | ||
| 659 | * Retrieves the total number of digits for values stored in | ||
| 660 | * the designated column. | ||
| 661 | * | ||
| 662 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 663 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 664 | * @return the precision for values stored in the designated column | ||
| 665 | * @throws SQLException if a database access error occurs | ||
| 666 | * or the given column number is out of bounds | ||
| 667 | */ | ||
| 668 | public int getPrecision(int columnIndex) throws SQLException { | ||
| 669 | checkColRange(columnIndex); | ||
| 670 | return colInfo[columnIndex].colPrecision; | ||
| 671 | } | ||
| 672 | |||
| 673 | /** | ||
| 674 | * Retrieves the number of digits to the right of the decimal point | ||
| 675 | * for values stored in the designated column. | ||
| 676 | * | ||
| 677 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 678 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 679 | * @return the scale for values stored in the designated column | ||
| 680 | * @throws SQLException if a database access error occurs | ||
| 681 | * or the given column number is out of bounds | ||
| 682 | */ | ||
| 683 | public int getScale(int columnIndex) throws SQLException { | ||
| 684 | checkColRange(columnIndex); | ||
| 685 | return colInfo[columnIndex].colScale; | ||
| 686 | } | ||
| 687 | |||
| 688 | /** | ||
| 689 | * Retrieves the name of the table from which the value | ||
| 690 | * in the designated column was derived. | ||
| 691 | * | ||
| 692 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 693 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 694 | * @return the table name or an empty <code>String</code> if no table name | ||
| 695 | * is available | ||
| 696 | * @throws SQLException if a database access error occurs | ||
| 697 | * or the given column number is out of bounds | ||
| 698 | */ | ||
| 699 | public String getTableName(int columnIndex) throws SQLException { | ||
| 700 | checkColRange(columnIndex); | ||
| 701 | return colInfo[columnIndex].tableName; | ||
| 702 | } | ||
| 703 | |||
| 704 | /** | ||
| 705 | * Retrieves the catalog name of the table from which the value | ||
| 706 | * in the designated column was derived. | ||
| 707 | * | ||
| 708 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 709 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 710 | * @return the catalog name of the column's table or an empty | ||
| 711 | * <code>String</code> if no catalog name is available | ||
| 712 | * @throws SQLException if a database access error occurs | ||
| 713 | * or the given column number is out of bounds | ||
| 714 | */ | ||
| 715 | public String getCatalogName(int columnIndex) throws SQLException { | ||
| 716 | checkColRange(columnIndex); | ||
| 717 | String str =""; | ||
| 718 | if(colInfo[columnIndex].catName == null){ | ||
| 719 | } else { | ||
| 720 | str = colInfo[columnIndex].catName; | ||
| 721 | } | ||
| 722 | return str; | ||
| 723 | } | ||
| 724 | |||
| 725 | /** | ||
| 726 | * Retrieves the type code (one of the <code>java.sql.Types</code> | ||
| 727 | * constants) for the SQL type of the value stored in the | ||
| 728 | * designated column. | ||
| 729 | * | ||
| 730 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 731 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 732 | * @return an <code>int</code> representing the SQL type of values | ||
| 733 | * stored in the designated column | ||
| 734 | * @throws SQLException if a database access error occurs | ||
| 735 | * or the given column number is out of bounds | ||
| 736 | * @see java.sql.Types | ||
| 737 | */ | ||
| 738 | public int getColumnType(int columnIndex) throws SQLException { | ||
| 739 | checkColRange(columnIndex); | ||
| 740 | return colInfo[columnIndex].colType; | ||
| 741 | } | ||
| 742 | |||
| 743 | /** | ||
| 744 | * Retrieves the DBMS-specific type name for values stored in the | ||
| 745 | * designated column. | ||
| 746 | * | ||
| 747 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 748 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 749 | * @return the type name used by the data source | ||
| 750 | * @throws SQLException if a database access error occurs | ||
| 751 | * or the given column number is out of bounds | ||
| 752 | */ | ||
| 753 | public String getColumnTypeName(int columnIndex) throws SQLException { | ||
| 754 | checkColRange(columnIndex); | ||
| 755 | return colInfo[columnIndex].colTypeName; | ||
| 756 | } | ||
| 757 | |||
| 758 | |||
| 759 | /** | ||
| 760 | * Indicates whether the designated column is definitely | ||
| 761 | * not writable, thus readonly. | ||
| 762 | * | ||
| 763 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 764 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 765 | * @return <code>true</code> if this <code>RowSet</code> object is read-Only | ||
| 766 | * and thus not updatable; <code>false</code> otherwise | ||
| 767 | * @throws SQLException if a database access error occurs | ||
| 768 | * or the given column number is out of bounds | ||
| 769 | */ | ||
| 770 | public boolean isReadOnly(int columnIndex) throws SQLException { | ||
| 771 | checkColRange(columnIndex); | ||
| 772 | return colInfo[columnIndex].readOnly; | ||
| 773 | } | ||
| 774 | |||
| 775 | /** | ||
| 776 | * Indicates whether it is possible for a write operation on | ||
| 777 | * the designated column to succeed. A return value of | ||
| 778 | * <code>true</code> means that a write operation may or may | ||
| 779 | * not succeed. | ||
| 780 | * | ||
| 781 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 782 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 783 | * @return <code>true</code> if a write operation on the designated column may | ||
| 784 | * will succeed; <code>false</code> otherwise | ||
| 785 | * @throws SQLException if a database access error occurs | ||
| 786 | * or the given column number is out of bounds | ||
| 787 | */ | ||
| 788 | public boolean isWritable(int columnIndex) throws SQLException { | ||
| 789 | checkColRange(columnIndex); | ||
| 790 | return colInfo[columnIndex].writable; | ||
| 791 | } | ||
| 792 | |||
| 793 | /** | ||
| 794 | * Indicates whether a write operation on the designated column | ||
| 795 | * will definitely succeed. | ||
| 796 | * | ||
| 797 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 798 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 799 | * @return <code>true</code> if a write operation on the designated column will | ||
| 800 | * definitely succeed; <code>false</code> otherwise | ||
| 801 | * @throws SQLException if a database access error occurs | ||
| 802 | * or the given column number is out of bounds | ||
| 803 | */ | ||
| 804 | public boolean isDefinitelyWritable(int columnIndex) | ||
| 805 | throws SQLException { return true;} | ||
| 806 | |||
| 807 | /** | ||
| 808 | * Retrieves the fully-qualified name of the class in the Java | ||
| 809 | * programming language to which a value in the designated column | ||
| 810 | * will be mapped. For example, if the value is an <code>int</code>, | ||
| 811 | * the class name returned by this method will be | ||
| 812 | * <code>java.lang.Integer</code>. | ||
| 813 | * <P> | ||
| 814 | * If the value in the designated column has a custom mapping, | ||
| 815 | * this method returns the name of the class that implements | ||
| 816 | * <code>SQLData</code>. When the method <code>ResultSet.getObject</code> | ||
| 817 | * is called to retrieve a value from the designated column, it will | ||
| 818 | * create an instance of this class or one of its subclasses. | ||
| 819 | * | ||
| 820 | * @param columnIndex the first column is 1, the second is 2, and so on; | ||
| 821 | * must be between <code>1</code> and the number of columns, inclusive | ||
| 822 | * @return the fully-qualified name of the class in the Java programming | ||
| 823 | * language that would be used by the method <code>RowSet.getObject</code> to | ||
| 824 | * retrieve the value in the specified column. This is the class | ||
| 825 | * name used for custom mapping when there is a custom mapping. | ||
| 826 | * @throws SQLException if a database access error occurs | ||
| 827 | * or the given column number is out of bounds | ||
| 828 | */ | ||
| 829 | public String getColumnClassName(int columnIndex) throws SQLException { | ||
| 830 | String className = String.class.getName(); | ||
| 831 | |||
| 832 | int sqlType = getColumnType(columnIndex); | ||
| 833 | |||
| 834 | switch (sqlType) { | ||
| 835 | |||
| 836 | case Types.NUMERIC: | ||
| 837 | case Types.DECIMAL: | ||
| 838 | className = java.math.BigDecimal.class.getName(); | ||
| 839 | break; | ||
| 840 | |||
| 841 | case Types.BIT: | ||
| 842 | className = java.lang.Boolean.class.getName(); | ||
| 843 | break; | ||
| 844 | |||
| 845 | case Types.TINYINT: | ||
| 846 | className = java.lang.Byte.class.getName(); | ||
| 847 | break; | ||
| 848 | |||
| 849 | case Types.SMALLINT: | ||
| 850 | className = java.lang.Short.class.getName(); | ||
| 851 | break; | ||
| 852 | |||
| 853 | case Types.INTEGER: | ||
| 854 | className = java.lang.Integer.class.getName(); | ||
| 855 | break; | ||
| 856 | |||
| 857 | case Types.BIGINT: | ||
| 858 | className = java.lang.Long.class.getName(); | ||
| 859 | break; | ||
| 860 | |||
| 861 | case Types.REAL: | ||
| 862 | className = java.lang.Float.class.getName(); | ||
| 863 | break; | ||
| 864 | |||
| 865 | case Types.FLOAT: | ||
| 866 | case Types.DOUBLE: | ||
| 867 | className = java.lang.Double.class.getName(); | ||
| 868 | break; | ||
| 869 | |||
| 870 | case Types.BINARY: | ||
| 871 | case Types.VARBINARY: | ||
| 872 | case Types.LONGVARBINARY: | ||
| 873 | className = "byte[]"; | ||
| 874 | break; | ||
| 875 | |||
| 876 | case Types.DATE: | ||
| 877 | className = java.sql.Date.class.getName(); | ||
| 878 | break; | ||
| 879 | |||
| 880 | case Types.TIME: | ||
| 881 | className = java.sql.Time.class.getName(); | ||
| 882 | break; | ||
| 883 | |||
| 884 | case Types.TIMESTAMP: | ||
| 885 | className = java.sql.Timestamp.class.getName(); | ||
| 886 | break; | ||
| 887 | |||
| 888 | case Types.BLOB: | ||
| 889 | className = java.sql.Blob.class.getName(); | ||
| 890 | break; | ||
| 891 | |||
| 892 | case Types.CLOB: | ||
| 893 | className = java.sql.Clob.class.getName(); | ||
| 894 | break; | ||
| 895 | } | ||
| 896 | |||
| 897 | return className; | ||
| 898 | } | ||
| 899 | |||
| 900 | /** | ||
| 901 | * Returns an object that implements the given interface to allow access to non-standard methods, | ||
| 902 | * or standard methods not exposed by the proxy. | ||
| 903 | * The result may be either the object found to implement the interface or a proxy for that object. | ||
| 904 | * If the receiver implements the interface then that is the object. If the receiver is a wrapper | ||
| 905 | * and the wrapped object implements the interface then that is the object. Otherwise the object is | ||
| 906 | * the result of calling <code>unwrap</code> recursively on the wrapped object. If the receiver is not a | ||
| 907 | * wrapper and does not implement the interface, then an <code>SQLException</code> is thrown. | ||
| 908 | * | ||
| 909 | * @param iface A Class defining an interface that the result must implement. | ||
| 910 | * @return an object that implements the interface. May be a proxy for the actual implementing object. | ||
| 911 | * @throws java.sql.SQLException If no object found that implements the interface | ||
| 912 | * @since 1.6 | ||
| 913 | */ | ||
| 914 | public <T> T unwrap(java.lang.Class<T> iface) throws java.sql.SQLException { | ||
| 915 | |||
| 916 | if(isWrapperFor(iface)) { | ||
| 917 | return iface.cast(this); | ||
| 918 | } else { | ||
| 919 | throw new SQLException("unwrap failed for:"+ iface); | ||
| 920 | } | ||
| 921 | } | ||
| 922 | |||
| 923 | /** | ||
| 924 | * Returns true if this either implements the interface argument or is directly or indirectly a wrapper | ||
| 925 | * for an object that does. Returns false otherwise. If this implements the interface then return true, | ||
| 926 | * else if this is a wrapper then return the result of recursively calling <code>isWrapperFor</code> on the wrapped | ||
| 927 | * object. If this does not implement the interface and is not a wrapper, return false. | ||
| 928 | * This method should be implemented as a low-cost operation compared to <code>unwrap</code> so that | ||
| 929 | * callers can use this method to avoid expensive <code>unwrap</code> calls that may fail. If this method | ||
| 930 | * returns true then calling <code>unwrap</code> with the same argument should succeed. | ||
| 931 | * | ||
| 932 | * @param interfaces a Class defining an interface. | ||
| 933 | * @return true if this implements the interface or directly or indirectly wraps an object that does. | ||
| 934 | * @throws java.sql.SQLException if an error occurs while determining whether this is a wrapper | ||
| 935 | * for an object with the given interface. | ||
| 936 | * @since 1.6 | ||
| 937 | */ | ||
| 938 | public boolean isWrapperFor(Class<?> interfaces) throws SQLException { | ||
| 939 | return interfaces.isInstance(this); | ||
| 940 | } | ||
| 941 | |||
| 942 | static final long serialVersionUID = 6893806403181801867L; | ||
| 943 | |||
| 944 | private class ColInfo implements Serializable { | ||
| 945 | /** | ||
| 946 | * The field that indicates whether the value in this column is a number | ||
| 947 | * that is incremented automatically, which makes the value read-only. | ||
| 948 | * <code>true</code> means that the value in this column | ||
| 949 | * is automatically numbered; <code>false</code> means that it is not. | ||
| 950 | * | ||
| 951 | * @serial | ||
| 952 | */ | ||
| 953 | public boolean autoIncrement; | ||
| 954 | |||
| 955 | /** | ||
| 956 | * The field that indicates whether the value in this column is case sensitive. | ||
| 957 | * <code>true</code> means that it is; <code>false</code> that it is not. | ||
| 958 | * | ||
| 959 | * @serial | ||
| 960 | */ | ||
| 961 | public boolean caseSensitive; | ||
| 962 | |||
| 963 | /** | ||
| 964 | * The field that indicates whether the value in this column is a cash value | ||
| 965 | * <code>true</code> means that it is; <code>false</code> that it is not. | ||
| 966 | * | ||
| 967 | * @serial | ||
| 968 | */ | ||
| 969 | public boolean currency; | ||
| 970 | |||
| 971 | /** | ||
| 972 | * The field that indicates whether the value in this column is nullable. | ||
| 973 | * The possible values are the <code>ResultSet</code> constants | ||
| 974 | * <code>columnNoNulls</code>, <code>columnNullable</code>, and | ||
| 975 | * <code>columnNullableUnknown</code>. | ||
| 976 | * | ||
| 977 | * @serial | ||
| 978 | */ | ||
| 979 | public int nullable; | ||
| 980 | |||
| 981 | /** | ||
| 982 | * The field that indicates whether the value in this column is a signed number. | ||
| 983 | * <code>true</code> means that it is; <code>false</code> that it is not. | ||
| 984 | * | ||
| 985 | * @serial | ||
| 986 | */ | ||
| 987 | public boolean signed; | ||
| 988 | |||
| 989 | /** | ||
| 990 | * The field that indicates whether the value in this column can be used in | ||
| 991 | * a <code>WHERE</code> clause. | ||
| 992 | * <code>true</code> means that it can; <code>false</code> that it cannot. | ||
| 993 | * | ||
| 994 | * @serial | ||
| 995 | */ | ||
| 996 | public boolean searchable; | ||
| 997 | |||
| 998 | /** | ||
| 999 | * The field that indicates the normal maximum width in characters for | ||
| 1000 | * this column. | ||
| 1001 | * | ||
| 1002 | * @serial | ||
| 1003 | */ | ||
| 1004 | public int columnDisplaySize; | ||
| 1005 | |||
| 1006 | /** | ||
| 1007 | * The field that holds the suggested column title for this column, to be | ||
| 1008 | * used in printing and displays. | ||
| 1009 | * | ||
| 1010 | * @serial | ||
| 1011 | */ | ||
| 1012 | public String columnLabel; | ||
| 1013 | |||
| 1014 | /** | ||
| 1015 | * The field that holds the name of this column. | ||
| 1016 | * | ||
| 1017 | * @serial | ||
| 1018 | */ | ||
| 1019 | public String columnName; | ||
| 1020 | |||
| 1021 | /** | ||
| 1022 | * The field that holds the schema name for the table from which this column | ||
| 1023 | * was derived. | ||
| 1024 | * | ||
| 1025 | * @serial | ||
| 1026 | */ | ||
| 1027 | public String schemaName; | ||
| 1028 | |||
| 1029 | /** | ||
| 1030 | * The field that holds the precision of the value in this column. For number | ||
| 1031 | * types, the precision is the total number of decimal digits; for character types, | ||
| 1032 | * it is the maximum number of characters; for binary types, it is the maximum | ||
| 1033 | * length in bytes. | ||
| 1034 | * | ||
| 1035 | * @serial | ||
| 1036 | */ | ||
| 1037 | public int colPrecision; | ||
| 1038 | |||
| 1039 | /** | ||
| 1040 | * The field that holds the scale (number of digits to the right of the decimal | ||
| 1041 | * point) of the value in this column. | ||
| 1042 | * | ||
| 1043 | * @serial | ||
| 1044 | */ | ||
| 1045 | public int colScale; | ||
| 1046 | |||
| 1047 | /** | ||
| 1048 | * The field that holds the name of the table from which this column | ||
| 1049 | * was derived. This value may be the empty string if there is no | ||
| 1050 | * table name, such as when this column is produced by a join. | ||
| 1051 | * | ||
| 1052 | * @serial | ||
| 1053 | */ | ||
| 1054 | public String tableName =""; | ||
| 1055 | |||
| 1056 | /** | ||
| 1057 | * The field that holds the catalog name for the table from which this column | ||
| 1058 | * was derived. If the DBMS does not support catalogs, the value may be the | ||
| 1059 | * empty string. | ||
| 1060 | * | ||
| 1061 | * @serial | ||
| 1062 | */ | ||
| 1063 | public String catName; | ||
| 1064 | |||
| 1065 | /** | ||
| 1066 | * The field that holds the type code from the class <code>java.sql.Types</code> | ||
| 1067 | * indicating the type of the value in this column. | ||
| 1068 | * | ||
| 1069 | * @serial | ||
| 1070 | */ | ||
| 1071 | public int colType; | ||
| 1072 | |||
| 1073 | /** | ||
| 1074 | * The field that holds the the type name used by this particular data source | ||
| 1075 | * for the value stored in this column. | ||
| 1076 | * | ||
| 1077 | * @serial | ||
| 1078 | */ | ||
| 1079 | public String colTypeName; | ||
| 1080 | |||
| 1081 | /** | ||
| 1082 | * The field that holds the updatablity boolean per column of a RowSet | ||
| 1083 | * | ||
| 1084 | * @serial | ||
| 1085 | */ | ||
| 1086 | public boolean readOnly = false; | ||
| 1087 | |||
| 1088 | /** | ||
| 1089 | * The field that hold the writable boolean per column of a RowSet | ||
| 1090 | * | ||
| 1091 | *@serial | ||
| 1092 | */ | ||
| 1093 | public boolean writable = true; | ||
| 1094 | } | ||
| 1095 | } | ||