001: /*
002:
003: Derby - Class org.apache.derby.iapi.types.SQLVarchar
004:
005: Licensed to the Apache Software Foundation (ASF) under one or more
006: contributor license agreements. See the NOTICE file distributed with
007: this work for additional information regarding copyright ownership.
008: The ASF licenses this file to you under the Apache License, Version 2.0
009: (the "License"); you may not use this file except in compliance with
010: the License. You may obtain a copy of the License at
011:
012: http://www.apache.org/licenses/LICENSE-2.0
013:
014: Unless required by applicable law or agreed to in writing, software
015: distributed under the License is distributed on an "AS IS" BASIS,
016: WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
017: See the License for the specific language governing permissions and
018: limitations under the License.
019:
020: */
021:
022: package org.apache.derby.iapi.types;
023:
024: import org.apache.derby.iapi.types.DataTypeDescriptor;
025: import org.apache.derby.iapi.types.DataValueDescriptor;
026: import org.apache.derby.iapi.types.TypeId;
027: import org.apache.derby.iapi.types.DataValueDescriptor;
028: import org.apache.derby.iapi.types.StringDataValue;
029: import org.apache.derby.iapi.reference.SQLState;
030: import org.apache.derby.iapi.error.StandardException;
031:
032: import org.apache.derby.iapi.services.io.FormatIdUtil;
033: import org.apache.derby.iapi.services.io.StoredFormatIds;
034:
035: import org.apache.derby.iapi.services.sanity.SanityManager;
036: import org.apache.derby.iapi.util.StringUtil;
037:
038: /**
039: * SQLVarchar satisfies the DataValueDescriptor
040: * interfaces (i.e., OrderableDataType). It implements a String holder,
041: * e.g. for storing a column value; it can be specified
042: * when constructed to not allow nulls. Nullability cannot be changed
043: * after construction.
044: * <p>
045: * Because OrderableDataType is a subclass of DataType,
046: * SQLVarchar can play a role in either a DataType/ValueRow
047: * or a OrderableDataType/KeyRow, interchangeably.
048: *
049: * SQLVarchar is mostly the same as SQLChar, so it is implemented as a
050: * subclass of SQLChar. Only those methods with different behavior are
051: * implemented here.
052: */
053: public class SQLVarchar extends SQLChar {
054:
055: /*
056: * DataValueDescriptor interface.
057: *
058: */
059:
060: public String getTypeName() {
061: return TypeId.VARCHAR_NAME;
062: }
063:
064: /*
065: * DataValueDescriptor interface
066: */
067:
068: /** @see DataValueDescriptor#getClone */
069: public DataValueDescriptor getClone() {
070: try {
071: return new SQLVarchar(getString());
072: } catch (StandardException se) {
073: if (SanityManager.DEBUG)
074: SanityManager.THROWASSERT("Unexpected exception " + se);
075: return null;
076: }
077: }
078:
079: /**
080: * @see DataValueDescriptor#getNewNull
081: *
082: */
083: public DataValueDescriptor getNewNull() {
084: return new SQLVarchar();
085: }
086:
087: /*
088: * Storable interface, implies Externalizable, TypedFormat
089: */
090:
091: /**
092: Return my format identifier.
093:
094: @see org.apache.derby.iapi.services.io.TypedFormat#getTypeFormatId
095: */
096: public int getTypeFormatId() {
097: return StoredFormatIds.SQL_VARCHAR_ID;
098: }
099:
100: /*
101: * constructors
102: */
103:
104: public SQLVarchar() {
105: }
106:
107: public SQLVarchar(String val) {
108: super (val);
109: }
110:
111: /**
112: * Normalization method - this method may be called when putting
113: * a value into a SQLVarchar, for example, when inserting into a SQLVarchar
114: * column. See NormalizeResultSet in execution.
115: *
116: * @param desiredType The type to normalize the source column to
117: * @param source The value to normalize
118: *
119: *
120: * @exception StandardException Thrown for null into
121: * non-nullable column, and for
122: * truncation error
123: */
124:
125: public void normalize(DataTypeDescriptor desiredType,
126: DataValueDescriptor source) throws StandardException {
127: normalize(desiredType, source.getString());
128: }
129:
130: protected void normalize(DataTypeDescriptor desiredType,
131: String sourceValue) throws StandardException {
132:
133: int desiredWidth = desiredType.getMaximumWidth();
134:
135: int sourceWidth = sourceValue.length();
136:
137: /*
138: ** If the input is already the right length, no normalization is
139: ** necessary.
140: **
141: ** It's OK for a Varchar value to be shorter than the desired width.
142: ** This can happen, for example, if you insert a 3-character Varchar
143: ** value into a 10-character Varchar column. Just return the value
144: ** in this case.
145: */
146:
147: if (sourceWidth > desiredWidth) {
148:
149: hasNonBlankChars(sourceValue, desiredWidth, sourceWidth);
150:
151: /*
152: ** No non-blank characters will be truncated. Truncate the blanks
153: ** to the desired width.
154: */
155: sourceValue = sourceValue.substring(0, desiredWidth);
156: }
157:
158: setValue(sourceValue);
159: }
160:
161: /*
162: * DataValueDescriptor interface
163: */
164:
165: /* @see DataValueDescriptor#typePrecedence */
166: public int typePrecedence() {
167: return TypeId.VARCHAR_PRECEDENCE;
168: }
169:
170: /**
171: * returns the reasonable minimum amount by
172: * which the array can grow . See readExternal.
173: * when we know that the array needs to grow by at least
174: * one byte, it is not performant to grow by just one byte
175: * instead this amount is used to provide a resonable growby size.
176: * @return minimum reasonable growby size
177: */
178: protected final int growBy() {
179: return RETURN_SPACE_THRESHOLD; //seems reasonable for a varchar or clob
180: }
181: }
|