src/complete.c

   1 /*
   2 ** 2001 September 15
   3 **
   4 ** The author disclaims copyright to this source code.  In place of
   5 ** a legal notice, here is a blessing:
   6 **
   7 **    May you do good and not evil.
   8 **    May you find forgiveness for yourself and forgive others.
   9 **    May you share freely, never taking more than you give.
  10 **
  11 *************************************************************************
  12 ** An tokenizer for SQL
  13 **
  14 ** This file contains C code that implements the sqlite3_complete() API.
  15 ** This code used to be part of the tokenizer.c source file.  But by
  16 ** separating it out, the code will be automatically omitted from
  17 ** static links that do not use it.
  18 */
  19 #include "sqliteInt.h"
  20 #ifndef SQLITE_OMIT_COMPLETE
  21
  22 /*
  23 ** This is defined in tokenize.c.  We just have to import the definition.
  24 */
  25 #ifndef SQLITE_AMALGAMATION
  26 #ifdef SQLITE_ASCII
  27 #define IdChar(C)  ((sqlite3CtypeMap[(unsigned char)C]&0x46)!=0)
  28 #endif
  29 #ifdef SQLITE_EBCDIC
  30 extern const char sqlite3IsEbcdicIdChar[];
  31 #define IdChar(C)  (((c=C)>=0x42 && sqlite3IsEbcdicIdChar[c-0x40]))
  32 #endif
  33 #endif /* SQLITE_AMALGAMATION */
  34
  35
  36 /*
  37 ** Token types used by the sqlite3_complete() routine.  See the header
  38 ** comments on that procedure for additional information.
  39 */
  40 #define tkSEMI    0
  41 #define tkWS      1
  42 #define tkOTHER   2
  43 #ifndef SQLITE_OMIT_TRIGGER
  44 #define tkEXPLAIN 3
  45 #define tkCREATE  4
  46 #define tkTEMP    5
  47 #define tkTRIGGER 6
  48 #define tkEND     7
  49 #endif
  50
  51 /*
  52 ** Return TRUE if the given SQL string ends in a semicolon.
  53 **
  54 ** Special handling is require for CREATE TRIGGER statements.
  55 ** Whenever the CREATE TRIGGER keywords are seen, the statement
  56 ** must end with ";END;".
  57 **
  58 ** This implementation uses a state machine with 8 states:
  59 **
  60 **   (0) INVALID   We have not yet seen a non-whitespace character.
  61 **
  62 **   (1) START     At the beginning or end of an SQL statement.  This routine
  63 **                 returns 1 if it ends in the START state and 0 if it ends
  64 **                 in any other state.
  65 **
  66 **   (2) NORMAL    We are in the middle of statement which ends with a single
  67 **                 semicolon.
  68 **
  69 **   (3) EXPLAIN   The keyword EXPLAIN has been seen at the beginning of
  70 **                 a statement.
  71 **
  72 **   (4) CREATE    The keyword CREATE has been seen at the beginning of a
  73 **                 statement, possibly preceded by EXPLAIN and/or followed by
  74 **                 TEMP or TEMPORARY
  75 **
  76 **   (5) TRIGGER   We are in the middle of a trigger definition that must be
  77 **                 ended by a semicolon, the keyword END, and another semicolon.
  78 **
  79 **   (6) SEMI      We've seen the first semicolon in the ";END;" that occurs at
  80 **                 the end of a trigger definition.
  81 **
  82 **   (7) END       We've seen the ";END" of the ";END;" that occurs at the end
  83 **                 of a trigger definition.
  84 **
  85 ** Transitions between states above are determined by tokens extracted
  86 ** from the input.  The following tokens are significant:
  87 **
  88 **   (0) tkSEMI      A semicolon.
  89 **   (1) tkWS        Whitespace.
  90 **   (2) tkOTHER     Any other SQL token.
  91 **   (3) tkEXPLAIN   The "explain" keyword.
  92 **   (4) tkCREATE    The "create" keyword.
  93 **   (5) tkTEMP      The "temp" or "temporary" keyword.
  94 **   (6) tkTRIGGER   The "trigger" keyword.
  95 **   (7) tkEND       The "end" keyword.
  96 **
  97 ** Whitespace never causes a state transition and is always ignored.
  98 ** This means that a SQL string of all whitespace is invalid.
  99 **
 100 ** If we compile with SQLITE_OMIT_TRIGGER, all of the computation needed
 101 ** to recognize the end of a trigger can be omitted.  All we have to do
 102 ** is look for a semicolon that is not part of an string or comment.
 103 */
 104 int sqlite3_complete(const char *zSql){
 105   u8 state = 0;   /* Current state, using numbers defined in header comment */
 106   u8 token;       /* Value of the next token */
 107
 108 #ifndef SQLITE_OMIT_TRIGGER
 109   /* A complex statement machine used to detect the end of a CREATE TRIGGER
 110   ** statement.  This is the normal case.
 111   */
 112   static const u8 trans[8][8] = {
 113                      /* Token:                                                */
 114      /* State:       **  SEMI  WS  OTHER  EXPLAIN  CREATE  TEMP  TRIGGER  END */
 115      /* 0 INVALID: */ {    1,  0,     2,       3,      4,    2,       2,   2, },
 116      /* 1   START: */ {    1,  1,     2,       3,      4,    2,       2,   2, },
 117      /* 2  NORMAL: */ {    1,  2,     2,       2,      2,    2,       2,   2, },
 118      /* 3 EXPLAIN: */ {    1,  3,     3,       2,      4,    2,       2,   2, },
 119      /* 4  CREATE: */ {    1,  4,     2,       2,      2,    4,       5,   2, },
 120      /* 5 TRIGGER: */ {    6,  5,     5,       5,      5,    5,       5,   5, },
 121      /* 6    SEMI: */ {    6,  6,     5,       5,      5,    5,       5,   7, },
 122      /* 7     END: */ {    1,  7,     5,       5,      5,    5,       5,   5, },
 123   };
 124 #else
 125   /* If triggers are not supported by this compile then the statement machine
 126   ** used to detect the end of a statement is much simpler
 127   */
 128   static const u8 trans[3][3] = {
 129                      /* Token:           */
 130      /* State:       **  SEMI  WS  OTHER */
 131      /* 0 INVALID: */ {    1,  0,     2, },
 132      /* 1   START: */ {    1,  1,     2, },
 133      /* 2  NORMAL: */ {    1,  2,     2, },
 134   };
 135 #endif /* SQLITE_OMIT_TRIGGER */
 136
 137 #ifdef SQLITE_ENABLE_API_ARMOR
 138   if( zSql==0 ){
 139     (void)SQLITE_MISUSE_BKPT;
 140     return 0;
 141   }
 142 #endif
 143
 144   while( *zSql ){
 145     switch( *zSql ){
 146       case ';': {  /* A semicolon */
 147         token = tkSEMI;
 148         break;
 149       }
 150       case ' ':
 151       case '\r':
 152       case '\t':
 153       case '\n':
 154       case '\f': {  /* White space is ignored */
 155         token = tkWS;
 156         break;
 157       }
 158       case '/': {   /* C-style comments */
 159         if( zSql[1]!='*' ){
 160           token = tkOTHER;
 161           break;
 162         }
 163         zSql += 2;
 164         while( zSql[0] && (zSql[0]!='*' || zSql[1]!='/') ){ zSql++; }
 165         if( zSql[0]==0 ) return 0;
 166         zSql++;
 167         token = tkWS;
 168         break;
 169       }
 170       case '-': {   /* SQL-style comments from "--" to end of line */
 171         if( zSql[1]!='-' ){
 172           token = tkOTHER;
 173           break;
 174         }
 175         while( *zSql && *zSql!='\n' ){ zSql++; }
 176         if( *zSql==0 ) return state==1;
 177         token = tkWS;
 178         break;
 179       }
 180       case '[': {   /* Microsoft-style identifiers in [...] */
 181         zSql++;
 182         while( *zSql && *zSql!=']' ){ zSql++; }
 183         if( *zSql==0 ) return 0;
 184         token = tkOTHER;
 185         break;
 186       }
 187       case '`':     /* Grave-accent quoted symbols used by MySQL */
 188       case '"':     /* single- and double-quoted strings */
 189       case '\'': {
 190         int c = *zSql;
 191         zSql++;
 192         while( *zSql && *zSql!=c ){ zSql++; }
 193         if( *zSql==0 ) return 0;
 194         token = tkOTHER;
 195         break;
 196       }
 197       default: {
 198 #ifdef SQLITE_EBCDIC
 199         unsigned char c;
 200 #endif
 201         if( IdChar((u8)*zSql) ){
 202           /* Keywords and unquoted identifiers */
 203           int nId;
 204           for(nId=1; IdChar(zSql[nId]); nId++){}
 205 #ifdef SQLITE_OMIT_TRIGGER
 206           token = tkOTHER;
 207 #else
 208           switch( *zSql ){
 209             case 'c': case 'C': {
 210               if( nId==6 && sqlite3StrNICmp(zSql, "create", 6)==0 ){
 211                 token = tkCREATE;
 212               }else{
 213                 token = tkOTHER;
 214               }
 215               break;
 216             }
 217             case 't': case 'T': {
 218               if( nId==7 && sqlite3StrNICmp(zSql, "trigger", 7)==0 ){
 219                 token = tkTRIGGER;
 220               }else if( nId==4 && sqlite3StrNICmp(zSql, "temp", 4)==0 ){
 221                 token = tkTEMP;
 222               }else if( nId==9 && sqlite3StrNICmp(zSql, "temporary", 9)==0 ){
 223                 token = tkTEMP;
 224               }else{
 225                 token = tkOTHER;
 226               }
 227               break;
 228             }
 229             case 'e':  case 'E': {
 230               if( nId==3 && sqlite3StrNICmp(zSql, "end", 3)==0 ){
 231                 token = tkEND;
 232               }else
 233 #ifndef SQLITE_OMIT_EXPLAIN
 234               if( nId==7 && sqlite3StrNICmp(zSql, "explain", 7)==0 ){
 235                 token = tkEXPLAIN;
 236               }else
 237 #endif
 238               {
 239                 token = tkOTHER;
 240               }
 241               break;
 242             }
 243             default: {
 244               token = tkOTHER;
 245               break;
 246             }
 247           }
 248 #endif /* SQLITE_OMIT_TRIGGER */
 249           zSql += nId-1;
 250         }else{
 251           /* Operators and special symbols */
 252           token = tkOTHER;
 253         }
 254         break;
 255       }
 256     }
 257     state = trans[state][token];
 258     zSql++;
 259   }
 260   return state==1;
 261 }
 262
 263 #ifndef SQLITE_OMIT_UTF16
 264 /*
 265 ** This routine is the same as the sqlite3_complete() routine described
 266 ** above, except that the parameter is required to be UTF-16 encoded, not
 267 ** UTF-8.
 268 */
 269 int sqlite3_complete16(const void *zSql){
 270   sqlite3_value *pVal;
 271   char const *zSql8;
 272   int rc;
 273
 274 #ifndef SQLITE_OMIT_AUTOINIT
 275   rc = sqlite3_initialize();
 276   if( rc ) return rc;
 277 #endif
 278   pVal = sqlite3ValueNew(0);
 279   sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);
 280   zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);
 281   if( zSql8 ){
 282     rc = sqlite3_complete(zSql8);
 283   }else{
 284     rc = SQLITE_NOMEM_BKPT;
 285   }
 286   sqlite3ValueFree(pVal);
 287   return rc & 0xff;
 288 }
 289 #endif /* SQLITE_OMIT_UTF16 */
 290 #endif /* SQLITE_OMIT_COMPLETE */