/afs/cs.wisc.edu/u/n/w/nwilliam/private/workspace/Quut/src/parser/SqlInterp.cpp

//
// Author: Jignesh M. Patel
//         EECS Department, University of Michigan
// Date:  August-October 2001
//
//


#include <stdio.h>
#include <assert.h>

#include <sstream>
#include <cstdlib>
#include <string>

#include "SqlParser.h"
#include "SqlInterp.h"
#include "catalog.h"
#include "query.h"
#include "updates.h"
#include "utility.h"
#include "exceptions/relation_not_found_exception.h"

#define E_OK      0
#define E_INCOMPATIBLE    -1
#define E_TOOMANYATTRS    -2
#define E_NOLENGTH    -3
#define E_INVINTSIZE    -4
#define E_INVFLOATSIZE    -5
#define E_INVFORMATSTRING -6
#define E_INVSTRLEN   -7
#define E_DUPLICATEATTR   -8
#define E_TOOLONG   -9
#define E_STRINGTOOLONG   -10
#define E_CORRUPTSQL    -11
#define E_LITERALTYPE   -12


#define ERRFP     stderr  // error message go here
#define MAXATTRS    40      // max. number of attrs in a relation



//
// prefab arrays of useful types
//

static REL_ATTR qual_attrs[MAXATTRS + 1];
static ATTR_DESCR attr_descrs[MAXATTRS + 1];
static ATTR_VAL ins_attrs[MAXATTRS + 1];
static char *names[MAXATTRS + 1];

static int mk_attrnames(PxxList *list, char *attrnames[], char *relname);
static int mk_qual_attrs(PxxList *list, REL_ATTR qual_attrs[],
                         char *relname1, char *relname2);
static int mk_attr_descrs(PxxList *list, ATTR_DESCR attr_descrs[]);
static int mk_ins_attrs(PxxPnode *list, ATTR_VAL ins_attrs[]);
static void print_error(const char *errmsg, int errval);
/*
static int parse_format_string(char *format_string, int *type, int *len);
static void *value_of(PxxPnode *n);
static int  type_of(PxxPnode *n);
static int  length_of(PxxPnode *n);
static void echo_query(PxxPnode *n);
static void print_qual(PxxPnode *n);
static void print_attrnames(PxxPnode *n);
static void print_attrdescrs(PxxPnode *n);
static void print_attrvals(PxxPnode *n);
static void print_primattr(PxxPnode *n);
static void print_qualattr(PxxPnode *n);
static void print_op(int op);
static void print_val(NODE *n);
*/

static int nattrs;
static string resultName;

static attrInfo attrList[MAXATTRS];
static attrInfo attr1;
static attrInfo attr2;


extern "C" int isatty(int fd);          // returns 1 if fd is a tty device

//
// Evaluate the parse tree
//

void PxxInterp::eval(PxxPnode *ptree)
{
   // cout << *ptree << endl;
   
   switch(ptree->MyType()) 
   {
   case PxxPnode::Create:
      createTable(ptree);
      break;
   case PxxPnode::Insert:
      insertIntoTable(ptree);
      break;
   case PxxPnode::Drop:
      deleteTable((PxxDrop*)ptree);
      break;
   case PxxPnode::Query:
      processQuery(ptree);
      break;
   case PxxPnode::CreateIndex:
      createIndex((PxxCreateIndex*)ptree);
      break;
   case PxxPnode::DropIndex:
      deleteIndex((PxxDropIndex*)ptree);
      break;
   case PxxPnode::Delete:
      deleteTable((PxxDrop*)ptree);
      break; 
   default:
      assert(!"Invalid node type");
   }
}

//
// quit the system
//
void PxxInterp::quit(void)
{
   Utilities::Quit();
   exit(1);
}

