SqlStringAscii.cpp File Reference

Go to the source code of this file.

Functions
FENNEL_BEGIN_NAMESPACE int	SqlStrCat_Ascii (char *dest, int destStorageBytes, int destLenBytes, char const *const str, int strLenBytes)
	Strcat.
int	SqlStrCat_Ascii (char *dest, int destStorageBytes, char const *const str1, int str1LenBytes, char const *const str2, int str2LenBytes)
	StrCat.
int	SqlStrCmp_Ascii_Fix (char const *const str1, int str1LenBytes, char const *const str2, int str2LenBytes, char trimchar)
	StrCmp.
int	SqlStrCmp_Ascii_Var (char const *const str1, int str1LenBytes, char const *const str2, int str2LenBytes)
	StrCmp.
int	SqlStrLenBit_Ascii (char const *const str, int strLenBytes)
	StrLen in bits.
int	SqlStrLenChar_Ascii (char const *const str, int strLenBytes)
	StrLen in characters.
int	SqlStrLenOct_Ascii (char const *const str, int strLenBytes)
	StrLen in octets.
int	SqlStrOverlay_Ascii (char *dest, int destStorageBytes, char const *const str, int strLenBytes, char const *const over, int overLenBytes, int startChar, int lengthChar, int lenSpecified)
	Overlay.
int	SqlStrPos_Ascii (char const *const str, int strLenBytes, char const *const find, int findLenBytes)
	Position.
int	SqlStrSubStr_Ascii (char const **dest, int destStorageBytes, char const *const str, int strLenBytes, int subStartChar, int subLengthChar, int subLenSpecified)
	Substring by reference.
int	SqlStrToLower_Ascii (char *dest, int destStorageBytes, char const *src, int srcLenBytes)
	toLower. Ascii. CHAR/VARCHAR. Returns length.
int	SqlStrToUpper_Ascii (char *dest, int destStorageBytes, char const *src, int srcLenBytes)
	toUpper. Ascii. CHAR/VARCHAR. Returns length.
int	SqlStrTrim_Ascii (char *dest, int destStorageBytes, char const *const str, int strLenBytes, int trimLeft, int trimRight, char trimchar)
	Trim padding.
int	SqlStrTrim_Ascii (char const **result, char const *const str, int strLenBytes, int trimLeft, int trimRight, char trimchar)
	Trim padding by reference.

---

Function Documentation

int SqlStrCat_Ascii	(	char *	dest,
		int	destStorageBytes,
		char const *const	str1,
		int	str1LenBytes,
		char const *const	str2,
		int	str2LenBytes
	)

StrCat.

Ascii. SQL VARCHAR & CHAR. dest = str1 || str2. dest = str1 || str2

Returns new length in bytes.

This is an optimization for creating a concatenated string from two other strings, eliminating a separate string copy. The assumption is that this is the common case with concatenation. Subsequent concatenations may occur with other form.

If either string is variable width, the result is variable width: per SQL99 Part 2 Section 6.27 Syntax Rule 3.a.i. If both strings are fixed width, the result is fixed width, item ii.

Note: CHAR('1 ') || CHAR('2 ') is CHAR('1 2 ') and is not CHAR('12 ').

When used with CHARs, ignore the return value, and set destLenBytes = destStorageBytes

Definition at line 51 of file SqlStringAscii.cpp.

{
    if (str1LenBytes + str2LenBytes > destStorageBytes) {
        // SQL99 Part 2 Section 22.1 22-001 "String Data Right truncation"
        throw "22001";
    }

    memcpy(dest, str1, str1LenBytes);
    memcpy(dest + str1LenBytes, str2, str2LenBytes);
    return str1LenBytes + str2LenBytes;
}

FENNEL_BEGIN_NAMESPACE int SqlStrCat_Ascii	(	char *	dest,
		int	destStorageBytes,
		int	destLenBytes,
		char const *const	str,
		int	strLenBytes
	)

Strcat.

Ascii. SQL VARCHAR & CHAR. dest = dest || str. Returns new length in bytes.

If either string is variable width, the result is variable width: per SQL99 Part 2 Section 6.27 Syntax Rule 3.a.i. If both strings are fixed width, the result is fixed width, per item ii.

Note that CHAR('1 ') || CHAR('2 ') = CHAR('1 2 ') and not CHAR('12 ').

When called repeatedly to cat multiple strings together (e.g. A || B || C), the final destLength must be exactly equal to the defined resulting width. (e.g. width of A+B+C) for both VARCHAR & CHAR. Take care that these length semantics are adhered to in the final result, even though intermediate results (say A || B) may not have the correct length.

When used with CHARs, set strLenBytes to strStorageBytes. On intermediate results set destLenBytes = return value of previous call. Final result should/must have return value == destStorage.

