src/sql/MetadataStatement.cxx

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Prabakaran Thirumalai   *
   3  *   praba_tuty@yahoo.com   *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15   ***************************************************************************/
  16 #include <os.h>
  17 #include <Statement.h>
  18 #include <TableImpl.h>
  19 #include <OrderTableImpl.h>
  20
  21
  22 ListIterator MetadataStatement::getExportKeyIterator()
  23 {
  24     List datalist;
  25     TableImpl *tbl = (TableImpl*)table;
  26     if(!tbl->isPkTbl)
  27     {
  28        return datalist.getIterator();
  29     }else
  30     {
  31        TableImpl *fkTbl =NULL;
  32        ListIterator tblIter =tbl->tblFkList.getIterator();
  33        tblIter.reset();
  34        void *tPkptr =NULL;
  35        void *tFkptr = NULL;
  36        void *chunkPk = NULL;
  37        void *vcchunkPk = NULL;
  38        char *pkFldName = NULL;
  39        char *fkFldName = NULL;
  40        ForeignKeyMetadata *fkMeta= NULL;
  41        while (tblIter.hasElement()){
  42            fkTbl = (TableImpl *) tblIter.nextElement();
  43            FieldNameList pkFieldList,fkFieldList;
  44            CatalogTableTABLE cTable(tbl->sysDB_);
  45            cTable.getChunkAndTblPtr(tbl->getName(), chunkPk, tPkptr, vcchunkPk);
  46            cTable.getChunkAndTblPtr(fkTbl->getName(), chunkPk, tFkptr, vcchunkPk);
  47            CatalogTableFK cFk(tbl->sysDB_);
  48            cFk.getPkFkFieldInfo(tPkptr,tFkptr,pkFieldList,fkFieldList);
  49            pkFieldList.resetIter();
  50            fkFieldList.resetIter();
  51            int count = 0;
  52            while((fkFldName = fkFieldList.nextFieldName())!= NULL)
  53            {
  54                count++;
  55                fkMeta = new ForeignKeyMetadata();
  56                pkFldName = pkFieldList.nextFieldName();
  57                strcpy(fkMeta->pkTableName,tbl->getName());
  58                strcpy(fkMeta->pkColName,pkFldName);
  59                strcpy(fkMeta->fkTableName,fkTbl->getName());
  60                strcpy(fkMeta->fkColName,fkFldName);
  61                fkMeta->keySeq = count;
  62                fkMeta->updateRule = 3;
  63                fkMeta->deleteRule = 3;
  64                datalist.append(fkMeta);
  65            }
  66
  67         }
  68     }
  69     return datalist.getIterator();
  70 }
  71
  72 ListIterator MetadataStatement::getImportKeyIterator()
  73 {
  74     List datalist;
  75     TableImpl *tbl = (TableImpl*)table;
  76     if(!tbl->isFkTbl)
  77     {
  78        return datalist.getIterator();
  79     }else
  80     {
  81        TableImpl *fkTbl =NULL;
  82        ListIterator tblIter = tbl->tblList.getIterator();
  83        tblIter.reset();
  84        void *tPkptr =NULL;
  85        void *tFkptr = NULL;
  86        void *chunkPk = NULL;
  87        void *vcchunkPk = NULL;
  88        char *pkFldName = NULL;
  89        char *fkFldName = NULL;
  90        ForeignKeyMetadata *fkMeta= NULL;
  91        while (tblIter.hasElement()){
  92            fkTbl = (TableImpl *) tblIter.nextElement();
  93            FieldNameList pkFieldList,fkFieldList;
  94            CatalogTableTABLE cTable(tbl->sysDB_);
  95            cTable.getChunkAndTblPtr(tbl->getName(), chunkPk, tPkptr, vcchunkPk);
  96            cTable.getChunkAndTblPtr(fkTbl->getName(), chunkPk, tFkptr, vcchunkPk);
  97            CatalogTableFK cFk(tbl->sysDB_);
  98            cFk.getPkFkFieldInfo(tFkptr,tPkptr,fkFieldList,pkFieldList);
  99            pkFieldList.resetIter();
 100            fkFieldList.resetIter();
 101            int count = 0;
 102            while((pkFldName = pkFieldList.nextFieldName())!= NULL)
 103            {
 104                count++;
 105                fkMeta = new ForeignKeyMetadata();
 106                fkFldName = fkFieldList.nextFieldName();
 107                strcpy(fkMeta->pkTableName,fkTbl->getName());
 108                strcpy(fkMeta->pkColName,fkFldName);
 109                strcpy(fkMeta->fkTableName,tbl->getName());
 110                strcpy(fkMeta->fkColName,pkFldName);
 111                fkMeta->keySeq = count;
 112                fkMeta->updateRule = 3;
 113                fkMeta->deleteRule = 3;
 114                datalist.append(fkMeta);
 115            }
 116
 117         }
 118     }
 119     return datalist.getIterator();
 120 }
 121
 122
 123 MetadataStatement::MetadataStatement()
 124 {
 125     parsedData = NULL;
 126     dbMgr = NULL;
 127     table = NULL;
 128     params = NULL;
 129     paramValues = NULL;
 130     totalParams = 0;
 131     bindFields = NULL;
 132     bindFieldValues = NULL;
 133     totalFields = 0;
 134     plan = Normal;
 135     numRecords = 0;
 136     isPlanFreed=false;
 137     isSecondFetch=false;
 138 }
 139
 140 MetadataStatement::~MetadataStatement()
 141 {
 142     close();
 143     if (table) { table->close(); table = NULL; }
 144     if (totalParams) {
 145         free(params);
 146         params =  NULL;
 147         free(paramValues);
 148         paramValues = NULL;
 149     }
 150     if (totalFields)
 151     {
 152         free(bindFields);
 153         bindFields =  NULL;
 154         free(bindFieldValues);
 155         bindFieldValues = NULL;
 156
 157     }
 158 }
 159 DbRetVal MetadataStatement::getParamFldInfo(int paramNo, FieldInfo *&info)
 160 {
 161     if (paramNo <=0 || paramNo > totalParams) return ErrBadArg;
 162     ConditionValue *cValue = (ConditionValue*) params [paramNo-1];
 163     if (NULL == cValue)
 164     {
 165         printError(ErrSysFatal, "condition value is null. Should never happen");
 166         return ErrSysFatal;
 167     }
 168     table->getFieldNameAlone(cValue->fName,info->fldName);
 169     info->type = cValue->type;
 170     info->length = cValue->length;
 171     info->isNull = cValue->isNullable;
 172     return OK;
 173 }
 174 DbRetVal MetadataStatement::execute(int &rowsAffected)
 175 {
 176     DbRetVal rv = OK;
 177     switch( plan )
 178     {
 179       case GetTables:
 180       {
 181            dataListIter = dbMgr->getAllTableNames().getIterator();
 182            break;
 183       }
 184       case GetColumns:
 185       {
 186             List colList;
 187             List fNameList = table->getFieldNameList();
 188             ListIterator fNameIter = fNameList.getIterator();
 189             for (int i = 0; i < fNameList.size() ; i++)
 190             {
 191                  FieldInfo *fInfo = new FieldInfo();
 192                  Identifier *elem= (Identifier*)fNameIter.nextElement();
 193                  char *fName = elem->name;
 194                  rv = table->getFieldInfo(fName, fInfo);
 195                  if (ErrNotFound == rv || ErrNotExists == rv)
 196                  {
 197                      delete fInfo;
 198                      fNameList.reset();
 199                      printError(ErrSysFatal, "Should never happen.");
 200                      return ErrSysFatal;
 201                  }
 202                  delete elem;
 203                  colList.append(fInfo);
 204              }
 205              fNameIter.reset();
 206              fNameList.reset();
 207              dataListIter = colList.getIterator();
 208            break;
 209       }
 210       case GetIndexes:
 211       {
 212            List colList;
 213            CatalogTableINDEXFIELD cIndexField(((DatabaseManagerImpl *)dbMgr)->sysDb());
 214            dataListIter = cIndexField.getIndexListIterater(table->getName());
 215            break;
 216       }
 217       case GetPriIndex:
 218       {
 219           List colList;
 220           CatalogTableINDEXFIELD cIndexField(((DatabaseManagerImpl *)dbMgr)->sysDb());
 221           dataListIter = cIndexField.getIndexListIterater(table->getName());
 222           break;
 223       }
 224       case GetImportKey:
 225       {
 226           dataListIter = getImportKeyIterator();
 227           break;
 228       }
 229       case GetExportKey:
 230       {
 231           dataListIter = getExportKeyIterator();
 232           break;
 233       }
 234       case GetDataType:
 235       {
 236           dataListIter = getDataTypeInfoIterator();
 237           break;
 238       }
 239       default:
 240           break;
 241     };
 242     return rv;
 243 }
 244
 245 DbRetVal MetadataStatement::openTables()
 246 {
 247 //TODO : need to remove unnecessery code
 248     if (dbMgr == NULL) return ErrNoConnection;
 249     JoinTableImpl *jHdl = NULL;
 250     Table *tHdl = NULL, *prevHdl = NULL;
 251     bool joinInvolved = false;
 252     //check whether all the table exists
 253     ListIterator titer = parsedData->getTableNameList().getIterator();
 254     ListIterator jiter = parsedData->getJoinTypeList().getIterator();
 255     while (titer.hasElement())
 256     {
 257         TableName *t  = (TableName*)titer.nextElement();
 258         parsedData->setTableName(t->tblName);
 259         tHdl = dbMgr->openTable(t->tblName);
 260         if ( NULL == tHdl )
 261         {
 262             printError(ErrNotExists,
 263                        "Unable to open the table:Table not exists");
 264             if (prevHdl) delete prevHdl;
 265             return ErrNotExists;
 266         }
 267         TableImpl *tImpl=  (TableImpl*) tHdl;
 268         if (NULL != prevHdl)
 269         {
 270             joinInvolved = true;
 271             jHdl = new JoinTableImpl();
 272             jHdl->setTable(prevHdl, tHdl);
 273             JoinTypeNode *node = (JoinTypeNode*) jiter.nextElement();
 274             if (node == NULL) {
 275                 printError(ErrSyntaxError,
 276                            "Join Type and number of tables do not match");
 277                 delete jHdl;
 278                 return ErrSyntaxError;
 279             }
 280             jHdl->setJoinType(node->jType);
 281             prevHdl = jHdl;
 282             continue;
 283         }
 284         prevHdl = tHdl;
 285     }
 286
 287     if (joinInvolved) table = jHdl; else table = tHdl;
 288     return OK;
 289 }
 290 DbRetVal MetadataStatement::resolve()
 291 {
 292     DbRetVal rv =OK;
 293     plan = parsedData->getResultSetPlan();
 294     switch(plan)
 295     {
 296         case GetTables:
 297         {
 298             bindFields = (FieldValue**) malloc (5 * sizeof(FieldValue*));
 299             bindFieldValues = (char**) malloc  (5 * sizeof(char*));
 300             for(int i=0;i<5;i++){
 301                 FieldValue *newVal = new FieldValue();
 302                 if(i==0)  strcpy(newVal->fldName,"TABLE_CAT");
 303                 if(i==1)  strcpy(newVal->fldName,"TABLE_SCHEM");
 304                 if(i==2)  strcpy(newVal->fldName,"TABLE_NAME");
 305                 if(i==3)  strcpy(newVal->fldName,"TABLE_TYPE");
 306                 newVal->parsedString = NULL;
 307                 newVal->paramNo = 0;
 308                 newVal->type = typeString;
 309                 newVal->length = 64;
 310                 newVal->value = AllDataType::alloc(newVal->type, 64);
 311                 if(i==0) strcpy((char*)newVal->value,(char*)"CSQL");
 312                 if(i==1) strcpy((char*)newVal->value,(char*)"CSQL");
 313                 if(i==3) strcpy((char*)newVal->value,(char*)"TABLE");
 314                 if(i==4) strcpy((char*)newVal->value,(char*)"TABLE Catalog");
 315                 newVal->isAllocVal=true;
 316                 totalFields =i+1;
 317                 bindFields[i] = newVal;
 318             }
 319             break;
 320         }
 321         case GetColumns:
 322         {
 323             rv = openTables();
 324             if (rv != OK)  break; //return rv;
 325             bindFields = (FieldValue**) malloc (23 * sizeof(FieldValue*));
 326             bindFieldValues = (char**) malloc  (23 * sizeof(char*));
 327             for(int i=0;i<23;i++){
 328                 FieldValue *newVal = new FieldValue();
 329                 switch(i){
 330                     case 0:
 331                         strcpy(newVal->fldName,"TABLE_CAT");
 332                         newVal->type = typeString;
 333                         break;
 334                     case 1:
 335                         newVal->type = typeString;
 336                         strcpy(newVal->fldName,"TABLE_SCHEM");
 337                         break;
 338                     case 2:
 339                         newVal->type = typeString;
 340                         strcpy(newVal->fldName,"TABLE_NAME");
 341                         break;
 342                     case 3:
 343                         newVal->type = typeString;
 344                         strcpy(newVal->fldName,"COLUMN_NAME");
 345                         break;
 346                     case 4:
 347                         newVal->type = typeInt;
 348                         strcpy(newVal->fldName,"DATA_TYPE");
 349                         break;
 350                     case 5:
 351                         newVal->type = typeString;
 352                         strcpy(newVal->fldName,"TYPE_NAME");
 353                         break;
 354                     case 6:
 355                         newVal->type = typeInt;
 356                         strcpy(newVal->fldName,"COLUMN_SIZE");
 357                         break;
 358                     case 7:
 359                         newVal->type = typeInt;
 360                         strcpy(newVal->fldName,"BUFFER_LENGTH");
 361                         break;
 362                     case 8:
 363                         newVal->type = typeShort;
 364                         strcpy(newVal->fldName,"DECIMAL_DIGITS");
 365                         break;
 366                     case 9:
 367                         newVal->type = typeShort;
 368                         strcpy(newVal->fldName,"NUM_PREC_RADIX");
 369                         break;
 370                     case 10:
 371                         newVal->type = typeShort;
 372                         strcpy(newVal->fldName,"NULLABLE");
 373                         break;
 374                     case 11:
 375                         newVal->type = typeString;
 376                         strcpy(newVal->fldName,"REMARKS");
 377                         break;
 378                     case 12:
 379                         newVal->type = typeString;
 380                         strcpy(newVal->fldName,"COLUMN_DEF");
 381                         break;
 382                     case 13:
 383                         newVal->type = typeShort;
 384                         strcpy(newVal->fldName,"SQL_DATA_TYPE");
 385                         break;
 386                     case 14:
 387                         newVal->type = typeInt;
 388                         strcpy(newVal->fldName,"SQL_DATETIME_SUB");
 389                         break;
 390                     case 15:
 391                         newVal->type = typeInt;
 392                         strcpy(newVal->fldName,"CHAR_OCTET_LENGTH");
 393                         break;
 394                     case 16:
 395                         newVal->type = typeInt;
 396                         strcpy(newVal->fldName,"ORDINAL_POSITION");
 397                         break;
 398                     case 17:
 399                         newVal->type = typeString;
 400                         strcpy(newVal->fldName,"IS_NULLABLE");
 401                         break;
 402                     case 18:
 403                         newVal->type = typeString;
 404                         strcpy(newVal->fldName,"SCOPE_CATLOG");
 405                         break;
 406                     case 19:
 407                         newVal->type = typeString;
 408                         strcpy(newVal->fldName,"SCOPE_SCHEMA");
 409                         break;
 410                     case 20:
 411                         newVal->type = typeString;
 412                         strcpy(newVal->fldName,"SCOPE_TABLE");
 413                         break;
 414                     case 21:
 415                         newVal->type = typeShort;
 416                         strcpy(newVal->fldName,"SOURCE_DATA_TYPE");
 417                         break;
 418                     case 22:
 419                         newVal->type = typeString;
 420                         strcpy(newVal->fldName,"IS_AUTOINCREMENT");
 421                         break;
 422                     default:
 423                         newVal->type = typeString;
 424                         break;
 425                 };
 426                 newVal->parsedString = NULL;
 427                 newVal->paramNo = 0;
 428                 newVal->length = AllDataType::size(newVal->type, 64);
 429                 if(i==12)  newVal->length = DEFAULT_VALUE_BUF_LENGTH;
 430                 newVal->value = AllDataType::alloc(newVal->type,newVal->length);
 431                 if(newVal->type == typeInt) (*(int*)newVal->value) = 0;
 432                 if(newVal->type == typeShort) (*(short*)newVal->value) = 0;
 433                 if(newVal->type == typeString) strcpy((char*)newVal->value,(char*)"");
 434                 if(i==0) strcpy((char*)newVal->value,(char*)"CSQL");
 435                 if(i==1) strcpy((char*)newVal->value,(char*)"CSQL");
 436                 if(i==2) strcpy((char*)newVal->value,(char*)table->getName());
 437                 if(i==11) strcpy((char*)newVal->value,(char*)"Columns Catalog");
 438               //  if(i==16) (*(int *)newVal->value) = 0;
 439                 newVal->isAllocVal=true;
 440                 totalFields =i+1;
 441                 bindFields[i] = newVal;
 442             }
 443             break;
 444         }
 445         case GetIndexes:
 446         {
 447             rv = openTables();
 448             if (rv != OK)  break; //return rv;
 449             bindFields = (FieldValue**) malloc (13 * sizeof(FieldValue*));
 450             bindFieldValues = (char**) malloc  (13 * sizeof(char*));
 451             for(int i=0;i<13;i++){
 452                 FieldValue *newVal = new FieldValue();
 453                 switch(i)
 454                 {
 455                     case 0:
 456                         strcpy(newVal->fldName,"TABLE_CAT");
 457                         newVal->type = typeString;
 458                         break;
 459                     case 1:
 460                         newVal->type = typeString;
 461                         strcpy(newVal->fldName,"TABLE_SCHEM");
 462                         break;
 463                     case 2:
 464                         newVal->type = typeString;
 465                         strcpy(newVal->fldName,"TABLE_NAME");
 466                         break;
 467                     case 3:
 468                         newVal->type = typeInt;
 469                         strcpy(newVal->fldName,"NON_UNIQUE");
 470                         break;
 471                     case 4:
 472                         newVal->type = typeString;
 473                         strcpy(newVal->fldName,"INDEX_QUALIFIER");
 474                         break;
 475                     case 5:
 476                         newVal->type = typeString;
 477                         strcpy(newVal->fldName,"INDEX_NAME");
 478                         break;
 479                     case 6:
 480                         newVal->type = typeShort;
 481                         strcpy(newVal->fldName,"TYPE");
 482                         break;
 483                     case 7:
 484                         newVal->type = typeShort;
 485                         strcpy(newVal->fldName,"ORDINAL_POSITION");
 486                         break;
 487                     case 8:
 488                         newVal->type = typeString;
 489                         strcpy(newVal->fldName,"COLUMN_NAME");
 490                         break;
 491                     case 9:
 492                         newVal->type = typeString;
 493                         strcpy(newVal->fldName,"ASC_OR_DESC");
 494                         break;
 495                     case 10:
 496                         newVal->type = typeInt;
 497                         strcpy(newVal->fldName,"CARDINALITY");
 498                         break;
 499                     case 11:
 500                         newVal->type = typeInt;
 501                         strcpy(newVal->fldName,"PAGES");
 502                         break;
 503                     case 12:
 504                         newVal->type = typeString;
 505                         strcpy(newVal->fldName,"FILTER_CONDITION");
 506                         break;
 507                     default:
 508                         newVal->type = typeString;
 509                         break;
 510                 };
 511                 newVal->parsedString = NULL;
 512                 newVal->paramNo = 0;
 513                 newVal->length = AllDataType::size(newVal->type, 64);
 514                 newVal->value = AllDataType::alloc(newVal->type,newVal->length);
 515                 if(newVal->type == typeString) strcpy((char*)newVal->value,(char*)"");
 516                 if(i==0) strcpy((char*)newVal->value,(char*)"CSQL");
 517                 if(i==1) strcpy((char*)newVal->value,(char*)"CSQL");
 518                 newVal->isAllocVal=true;
 519                 totalFields =i+1;
 520                 bindFields[i] = newVal;
 521             }
 522             break;
 523         }
 524         case GetPriIndex:
 525         {
 526             rv = openTables();
 527             if (rv != OK)  break; //return rv;
 528             bindFields = (FieldValue**) malloc (6 * sizeof(FieldValue*));
 529             bindFieldValues = (char**) malloc  (6 * sizeof(char*));
 530             for(int i=0;i<6;i++){
 531                 FieldValue *newVal = new FieldValue();
 532                 switch(i)
 533                 {
 534                     case 0:
 535                         strcpy(newVal->fldName,"TABLE_CAT");
 536                         newVal->type = typeString;
 537                         break;
 538                     case 1:
 539                         newVal->type = typeString;
 540                         strcpy(newVal->fldName,"TABLE_SCHEM");
 541                         break;
 542                     case 2:
 543                         newVal->type = typeString;
 544                         strcpy(newVal->fldName,"TABLE_NAME");
 545                         break;
 546                     case 3:
 547                         newVal->type = typeString;
 548                         strcpy(newVal->fldName,"COLUMN_NAME");
 549                         break;
 550                     case 4:
 551                         newVal->type = typeShort;
 552                         strcpy(newVal->fldName,"KEY_SEQ");
 553                         break;
 554                     case 5:
 555                         newVal->type = typeString;
 556                         strcpy(newVal->fldName,"PK_NAME");
 557                         break;
 558                     default:
 559                         break;
 560                 };
 561                 newVal->parsedString = NULL;
 562                 newVal->paramNo = 0;
 563                 newVal->length = AllDataType::size(newVal->type, 64);
 564                 newVal->value = AllDataType::alloc(newVal->type, newVal->length);
 565                 if(i==0) strcpy((char*)newVal->value,(char*)"CSQL");
 566                 if(i==1) strcpy((char*)newVal->value,(char*)"CSQL");
 567                 newVal->isAllocVal=true;
 568                 totalFields = i+1;
 569                 bindFields[i] = newVal;
 570             }
 571             break;
 572         }
 573         case GetCatalogs:
 574         {
 575              bindFields = (FieldValue**) malloc (1 * sizeof(FieldValue*));
 576              bindFieldValues = (char**) malloc  (1 * sizeof(char*));
 577              FieldValue *newVal = new FieldValue();
 578              strcpy(newVal->fldName,"TABLE_CAT");
 579              newVal->type = typeString;
 580              newVal->parsedString = NULL;
 581              newVal->paramNo = 0;
 582              newVal->length = AllDataType::size(newVal->type, 64);
 583              newVal->value = AllDataType::alloc(newVal->type, newVal->length);
 584              newVal->isAllocVal=true;
 585              totalFields = 1;
 586              bindFields[0] = newVal;
 587              break;
 588         }
 589         case GetTableType:
 590         {
 591              bindFields = (FieldValue**) malloc (1 * sizeof(FieldValue*));
 592              bindFieldValues = (char**) malloc  (1 * sizeof(char*));
 593              FieldValue *newVal = new FieldValue();
 594              strcpy(newVal->fldName,"TABLE_TYPE");
 595              newVal->type = typeString;
 596              newVal->parsedString = NULL;
 597              newVal->paramNo = 0;
 598              newVal->length = AllDataType::size(newVal->type, 64);
 599              newVal->value = AllDataType::alloc(newVal->type, newVal->length);
 600              newVal->isAllocVal=true;
 601              totalFields = 1;
 602              bindFields[0] = newVal;
 603              break;
 604         }
 605         case GetDataType:
 606         {
 607              bindFields = (FieldValue**) malloc (19 * sizeof(FieldValue*));
 608              bindFieldValues = (char**) malloc  (19 * sizeof(char*));
 609              for(int i=0;i<19;i++)
 610              {
 611                  FieldValue *newVal = new FieldValue();
 612                  switch(i)
 613                  {
 614                      case 0:
 615                          strcpy(newVal->fldName,"TYPE_NAME");
 616                          newVal->type = typeString;
 617                          break;
 618                      case 1:
 619                          newVal->type = typeInt;
 620                          strcpy(newVal->fldName,"DATA_TYPE");
 621                          break;
 622                      case 2:
 623                          strcpy(newVal->fldName,"PRECISION");
 624                          newVal->type = typeInt;
 625                          break;
 626                      case 3:
 627                          strcpy(newVal->fldName,"LITERAL_PREFIX");
 628                          newVal->type = typeString;
 629                          break;
 630                      case 4:
 631                          strcpy(newVal->fldName,"LITERAL_SUFFIX");
 632                          newVal->type = typeString;
 633                          break;
 634                      case 5:
 635                          strcpy(newVal->fldName,"CREATE_PARAMS");
 636                          newVal->type = typeString;
 637                          break;
 638                      case 6:
 639                          strcpy(newVal->fldName,"NULLABLE");
 640                          newVal->type = typeShort;
 641                          break;
 642                      case 7:
 643                          strcpy(newVal->fldName,"CASE_SENSITIVE");
 644                          newVal->type = typeInt;
 645                          break;
 646                      case 8:
 647                          strcpy(newVal->fldName,"SEARCHABLE");
 648                          newVal->type = typeShort;
 649                          break;
 650                      case 9:
 651                          strcpy(newVal->fldName,"UNSIGNED_ATTRIBUTE");
 652                          newVal->type = typeInt;
 653                          break;
 654                      case 10:
 655                          strcpy(newVal->fldName,"FIXED_PREC_SCALE");
 656                          newVal->type = typeInt;
 657                          break;
 658                      case 11:
 659                          strcpy(newVal->fldName,"AUTO_INCREMENT");
 660                          newVal->type = typeInt;
 661                          break;
 662                      case 12:
 663                          strcpy(newVal->fldName,"LOCAL_TYPE_NAME");
 664                          newVal->type = typeString;
 665                          break;
 666                      case 13:
 667                          strcpy(newVal->fldName,"MINIMUM_SCALE");
 668                          newVal->type = typeShort;
 669                          break;
 670                      case 14:
 671                          strcpy(newVal->fldName,"MAXIMUM_SCALE");
 672                          newVal->type = typeShort;
 673                          break;
 674                      case 15:
 675                          strcpy(newVal->fldName,"SQL_DATA_TYPE");
 676                          newVal->type = typeInt;
 677                          break;
 678                      case 16:
 679                          strcpy(newVal->fldName,"SQL_DATETIME_SUB");
 680                          newVal->type = typeInt;
 681                          break;
 682                      case 17:
 683                          strcpy(newVal->fldName,"NUM_PREC_RADIX");
 684                          newVal->type = typeInt;
 685                          break;
 686                      case 18:
 687                          strcpy(newVal->fldName,"INTERVAL_PRECISION");
 688                          newVal->type = typeShort;
 689                          break;
 690                      default:
 691                          break;
 692                 };
 693                 newVal->parsedString = NULL;
 694                 newVal->paramNo = 0;
 695                 newVal->length = AllDataType::size(newVal->type, 64);
 696                 newVal->value = AllDataType::alloc(newVal->type,newVal->length);
 697                 newVal->isAllocVal = true;
 698                 totalFields = i+1;
 699                 bindFields[i] = newVal;
 700              }
 701              break;
 702         }
 703         case GetImportKey:
 704         case GetExportKey:
 705         {
 706             rv = openTables();
 707             if (rv != OK)  break; //return rv;
 708             bindFields = (FieldValue**) malloc (14 * sizeof(FieldValue*));
 709             bindFieldValues = (char**) malloc  (14 * sizeof(char*));
 710             for(int i=0;i<14;i++){
 711                 FieldValue *newVal = new FieldValue();
 712                 switch(i){
 713                     case 0:
 714                         strcpy(newVal->fldName,"PKTABLE_CAT");
 715                         newVal->type = typeString;
 716                         break;
 717                     case 1:
 718                         newVal->type = typeString;
 719                         strcpy(newVal->fldName,"PKTABLE_SCHEM");
 720                         break;
 721                     case 2:
 722                         newVal->type = typeString;
 723                         strcpy(newVal->fldName,"PKTABLE_NAME");
 724                         break;
 725                     case 3:
 726                         newVal->type = typeString;
 727                         strcpy(newVal->fldName,"PKCOLUMN_NAME");
 728                         break;
 729                     case 4:
 730                         newVal->type = typeString;
 731                         strcpy(newVal->fldName,"FKTABLE_CAT");
 732                         break;
 733                     case 5:
 734                         newVal->type = typeString;
 735                         strcpy(newVal->fldName,"FKTABLE_SCHEM");
 736                         break;
 737                     case 6:
 738                         newVal->type = typeString;
 739                         strcpy(newVal->fldName,"FKTABLE_NAME");
 740                         break;
 741                     case 7:
 742                         newVal->type = typeString;
 743                         strcpy(newVal->fldName,"FKCOLUMN_NAME");
 744                         break;
 745                     case 8:
 746                         newVal->type = typeShort;
 747                         strcpy(newVal->fldName,"KEY_SEQ");
 748                         break;
 749                     case 9:
 750                         newVal->type = typeShort;
 751                         strcpy(newVal->fldName,"UPDATE_RULE");
 752                         break;
 753                     case 10:
 754                         newVal->type = typeShort;
 755                         strcpy(newVal->fldName,"DELETE_RULE");
 756                         break;
 757                     case 11:
 758                         newVal->type = typeString;
 759                         strcpy(newVal->fldName,"FK_NAME");
 760                         break;
 761                     case 12:
 762                         newVal->type = typeString;
 763                         strcpy(newVal->fldName,"PK_NAME");
 764                         break;
 765                     case 13:
 766                         newVal->type = typeShort;
 767                         strcpy(newVal->fldName,"DEFERRABILITY");
 768                     default:
 769                         newVal->type = typeString;
 770                         break;
 771                 };
 772                 newVal->parsedString = NULL;
 773                 newVal->paramNo = 0;
 774                 newVal->length = AllDataType::size(newVal->type, 64);
 775                 newVal->value = AllDataType::alloc(newVal->type,newVal->length);
 776                 if(typeString == newVal->type) strcpy((char*)newVal->value,(char*)"");
 777                 if(i==0||i==1||i == 4 || i==5) strcpy((char*)newVal->value,(char*)"csql");
 778                 newVal->isAllocVal=true;
 779                 totalFields =i+1;
 780                 bindFields[i] = newVal;
 781             }
 782             break;
 783         }
 784         default:
 785             break;
 786     };
 787     return rv;
 788 }
 789
 790 void* MetadataStatement::fetch()
 791 {
 792
 793     void *tuple = NULL;
 794     tuple = fetchMetaData();
 795     if (NULL == tuple) return NULL;
 796     FieldValue *value;
 797     for (int i = 0; i < totalFields; i++)
 798     {
 799         value = bindFields[i];
 800         if (bindFieldValues[i] == NULL)
 801         {
 802            continue;
 803         }
 804         AllDataType::copyVal(bindFieldValues[i], value->value, value->type, value->length);
 805     }
 806     return tuple;
 807 }
 808
 809 void* MetadataStatement::fetch(DbRetVal &rv)
 810 {
 811     void *tuple = NULL;
 812     tuple = fetchMetaData();
 813     if (NULL == tuple) return NULL;
 814     FieldValue *value;
 815     for (int i = 0; i < totalFields; i++)
 816     {
 817         value = bindFields[i];
 818         if (bindFieldValues[i] == NULL)
 819         {
 820             continue;
 821         }
 822         AllDataType::copyVal(bindFieldValues[i], value->value, value->type, value->length);
 823     }
 824     return tuple;
 825 }
 826
 827 void MetadataStatement::freeMetadata()
 828 {
 829    if(isPlanFreed) return;
 830    dataListIter.reset();
 831    ListNode *head= (ListNode *)dataListIter.getCurrentListNode();
 832    if(head && (plan != GetTableType && plan != GetCatalogs)){
 833        List *list = new List(head);
 834        list->reset();
 835        delete list;
 836    }
 837    switch(plan)
 838    {
 839        case GetTables:
 840        {
 841           FieldValue *newVal = NULL;
 842           if(bindFields){
 843               for(int i=0;i<5;i++){
 844                  newVal=bindFields[i];
 845                  if (newVal->isAllocVal) free(newVal->value);
 846                  delete newVal;
 847               }
 848           }
 849           break;
 850        }
 851        case GetColumns:
 852        {
 853           FieldValue *newVal;
 854           if(bindFields){
 855               for(int i=0;i<23;i++){
 856                   newVal=bindFields[i];
 857                   if ( newVal->isAllocVal) free(newVal->value);
 858                   delete newVal;
 859               }
 860           }
 861           break;
 862        }
 863        case GetIndexes:
 864        {
 865           FieldValue *newVal;
 866           if(bindFields){
 867               for(int i=0;i<13;i++){
 868                   newVal=bindFields[i];
 869                   if ( newVal->isAllocVal) free(newVal->value);
 870                   delete newVal;
 871               }
 872           }
 873           break;
 874        }
 875        case GetPriIndex:
 876        {
 877           FieldValue *newVal;
 878           if(bindFields){
 879               for(int i=0;i<6;i++){
 880                   newVal=bindFields[i];
 881                   if ( newVal->isAllocVal) free(newVal->value);
 882                   delete newVal;
 883               }
 884           }
 885           break;
 886        }
 887        case GetCatalogs:
 888        {
 889           FieldValue *newVal;
 890           if(bindFields){
 891               for(int i=0;i<1;i++){
 892                   newVal=bindFields[i];
 893                 //  if ( newVal->isAllocVal) free(newVal->value);
 894                   delete newVal;
 895               }
 896           }
 897           break;
 898        }
 899        case GetTableType:
 900        {
 901           FieldValue *newVal;
 902           if(bindFields){
 903               for(int i=0;i<1;i++){
 904                   newVal=bindFields[i];
 905                  // if ( newVal->isAllocVal) free(newVal->value);
 906                   delete newVal;
 907               }
 908           }
 909           break;
 910        }
 911        case GetDataType:
 912        {
 913           FieldValue *newVal;
 914           if(bindFields){
 915               for(int i=0;i<18;i++){
 916                   newVal=bindFields[i];
 917                   if ( newVal->isAllocVal) free(newVal->value);
 918                   delete newVal;
 919               }
 920           }
 921           break;
 922        }
 923        case GetImportKey:
 924        {
 925           FieldValue *newVal;
 926           if(bindFields){
 927               for(int i=0;i<14;i++){
 928                   newVal=bindFields[i];
 929                   if ( newVal->isAllocVal) free(newVal->value);
 930                   delete newVal;
 931               }
 932           }
 933           break;
 934        }
 935        case GetExportKey:
 936        {
 937           FieldValue *newVal;
 938           if(bindFields){
 939               for(int i=0;i<14;i++){
 940                   newVal=bindFields[i];
 941                   if ( newVal->isAllocVal) free(newVal->value);
 942                   delete newVal;
 943               }
 944           }
 945           break;
 946        }
 947        default:
 948          break;
 949    };
 950    isPlanFreed=true;
 951 }
 952 DbRetVal MetadataStatement::close()
 953 {
 954     if(plan!=Normal){ freeMetadata(); }
 955     if (table) return table->closeScan();
 956     return OK;
 957 }
 958
 959
 960 char* MetadataStatement::getFieldName ( int pos )
 961 {
 962     ListIterator iter = parsedData->getFieldNameList().getIterator();
 963     int position =0;
 964     while (iter.hasElement())
 965     {
 966         if (position == pos) {
 967               FieldName *name = (FieldName*) iter.nextElement();
 968               if (NULL == name)
 969               {
 970                   printError(ErrSysFatal, "Should never happen. Field Name list has NULL");
 971                   return (char*) 0;
 972               }
 973               return name->fldName;
 974       }
 975         position++;
 976     }
 977     return (char*) 0;
 978 }
 979
 980 DataType MetadataStatement::getFieldType( int pos )
 981 {
 982     FieldValue *v = bindFields[pos];
 983     return ( (DataType) v->type );
 984 }
 985
 986 int MetadataStatement::getFieldLength( int pos )
 987 {
 988     FieldValue *v = bindFields[pos];
 989     return ( (int) v->type );
 990 }
 991
 992 void* MetadataStatement::fetchAndPrint(bool SQL)
 993 {
 994     void *tuple = NULL;
 995     return tuple;
 996 }
 997
 998 void* MetadataStatement::next()
 999 {
1000     return fetchMetaData();
1001 }
1002
1003 void* MetadataStatement::getFieldValuePtr( int pos )
1004 {
1005     FieldValue *v = bindFields[pos];
1006     return ( (void*) v->value );
1007 }
1008
1009 void* MetadataStatement::getFieldValuePtr( char *name )
1010 {
1011     FieldValue *value;
1012     char fName[IDENTIFIER_LENGTH];
1013     for (int i = 0; i < totalFields; i++)
1014     {
1015         value = bindFields[i];
1016         table->getFieldNameAlone(value->fldName,fName);
1017         if (strcmp(fName,name)==0)
1018         {
1019             return ( (void*) value->value );
1020         }
1021
1022     }
1023     return NULL;
1024 }
1025
1026 void MetadataStatement::getProjFieldType(int *data)
1027 {
1028     FieldValue *value;
1029     for (int i = 0; i < totalFields; i++)
1030     {
1031         value = bindFields[i];
1032         data[i+1] = value->type;
1033     }
1034 }
1035
1036 DbRetVal MetadataStatement::setBindField(int colNo, void *value)
1037 {
1038     if (colNo <=0) return ErrBadArg;
1039     if (NULL == value) return ErrBadArg;
1040     bindFieldValues[colNo -1] = (char*) value;
1041     return OK;
1042 }
1043
1044
1045 int MetadataStatement::noOfProjFields()
1046 {
1047     return totalFields;
1048 }
1049
1050 DbRetVal MetadataStatement::getProjFldInfo (int projpos, FieldInfo *&fInfo)
1051 {
1052
1053     DbRetVal rv = OK;
1054     if(plan != Normal)
1055     {
1056         FieldValue *v = bindFields[projpos-1];
1057         strcpy(fInfo->fldName, v->fldName);
1058         fInfo->type = v->type;
1059         fInfo->length = v->length;
1060         return rv;
1061     }
1062     ListIterator iter = parsedData->getFieldNameList().getIterator();
1063     FieldName *name = NULL;
1064     int position =0;
1065     while (iter.hasElement())
1066     {
1067         name = (FieldName*)iter.nextElement();
1068         if (NULL == name)
1069         {
1070             printError(ErrSysFatal, "Should never happen. Field Name list has NULL");
1071             return ErrSysFatal;
1072         }
1073         if (position == (projpos-1)) break;
1074         position++;
1075     }
1076
1077     rv = table->getFieldInfo(name->fldName, fInfo);
1078     if (OK == rv)
1079     {
1080        //get back the qualified name(tablename.fldname)
1081        char qualName[IDENTIFIER_LENGTH];
1082        strcpy(qualName, name->fldName);
1083        switch(name->aType)
1084        {
1085            case AGG_COUNT:
1086                sprintf(fInfo->fldName, "COUNT(%s)", qualName);
1087                fInfo->type = typeInt;
1088                fInfo->length = sizeof(int);
1089                break;
1090            case AGG_MIN:
1091                sprintf(fInfo->fldName, "MIN(%s)", qualName);
1092                break;
1093            case AGG_MAX:
1094                sprintf(fInfo->fldName, "MAX(%s)", qualName);
1095                break;
1096            case AGG_SUM:
1097                sprintf(fInfo->fldName, "SUM(%s)", qualName);
1098                break;
1099            case AGG_AVG:
1100                sprintf(fInfo->fldName, "AVG(%s)", qualName);
1101                fInfo->type = typeDouble;
1102                fInfo->length = sizeof(double);
1103                break;
1104            default:
1105                strcpy(fInfo->fldName, qualName);
1106                break;
1107        }
1108     }
1109     return rv;
1110 }
1111 int MetadataStatement::getFldPos(char *name)
1112 {
1113     return table->getFldPos(name);
1114 }
1115
1116 void *MetadataStatement::fetchMetaData()
1117 {
1118      switch(plan)
1119      {
1120         case GetTables:
1121         {
1122            Identifier *elem = NULL;
1123            if(dataListIter.hasElement())
1124            {
1125                FieldValue *v = bindFields[2];
1126                elem = (Identifier*) dataListIter.nextElement();
1127                AllDataType::copyVal(v->value, elem->name, v->type, v->length);
1128                delete elem;
1129                return v->value;
1130            } else return NULL;
1131         }
1132         case GetColumns:
1133         {
1134            FieldInfo *info = NULL;
1135            if(dataListIter.hasElement())
1136            {
1137                info = (FieldInfo *) dataListIter.nextElement();
1138                FieldValue *v;
1139                for(int i=0;i<23;i++)
1140                {
1141                    switch(i)
1142                    {
1143                        case 3:
1144                          {
1145                              v = bindFields [i];
1146                              AllDataType::copyVal(v->value, info->fldName, v->type, v->length);
1147                              break;
1148                          }
1149                       case 4:
1150                          {
1151                              v = bindFields [i];
1152                              int type=0;
1153                              type = AllDataType::convertToCSQLSQLType(info->type);
1154                              AllDataType::copyVal(v->value,&type,v->type, v->length);
1155                              break;
1156                          }
1157                       case 5:
1158                          {
1159                              v = bindFields [i];
1160                              AllDataType::copyVal(v->value,AllDataType::getSQLString(info->type),v->type, v->length);
1161                              break;
1162                          }
1163
1164                       case 6:
1165                          {
1166                              v = bindFields [i];
1167                              AllDataType::copyVal(v->value,&info->length,v->type, v->length);
1168                              break;
1169                          }
1170                       case 10:
1171                          {
1172                              v = bindFields [i];
1173                              if(info->isNull)
1174                                  (*(short*)v->value)=0;
1175                              else
1176                                  (*(short*)v->value)=1;
1177                              break;
1178                          }
1179                       case 12:
1180                          {
1181                              v = bindFields [i];
1182                              AllDataType::copyVal(v->value,info->defaultValueBuf,v->type, v->length);
1183                              break;
1184                          }
1185                       case 16:
1186                          {
1187                              v = bindFields [i];
1188                              (*(int*)v->value) = table->getFldPos(info->fldName);
1189                              break;
1190                          }
1191                       case 17:
1192                          {
1193                              v = bindFields [i];
1194                              if(info->isNull)
1195                                  AllDataType::copyVal(v->value,(void *)"NO",v->type, v->length);
1196                              else
1197                                  AllDataType::copyVal(v->value,(void *)"YES",v->type, v->length);
1198                              break;
1199                          }
1200                       case 22:
1201                              v = bindFields [i];
1202                              if(info->isAutoIncrement)
1203                                  AllDataType::copyVal(v->value,(void *)"YES",v->type, v->length);
1204                              else
1205                                  AllDataType::copyVal(v->value,(void *)"NO",v->type, v->length);
1206
1207                       default:
1208                          break;
1209                    };
1210                }
1211                delete info;
1212                return v->value ;
1213            }else return NULL;
1214         }
1215         case GetIndexes:
1216         {
1217            IndexInfoForDriver *info=NULL;
1218            if(dataListIter.hasElement())
1219            {
1220                info = (IndexInfoForDriver *) dataListIter.nextElement();
1221                FieldValue *v;
1222                for(int i=0;i<22;i++)
1223                {
1224                    switch(i)
1225                    {
1226                        case 2:
1227                          {
1228                              v = bindFields [i];
1229                              AllDataType::copyVal(v->value, info->tableName, v->type, v->length);
1230                              break;
1231                          }
1232                       case 3:
1233                          {
1234                              v = bindFields [i];
1235                              if(info->isUnique) { ( *(int*) v->value) = 1; }
1236                              else (*(int*) v->value) = 0;
1237                              break;
1238                          }
1239                       case 5:
1240                          {
1241                              v = bindFields [i];
1242                              AllDataType::copyVal(v->value,info->indexName, v->type, v->length);
1243                              break;
1244                          }
1245                       case 6:
1246                          {
1247                              v = bindFields [i];
1248                              if(info->type ==0)  (*(short *) v->value) = SQL_INDEX_HASHED ;
1249                              else  (*(short *) v->value) = SQL_INDEX_OTHER ;
1250                              break;
1251                          }
1252                       case 7:
1253                          {
1254                              v = bindFields [i];
1255                              (*(short *) v->value) = table->getFldPos(info->fieldName) ;
1256                              break;
1257                          }
1258                       case 8:
1259                          {
1260                              v = bindFields [i];
1261                              AllDataType::copyVal(v->value, info->fieldName, v->type, v->length);
1262                              break;
1263                          }
1264                       default:
1265                          break;
1266                    };
1267                }
1268                delete info;
1269                return v->value ;
1270            }else return NULL;
1271         }
1272         case GetPriIndex:
1273         {
1274             IndexInfoForDriver *info=NULL;
1275             char name[IDENTIFIER_LENGTH];
1276             while(dataListIter.hasElement())
1277             {
1278                 info = (IndexInfoForDriver *) dataListIter.nextElement();
1279                 FieldValue *v = NULL;
1280                 //sprintf(name, "%s_idx1_Primary",info->tableName);
1281                 //if(strcmp(name, info->indexName) != 0){ continue; }
1282                 if( !info->isPrimary ){ continue; }
1283                 for(int i=0;i<6;i++)
1284                 {
1285                     switch(i)
1286                     {
1287                         case 2:
1288                           {
1289                               v = bindFields [i];
1290                               AllDataType::copyVal(v->value, table->getName(), v->type, v->length);
1291                               break;
1292                           }
1293                         case 3:
1294                           {
1295                               v = bindFields [i];
1296                               AllDataType::copyVal(v->value, info->fieldName, v->type, v->length);
1297                               break;
1298                           }
1299                        case 4:
1300                           {
1301                               v = bindFields [i];
1302                               (*(short *) v->value) = table->getFldPos(info->fieldName) ;
1303                               break;
1304                           }
1305                        case 5:
1306                           {
1307                               v = bindFields [i];
1308                               AllDataType::copyVal(v->value,info->indexName, v->type, v->length);
1309                     //          printf("Index name %s\n",info->indexName);
1310                               break;
1311                           }
1312                        default :
1313                               break;
1314                    };
1315               }
1316               delete info;
1317               return v->value;
1318            }
1319            return NULL;
1320         }
1321         case GetCatalogs:
1322         {
1323             FieldValue *v = NULL;
1324             v = bindFields [0];
1325             if(!isSecondFetch)
1326             {
1327                 strcpy((char*)v->value,"csql");
1328                 isSecondFetch=true;
1329                 return v->value;
1330             }
1331             free(v->value);
1332             return NULL;
1333         }
1334         case GetTableType:
1335         {
1336             FieldValue *v = NULL;
1337             v = bindFields [0];
1338             if(!isSecondFetch)
1339             {
1340                 strcpy((char*)v->value,"TABLE");
1341                 isSecondFetch=true;
1342                 return v->value;
1343             }
1344             free(v->value);
1345             return NULL;
1346         }
1347         case GetImportKey:
1348         case GetExportKey:
1349         {
1350             ForeignKeyMetadata *info=NULL;
1351             char name[IDENTIFIER_LENGTH];
1352             while(dataListIter.hasElement())
1353             {
1354                 info = (ForeignKeyMetadata *) dataListIter.nextElement();
1355                 FieldValue *v = NULL;
1356                 for(int i=0;i<14;i++)
1357                 {
1358                     switch(i)
1359                     {
1360                         case 2:
1361                           {
1362                               v = bindFields [i];
1363                               AllDataType::copyVal(v->value, info->pkTableName, v->type, v->length);
1364                               break;
1365                           }
1366                         case 3:
1367                           {
1368                               v = bindFields [i];
1369                               AllDataType::copyVal(v->value, info->pkColName, v->type, v->length);
1370                               break;
1371                           }
1372                         case 6:
1373                           {
1374                               v = bindFields [i];
1375                               AllDataType::copyVal(v->value, info->fkTableName, v->type, v->length);
1376                               break;
1377                           }
1378                         case 7:
1379                           {
1380                               v = bindFields [i];
1381                               AllDataType::copyVal(v->value, info->fkColName, v->type, v->length);
1382                               break;
1383                           }
1384                        case 8:
1385                           {
1386                               v = bindFields [i];
1387                               (*(short *) v->value) = info->keySeq;
1388                               break;
1389                           }
1390                        case 9:
1391                           {
1392                               v = bindFields [i];
1393                               (*(short *) v->value) = info->updateRule;
1394                               break;
1395                           }
1396                        case 10:
1397                           {
1398                               v = bindFields [i];
1399                               (*(short *) v->value) = info->deleteRule;
1400                               break;
1401                           }
1402                        default :
1403                               break;
1404                    };
1405               }
1406               delete info;
1407               return v->value;
1408            }
1409            return NULL;
1410         }
1411         case GetDataType:
1412         {
1413             DataTypeInfo *info=NULL;
1414             char name[IDENTIFIER_LENGTH];
1415             while(dataListIter.hasElement())
1416             {
1417                 info = (DataTypeInfo *) dataListIter.nextElement();
1418                 FieldValue *v = NULL;
1419                 for(int i=0;i<19;i++)
1420                 {
1421                     switch(i)
1422                     {
1423                         case 0:
1424                           {
1425                               v = bindFields [i];
1426                               AllDataType::copyVal(v->value, info->name, v->type, v->length);
1427                               break;
1428                           }
1429                         case 1:
1430                           {
1431                               v = bindFields [i];
1432                               int type=0;
1433                               type = AllDataType::convertToCSQLSQLType((DataType)info->type);
1434                               AllDataType::copyVal(v->value,&type,v->type, v->length);
1435                               break;
1436                           }
1437                         case 2:
1438                           {
1439                               v = bindFields [i];
1440                               AllDataType::copyVal(v->value, &info->precision, v->type, v->length);
1441                               break;
1442                           }
1443                         case 3:
1444                           {
1445                               v = bindFields [i];
1446                               if( info->type == typeString || info->type == typeDate || info->type == typeTime || info->type == typeTimeStamp )
1447                                   AllDataType::copyVal(v->value, (void *)"'", v->type, v->length);
1448                               else
1449                                   AllDataType::copyVal(v->value, (void *)"", v->type, v->length);
1450                               break;
1451                           }
1452                        case 4:
1453                           {
1454                               v = bindFields [i];
1455                               if( info->type == typeString || info->type == typeDate || info->type == typeTime || info->type == typeTimeStamp )
1456                                   AllDataType::copyVal(v->value, (void *)"'", v->type, v->length);
1457                               else
1458                                   AllDataType::copyVal(v->value, (void *)"", v->type, v->length);
1459                               break;
1460                           }
1461                        case 5:
1462                           {
1463                               v = bindFields [i];
1464                               AllDataType::copyVal(v->value, (void *)"", v->type, v->length);
1465                               break;
1466                           }
1467                        case 6:
1468                           {
1469                               v = bindFields [i];
1470                               (*(short *) v->value) = 1;
1471                               break;
1472                           }
1473                        case 7:
1474                           {
1475                               v = bindFields [i];
1476                               (*(short *) v->value) = 0;
1477                               break;
1478                           }
1479                        case 8:
1480                           {
1481                               v = bindFields [i];
1482                               (*(short *) v->value) = 3;
1483                               break;
1484                           }
1485                        case 9:
1486                           {
1487                               v = bindFields [i];
1488                               (*(short *) v->value) = 0;
1489                               break;
1490                           }
1491                        case 10:
1492                           {
1493                               v = bindFields [i];
1494                               (*(short *) v->value) = 0;
1495                               break;
1496                           }
1497                        case 11:
1498                           {
1499                               v = bindFields [i];
1500                               if(info->autoIncrement)
1501                                   (*(short *) v->value) = 1;
1502                               else
1503                                   (*(short *) v->value) = 0;
1504                               break;
1505                           }
1506                        case 12:
1507                           {
1508                               v = bindFields [i];
1509                               AllDataType::copyVal(v->value, info->name, v->type, v->length);
1510                               break;
1511                           }
1512                        case 13:
1513                           {
1514                               v = bindFields [i];
1515                               if(info->type == typeFloat)
1516                                   (*(short *) v->value) = -38;
1517                               else if(info->type == typeDouble)
1518                                   (*(short *) v->value) = -308;
1519                               else
1520                                   (*(short *) v->value) = 0;
1521                               break;
1522                           }
1523                        case 14:
1524                           {
1525                               v = bindFields [i];
1526                               if(info->type == typeFloat)
1527                                   (*(short *) v->value) = 38;
1528                               else if(info->type == typeDouble)
1529                                   (*(short *) v->value) = 308;
1530                               else
1531                                   (*(short *) v->value) = 0;
1532                               break;
1533                           }
1534                        case 15:
1535                           {
1536                               v = bindFields [i];
1537                               (*(short *) v->value) =0; //TODO
1538                               break;
1539                           }
1540                        case 16:
1541                           {
1542                               v = bindFields [i];
1543                               (*(short *) v->value) = 0;//TODO
1544                               break;
1545                           }
1546                        case 17:
1547                           {
1548                               v = bindFields [i];
1549                               (*(int *) v->value) = 10;
1550                               break;
1551                           }
1552                        case 18:
1553                           {
1554                               v = bindFields [i];
1555                               (*(short *) v->value) = 0;
1556                               break;
1557                           }
1558                        default :
1559                               break;
1560                    };
1561               }
1562               delete info;
1563               return v->value;
1564            }
1565            return NULL;
1566         }
1567         default:
1568            break;
1569      };
1570      return NULL;
1571 }
1572
1573 ListIterator MetadataStatement::getDataTypeInfoIterator()
1574 {
1575     List datalist;
1576     for(int i=0; i<10; i++)
1577     {
1578         DataTypeInfo *typeInfo = new DataTypeInfo();
1579         datalist.append(typeInfo);
1580     }
1581     DataTypeInfo *info = (DataTypeInfo *)datalist.get(1);
1582     strcpy(info->name,"TINYINT");
1583     info->type = 4;
1584     info->precision = 3;
1585     info->autoIncrement = true;
1586     info = (DataTypeInfo *)datalist.get(2);
1587     strcpy(info->name,"SMALLINT");
1588     info->type =3 ;
1589     info->precision = 5;
1590     info->autoIncrement = true;
1591     info =(DataTypeInfo *) datalist.get(3);
1592     strcpy(info->name,"INT");
1593     info->type = 0 ;
1594     info->precision = 10 ;
1595     info->autoIncrement = true;
1596     info =(DataTypeInfo *) datalist.get(4);
1597     strcpy(info->name,"BIGINT");
1598     info->type =1 ;
1599     info->precision = 19;
1600     info->autoIncrement = true;
1601     info =(DataTypeInfo *) datalist.get(5);
1602     strcpy(info->name,"FLOAT");
1603     info->type = 11;
1604     info->precision = 10;
1605     info->autoIncrement = false;
1606     info =(DataTypeInfo *) datalist.get(6);
1607     strcpy(info->name,"DOUBLE");
1608     info->type =10 ;
1609     info->precision = 17;
1610     info->autoIncrement = false;
1611     info =(DataTypeInfo *) datalist.get(7);
1612     strcpy(info->name,"CHAR");
1613     info->type =30 ;
1614     info->precision = 255;
1615     info->autoIncrement = false;
1616     info =(DataTypeInfo *) datalist.get(8);
1617     strcpy(info->name,"DATE");
1618     info->type =20 ;
1619     info->precision = 0;
1620     info->autoIncrement = false;
1621     info =(DataTypeInfo *) datalist.get(9);
1622     strcpy(info->name,"TIME");
1623     info->type =21 ;
1624     info->precision = 0;
1625     info->autoIncrement = false;
1626     info =(DataTypeInfo *) datalist.get(10);
1627     strcpy(info->name,"TIMESTAMP");
1628     info->type =22;
1629     info->precision = 0;
1630     info->autoIncrement = false;
1631     return datalist.getIterator();
1632 }
1633