void PxxInterp::createTable(PxxPnode *ptree)
{   
   // make a list of ATTR_DESCRS suitable for sending to Create
   nattrs = mk_attr_descrs(((PxxCreate*)ptree)->AttrList(), attr_descrs);
   if (nattrs < 0) 
   {
      print_error("Corrupt attribute list", E_CORRUPTSQL);
      return;
   }
   
   for(int acnt = 0; acnt < nattrs; acnt++) {
      strcpy(attrList[acnt].relName, ((PxxCreate*)ptree) -> RelName());
      strcpy(attrList[acnt].attrName, attr_descrs[acnt].attrName);
      attrList[acnt].attrType = attr_descrs[acnt].attrType;
      attrList[acnt].attrLen = attr_descrs[acnt].attrLen;
      attrList[acnt].attrValue = NULL;
   }
   
   // make the call to Create
   relCat->createRel(((PxxCreate*)ptree)->RelName(), nattrs, attrList);
   
   return;
}

void PxxInterp::deleteTable(PxxDrop *ptree)
{
   // Make a call to Drop.
   relCat->destroyRel(ptree->RelName());
}

void PxxInterp::createIndex(PxxCreateIndex *ptree)
{
   // Call the catalog create index
   relCat->addIndex(ptree->RelName(), ptree->AttrName());
}

void PxxInterp::deleteIndex(PxxDropIndex *ptree)
{
   relCat->dropIndex(ptree->RelName(), ptree->AttrName());
}

void PxxInterp::insertIntoTable(PxxPnode *ptree)
{
   if(((PxxInsert*)ptree)->ValList() != NULL)
   { 
      // make attribute and value list to be passed to Updates::Insert
      nattrs = mk_ins_attrs(ptree, ins_attrs);
      if (nattrs < 0) 
      {
         print_error("Invalid attribute list", E_CORRUPTSQL);
         return;
      }
      
      PxxInsert* pinsert = (PxxInsert*)ptree;
      
      // make the call to Updates::Insert
      int acnt;
      for(acnt = 0; acnt < nattrs; acnt++) 
      {
         strcpy(attrList[acnt].relName, pinsert->RelName());
         
         strcpy(attrList[acnt].attrName, ins_attrs[acnt].attrName);
         attrList[acnt].attrType = (Datatype)ins_attrs[acnt].valType;
         attrList[acnt].attrLen = -1;
         attrList[acnt].attrValue = ins_attrs[acnt].value;
      }
      
      Updates::Insert(pinsert->RelName(),nattrs,attrList);
      
      // for (acnt = 0; acnt < nattrs; acnt++)
      //  delete [] (char*)attrList[acnt].attrValue; // Winter 00
      
      return;
   }   
   else
   {
      /* Doing a load from a file */
      Utilities::Load(((PxxInsert*)ptree)->RelName(), ((PxxInsert*)ptree)->FileName());
   }
}