Definition at line 33 of file SqlStringAscii.cpp.

Referenced by SqlStringAsciiTest::testSqlStringCat_Ascii_Fix(), SqlStringAsciiTest::testSqlStringCat_Ascii_Var(), and SqlStringAsciiTest::testSqlStringCat_Ascii_Var2().

{
    if (destLenBytes + strLenBytes > destStorageBytes) {
        // SQL99 Part 2 Section 22.1 22-001 "String Data Right truncation"
        throw "22001";
    }

    memcpy(dest + destLenBytes, str, strLenBytes);
    return destLenBytes + strLenBytes;
}

int SqlStrCmp_Ascii_Fix	(	char const *const	str1,
		int	str1LenBytes,
		char const *const	str2,
		int	str2LenBytes,
		char	trimchar = ' '
	)

StrCmp.

Ascii. Fixed Width / SQL CHAR.

Returns -1, 0, 1.

Definition at line 70 of file SqlStringAscii.cpp.

Referenced by SqlStringAsciiTest::testSqlStringCmp_Ascii_Fix_Helper().

{
    char const * start = str1;
    char const * end = str1 + str1LenBytes;

    if (end != start) {
        end--;
        while (end != start && *end == trimchar) {
            end--;
        }
        if (end != start || *end != trimchar) {
            end++;
        }
    }
    int str1TrimLenBytes = end - start;

    start = str2;
    end = str2 + str2LenBytes;

    if (end != start) {
        end--;
        while (end != start && *end == trimchar) {
            end--;
        }
        if (end != start || *end != trimchar) {
            end++;
        }
    }
    int str2TrimLenBytes = end - start;

    if (str1TrimLenBytes > str2TrimLenBytes) {
        return 1;
    } else if (str1TrimLenBytes < str2TrimLenBytes) {
        return -1;
    }

    assert(str1TrimLenBytes == str2TrimLenBytes);

    // comparison must be unsigned to work for > 128
    unsigned char const *s1 = reinterpret_cast<unsigned char const *>(str1);
    unsigned char const *s2 = reinterpret_cast<unsigned char const *>(str2);
    int len = str1TrimLenBytes;

    while (len-- > 0) {
        if (*s1 != *s2) {
            return (*s1 > *s2) ? 1 : -1;
        }
        s1++;
        s2++;
    }
    return 0;
}

int SqlStrCmp_Ascii_Var	(	char const *const	str1,
		int	str1LenBytes,
		char const *const	str2,
		int	str2LenBytes
	)

StrCmp.

Ascii. Variable Width / VARCHAR.

Returns -1, 0, 1

Definition at line 129 of file SqlStringAscii.cpp.

Referenced by SqlStringAsciiTest::testSqlStringCmp_Ascii_Var_Helper().

{
    // consider strcoll for I18N
    if (str1LenBytes > str2LenBytes) {
        return 1;
    } else if (str1LenBytes < str2LenBytes) {
        return -1;
    }

    assert(str1LenBytes == str2LenBytes);

    // comparison must be unsigned to work for > 128
    unsigned char const *s1 = reinterpret_cast<unsigned char const *>(str1);
    unsigned char const *s2 = reinterpret_cast<unsigned char const *>(str2);
    int len = str1LenBytes;

    while (len-- > 0) {
        if (*s1 != *s2) {
            return (*s1 > *s2) ? 1 : -1;
        }
        s1++;
        s2++;
    }
    return 0;
}

int SqlStrLenBit_Ascii	(	char const *const	str,
		int	strLenBytes
	)

StrLen in bits.

Ascii. CHAR/VARCHAR.

Parameter str is ignored for ascii strings.

Definition at line 161 of file SqlStringAscii.cpp.

Referenced by SqlStringAsciiTest::testSqlStringLenBit_Ascii().

{
    return 8 * strLenBytes;
}

int SqlStrLenChar_Ascii	(	char const *const	str,
		int	strLenBytes
	)

StrLen in characters.

Ascii. CHAR/VARCHAR.

Parameter str is ignored for ascii strings.

Definition at line 169 of file SqlStringAscii.cpp.

Referenced by SqlStringAsciiTest::testSqlStringLenChar_Ascii().

{
    return strLenBytes;
}

int SqlStrLenOct_Ascii	(	char const *const	str,
		int	strLenBytes
	)

StrLen in octets.

Ascii. CHAR/VARCHAR.

Parameter str is ignored for ascii strings.

Definition at line 177 of file SqlStringAscii.cpp.

Referenced by SqlStringAsciiTest::testSqlStringLenOct_Ascii().

{
    return strLenBytes;
}

