home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / dbutil.zip / BUFOP.ZIP / GENSQL.CPP < prev    next >
Text File  |  1993-09-13  |  16KB  |  454 lines
  1. #include "compsql.hpp"                                  
  2. #include <istring.hpp>                                  
  3. #include "files.hpp"
  4. #include <fstream.h>                                    
  5. #include <iset.h>                                       
  6. #include "hostvars.hpp"         // host variables       
  7. #include <sqlaprep.h>                                   
  8. #include <sql.h>                                        
  9. #include <stdlib.h>                                     
  10.  
  11. extern sqlca mysqlca;
  12. extern sqla_program_id progID; 
  13.  
  14. Boolean optimize;
  15.  
  16.  
  17. //
  18. //  On an SQL error, warning or not found - the goto labels
  19. //
  20. static IString NotFoundLabel="";
  21. static IString WarningLabel ="";
  22. static IString ErrorLabel = "";
  23.  
  24.  
  25. /*********************************************************************
  26. *   Generate the source code for access to the database
  27. *  The generate instructions are in the task array 
  28. *  (created by the precompiler services)
  29. *  Variables and usage is in the token array (usage filled in by
  30. *  precompiler services)
  31. **********************************************************************/
  32.  
  33. /*********************************************************************
  34. * Proto Types of internal functions to gen code
  35. *********************************************************************/
  36.  
  37. void inputFile(IString const & Stmt, unsigned long );
  38.  
  39. static unsigned short nxtSQLDA=1,inputSQLDA=0, outputSQLDA=0;
  40.  
  41. void genConnect(char type,      // exclusive or shared
  42.                 IString const & stmt, // SQL statment with DB name in
  43.                 unsigned long x,  // offset to DBName & DBLen
  44.                 ofstream & fout); // output file
  45.  
  46. void GenSetVArray(int nbrTokens,                
  47.                   unsigned short StmtID,        
  48.                   Boolean input,                
  49.                   ofstream & fout,              
  50.                   sqla_tokens * tokenArray);
  51.  
  52. void GenOnError(ofstream & fout);
  53.  
  54. void GenOnWarning(ofstream & fout);
  55.  
  56. void GenOnNotFound(ofstream & fout);
  57.  
  58. IString MakeLabel(IString & theLabel);
  59.  
  60. void GenIncludeSQLDA(ofstream & fout);
  61.  
  62. void GenIncludeSQLCA(ofstream & fout);
  63.  
  64. void GenSQLASets(int theID, ofstream & fout);
  65.  
  66.  
  67.  
  68. /*************************************************************  */
  69. /*  G E N E R A T E   C O D E    TO   I N T E R F A C E         */
  70. /*  D B 2 / 2                                                   */
  71. /************************************************************** */
  72.  
  73.  
  74. genSQL(ofstream & fout, sqla_tasks * taskArray, sqla_tokens * tokenArray,
  75.        unsigned short sectionNbr, IString const & Stmt, int stmttype)
  76. {
  77.    int task;
  78. //
  79. //  reset the sqlda ids for this call
  80. //
  81.    inputSQLDA = 0;
  82.    outputSQLDA = 0;
  83.    for (int j=0;j<taskArray->header.used ;j++ ) {
  84.       switch (taskArray->task[j].func) {
  85.         case SQLA_START:  fout <<  "     sqlastrt(&sqla_program_id,NULL,&sqlca); \n";
  86.            break;
  87.         case SQLA_DECLARE:
  88.               if (taskArray->task[j].val == SQLA_BEGIN) {
  89.                  setDeclare(true);
  90.               } else {
  91.                  setDeclare(false);
  92.               } /* endif */
  93.            break;
  94.         case SQLA_INCLUDE:   
  95.              if (taskArray->task[j].val == SQLA_SQLCA) {
  96.                 GenIncludeSQLCA(fout);
  97.              } else {
  98.                 GenIncludeSQLDA(fout);
  99.              } /* endif */
  100.  
  101.            break;
  102.         case SQLA_ALLOC_INPUT: GenSetVArray(taskArray->task[j].val,sectionNbr,
  103.                                        true,fout,tokenArray);
  104.  
  105.            break;
  106.       case SQLA_ALLOC_OUTPUT: GenSetVArray(taskArray->task[j].val,sectionNbr,
  107.                                       false,fout,tokenArray);
  108.            break;
  109.         case SQLA_SETS: GenSQLASets(taskArray->task[j].val, fout);
  110.            break;
  111.         case SQLA_USDA_INPUT: // TBD GenSQLDA(taskArray->task[j].value); 
  112.            break;
  113.         case SQLA_USDA_OUTPUT: // TBDGenInputSQLDA(taskArray->task[j].value);
  114.            break;
  115.         case SQLA_CALL: 
  116.                  fout << "     sqlacall("  
  117.                       << taskArray->task[j].val << ", "
  118.                       << sectionNbr << ", " 
  119.                       << inputSQLDA << ", " 
  120.                       << outputSQLDA
  121.                       << ",NULL); \n";
  122.            break;
  123.         case SQLA_DEALLOC:   /* not used */
  124.            break;
  125.         case SQLA_STOP:    fout << "     sqlastop(NULL); \n";
  126.            break;
  127.         case SQLA_SQLERROR: GenOnError(fout);
  128.            break;
  129.         case SQLA_SQLWARNING: GenOnWarning(fout);
  130.            break;
  131.         case SQLA_NOT_FOUND: GenOnNotFound(fout);
  132.            break;
  133.         case SQLA_CONNECT_EXCL:  genConnect('X',Stmt,taskArray->task[j].val,fout);
  134.            break;
  135.         case SQLA_CONNECT_SHARE:  genConnect('S',Stmt,taskArray->task[j].val,fout);
  136.            break;
  137.         case SQLA_CONNECT_RESET:  fout << "    _RC = sqlestpd(&sqlca);  \n";// not used
  138.            break;
  139.         case SQLA_INC_TEXTFILE:
  140.             {inputFile(Stmt,taskArray->task[j].val);}
  141.  
  142.            break;
  143.       } /* endswitch */
  144.   } /* endfor  each task in task array*/
  145.  
  146. //-----------------------------------------------------------------------
  147. //  C H E C K   F O R  A   W H E N E V E R  S T M T
  148. //  a "whenever statement does not associate any tasks
  149. //  must pick up the info based on statement type
  150. //    N O T I C E 
  151. //      do not support ":label" no colon in the label
  152. //----------------------------------------------------------------------
  153.   if (stmttype == SQLA_TYPE_WHEN_NOT_FOUND ) {
  154.      NotFoundLabel = Stmt.word(Stmt.numWords());  // skip "whenever not found"
  155.   } else {
  156.     if (stmttype == SQLA_TYPE_WHEN_SQLERROR ) {
  157.        ErrorLabel = Stmt.word(Stmt.numWords());   // skip " whenever sqlwarning"
  158.     } else {
  159.        if (stmttype == SQLA_TYPE_WHEN_SQLWARNING ) {
  160.           WarningLabel = Stmt.word(Stmt.numWords());  // skip " whenever sqlerror "
  161.        } /* endif */
  162.     } /* endif */
  163.   } /* endif */
  164.  
  165.  
  166. } /* end of gen code */
  167.  
  168. /***************************************************************************
  169. * support functions for code generation
  170. ***************************************************************************/
  171. void GenSetVArray(int nbrTokens, 
  172.                   unsigned short StmtID,
  173.                   Boolean input, 
  174.                   ofstream & fout, 
  175.                   sqla_tokens * tokenArray)
  176. {
  177.          short useSQLDA;     // id of sqlda to use
  178.  
  179.   Variable Var;                 // a variable objects
  180.  
  181. // -----------------------------------------------------------
  182.     if (input) {
  183.        inputSQLDA =nxtSQLDA++;
  184.        useSQLDA = inputSQLDA;
  185.     } else {
  186.        outputSQLDA = nxtSQLDA++;
  187.        useSQLDA = outputSQLDA;
  188.     } /* endif */
  189.     fout << "     _RC = sqlaaloc(" << useSQLDA << ", " << nbrTokens << ","
  190.           << StmtID << ",NULL);// allocate an sqlda \n";
  191.  
  192. //
  193. //              for each host variable used - gen setV code
  194. //
  195. //      if the indicator is with Indicator, the next in the array
  196. //      will be the null indicator - get that and send the name
  197. //
  198.   if (optimize) {
  199.     fout << "if (sqlca.code == 0) { \n";    // gen the optimization stuff
  200.   } /* endif*/
  201.  
  202.   int index = 0;
  203.   int theID, theNullInd;
  204.   Variable theToken;
  205. /***********************************************************************
  206. *  The token array has all tokens used  For input only process the ones
  207. *  markeds for input, for output, only process the ones marked for output
  208. ************************************************************************/
  209.  
  210.   if (input) {
  211.  
  212.       for (int j = 0;j < tokenArray->header.used ;j++ ) {
  213.              theID = tokenArray->token[j].id;
  214.          switch (tokenArray->token[j].use) {
  215.          case SQLA_INPUT_HVAR : theToken = getVarByID(theID); // get the token
  216.                                  theToken.setV(useSQLDA,index,fout);
  217.                                  index++;
  218.             break;
  219.          case SQLA_INPUT_WITH_IND : theToken = getVarByID(theID);
  220.                                     theNullInd = tokenArray->token[j+1].id;
  221.                                     theToken.setVNull(useSQLDA,index,fout,theNullInd);
  222.                                     index++;
  223.             break;
  224.          case SQLA_INDICATOR:       // do nothing - already done by withNull
  225.             break;
  226.          } /* endswitch */
  227.       }  /* end for */
  228.   } else {
  229.        for (int j = 0;j < tokenArray->header.used ;j++ ) {
  230.              theID = tokenArray->token[j].id;
  231.          switch (tokenArray->token[j].use) {
  232.          case SQLA_OUTPUT_HVAR : theToken = getVarByID(theID); // get the token
  233.                                  theToken.setV(useSQLDA,index,fout);
  234.                                  index++;
  235.             break;
  236.          case SQLA_OUTPUT_WITH_IND: theToken = getVarByID(theID);
  237.                                     theNullInd = tokenArray->token[j+1].id;
  238.                                     theToken.setVNull(useSQLDA,index,fout,theNullInd);
  239.                                     index++;
  240.             break;
  241.          case SQLA_INDICATOR:       // do nothing - already done by withNull
  242.             break;
  243.          } /* endswitch */
  244.  
  245.   } /* end for */
  246.   } /* end if*/
  247.   if (optimize) {
  248.      fout << "}  // end of optimize \n ";
  249.   } /* endif */
  250. }
  251.  
  252.  
  253. /**********************************************************************
  254. * and EXEC SQL IMPORT
  255. * was found in the input stream.  Isolate the file name and
  256. * make a recursive call to process file with the file name
  257. **********************************************************************/
  258.  
  259. void inputFile(IString const & Stmt, unsigned long x)
  260. { 
  261.   sqla_return_token *  p = (sqla_return_token *) &x;
  262.  
  263.   IString FileName=Stmt.subString(p->offset,p->length);
  264.   FileName.translate("'","");
  265.   FileName.strip(' ');
  266.   processFile(FileName);
  267. }
  268.  
  269.  
  270. /************************************************************ 
  271. *
  272. *  Generate call to connent the database
  273. *  in form of
  274. *  _rc =sqlestrd("dbname",use,&sqlca);
  275. **************************************************************/
  276. void genConnect(char type,      // exclusive or shared
  277.                 IString const & stmt, // SQL statment with DB name in
  278.                 unsigned long x,  // offset to DBName & DBLen
  279.                 ofstream & fout) // output file
  280.  
  281. {
  282.    sqla_return_token * p = (sqla_return_token *) &x;  
  283.    IString dbName = stmt.subString((p->offset)+1,p->length);
  284.    fout << "\n  unsigned char dbname[]= \"" << dbName << "\";\n";
  285.    fout <<"     _RC = sqlestrd(dbname, '" << type << "',&sqlca);\n";
  286. }
  287.  
  288.  
  289.  
  290. //========================================================================
  291. //  an sqlca includes both the CA and the DA  and....
  292. //  in this implementation generates the program ID sqla_program_id
  293. //  defines the ca to use in all DB calls
  294. //  defines the Booean _found
  295. //  one of these should be put into every program module that
  296. //  makes DB calls
  297. //========================================================================
  298. void GenIncludeSQLCA(ofstream & fout)
  299. {
  300.  //unsigned short letter;
  301.  unsigned char * pProgID =  (unsigned char *) &progID;  // pointer to program ID
  302.  
  303.     fout << "#include <sqlda.h>   // sqlda structure \n"
  304.          << "#include <sqlca.h>   // sqlca structre \n"
  305.          << "#include <sqlaprep.h> // api(s) for most calls \n"
  306.          << "#include <sqlenv.h>   // api(s) for start & stop db \n"
  307.          << "sqlca sqlca; \n"          // an instance of sqlca
  308.          << "typedef int  Boolean; \n"
  309.          << "#define false 0\n"
  310.          << "#define true 1 \n"
  311.          << "Boolean _sqlfound = false;\n"
  312.          << "Boolean _sqlerror = false;\n"
  313.          << "Boolean _sqlwarn = false; \n"
  314.          << "int _RC;\n"
  315.          << "const unsigned char sqla_program_id[40] = {";
  316.    fout << hex;
  317.    fout.setf(ios::showbase);
  318.          for (int j=0;j<4 ;j++ ) { // print 4 lines of 10
  319.             fout << "\n       ";
  320.             for (int k=j*10;k<(j+1)*10 ;k++ ) {  // do 10 char
  321.                fout  << short (pProgID[k]);
  322.                if (k < 39) {
  323.                   fout <<",";
  324.                } /* endif */
  325.             } /* endfor */
  326.          } /* endfor */
  327.     fout << "};\n\n";
  328.     fout << dec;                // change it back to decimal
  329. }
  330.  
  331.  
  332.  
  333. //=================================================================
  334. //  an sqlda include only includes the file
  335. //  wow big deal.  changed the including of the
  336. //  structure into the program  to generating an include <sqlda.h>
  337. //  does the same thing but no so messy
  338. //  I don't know of any real use for this command.
  339. //===================================================================
  340. void GenIncludeSQLDA(ofstream & fout)
  341. { fout <<  "#include <sqlda.h>\n";
  342. }
  343.  
  344.  
  345. //------------------------------------------------------
  346. //  support for dynamic sql SQLASets
  347. //  the hostvar in the ID
  348. //  get the hostvar by the ID and generate SQLASETS
  349. //-----------------------------------------------------------
  350. void GenSQLASets(int theID, ofstream & fout)
  351. { IString VName,lenstr;
  352.    Variable V;
  353.    V = getVarByID(theID);
  354.    VName = V.getFullName();
  355.    if (VName.includes('&')) {
  356.       lenstr = VName.strip('&');
  357.     }else{
  358.       lenstr = VName;
  359.    } /* endif */
  360.    fout << "     _RC  = sqlasets(strlen( " << lenstr << "),"
  361.         << VName << ",NULL);\n";
  362. }
  363.  
  364.  
  365. /***************************************************************
  366. *  A word about GOTOs (on error, warning, not found )
  367. *  I HATE Gotos  but SQL uses them.  So I cheat!
  368. *  If the goto label is of the patterm xxxx(x)
  369. *  I will call it as a function rather than a goto
  370. *  If the no found is _found  I will gen code to
  371. *  set the boolean _found
  372. *  otherwise I'll just gen the go-old goto
  373. *************************************************************/
  374.  
  375.  
  376. void GenOnError(ofstream & fout){
  377.  const char SB[]=
  378.   "      if (sqlca.sqlcode < 0) { \n"
  379.   "         _sqlerror = true;\n"
  380.   "       } else { \n"
  381.   "          _sqlerror = false;\n"
  382.   "       } /* endif */ \n";
  383.  
  384.  const char GT[] =
  385.   "      if (sqlca.sqlcode < 0) { \n";
  386.  
  387.     if (ErrorLabel.includes("_sqlerror")) {  // generate code to set boolean
  388.       fout << SB;
  389.     } else {   fout << "        " << MakeLabel(NotFoundLabel) << ";\n"
  390.                     << "    }\n";
  391.     } /* endif */
  392.  
  393.  
  394.  }
  395.                                                    
  396. void GenOnWarning(ofstream & fout){
  397.  
  398.  const char SB[]=
  399.   "   if (((sqlca.sqlcode > 0) && (sqlca.sqlcode !=100))) ||\n"
  400.   "      ((sqlca.sqlcode ==0) && (sqlca.sqlwarn[0] == 'W'))){\n"
  401.   "         _sqlwarn = true;\n"
  402.   "       } else { \n"
  403.   "          _sqlwarn = true;\n"
  404.   "       } /* endif */ \n";
  405.  
  406.  const char GT[] =
  407.   "      if (sqlca.sqlcode == 100) { \n";
  408.  
  409.     if (WarningLabel.includes("_sqlwarn")) {  // generate code to set boolean
  410.       fout << SB;
  411.     } else {   fout << "        " << MakeLabel(NotFoundLabel) << ";\n"
  412.                     << "    }\n";
  413.     } /* endif */
  414.  
  415.  
  416.  }
  417. void GenOnNotFound(ofstream & fout){
  418.  const char SB[]=
  419.   "      if (sqlca.sqlcode == 100) { \n"
  420.   "         _sqlfound = false;\n"
  421.   "       } else { \n"
  422.   "          _sqlfound = true;\n"
  423.   "       } /* endif */ \n";
  424.  
  425.  const char GT[] =
  426.   "      if (sqlca.sqlcode == 100) { \n";
  427.  
  428.     if (NotFoundLabel.includes("_sqlfound")) {  // generate code to set boolean
  429.       fout << SB;
  430.     } else {   fout << "        " << MakeLabel(NotFoundLabel) << ";\n"
  431.                     << "    }\n";
  432.     } /* endif */
  433.                                                    
  434. }
  435.  
  436. IString MakeLabel(IString & theLabel) {
  437.    if (theLabel.isLike("*(*)")) {    // make it a function call
  438.       return theLabel+ ";\n";  
  439.    } else {
  440.       return "goto " + theLabel;
  441.    } /* endif */           
  442. }
  443.                                                    
  444.  
  445.  
  446.  
  447.  
  448.  
  449.  
  450.  
  451.  
  452.  
  453.  
  454.