void PxxInterp::processQuery(PxxPnode *ptree)
{
   PxxQuery* pquery = (PxxQuery*)ptree;
   PxxList* projnames = pquery->Projs();
   PxxList  starList; 
   PxxList* fromnames = pquery->Froms();
   // PxxList* fromlist = fromnames; 
   PxxPredTree* predicates = pquery->Preds();
   PxxPredicate* singlepred = 0;
   PxxLiteral* literal = 0; 
   //unsigned int usingtemp = 0; //This is a flag to let us know when we are reading into a temp
   int numberoftables;  
   int attrCnt;
   
   // First, check to see how many tables we are reading from.
   // If it is more than one, then the query is a join query
   // Check if the table definition exists in the catalog. 
   ListNode* table = fromnames->Init();  
   for(numberoftables = 0; table != NULL; table = table->Next())
   {
      PxxRelName* relname = (PxxRelName*)(table->Data()); 
      RelDesc relDesc;

      relCat->getInfo(relname->RelName(), relDesc);

      // Add attrnames to the starlist.
      AttrDesc* attrDescs;
      int numAttrs;

      attrCat->getRelInfo(relname->RelName(), numAttrs, attrDescs);

      // Add all the attributes of this relations to the starList. 
      for (int j=0; j<numAttrs; j++)
      {
         PxxAttrName *aname = new PxxAttrName(attrDescs[j].attrName, 
                                              attrDescs[j].relName,
                                              true);
         starList.Add(aname);
      }

      delete [] attrDescs;

      numberoftables++;
   } 
   
   // process * ops in the projection list
   if (projnames->Cardinality() == 1 &&  
       ((PxxAttrName*)(projnames->First()->Data()))->Star())
   {
      projnames = &starList; 
   }

   // Check to see if an "INTO" was specified, else just write into a default
   PxxRelName insert_relname = pquery->RelName();
   
   RelDesc relDesc;
   if(insert_relname.RelName() == NULL)
   {
      // If we are using a temp relation then the number of 
      // attributes will just be the number of projected ones 
      //usingtemp = 1;
      resultName = "TMP_BDB";
      unsigned i;
      attrCnt = projnames->Cardinality();
      
      try
      {
        relCat->getInfo(resultName, relDesc);
        std::cerr << "TMP_RES_EXISTS : Database corrupted!" << std::endl;
        return;
      }
      catch(RelationNotFoundException &e)
      {
      }

      // Create the temp result relation
      attrInfo *createAttrInfo = new attrInfo[attrCnt];
           
      ListNode *projdata = projnames->Init();
      PxxAttrName* projattr;
      
      // for each element of the list...
      for(i = 0; projdata != NULL && i < MAXATTRS; ++i, projdata = projdata->Next()) 
      {     
         projattr = (PxxAttrName*)(projdata->Data());
         
         // Step through each projection attribute.
         AttrDesc attrDesc;
         attrCat->getInfo(projattr->RelName(), projattr->AttrName(), attrDesc); 
         
         strcpy(createAttrInfo[i].relName, resultName.c_str());
         
         // Create a unique attribute name
         ostringstream newAttrName;
         newAttrName << projattr->AttrName() << '.' << i << endl;
         strcpy(createAttrInfo[i].attrName, newAttrName.str().c_str());
 
         createAttrInfo[i].attrType = attrDesc.attrType;
         createAttrInfo[i].attrLen = attrDesc.attrLen;
      }
      
      if (i != projnames->Cardinality())
      {
         print_error("Corrupt SELECT clause", E_CORRUPTSQL);
         return;
      }

      // Create the temp relation. 
      relCat->createRel(resultName, attrCnt, createAttrInfo);
      delete [] createAttrInfo;
   } 
   else
   { 
      resultName = insert_relname.RelName();
      relCat->getInfo(resultName, relDesc);
      // if (status != OK && status != RELNOTFOUND)

      AttrDesc* resAttrDesc;
      attrCat->getRelInfo(resultName, attrCnt, resAttrDesc); 

      if (attrCnt != relDesc.attrCnt)
      {
         print_error("Incompatible projection list", E_CORRUPTSQL);
         return; 
      }

      // Type check the projection list and the target relation schema
      ListNode *temp = projnames->Init();
      PxxAttrName *attr;

      int iter;
      AttrDesc attrDesc;
      // for each qualified attribute in the list...
      for(iter = 0; temp != NULL; iter++, temp = temp->Next()) 
      {
         attr = (PxxAttrName*)(temp->Data());
         char* aName = attr->AttrName();
         char* rName = attr->RelName();

         attrCat->getInfo(rName, aName, attrDesc);

         if (resAttrDesc[iter].attrType != attrDesc.attrType || resAttrDesc[iter].attrLen  != attrDesc.attrLen)
         {
             print_error("Corrupt projection list", E_CORRUPTSQL);
             delete [] resAttrDesc;
             return; 
         }
      }

      if (iter != relDesc.attrCnt)
      {
         print_error("Incompatible projection list", E_CORRUPTSQL);
         delete [] resAttrDesc;
         return; 
      }

      delete [] resAttrDesc;
   }
   
   // See if we are doing a join or calling select
   if(numberoftables == 1)
   {
      // Now take care of the projected names and
      // make a list of attribute names suitable for passing to select
      char *rName = 0;
      nattrs = mk_attrnames(projnames, names, rName);
      if (nattrs < 0) 
      {
         print_error("Select Clause", E_CORRUPTSQL);
         return; 
      }
      
      for(int acnt = 0; acnt < nattrs; acnt++) 
      {
         strcpy(attrList[acnt].relName, names[nattrs]);
         strcpy(attrList[acnt].attrName, names[acnt]);
         attrList[acnt].attrType = -1;
         attrList[acnt].attrLen = -1;
         attrList[acnt].attrValue = NULL;
      }
      
      if(predicates != NULL)
      {
         // cout << "Predicate Node Type: " << predicates->MyType() << endl;
         if (predicates->MyType() == PxxPnode::Predicate)
         {
            singlepred = (PxxPredicate*) predicates;
            // cout << *singlepred << endl;
            // At this point single pred is the predicate to evaluate. Assume 
            // that a query never has more than one predicate ... 
            
            strcpy(attr1.relName, (*singlepred)[0].AttrName()->RelName());
            strcpy(attr1.attrName, (*singlepred)[0].AttrName()->AttrName());
            attr1.attrLen = -1; 
            literal = ((*singlepred)[1]).Lit(); 
            attr1.attrType = literal->Type();
            switch(attr1.attrType)
            {
            case PxxAttrType::STRING:
               attr1.attrValue = (void*)(literal->Char());
               break; 
            case PxxAttrType::INTEGER:
               attr1.attrValue = (void*)(literal->Int());
               break; 
            case PxxAttrType::DOUBLE: 
               attr1.attrValue = (void*)(literal->Double());
               break;
            }
         } 
         else
         {
            assert (!"multiple predicates not supported");
         }
         
      }
      
      // make different calls to Operators::Select depending upon whether 
      // there is a predicate or not
      if(predicates == NULL)
      {
         Operators::Select(resultName, nattrs, attrList, NULL, NOTSET, NULL);
      }
      else
      {
         void* filter = 0;
         switch(attr1.attrType)
         { 
         case PxxAttrType::STRING:
            filter = literal->Char();
            break; 
         case PxxAttrType::INTEGER:
            filter = literal->Int();
            break; 
         case PxxAttrType::DOUBLE: 
            filter = literal->Double();
            break; 
         }
         // cerr << "Calling select with a predicate" << endl;
         Operator selectop = singlepred->Oper();
         Operators::Select(resultName, nattrs,
            attrList, &attr1,
            selectop,
            filter);
      }
  }
  
  // JOIN Query: If we are joining then don't actually select, just call join
  else 
  {
     PxxPredicate* singlepred = (PxxPredicate*) predicates;
     PxxAttrName* first_attr = (*singlepred)[0].AttrName();
     PxxAttrName* second_attr = (*singlepred)[1].AttrName();   
     
     // make an attribute list suitable for passing to join
     nattrs = mk_qual_attrs(projnames,
                            qual_attrs,
                            first_attr->RelName(),
                            second_attr->RelName());
     if (nattrs < 0) 
     {
        print_error("Invalid attribute list", E_CORRUPTSQL);
     }
     
     // set up the joined attributes to be passed to Join
     qual_attrs[nattrs].relName = first_attr->RelName();
     qual_attrs[nattrs].attrName = first_attr->AttrName();
     qual_attrs[nattrs + 1].relName = second_attr->RelName(); 
     qual_attrs[nattrs + 1].attrName = second_attr->AttrName();
     
     for(int acnt = 0; acnt < nattrs; acnt++) 
     {
        strcpy(attrList[acnt].relName, qual_attrs[acnt].relName);
        strcpy(attrList[acnt].attrName, qual_attrs[acnt].attrName);
        attrList[acnt].attrType = -1;
        attrList[acnt].attrLen = -1;
        attrList[acnt].attrValue = NULL;
     }
     
     strcpy(attr1.relName, qual_attrs[nattrs].relName);
     strcpy(attr1.attrName, qual_attrs[nattrs].attrName);
     attr1.attrType = -1;
     attr1.attrLen = -1;
     attr1.attrValue = NULL;
     
     strcpy(attr2.relName, qual_attrs[nattrs+1].relName);
     strcpy(attr2.attrName, qual_attrs[nattrs+1].attrName);
     attr2.attrType = -1;
     attr2.attrLen = -1;
     attr2.attrValue = NULL;
          
     // make the call to Operators::Join
     
     Operators::Join(resultName, nattrs, attrList, &attr1, (Operator)(singlepred->Oper()), &attr2);
  }
  
  if (resultName == string( "TMP_BDB"))
  {
     // Print the contents of the result relation and destroy it
     Utilities::Print(resultName);
     
     relCat->destroyRel(resultName);
  }
  
  
  return; 
}


