---

SQLtoLDAPPredicateTree.cpp

                              /* SQLtoLDAPPredicateTree.cpp */

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

using namespace LcgInfo;
using namespace std;
   

/*********************  METHODS FOR CLASS SQLtoLDAPPredicateTree **********************/

SQLtoLDAPPredicateTree::SQLtoLDAPPredicateTree()
:SQLPredicateTree(){
}

SQLtoLDAPPredicateTree::~SQLtoLDAPPredicateTree(){
}

SQLtoLDAPPredicateTree* SQLtoLDAPPredicateTree::create(){
   return new SQLtoLDAPPredicateTree();
}

SQLtoLDAPPredicateTree * SQLtoLDAPPredicateTree::clone(){
   SQLtoLDAPPredicateTree * aux=create();

   //copy this node values
   aux->setValue(value());
   aux->setType(type());
   aux->setDepth(depth());

  //clone children
  if(left()!=NULL)
      aux->setLeft(left()->clone());
   else
      aux->setLeft(NULL);
   if(right()!=NULL)
      aux->setRight(right()->clone());
   else
      aux->setRight(NULL);    

   return aux;
}

string SQLtoLDAPPredicateTree::evaluate(vector<string> & pQueries){
   if(depth()==0) pQueries.clear();
   string aux; 
   switch (this->type()){
      case COMPARISON:
         //switch depending on the comparison...
         if((this->value()=="=") || (this->value()==">=") || (this->value()=="<=")){
            aux='(' + left()->evaluate(pQueries) ;
            aux+= this->value() + right()->evaluate(pQueries) + ')';
         }
         if(this->value()==">"){  // ">" is the same as "NOT <="
            aux="(! (" + left()->evaluate(pQueries) + "<=";
            aux+= right()->evaluate(pQueries) + "))";
         }
         if(this->value()=="<"){
            aux="(! (" + left()->evaluate(pQueries) + ">=";
            aux+= right()->evaluate(pQueries) + "))";
         }
         if(this->value()=="<>"){ // and "<>" is the same as "NOT ="
            aux="(! (" + left()->evaluate(pQueries) + "=";
            aux+= right()->evaluate(pQueries) + "))";
         }
         if(nocaseCompare(this->value(),"LIKE")) {
            //Substitute SQL's % wildcard for LDAP's * (the _ has no equivalent)
            string temp=right()->evaluate(pQueries);
            string::size_type pos = temp.find_first_of("%", 0);
            while (pos != string::npos){
               int count=0; 
               for(int i=pos-1; temp.at(i)=='\\'; i--, count++); //count escape chars
               if(count>0){
                  temp.erase(pos-count/2,count/2); //delete half of the "\"
                  pos-=count/2;                    // adjust index (elements were eliminated)
                  if(count%2==0)                   // the "%" was not escaped, substitute it 
                     temp.replace(pos,1,"*");
                  else                             //the "%" was escaped, just delete 1 more "\"
                     temp.erase(pos-1,1);
               }
               else temp.replace(pos,1,"*");            // no "\", substitute the "%"
               
               pos = temp.find_first_of("%", pos+1);   // go for next one 
            }
            aux='(' + left()->evaluate(pQueries) + " = " + temp + ')'; 
         }
         break;

      case BOOLEAN: 
         if (nocaseCompare(this->value(),"NOT")){
            if(right()->relatesTables())              
               aux="(! " + substituteSubquery(right(), 0, pQueries) + ')'; //modify only child(sense?)
            else
               aux="(! " + right()->evaluate(pQueries) + ')';
         }

         else if (nocaseCompare(this->value(),"AND")){
           //first check for NULL children (usually coming from identities)
           if((right()==0)&&(left()==0)) return "";
           if(right()==0) aux = left()->evaluate(pQueries);
           else if(left()==0){ aux = right()->evaluate(pQueries);}
            
            //check if any of the children is a relation among keys
           else if((left()->relatesTables())&&(!(right()->relatesTables()))){  //modify left
               aux=substituteSubquery(left(), right(), pQueries);
            }
            else if((right()->relatesTables())&&(!(left()->relatesTables()))){ //modify right
               aux=substituteSubquery(right(), left(), pQueries);
            }
            else if((right()->relatesTables())&&(left()->relatesTables())){    //modify both (sense?)
               aux = "(& " + substituteSubquery(left(), 0, pQueries);
               aux += substituteSubquery(right(), 0, pQueries) + ')';
            }
            else{                                                          //modify none
               aux="(& " + left()->evaluate(pQueries);
               aux+=right()->evaluate(pQueries) + ')';
            }
         }//end if(AND)

         else if (nocaseCompare(this->value(),"OR")){
           //first check for NULL children (usually coming from identities)
           if((right()==0) || (left()==0)) return "";
 
            aux="(| " + left()->evaluate(pQueries) + right()->evaluate(pQueries) + ')';
         }
         break;

      case LEAF:
            //first, remove the determinant objectclass (table) name, that is before the last "."
            string::size_type pos=0;
            if((!isLiteral(value())) && (!isNumber(value()))){
               pos=value().find_last_of('.', value().size()-1);
               if(pos!=string::npos)
                  aux=value().substr(pos+1);
               else 
                  aux=value();
            }

            //Now, remove the "'" chars
            if(isLiteral(value()))
               aux=value().substr(1,value().size()-2);         

            //finally, need to escape the "#" chars
            if(depth()!=-1){
               string::size_type pos=aux.find('#',0); 
               while (pos != string::npos){
                  aux.insert(pos,"\\");              
                  pos=aux.find('#',pos+2);
               }
            }
   }//end of switch(type)

   if(aux.empty()){
      string msg="Parsing error. The node could not be evaluated.";
      msg += "\nThis node's value: " + value() + "\nThis node's depth: " + int2str(depth());
      throw QueryTranslationException(msg,__FILE__,__LINE__);
   }
   
   return aux;
};//end of recurEval()


string SQLtoLDAPPredicateTree::substituteSubquery(PredicateTree * pNode,
                     PredicateTree * pTheOther, vector<string> & pQueries){

   string temp, result, subquery;
   string tempType;
   int tempDepth;

   if(pTheOther!=0){
      subquery=pTheOther->evaluate(pQueries) + " ";
//      subquery+= pNode->right()->evaluate(pQueries);
      subquery+= pNode->right()->value();
   }
   else 
      subquery=pNode->right()->evaluate(pQueries);
   pQueries.push_back(subquery);

   temp=pNode->right()->value();  // store what there was on the right child
   tempDepth=pNode->right()->depth();
   // change it by the ldap query identifier 
   pNode->right()->setValue("\'#" + int2str(pQueries.size()-1) + "#\'");
   pNode->right()->setDepth(-1); //dirty trick to make evaluate() not to escape the previous #s
   result=pNode->evaluate(pQueries);
   pNode->right()->setValue(temp);     // restore the node's original value and depth
   pNode->right()->setDepth(tempDepth);

   return result;
}

---