ExtRegExp.cpp File Reference

Go to the source code of this file.

Classes
class	ExtRegExpContext
Functions
void	strLikeEscapeA (boost::scoped_ptr< ExtendedInstructionContext > &context, RegisterRef< bool > *result, RegisterRef< char * > *matchValue, RegisterRef< char * > *pattern, RegisterRef< char * > *escape)
void	strLikeA (boost::scoped_ptr< ExtendedInstructionContext > &context, RegisterRef< bool > *result, RegisterRef< char * > *matchValue, RegisterRef< char * > *pattern)
void	strSimilarEscapeA (boost::scoped_ptr< ExtendedInstructionContext > &context, RegisterRef< bool > *result, RegisterRef< char * > *matchValue, RegisterRef< char * > *pattern, RegisterRef< char * > *escape)
void	strSimilarA (boost::scoped_ptr< ExtendedInstructionContext > &context, RegisterRef< bool > *result, RegisterRef< char * > *matchValue, RegisterRef< char * > *pattern)
void	ExtRegExpRegister (ExtendedInstructionTable *eit)

---

Function Documentation

void ExtRegExpRegister

(

ExtendedInstructionTable *

eit

)

Definition at line 180 of file ExtRegExp.cpp.

References ExtendedInstructionTable::add(), STANDARD_TYPE_BOOL, STANDARD_TYPE_CHAR, STANDARD_TYPE_VARCHAR, strLikeA(), strLikeEscapeA(), strSimilarA(), and strSimilarEscapeA().

Referenced by CalcInit::instance().

{
    assert(eit != NULL);

    // JK 2004/5/27: Are all of these combinations really needed?
    int i;
    for (i = 0; i < 8; i++) {
        vector<StandardTypeDescriptorOrdinal> params;

        params.push_back(STANDARD_TYPE_BOOL);

        if (i & 0x01) {
            params.push_back(STANDARD_TYPE_CHAR);
        } else {
            params.push_back(STANDARD_TYPE_VARCHAR);
        }
        if (i & 0x02) {
            params.push_back(STANDARD_TYPE_CHAR);
        } else {
            params.push_back(STANDARD_TYPE_VARCHAR);
        }

        eit->add(
            "strLikeA3", params,
            (ExtendedInstruction3Context<bool, char*, char*>*) NULL,
            &strLikeA);
        eit->add(
            "strSimilarA3", params,
            (ExtendedInstruction3Context<bool, char*, char*>*) NULL,
            &strSimilarA);

        // tack on escape parameter
        if (i & 0x04) {
            params.push_back(STANDARD_TYPE_CHAR);
        } else {
            params.push_back(STANDARD_TYPE_VARCHAR);
        }

        eit->add(
            "strLikeA4", params,
            (ExtendedInstruction4Context<bool, char*, char*, char*>*) NULL,
            &strLikeEscapeA);
        eit->add(
            "strSimilarA4", params,
            (ExtendedInstruction4Context<bool, char*, char*, char*>*) NULL,
            &strSimilarEscapeA);
    }
}

void strLikeA	(	boost::scoped_ptr< ExtendedInstructionContext > &	context,
		RegisterRef< bool > *	result,
		RegisterRef< char * > *	matchValue,
		RegisterRef< char * > *	pattern
	)

Definition at line 104 of file ExtRegExp.cpp.

References strLikeEscapeA().

Referenced by ExtRegExpRegister().

{
    strLikeEscapeA(context, result, matchValue, pattern, 0);
}

void strLikeEscapeA	(	boost::scoped_ptr< ExtendedInstructionContext > &	context,
		RegisterRef< bool > *	result,
		RegisterRef< char * > *	matchValue,
		RegisterRef< char * > *	pattern,
		RegisterRef< char * > *	escape
	)

Definition at line 49 of file ExtRegExp.cpp.

References RegisterRef< TMPLT >::isNull(), StandardTypeDescriptor::isTextArray(), RegisterRef< TMPLT >::length(), ExtRegExpContext::pattern, RegisterRef< TMPLT >::pointer(), ExtRegExpContext::regex, RegisterRef< TMPLT >::toNull(), RegisterReference::type(), and RegisterRef< TMPLT >::value().

