src/sql/SqlStatement.cxx File Reference

#include "Statement.h"
#include <SqlStatement.h>
#include <dmllex.h>

Include dependency graph for SqlStatement.cxx:

Go to the source code of this file.

Functions
int	yyparse ()
Variables
char *	lexInput
ParsedData *	parsedData

---

Function Documentation

int yyparse

(

)

Definition at line 374 of file dmlyacc.cxx.

References CreateIndexStatement, CreateTableStatement, DeleteStatement, DropIndexStatement, DropTableStatement, AllDataType::getComparisionOperator(), ParsedData::getInValueList(), List::getIterator(), ListIterator::hasElement(), hashIndex, ParsedData::insertCondValueAndGetPtr(), ParsedData::insertField(), ParsedData::insertFldDef(), ParsedData::insertInValue(), ParsedData::insertPredicate(), InsertStatement, ParsedData::insertUpdateValue(), ParsedData::insertValue(), ListIterator::nextElement(), OpAnd, OpEquals, OpGreaterThanEquals, OpLessThanEquals, OpNot, OpOr, parsedData, FieldValue::parsedString, YYSTYPE::predicate, SelectStatement, ParsedData::setCondition(), ParsedData::setDefaultValue(), ParsedData::setFldLength(), ParsedData::setFldName(), ParsedData::setFldNotNull(), ParsedData::setFldType(), ParsedData::setIndexName(), ParsedData::setIndexType(), ParsedData::setPrimary(), ParsedData::setStmtType(), ParsedData::setTableName(), ParsedData::setUnique(), YYSTYPE::stringval, treeIndex, typeByteInt, typeDate, typeDouble, typeFloat, typeInt, typeLong, typeLongLong, typeShort, typeString, typeTime, typeTimeStamp, UpdateStatement, YYACCEPT, yychar, yycheck, YYDEBUG, yydebug, yydefred, yydgoto, YYERRCODE, yyerrflag, yyerror(), YYFINAL, yygindex, yylen, yylex(), yylhs, yylval, YYMAXTOKEN, yynerrs, YYPREFIX, yyrindex, yysindex, yyss, yyssp, yystacksize, yytable, YYTABLESIZE, yyval, yyvs, and yyvsp.

Referenced by SqlStatement::prepare().

{
    register int yym, yyn, yystate;
#if YYDEBUG
    register char *yys;
    extern char *getenv();

    if (yys = getenv("YYDEBUG"))
    {
        yyn = *yys;
        if (yyn >= '0' && yyn <= '9')
            yydebug = yyn - '0';
    }
#endif

    yynerrs = 0;
    yyerrflag = 0;
    yychar = (-1);

    yyssp = yyss;
    yyvsp = yyvs;
    *yyssp = yystate = 0;

yyloop:
    if (yyn = yydefred[yystate]) goto yyreduce;
    if (yychar < 0)
    {
        if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, reading %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
    }
    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: state %d, shifting to state %d\n",
                    YYPREFIX, yystate, yytable[yyn]);
#endif
        if (yyssp >= yyss + yystacksize - 1)
        {
            goto yyoverflow;
        }
        *++yyssp = yystate = yytable[yyn];
        *++yyvsp = yylval;
        yychar = (-1);
        if (yyerrflag > 0)  --yyerrflag;
        goto yyloop;
    }
    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
        yyn = yytable[yyn];
        goto yyreduce;
    }
    if (yyerrflag) goto yyinrecovery;
#ifdef lint
    goto yynewerror;
#endif
yynewerror:
    yyerror("syntax error");
#ifdef lint
    goto yyerrlab;
#endif
yyerrlab:
    ++yynerrs;
yyinrecovery:
    if (yyerrflag < 3)
    {
        yyerrflag = 3;
        for (;;)
        {
            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: state %d, error recovery shifting\
 to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
#endif
                if (yyssp >= yyss + yystacksize - 1)
                {
                    goto yyoverflow;
                }
                *++yyssp = yystate = yytable[yyn];
                *++yyvsp = yylval;
                goto yyloop;
            }
            else
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: error recovery discarding state %d\n",
                            YYPREFIX, *yyssp);
#endif
                if (yyssp <= yyss) goto yyabort;
                --yyssp;
                --yyvsp;
            }
        }
    }
    else
    {
        if (yychar == 0) goto yyabort;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
        yychar = (-1);
        goto yyloop;
    }
yyreduce:
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
                YYPREFIX, yystate, yyn, yyrule[yyn]);
