Java tutorial
package org.jumpmind.db.model; /* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ import static org.jumpmind.db.model.ColumnTypes.ORACLE_TIMESTAMPLTZ; import static org.jumpmind.db.model.ColumnTypes.ORACLE_TIMESTAMPTZ; import java.io.Serializable; import java.math.BigDecimal; import java.sql.Date; import java.sql.Time; import java.sql.Timestamp; import java.sql.Types; import java.util.Collection; import java.util.HashMap; import java.util.Map; import org.apache.commons.lang.builder.EqualsBuilder; import org.apache.commons.lang.builder.HashCodeBuilder; import org.jumpmind.db.platform.PlatformUtils; import org.jumpmind.util.FormatUtils; /** * Represents a column in the database model. */ public class Column implements Cloneable, Serializable { /** Unique ID for serialization purposes. */ private static final long serialVersionUID = -6226348998874210093L; /** The name of the column. */ private String name; /** * The java name of the column (optional and unused by DdlUtils, for Torque * compatibility). */ private String javaName; /** The column's description. */ private String description; /** Whether the column is a primary key column. */ private boolean primaryKey; /** * Whether the column is required, ie. it must not contain <code>NULL</code> */ private boolean required; /** Whether the column's value is incremented automatically. */ private boolean autoIncrement; /** * The mapped JDBC type code */ private int mappedTypeCode; /** * The mapped JDBC type */ private String mappedType; /** The size of the column for JDBC types that require/support this. */ private String size; /** The size of the column for JDBC types that require/support this. */ private Integer sizeAsInt; /** The scale of the column for JDBC types that require/support this. */ private int scale; /** The default value. */ private String defaultValue; /** * The actual JDBC type code. */ private int jdbcTypeCode = Integer.MIN_VALUE; /** * The actual JDBC type name. */ private String jdbcTypeName; private boolean distributionKey; private int precisionRadix; private Map<String, PlatformColumn> platformColumns; private String[] enumValues; public Column() { } public Column(String name) { this(name, false); } public Column(String name, boolean primaryKey) { setName(name); setPrimaryKey(primaryKey); } public Column(String name, boolean primaryKey, int typeCode, int size, int scale) { setName(name); setPrimaryKey(primaryKey); setRequired(primaryKey); setTypeCode(typeCode); setSizeAndScale(size, scale); } /** * Returns the name of the column. * * @return The name */ public String getName() { return name; } /** * Sets the name of the column. * * @param name * The name */ public void setName(String name) { this.name = name; } /** * Returns the java name of the column. This property is unused by DdlUtils * and only for Torque compatibility. * * @return The java name */ public String getJavaName() { return javaName; } /** * Sets the java name of the column. This property is unused by DdlUtils and * only for Torque compatibility. * * @param javaName * The java name */ public void setJavaName(String javaName) { this.javaName = javaName; } /** * Returns the description of the column. * * @return The description */ public String getDescription() { return description; } /** * Sets the description of the column. * * @param description * The description */ public void setDescription(String description) { this.description = description; } /** * Determines whether this column is a primary key column. * * @return <code>true</code> if this column is a primary key column */ public boolean isPrimaryKey() { return primaryKey; } /** * Specifies whether this column is a primary key column. * * @param primaryKey * <code>true</code> if this column is a primary key column */ public void setPrimaryKey(boolean primaryKey) { this.primaryKey = primaryKey; } /** * Determines whether this column is a required column, ie. that it is not * allowed to contain <code>NULL</code> values. * * @return <code>true</code> if this column is a required column */ public boolean isRequired() { return required; } /** * Specifies whether this column is a required column, ie. that it is not * allowed to contain <code>NULL</code> values. * * @param required * <code>true</code> if this column is a required column */ public void setRequired(boolean required) { this.required = required; } /** * Determines whether this column is an auto-increment column. * * @return <code>true</code> if this column is an auto-increment column */ public boolean isAutoIncrement() { return autoIncrement; } /** * Specifies whether this column is an auto-increment column. * * @param autoIncrement * <code>true</code> if this column is an auto-increment column */ public void setAutoIncrement(boolean autoIncrement) { this.autoIncrement = autoIncrement; } /** * Returns the code (one of the constants in {@link java.sql.Types}) of the * JDBC type of the column. * * @return The type code */ public int getMappedTypeCode() { return mappedTypeCode; } /** * Sets the code (one of the constants in {@link java.sql.Types}) of the * JDBC type of the column. * * @param typeCode * The type code */ public void setMappedTypeCode(int typeCode) { this.mappedType = TypeMap.getJdbcTypeName(typeCode); if (this.mappedType == null) { throw new ModelException("Unknown JDBC type code " + typeCode + " for : " + toString()); } this.mappedTypeCode = typeCode; } /** * Returns the JDBC type of the column. * * @return The type */ public String getMappedType() { return mappedType; } /** * Sets the JDBC type of the column. * * @param type * The type */ public void setMappedType(String type) { Integer typeCode = TypeMap.getJdbcTypeCode(type); if (typeCode == null) { throw new ModelException("Unknown JDBC type " + type + " for : " + toString()); } else { this.mappedTypeCode = typeCode.intValue(); // we get the corresponding string value from the TypeMap in order // to detect extension types which we don't want in the model this.mappedType = TypeMap.getJdbcTypeName(typeCode); } } /** * Determines whether this column is of a numeric type. * * @return <code>true</code> if this column is of a numeric type */ public boolean isOfNumericType() { return TypeMap.isNumericType(getMappedTypeCode()); } /** * Determines whether this column is of a text type. * * @return <code>true</code> if this column is of a text type */ public boolean isOfTextType() { return TypeMap.isTextType(getMappedTypeCode()); } /** * Determines whether this column is of a binary type. * * @return <code>true</code> if this column is of a binary type */ public boolean isOfBinaryType() { return TypeMap.isBinaryType(getMappedTypeCode()); } /** * Determines whether this column is of a special type. * * @return <code>true</code> if this column is of a special type */ public boolean isOfSpecialType() { return TypeMap.isSpecialType(getMappedTypeCode()); } /** * Returns the size of the column. * * @return The size */ public String getSize() { return size; } /** * Returns the size of the column as an integer. * * @return The size as an integer */ public int getSizeAsInt() { return sizeAsInt == null ? 0 : sizeAsInt.intValue(); } /** * Sets the size of the column. This is either a simple integer value or a * comma-separated pair of integer values specifying the size and scale. * * @param size * The size */ public void setSize(String size) { if (size != null) { int pos = size.indexOf(","); this.size = size; if (pos < 0) { scale = 0; sizeAsInt = new Integer(size); } else { sizeAsInt = new Integer(size.substring(0, pos)); scale = Integer.parseInt(size.substring(pos + 1)); } } else { size = null; sizeAsInt = null; scale = 0; } } /** * Returns the scale of the column. * * @return The scale */ public int getScale() { return scale; } /** * Sets the scale of the column. * * @param scale * The scale */ public void setScale(int scale) { setSizeAndScale(getSizeAsInt(), scale); } /** * Sets both the size and scale. * * @param size * The size * @param scale * The scale */ public void setSizeAndScale(int size, int scale) { sizeAsInt = new Integer(size); this.scale = scale; this.size = String.valueOf(size); if (scale > 0) { this.size += "," + scale; } } /** * Returns the precision radix of the column. * * @return The precision radix */ public int getPrecisionRadix() { return this.precisionRadix; } /** * Sets the precision radix of the column. * * @param precisionRadix * The precision radix */ public void setPrecisionRadix(int precisionRadix) { this.precisionRadix = precisionRadix; } /** * Returns the default value of the column. * * @return The default value */ public String getDefaultValue() { return defaultValue; } /** * Tries to parse the default value of the column and returns it as an * object of the corresponding java type. If the value could not be parsed, * then the original definition is returned. * * @return The parsed default value */ public Object getParsedDefaultValue() { if ((defaultValue != null) && (defaultValue.length() > 0)) { try { switch (mappedTypeCode) { case Types.TINYINT: case Types.SMALLINT: return new Short(defaultValue); case Types.INTEGER: try { return new Integer(defaultValue); } catch (NumberFormatException e) { return new Long(defaultValue); } case Types.BIGINT: return new Long(defaultValue); case Types.DECIMAL: case Types.NUMERIC: return new BigDecimal(defaultValue); case Types.REAL: return new Float(defaultValue); case Types.DOUBLE: case Types.FLOAT: return new Double(defaultValue); case Types.DATE: return Date.valueOf(defaultValue); case Types.TIME: return Time.valueOf(defaultValue); case Types.TIMESTAMP: return Timestamp.valueOf(defaultValue); case Types.BIT: return FormatUtils.toBoolean(defaultValue); default: if (PlatformUtils.supportsJava14JdbcTypes() && (mappedTypeCode == PlatformUtils.determineBooleanTypeCode())) { return FormatUtils.toBoolean(defaultValue); } break; } } catch (NumberFormatException ex) { return null; } catch (IllegalArgumentException ex) { return null; } } return defaultValue; } public void removePlatformColumn(String databaseName) { if (platformColumns != null) { platformColumns.remove(databaseName); } } public void addPlatformColumn(PlatformColumn platformColumn) { if (platformColumns == null) { platformColumns = new HashMap<String, PlatformColumn>(); } platformColumns.put(platformColumn.getName(), platformColumn); } public Map<String, PlatformColumn> getPlatformColumns() { return platformColumns; } public PlatformColumn findPlatformColumn(String name) { PlatformColumn platformColumn = null; if (platformColumns != null) { platformColumn = platformColumns.get(name); } return platformColumn; } /** * Sets the default value of the column. Note that this expression will be * used within quotation marks when generating the column, and thus is * subject to the conversion rules of the target database. * * @param defaultValue * The default value */ public void setDefaultValue(String defaultValue) { this.defaultValue = defaultValue; if (platformColumns != null) { Collection<PlatformColumn> cols = platformColumns.values(); for (PlatformColumn platformColumn : cols) { platformColumn.setDefaultValue(defaultValue); } } } /** * {@inheritDoc} */ public Object clone() throws CloneNotSupportedException { Column result = (Column) super.clone(); result.name = name; result.javaName = javaName; result.primaryKey = primaryKey; result.required = required; result.autoIncrement = autoIncrement; result.mappedTypeCode = mappedTypeCode; result.mappedType = mappedType; result.size = size; result.defaultValue = defaultValue; result.scale = scale; result.size = size; result.sizeAsInt = sizeAsInt; if (platformColumns != null) { result.platformColumns = new HashMap<String, PlatformColumn>(platformColumns.size()); for (Map.Entry<String, PlatformColumn> entry : platformColumns.entrySet()) { result.platformColumns.put(entry.getKey(), (PlatformColumn) entry.getValue().clone()); } } return result; } /** * {@inheritDoc} */ public boolean equals(Object obj) { if (obj instanceof Column) { Column other = (Column) obj; EqualsBuilder comparator = new EqualsBuilder(); // Note that this compares case sensitive comparator.append(name, other.name); comparator.append(primaryKey, other.primaryKey); comparator.append(required, other.required); comparator.append(autoIncrement, other.autoIncrement); comparator.append(mappedTypeCode, other.mappedTypeCode); comparator.append(getParsedDefaultValue(), other.getParsedDefaultValue()); // comparing the size makes only sense for types where it is // relevant if ((mappedTypeCode == Types.NUMERIC) || (mappedTypeCode == Types.DECIMAL)) { comparator.append(size, other.size); comparator.append(scale, other.scale); } else if ((mappedTypeCode == Types.CHAR) || (mappedTypeCode == Types.VARCHAR) || (mappedTypeCode == Types.BINARY) || (mappedTypeCode == Types.VARBINARY)) { comparator.append(size, other.size); } return comparator.isEquals(); } else { return false; } } /** * {@inheritDoc} */ public int hashCode() { HashCodeBuilder builder = new HashCodeBuilder(17, 37); builder.append(name); builder.append(primaryKey); builder.append(required); builder.append(autoIncrement); builder.append(mappedTypeCode); builder.append(mappedType); builder.append(scale); builder.append(getParsedDefaultValue()); if (!TypeMap.isNumericType(mappedTypeCode)) { builder.append(size); } return builder.toHashCode(); } /** * {@inheritDoc} */ public String toString() { StringBuffer result = new StringBuffer(); result.append("Column [name="); result.append(getName()); result.append("; jdbcType="); result.append(getJdbcTypeName()); result.append("; mappedType="); result.append(getMappedType()); result.append("]"); return result.toString(); } /** * Returns a verbose string representation of this column. * * @return The string representation */ public String toVerboseString() { StringBuffer result = new StringBuffer(); result.append("Column [name="); result.append(getName()); result.append("; javaName="); result.append(getJavaName()); result.append("; type="); result.append(getMappedType()); result.append("; typeCode="); result.append(getMappedTypeCode()); result.append("; size="); result.append(getSize()); result.append("; required="); result.append(isRequired()); result.append("; primaryKey="); result.append(isPrimaryKey()); result.append("; autoIncrement="); result.append(isAutoIncrement()); result.append("; defaultValue="); result.append(getDefaultValue()); result.append("; precisionRadix="); result.append(getPrecisionRadix()); result.append("; scale="); result.append(getScale()); result.append("]"); return result.toString(); } public void setJdbcTypeName(String jdbcTypeName) { this.jdbcTypeName = jdbcTypeName; } public String getJdbcTypeName() { return jdbcTypeName; } public boolean isDistributionKey() { return distributionKey; } public void setDistributionKey(boolean distributionKey) { this.distributionKey = distributionKey; } public void setTypeCode(int typeCode) { this.setMappedTypeCode(typeCode); this.setJdbcTypeCode(typeCode); } public void setJdbcTypeCode(int jdbcTypeCode) { this.jdbcTypeCode = jdbcTypeCode; } public int getJdbcTypeCode() { return jdbcTypeCode; } public boolean isTimestampWithTimezone() { return mappedTypeCode == ORACLE_TIMESTAMPLTZ || mappedTypeCode == ORACLE_TIMESTAMPTZ || jdbcTypeCode == ORACLE_TIMESTAMPLTZ || jdbcTypeCode == ORACLE_TIMESTAMPTZ || (jdbcTypeName != null && jdbcTypeName.equals("timestamptz")); } public boolean containsJdbcTypes() { return jdbcTypeCode != Integer.MIN_VALUE && jdbcTypeName != null; } public void setEnumValues(String[] enumValues) { this.enumValues = enumValues; } public String[] getEnumValues() { return enumValues; } public boolean isEnum() { return enumValues != null && enumValues.length > 0; } }