Referenced by ExtRegExpRegister(), and strLikeA().

{
    assert(StandardTypeDescriptor::isTextArray(matchValue->type()));
    assert(StandardTypeDescriptor::isTextArray(pattern->type()));

    // SQL99 Part 2 Section 8.5 General Rule 3.a, cases i & ii
    if (matchValue->isNull() ||
        pattern->isNull() ||
        (escape ? escape->isNull() : false)) {
        result->toNull();
        result->length(0);
    } else {
        boost::regex* regexP;
        string* patP;
        ExtRegExpContext* ctxP;

        ctxP = static_cast<ExtRegExpContext*>(context.get());
        if (!ctxP) {
            string pat;
            SqlLikePrep<1,1>(
                pattern->pointer(),
                pattern->length(),
                (escape ? escape->pointer() : 0),
                (escape ? escape->length() : 0),
                pat);
            try {
                boost::regex regex(pat);
                context.reset(new ExtRegExpContext(regex, pat));
            } catch (boost::bad_expression badexp) {
                // SQL99 Part 2 Section 8.5 General Rule 3.b.i2 *seems* like
                // best fit here.
                // Data Exception - Invalid Escape Sequence
                throw "22025";
            }
            // get context anew
            ctxP = static_cast<ExtRegExpContext*>(context.get());
        }
        regexP = &(ctxP->regex);
        patP = &(ctxP->pattern);

        result->value(
            SqlRegExp<1,1>(
                matchValue->pointer(),
                matchValue->length(),
                pattern->length(),
                *regexP));
    }
}

void strSimilarA	(	boost::scoped_ptr< ExtendedInstructionContext > &	context,
		RegisterRef< bool > *	result,
		RegisterRef< char * > *	matchValue,
		RegisterRef< char * > *	pattern
	)

Definition at line 170 of file ExtRegExp.cpp.

References strSimilarEscapeA().

Referenced by ExtRegExpRegister().

{
    strSimilarEscapeA(context, result, matchValue, pattern, 0);
}

void strSimilarEscapeA	(	boost::scoped_ptr< ExtendedInstructionContext > &	context,
		RegisterRef< bool > *	result,
		RegisterRef< char * > *	matchValue,
		RegisterRef< char * > *	pattern,
		RegisterRef< char * > *	escape
	)

Definition at line 116 of file ExtRegExp.cpp.

References RegisterRef< TMPLT >::isNull(), StandardTypeDescriptor::isTextArray(), RegisterRef< TMPLT >::length(), ExtRegExpContext::pattern, RegisterRef< TMPLT >::pointer(), ExtRegExpContext::regex, RegisterRef< TMPLT >::toNull(), RegisterReference::type(), and RegisterRef< TMPLT >::value().

Referenced by ExtRegExpRegister(), and strSimilarA().

{
    assert(StandardTypeDescriptor::isTextArray(matchValue->type()));
    assert(StandardTypeDescriptor::isTextArray(pattern->type()));

    // SQL2003 Part 2 Section 8.5 General Rule 4.a,b
    if (matchValue->isNull() ||
        pattern->isNull() ||
        (escape ? escape->isNull() : false)) {
        result->toNull();
        result->length(0);
    } else {
        boost::regex* regexP;
        string* patP;
        ExtRegExpContext* ctxP;

        ctxP = static_cast<ExtRegExpContext*>(context.get());
        if (!ctxP) {
            string pat;
            SqlSimilarPrep<1,1>(
                pattern->pointer(),
                pattern->length(),
                (escape ? escape->pointer() : 0),
                (escape ? escape->length() : 0),
                pat);
            try {
                boost::regex regex(pat);
                context.reset(new ExtRegExpContext(regex, pat));
            } catch (boost::bad_expression badexp) {
                // SQL2003 Part 2 Section 8.6 General Rule 2
                // Data Exception - Invalid Regular Expression
                throw "2201B";
            }
            // get context anew
            ctxP = static_cast<ExtRegExpContext*>(context.get());
        }
        regexP = &(ctxP->regex);
        patP = &(ctxP->pattern);

        result->value(
            SqlRegExp<1,1>(
                matchValue->pointer(),
                matchValue->length(),
                pattern->length(),
                *regexP));
    }
}

---