---

SQLQueryTranslator.cpp

                              /* SQLQueryTranslator.cpp */

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

using namespace LcgInfo;
using namespace std;

/******************  METHODS FOR CLASS SQLQueryTranslator  ********************/

std::string const SQLQueryTranslator::CHARS_TO_DIVIDE_SQL_WORDS = "\t ,";
std::string const SQLQueryTranslator::CHARS_POSSIBLY_ESCAPED="%";

SQLQueryTranslator::SQLQueryTranslator()
: QueryTranslator(){
}

SQLQueryTranslator::SQLQueryTranslator(string const & pMapFile)
: QueryTranslator(pMapFile){
}

SQLQueryTranslator::SQLQueryTranslator(LcgConfigBuffer::ConfigBuffer & pMap)
: QueryTranslator(pMap){
}

SQLQueryTranslator::~SQLQueryTranslator(){
}

void SQLQueryTranslator::translateSemantic(string const & pQueryCanonical,
      SQLPredicateTree & pPred, vector<string> & pRowsToReturn, set<string> & pNewTableList){

   string orgQuery=pQueryCanonical;
   string currentToken;
   string translated="";
   string::size_type tokenPointer=0;

   vector<string> queryTokens;
   vector<short int> queryIndices;
   vector<string> fromList;  // the old list of tables

   pNewTableList.clear();
   pRowsToReturn.clear();
   pPred.clear();
    
   //First, check that there are no unmatched "\"
   string::size_type pos = orgQuery.find("\\", 0);
   while (pos != string::npos){
      int count=0; 
      for(int i=pos; orgQuery.at(i)=='\\'; i++, count++); //count escape chars
      if(count%2 !=0 ){                   //if the count is not even, check what is being escaped
         if(CHARS_POSSIBLY_ESCAPED.find(orgQuery.at(pos+1),0)==string::npos){
            string msg="Parsing error. Malformed query: unmatched \"\\\".";
            msg+="\nQuery: " + orgQuery;
            throw QueryTranslationException(msg,__FILE__,__LINE__);
         }         
      }         
      pos = orgQuery.find_first_of('\\', pos+count+1);   // go for next one 
   }

   escapeLiterals(orgQuery, CHARS_TO_DIVIDE_SQL_WORDS); //to avoid split of multi-word literals
   tokenizeStrWithIndices(orgQuery, queryTokens, queryIndices, CHARS_TO_DIVIDE_SQL_WORDS);
   currentToken=queryTokens[tokenPointer];

   //SELECT
   if(nocaseCompare(currentToken,"SELECT")){
 
      // store rows to return
      currentToken=queryTokens[++tokenPointer];
      while(!nocaseCompare(currentToken,"FROM")){
         pRowsToReturn.push_back(currentToken);
         currentToken=queryTokens[++tokenPointer];
      }
  
      // store the tables for the FROM list
      currentToken=queryTokens[++tokenPointer];
      while((tokenPointer<queryTokens.size())&&(!nocaseCompare(currentToken,"WHERE"))){
         fromList.push_back(currentToken);
         tokenPointer++;
         if(tokenPointer<queryTokens.size())
            currentToken=queryTokens[tokenPointer];        
      }
   
      if(tokenPointer<queryTokens.size()){
         //the rest conforms the predicate tree
         short int pos=queryIndices[tokenPointer]+currentToken.length();
         string predicate=orgQuery.substr(pos, orgQuery.length()-pos+1);
         unescapeLiterals(predicate, CHARS_TO_DIVIDE_SQL_WORDS); //undo the previous escapes
         pPred.insertPredicate(predicate);
      
         //Now, translate first the predicate tree
         pPred.translate(mTRowT, &fromList, &pNewTableList); 
      }

      //Second, process the rows to be returned      
      for(vector<string>::iterator i=pRowsToReturn.begin(); i!=pRowsToReturn.end(); i++){
         translated.clear();
         currentToken=*i;
         if(currentToken.find('.')==string::npos){  //if there is no table name...
            for(vector<string>::iterator j=fromList.begin(); j!=fromList.end(); j++){
               translated=(*j) + '.' + currentToken;
               try{
                  translated=mTRowT->mapTableRow(translated);
                  break;
               }catch(LcgConfigBuffer::CBException & e){
                   if (e.what()=="+CB EXCEPTION: Attribute does not exist"){ //it's not of that table
                      string::size_type auxPos=translated.find_last_of('.',translated.size()-1);
                      translated.erase(auxPos,1); // just remove the extra "."
                   }
                   else{
                      string msg="The attribute matching is not working properly.\n";
                      msg+= "Underlying LcgConfigBuffer::CBException message: " + e.what();
                      msg+= " +line: " + int2str(e.get_line()) + " +file: " + e.get_file();
                      throw QueryTranslationException(msg,__FILE__,__LINE__);
                   }
               }
            }
         }
         else{ //it contains the table and all
            try{
                translated=mTRowT->mapTableRow(currentToken);
            }catch(LcgConfigBuffer::CBException& e){
                if (e.what()=="+CB EXCEPTION: Attribute does not exist")
                   {} //it's not an attribute of that table, just go on
                else{
                   string msg="The attribute matching is not working properly.\n";
                   msg+= "Underlying LcgConfigBuffer::CBException message: " + e.what() + " +line: ";
                   msg+= int2str(e.get_line()) + " +file: " + e.get_file();
                   throw QueryTranslationException(msg,__FILE__,__LINE__);
                }
             }
         }
         if(translated.empty()) translated=currentToken; //it is not in the mapping, let it be
         pNewTableList.insert(extractTable(translated)); // update new table list

         if(mTRowT->thereIsStructChange()) 
            for(vector<string>::iterator j=mTRowT->getPredicatesBegin();
             j!=mTRowT->getPredicatesEnd(); j++){
                if((*j).at(0)=='+'){
                   string aux=(*j).substr(1);
                   pPred.addAndPredicate(aux, pNewTableList);
                }
                else{
                  string msg="Parsing error. Currently, a predicate rule must start with \"+\"";
                  msg+="\nPredicate: "+ (*j);
                  throw QueryTranslationException(msg,__FILE__,__LINE__);
                }
            }
         pRowsToReturn.erase(i); //remove the old table.row name
         if(i!=pRowsToReturn.end()) pRowsToReturn.insert(i,translated); //now add the translated one
         else pRowsToReturn.push_back(translated);
      }//end of for(rows to return)
   }//end of if("SELECT")

//   //INSERT
//   else if(nocaseCompare(currentToken,"INSERT")){
//   }

   else{
      string msg="Malformed SQL query: no SELECT clause detected.";
      msg+="\nCurrently, only SELECT queries are supported.";
      msg+="\nQuery: " + orgQuery;
      throw QueryTranslationException(msg,__FILE__,__LINE__);
   }
}//end of translateSemantic

   

---