static int mk_attr_descrs(PxxList *list, ATTR_DESCR attr_descrs[])
{
   int i;
   // int type, len;
   ListNode *attrlist = list->Init();
   PxxAttrType *attr;
   // int errval;
   
   // for each element of the list...
   for(i = 0; 
       attrlist != NULL && i < MAXATTRS; 
       ++i, attrlist = attrlist->Next())
   {
      attr = (PxxAttrType*)(attrlist->Data());
      
      // add it to the list
      attr_descrs[i].attrName = attr->AttrName();
      attr_descrs[i].attrType = attr->Type();
      switch(attr->Type()){
         
      case PxxAttrType::STRING:
         attr_descrs[i].attrLen = attr->Param1();
         // cout << "Length is " << attr->Param1() << endl;
         break; 
      case PxxAttrType::INTEGER:
         attr_descrs[i].attrLen = sizeof(int);
         break; 
      case PxxAttrType::DOUBLE: 
         attr_descrs[i].attrLen = sizeof(double);
         break;
      }
   } 
   // if the list is too long, then error
   if (i == MAXATTRS)
      return E_TOOMANYATTRS;
   
   return i;
}

//
// mk_ins_attrs: converts a list of <attribute, value> pairs to an array
// of ATTR_VAL's so it can be sent to Updates::Insert.
//
// Returns:
//  length of the list on success ( >= 0 )
//  error code otherwise ( < 0 )
//

