1 /*
   2  * Copyright (c) 2013, 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 package java.sql;
  26 
  27 /**
  28  * <P>Defines the constants that are used to identify generic
  29  * SQL types, called JDBC types.
  30  * <p>
  31  * @see SQLType
  32  * @since 1.8
  33  */
  34 public enum JDBCType implements SQLType {
  35 
  36     /**
  37      * Identifies the generic SQL type {@code BIT}.
  38      */
  39     BIT(Types.BIT),
  40     /**
  41      * Identifies the generic SQL type {@code TINYINT}.
  42      */
  43     TINYINT(Types.TINYINT),
  44     /**
  45      * Identifies the generic SQL type {@code SMALLINT}.
  46      */
  47     SMALLINT(Types.SMALLINT),
  48     /**
  49      * Identifies the generic SQL type {@code INTEGER}.
  50      */
  51     INTEGER(Types.INTEGER),
  52     /**
  53      * Identifies the generic SQL type {@code BIGINT}.
  54      */
  55     BIGINT(Types.BIGINT),
  56     /**
  57      * Identifies the generic SQL type {@code FLOAT}.
  58      */
  59     FLOAT(Types.FLOAT),
  60     /**
  61      * Identifies the generic SQL type {@code REAL}.
  62      */
  63     REAL(Types.REAL),
  64     /**
  65      * Identifies the generic SQL type {@code DOUBLE}.
  66      */
  67     DOUBLE(Types.DOUBLE),
  68     /**
  69      * Identifies the generic SQL type {@code NUMERIC}.
  70      */
  71     NUMERIC(Types.NUMERIC),
  72     /**
  73      * Identifies the generic SQL type {@code DECIMAL}.
  74      */
  75     DECIMAL(Types.DECIMAL),
  76     /**
  77      * Identifies the generic SQL type {@code CHAR}.
  78      */
  79     CHAR(Types.CHAR),
  80     /**
  81      * Identifies the generic SQL type {@code VARCHAR}.
  82      */
  83     VARCHAR(Types.VARCHAR),
  84     /**
  85      * Identifies the generic SQL type {@code LONGVARCHAR}.
  86      */
  87     LONGVARCHAR(Types.LONGVARCHAR),
  88     /**
  89      * Identifies the generic SQL type {@code DATE}.
  90      */
  91     DATE(Types.DATE),
  92     /**
  93      * Identifies the generic SQL type {@code TIME}.
  94      */
  95     TIME(Types.TIME),
  96     /**
  97      * Identifies the generic SQL type {@code TIMESTAMP}.
  98      */
  99     TIMESTAMP(Types.TIMESTAMP),
 100     /**
 101      * Identifies the generic SQL type {@code BINARY}.
 102      */
 103     BINARY(Types.BINARY),
 104     /**
 105      * Identifies the generic SQL type {@code VARBINARY}.
 106      */
 107     VARBINARY(Types.VARBINARY),
 108     /**
 109      * Identifies the generic SQL type {@code LONGVARBINARY}.
 110      */
 111     LONGVARBINARY(Types.LONGVARBINARY),
 112     /**
 113      * Identifies the generic SQL value {@code NULL}.
 114      */
 115     NULL(Types.NULL),
 116     /**
 117      * Indicates that the SQL type
 118      * is database-specific and gets mapped to a Java object that can be
 119      * accessed via the methods getObject and setObject.
 120      */
 121     OTHER(Types.OTHER),
 122     /**
 123      * Indicates that the SQL type
 124      * is database-specific and gets mapped to a Java object that can be
 125      * accessed via the methods getObject and setObject.
 126      */
 127     JAVA_OBJECT(Types.JAVA_OBJECT),
 128     /**
 129      * Identifies the generic SQL type {@code DISTINCT}.
 130      */
 131     DISTINCT(Types.DISTINCT),
 132     /**
 133      * Identifies the generic SQL type {@code STRUCT}.
 134      */
 135     STRUCT(Types.STRUCT),
 136     /**
 137      * Identifies the generic SQL type {@code ARRAY}.
 138      */
 139     ARRAY(Types.ARRAY),
 140     /**
 141      * Identifies the generic SQL type {@code BLOB}.
 142      */
 143     BLOB(Types.BLOB),
 144     /**
 145      * Identifies the generic SQL type {@code CLOB}.
 146      */
 147     CLOB(Types.CLOB),
 148     /**
 149      * Identifies the generic SQL type {@code REF}.
 150      */
 151     REF(Types.REF),
 152     /**
 153      * Identifies the generic SQL type {@code DATALINK}.
 154      */
 155     DATALINK(Types.DATALINK),
 156     /**
 157      * Identifies the generic SQL type {@code BOOLEAN}.
 158      */
 159     BOOLEAN(Types.BOOLEAN),
 160 
 161     /* JDBC 4.0 Types */
 162 
 163     /**
 164      * Identifies the SQL type {@code ROWID}.
 165      */
 166     ROWID(Types.ROWID),
 167     /**
 168      * Identifies the generic SQL type {@code NCHAR}.
 169      */
 170     NCHAR(Types.NCHAR),
 171     /**
 172      * Identifies the generic SQL type {@code NVARCHAR}.
 173      */
 174     NVARCHAR(Types.NVARCHAR),
 175     /**
 176      * Identifies the generic SQL type {@code LONGNVARCHAR}.
 177      */
 178     LONGNVARCHAR(Types.LONGNVARCHAR),
 179     /**
 180      * Identifies the generic SQL type {@code NCLOB}.
 181      */
 182     NCLOB(Types.NCLOB),
 183     /**
 184      * Identifies the generic SQL type {@code SQLXML}.
 185      */
 186     SQLXML(Types.SQLXML),
 187 
 188     /* JDBC 4.2 Types */
 189 
 190     /**
 191      * Identifies the generic SQL type {@code REF_CURSOR}.
 192      */
 193     REF_CURSOR(Types.REF_CURSOR),
 194 
 195     /**
 196      * Identifies the generic SQL type {@code TIME_WITH_TIMEZONE}.
 197      */
 198     TIME_WITH_TIMEZONE(Types.TIME_WITH_TIMEZONE),
 199 
 200     /**
 201      * Identifies the generic SQL type {@code TIMESTAMP_WITH_TIMEZONE}.
 202      */
 203     TIMESTAMP_WITH_TIMEZONE(Types.TIMESTAMP_WITH_TIMEZONE);
 204 
 205     /**
 206      * The Integer value for the JDBCType.  It maps to a value in
 207      * {@code Types.java}
 208      */
 209     private Integer type;
 210 
 211     /**
 212      * Constructor to specify the data type value from {@code Types) for
 213      * this data type.
 214      * @param type The value from {@code Types) for this data type
 215      */
 216     JDBCType(final Integer type) {
 217         this.type = type;
 218     }
 219 
 220     /**
 221      *{@inheritDoc }
 222      * @return The name of this {@code SQLType}.
 223      */
 224     public String getName() {
 225         return name();
 226     }
 227     /**
 228      * Returns the name of the vendor that supports this data type.
 229      * @return  The name of the vendor for this data type which is
 230      * {@literal java.sql} for JDBCType.
 231      */
 232     public String getVendor() {
 233         return "java.sql";
 234     }
 235 
 236     /**
 237      * Returns the vendor specific type number for the data type.
 238      * @return  An Integer representing the data type. For {@code JDBCType},
 239      * the value will be the same value as in {@code Types} for the data type.
 240      */
 241     public Integer getVendorTypeNumber() {
 242         return type;
 243     }
 244     /**
 245      * Returns the {@code JDBCType} that corresponds to the specified
 246      * {@code Types} value
 247      * @param type {@code Types} value
 248      * @return The {@code JDBCType} constant
 249      * @throws IllegalArgumentException if this enum type has no constant with
 250      * the specified {@code Types} value
 251      * @see Types
 252      */
 253     public static JDBCType valueOf(int type) {
 254         for( JDBCType sqlType : JDBCType.class.getEnumConstants()) {
 255             if(type == sqlType.type)
 256                 return sqlType;
 257         }
 258         throw new IllegalArgumentException("Type:" + type + " is not a valid "
 259                 + "Types.java value.");
 260     }
 261 }