column.java

OBPM是一个开源

    /**
     * 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(",");

            _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);
        _scale     = scale;
        _size      = String.valueOf(size);
        if (scale > 0)
        {
            _size += "," + _scale;
        }
    }
    
    /**
     * Returns the precision radix of the column.
     * 
     * @return The precision radix
     */
    public int getPrecisionRadix()
    {
        return getSizeAsInt();
    }

    /**
     * Sets the precision radix of the column.
     * 
     * @param precisionRadix The precision radix
     */
    public void setPrecisionRadix(int precisionRadix)
    {
        _sizeAsInt = new Integer(precisionRadix);
        _size      = String.valueOf(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 (_typeCode)
                {
                    case Types.TINYINT:
                    case Types.SMALLINT:
                        return new Short(_defaultValue);
                    case Types.INTEGER:
                        return new Integer(_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 ConvertUtils.convert(_defaultValue, Boolean.class);
                    default:
                        if (Jdbc3Utils.supportsJava14JdbcTypes() &&
                            (_typeCode == Jdbc3Utils.determineBooleanTypeCode()))
                        {
                            return ConvertUtils.convert(_defaultValue, Boolean.class);
                        }
                        break;
                }
            }
            catch (NumberFormatException ex)
            {
                return null;
            }
            catch (IllegalArgumentException ex)
            {
                return null;
            }
        }
        return _defaultValue;
    }

    /**
     * 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)
    {
        _defaultValue = 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._typeCode        = _typeCode;
        result._type            = _type;
        result._size            = _size;
        result._defaultValue    = _defaultValue;
        result._scale           = _scale;
        result._size            = _size;
        result._sizeAsInt       = _sizeAsInt;

        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(_typeCode,               other._typeCode);
            comparator.append(getParsedDefaultValue(), other.getParsedDefaultValue());

            // comparing the size makes only sense for types where it is relevant
            if ((_typeCode == Types.NUMERIC) || (_typeCode == Types.DECIMAL))
            {
                comparator.append(_size,  other._size);
                comparator.append(_scale, other._scale);
            }
            else if ((_typeCode == Types.CHAR) || (_typeCode == Types.VARCHAR) ||
                     (_typeCode == Types.BINARY) || (_typeCode == 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(_typeCode);
        builder.append(_type);
        builder.append(_scale);
        builder.append(getParsedDefaultValue());
        if (!TypeMap.isNumericType(_typeCode))
        {
            builder.append(_size);
        }
        
        return builder.toHashCode();
    }

    /**
     * {@inheritDoc}
     */
    public String toString()
    {
        StringBuffer result = new StringBuffer();

        result.append("Column [name=");
        result.append(getName());
        result.append("; type=");
        result.append(getType());
        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(getType());
        result.append("; typeCode=");
        result.append(getTypeCode());
        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();
    }
}