#endif
    yym = yylen[yyn];
    yyval = yyvsp[1-yym];
    switch (yyn)
    {
case 1:
#line 33 "dmlyacc.yxx"
{ YYACCEPT; }
break;
case 2:
#line 34 "dmlyacc.yxx"
{ YYACCEPT; }
break;
case 3:
#line 35 "dmlyacc.yxx"
{ YYACCEPT; }
break;
case 4:
#line 36 "dmlyacc.yxx"
{ YYACCEPT; }
break;
case 5:
#line 37 "dmlyacc.yxx"
{ YYACCEPT; }
break;
case 6:
#line 41 "dmlyacc.yxx"
{
            parsedData->setStmtType(SelectStatement);
            parsedData->setTableName(yyvsp[-2].stringval); 
            free(yyvsp[-2].stringval);
        }
break;
case 10:
#line 55 "dmlyacc.yxx"
{
            parsedData->setStmtType(InsertStatement);
            parsedData->setTableName(yyvsp[-6].stringval); 
            free(yyvsp[-6].stringval);
        }
break;
case 14:
#line 68 "dmlyacc.yxx"
{
            parsedData->insertValue((char*)yyvsp[0].stringval);
            free(yyvsp[0].stringval);
        }
break;
case 15:
#line 74 "dmlyacc.yxx"
{
            parsedData->insertValue((char*)yyvsp[0].stringval);
            free(yyvsp[0].stringval);
        }
break;
case 17:
#line 82 "dmlyacc.yxx"
{
            parsedData->insertInValue((char*)yyvsp[0].stringval);
            free(yyvsp[0].stringval);
        }
break;
case 18:
#line 88 "dmlyacc.yxx"
{
            parsedData->insertInValue((char*)yyvsp[0].stringval);
            free(yyvsp[0].stringval);
        }
break;
case 19:
#line 95 "dmlyacc.yxx"
{
            parsedData->setStmtType(DeleteStatement);
            parsedData->setTableName(yyvsp[-2].stringval); 
            free(yyvsp[-2].stringval);
        }
break;
case 20:
#line 103 "dmlyacc.yxx"
{
            parsedData->setStmtType(UpdateStatement);
            parsedData->setTableName(yyvsp[-4].stringval); 
            free( yyvsp[-4].stringval );
        }
break;
case 26:
#line 121 "dmlyacc.yxx"
{ 
            parsedData->insertUpdateValue( (char*) yyvsp[-2].stringval, (char*) yyvsp[0].stringval);
            free( yyvsp[-2].stringval ); free(yyvsp[-1].stringval);free( yyvsp[0].stringval ); 
        }
break;
case 29:
#line 132 "dmlyacc.yxx"
{
            Predicate *pred;
            pred = parsedData->insertPredicate((Predicate*) yyvsp[-2].predicate, OpAnd, (Predicate*) yyvsp[0].predicate);
            parsedData->setCondition((Predicate*)pred);
            yyval.predicate= pred;

        }
break;
case 30:
#line 140 "dmlyacc.yxx"
{
            Predicate *pred;
            pred = parsedData->insertPredicate((Predicate*) yyvsp[-2].predicate, OpOr, (Predicate*) yyvsp[0].predicate);
            parsedData->setCondition((Predicate*)pred);
            yyval.predicate= pred;
        }
break;
case 31:
#line 147 "dmlyacc.yxx"
{
            Predicate *pred;
            pred = parsedData->insertPredicate((Predicate*) yyvsp[0].predicate, OpNot, NULL);
            parsedData->setCondition((Predicate*)pred);
            yyval.predicate= pred;
        }
break;
case 32:
#line 153 "dmlyacc.yxx"
{ }
break;
case 33:
#line 155 "dmlyacc.yxx"
{
            parsedData->setCondition((Predicate*)yyvsp[0].predicate);
            /*((Predicate*)$1)->print();*/
            yyval.predicate=yyvsp[0].predicate;
        }
break;
case 34:
#line 162 "dmlyacc.yxx"
{
            ComparisionOp  op = AllDataType::getComparisionOperator((char*)yyvsp[-1].stringval);
            Predicate *pred;
            void **ptr = parsedData->insertCondValueAndGetPtr((char*)yyvsp[-2].stringval, (char*)yyvsp[0].stringval);
            pred = parsedData->insertPredicate((char*) yyvsp[-2].stringval, op, ptr);
            free( yyvsp[-2].stringval ); free(yyvsp[-1].stringval); free( yyvsp[0].stringval ); 
            yyval.predicate=pred;
        }
break;
case 35:
#line 171 "dmlyacc.yxx"
{
            ComparisionOp  op = AllDataType::getComparisionOperator((char*)yyvsp[-1].stringval);
            Predicate *pred;
            pred = parsedData->insertPredicate((char*) yyvsp[-2].stringval, op, (char*) yyvsp[0].stringval);
            free( yyvsp[-2].stringval ); free(yyvsp[-1].stringval); free( yyvsp[0].stringval );
            yyval.predicate=pred;
        }
break;
case 36:
#line 180 "dmlyacc.yxx"
{
            void **ptr1 = parsedData->insertCondValueAndGetPtr((char*)yyvsp[-5].stringval, (char*)yyvsp[-2].stringval);
            void **ptr2 = parsedData->insertCondValueAndGetPtr((char*)yyvsp[-5].stringval, (char*)yyvsp[0].stringval);
            Predicate *pred1, *pred2, *pred3, *finalPred;
            pred1 = parsedData->insertPredicate((char*) yyvsp[-5].stringval, OpGreaterThanEquals, ptr1);
            pred2 = parsedData->insertPredicate((char*) yyvsp[-5].stringval, OpLessThanEquals, ptr2);
            finalPred = parsedData->insertPredicate(pred1, OpAnd, pred2);
            if( yyvsp[-4].stringval == (char*) 1 )
                finalPred = parsedData->insertPredicate(finalPred, OpNot, NULL);
            free( yyvsp[-5].stringval );  free( yyvsp[-2].stringval );  free( yyvsp[0].stringval );
            yyval.predicate= finalPred;
        }
break;
case 37:
#line 193 "dmlyacc.yxx"
{
            ListIterator valIter = parsedData->getInValueList().getIterator();
            FieldValue *value1, *value2;
            Predicate *pred1, *pred2, *finalPred;
            void **ptr1, **ptr2;
            if (valIter.hasElement()) {
               value1 = (FieldValue*) valIter.nextElement();
               ptr1 = parsedData->insertCondValueAndGetPtr((char*)yyvsp[-5].stringval, value1->parsedString);
               pred1 = parsedData->insertPredicate((char*) yyvsp[-5].stringval, OpEquals, ptr1);
               finalPred=pred1;
            }
            while (valIter.hasElement()) {
               value2 = (FieldValue*) valIter.nextElement();
               ptr2 = parsedData->insertCondValueAndGetPtr((char*)yyvsp[-5].stringval, value2->parsedString);
               pred2 = parsedData->insertPredicate((char*) yyvsp[-5].stringval, OpEquals, ptr2);
               finalPred = parsedData->insertPredicate(pred1, OpOr, pred2);
               pred1= finalPred;     
            }
            if( yyvsp[-4].stringval == (char*)1)
                finalPred = parsedData->insertPredicate(finalPred, OpNot, NULL);

            free( yyvsp[-5].stringval );  
            yyval.predicate= finalPred;
        }
break;
case 38:
#line 219 "dmlyacc.yxx"
{ yyval.stringval=(char*) 1;
        }
break;
case 39:
#line 222 "dmlyacc.yxx"
{ yyval.stringval=(char*) 0; }
break;
case 40:
#line 225 "dmlyacc.yxx"
{
            parsedData->insertField((char*)yyvsp[0].stringval);
            free( yyvsp[0].stringval );
        }
break;
case 41:
#line 230 "dmlyacc.yxx"
{ 
            parsedData->insertField((char*)yyvsp[0].stringval);
            free( yyvsp[0].stringval );
        }
break;
case 42:
#line 235 "dmlyacc.yxx"
{ yyval.stringval = yyvsp[0].stringval; }
break;
case 43:
#line 237 "dmlyacc.yxx"
{ yyval.stringval = yyvsp[0].stringval; }
break;
case 44:
#line 238 "dmlyacc.yxx"
{ yyval.stringval = yyvsp[0].stringval; }
break;
case 45:
#line 239 "dmlyacc.yxx"
{ yyval.stringval = yyvsp[0].stringval; }
break;
case 46:
#line 240 "dmlyacc.yxx"
{ yyval.stringval = yyvsp[0].stringval; }
break;
case 47:
#line 241 "dmlyacc.yxx"
{ yyval.stringval = yyvsp[0].stringval; }
break;
case 48:
#line 242 "dmlyacc.yxx"
{ yyval.stringval = (char*) 0; }
break;
case 49:
#line 246 "dmlyacc.yxx"
{
            parsedData->setStmtType(CreateTableStatement);
            parsedData->setTableName(yyvsp[-4].stringval); 
            free(yyvsp[-4].stringval);
        }
break;
case 50:
#line 252 "dmlyacc.yxx"
{
            parsedData->setStmtType(CreateIndexStatement);
            parsedData->setIndexName(yyvsp[-8].stringval); 
            parsedData->setTableName(yyvsp[-6].stringval); 
            free(yyvsp[-8].stringval);
            free(yyvsp[-6].stringval);
        }
break;
case 51:
#line 260 "dmlyacc.yxx"
{
            parsedData->setStmtType(DropTableStatement);
            parsedData->setTableName(yyvsp[0].stringval); 
            free(yyvsp[0].stringval);
        }
break;
case 52:
#line 266 "dmlyacc.yxx"
{
            parsedData->setStmtType(DropIndexStatement);
            parsedData->setIndexName(yyvsp[0].stringval); 
            free(yyvsp[0].stringval);
        }
break;
case 54:
#line 274 "dmlyacc.yxx"
{
            parsedData->setIndexType(hashIndex);
        }
break;
case 55:
#line 278 "dmlyacc.yxx"
{
            parsedData->setIndexType(treeIndex);
        }
break;
case 56:
#line 282 "dmlyacc.yxx"
{
            parsedData->setIndexType(hashIndex);
        }
break;
case 58:
#line 288 "dmlyacc.yxx"
{
            parsedData->setUnique(true);
        }
break;
case 59:
#line 292 "dmlyacc.yxx"
{
            parsedData->setUnique(true);
            parsedData->setPrimary(true);
        }
break;
case 60:
#line 297 "dmlyacc.yxx"
{
            parsedData->setUnique(false);
            parsedData->setPrimary(false);
        }
break;
case 64:
#line 310 "dmlyacc.yxx"
{
            parsedData->insertFldDef();
        }
break;
case 67:
#line 320 "dmlyacc.yxx"
{
            parsedData->setFldName(yyvsp[0].stringval);
            free(yyvsp[0].stringval);
        }
break;
case 69:
#line 326 "dmlyacc.yxx"
{
            parsedData->setFldLength(atoi(yyvsp[-1].stringval)+1);
            free(yyvsp[-1].stringval);
        }
break;
case 71:
#line 334 "dmlyacc.yxx"
{
            parsedData->setDefaultValue(yyvsp[0].stringval);
            free(yyvsp[0].stringval);
        }
break;
case 73:
#line 342 "dmlyacc.yxx"
{
            parsedData->setFldNotNull(true);
        }
break;
case 75:
#line 350 "dmlyacc.yxx"
{
            parsedData->setPrimary(true);
        }
break;
case 76:
#line 356 "dmlyacc.yxx"
{
            parsedData->setFldType(typeInt);
        }
break;
case 77:
#line 360 "dmlyacc.yxx"
{
            parsedData->setFldType(typeLong);
        }
break;
case 78:
#line 364 "dmlyacc.yxx"
{
            parsedData->setFldType(typeShort);
        }
break;
case 79:
#line 368 "dmlyacc.yxx"
{
            parsedData->setFldType(typeLongLong);
        }
break;
case 80:
#line 372 "dmlyacc.yxx"
{
            parsedData->setFldType(typeByteInt);
        }
break;
case 81:
#line 376 "dmlyacc.yxx"
{
            parsedData->setFldType(typeFloat);
        }
break;
case 82:
#line 380 "dmlyacc.yxx"
{
            parsedData->setFldType(typeDouble);
        }
break;
case 83:
#line 385 "dmlyacc.yxx"
{
            parsedData->setFldType(typeDate);
        }
break;
case 84:
#line 390 "dmlyacc.yxx"
{
            parsedData->setFldType(typeTime);
        }
break;
case 85:
#line 395 "dmlyacc.yxx"
{
            parsedData->setFldType(typeTimeStamp);
        }
break;
case 86:
#line 400 "dmlyacc.yxx"
{
            parsedData->setFldType(typeString);
            parsedData->setFldLength(2);
        }
break;
#line 929 "dmlyacc.cxx"
    }
    yyssp -= yym;
    yystate = *yyssp;
    yyvsp -= yym;
    yym = yylhs[yyn];
    if (yystate == 0 && yym == 0)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: after reduction, shifting from state 0 to\
 state %d\n", YYPREFIX, YYFINAL);
