---

SQLPredicateTree.cpp

                              /* SQLPredicateTree.cpp */

/*
 *  Implementation of SQLPredicateTree.h
 */
#include "SQLPredicateTree.h"

using namespace LcgInfo;
using namespace std;
   

/**************************  METHODS FOR CLASS SQLPredicateTree ***************************/

string const SQLPredicateTree::CHARS_TO_ESCAPE_IN_SQL_LITERALS = "\t ><=!()";

/***** Public functions *****/

SQLPredicateTree::SQLPredicateTree()
:PredicateTree(){
}

SQLPredicateTree::~SQLPredicateTree(){
}

void SQLPredicateTree::insertPredicate(string const & pPred){
   int level=0;  //indicates the level of depth of the parenthesis
   short int lastPosLeft, firstPosRight;  //to be returned by processLevel0()
   short int offset=0; //to calculate sub-preds lengths
   string::size_type pos=0, aux; //to look for parenthesis
   string predicate, subPredicate;

   predicate=pPred;  //copy the parameter passed
   escapeLiterals(predicate,CHARS_TO_ESCAPE_IN_SQL_LITERALS); //so special chars are not interpreted
   delSurroundingChars(predicate);  //delete blanks and tabs
   aux=predicate.length(); //end of subPredicate being considered (by now, all of it);

   // find level 0 sub-strings and then process them looking for boolean operators
         pos=predicate.find_first_of("()",0);  //look for the first parenthesis
         while(pos!=string::npos){ 
            if(predicate.at(pos)=='(') {level++; if((level==1)&&(pos>0)) {aux=pos; break;}}
            if(predicate.at(pos)==')') {level--; if((level==0)&&(pos<aux-1)) offset=pos+1;}
            pos=predicate.find_first_of("()",pos+1);  //look for new parenthesis
         }

   // Check if the whole predicate is between parenthesis (given that no level 0 was found)
   while((predicate.at(0)=='(') && (predicate.at(aux-1)==')'))
      predicate=predicate.substr(1,aux-=2);  //remove them
   
   processLevel0(predicate.substr(offset,aux-offset),lastPosLeft,firstPosRight);//process level0

   if(lastPosLeft!=-10){
      setLeft(create());
      aux=lastPosLeft+offset+1; //let's reuse this variable as end of left sub-predicate
      subPredicate=predicate.substr(0,aux);
      left()->insertPredicate(subPredicate);
   }
   if(firstPosRight!=-10){
      setRight(create());      
      aux=firstPosRight+offset; //reuse it again as beggining of right sub-predicate
      subPredicate=predicate.substr(aux,predicate.length()-aux);
      right()->insertPredicate(subPredicate);
   }
}// end of insertPredicate 


/***** Private functions *****/

void SQLPredicateTree::processLevel0(string const & pPred, short int& pLastPosLeft,
                             short int& pFirstPosRight){
   // The first boolean op. in level 0 (or 1 if all is in between parentheses) is root
   // If none is found, then look for a comparison operator as root node
   // Otherwise, it must be a leaf node

  vector<string> tokens;
  vector<short int> indices;

  vector<string>::iterator i;
  vector<short int>::iterator j; //for loops
   
  tokenizeStrWithIndices(pPred, tokens, indices); //tokenize the predicate

  //first, look for booleans
  for(i=tokens.begin(), j=indices.begin(); i!=tokens.end(); i++, j++)
     if(isBooleanOp(*i)){
        setType(BOOLEAN);
        setValue(*i);
        if(nocaseCompare(*i,"NOT"))
           pLastPosLeft=-10;  // with "NOT", there is no left child
        else
           pLastPosLeft=(*j)-1; //before the beggining of current token
        pFirstPosRight=(*j)+(*i).length();  //beginning of next token

        if(pFirstPosRight > (indices.back() + (int) tokens.back().size())){
           string msg="Parsing error. Missing expression after NOT operator.";
           msg+="\nPartial predicate: "+pPred;
           throw QueryTranslationException(msg,__FILE__,__LINE__);
        }
        return;
     }
        
  //if no boolean was found, look for the first comparison operator
  string::size_type pointer;  
  pointer=pPred.find_first_of("=><");
  if(pointer!=string::npos){
    setType(COMPARISON);
    if(pointer>0) pLastPosLeft=pointer-1;
    else{
       string msg="Parsing error. Missing expression before comparison operator.";
       msg+="\nPartial predicate: "+pPred;
       throw QueryTranslationException(msg,__FILE__,__LINE__);
    }

    // Now see if the operator is composed of one or two chars
    if(pPred.find_first_not_of("=>",pointer+1)==pointer+1){  //true for one char operator
       setValue(pPred.substr(pointer,1));
       if((pointer+1)<pPred.length()) pFirstPosRight=pointer+1;
       else{
          string msg="Parsing error. Missing expression after comparison operator.";
          msg+="\nPartial predicate: "+pPred;
          throw QueryTranslationException(msg,__FILE__,__LINE__);
       }
    }
    else{ //two char operator
       setValue(pPred.substr(pointer,2));
       if((pointer+2)<pPred.length())  pFirstPosRight=pointer+2;
       else{
          string msg="Parsing error. Missing expression after comparison operator.";
          msg+="\nPartial predicate: "+pPred;
          throw QueryTranslationException(msg,__FILE__,__LINE__);
       }
    }
    return;      
  }

  //still one more comparison operator: "LIKE"
  for(i=tokens.begin(), j=indices.begin(); i!=tokens.end(); i++, j++)
     if(nocaseCompare(*i,"LIKE")){
        setType(COMPARISON);
        setValue(*i);
        if(j!=indices.begin()) pLastPosLeft=*(j)-1; //before the beggining of current token
        if((j+1)!=indices.end()) pFirstPosRight=*(j)+(*i).length();  //beginning of next token
        return;
     }

  //if there is no operator, then it is a leaf node
  setType(LEAF);             //set type and value 
  unescapeLiterals(tokens.at(0),CHARS_TO_ESCAPE_IN_SQL_LITERALS); //undo previous escapes 
  setValue(tokens.at(0));
  pLastPosLeft=-10;
  pFirstPosRight=-10;
    
}//end of processLevel0

string SQLPredicateTree::getCHARS_TO_TOKENIZE_PREDICATES(){
   return "\t ><=!()";
}

---