int SqlStrOverlay_Ascii	(	char *	dest,
		int	destStorageBytes,
		char const *const	str,
		int	strLenBytes,
		char const *const	over,
		int	overLenBytes,
		int	startChar,
		int	lengthChar,
		int	lenSpecified
	)

Overlay.

Ascii. CHAR/VARCHAR. Returns new length in bytes

See SQL99 Part 2 Section 6.18 Syntax Rule 10. Overlay is defined in terms of Substring an concatenation. If start is < 1 or length < 0, a substring error may be thrown. Result is VARCHAR, as the result of substring is always VARCHAR, and concatenation results in VARCHAR if any of its operands are VARCHAR. startChar is 1-indexed, as per SQL standard.

Definition at line 186 of file SqlStringAscii.cpp.

Referenced by SqlStringAsciiTest::testSqlStringOverlay_Ascii().

{
    if (!lenSpecified) {
        lengthChar = overLenBytes;
    }
    if (lengthChar < 0 || startChar < 1) {
        // Overlay is defined in terms of substring. These conditions
        // would, I believe, generate a substring error. Also
        // another "reference" sql database gets angry under these
        // conditions. Therefore, per:
        // SQL99 Part 2 Section 6.18 General Rule 3.d generate a
        // SQL99 Part 2 Section 22.1 22-011 "data exception substring error".
        throw "22011";
    }

    int leftLenBytes = startChar - 1;         // 1-index to 0-index
    if (leftLenBytes > strLenBytes) {
        leftLenBytes = strLenBytes;
    }
    char const *rightP = str + leftLenBytes + lengthChar;
    int rightLenBytes = strLenBytes - (leftLenBytes + lengthChar);
    if (rightLenBytes < 0) {
        rightLenBytes = 0;
    }
    assert(leftLenBytes >= 0);
    assert(rightLenBytes >= 0);
    assert(rightP >= str);

    if (leftLenBytes + rightLenBytes + overLenBytes > destStorageBytes) {
        // SQL99 Part 2 Section 22.1 22-001 "String Data Right truncation"
        throw "22001";
    }

    char *dp = dest;

    memcpy(dp, str, leftLenBytes);
    dp += leftLenBytes;
    memcpy(dp, over, overLenBytes);
    dp += overLenBytes;
    memcpy(dp, rightP, rightLenBytes);
    dp += rightLenBytes;

    return dp - dest;
}

int SqlStrPos_Ascii	(	char const *const	str,
		int	strLenBytes,
		char const *const	find,
		int	findLenBytes
	)

Position.

Ascii. CHAR/VARHCAR. Returns 1-index string position.

Returns 0 if not found. Returns 1 if find is zero length. See SQL99 Part 2 Section 6.17 General Rule 2.

Definition at line 241 of file SqlStringAscii.cpp.

Referenced by SqlStringAsciiTest::testSqlStringPos_Ascii().

{
    // SQL99 Part 2 Section 6.17 General Rule 2.a.
    if (!findLenBytes) {
        return 1;
    }
    // SQL99 Part 2 Section 6.17 General Rule 2.c.
    if (findLenBytes > strLenBytes) {
        return 0;
    }
    assert(findLenBytes > 0);
    assert(strLenBytes > 0);
    assert(strLenBytes - findLenBytes >= 0);

    register char const * s = str;
    char const * end = 1 + s + (strLenBytes - findLenBytes);

    while (s < end) {
        // search for first char of find
        s = reinterpret_cast<char const *>(memchr(s, *find, end - s));
        if (!s) {
            return 0;                // Case C.
        }
        if (!memcmp(s, find, findLenBytes)) {
            // add 1 to make result 1-indexed.
            return (s - str) + 1;   // Case B.
        } else {
            s++;
        }
    }
    return 0;                            // Case C.
}

int SqlStrSubStr_Ascii	(	char const **	dest,
		int	destStorageBytes,
		char const *const	str,
		int	strLenBytes,
		int	subStartChar,
		int	subLenChar,
		int	subLenBytesSpecified
	)

Substring by reference.

Ascii. Returns VARCHAR. Accepts CHAR/VARCHAR. Sets dest to start of of substring. Returns length of substring.

Note that subStart is 1-indexed, as per SQL99 spec. All substring parameters are handled as signed, as spec implies that they could be negative. Some combinations of subStart and subLenBytes may throw an exception. Results in a VARCHAR. See SQL99 Part 2 Section 6.18 General Rule 3. subStartChar is 1-indexed.

Definition at line 280 of file SqlStringAscii.cpp.

Referenced by SqlStringAsciiTest::testSqlStringSubStr_Ascii().