#endif
        yystate = YYFINAL;
        *++yyssp = YYFINAL;
        *++yyvsp = yyval;
        if (yychar < 0)
        {
            if ((yychar = yylex()) < 0) yychar = 0;
#if YYDEBUG
            if (yydebug)
            {
                yys = 0;
                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
                if (!yys) yys = "illegal-symbol";
                printf("%sdebug: state %d, reading %d (%s)\n",
                        YYPREFIX, YYFINAL, yychar, yys);
            }
#endif
        }
        if (yychar == 0) goto yyaccept;
        goto yyloop;
    }
    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
        yystate = yytable[yyn];
    else
        yystate = yydgoto[yym];
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: after reduction, shifting from state %d \
to state %d\n", YYPREFIX, *yyssp, yystate);
#endif
    if (yyssp >= yyss + yystacksize - 1)
    {
        goto yyoverflow;
    }
    *++yyssp = yystate;
    *++yyvsp = yyval;
    goto yyloop;
yyoverflow:
    yyerror("yacc stack overflow");
yyabort:
    return (1);
yyaccept:
    return (0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

char* lexInput

Definition at line 24 of file SqlStatement.cxx.

Referenced by SqlStatement::prepare().

ParsedData* parsedData

Definition at line 16 of file dmlyacc.cxx.

Referenced by SqlStatement::prepare(), and yyparse().

---