static int mk_ins_attrs(PxxPnode *list, ATTR_VAL ins_attrs[])
{
   int i, type, len;
   PxxInsert* insertlist = (PxxInsert*)list; 
   
   ListNode *attrlist = insertlist->OptList()->Init();
   ListNode *valuelist = insertlist->ValList()->Init(); 
   PxxAttrName* attr;
   PxxLiteral* literal; 
   
   // add the attributes to the list
   for(i = 0; 
   attrlist != NULL && i < MAXATTRS; 
   ++i, attrlist = attrlist->Next(), valuelist = valuelist->Next())
   {
      attr = (PxxAttrName*)(attrlist->Data());
      literal = (PxxLiteral*)(valuelist->Data());    
      
      AttrDesc attrDesc;
      
      attrCat->getInfo(insertlist->RelName(), attr->AttrName(), attrDesc);
      
      // make sure string attributes aren't too long
      type = attrDesc.attrType;
      len = attrDesc.attrLen;
      
      if (type != literal->LiteralType())
      {
         print_error("Value List Corrupt ", E_LITERALTYPE);
         return -1;
      }

      switch(type)
      {
         
      case PxxAttrType::STRING:
         ins_attrs[i].value = (void*)(literal->Char());
         break; 
      case PxxAttrType::INTEGER:
         ins_attrs[i].value = (void*)(literal->Int());
         break; 
      case PxxAttrType::DOUBLE: 
         ins_attrs[i].value = (void*)(literal->Double());
         break;
      }
      
      if (type == PxxAttrType::STRING){
         if(len > MAXSTRINGLEN){ 
            
            return E_STRINGTOOLONG;
         }
      } 
      ins_attrs[i].attrName = attr->AttrName();
      ins_attrs[i].valType = type;
      ins_attrs[i].valLength = len;
   }
   
   if (attrlist) return E_TOOMANYATTRS;
   
   return i;
}

//
// mk_attrnames: converts a list of qualified attributes (<relation,
// attribute> pairs) into an array of char pointers so it can be
// sent to the appropriate Utilities or Operators function.
//
// All of the attributes should come from relation relname.  If relname
// is NULL, then it checks that all attributes come from the same
// relation.
//
// The first element of the array after the last attribute name is
// set to the name of the relation.
// 
// Returns:
//  the length of the list on success ( >= 0 )
//  error code otherwise ( < 0 )
//
// (Thus, the return code is both the number of attributes in the array,
// and the index of the relatin name in the array).
//