{
    int e;
    if (subLenSpecified) {
        e = subStartChar + subLengthChar;
    } else {
        e = strLenBytes + 1;
        if (subStartChar > e) {
            e = subStartChar;
        }
    }

    if (e < subStartChar) {
        // Per SQL99 Part 2 Section 6.18 General Rule 3.d, generate a
        // "data exception substring error". SQL99 Part 2 Section 22.1 22-011
        throw "22011";
    }

    if (subStartChar > strLenBytes || e < 1) {
        return 0;
    }

    int s1 = 1;
    if (subStartChar > s1) {
        s1 = subStartChar;
    }

    int e1 = strLenBytes + 1;
    if (e < e1) {
        e1 = e;
    }
    int l1 = e1 - s1;


    if (l1 > destStorageBytes) {
        // SQL99 Part 2 Section 22.1 22-001 "String Data Right truncation"
        throw "22001";
    }
    if (l1 < 0) {
        // Expected behavior not clear.
        // SQL99 Part 2 Section 22.1 22-011 "data exception substring error".
        throw "22011";
    }

    // - 1 converts from 1-indexed to 0-indexed
    *dest = str + s1 - 1;
    return l1;
}

int SqlStrToLower_Ascii	(	char *	dest,
		int	destStorageBytes,
		char const *	src,
		int	srcLenBytes
	)

toLower. Ascii. CHAR/VARCHAR. Returns length.

Definition at line 337 of file SqlStringAscii.cpp.

Referenced by SqlStringAsciiTest::testSqlStringToLower_Ascii().

{
    register char const * s = src;
    register char* d = dest;
    char* e = dest + srcLenBytes;

    if (srcLenBytes > destStorageBytes) {
        // SQL99 Part 2 Section 22.1 22-001 "String Data Right truncation"
        throw "22001";
    }

    while (d < e) {
        *(d++) = tolower(*(s++));
    }
    return srcLenBytes;
}

int SqlStrToUpper_Ascii	(	char *	dest,
		int	destStorageBytes,
		char const *	src,
		int	srcLenBytes
	)

toUpper. Ascii. CHAR/VARCHAR. Returns length.

Definition at line 359 of file SqlStringAscii.cpp.

Referenced by SqlStringAsciiTest::testSqlStringToUpper_Ascii().

{
    register char const * s = src;
    register char* d = dest;
    char* e = dest + srcLenBytes;

    if (srcLenBytes > destStorageBytes) {
        // SQL99 Part 2 Section 22.1 22-001 "String Data Right truncation"
        throw "22001";
    }

    while (d < e) {
        *(d++) = toupper(*(s++));
    }
    return srcLenBytes;
}

int SqlStrTrim_Ascii	(	char const **	result,
		char const *const	str,
		int	strLenBytes,
		int	trimLeft,
		int	trimRight,
		char	trimchar = ' '
	)

Trim padding by reference.

Ascii. CHAR/VARCHAR. Returns new length.

See SQL99 Part 2 Section 6.18 General Rule 8. Results in a VARCHAR. Note: Does not check that result has enough capacity to contain substring as this is irrelevant. If a program depends on the size of result not changing, and this instruction enforcing that invariant -- probably a bad practice anyway -- trouble could result.

Definition at line 420 of file SqlStringAscii.cpp.

{
    char const * start = str;
    char const * end = str + strLenBytes;

    // If many pad characters are expected, consider using memrchr()
    if (trimLeft) {
        while (start != end && *start == trimchar) {
            start++;
        }
    }
    if (trimRight && end != start) {
        end--;
        while (end != start && *end == trimchar) {
            end--;
        }
        if (end != start || *end != trimchar) {
            end++;
        }
    }

    *result = start;
    return end - start;
}

int SqlStrTrim_Ascii	(	char *	dest,
		int	destStorageBytes,
		char const *const	str,
		int	strLenBytes,
		int	trimLeft,
		int	trimRight,
		char	trimchar = ' '
	)

Trim padding.

Ascii. CHAR/VARCHAR. Returns new length.

See SQL99 Part 2 Section 6.18 General Rule 8. Results in a VARCHAR.

Definition at line 381 of file SqlStringAscii.cpp.

Referenced by SqlStringAsciiTest::testSqlStringTrim_Ascii().

{
    char const * start = str;
    char const * end = str + strLenBytes;
    int newLenBytes;

    // If many pad characters are expected, consider using memrchr()
    if (trimLeft) {
        while (start != end && *start == trimchar) {
            start++;
        }
    }
    if (trimRight && end != start) {
        end--;
        while (end != start && *end == trimchar) {
            end--;
        }
        if (end != start || *end != trimchar) {
            end++;
        }
    }
    newLenBytes = end - start;

    if (newLenBytes > destStorageBytes) {
        // SQL99 Part 2 Section 22.1 22-001 "String Data Right truncation"
        throw "22001";
    }
    memcpy(dest, start, newLenBytes);
    return newLenBytes;
}

---