开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
ndbsql.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：27k
源码类别：

MySQL数据库

开发平台：

Visual C++

ndbsql.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. /*******************************************************************************
  18.  *  NDB Cluster NDB SQL -- A simple SQL Command-line Interface
  19.  *
  20.  ******************************************************************************/
  22. #include <stdlib.h>
  23. #include <stdio.h>
  24. #include <string.h>
  25. #ifdef NDB_MACOSX
  26. #include <stdlib.h>
  27. #else
  28. #include <malloc.h>
  29. #endif
  30. #include <errno.h>
  31. #include <editline/editline.h>
  32. #include <NdbOut.hpp>
  33. #include <ctype.h>
  34. #include <wctype.h>
  36. #ifndef SQL_BLOB
  37. #define SQL_BLOB                30
  38. #endif
  39. #ifndef SQL_CLOB
  40. #define SQL_CLOB                40
  41. #endif
  43. /**************************************************************************
  44.  * ------------------------------------------------------------------------
  45.  *  MODULE:       Readline and string handling
  46.  * ------------------------------------------------------------------------
  47.  **************************************************************************/
  48. #define MAXBUF 2048
  49. static char* s_readBuf;
  50. static int s_bufSize = MAXBUF;
  52. static char*
  53. readSQL_File(FILE* inputFile)
  54. {
  55.   int c;
  56.   int i = 0;
  57.   if (feof(inputFile))
  58.     return 0;
  59.   while ((c = getc(inputFile)) != EOF) {
  60.     if (i == s_bufSize-1) {
  61.       s_bufSize *= 2;
  62.       s_readBuf = (char*)realloc(s_readBuf, s_bufSize);
  63.     }
  64.     s_readBuf[i] = c;
  65.     if (c == 'n')
  66.       break;
  67.     i++;
  68.   }
  69.   s_readBuf[i] = 0;
  70.   return s_readBuf;
  71. }
  72.   
  73. static char*
  74. readline_gets(const char* prompt, bool batchMode, FILE* inputFile)
  75. {
  76.   static char *line_read = (char *)NULL;
  77.   
  78.   // Disable the default file-name completion action of TAB
  79.   // rl_bind_key ('t', rl_insert);
  80.   
  81.   if (batchMode)
  82.     /* Read one line from a file. */
  83.     line_read = readSQL_File(inputFile);
  84.   else
  85.     /* Get a line from the user. */
  86.     line_read = readline(prompt);
  87.   
  88.   /* If the line has any text in it, save it in the history. */
  89.   if (!batchMode)
  90.     if (line_read && *line_read) add_history(line_read);
  91.     
  92.   return (line_read);
  93. }
  95. #ifdef NDB_WIN32
  96. extern "C" 
  97. {
  98.   char* readline(const char* prompt)
  99.   {
  100.     fputs(prompt, stdout);
  101.     return fgets(s_readBuf, MAXBUF, stdin);
  102.   }
  103.   void add_history(char*)
  104.   {
  105.   }
  106. }
  107. #endif
  109. bool emptyString(const char* s) {
  110.   if (s == NULL) {
  111.     return true;
  112.   }
  114.   for (unsigned int i = 0; i < strlen(s); ++i) {
  115.     if (! isspace(s[i])) {
  116.       return false;
  117.     }
  118.   }
  120.   return true;
  121. }
  123. /**************************************************************************
  124.  * ------------------------------------------------------------------------
  125.  *  MODULE:       ODBC Handling
  126.  * ------------------------------------------------------------------------
  127.  **************************************************************************/
  129. #include <sqlext.h>
  130. #include <stdio.h>
  131. #include <string.h>
  132. #ifdef NDB_MACOSX
  133. #include <stdlib.h>
  134. #else
  135. #include <malloc.h>
  136. #endif
  137. /**
  138.  * In the case where the user types a SELECT statement, 
  139.  * the function fetches and displays all rows of the result set.
  140.  *
  141.  * This example illustrates the use of GetDiagField to identify the
  142.  * type of SQL statement executed and, for SQL statements where the
  143.  * row count is defined on all implementations, the use of GetDiagField
  144.  * to obtain the row count.
  145.  */
  146. #define MAXCOLS 100
  147. #undef max
  148. #define max(a,b) ((a)>(b)?(a):(b))
  150. #define MAX_MESSAGE 500
  152. void getDiag(SQLSMALLINT type, SQLHANDLE handle, unsigned k, unsigned count) 
  153. {
  154.   char message[MAX_MESSAGE];
  155.   char state[6];
  156.   SQLINTEGER native;
  158.   SQLSMALLINT length = -1;
  159.   memset(message, 0, MAX_MESSAGE);
  160.   int ret = SQLGetDiagRec(type, handle, k, (SQLCHAR*)state, 
  161.   &native, (SQLCHAR*)message, MAX_MESSAGE, &length);
  162.   if (ret == SQL_NO_DATA) {
  163.     ndbout << "No error diagnostics available" << endl;
  164.     return;
  165.   }
  166.   ndbout << message << endl;
  168.   if (k <= count && ret != SQL_SUCCESS)
  169.     ndbout_c("SQLGetDiagRec %d of %d: return %d != SQL_SUCCESS", 
  170.      k, count, (int)ret);
  171.   if (k <= count && (SQLSMALLINT) strlen(message) != length)
  172.     ndbout_c("SQLGetDiagRec %d of %d: message length %d != %d", 
  173.      k, count, strlen(message), length);
  174.   if (k > count && ret != SQL_NO_DATA)
  175.     ndbout_c("SQLGetDiagRec %d of %d: return %d != SQL_NO_DATA", 
  176.      k, count, (int)ret);
  177. }
  179. int print_err(SQLSMALLINT handletype, SQLHDBC hdbc) {
  180.   getDiag(handletype, hdbc, 1, 1);
  182.   return -1;
  183. }
  186. /***************************************************************
  187.  * The following functions are given for completeness, but are
  188.  * not relevant for understanding the database processing
  189.  * nature of CLI
  190.  ***************************************************************/
  191. #define MAX_NUM_PRECISION 15
  192. /*#define max length of char string representation of no. as:
  193. = max(precision) + leading sign +E +expsign + max exp length
  194. = 15 +1 +1 +1 +2
  195. = 15 +5
  196. */
  197. #define MAX_NUM_STRING_SIZE (MAX_NUM_PRECISION + 5)
  199. int build_indicator_message(SQLCHAR *errmsg, SQLPOINTER *data,
  200.     SQLINTEGER collen, SQLINTEGER *outlen, 
  201.     SQLSMALLINT colnum) {
  202.   if (*outlen == SQL_NULL_DATA) {
  203.     (void)strcpy((char *)data, "NULL");
  204.     *outlen=4;
  205.   } else {
  206.     sprintf((char *)errmsg+strlen((char *)errmsg),
  207.     "%ld chars truncated, col %dn", *outlen-collen+1,
  208.     colnum);
  209.     *outlen=255;
  210.   }
  211.   return 0;
  212. }
  215. SQLINTEGER display_length(SQLSMALLINT coltype, SQLINTEGER collen, 
  216.   SQLCHAR *colname) {
  217.   switch (coltype) {
  218.   case SQL_VARCHAR:
  219.   case SQL_CHAR:
  220.   case SQL_VARBINARY:
  221.   case SQL_BINARY:
  222.   case SQL_BLOB:
  223.   case SQL_CLOB:
  224.   case SQL_BIT:
  225.     //case SQL_REF:
  226.     //case SQL_BIT_VARYING:
  227.     return(max(collen,(SQLINTEGER) strlen((char *)colname))+1);
  228.   case SQL_FLOAT:
  229.   case SQL_DOUBLE:
  230.   case SQL_NUMERIC:
  231.   case SQL_REAL:
  232.   case SQL_DECIMAL:
  233.     return(max(MAX_NUM_STRING_SIZE,strlen((char *)colname))+1);
  234.   case SQL_TYPE_DATE:
  235.   case SQL_TYPE_TIME:
  236.     //case SQL_TYPE_TIME_WITH_TIMEZONE:
  237.   case SQL_TYPE_TIMESTAMP:
  238.     //case SQL_TYPE_TIMESTAMP_WITH_TIMEZONE:
  239.   case SQL_INTERVAL_YEAR:
  240.   case SQL_INTERVAL_MONTH:
  241.   case SQL_INTERVAL_DAY:
  242.   case SQL_INTERVAL_HOUR:
  243.   case SQL_INTERVAL_MINUTE:
  244.   case SQL_INTERVAL_SECOND:
  245.   case SQL_INTERVAL_YEAR_TO_MONTH:
  246.   case SQL_INTERVAL_DAY_TO_HOUR:
  247.   case SQL_INTERVAL_DAY_TO_MINUTE:
  248.   case SQL_INTERVAL_DAY_TO_SECOND:
  249.   case SQL_INTERVAL_HOUR_TO_MINUTE:
  250.   case SQL_INTERVAL_HOUR_TO_SECOND:
  251.   case SQL_INTERVAL_MINUTE_TO_SECOND:
  252.     return(max(collen,(SQLINTEGER) strlen((char *)colname))+1);
  253.   case SQL_INTEGER:
  254.     //case SQL_BLOB_LOCATOR:
  255.     //case SQL_CLOB_LOCATOR:
  256.     //case SQL_UDT_LOCATOR:
  257.     //case SQL_ARRAY_LOCATOR:
  258.     return(max(11,strlen((char *)colname))+1);
  259.   case SQL_BIGINT:
  260.     return(max(21,strlen((char *)colname))+1);
  261.   case SQL_SMALLINT:
  262.     return(max(5,strlen((char *)colname))+1);
  263.   default:
  264.     (void)printf("Unknown datatype, %dn", coltype);
  265.     return(0);
  266.   }
  267. }
  269. struct Con {
  270.   const char* dsn;
  271.   SQLHENV henv;
  272.   SQLHDBC hdbc;
  273.   Con(const char* _dsn) :
  274.     dsn(_dsn), henv(SQL_NULL_HANDLE), hdbc(SQL_NULL_HANDLE) {}
  275. };
  277. static int
  278. do_connect(Con& con)
  279. {
  280.   int ret;
  282.   // allocate an environment handle
  283.   ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &con.henv);
  284.   if (ret != SQL_SUCCESS)
  285.     return -1;
  286.   
  287.   // set odbc version (required)
  288.   ret = SQLSetEnvAttr(con.henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, 0); 
  289.   if (ret != SQL_SUCCESS)
  290.     return -1;
  291.   
  292.   // allocate a connection handle
  293.   ret = SQLAllocHandle(SQL_HANDLE_DBC, con.henv, &con.hdbc);
  294.   if (ret != SQL_SUCCESS)
  295.     return -1;
  296.   
  297.   // connect to database
  298.   SQLCHAR szConnStrOut[256];
  299.   SQLSMALLINT cbConnStrOut;
  300.   ret = SQLDriverConnect(con.hdbc, 0, (SQLCHAR*)con.dsn, SQL_NTS,
  301.       szConnStrOut, sizeof(szConnStrOut), &cbConnStrOut, SQL_DRIVER_COMPLETE);
  302.   if (ret != SQL_SUCCESS) {
  303.     ndbout << "Connection failure: Could not connect to database" << endl;
  304.     print_err(SQL_HANDLE_DBC, con.hdbc);
  305.     return -1;
  306.   }  
  308.   return 0;
  309. }
  311. static int
  312. do_disconnect(Con& con)
  313. {
  314.   // disconnect from database
  315.   SQLDisconnect(con.hdbc);
  317.   // free connection handle
  318.   SQLFreeHandle(SQL_HANDLE_DBC, con.hdbc);
  319.   con.hdbc = SQL_NULL_HANDLE;
  321.   // free environment handle
  322.   SQLFreeHandle(SQL_HANDLE_ENV, con.henv);
  323.   con.henv = SQL_NULL_HANDLE;
  325.   return 0;
  326. }
  328. static int
  329. get_autocommit(Con& con)
  330. {
  331.   int ret;
  332.   SQLUINTEGER v;
  333.   ret = SQLGetConnectAttr(con.hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)&v, SQL_IS_UINTEGER, 0);
  334.   if (ret != SQL_SUCCESS) {
  335.     ndbout << "Get autocommit failed" << endl;
  336.     print_err(SQL_HANDLE_DBC, con.hdbc);
  337.     return -1;
  338.   }
  339.   return v;
  340. }
  342. static int
  343. set_autocommit(Con& con, SQLUINTEGER v)
  344. {
  345.   int ret;
  346.   ret = SQLSetConnectAttr(con.hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)v, SQL_IS_UINTEGER);
  347.   if (ret != SQL_SUCCESS) {
  348.     ndbout << "Set autocommit failed" << endl;
  349.     print_err(SQL_HANDLE_DBC, con.hdbc);
  350.     return -1;
  351.   }
  352.   return 0;
  353. }
  355. static int
  356. do_commit(Con& con)
  357. {
  358.   int ret = SQLEndTran(SQL_HANDLE_DBC, con.hdbc, SQL_COMMIT);
  359.   if (ret != SQL_SUCCESS) {
  360.     ndbout << "Commit failed" << endl;
  361.     print_err(SQL_HANDLE_DBC, con.hdbc);
  362.     return -1;
  363.   }
  364.   return 0;
  365. }
  367. static int
  368. do_rollback(Con& con)
  369. {
  370.   int ret = SQLEndTran(SQL_HANDLE_DBC, con.hdbc, SQL_ROLLBACK);
  371.   if (ret != SQL_SUCCESS) {
  372.     ndbout << "Rollback failed" << endl;
  373.     print_err(SQL_HANDLE_DBC, con.hdbc);
  374.     return -1;
  375.   }
  376.   return 0;
  377. }
  379. static int
  380. do_stmt(Con& con, const char *sqlstr)
  381. {
  382.   SQLHSTMT hstmt;
  383.   SQLCHAR errmsg[256];
  384.   SQLCHAR colname[32];
  385.   SQLSMALLINT coltype;
  386.   SQLSMALLINT colnamelen;
  387.   SQLSMALLINT nullable;
  388.   SQLUINTEGER collen[MAXCOLS];
  389.   SQLSMALLINT scale;
  390.   SQLINTEGER outlen[MAXCOLS];
  391.   SQLCHAR *data[MAXCOLS];
  392.   SQLSMALLINT nresultcols = 0;
  393.   SQLINTEGER rowcount;
  394.   SQLINTEGER stmttype;
  395.   SQLRETURN rc;
  397.   /* allocate a statement handle */
  398.   SQLAllocHandle(SQL_HANDLE_STMT, con.hdbc, &hstmt);
  400.   /* execute the SQL statement */
  401.   rc = SQLExecDirect(hstmt, (SQLCHAR*)sqlstr, SQL_NTS);
  402.   if (rc == SQL_ERROR) {
  403.     ndbout << "Operation failed" << endl;
  404.     print_err(SQL_HANDLE_STMT, hstmt);
  405.     return -1;
  406.   }
  407.   if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO && rc != SQL_NO_DATA_FOUND) {
  408.     ndbout << "Operation returned unknown code " << rc << endl;
  409.     return -1;
  410.   }
  412.   /* see what kind of statement it was */
  413.   SQLGetDiagField(SQL_HANDLE_STMT, hstmt, 0,
  414.   SQL_DIAG_DYNAMIC_FUNCTION_CODE,
  415.   (SQLPOINTER)&stmttype, SQL_IS_INTEGER, (SQLSMALLINT *)NULL);
  417.   switch (stmttype) {
  418.     /* SELECT statement */
  419.   case SQL_DIAG_SELECT_CURSOR:
  420.     /* determine number of result columns */
  421.     SQLNumResultCols(hstmt, &nresultcols);
  423.     /***********************
  424.      * Display column names 
  425.      ***********************/
  426.     /* Print vertical divider */
  427.     printf("|");
  428.     for (int i=0; i<nresultcols; i++) {
  429.       SQLDescribeCol(hstmt, i+1, colname, sizeof(colname),
  430.      &colnamelen, &coltype, &collen[i], &scale, &nullable);
  431.       collen[i] = display_length(coltype, collen[i], colname);
  432.       for (SQLUINTEGER j=0; j<collen[i]; j++) printf("-");
  433.       printf("--+");
  434.     }
  435.     printf("n");
  437.     printf("|");
  438.     for (int i=0; i<nresultcols; i++) {
  439.       SQLDescribeCol(hstmt, i+1, colname, sizeof(colname),
  440.      &colnamelen, &coltype, &collen[i], &scale, &nullable);
  441.       
  442.       /* assume there is a display_length function which
  443.  computes correct length given the data type */
  444.       collen[i] = display_length(coltype, collen[i], colname);
  445.       (void)printf(" %*.*s |", (int)collen[i], (int)collen[i], (char *)colname);
  446.       
  447.       /* allocate memory to bind column */
  448.       data[i] = (SQLCHAR *) malloc(collen[i]);
  449.       if (data[i] == NULL) {
  450. ndbout << "Failed to allocate malloc memory in NDB SQL program" 
  451.        << endl;
  452. exit(-1);
  453.       }
  454.       
  455.       /* bind columns to program vars, converting all types to CHAR */
  456.       SQLBindCol(hstmt, i+1, SQL_C_CHAR, data[i], collen[i], &outlen[i]);
  457.     }
  458.     printf("n");
  460.     /* Print vertical divider */
  461.     printf("|");
  462.     for (int i=0; i<nresultcols; i++) {
  463.       SQLDescribeCol(hstmt, i+1, colname, sizeof(colname),
  464.      &colnamelen, &coltype, &collen[i], &scale, &nullable);
  465.       collen[i] = display_length(coltype, collen[i], colname);
  466.       for (SQLUINTEGER j=0; j<collen[i]; j++) printf("-");
  467.       printf("--+");
  468.     }
  469.     printf("n");
  471.     /**********************
  472.      * Display result rows 
  473.      **********************/
  474.     {
  475.       int no_of_rows_fetched=0;
  476.       while (1) {
  477. rc=SQLFetch(hstmt);
  478. errmsg[0] = '';
  479. if (rc == SQL_ERROR) {
  480.   print_err(SQL_HANDLE_STMT, hstmt);
  481.   break;
  482. }
  483. if (rc == SQL_NO_DATA) break;
  484. if (rc == SQL_SUCCESS) {
  485.   printf("|");
  486.   for (int i=0; i<nresultcols; i++) {
  487.     if (outlen[i] == SQL_NULL_DATA
  488. || outlen[i] >= (SQLINTEGER) collen[i])
  489.       build_indicator_message(errmsg,
  490.       (SQLPOINTER *)data[i], collen[i],
  491.       &outlen[i], i);
  492.     (void)printf(" %*.*s |", (int)collen[i], (int)collen[i],
  493.  (char *)data[i]);
  494.   } 
  495.   /* print any truncation messages */
  496.   (void)printf("n%s", (char *)errmsg);
  497. } else if (rc == SQL_SUCCESS_WITH_INFO) {
  498.   printf("|");
  499.   for (int i=0; i<nresultcols; i++) {
  500.     if (outlen[i] == SQL_NULL_DATA
  501. || outlen[i] >= (SQLINTEGER) collen[i])
  502.       build_indicator_message(errmsg,
  503.       (SQLPOINTER *)data[i], collen[i],
  504.       &outlen[i], i);
  505.     (void)printf(" %*.*s |", (int)collen[i], (int)collen[i],
  506.  (char *)data[i]);
  507.   } /* for all columns in this row */
  508.   /* print any truncation messages */
  509.   (void)printf("n%s", (char *)errmsg);
  510. }
  511. no_of_rows_fetched++;
  512.       } /* while rows to fetch */
  513.       /* Print vertical divider */
  514.       printf("|");
  515.       for (int i=0; i<nresultcols; i++) {
  516. SQLDescribeCol(hstmt, i+1, colname, sizeof(colname),
  517.        &colnamelen, &coltype, &collen[i], &scale, &nullable);
  518. collen[i] = display_length(coltype, collen[i], colname);
  519. for (SQLUINTEGER j=0; j<collen[i]; j++) printf("-");
  520. printf("--+");
  521.       }
  522.       printf("n");
  523.       ndbout << no_of_rows_fetched << " rows fetched" << endl;
  524.     }
  525.     SQLCloseCursor(hstmt);
  526.     break;
  527.     /* searched DELETE, INSERT or searched UPDATE statement */
  528.   case SQL_DIAG_DELETE_WHERE:
  529.   case SQL_DIAG_INSERT:
  530.   case SQL_DIAG_UPDATE_WHERE:
  531.     /* check rowcount */
  532.     SQLRowCount(hstmt, (SQLINTEGER*)&rowcount);
  533.     ndbout << (int)rowcount << " rows affected" << endl;
  534.     break;
  535.     /* other statements */
  536.   case SQL_DIAG_ALTER_TABLE:
  537.   case SQL_DIAG_CREATE_TABLE:
  538.   case SQL_DIAG_CREATE_VIEW:
  539.   case SQL_DIAG_DROP_TABLE:
  540.   case SQL_DIAG_DROP_VIEW:
  541.   case SQL_DIAG_CREATE_INDEX:
  542.   case SQL_DIAG_DROP_INDEX:
  543.   case SQL_DIAG_DYNAMIC_DELETE_CURSOR:
  544.   case SQL_DIAG_DYNAMIC_UPDATE_CURSOR:
  545.   case SQL_DIAG_GRANT:
  546.   case SQL_DIAG_REVOKE:
  547.     ndbout << "Operation successful" << endl;
  548.     break;
  549.     /* implementation-defined statement */
  550.   default:
  551.     (void)printf("Unknown Statement type=%ldn", stmttype);
  552.     break;
  553.   }
  555.   /* free data buffers */
  556.   for (int i=0; i<nresultcols; i++) {
  557.     (void)free(data[i]);
  558.   }
  559.   
  560.   SQLFreeHandle(SQL_HANDLE_STMT, hstmt);  // free statement handle 
  561.   return(0);
  562. }
  564. /**************************************************************************
  565.  * ------------------------------------------------------------------------
  566.  *  MODULE:       Help
  567.  * ------------------------------------------------------------------------
  568.  **************************************************************************/
  570. void print_help() {
  571.   ndbout << "Commands:" << endl
  572.  << "set                Print currect settings" << endl
  573.  << "set trace N        Set NDB ODBC trace level to N (0-5)" << endl
  574.  << "set autocommit on  Commit each statement (default)" << endl
  575.  << "set autocommit off Use explicit commit/rollback - may time out!" << endl
  576.  << "commit             Commit changes to database" << endl
  577.  << "rollback           Rollback (undo) any changes" << endl
  578.          << "whenever sqlerror  Define action: exit or continue (default)" << endl
  579.  << endl
  580.  << "help               Print this help" << endl
  581.  << "help create        Print create table examples" << endl
  582.  << "help insert        Print insert examples" << endl
  583.  << "help select        Print select examples" << endl
  584.  << "help delete        Print delete examples" << endl
  585.  << "help update        Print update examples" << endl
  586.  << "help virtual       Print help on NDB ODBC virtual tables" << endl
  587.  << "list tables        Lists all table names" << endl
  588.  << endl
  589.  << "All other commands are sent to the NDB ODBC SQL executor" 
  590.  << endl << endl;
  591. }
  593. void print_help_create() {  
  594.   ndbout << "Create Table Examples" << endl << endl 
  595.  << "create table t ( a integer not null, b char(20) not null," << endl
  596.  << "                 c float, primary key(a, b) )" << endl
  597.  << "create table t ( ndb$tid bigint unsigned primary key," << endl
  598.  << "                 b char(20) not null, c float )" << endl
  599.  << "create table t ( a int auto_increment primary key," << endl
  600.  << "                 b char(20) not null, c float )" << endl
  601.  << "create table t ( a int primary key," << endl
  602.  << "                 b int default 100 )" << endl
  603.  << endl 
  604.  << "For more information read NDB Cluster ODBC Manual."
  605.  << endl;
  606. }
  608. void print_help_insert() {  
  609.   ndbout << "Insert Examples" << endl << endl 
  610.  << "insert into t(a, c) values (123, 'abc')" << endl
  611.  << "insert into t1(a, c) select a + 10 * b, c from t2" << endl
  612.  << "insert into t values(null, 'abc', 1.23)" << endl
  613.  << "insert into t(b, c) values('abc', 1.23)" << endl
  614.  << endl 
  615.  << "For more information read NDB Cluster ODBC Manual."
  616.  << endl;
  617. }
  619. void print_help_select() {  
  620.   ndbout << "Select Examples" << endl << endl 
  621.  << "select a + b * c from t where a <= b + c and (b > c or c > 10)"
  622.  << endl
  623.  << "select a.x, b.y, c.z from t1 a, t2 b, t2 c where a.x + b.y < c.z" 
  624.  << endl
  625.  << "select * from t1, t2 where a1 > 5 order by b1 + b2, c1 desc" 
  626.  << endl
  627.  << "select count(*), max(a), 1 + sum(b) + avg(c * d) from t" << endl
  628.  << "select * from t where a < 10 or b > 10" << endl
  629.  << "select * from t where pk = 5 and b > 10" << endl
  630.  << "select * from t1, t2, t3 where t1.pk = t2.x and t2.pk = t3.y" 
  631.  << endl  << endl 
  632.  << "For more information read NDB Cluster ODBC Manual."
  633.  << endl;
  634. }
  636. void print_help_update() {  
  637.   ndbout << "Update and Delete Examples" << endl << endl 
  638.  << "update t set a = b + 5, c = d where c > 10" << endl
  639.  << "update t set a = b + 5, c = d where pk = 5 and c > 10" << endl
  640.  << "update t set a = 5, c = 7 where pk = 5" << endl
  641.  << "delete from t where c > 10" << endl
  642.  << "delete from t where pk = 5 and c > 10" << endl
  643.  << "delete from t where pk = 5" << endl 
  644.  << endl
  645.  << "For more information read NDB Cluster ODBC Manual."
  646.  << endl;
  647. }
  649. void print_help_virtual() {  
  650.   ndbout << "Virtual tables" << endl << endl 
  651.  << "* DUAL" 
  652.  << "  a 1-row table - example: select SYSDATE from DUAL" << endl
  653.  << "* ODBC$TYPEINFO" << endl
  654.  << "  corresponds to SQLGetTypeInfo" << endl
  655.  << "* ODBC$TABLES" << endl
  656.  << "  corresponds to SQLTables (ordered by NDB table id)" << endl
  657.  << "* ODBC$COLUMNS" << endl
  658.  << "  corresponds to SQLColumns (ordered by NDB table id)" << endl
  659.  << "* ODBC$PRIMARYKEYS" << endl
  660.  << "  corresponds to SQLPrimaryKeys (ordered by NDB table id)" << endl
  661.  << endl
  662.  << "For more information read NDB Cluster ODBC Manual."
  663.  << endl;
  664. }
  666. /**************************************************************************
  667.  * ------------------------------------------------------------------------
  668.  *  MODULE:       Main
  669.  * ------------------------------------------------------------------------
  670.  **************************************************************************/
  672. int main(int argc, const char** argv)
  673. {
  674.   ndb_init();
  675.   const char* usage = "Usage: ndbsql [-h] [-d dsn] [-f file] [stmt]n-h helpn-d <database name or connect string>n-f <file name> batch modenstmt single SQL statementn";
  676.   const char* dsn = "TEST_DB";
  677.   bool helpFlg = false, batchMode = false;
  678.   const char* fileName = 0;
  679.   FILE* inputFile = stdin;
  680.   const char* singleStmt = 0;
  682.   s_readBuf = (char*)malloc(s_bufSize);
  683.   while (++argv, --argc > 0) {
  684.     const char* arg = argv[0];
  685.     if (arg[0] != '-')
  686.       break;
  687.     if (strcmp(arg, "-d") == 0) {
  688.       if (++argv, --argc > 0) {
  689.         dsn = argv[0];
  690.         continue;
  691.       }
  692.     }
  693.     if (strcmp(arg, "-h") == 0) {
  694.       helpFlg = true;
  695.       continue;
  696.     }
  697.     if (strcmp(arg, "-f") == 0) {
  698.       if (++argv, --argc > 0) {
  699. fileName = argv[0];
  700. continue;
  701.       }
  702.     }
  703.     ndbout << usage;
  704.     return 1;
  705.   }
  706.   if (helpFlg) {
  707.     ndbout << usage << "n";
  708.     print_help();
  709.     return 0;
  710.   }
  711.   if (fileName != 0) {
  712.     if (argc > 0) {
  713.       ndbout << usage;
  714.       return 1;
  715.     }
  716.     if ((inputFile = fopen(fileName, "r")) == 0) {
  717.       ndbout << "Could not read file " << fileName << ": " << strerror(errno) << endl;
  718.       return 1;
  719.     }
  720.     batchMode = true;
  721.   }
  722.   if (argc > 0) {
  723.     singleStmt = argv[0];
  724.     batchMode = true;
  725.   }
  726.   if (! batchMode)
  727.     ndbout << "NDB Cluster NDB SQL -- A simple SQL Command-line Interfacenn";
  729.   Con con(dsn);
  730.   if (do_connect(con) < 0)
  731.     return 1;
  732.   if (! batchMode)
  733.     ndbout << "Terminate SQL statements with a semi-colon ';'n";
  735.   char* line = 0;
  736.   char* line2 = 0;
  737.   char* line3 = 0;
  738.   unsigned lineno = 0;
  739.   bool has_semi;
  740.   bool exit_on_error = false;
  741.   int exit_code = 0;
  742.   while (1) {
  743.     free(line);
  744.     line = 0;
  745.     lineno = 0;
  747. more_lines:
  748.     free(line2);
  749.     free(line3);
  750.     line2 = line3 = 0;
  751.     lineno++;
  752.     has_semi = false;
  753.     char prompt[20];
  754.     if (lineno == 1)
  755.       strcpy(prompt, "SQL> ");
  756.     else
  757.       sprintf(prompt, "%4d ", lineno);
  758.     if (singleStmt != 0) {
  759.       line = strdup(singleStmt);
  760.       int n = strlen(line);
  761.       while (n > 0 && isspace(line[n - 1])) {
  762.         line[--n] = 0;
  763.       }
  764.       if (n > 0 && line[n - 1] == ';')
  765.         line[n - 1] = 0;
  766.       has_semi = true;  // regardless
  767.     } else {
  768.       const char *line1 = readline_gets(prompt, batchMode, inputFile); 
  769.       if (line1 != 0) {
  770.         if (line == 0)
  771.           line = strdup(line1);
  772.         else {
  773.           line = (char*)realloc(line, strlen(line) + 1 + strlen(line1) + 1);
  774.           strcat(line, "n");
  775.           strcat(line, line1);
  776.         }
  777.         if (batchMode)
  778.           ndbout << prompt << line1 << endl;
  779.       } else {
  780.         if (! batchMode)
  781.           ndbout << endl;
  782.         if (line != 0)
  783.           ndbout << "Ignored unterminated SQL statement" << endl;
  784.         break;
  785.       }
  786.     }
  788.     line2 = (char*)malloc(strlen(line) + 1);
  789.     {
  790.       char* p = line2;
  791.       char* q = line;
  792.       bool str = false;
  793.       while (*q != 0) {
  794.         if (*q == ''') {
  795.           str = !str;
  796.           *p++ = *q++;
  797.         } else if (!str && *q == '-' && *(q + 1) == '-') {
  798.           while (*q != 0 && *q != 'n')
  799.             q++;
  800.         } else
  801.           *p++ = *q++;
  802.       }
  803.       *p = 0;
  804.       int n = strlen(line2);
  805.       while (n > 0 && isspace(line2[n - 1]))
  806.         line2[--n] = 0;
  807.       if (n > 0 && line2[n - 1] == ';') {
  808.         line2[--n] = 0;
  809.         has_semi = true;
  810.       }
  811.     }
  812.     line3 = strdup(line2);
  813.     char* tok[10];
  814.     int ntok = 0;
  815.     tok[ntok] = strtok(line3, " ");
  816.     while (tok[ntok] != 0) {
  817.       ntok++;
  818.       if (ntok == 10)
  819.         break;
  820.       tok[ntok] = strtok(0, " ");
  821.     }
  822.     if (ntok == 0)
  823.       continue;
  825.     if (!strcasecmp(tok[0], "help") || !strcmp(tok[0], "?")) {
  826.       if (ntok != 2)
  827. print_help();
  828.       else if (!strcasecmp(tok[1], "create"))
  829. print_help_create();
  830.       else if (!strcasecmp(tok[1], "insert"))
  831. print_help_insert();
  832.       else if (strcasecmp(tok[1], "select"))
  833. print_help_select();
  834.       else if (!strcasecmp(tok[1], "delete"))
  835. print_help_update();
  836.       else if (!strcasecmp(tok[1], "update"))
  837. print_help_update();
  838.       else if (!strcasecmp(tok[1], "virtual"))
  839. print_help_virtual();
  840.       else
  841. print_help();
  842.       continue;
  843.     }
  845.     if (!strcasecmp(tok[0], "list")) {
  846.       if (ntok == 2 && !strcasecmp(tok[1], "tables")) {
  847. free(line2);
  848. line2 = strdup("SELECT TABLE_NAME FROM ODBC$TABLES");
  849.         has_semi = true;
  850.       } else {
  851.         ndbout << "Invalid list option - try help" << endl;
  852.         continue;
  853.       }
  854.     }
  856.     if (ntok == 1 && !strcasecmp(tok[0], "quit"))
  857.       break;
  858.     if (ntok == 1 && !strcasecmp(tok[0], "exit"))
  859.       break;
  860.     if (ntok == 1 && !strcasecmp(tok[0], "bye"))
  861.       break;
  863.     if (!strcasecmp(tok[0], "set")) {
  864.       if (ntok == 1) {
  865. char* p;
  866. p = getenv("NDB_ODBC_TRACE");
  867. ndbout << "Trace level is " << (p ? atoi(p) : 0) << endl;
  868. int ret = get_autocommit(con);
  869. if (ret != -1)
  870.   ndbout << "Autocommit is " << (ret == SQL_AUTOCOMMIT_ON ? "on" : "off") << endl;
  871.       } else if (ntok == 3 && !strcasecmp(tok[1], "trace")) {
  872. static char env[40];
  873. int n = tok[2] ? atoi(tok[2]) : 0;
  874. sprintf(env, "NDB_ODBC_TRACE=%d", n);
  875. putenv(env);
  876. ndbout << "Trace level set to " << n << endl;
  877.       } else if (ntok == 3 && !strcasecmp(tok[1], "autocommit")) {
  878. if (tok[2] && !strcasecmp(tok[2], "on")) {
  879.   int ret = set_autocommit(con, SQL_AUTOCOMMIT_ON);
  880.   if (ret != -1)
  881.     ndbout << "Autocommit set to ON" << endl;
  882. } else if (tok[2] && !strcasecmp(tok[2], "off")) {
  883.   int ret = set_autocommit(con, SQL_AUTOCOMMIT_OFF);
  884.   if (ret != -1)
  885.     ndbout << "Autocommit set to OFF - transaction may time out" << endl;
  886. } else {
  887.   ndbout << "Invalid autocommit option - try help" << endl;
  888. }
  889.       } else {
  890. ndbout << "Invalid set command - try help" << endl;
  891.       }
  892.       continue;
  893.     }
  895.     if (ntok >= 2 &&
  896.         !strcasecmp(tok[0], "whenever") && !strcasecmp(tok[1], "sqlerror")) {
  897.       if (ntok == 3 && !strcasecmp(tok[2], "exit"))
  898.         exit_on_error = true;
  899.       else if (ntok == 3 && !strcasecmp(tok[2], "continue"))
  900.         exit_on_error = false;
  901.       else {
  902.         ndbout << "Invalid whenever clause - try help" << endl;
  903.       }
  904.       continue;
  905.     }
  907.     if (!strcasecmp(tok[0], "commit")) {
  908.       if (ntok == 1) {
  909.         if (do_commit(con) != -1)
  910.           ndbout << "Commit done" << endl;
  911.         else {
  912.           exit_code = 1;
  913.           if (exit_on_error) {
  914.             ndbout << "Exit on error" << endl;
  915.             break;
  916.           }
  917.         }
  918.       } else {
  919.         ndbout << "Invalid commit command - try help" << endl;
  920.       }
  921.       continue;
  922.     }
  924.     if (!strcasecmp(tok[0], "rollback")) {
  925.       if (ntok == 1) {
  926.         if (do_rollback(con) != -1)
  927.           ndbout << "Rollback done" << endl;
  928.         else {
  929.           exit_code = 1;
  930.           if (exit_on_error) {
  931.             ndbout << "Exit on error" << endl;
  932.             break;
  933.           }
  934.         }
  935.       } else {
  936.         ndbout << "Invalid commit command - try help" << endl;
  937.       }
  938.       continue;
  939.     }
  941.     if (! has_semi)
  942.       goto more_lines;
  943.     if (do_stmt(con, line2) != 0) {
  944.       exit_code = 1;
  945.       if (exit_on_error) {
  946.         ndbout << "Exit on error" << endl;
  947.         break;
  948.       }
  949.     }
  950.     if (singleStmt)
  951.       break;
  952.   }
  953.   do_disconnect(con);
  954.   return exit_code;
  955. }
  957. // vim: set sw=2 et: