Class StringUtils

java.lang.Object
com.mysql.jdbc.StringUtils
public class StringUtils extends Object
Various utility methods for converting to/from byte arrays in the platform encoding

  • Field Details

    • SEARCH_MODE__ALL

      public static final Set<StringUtils.SearchMode> SEARCH_MODE__ALL
      Full search mode: allow backslash escape, skip between markers, skip block comments, skip line comments and skip white space.

    • SEARCH_MODE__MRK_COM_WS

      public static final Set<StringUtils.SearchMode> SEARCH_MODE__MRK_COM_WS
      Search mode: skip between markers, skip block comments, skip line comments and skip white space.

    • SEARCH_MODE__BSESC_COM_WS

      public static final Set<StringUtils.SearchMode> SEARCH_MODE__BSESC_COM_WS
      Search mode: allow backslash escape, skip block comments, skip line comments and skip white space.

    • SEARCH_MODE__BSESC_MRK_WS

      public static final Set<StringUtils.SearchMode> SEARCH_MODE__BSESC_MRK_WS
      Search mode: allow backslash escape, skip between markers and skip white space.

    • SEARCH_MODE__COM_WS

      public static final Set<StringUtils.SearchMode> SEARCH_MODE__COM_WS
      Search mode: skip block comments, skip line comments and skip white space.

    • SEARCH_MODE__MRK_WS

      public static final Set<StringUtils.SearchMode> SEARCH_MODE__MRK_WS
      Search mode: skip between markers and skip white space.

    • SEARCH_MODE__NONE

      public static final Set<StringUtils.SearchMode> SEARCH_MODE__NONE
      Empty search mode.

    • WILDCARD_MANY

      static final char WILDCARD_MANY
      See Also:

    • WILDCARD_ONE

      static final char WILDCARD_ONE
      See Also:

    • WILDCARD_ESCAPE

      static final char WILDCARD_ESCAPE
      See Also:

  • Constructor Details

    • StringUtils

      public StringUtils()

  • Method Details

    • findCharset

      static Charset findCharset(String alias) throws UnsupportedEncodingException
      Throws:
      UnsupportedEncodingException

    • consistentToString

      public static String consistentToString(BigDecimal decimal)
      Takes care of the fact that Sun changed the output of BigDecimal.toString() between JDK-1.4 and JDK 5
      Parameters:
      decimal - the big decimal to stringify
      Returns:
      a string representation of 'decimal'

    • dumpAsHex

      public static String dumpAsHex(byte[] byteBuffer, int length)
      Dumps the given bytes to STDOUT as a hex dump (up to length bytes).
      Parameters:
      byteBuffer - the data to print as hex
      length - the number of bytes to print
      Returns:
      ...

    • escapeEasternUnicodeByteStream

      public static byte[] escapeEasternUnicodeByteStream(byte[] origBytes, String origString)
      Unfortunately, SJIS has 0x5c as a high byte in some of its double-byte characters, so we need to escape it.
      Parameters:
      origBytes - the original bytes in SJIS format
      origString - the string that had .getBytes() called on it
      Returns:
      byte[] with 0x5c escaped

    • firstNonWsCharUc

      public static char firstNonWsCharUc(String searchIn)
      Returns the first non whitespace char, converted to upper case
      Parameters:
      searchIn - the string to search in
      Returns:
      the first non-whitespace character, upper cased.

    • firstNonWsCharUc

      public static char firstNonWsCharUc(String searchIn, int startAt)

    • firstAlphaCharUc

      public static char firstAlphaCharUc(String searchIn, int startAt)

    • fixDecimalExponent

      public static String fixDecimalExponent(String dString)
      Adds '+' to decimal numbers that are positive (MySQL doesn't understand them otherwise
      Parameters:
      dString - The value as a string
      Returns:
      String the string with a '+' added (if needed)

    • getBytes

      public static byte[] getBytes(char[] c, SingleByteCharsetConverter converter, String encoding, String serverEncoding, boolean parserKnowsUnicode, ExceptionInterceptor exceptionInterceptor) throws SQLException
      Returns the byte[] representation of the given char[] (re)using the given charset converter, and the given encoding.
      Throws:
      SQLException

    • getBytes

      public static byte[] getBytes(char[] c, SingleByteCharsetConverter converter, String encoding, String serverEncoding, int offset, int length, boolean parserKnowsUnicode, ExceptionInterceptor exceptionInterceptor) throws SQLException
      Returns the byte[] representation of subset of the given char[] (re)using the given charset converter, and the given encoding.
      Throws:
      SQLException

    • getBytes

      public static byte[] getBytes(char[] c, String encoding, String serverEncoding, boolean parserKnowsUnicode, MySQLConnection conn, ExceptionInterceptor exceptionInterceptor) throws SQLException
      Returns the byte[] representation of the given char[] (re)using a cached charset converter, and the given encoding.
      Throws:
      SQLException

    • getBytes

      public static byte[] getBytes(String s, SingleByteCharsetConverter converter, String encoding, String serverEncoding, boolean parserKnowsUnicode, ExceptionInterceptor exceptionInterceptor) throws SQLException
      Returns the byte[] representation of the given string (re)using the given charset converter, and the given encoding.
      Throws:
      SQLException

    • getBytes

      public static byte[] getBytes(String s, SingleByteCharsetConverter converter, String encoding, String serverEncoding, int offset, int length, boolean parserKnowsUnicode, ExceptionInterceptor exceptionInterceptor) throws SQLException
      Returns the byte[] representation of a substring of the given string (re)using the given charset converter, and the given encoding.
      Throws:
      SQLException

    • getBytes

      public static byte[] getBytes(String s, String encoding, String serverEncoding, boolean parserKnowsUnicode, MySQLConnection conn, ExceptionInterceptor exceptionInterceptor) throws SQLException
      Returns the byte[] representation of the given string (re)using a cached charset converter, and the given encoding.
      Throws:
      SQLException

    • getBytes

      public static final byte[] getBytes(String s, String encoding, String serverEncoding, int offset, int length, boolean parserKnowsUnicode, MySQLConnection conn, ExceptionInterceptor exceptionInterceptor) throws SQLException
      Returns the byte[] representation of a substring of the given string (re)using a cached charset converter, and the given encoding.
      Throws:
      SQLException

    • getBytesWrapped

      public static byte[] getBytesWrapped(String s, char beginWrap, char endWrap, SingleByteCharsetConverter converter, String encoding, String serverEncoding, boolean parserKnowsUnicode, ExceptionInterceptor exceptionInterceptor) throws SQLException
      Returns the byte[] representation of the given string properly wrapped between the given char delimiters, (re)using the given charset converter, and the given encoding.
      Throws:
      SQLException

    • getInt

      public static int getInt(byte[] buf) throws NumberFormatException
      Throws:
      NumberFormatException

    • getInt

      public static int getInt(byte[] buf, int offset, int endPos) throws NumberFormatException
      Throws:
      NumberFormatException

    • getLong

      public static long getLong(byte[] buf) throws NumberFormatException
      Throws:
      NumberFormatException

    • getLong

      public static long getLong(byte[] buf, int offset, int endpos) throws NumberFormatException
      Throws:
      NumberFormatException

    • getShort

      public static short getShort(byte[] buf) throws NumberFormatException
      Throws:
      NumberFormatException

    • getShort

      public static short getShort(byte[] buf, int offset, int endpos) throws NumberFormatException
      Throws:
      NumberFormatException

    • indexOfIgnoreCase

      public static int indexOfIgnoreCase(String searchIn, String searchFor)
      Finds the position of a substring within a string ignoring case.
      Parameters:
      searchIn - the string to search in
      searchFor - the array of strings to search for
      Returns:
      the position where searchFor is found within searchIn starting from startingPosition.

    • indexOfIgnoreCase

      public static int indexOfIgnoreCase(int startingPosition, String searchIn, String searchFor)
      Finds the position of a substring within a string ignoring case.
      Parameters:
      startingPosition - the position to start the search from
      searchIn - the string to search in
      searchFor - the array of strings to search for
      Returns:
      the position where searchFor is found within searchIn starting from startingPosition.

    • indexOfIgnoreCase

      public static int indexOfIgnoreCase(int startingPosition, String searchIn, String[] searchForSequence, String openingMarkers, String closingMarkers, Set<StringUtils.SearchMode> searchMode)
      Finds the position of the first of a consecutive sequence of strings within a string, ignoring case, with the option to skip text delimited by given markers or within comments.

      Independently of the searchMode provided, when searching for the second and following strings SearchMode.SKIP_WHITE_SPACE will be added and SearchMode.SKIP_BETWEEN_MARKERS removed.

      Parameters:
      startingPosition - the position to start the search from
      searchIn - the string to search in
      openingMarkers - characters which delimit the beginning of a text block to skip
      closingMarkers - characters which delimit the end of a text block to skip
      searchMode - a Set, ideally an EnumSet, containing the flags from the enum StringUtils.SearchMode that determine the behavior of the search
      searchFor - the array of strings to search for
      Returns:
      the position where searchFor is found within searchIn starting from startingPosition.

    • indexOfIgnoreCase

      public static int indexOfIgnoreCase(int startingPosition, String searchIn, String searchFor, String openingMarkers, String closingMarkers, Set<StringUtils.SearchMode> searchMode)
      Finds the position of a substring within a string, ignoring case, with the option to skip text delimited by given markers or within comments.
      Parameters:
      startingPosition - the position to start the search from
      searchIn - the string to search in
      searchFor - the string to search for
      openingMarkers - characters which delimit the beginning of a text block to skip
      closingMarkers - characters which delimit the end of a text block to skip
      searchMode - a Set, ideally an EnumSet, containing the flags from the enum StringUtils.SearchMode that determine the behavior of the search
      Returns:
      the position where searchFor is found within searchIn starting from startingPosition.

    • indexOfIgnoreCase

      public static int indexOfIgnoreCase(int startingPosition, String searchIn, String searchFor, String openingMarkers, String closingMarkers, String overridingMarkers, Set<StringUtils.SearchMode> searchMode)
      Finds the position of a substring within a string, ignoring case, with the option to skip text delimited by given markers or within comments.
      Parameters:
      startingPosition - the position to start the search from
      searchIn - the string to search in
      searchFor - the string to search for
      openingMarkers - characters which delimit the beginning of a text block to skip
      closingMarkers - characters which delimit the end of a text block to skip
      overridingMarkers - the subset of openingMarkers that override the remaining markers, e.g., if openingMarkers = "'(" and overridingMarkers = "'" then the block between the outer parenthesis in "start ('max('); end" is strictly consumed, otherwise the suffix " end" would end up being consumed too in the process of handling the nested parenthesis.
      searchMode - a Set, ideally an EnumSet, containing the flags from the enum StringUtils.SearchMode that determine the behavior of the search
      Returns:
      the position where searchFor is found within searchIn starting from startingPosition.

    • split

      public static List<String> split(String stringToSplit, String delimiter, boolean trim)
      Splits stringToSplit into a list, using the given delimiter
      Parameters:
      stringToSplit - the string to split
      delimiter - the string to split on
      trim - should the split strings be whitespace trimmed?
      Returns:
      the list of strings, split by delimiter
      Throws:
      IllegalArgumentException

    • split

      public static List<String> split(String stringToSplit, String delimiter, String openingMarkers, String closingMarkers, boolean trim)
      Splits stringToSplit into a list, using the given delimiter and skipping all between the given markers.
      Parameters:
      stringToSplit - the string to split
      delimiter - the string to split on
      openingMarkers - characters which delimit the beginning of a text block to skip
      closingMarkers - characters which delimit the end of a text block to skip
      trim - should the split strings be whitespace trimmed?
      Returns:
      the list of strings, split by delimiter
      Throws:
      IllegalArgumentException

    • split

      public static List<String> split(String stringToSplit, String delimiter, String openingMarkers, String closingMarkers, String overridingMarkers, boolean trim)
      Splits stringToSplit into a list, using the given delimiter and skipping all between the given markers.
      Parameters:
      stringToSplit - the string to split
      delimiter - the string to split on
      openingMarkers - characters which delimit the beginning of a text block to skip
      closingMarkers - characters which delimit the end of a text block to skip
      overridingMarkers - the subset of openingMarkers that override the remaining markers, e.g., if openingMarkers = "'(" and overridingMarkers = "'" then the block between the outer parenthesis in "start ('max('); end" is strictly consumed, otherwise the suffix " end" would end up being consumed too in the process of handling the nested parenthesis.
      trim - should the split strings be whitespace trimmed?
      Returns:
      the list of strings, split by delimiter
      Throws:
      IllegalArgumentException

    • startsWithIgnoreCase

      public static boolean startsWithIgnoreCase(String searchIn, int startAt, String searchFor)
      Determines whether or not the string 'searchIn' contains the string 'searchFor', dis-regarding case starting at 'startAt' Shorthand for a String.regionMatch(...)
      Parameters:
      searchIn - the string to search in
      startAt - the position to start at
      searchFor - the string to search for
      Returns:
      whether searchIn starts with searchFor, ignoring case

    • startsWithIgnoreCase

      public static boolean startsWithIgnoreCase(String searchIn, String searchFor)
      Determines whether or not the string 'searchIn' contains the string 'searchFor', dis-regarding case. Shorthand for a String.regionMatch(...)
      Parameters:
      searchIn - the string to search in
      searchFor - the string to search for
      Returns:
      whether searchIn starts with searchFor, ignoring case

    • startsWithIgnoreCaseAndNonAlphaNumeric

      public static boolean startsWithIgnoreCaseAndNonAlphaNumeric(String searchIn, String searchFor)
      Determines whether or not the string 'searchIn' contains the string 'searchFor', disregarding case,leading whitespace and non-alphanumeric characters.
      Parameters:
      searchIn - the string to search in
      searchFor - the string to search for
      Returns:
      true if the string starts with 'searchFor' ignoring whitespace

    • startsWithIgnoreCaseAndWs

      public static boolean startsWithIgnoreCaseAndWs(String searchIn, String searchFor)
      Determines whether or not the string 'searchIn' contains the string 'searchFor', disregarding case and leading whitespace
      Parameters:
      searchIn - the string to search in
      searchFor - the string to search for
      Returns:
      true if the string starts with 'searchFor' ignoring whitespace

    • startsWithIgnoreCaseAndWs

      public static boolean startsWithIgnoreCaseAndWs(String searchIn, String searchFor, int beginPos)
      Determines whether or not the string 'searchIn' contains the string 'searchFor', disregarding case and leading whitespace
      Parameters:
      searchIn - the string to search in
      searchFor - the string to search for
      beginPos - where to start searching
      Returns:
      true if the string starts with 'searchFor' ignoring whitespace

    • startsWithIgnoreCaseAndWs

      public static int startsWithIgnoreCaseAndWs(String searchIn, String[] searchFor)
      Determines whether or not the string 'searchIn' starts with one of the strings in 'searchFor', disregarding case and leading whitespace
      Parameters:
      searchIn - the string to search in
      searchFor - the string array to search for
      Returns:
      the 'searchFor' array index that matched or -1 if none matches

    • stripEnclosure

      public static byte[] stripEnclosure(byte[] source, String prefix, String suffix)
      Parameters:
      prefix -
      suffix -
      bytesToStrip -

    • toAsciiString

      public static String toAsciiString(byte[] buffer)
      Returns the bytes as an ASCII String.
      Parameters:
      buffer - the bytes representing the string
      Returns:
      The ASCII String.

    • toAsciiString

      public static String toAsciiString(byte[] buffer, int startPos, int length)
      Returns the bytes as an ASCII String.
      Parameters:
      buffer - the bytes to convert
      startPos - the position to start converting
      length - the length of the string to convert
      Returns:
      the ASCII string

    • wildCompareIgnoreCase

      public static boolean wildCompareIgnoreCase(String searchIn, String searchFor)
      Compares searchIn against searchForWildcard with wildcards, in a case insensitive manner.
      Parameters:
      searchIn - the string to search in
      searchFor - the string to search for, using the 'standard' SQL wildcard chars of '%' and '_'

    • s2b

      static byte[] s2b(String s, MySQLConnection conn) throws SQLException
      Throws:
      SQLException

    • lastIndexOf

      public static int lastIndexOf(byte[] s, char c)

    • indexOf

      public static int indexOf(byte[] s, char c)

    • isNullOrEmpty

      public static boolean isNullOrEmpty(String toTest)

    • stripComments

      public static String stripComments(String src, String stringOpens, String stringCloses, boolean slashStarComments, boolean slashSlashComments, boolean hashComments, boolean dashDashComments)
      Returns the given string, with comments removed
      Parameters:
      src - the source string
      stringOpens - characters which delimit the "open" of a string
      stringCloses - characters which delimit the "close" of a string, in counterpart order to stringOpens
      slashStarComments - strip slash-star type "C" style comments
      slashSlashComments - strip slash-slash C++ style comments to end-of-line
      hashComments - strip #-style comments to end-of-line
      dashDashComments - strip "--" style comments to end-of-line
      Returns:
      the input string with all comment-delimited data removed

    • sanitizeProcOrFuncName

      public static String sanitizeProcOrFuncName(String src)
      Next two functions are to help DBMD check if the given string is in form of database.name and return it as "database";"name" with comments removed. If string is NULL or wildcard (%), returns null and exits. First, we sanitize...
      Parameters:
      src - the source string
      Returns:
      the input string with all comment-delimited data removed

    • splitDBdotName

      public static List<String> splitDBdotName(String source, String catalog, String quoteId, boolean isNoBslashEscSet)
      Splits an entity identifier into its parts (database and entity name) and returns a list containing the two elements. If the identifier doesn't contain the database part then the argument catalog is used in its place and source corresponds to the full entity name. If argument source is NULL or wildcard (%), returns an empty list.
      Parameters:
      source - the source string
      catalog - Catalog, if available
      quoteId - quote character as defined on server
      isNoBslashEscSet - is our connection in no BackSlashEscape mode
      Returns:
      the input string with all comment-delimited data removed

    • isEmptyOrWhitespaceOnly

      public static boolean isEmptyOrWhitespaceOnly(String str)

    • escapeQuote

      public static String escapeQuote(String src, String quotChar)

    • quoteIdentifier

      public static String quoteIdentifier(String identifier, String quoteChar, boolean isPedantic)
      Surrounds identifier with quoteChar and duplicates these symbols inside the identifier.
      Parameters:
      identifier - in pedantic mode (connection property pedantic=true) identifier is treated as unquoted (as it is stored in the database) even if it starts and ends with quoteChar; in non-pedantic mode if identifier starts and ends with quoteChar method treats it as already quoted and doesn't modify.
      quoteChar - ` or "
      isPedantic - are we in pedantic mode
      Returns:
      With quoteChar="`":
      • null -> null
      • abc -> `abc`
      • ab`c -> `ab``c`
      • ab"c -> `ab"c`
      • `ab``c` -> `ab``c` in non-pedantic mode or ```ab````c``` in pedantic mode
      With quoteChar="\"":
      • null -> null
      • abc -> "abc"
      • ab`c -> "ab`c"
      • ab"c -> "ab""c"
      • "ab""c" -> "ab""c" in non-pedantic mode or """ab""""c""" in pedantic mode

    • quoteIdentifier

      public static String quoteIdentifier(String identifier, boolean isPedantic)
      Surrounds identifier with "`" and duplicates these symbols inside the identifier.
      Parameters:
      identifier - in pedantic mode (connection property pedantic=true) identifier is treated as unquoted (as it is stored in the database) even if it starts and ends with "`"; in non-pedantic mode if identifier starts and ends with "`" method treats it as already quoted and doesn't modify.
      isPedantic - are we in pedantic mode
      Returns:
      • null -> null
      • abc -> `abc`
      • ab`c -> `ab``c`
      • ab"c -> `ab"c`
      • `ab``c` -> `ab``c` in non-pedantic mode or ```ab````c``` in pedantic mode

    • unQuoteIdentifier

      public static String unQuoteIdentifier(String identifier, String quoteChar)
      Trims identifier, removes quote chars from first and last positions and replaces double occurrences of quote char from entire identifier, i.e converts quoted identifier into form as it is stored in database.
      Parameters:
      identifier -
      quoteChar - ` or "
      Returns:
      • null -> null
      • abc -> abc
      • `abc` -> abc
      • `ab``c` -> ab`c
      • `"ab`c"` -> "ab`c"
      • `ab"c` -> ab"c
      • "abc" -> abc
      • "`ab""c`" -> `ab"c`
      • "ab`c" -> ab`c

    • indexOfQuoteDoubleAware

      public static int indexOfQuoteDoubleAware(String searchIn, String quoteChar, int startFrom)

    • toString

      public static String toString(byte[] value, int offset, int length, String encoding) throws UnsupportedEncodingException
      Throws:
      UnsupportedEncodingException

    • toString

      public static String toString(byte[] value, String encoding) throws UnsupportedEncodingException
      Throws:
      UnsupportedEncodingException

    • toString

      public static String toString(byte[] value, int offset, int length)

    • toString

      public static String toString(byte[] value)

    • getBytes

      public static byte[] getBytes(char[] value)

    • getBytes

      public static byte[] getBytes(char[] value, int offset, int length)

    • getBytes

      public static byte[] getBytes(char[] value, String encoding) throws UnsupportedEncodingException
      Throws:
      UnsupportedEncodingException

    • getBytes

      public static byte[] getBytes(char[] value, int offset, int length, String encoding) throws UnsupportedEncodingException
      Throws:
      UnsupportedEncodingException

    • getBytes

      public static byte[] getBytes(String value)

    • getBytes

      public static byte[] getBytes(String value, int offset, int length)

    • getBytes

      public static byte[] getBytes(String value, String encoding) throws UnsupportedEncodingException
      Throws:
      UnsupportedEncodingException

    • getBytes

      public static byte[] getBytes(String value, int offset, int length, String encoding) throws UnsupportedEncodingException
      Throws:
      UnsupportedEncodingException

    • isValidIdChar

      public static final boolean isValidIdChar(char c)

    • appendAsHex

      public static void appendAsHex(StringBuilder builder, byte[] bytes)

    • appendAsHex

      public static void appendAsHex(StringBuilder builder, int value)

    • getBytesNullTerminated

      public static byte[] getBytesNullTerminated(String value, String encoding) throws UnsupportedEncodingException
      Throws:
      UnsupportedEncodingException

    • isStrictlyNumeric

      public static boolean isStrictlyNumeric(CharSequence cs)
      Checks is the CharSequence contains digits only. No leading sign and thousands or decimal separators are allowed.
      Parameters:
      cs - The CharSequence to check.
      Returns:
      true if the CharSequence not empty and contains only digits, false otherwise.