---

SQLtoLDAPQuerier.cpp

                              /* SQLtoLDAPQuerier.cpp */

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

using namespace std;
using namespace LcgInfo;

typedef vector<vector<string> >::iterator matrStrIt;
typedef vector<string>::iterator vecStrIt;
typedef string::size_type strPos;

/*****************   EXTERN SYMBOLS FOR GENERIC CLASS  ****************/
extern "C" {
   Querier* SQLtoLDAPQuerier_create(){
      return new SQLtoLDAPQuerier();
   }
}

extern "C" {
   void SQLtoLDAPQuerier_destroy(Querier *p){
      delete p;
   }
}

/******************  METHODS FOR CLASS SQLtoLDAPQuerier  ********************/

SQLtoLDAPQuerier::SQLtoLDAPQuerier()
   :mConf(0),mTranslator(0),mLdap(0){
}

SQLtoLDAPQuerier::~SQLtoLDAPQuerier(){
   delete mConf;
   mConf=0;
}

void SQLtoLDAPQuerier::setConfig(LcgConfigBuffer::ConfigBuffer & pConf){
   mConf=&pConf;
   mLdap=new InfoFromLDAP();
   mLdap->setConfig(pConf);
   mMap=new LcgConfigBuffer::ConfigBuffer();
   //It may throw a ConfigBufferException if no attribute found, or 
   //a QueryTranslationException if the mapping file is not proper
   try{
      string mappingFile=mConf->get_attribute_value("SCHEMA_MAPPING_FILE");
      mMap->populate_from_config(mappingFile);
   }catch(LcgConfigBuffer::CBException& e){
       string msg="No valid mapping file. Aborting.";
       msg += "\nUnderlying CBException message: " + e.what() + " +line: ";
       msg += int2str(e.get_line()) + " +file: " + e.get_file();
       throw QueryTranslationException(msg,__FILE__,__LINE__);
    }
   mTranslator=new SQLtoLDAPQueryTranslator(*mMap);
}

