Package org.apache.derby.iapi.types

Class SQLChar

  • All Implemented Interfaces:
    java.io.Externalizable, java.io.Serializable, java.lang.Comparable, Formatable, Storable, StreamStorable, TypedFormat, ConcatableDataValue, DataValueDescriptor, Orderable, StringDataValue, VariableSizeDataValue
    Direct Known Subclasses:
    CollatorSQLChar, SQLVarchar
    public class SQLChar
extends DataType
implements StringDataValue, StreamStorable
    The SQLChar represents a CHAR value with UCS_BASIC collation. SQLChar may be used directly by any code when it is guaranteed that the required collation is UCS_BASIC, e.g. system columns.

    The state may be in char[], a String, a Clob, or an unread stream, depending on how the datatype was created.

    Stream notes:

    When the datatype comes from the database layer and the length of the bytes necessary to store the datatype on disk exceeds the size of a page of the container holding the data then the store returns a stream rather than reading all the bytes into a char[] or String. The hope is that the usual usage case is that data never need be expanded in the derby layer, and that client can just be given a stream that can be read a char at a time through the jdbc layer. Even though SQLchar's can't ever be this big, this code is shared by all the various character datatypes including SQLClob which is expected to usually larger than a page.

    The state can also be a stream in the case of insert/update where the client has used a jdbc interface to set the value as a stream rather than char[]. In this case the hope is that the usual usage case is that stream never need be read until it is passed to store, read once, and inserted into the database.

    See Also:
    Serialized Form

    • Field Detail

      • RETURN_SPACE_THRESHOLD

        protected static final int RETURN_SPACE_THRESHOLD
        threshold, that decides when we return space back to the VM see getString() where it is used
        See Also:
        Constant Field Values

      • GROWBY_FOR_CHAR

        private static final int GROWBY_FOR_CHAR
        when we know that the array needs to grow by at least one byte, it is not performant to grow by just one byte instead this amount is used to provide a reasonable growby size.
        See Also:
        Constant Field Values

      • BASE_MEMORY_USAGE

        private static final int BASE_MEMORY_USAGE

      • BLANKS

        private static final char[] BLANKS
        Static array that can be used for blank padding.

      • CHAR_HEADER_GENERATOR

        protected static final StreamHeaderGenerator CHAR_HEADER_GENERATOR
        Stream header generator for CHAR, VARCHAR and LONG VARCHAR. Currently, only one header format is used for these data types.

      • value

        private java.lang.String value
        Fields of the class

      • rawData

        private char[] rawData

      • rawLength

        private int rawLength

      • cKey

        private java.text.CollationKey cKey

      • _clobValue

        protected java.sql.Clob _clobValue
        The value as a user-created Clob

      • stream

        java.io.InputStream stream
        The value as a stream in the on-disk format.

      • arg_passer

        char[][] arg_passer

    • Constructor Detail

      • SQLChar

        public SQLChar()
        no-arg constructor, required by Formattable.

      • SQLChar

        public SQLChar​(java.lang.String val)

      • SQLChar

        public SQLChar​(java.sql.Clob val)

      • SQLChar

        public SQLChar​(char[] val)

        This is a special constructor used when we need to represent a password as a VARCHAR (see DERBY-866). If you need a general-purpose constructor for char[] values and you want to re-use this constructor, make sure to keep track of the following:

        • A password should never be turned into a String. This is because Java garbage collection makes it easy to sniff memory for String passwords. For more information, see this blog.
        • It must be possible to 0 out the char[] array wrapped inside this SQLChar. This reduces the vulnerability that someone could sniff the char[] password after Derby has processed it.

    • Method Detail

      • appendBlanks

        private static void appendBlanks​(char[] ca,
                                 int offset,
                                 int howMany)
        Private/Protected methods of This class:

      • getRawDataAndZeroIt

        public char[] getRawDataAndZeroIt()

        This is a special accessor used when we wrap passwords in VARCHARs. This accessor copies the wrapped char[] and then fills it with 0s so that the password can't be memory-sniffed. For more information, see the comment on the SQLChar( char[] ) constructor.

      • zeroRawData

        public void zeroRawData()

        Zero out the wrapped char[] so that it can't be memory-sniffed. This helps us protect passwords. See the comment on the SQLChar( char[] ) constructor.

      • returnStream

        public java.io.InputStream returnStream()
        Public Methods of StreamStorable interface:
        Specified by:
        returnStream in interface StreamStorable

      • setStream

        public void setStream​(java.io.InputStream newStream)
        Set this value to the on-disk format stream.
        Specified by:
        setStream in interface StreamStorable

      • typeToBigDecimal

        public int typeToBigDecimal()
                     throws StandardException
        CHAR/VARCHAR/LONG VARCHAR implementation. Convert to a BigDecimal using getString.
        Specified by:
        typeToBigDecimal in interface DataValueDescriptor
        Overrides:
        typeToBigDecimal in class DataType
        Returns:
        Types.CHAR for String conversion through getString Types.DECIMAL for BigDecimal through getObject or Types.BIGINT for long conversion through getLong
        Throws:
        StandardException - Conversion is not possible

      • getLength

        public int getLength()
              throws StandardException
        Description copied from interface: DataValueDescriptor
        Gets the length of the data value. The meaning of this is implementation-dependent. For string types, it is the number of characters in the string. For numeric types, it is the number of bytes used to store the number. This is the actual length of this value, not the length of the type it was defined as. For example, a VARCHAR value may be shorter than the declared VARCHAR (maximum) length.
        Specified by:
        getLength in interface DataValueDescriptor
        Returns:
        The length of the data value
        Throws:
        StandardException - Thrown on error

      • throwStreamingIOException

        protected void throwStreamingIOException​(java.io.IOException ioe)
                                  throws StandardException
        Wraps an IOException in a StandardException then throws the wrapping exception.
        Parameters:
        ioe - the IOException to wrap
        Throws:
        StandardException - the wrapping exception

      • getString

        public java.lang.String getString()
                           throws StandardException
        If possible, use getCharArray() if you don't really need a string. getString() will cause an extra char array to be allocated when it calls the the String() constructor (the first time through), so may be cheaper to use getCharArray().
        Specified by:
        getString in interface DataValueDescriptor
        Returns:
        The data value as a String.
        Throws:
        StandardException - Thrown on error

      • getCharArray

        public char[] getCharArray()
                    throws StandardException
        Get a char array. Typically, this is a simple getter that is cheaper than getString() because we always need to create a char array when doing I/O. Use this instead of getString() where reasonable.

        WARNING: may return a character array that has spare characters at the end. MUST be used in conjunction with getLength() to be safe.

        Specified by:
        getCharArray in interface StringDataValue
        Throws:
        StandardException - Thrown on error

      • isNull

        public boolean isNull()
        see if the String value is null.
        Specified by:
        isNull in interface Storable
        Returns:
        true if the value is null and false otherwise.
        See Also:
        Storable.isNull()

      • writeExternal

        public void writeExternal​(java.io.ObjectOutput out)
                   throws java.io.IOException
        Writes a non-Clob data value to the modified UTF-8 format used by Derby. The maximum stored size is based upon the UTF format used to stored the String. The format consists of a two byte length field and a maximum number of three bytes for each character.
        This puts an upper limit on the length of a stored String. The maximum stored length is 65535, these leads to the worse case of a maximum string length of 21844 ((65535 - 2) / 3).
        Strings with stored length longer than 64K is handled with the following format: (1) 2 byte length: will be assigned 0. (2) UTF formated string data. (3) terminate the string with the following 3 bytes: first byte is: +---+---+---+---+---+---+---+---+ | 1 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | +---+---+---+---+---+---+---+---+ second byte is: +---+---+---+---+---+---+---+---+ | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | +---+---+---+---+---+---+---+---+ third byte is: +---+---+---+---+---+---+---+---+ | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | +---+---+---+---+---+---+---+---+ The UTF format: Writes a string to the underlying output stream using UTF-8 encoding in a machine-independent manner.

        First, two bytes are written to the output stream as if by the writeShort method giving the number of bytes to follow. This value is the number of bytes actually written out, not the length of the string. Following the length, each character of the string is output, in sequence, using the UTF-8 encoding for the character.

        Specified by:
        writeExternal in interface java.io.Externalizable
        Throws:
        java.io.IOException - if an I/O error occurs.
        Since:
        JDK1.0
        See Also:
        DataInputStream

      • writeUTF

        private final void writeUTF​(java.io.ObjectOutput out,
                            int strLen,
                            boolean isRaw,
                            java.io.Reader characterReader)
                     throws java.io.IOException
        Writes the user data value to a stream in the modified UTF-8 format.
        Parameters:
        out - destination stream
        strLen - string length of the value
        isRaw - true if the source is rawData, false if the source is value
        characterReader - Reader from _clobValue if it exists
        Throws:
        java.io.IOException - if writing to the destination stream fails

      • writeUTF

        private static void writeUTF​(java.io.ObjectOutput out,
                             int c)
                      throws java.io.IOException
        Write a single character to a stream in the modified UTF-8 format.
        Parameters:
        out - the destination stream
        c - the character to write
        Throws:
        java.io.IOException - if writing to the destination stream fails

      • writeClobUTF

        protected final void writeClobUTF​(java.io.ObjectOutput out)
                           throws java.io.IOException
        Writes the header and the user data for a CLOB to the destination stream.
        Parameters:
        out - destination stream
        Throws:
        java.io.IOException - if writing to the destination stream fails

      • readExternalFromArray

        public void readExternalFromArray​(ArrayInputStream in)
                           throws java.io.IOException
        Reads in a string from the specified data input stream. The string has been encoded using a modified UTF-8 format.

        The first two bytes are read as if by readUnsignedShort. This value gives the number of following bytes that are in the encoded string, not the length of the resulting string. The following bytes are then interpreted as bytes encoding characters in the UTF-8 format and are converted into characters.

        This method blocks until all the bytes are read, the end of the stream is detected, or an exception is thrown.

        Specified by:
        readExternalFromArray in interface DataValueDescriptor
        Overrides:
        readExternalFromArray in class DataType
        Parameters:
        in - a data input stream.
        Throws:
        java.io.EOFException - if the input stream reaches the end before all the bytes.
        java.io.IOException - if an I/O error occurs.
        java.io.UTFDataFormatException - if the bytes do not represent a valid UTF-8 encoding of a Unicode string.
        See Also:
        DataInputStream.readUnsignedShort(), Externalizable.readExternal(java.io.ObjectInput)

      • readExternalClobFromArray

        protected void readExternalClobFromArray​(ArrayInputStream in,
                                         int charLen)
                                  throws java.io.IOException
        Reads a CLOB from the source stream and materializes the value in a character array.
        Parameters:
        in - source stream
        charLen - the char length of the value, or 0 if unknown
        Throws:
        java.io.IOException - if reading from the source fails

      • resetForMaterialization

        private void resetForMaterialization()
        Resets state after materializing value from an array.

      • readExternal

        public void readExternal​(java.io.ObjectInput in)
                  throws java.io.IOException
        Specified by:
        readExternal in interface java.io.Externalizable
        Throws:
        java.io.IOException

      • readExternal

        protected void readExternal​(java.io.ObjectInput in,
                            int utflen,
                            int knownStrLen)
                     throws java.io.IOException
        Restores the data value from the source stream, materializing the value in memory.
        Parameters:
        in - the source stream
        utflen - the byte length, or 0 if unknown
        knownStrLen - the char length, or 0 if unknown
        Throws:
        java.io.UTFDataFormatException - if an encoding error is detected
        java.io.IOException - if reading the stream fails

      • growBy

        protected int growBy()
        returns the reasonable minimum amount by which the array can grow . See readExternal. when we know that the array needs to grow by at least one byte, it is not performant to grow by just one byte instead this amount is used to provide a resonable growby size.
        Returns:
        minimum reasonable growby size

      • compare

        public boolean compare​(int op,
                       DataValueDescriptor other,
                       boolean orderedNulls,
                       boolean unknownRV)
                throws StandardException
        Description copied from interface: DataValueDescriptor
        Compare this Orderable with a given Orderable for the purpose of qualification and sorting. The caller gets to determine how nulls should be treated - they can either be ordered values or unknown values.
        Specified by:
        compare in interface DataValueDescriptor
        Overrides:
        compare in class DataType
        Parameters:
        op - Orderable.ORDER_OP_EQUALS means do an = comparison. Orderable.ORDER_OP_LESSTHAN means compare this < other. Orderable.ORDER_OP_LESSOREQUALS means compare this <= other.
        other - The DataValueDescriptor to compare this one to.
        orderedNulls - True means to treat nulls as ordered values, that is, treat SQL null as equal to null, and less than all other values. False means to treat nulls as unknown values, that is, the result of any comparison with a null is the UNKNOWN truth value.
        unknownRV - The return value to use if the result of the comparison is the UNKNOWN truth value. In other words, if orderedNulls is false, and a null is involved in the comparison, return unknownRV. This parameter is not used orderedNulls is true.
        Returns:
        true if the comparison is true (duh!)
        Throws:
        StandardException - thrown on error

      • compare

        public int compare​(DataValueDescriptor other)
            throws StandardException
        Description copied from interface: DataValueDescriptor
        Compare this Orderable with a given Orderable for the purpose of index positioning. This method treats nulls as ordered values - that is, it treats SQL null as equal to null and greater than all other values.
        Specified by:
        compare in interface DataValueDescriptor
        Parameters:
        other - The Orderable to compare this one to.
        Returns:
        <0 - this Orderable is less than other. 0 - this Orderable equals other. >0 - this Orderable is greater than other. The code should not explicitly look for -1, or 1.
        Throws:
        StandardException - thrown on error

      • cloneHolder

        public DataValueDescriptor cloneHolder()
        Shallow clone a StreamStorable without objectifying. This is used to avoid unnecessary objectifying of a stream object. The only difference of this method from cloneValue is this method does not objectify a stream.
        Specified by:
        cloneHolder in interface DataValueDescriptor
        Overrides:
        cloneHolder in class DataType
        Returns:
        A shallow clone.

      • cloneValue

        public DataValueDescriptor cloneValue​(boolean forceMaterialization)
        Description copied from interface: DataValueDescriptor
        Clone this DataValueDescriptor. Results in a new object that has the same value as this but can be modified independently.

        Even though the objects can be modified independently regardless of the value of forceMaterialization, both the clone and the original may be dependent on the store state if forceMaterialization is set to false. An example is if you need to access the value you just read using cloneValue after the current transaction has ended, or after the source result set has been closed.

        Specified by:
        cloneValue in interface DataValueDescriptor
        Parameters:
        forceMaterialization - any streams representing the data value will be materialized if true, the data value will be kept as a stream if possible if false
        Returns:
        A clone of the DataValueDescriptor with the same initial value as this.
        See Also:
        DataValueDescriptor.cloneValue(boolean)

      • getValue

        public StringDataValue getValue​(java.text.RuleBasedCollator collatorForComparison)
        Description copied from interface: StringDataValue
        Gets either SQLChar/SQLVarchar/SQLLongvarchar/SQLClob(base classes) or CollatorSQLChar/CollatorSQLVarchar/CollatorSQLLongvarch/CollatorSQLClob (subclasses). Whether this method returns the base class or the subclass depends on the value of the RuleBasedCollator. If RuleBasedCollator is null, then the object returned would be baseclass otherwise it would be subcalss.
        Specified by:
        getValue in interface StringDataValue
        See Also:
        StringDataValue.getValue(RuleBasedCollator)

      • setValueFromResultSet

        public final void setValueFromResultSet​(java.sql.ResultSet resultSet,
                                        int colNumber,
                                        boolean isNullable)
                                 throws java.sql.SQLException
        Description copied from interface: DataValueDescriptor
        Set the value based on the value for the specified DataValueDescriptor from the specified ResultSet.
        Specified by:
        setValueFromResultSet in interface DataValueDescriptor
        Parameters:
        resultSet - The specified ResultSet.
        colNumber - The 1-based column # into the resultSet.
        isNullable - Whether or not the column is nullable (No need to call wasNull() if not)
        Throws:
        java.sql.SQLException - Thrown on error
        See Also:
        DataValueDescriptor.setValueFromResultSet(java.sql.ResultSet, int, boolean)

      • setInto

        public final void setInto​(java.sql.PreparedStatement ps,
                          int position)
                   throws java.sql.SQLException,
                          StandardException
        Set the value into a PreparedStatement.
        Specified by:
        setInto in interface DataValueDescriptor
        Overrides:
        setInto in class DataType
        Throws:
        java.sql.SQLException - thrown by the PreparedStatement object
        StandardException - thrown by me accessing my value.

      • setValue

        public void setValue​(java.sql.Clob theValue)
        Description copied from class: DataType
        Set the value of this DataValueDescriptor. At DataType level just throws an error lower classes will override
        Specified by:
        setValue in interface DataValueDescriptor
        Specified by:
        setValue in interface StringDataValue
        Overrides:
        setValue in class DataType
        Parameters:
        theValue - The Clob value to set this DataValueDescriptor to

      • setValue

        public void setValue​(java.lang.String theValue)
        Description copied from class: DataType
        Set the value of this DataValueDescriptor. At DataType level just throws an error lower classes will override
        Specified by:
        setValue in interface DataValueDescriptor
        Overrides:
        setValue in class DataType
        Parameters:
        theValue - The BigDecimal value to set this DataValueDescriptor to

      • setValue

        public void setValue​(int theValue)
              throws StandardException
        Description copied from class: DataType
        Set the value of this DataValueDescriptor to the given int value At DataType level just throws an error lower classes will override
        Specified by:
        setValue in interface DataValueDescriptor
        Overrides:
        setValue in class DataType
        Parameters:
        theValue - The value to set this DataValueDescriptor to
        Throws:
        StandardException - Thrown on error

      • setValue

        public void setValue​(double theValue)
              throws StandardException
        Description copied from class: DataType
        Set the value of this DataValueDescriptor to the given double value At DataType level just throws an error lower classes will override
        Specified by:
        setValue in interface DataValueDescriptor
        Overrides:
        setValue in class DataType
        Parameters:
        theValue - The value to set this DataValueDescriptor to
        Throws:
        StandardException - Thrown on error

      • setValue

        public void setValue​(float theValue)
              throws StandardException
        Description copied from class: DataType
        Set the value of this DataValueDescriptor to the given float value At DataType level just throws an error lower classes will override
        Specified by:
        setValue in interface DataValueDescriptor
        Overrides:
        setValue in class DataType
        Parameters:
        theValue - The value to set this DataValueDescriptor to
        Throws:
        StandardException - Thrown on error

      • setValue

        public void setValue​(short theValue)
              throws StandardException
        Description copied from class: DataType
        Set the value of this DataValueDescriptor to the given short value At DataType level just throws an error lower classes will override
        Specified by:
        setValue in interface DataValueDescriptor
        Overrides:
        setValue in class DataType
        Parameters:
        theValue - The value to set this DataValueDescriptor to
        Throws:
        StandardException - Thrown on error

      • setValue

        public void setValue​(long theValue)
              throws StandardException
        Description copied from class: DataType
        Set the value of this DataValueDescriptor to the given long value At DataType level just throws an error lower classes will override
        Specified by:
        setValue in interface DataValueDescriptor
        Overrides:
        setValue in class DataType
        Parameters:
        theValue - The value to set this DataValueDescriptor to
        Throws:
        StandardException - Thrown on error

      • setValue

        public void setValue​(byte theValue)
              throws StandardException
        Description copied from class: DataType
        Set the value of this DataValueDescriptor to the given byte value At DataType level just throws an error lower classes will override
        Specified by:
        setValue in interface DataValueDescriptor
        Overrides:
        setValue in class DataType
        Parameters:
        theValue - The value to set this DataValueDescriptor to
        Throws:
        StandardException - Thrown on error

      • setValue

        public void setValue​(byte[] theValue)
              throws StandardException
        Description copied from class: DataType
        Set the value of this DataValueDescriptor. At DataType level just throws an error lower classes will override
        Specified by:
        setValue in interface DataValueDescriptor
        Overrides:
        setValue in class DataType
        Parameters:
        theValue - The byte value to set this DataValueDescriptor to
        Throws:
        StandardException

      • setValue

        public void setValue​(java.sql.Date theValue,
                     java.util.Calendar cal)
              throws StandardException
        Description copied from class: DataType
        Set the value of this DataValueDescriptor. At DataType level just throws an error lower classes will override
        Specified by:
        setValue in interface DataValueDescriptor
        Overrides:
        setValue in class DataType
        Parameters:
        theValue - The Date value to set this DataValueDescriptor to
        cal - The time zone from the calendar is used to construct the database date value
        Throws:
        StandardException - Thrown on error

      • setValue

        public void setValue​(java.sql.Time theValue,
                     java.util.Calendar cal)
              throws StandardException
        Description copied from class: DataType
        Set the value of this DataValueDescriptor. At DataType level just throws an error lower classes will override
        Specified by:
        setValue in interface DataValueDescriptor
        Overrides:
        setValue in class DataType
        Parameters:
        theValue - The Time value to set this DataValueDescriptor to
        cal - The time zone from the calendar is used to construct the database time value
        Throws:
        StandardException - Thrown on error

      • setValue

        public void setValue​(java.sql.Timestamp theValue,
                     java.util.Calendar cal)
              throws StandardException
        Description copied from class: DataType
        Set the value of this DataValueDescriptor. At DataType level just throws an error lower classes will override
        Specified by:
        setValue in interface DataValueDescriptor
        Overrides:
        setValue in class DataType
        Parameters:
        theValue - The Timestamp value to set this DataValueDescriptor to
        cal - The time zone from the calendar is used to construct the database timestamp value
        Throws:
        StandardException - Thrown on error

      • formatJDBCDate

        private void formatJDBCDate​(java.util.Calendar cal,
                            java.lang.StringBuffer sb)

      • formatJDBCTime

        private void formatJDBCTime​(java.util.Calendar cal,
                            java.lang.StringBuffer sb)

      • setValue

        public final void setValue​(java.io.InputStream theStream,
                           int valueLength)
        Set the value from the stream which is in the on-disk format.
        Specified by:
        setValue in interface DataValueDescriptor
        Overrides:
        setValue in class DataType
        Parameters:
        theStream - On disk format of the stream
        valueLength - length of the logical value in characters, or DataValueDescriptor.UNKNOWN_LOGICAL_LENGTH

      • setFrom

        protected void setFrom​(DataValueDescriptor theValue)
                throws StandardException
        Description copied from class: DataType
        Set the value of this DataValueDescriptor based on the value of the specified DataValueDescriptor.
        Overrides:
        setFrom in class DataType
        Parameters:
        theValue - The DataValueDescriptor that holds the value to which we want to set this DataValueDescriptor's value.
        Throws:
        StandardException

      • normalize

        public void normalize​(DataTypeDescriptor desiredType,
                      DataValueDescriptor source)
               throws StandardException
        Normalization method - this method may be called when putting a value into a SQLChar, for example, when inserting into a SQLChar column. See NormalizeResultSet in execution.
        Specified by:
        normalize in interface DataValueDescriptor
        Overrides:
        normalize in class DataType
        Parameters:
        desiredType - The type to normalize the source column to
        source - The value to normalize
        Throws:
        StandardException - Thrown for null into non-nullable column, and for truncation error

      • setWidth

        public void setWidth​(int desiredWidth,
                     int desiredScale,
                     boolean errorOnTrunc)
              throws StandardException
        Set the width of the to the desired value. Used when CASTing. Ideally we'd recycle normalize(), but the behavior is different (we issue a warning instead of an error, and we aren't interested in nullability).
        Specified by:
        setWidth in interface VariableSizeDataValue
        Parameters:
        desiredWidth - the desired length
        desiredScale - the desired scale (ignored)
        errorOnTrunc - throw an error on truncation
        Throws:
        StandardException - Thrown when errorOnTrunc is true and when a shrink will truncate non-white spaces.

      • getUTF8Length

        private int getUTF8Length​(java.lang.String string,
                          int start,
                          int end)
                   throws StandardException
        Get the number of bytes needed to represent a string in modified UTF-8, which is the encoding used by writeExternal() and writeUTF().
        Parameters:
        string - the string whose length to calculate
        start - start index (inclusive)
        end - end index (exclusive)
        Throws:
        StandardException

      • locate

        public NumberDataValue locate​(StringDataValue searchFrom,
                              NumberDataValue start,
                              NumberDataValue result)
                       throws StandardException
        This method implements the locate function for char.
        Specified by:
        locate in interface StringDataValue
        Parameters:
        searchFrom - - The string to search from
        start - - The position to search from in string searchFrom
        result - - The object to return Note: use getString() to get the string to search for.
        Returns:
        The position in searchFrom the fist occurrence of this.value. 0 is returned if searchFrom does not contain this.value.
        Throws:
        StandardException - Thrown on error

      • trimInternal

        private java.lang.String trimInternal​(int trimType,
                                      char trimChar,
                                      java.lang.String source)
        This function public for testing purposes.
        Parameters:
        trimType - Type of trim (LEADING, TRAILING, or BOTH)
        trimChar - Character to trim
        source - String from which to trim trimChar
        Returns:
        A String containing the result of the trim.

      • typePrecedence

        public int typePrecedence()
        Description copied from class: DataType
        Each built-in type in JSQL has a precedence. This precedence determines how to do type promotion when using binary operators. For example, float has a higher precedence than int, so when adding an int to a float, the result type is float. The precedence for some types is arbitrary. For example, it doesn't matter what the precedence of the boolean type is, since it can't be mixed with other types. But the precedence for the number types is critical. The SQL standard requires that exact numeric types be promoted to approximate numeric when one operator uses both. Also, the precedence is arranged so that one will not lose precision when promoting a type.
        Specified by:
        typePrecedence in interface DataValueDescriptor
        Overrides:
        typePrecedence in class DataType
        Returns:
        The precedence of this type.
        See Also:
        DataValueDescriptor.typePrecedence()

      • stringCompare

        protected static int stringCompare​(java.lang.String op1,
                                   java.lang.String op2)
        Compare two Strings using standard SQL semantics.
        Parameters:
        op1 - The first String
        op2 - The second String
        Returns:
        -1 - op1 < op2 0 - op1 == op2 1 - op1 > op2

      • stringCompare

        protected static int stringCompare​(char[] op1,
                                   int leftlen,
                                   char[] op2,
                                   int rightlen)
        Compare two Strings using standard SQL semantics.
        Parameters:
        op1 - The first String
        op2 - The second String
        Returns:
        -1 - op1 < op2 0 - op1 == op2 1 - op1 > op2

      • getCollationKey

        protected java.text.CollationKey getCollationKey()
                                          throws StandardException
        This method gets called for the collation sensitive char classes ie CollatorSQLChar, CollatorSQLVarchar, CollatorSQLLongvarchar, CollatorSQLClob. These collation sensitive chars need to have the collation key in order to do string comparison. And the collation key is obtained using the Collator object that these classes already have.
        Returns:
        CollationKey obtained using Collator on the string
        Throws:
        StandardException

      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object

      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class java.lang.Object

      • hashCodeForCollation

        int hashCodeForCollation()
        Hash code implementation for collator sensitive subclasses.

      • setLocaleFinder

        protected void setLocaleFinder​(LocaleFinder localeFinder)

      • getLocaleFinder

        protected LocaleFinder getLocaleFinder()

      • estimateMemoryUsage

        public int estimateMemoryUsage()
        Description copied from interface: DataValueDescriptor
        Estimate the memory usage in bytes of the data value and the overhead of the class.
        Specified by:
        estimateMemoryUsage in interface DataValueDescriptor
        Returns:
        the estimated memory usage

      • copyState

        protected void copyState​(SQLChar other)

      • copyState

        private void copyState​(java.lang.String otherValue,
                       char[] otherRawData,
                       int otherRawLength,
                       java.text.CollationKey otherCKey,
                       java.io.InputStream otherStream,
                       java.sql.Clob otherClobValue,
                       LocaleFinder otherLocaleFinder)

      • setStreamHeaderFormat

        public void setStreamHeaderFormat​(java.lang.Boolean inSoftUpgradeMode)
        Sets the mode for the database being accessed.
        Specified by:
        setStreamHeaderFormat in interface StringDataValue
        Parameters:
        inSoftUpgradeMode - true if the database is being accessed in soft upgrade mode, false if not, and null if unknown

      • rawGetClobLength

        private int rawGetClobLength()
                      throws java.sql.SQLException
        Throws:
        java.sql.SQLException