static int mk_attrnames(PxxList *list, char *attrnames[], char *relname)
{
   int i;
   ListNode *temp = list->Init();
   PxxAttrName *attr;
   
   // for each qualified attribute in the list...
   for(i = 0; temp != NULL && i < MAXATTRS; ++i, temp = temp->Next()) 
   {
      
      attr = (PxxAttrName*)(temp->Data());
      
      // if relname is NULL, then remember this relname
      if (relname == NULL)
         relname = attr->RelName();
      
      // otherwise, see if the relname matches the remembered relname
      else if (strcmp(relname, attr->RelName()))
         return E_INCOMPATIBLE;
      
      // add attribute name to the list
      attrnames[i] = attr->AttrName();
   }
   
   // if the list is too long then error
   if (i == MAXATTRS)
      return E_TOOMANYATTRS;
   
   // put the relation name in the last position in the array
   attrnames[i] = relname;
   
   return i;
}


//
// mk_qual_attrs: converts a list of qualified attributes (<relation,
// attribute> pairs) into an array of REL_ATTRS so it can be sent to
// Operators::Join.
//
// All of the attributes must come from either relname1 or relname2.
//
// Returns:
//  the lengh of the list on success ( >= 0 )
//  error code otherwise
//

static int mk_qual_attrs(PxxList *list, REL_ATTR qual_attrs[],
                         char *relname1, char *relname2)
{
   int i;
   ListNode *temp = list->Init();
   PxxAttrName* attr;

   // for each element of the list...
   for(i = 0; temp != NULL && i < MAXATTRS; ++i, temp = temp->Next()) 
   {     
      attr = (PxxAttrName*)(temp->Data());

      // if relname != relname 1...
      if (strcmp(attr->RelName(), relname1)) 
      {       
         // and relname != relname 2, then error
         if (strcmp(attr->RelName(), relname2))
            return E_INCOMPATIBLE;
      }
      
      // add it to the list
      qual_attrs[i].relName = attr->RelName();
      qual_attrs[i].attrName = attr->AttrName();
   }
   
   // If the list is too long then error
   if (i == MAXATTRS)
      return E_TOOMANYATTRS;
   
   return i;
}

static void print_error(const char *errmsg, int errval)
{
   if (errmsg != NULL)
      fprintf(stderr, "%s: ", errmsg);
   switch(errval) {
   case E_OK:
      fprintf(ERRFP, "no error\n");
      break;
   case E_INCOMPATIBLE:
      fprintf(ERRFP, "attributes must be from selected relation(s)\n");
      break;
   case E_TOOMANYATTRS:
      fprintf(ERRFP, "too many attributes\n");
      break;
   case E_NOLENGTH:
      fprintf(ERRFP, "length must be specified for STRING attribute\n");
      break;
   case E_INVINTSIZE:
      fprintf(ERRFP, "invalid size for INTEGER attribute (should be %d)\n",
         sizeof(int));
      break;
   case E_INVFLOATSIZE:
      fprintf(ERRFP, "invalid size for FLOAT attribute (should be %d)\n",
         sizeof(float));
      break;
   case E_INVFORMATSTRING:
      fprintf(ERRFP, "invalid format string\n");
      break;
   case E_INVSTRLEN:
      fprintf(ERRFP, "invalid length for string attribute\n");
      break;
   case E_DUPLICATEATTR:
      fprintf(ERRFP, "duplicated attribute name\n");
      break;
   case E_TOOLONG:
      fprintf(stderr, "relation name or attribute name too long\n");
      break;
   case E_STRINGTOOLONG:
      fprintf(stderr, "string attribute too long\n");
      break;
   case E_CORRUPTSQL:
      fprintf(stderr, "Invalid SQL Statement\n");
      break;
   case E_LITERALTYPE:
      fprintf(stderr, "Data Type Mistmatch\n");
      break;
   default:
      fprintf(ERRFP, "unrecognized errval: %d\n", errval);
   }
}