vector<vector<string> > SQLtoLDAPQuerier::query(string const & pCanonical){
 vector<vector<string> > resultsBuffer;
 try{
   string input=pCanonical;
   vector<string> translation=mTranslator->translateQuery(input);

   vector<strPos> subqueries;   //index of rows which contain past subqueries results
   vector<strPos> priorQueries; //numbers of prior subqueries that have to be substituted
   vector<strPos> cols;  //column indeces where we are operating

   strPos pos; //where
   vector<strPos> posList; //size(i)-posList(i) = pos where the #n# have to be substituted
   bool nplicate=false; //for subqueries that that need n-plicate (all but first one)
   bool replace=false;  //for subqueries in which there was a #n# substitution

   // Main loop on the queries passed (last is the results list)
   for(vecStrIt orgQry=translation.begin(); orgQry!=(translation.end()-1); orgQry++){
      if(orgQry!=translation.begin()) nplicate=true;
      else nplicate=false;
      replace=false;
      priorQueries.clear();
      posList.clear();
      cols.clear();

//debug
//         cout << "Original: "+ *orgQry << endl;
//         cout << "--------------------------" << endl;
//end debug

      // First localize in this query the "#n#" marks of previous queries
      pos=(*orgQry).find('#',0);
      while (pos != string::npos){
         int count=0; 
         bool substitute=true;
         for(int i=pos-1; (*orgQry).at(i)=='\\'; i--, count++); //count escape chars
         if(count>0){
            (*orgQry).erase(pos-count/2,count/2); //delete half of the "\"
            pos-=count/2;                    // adjust index (elements were eliminated)
            if(count%2!=0) substitute=false; 
         }
         if(substitute){                             // the "#" was not escaped, substitute it 
            replace=true;
            nplicate=true;
            strPos queryNumber=str2int(string(1,(*orgQry).at(pos+1)));
            (*orgQry).erase(pos,3);   //remove 1st and 2nd "#" and the query number
            if(subqueries.size()<=queryNumber){
                  string msg="Trying to substitute a query whose results are not present";
                  msg+="\nQuery number: " + int2str(queryNumber);
                  throw QueryTranslationException(msg,__FILE__,__LINE__);
            }
            priorQueries.push_back(queryNumber);
            posList.push_back(pos);
         }
         else (*orgQry).erase(pos-1,1);   //the "#" was escaped, just delete 1 more "\"

         pos = (*orgQry).find("#", pos+1);   // go for next one 
      }//end of while(localize #n#)

      //now, make the real substitutions and ldap calls
      vector<string> theQueries;
      vector<string> auxQueries;
      string toQuery;
      strPos maxsub;

      if(replace){
         //Recalculate the list of #n# positions, so that it counts from the end 
         for(vector<strPos>::iterator i=posList.begin(); i!=posList.end(); i++){
            (*i) = (*orgQry).size()-(*i);
         }      
         //put the biggest subquery (and posList) number last
         if(priorQueries.size()>0) maxsub=priorQueries.back();
         for(strPos priorIndx=0; priorIndx<priorQueries.size(); priorIndx++){
            strPos auxPrev=priorQueries.at(priorIndx);
            if(auxPrev>maxsub) {
               maxsub=auxPrev;
               priorQueries.erase(priorQueries.begin()+priorIndx); 
               priorQueries.push_back(maxsub);
               posList.push_back(posList.at(priorIndx));
               posList.erase(posList.begin()+priorIndx);
            }
         }
         //list of significant previous values
         vector<string> prior=resultsBuffer[subqueries[priorQueries.back()]];
      
         //loop on each diff column of values of prior queries (taking last one as reference)
         for(strPos colNum=0; colNum<prior.size() ; colNum++){ 
            if(colNum>0) {if(prior.at(colNum)==prior.at(colNum-1)) continue;}
            toQuery=*orgQry;
            //loop on all prior queries
            for(strPos priorIndx=0; priorIndx<priorQueries.size(); priorIndx++){  
               prior=resultsBuffer[subqueries[priorQueries[priorIndx]]];
               toQuery.insert(toQuery.size()-posList[priorIndx], prior[colNum]);  //substitute
            }//end of for(prior queries)
            cols.push_back(colNum);
            theQueries.push_back(toQuery); //store
         }//end of for(colNum)
      }//end of if(replace)
      else{  
         theQueries.push_back(*orgQry);  //no replace => just add the query to the list as it is 
      }
     
      //call ldap with col and query number of the last of the subqueries used
      strPos qryIndx=0;
      strPos offset=0;//takes into account that if several values are got, the column number increases
      for(vecStrIt currQry=theQueries.begin(); currQry!=theQueries.end(); currQry++, qryIndx++){
         string filter;   
         vector<string> attribs;
         vector<vector<string> > partialResults;
         strPos differentValues=1; //how many different values we have retrieved in last ldap query

         // Separate filter and attributes
         pos=(*currQry).find_last_of(')',(*currQry).size()-1); //where filter ends
         filter=(*currQry).substr(0,pos+1);  //substring with the filter
         tokenizeStr((*currQry).substr(pos+1),attribs);  //tokenize substring with the attributes
      
         // Perform the LDAP search and store the results
//debug
//cout << "Filter: " << filter << endl;
//cout << "Attribs: ";
//for (string::size_type i=0; i < attribs.size(); i++){
//   cout << attribs.at(i);
//}
//cout << endl;
//cout << "Asking: "+ *currQry << endl;
//end debug
         partialResults.clear();
         try{
            partialResults=mLdap->query(filter,attribs);//can return several values, for several attr
         }catch(LcgConfigBuffer::CBException e){
             string msg="Error while querying the ldap interface. Aborting.";
             msg += "\nUnderlying CBException message: " + e.what() + " +line: ";
             msg += int2str(e.get_line()) + " +file: " + e.get_file();
             throw LcgInfoException(msg,__FILE__,__LINE__);
          }
         differentValues=partialResults[0].size();

         //This is not nice, but if keys were asked, we have to remove the leading "xxx=" part
         string::size_type which=0;
         for(vecStrIt attr=attribs.begin(); attr!=attribs.end(); attr++, which++){
            if(((*attr)=="GlueForeignKey")||(*attr)=="GlueChunkKey"){
               for(vecStrIt value=partialResults[which].begin();
                            value!=partialResults[which].end(); value++){
                  string::size_type auxPos=(*value).find_last_of('=',(*value).size()-1);
                  if(auxPos!=string::npos)  (*value)=(*value).substr(auxPos+1);
               }
            }
         }
         
//debug
//cout << "Getting: ";
// for(matrStrIt r=partialResults.begin(); r!=partialResults.end(); r++){
//   cout << "\n              ";
//   for(vecStrIt k=(*r).begin(); k!=(*r).end(); k++)
//      cout << *k << " ";
//}
//cout << "\n\n";
//end of debug

         //n-plicate the resultsBuffer
         if(nplicate){
            strPos limit, ini;
            vector<string> prior;
            if(replace){
               ini=cols.at(qryIndx)+offset;
               limit=ini+1;
            }           
            else{
               limit=differentValues;
               ini=0;
            }
            //loop on the different values of the reference column
            for(strPos i=ini; i<limit; i++){ 
               strPos baseCol;
               if(replace){
                  baseCol=i;
                  prior=resultsBuffer[subqueries.at(maxsub)];
               }
               else{
                  prior=resultsBuffer[subqueries.back()];
                  baseCol=differentValues * i;
               }
               //loop on the different values of the reference column
               for(strPos colNum=baseCol; colNum<prior.size() && prior.at(colNum)==prior.at(baseCol); colNum++){
                  //loop on the different rows of the buffer
                  for(matrStrIt bufRow=resultsBuffer.begin();bufRow!=resultsBuffer.end();bufRow++){
                     if((*bufRow).size()>colNum){
                        //repeat each column as many times as diff values were got on last ldap call
                        for(strPos j=0; j<differentValues-1; j++){
                           (*bufRow).insert(((*bufRow).begin())+colNum, (*bufRow).at(colNum));
                        }
                     }
                  }
               }

            }//end of for(baseCol)
         }//end if(nplicate)

         //Add the new results to the buffer
         if(replace && (cols.at(qryIndx)!=0)){
            for(matrStrIt toStore=partialResults.begin(); toStore!=partialResults.end(); toStore++){
               resultsBuffer.back().insert(resultsBuffer.back().end(), (*toStore).begin(), (*toStore).end());
            }            
         }
         else if((!replace) && nplicate){ 
            for(matrStrIt toStore=partialResults.begin(); toStore!=partialResults.end(); toStore++){
               resultsBuffer.push_back(*toStore);
            }            
            for(strPos i=0; i<differentValues-1; i++){
               for(matrStrIt toStore=partialResults.begin(); toStore!=partialResults.end(); toStore++){
                  resultsBuffer.back().insert(resultsBuffer.back().end(),(*toStore).begin(), (*toStore).end());
               }
            }
         }
         else{ //for !replace && !nplicate and for replace when cols..==0
            for(matrStrIt toStore=partialResults.begin(); toStore!=partialResults.end(); toStore++){
               resultsBuffer.push_back(*toStore);
            }
         }

         //Add the position of relevant prior subquery to the index vector
         if ((!replace) || (cols.at(qryIndx)==0))
            subqueries.push_back(resultsBuffer.size()-partialResults.size());

         //Calculate the offset for next iteration
         offset+=differentValues-1;
      }//end of for(currQry)
               
   }//end of queries loop, for(translation)


   //Finally, select which rows of the matrix have to be returned
   vector<vector<string> > finalResults;
   vector<string> listOfResults;
   tokenizeStr(translation.back(), listOfResults, ",");
   for(vecStrIt i=listOfResults.begin(); i!=listOfResults.end(); i++){
      vector<string> numbers;
      tokenizeStr(*i, numbers, "-");
      strPos theLine=str2int(numbers[0]);
      string::size_type aux;
      if(numbers[1]=="1"){         
         if((aux=subqueries.at(theLine))!=string::npos){
            subqueries.at(theLine)=string::npos;
            strPos limit;
            if(subqueries.size()>theLine+1) limit=subqueries.at(theLine+1);
            else limit=resultsBuffer.size();
            for(string::size_type j=aux+1; j<limit; j++){
               finalResults.push_back(resultsBuffer.at(j));
            }
         }
      }
      else{
         aux=subqueries.at(theLine);
         finalResults.push_back(resultsBuffer.at(aux));
      }
      
   }


//debug
//   cout << "Final results: ";
//   for(matrStrIt i=finalResults.begin(); i!=finalResults.end(); i++){
//      cout << "\n              ";
//      for(vecStrIt j=(*i).begin(); j!=(*i).end(); j++)
//         cout << *j << " ";
//   }
//   cout << endl;
//   cout << " ##############################################          ";
//   cout << "\n******************************************************************************\n\n";
//end of debug

   return finalResults;

 }catch(QueryTranslationException &e){
    cerr << e.what() << " +line: " << e.get_line() << " +file: " << e.get_file() << endl;;
    return resultsBuffer;
  }

}//end of query()

---