← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/symbol_hash.gperf

  • Committer: Mark Atwood
  • Date: 2011-12-28 02:50:31 UTC
  • Revision ID: me@mark.atwood.name-20111228025031-eh4h1zwv4ig88g0i
fix tests/r/basic.result

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/symbol_hash.gperf
 
1
%{
1
2
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
3
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
4
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems
 
5
 *  Copyright (C) 2008 Sun Microsystems, Inc.
5
6
 *
6
7
 *  This program is free software; you can redistribute it and/or modify
7
8
 *  it under the terms of the GNU General Public License as published by
18
19
 */
19
20
 
20
21
 
21
 
/* This file includes all reserved words and functions */
 
22
/* This file includes all reserved words */
22
23
 
 
24
#include <drizzled/sql_yacc.h>
23
25
#include <drizzled/lex_symbol.h>
24
26
 
25
 
SYM_GROUP sym_group_common= {"", ""};
26
 
 
27
 
/* We don't want to include sql_yacc.h into gen_lex_hash */
28
 
#ifdef NO_YACC_SYMBOLS
29
 
#define SYM_OR_NULL(A) 0
30
 
#else
31
 
#define SYM_OR_NULL(A) A
32
 
#endif
33
 
 
34
 
#define SYM(A) SYM_OR_NULL(A),0,&sym_group_common
 
27
using namespace drizzled;
35
28
 
36
29
/*
37
30
  Symbols are broken into separated arrays to allow field names with
42
35
  are compiled into the server. Don't add ifdef'ed symbols to the
43
36
  lists
44
37
*/
45
 
 
46
 
static SYMBOL symbols[] = {
47
 
  { "<",                SYM(LT)},
48
 
  { "<=",               SYM(LE)},
49
 
  { "<>",               SYM(NE)},
50
 
  { "!=",               SYM(NE)},
51
 
  { "=",                SYM(EQ)},
52
 
  { ">",                SYM(GT_SYM)},
53
 
  { ">=",               SYM(GE)},
54
 
  { "<=>",              SYM(EQUAL_SYM)},
55
 
  { "ACCESSIBLE",       SYM(ACCESSIBLE_SYM)},
56
 
  { "ACTION",           SYM(ACTION)},
57
 
  { "ADD",              SYM(ADD)},
58
 
  { "AFTER",            SYM(AFTER_SYM)},
59
 
  { "AGGREGATE",        SYM(AGGREGATE_SYM)},
60
 
  { "ALL",              SYM(ALL)},
61
 
  { "ALGORITHM",        SYM(ALGORITHM_SYM)},
62
 
  { "ALTER",            SYM(ALTER)},
63
 
  { "ANALYZE",          SYM(ANALYZE_SYM)},
64
 
  { "AND",              SYM(AND_SYM)},
65
 
  { "ANY",              SYM(ANY_SYM)},
66
 
  { "AS",               SYM(AS)},
67
 
  { "ASC",              SYM(ASC)},
68
 
  { "ASCII",            SYM(ASCII_SYM)},
69
 
  { "ASENSITIVE",       SYM(ASENSITIVE_SYM)},
70
 
  { "AT",               SYM(AT_SYM)},
71
 
  { "AUTHORS",          SYM(AUTHORS_SYM)},
72
 
  { "AUTO_INCREMENT",   SYM(AUTO_INC)},
73
 
  { "AUTOEXTEND_SIZE",  SYM(AUTOEXTEND_SIZE_SYM)},
74
 
  { "AVG",              SYM(AVG_SYM)},
75
 
  { "AVG_ROW_LENGTH",   SYM(AVG_ROW_LENGTH)},
76
 
  { "BEFORE",           SYM(BEFORE_SYM)},
77
 
  { "BEGIN",            SYM(BEGIN_SYM)},
78
 
  { "BETWEEN",          SYM(BETWEEN_SYM)},
79
 
  { "BIGINT",           SYM(BIGINT)},
80
 
  { "BINARY",           SYM(BINARY)},
81
 
  { "BINLOG",           SYM(BINLOG_SYM)},
82
 
  { "BIT",              SYM(BIT_SYM)},
83
 
  { "BLOB",             SYM(BLOB_SYM)},
84
 
  { "BLOCK",  SYM(BLOCK_SYM)},
85
 
  { "BLOCK_SIZE", SYM(BLOCK_SIZE_SYM)},
86
 
  { "BOOL",             SYM(BOOL_SYM)},
87
 
  { "BOOLEAN",          SYM(BOOLEAN_SYM)},
88
 
  { "BOTH",             SYM(BOTH)},
89
 
  { "BTREE",            SYM(BTREE_SYM)},
90
 
  { "BY",               SYM(BY)},
91
 
  { "BYTE",             SYM(BYTE_SYM)},
92
 
  { "CACHE",            SYM(CACHE_SYM)},
93
 
  { "CALL",             SYM(CALL_SYM)},
94
 
  { "CASCADE",          SYM(CASCADE)},
95
 
  { "CASCADED",         SYM(CASCADED)},
96
 
  { "CASE",             SYM(CASE_SYM)},
97
 
  { "CHAIN",            SYM(CHAIN_SYM)},
98
 
  { "CHANGE",           SYM(CHANGE)},
99
 
  { "CHANGED",          SYM(CHANGED)},
100
 
  { "CHAR",             SYM(CHAR_SYM)},
101
 
  { "CHARACTER",        SYM(CHAR_SYM)},
102
 
  { "CHARSET",          SYM(CHARSET)},
103
 
  { "CHECK",            SYM(CHECK_SYM)},
104
 
  { "CHECKSUM",         SYM(CHECKSUM_SYM)},
105
 
  { "CLOSE",            SYM(CLOSE_SYM)},
106
 
  { "COALESCE",         SYM(COALESCE)},
107
 
  { "COLLATE",          SYM(COLLATE_SYM)},
108
 
  { "COLLATION",        SYM(COLLATION_SYM)},
109
 
  { "COLUMN",           SYM(COLUMN_SYM)},
110
 
  { "COLUMNS",          SYM(COLUMNS)},
111
 
  { "COMMENT",          SYM(COMMENT_SYM)},
112
 
  { "COMMIT",           SYM(COMMIT_SYM)},
113
 
  { "COMMITTED",        SYM(COMMITTED_SYM)},
114
 
  { "COMPACT",          SYM(COMPACT_SYM)},
115
 
  { "COMPLETION",       SYM(COMPLETION_SYM)},
116
 
  { "COMPRESSED",       SYM(COMPRESSED_SYM)},
117
 
  { "CONCURRENT",       SYM(CONCURRENT)},
118
 
  { "CONDITION",        SYM(CONDITION_SYM)},
119
 
  { "CONNECTION",       SYM(CONNECTION_SYM)},
120
 
  { "CONSISTENT",       SYM(CONSISTENT_SYM)},
121
 
  { "CONSTRAINT",       SYM(CONSTRAINT)},
122
 
  { "CONTAINS",         SYM(CONTAINS_SYM)},
123
 
  { "CONTEXT",    SYM(CONTEXT_SYM)},
124
 
  { "CONTINUE",         SYM(CONTINUE_SYM)},
125
 
  { "CONVERT",          SYM(CONVERT_SYM)},
126
 
  { "CREATE",           SYM(CREATE)},
127
 
  { "CROSS",            SYM(CROSS)},
128
 
  { "CUBE",             SYM(CUBE_SYM)},
129
 
  { "CURRENT_DATE",     SYM(CURDATE)},
130
 
  { "CURRENT_TIME",     SYM(CURTIME)},
131
 
  { "CURRENT_TIMESTAMP", SYM(NOW_SYM)},
132
 
  { "CURRENT_USER",     SYM(CURRENT_USER)},
133
 
  { "CURSOR",           SYM(CURSOR_SYM)},
134
 
  { "DATA",             SYM(DATA_SYM)},
135
 
  { "DATABASE",         SYM(DATABASE)},
136
 
  { "DATABASES",        SYM(DATABASES)},
137
 
  { "DATAFILE",         SYM(DATAFILE_SYM)},
138
 
  { "DATE",             SYM(DATE_SYM)},
139
 
  { "DATETIME",         SYM(DATETIME)},
140
 
  { "DAY",              SYM(DAY_SYM)},
141
 
  { "DAY_HOUR",         SYM(DAY_HOUR_SYM)},
142
 
  { "DAY_MICROSECOND",  SYM(DAY_MICROSECOND_SYM)},
143
 
  { "DAY_MINUTE",       SYM(DAY_MINUTE_SYM)},
144
 
  { "DAY_SECOND",       SYM(DAY_SECOND_SYM)},
145
 
  { "DEALLOCATE",       SYM(DEALLOCATE_SYM)},     
146
 
  { "DEC",              SYM(DECIMAL_SYM)},
147
 
  { "DECIMAL",          SYM(DECIMAL_SYM)},
148
 
  { "DECLARE",          SYM(DECLARE_SYM)},
149
 
  { "DEFAULT",          SYM(DEFAULT)},
150
 
  { "DELAYED",          SYM(DELAYED_SYM)},
151
 
  { "DELAY_KEY_WRITE",  SYM(DELAY_KEY_WRITE_SYM)},
152
 
  { "DELETE",           SYM(DELETE_SYM)},
153
 
  { "DESC",             SYM(DESC)},
154
 
  { "DESCRIBE",         SYM(DESCRIBE)},
155
 
  { "DETERMINISTIC",    SYM(DETERMINISTIC_SYM)},
156
 
  { "DIRECTORY",        SYM(DIRECTORY_SYM)},
157
 
  { "DISABLE",          SYM(DISABLE_SYM)},
158
 
  { "DISCARD",          SYM(DISCARD)},
159
 
  { "DISTINCT",         SYM(DISTINCT)},
160
 
  { "DISTINCTROW",      SYM(DISTINCT)}, /* Access likes this */
161
 
  { "DIV",              SYM(DIV_SYM)},
162
 
  { "DOUBLE",           SYM(DOUBLE_SYM)},
163
 
  { "DROP",             SYM(DROP)},
164
 
  { "DUMPFILE",         SYM(DUMPFILE)},
165
 
  { "DUPLICATE",        SYM(DUPLICATE_SYM)},
166
 
  { "DYNAMIC",          SYM(DYNAMIC_SYM)},
167
 
  { "EACH",             SYM(EACH_SYM)},
168
 
  { "ELSE",             SYM(ELSE)},
169
 
  { "ELSEIF",           SYM(ELSEIF_SYM)},
170
 
  { "ENABLE",           SYM(ENABLE_SYM)},
171
 
  { "ENCLOSED",         SYM(ENCLOSED)},
172
 
  { "END",              SYM(END)},
173
 
  { "ENDS",             SYM(ENDS_SYM)},
174
 
  { "ENGINE",           SYM(ENGINE_SYM)},
175
 
  { "ENUM",             SYM(ENUM)},
176
 
  { "ERRORS",           SYM(ERRORS)},
177
 
  { "ESCAPE",           SYM(ESCAPE_SYM)},
178
 
  { "ESCAPED",          SYM(ESCAPED)},
179
 
  { "EXCLUSIVE",        SYM(EXCLUSIVE_SYM)},
180
 
  { "EXISTS",           SYM(EXISTS)},
181
 
  { "EXIT",             SYM(EXIT_SYM)},
182
 
  { "EXPLAIN",          SYM(DESCRIBE)},
183
 
  { "EXTENDED",         SYM(EXTENDED_SYM)},
184
 
  { "EXTENT_SIZE",      SYM(EXTENT_SIZE_SYM)},
185
 
  { "FALSE",            SYM(FALSE_SYM)},
186
 
  { "FAST",             SYM(FAST_SYM)},
187
 
  { "FAULTS",  SYM(FAULTS_SYM)},
188
 
  { "FETCH",            SYM(FETCH_SYM)},
189
 
  { "COLUMN_FORMAT",    SYM(COLUMN_FORMAT_SYM)},
190
 
  { "FIELDS",           SYM(COLUMNS)},
191
 
  { "FILE",             SYM(FILE_SYM)},
192
 
  { "FIRST",            SYM(FIRST_SYM)},
193
 
  { "FIXED",            SYM(FIXED_SYM)},
194
 
  { "FLOAT",            SYM(DOUBLE_SYM)},
195
 
  { "FLUSH",            SYM(FLUSH_SYM)},
196
 
  { "FOR",              SYM(FOR_SYM)},
197
 
  { "FORCE",            SYM(FORCE_SYM)},
198
 
  { "FOREIGN",          SYM(FOREIGN)},
199
 
  { "FOUND",            SYM(FOUND_SYM)},
200
 
  { "FRAC_SECOND",      SYM(FRAC_SECOND_SYM)},
201
 
  { "FROM",             SYM(FROM)},
202
 
  { "FULL",             SYM(FULL)},
203
 
  { "GET_FORMAT",       SYM(GET_FORMAT)},
204
 
  { "GLOBAL",           SYM(GLOBAL_SYM)},
205
 
  { "GROUP",            SYM(GROUP_SYM)},
206
 
  { "HANDLER",          SYM(HANDLER_SYM)},
207
 
  { "HASH",             SYM(HASH_SYM)},
208
 
  { "HAVING",           SYM(HAVING)},
209
 
  { "HIGH_PRIORITY",    SYM(HIGH_PRIORITY)},
210
 
  { "HOST",             SYM(HOST_SYM)},
211
 
  { "HOSTS",            SYM(HOSTS_SYM)},
212
 
  { "HOUR",             SYM(HOUR_SYM)},
213
 
  { "HOUR_MICROSECOND", SYM(HOUR_MICROSECOND_SYM)},
214
 
  { "HOUR_MINUTE",      SYM(HOUR_MINUTE_SYM)},
215
 
  { "HOUR_SECOND",      SYM(HOUR_SECOND_SYM)},
216
 
  { "IDENTIFIED",       SYM(IDENTIFIED_SYM)},
217
 
  { "IF",               SYM(IF)},
218
 
  { "IGNORE",           SYM(IGNORE_SYM)},
219
 
  { "IMPORT",           SYM(IMPORT)},
220
 
  { "IN",               SYM(IN_SYM)},
221
 
  { "INDEX",            SYM(INDEX_SYM)},
222
 
  { "INDEXES",          SYM(INDEXES)},
223
 
  { "INFILE",           SYM(INFILE)},
224
 
  { "INITIAL_SIZE",     SYM(INITIAL_SIZE_SYM)},
225
 
  { "INNER",            SYM(INNER_SYM)},
226
 
  { "INOUT",            SYM(INOUT_SYM)},
227
 
  { "INSENSITIVE",      SYM(INSENSITIVE_SYM)},
228
 
  { "INSERT",           SYM(INSERT)},
229
 
  { "INSERT_METHOD",    SYM(INSERT_METHOD)},
230
 
  { "INSTALL",          SYM(INSTALL_SYM)},
231
 
  { "INT",              SYM(INT_SYM)},
232
 
  { "INT4",             SYM(INT_SYM)},
233
 
  { "INT8",             SYM(BIGINT)},
234
 
  { "INTEGER",          SYM(INT_SYM)},
235
 
  { "INTERVAL",         SYM(INTERVAL_SYM)},
236
 
  { "INTO",             SYM(INTO)},
237
 
  { "IO_THREAD",        SYM(RELAY_THREAD)},
238
 
  { "IS",               SYM(IS)},
239
 
  { "ISOLATION",        SYM(ISOLATION)},
240
 
  { "ITERATE",          SYM(ITERATE_SYM)},
241
 
  { "JOIN",             SYM(JOIN_SYM)},
242
 
  { "KEY",              SYM(KEY_SYM)},
243
 
  { "KEYS",             SYM(KEYS)},
244
 
  { "KEY_BLOCK_SIZE",   SYM(KEY_BLOCK_SIZE)},
245
 
  { "KILL",             SYM(KILL_SYM)},
246
 
  { "LAST",             SYM(LAST_SYM)},
247
 
  { "LEADING",          SYM(LEADING)},
248
 
  { "LEAVES",           SYM(LEAVES)},
249
 
  { "LEFT",             SYM(LEFT)},
250
 
  { "LEVEL",            SYM(LEVEL_SYM)},
251
 
  { "LIKE",             SYM(LIKE)},
252
 
  { "LIMIT",            SYM(LIMIT)},
253
 
  { "LINEAR",           SYM(LINEAR_SYM)},
254
 
  { "LIST",             SYM(LIST_SYM)},
255
 
  { "LOAD",             SYM(LOAD)},
256
 
  { "LOCAL",            SYM(LOCAL_SYM)},
257
 
  { "LOCALTIME",        SYM(NOW_SYM)},
258
 
  { "LOCALTIMESTAMP",   SYM(NOW_SYM)},
259
 
  { "LOCK",             SYM(LOCK_SYM)},
260
 
  { "LOCKS",            SYM(LOCKS_SYM)},
261
 
  { "LOGFILE",          SYM(LOGFILE_SYM)},
262
 
  { "LOGS",             SYM(LOGS_SYM)},
263
 
  { "LONG",             SYM(LONG_SYM)},
264
 
  { "LONGBLOB",         SYM(BLOB_SYM)},
265
 
  { "LONGTEXT",         SYM(TEXT_SYM)},
266
 
  { "LOOP",             SYM(LOOP_SYM)},
267
 
  { "LOW_PRIORITY",     SYM(LOW_PRIORITY)},
268
 
  { "MASTER",           SYM(MASTER_SYM)},
269
 
  { "MASTER_CONNECT_RETRY",           SYM(MASTER_CONNECT_RETRY_SYM)},
270
 
  { "MASTER_HOST",           SYM(MASTER_HOST_SYM)},
271
 
  { "MASTER_LOG_FILE",           SYM(MASTER_LOG_FILE_SYM)},
272
 
  { "MASTER_LOG_POS",           SYM(MASTER_LOG_POS_SYM)},
273
 
  { "MASTER_PASSWORD",           SYM(MASTER_PASSWORD_SYM)},
274
 
  { "MASTER_PORT",           SYM(MASTER_PORT_SYM)},
275
 
  { "MASTER_SERVER_ID",           SYM(MASTER_SERVER_ID_SYM)},
276
 
  { "MASTER_USER",           SYM(MASTER_USER_SYM)},
277
 
  { "MASTER_HEARTBEAT_PERIOD", SYM(MASTER_HEARTBEAT_PERIOD_SYM)},
278
 
  { "MATCH",            SYM(MATCH)},
279
 
  { "MAX_CONNECTIONS_PER_HOUR", SYM(MAX_CONNECTIONS_PER_HOUR)},
280
 
  { "MAX_QUERIES_PER_HOUR", SYM(MAX_QUERIES_PER_HOUR)},
281
 
  { "MAX_ROWS",         SYM(MAX_ROWS)},
282
 
  { "MAX_SIZE",         SYM(MAX_SIZE_SYM)},
283
 
  { "MAX_UPDATES_PER_HOUR", SYM(MAX_UPDATES_PER_HOUR)},
284
 
  { "MAX_USER_CONNECTIONS", SYM(MAX_USER_CONNECTIONS_SYM)},
285
 
  { "MAXVALUE",         SYM(MAX_VALUE_SYM)},
286
 
  { "MEDIUM",           SYM(MEDIUM_SYM)},
287
 
  { "MEDIUMBLOB",       SYM(BLOB_SYM)},
288
 
  { "MEDIUMTEXT",       SYM(TEXT_SYM)},
289
 
  { "MERGE",            SYM(MERGE_SYM)},
290
 
  { "MICROSECOND",      SYM(MICROSECOND_SYM)},
291
 
  { "MIGRATE",          SYM(MIGRATE_SYM)},
292
 
  { "MINUTE",           SYM(MINUTE_SYM)},
293
 
  { "MINUTE_MICROSECOND", SYM(MINUTE_MICROSECOND_SYM)},
294
 
  { "MINUTE_SECOND",    SYM(MINUTE_SECOND_SYM)},
295
 
  { "MIN_ROWS",         SYM(MIN_ROWS)},
296
 
  { "MOD",              SYM(MOD_SYM)},
297
 
  { "MODE",             SYM(MODE_SYM)},
298
 
  { "MODIFIES",         SYM(MODIFIES_SYM)},
299
 
  { "MODIFY",           SYM(MODIFY_SYM)},
300
 
  { "MONTH",            SYM(MONTH_SYM)},
301
 
  { "NAME",             SYM(NAME_SYM)},
302
 
  { "NAMES",            SYM(NAMES_SYM)},
303
 
  { "NATIONAL",         SYM(NATIONAL_SYM)},
304
 
  { "NATURAL",          SYM(NATURAL)},
305
 
  { "NEW",              SYM(NEW_SYM)},
306
 
  { "NEXT",             SYM(NEXT_SYM)},
307
 
  { "NO",               SYM(NO_SYM)},
308
 
  { "NO_WAIT",          SYM(NO_WAIT_SYM)},
309
 
  { "NODEGROUP",        SYM(NODEGROUP_SYM)},
310
 
  { "NONE",             SYM(NONE_SYM)},
311
 
  { "NOT",              SYM(NOT_SYM)},
312
 
  { "NOWAIT",           SYM(NOWAIT_SYM)},
313
 
  { "NO_WRITE_TO_BINLOG",  SYM(NO_WRITE_TO_BINLOG)},
314
 
  { "NULL",             SYM(NULL_SYM)},
315
 
  { "NUMERIC",          SYM(NUMERIC_SYM)},
316
 
  { "OFFLINE",          SYM(OFFLINE_SYM)},
317
 
  { "OFFSET",           SYM(OFFSET_SYM)},
318
 
  { "ON",               SYM(ON)},
319
 
  { "ONE",              SYM(ONE_SYM)},
320
 
  { "ONLINE",           SYM(ONLINE_SYM)},
321
 
  { "ONE_SHOT",         SYM(ONE_SHOT_SYM)},
322
 
  { "OPEN",             SYM(OPEN_SYM)},
323
 
  { "OPTIMIZE",         SYM(OPTIMIZE)},
324
 
  { "OPTIONS",          SYM(OPTIONS_SYM)},
325
 
  { "OPTION",           SYM(OPTION)},
326
 
  { "OPTIONALLY",       SYM(OPTIONALLY)},
327
 
  { "OR",               SYM(OR_SYM)},
328
 
  { "ORDER",            SYM(ORDER_SYM)},
329
 
  { "OUT",              SYM(OUT_SYM)},
330
 
  { "OUTER",            SYM(OUTER)},
331
 
  { "OUTFILE",          SYM(OUTFILE)},
332
 
  { "PACK_KEYS",        SYM(PACK_KEYS_SYM)},
333
 
  { "PAGE",             SYM(PAGE_SYM)},
334
 
  { "PAGE_CHECKSUM",        SYM(PAGE_CHECKSUM_SYM)},
335
 
  { "PARSE_VCOL_EXPR",  SYM(PARSE_VCOL_EXPR_SYM)},
336
 
  { "PARTIAL",          SYM(PARTIAL)},
337
 
  { "PHASE",            SYM(PHASE_SYM)},
338
 
  { "PLUGIN",           SYM(PLUGIN_SYM)},
339
 
  { "PLUGINS",          SYM(PLUGINS_SYM)},
340
 
  { "PORT",             SYM(PORT_SYM)},
341
 
  { "PRECISION",        SYM(PRECISION)},
342
 
  { "PREV",             SYM(PREV_SYM)},
343
 
  { "PRIMARY",          SYM(PRIMARY_SYM)},
344
 
  { "PROCESS"   ,       SYM(PROCESS)},
345
 
  { "PROCESSLIST",      SYM(PROCESSLIST_SYM)},
346
 
  { "PURGE",            SYM(PURGE)},
347
 
  { "QUARTER",          SYM(QUARTER_SYM)},
348
 
  { "QUERY",            SYM(QUERY_SYM)},
349
 
  { "QUICK",            SYM(QUICK)},
350
 
  { "RANGE",            SYM(RANGE_SYM)},
351
 
  { "READ",             SYM(READ_SYM)},
352
 
  { "READ_ONLY",        SYM(READ_ONLY_SYM)},
353
 
  { "READ_WRITE",       SYM(READ_WRITE_SYM)},
354
 
  { "READS",            SYM(READS_SYM)},
355
 
  { "REAL",             SYM(REAL)},
356
 
  { "REBUILD",          SYM(REBUILD_SYM)},
357
 
  { "RECOVER",          SYM(RECOVER_SYM)},
358
 
  { "REDO_BUFFER_SIZE", SYM(REDO_BUFFER_SIZE_SYM)},
359
 
  { "REDOFILE",         SYM(REDOFILE_SYM)},
360
 
  { "REDUNDANT",        SYM(REDUNDANT_SYM)},
361
 
  { "REFERENCES",       SYM(REFERENCES)},
362
 
  { "RELAY_LOG_FILE",   SYM(RELAY_LOG_FILE_SYM)},
363
 
  { "RELAY_LOG_POS",    SYM(RELAY_LOG_POS_SYM)},
364
 
  { "RELAY_THREAD",     SYM(RELAY_THREAD)},
365
 
  { "RELEASE",          SYM(RELEASE_SYM)},
366
 
  { "RELOAD",           SYM(RELOAD)},
367
 
  { "REMOVE",           SYM(REMOVE_SYM)},
368
 
  { "RENAME",           SYM(RENAME)},
369
 
  { "REORGANIZE",       SYM(REORGANIZE_SYM)},
370
 
  { "REPAIR",           SYM(REPAIR)},
371
 
  { "REPEATABLE",       SYM(REPEATABLE_SYM)},
372
 
  { "REPLACE",          SYM(REPLACE)},
373
 
  { "REPLICATION",      SYM(REPLICATION)},
374
 
  { "REPEAT",           SYM(REPEAT_SYM)},
375
 
  { "REQUIRE",          SYM(REQUIRE_SYM)},
376
 
  { "RESET",            SYM(RESET_SYM)},
377
 
  { "RESTRICT",         SYM(RESTRICT)},
378
 
  { "RESUME",           SYM(RESUME_SYM)},
379
 
  { "RETURN",           SYM(RETURN_SYM)},
380
 
  { "RETURNS",          SYM(RETURNS_SYM)},
381
 
  { "REVERSE",          SYM(REVERSE_SYM)},
382
 
  { "REVOKE",           SYM(REVOKE)},
383
 
  { "RIGHT",            SYM(RIGHT)},
384
 
  { "ROLLBACK",         SYM(ROLLBACK_SYM)},
385
 
  { "ROLLUP",           SYM(ROLLUP_SYM)},
386
 
  { "ROUTINE",          SYM(ROUTINE_SYM)},
387
 
  { "ROW",              SYM(ROW_SYM)},
388
 
  { "ROWS",             SYM(ROWS_SYM)},
389
 
  { "ROW_FORMAT",       SYM(ROW_FORMAT_SYM)},
390
 
  { "SAVEPOINT",        SYM(SAVEPOINT_SYM)},
391
 
  { "SCHEMA",           SYM(DATABASE)},
392
 
  { "SCHEMAS",          SYM(DATABASES)},
393
 
  { "SECOND",           SYM(SECOND_SYM)},
394
 
  { "SECOND_MICROSECOND", SYM(SECOND_MICROSECOND_SYM)},
395
 
  { "SECURITY",         SYM(SECURITY_SYM)},
396
 
  { "SELECT",           SYM(SELECT_SYM)},
397
 
  { "SENSITIVE",        SYM(SENSITIVE_SYM)},
398
 
  { "SEPARATOR",        SYM(SEPARATOR_SYM)},
399
 
  { "SERIAL",           SYM(SERIAL_SYM)},
400
 
  { "SERIALIZABLE",     SYM(SERIALIZABLE_SYM)},
401
 
  { "SESSION",          SYM(SESSION_SYM)},
402
 
  { "SERVER",           SYM(SERVER_SYM)},
403
 
  { "SET",              SYM(SET)},
404
 
  { "SHARE",            SYM(SHARE_SYM)},
405
 
  { "SHOW",             SYM(SHOW)},
406
 
  { "SHUTDOWN",         SYM(SHUTDOWN)},
407
 
  { "SIMPLE",           SYM(SIMPLE_SYM)},
408
 
  { "SLAVE",            SYM(SLAVE)},
409
 
  { "SNAPSHOT",         SYM(SNAPSHOT_SYM)},
410
 
  { "SOCKET",           SYM(SOCKET_SYM)},
411
 
  { "SOME",             SYM(ANY_SYM)},
412
 
  { "SONAME",           SYM(SONAME_SYM)},
413
 
  { "SOURCE",   SYM(SOURCE_SYM)},
414
 
  { "SPECIFIC",         SYM(SPECIFIC_SYM)},
415
 
  { "SQL",              SYM(SQL_SYM)},
416
 
  { "SQLEXCEPTION",     SYM(SQLEXCEPTION_SYM)},
417
 
  { "SQLSTATE",         SYM(SQLSTATE_SYM)},
418
 
  { "SQLWARNING",       SYM(SQLWARNING_SYM)},
419
 
  { "SQL_BIG_RESULT",   SYM(SQL_BIG_RESULT)},
420
 
  { "SQL_BUFFER_RESULT", SYM(SQL_BUFFER_RESULT)},
421
 
  { "SQL_CALC_FOUND_ROWS", SYM(SQL_CALC_FOUND_ROWS)},
422
 
  { "SQL_SMALL_RESULT", SYM(SQL_SMALL_RESULT)},
423
 
  { "SQL_THREAD",       SYM(SQL_THREAD)},
424
 
  { "SQL_TSI_FRAC_SECOND", SYM(FRAC_SECOND_SYM)},
425
 
  { "SQL_TSI_SECOND",   SYM(SECOND_SYM)},
426
 
  { "SQL_TSI_MINUTE",   SYM(MINUTE_SYM)},
427
 
  { "SQL_TSI_HOUR",     SYM(HOUR_SYM)},
428
 
  { "SQL_TSI_DAY",      SYM(DAY_SYM)},
429
 
  { "SQL_TSI_WEEK",     SYM(WEEK_SYM)},
430
 
  { "SQL_TSI_MONTH",    SYM(MONTH_SYM)},
431
 
  { "SQL_TSI_QUARTER",  SYM(QUARTER_SYM)},
432
 
  { "SQL_TSI_YEAR",     SYM(YEAR_SYM)},
433
 
  { "START",            SYM(START_SYM)},
434
 
  { "STARTING",         SYM(STARTING)},
435
 
  { "STARTS",           SYM(STARTS_SYM)},
436
 
  { "STATUS",           SYM(STATUS_SYM)},
437
 
  { "STOP",             SYM(STOP_SYM)},
438
 
  { "STORAGE",          SYM(STORAGE_SYM)},
439
 
  { "STORED",           SYM(STORED_SYM)},
440
 
  { "STRAIGHT_JOIN",    SYM(STRAIGHT_JOIN)},
441
 
  { "STRING",           SYM(STRING_SYM)},
442
 
  { "SUBJECT",          SYM(SUBJECT_SYM)},
443
 
  { "SUPER",            SYM(SUPER_SYM)},
444
 
  { "SUSPEND",          SYM(SUSPEND_SYM)},
445
 
  { "SWAPS",      SYM(SWAPS_SYM)},
446
 
  { "SWITCHES",   SYM(SWITCHES_SYM)},
447
 
  { "TABLE",            SYM(TABLE_SYM)},
448
 
  { "TABLES",           SYM(TABLES)},
449
 
  { "TABLESPACE",               SYM(TABLESPACE)},
450
 
  { "TABLE_CHECKSUM",   SYM(TABLE_CHECKSUM_SYM)},
451
 
  { "TEMPORARY",        SYM(TEMPORARY)},
452
 
  { "TEMPTABLE",        SYM(TEMPTABLE_SYM)},
453
 
  { "TERMINATED",       SYM(TERMINATED)},
454
 
  { "TEXT",             SYM(TEXT_SYM)},
455
 
  { "THAN",             SYM(THAN_SYM)},
456
 
  { "THEN",             SYM(THEN_SYM)},
457
 
  { "TIME",             SYM(TIME_SYM)},
458
 
  { "TIMESTAMP",        SYM(TIMESTAMP)},
459
 
  { "TIMESTAMPADD",     SYM(TIMESTAMP_ADD)},
460
 
  { "TIMESTAMPDIFF",    SYM(TIMESTAMP_DIFF)},
461
 
  { "TINYBLOB",         SYM(BLOB_SYM)},
462
 
  { "TINYTEXT",         SYM(TEXT_SYM)},
463
 
  { "TO",               SYM(TO_SYM)},
464
 
  { "TRAILING",         SYM(TRAILING)},
465
 
  { "TRANSACTION",      SYM(TRANSACTION_SYM)},
466
 
  { "TRANSACTIONAL",    SYM(TRANSACTIONAL_SYM)},
467
 
  { "TRUE",             SYM(TRUE_SYM)},
468
 
  { "TRUNCATE",         SYM(TRUNCATE_SYM)},
469
 
  { "TYPE",             SYM(TYPE_SYM)},
470
 
  { "TYPES",            SYM(TYPES_SYM)},
471
 
  { "UNCOMMITTED",      SYM(UNCOMMITTED_SYM)},
472
 
  { "UNDEFINED",        SYM(UNDEFINED_SYM)},
473
 
  { "UNDOFILE",         SYM(UNDOFILE_SYM)},
474
 
  { "UNDO",             SYM(UNDO_SYM)},
475
 
  { "UNION",            SYM(UNION_SYM)},
476
 
  { "UNIQUE",           SYM(UNIQUE_SYM)},
477
 
  { "UNKNOWN",          SYM(UNKNOWN_SYM)},
478
 
  { "UNLOCK",           SYM(UNLOCK_SYM)},
479
 
  { "UNTIL",            SYM(UNTIL_SYM)},
480
 
  { "UPDATE",           SYM(UPDATE_SYM)},
481
 
  { "UPGRADE",          SYM(UPGRADE_SYM)},
482
 
  { "USAGE",            SYM(USAGE)},
483
 
  { "USE",              SYM(USE_SYM)},
484
 
  { "USER",             SYM(USER)},
485
 
  { "USER_RESOURCES",   SYM(RESOURCES)},
486
 
  { "USE_FRM",          SYM(USE_FRM)},
487
 
  { "USING",            SYM(USING)},
488
 
  { "UTC_DATE",         SYM(UTC_DATE_SYM)},
489
 
  { "UTC_TIME",         SYM(UTC_TIME_SYM)},
490
 
  { "UTC_TIMESTAMP",    SYM(UTC_TIMESTAMP_SYM)},
491
 
  { "VALUE",            SYM(VALUE_SYM)},
492
 
  { "VALUES",           SYM(VALUES)},
493
 
  { "VARBINARY",        SYM(VARBINARY)},
494
 
  { "VARCHAR",          SYM(VARCHAR)},
495
 
  { "VARCHARACTER",     SYM(VARCHAR)},
496
 
  { "VARIABLES",        SYM(VARIABLES)},
497
 
  { "VARYING",          SYM(VARYING)},
498
 
  { "WAIT",             SYM(WAIT_SYM)},
499
 
  { "WARNINGS",         SYM(WARNINGS)},
500
 
  { "WEEK",             SYM(WEEK_SYM)},
501
 
  { "WEIGHT_STRING",    SYM(WEIGHT_STRING_SYM)},
502
 
  { "WHEN",             SYM(WHEN_SYM)},
503
 
  { "WHERE",            SYM(WHERE)},
504
 
  { "WITH",             SYM(WITH)},
505
 
  { "WORK",             SYM(WORK_SYM)},
506
 
  { "WRITE",            SYM(WRITE_SYM)},
507
 
  { "VIRTUAL",          SYM(VIRTUAL_SYM)},
508
 
  { "XOR",              SYM(XOR)},
509
 
  { "YEAR",             SYM(YEAR_SYM)},
510
 
  { "YEAR_MONTH",       SYM(YEAR_MONTH_SYM)},
511
 
};
512
 
 
513
 
 
514
 
static SYMBOL sql_functions[] = {
515
 
  { "ADDDATE",          SYM(ADDDATE_SYM)},
516
 
  { "CAST",             SYM(CAST_SYM)},
517
 
  { "COUNT",            SYM(COUNT_SYM)},
518
 
  { "CURDATE",          SYM(CURDATE)},
519
 
  { "CURTIME",          SYM(CURTIME)},
520
 
  { "DATE_ADD",         SYM(DATE_ADD_INTERVAL)},
521
 
  { "DATE_SUB",         SYM(DATE_SUB_INTERVAL)},
522
 
  { "EXTRACT",          SYM(EXTRACT_SYM)},
523
 
  { "GROUP_CONCAT",     SYM(GROUP_CONCAT_SYM)},
524
 
  { "MAX",              SYM(MAX_SYM)},
525
 
  { "MID",              SYM(SUBSTRING)},        /* unireg function */
526
 
  { "MIN",              SYM(MIN_SYM)},
527
 
  { "NOW",              SYM(NOW_SYM)},
528
 
  { "POSITION",         SYM(POSITION_SYM)},
529
 
  { "SESSION_USER",     SYM(USER)},
530
 
  { "STD",              SYM(STD_SYM)},
531
 
  { "STDDEV",           SYM(STD_SYM)},
532
 
  { "STDDEV_POP",       SYM(STD_SYM)},
533
 
  { "STDDEV_SAMP",      SYM(STDDEV_SAMP_SYM)},
534
 
  { "SUBDATE",          SYM(SUBDATE_SYM)},
535
 
  { "SUBSTR",           SYM(SUBSTRING)},
536
 
  { "SUBSTRING",        SYM(SUBSTRING)},
537
 
  { "SUM",              SYM(SUM_SYM)},
538
 
  { "SYSDATE",          SYM(SYSDATE)},
539
 
  { "SYSTEM_USER",      SYM(USER)},
540
 
  { "TRIM",             SYM(TRIM)},
541
 
  { "VARIANCE",         SYM(VARIANCE_SYM)},
542
 
  { "VAR_POP",          SYM(VARIANCE_SYM)},
543
 
  { "VAR_SAMP",         SYM(VAR_SAMP_SYM)},
544
 
};
 
38
%}
 
39
struct SYMBOL
 
40
{
 
41
  const char *name;
 
42
  unsigned int  tok;
 
43
};
 
44
%%
 
45
||, CONCAT
 
46
<=, LE
 
47
<>, NE
 
48
!=, NE
 
49
>=, GE
 
50
<=>, EQUAL_SYM
 
51
<, LESS_THAN
 
52
>, GREATER_THAN
 
53
<<, SHIFT_LEFT
 
54
>>, SHIFT_RIGHT
 
55
# Access likes this, keep everything supported below this
 
56
ACTION, ACTION
 
57
ADD, ADD_SYM
 
58
AFTER, AFTER_SYM
 
59
AGGREGATE, AGGREGATE_SYM
 
60
ALL, ALL
 
61
ALTER, ALTER_SYM
 
62
ANALYZE, ANALYZE_SYM
 
63
AND, AND_SYM
 
64
ANY, ANY_SYM
 
65
AS, AS
 
66
ASC, ASC
 
67
ASENSITIVE, ASENSITIVE_SYM
 
68
AT, AT_SYM
 
69
AUTO_INCREMENT, AUTO_INC
 
70
AVG, AVG_SYM
 
71
BEFORE, BEFORE_SYM
 
72
BEGIN, BEGIN_SYM
 
73
BETWEEN, BETWEEN_SYM
 
74
BIGINT, BIGINT_SYM
 
75
BINARY, BINARY
 
76
BIT, BIT_SYM
 
77
BLOB, BLOB_SYM
 
78
BOOL, BOOL_SYM
 
79
BOOLEAN, BOOLEAN_SYM
 
80
BOTH, BOTH
 
81
BTREE, BTREE_SYM
 
82
BY, BY
 
83
CALL, CALL_SYM
 
84
CASCADE, CASCADE
 
85
CASCADED, CASCADED
 
86
CASE, CASE_SYM
 
87
CATALOG, CATALOG_SYM
 
88
CHAIN, CHAIN_SYM
 
89
CHANGE, CHANGE_SYM
 
90
CHAR, CHAR_SYM
 
91
CHARACTER, CHAR_SYM
 
92
CHARSET, CHARSET
 
93
CHECK, CHECK_SYM
 
94
CHECKSUM, CHECKSUM_SYM
 
95
CLOSE, CLOSE_SYM
 
96
COALESCE, COALESCE
 
97
COLLATE, COLLATE_SYM
 
98
COLLATION, COLLATION_SYM
 
99
COLUMN, COLUMN_SYM
 
100
COLUMNS, COLUMNS
 
101
COMMENT, COMMENT_SYM
 
102
COMMIT, COMMIT_SYM
 
103
COMMITTED, COMMITTED_SYM
 
104
COMPACT, COMPACT_SYM
 
105
COMPRESSED, COMPRESSED_SYM
 
106
CONCURRENT, CONCURRENT
 
107
CONDITION, CONDITION_SYM
 
108
CONNECTION, CONNECTION_SYM
 
109
CONSISTENT, CONSISTENT_SYM
 
110
CONSTRAINT, CONSTRAINT
 
111
CONTAINS, CONTAINS_SYM
 
112
CONVERT, CONVERT_SYM
 
113
CREATE, CREATE
 
114
CROSS, CROSS
 
115
CUBE, CUBE_SYM
 
116
CURRENT_DATE, CURDATE
 
117
CURRENT_TIMESTAMP, NOW_SYM
 
118
CURRENT_USER, CURRENT_USER
 
119
CURSOR, CURSOR_SYM
 
120
DATA, DATA_SYM
 
121
DATABASE, DATABASE
 
122
DATABASES, DATABASES
 
123
DATE, DATE_SYM
 
124
DATETIME, DATETIME_SYM
 
125
DAY, DAY_SYM
 
126
DAY_HOUR, DAY_HOUR_SYM
 
127
DAY_MICROSECOND, DAY_MICROSECOND_SYM
 
128
DAY_MINUTE, DAY_MINUTE_SYM
 
129
DAY_SECOND, DAY_SECOND_SYM
 
130
DEALLOCATE, DEALLOCATE_SYM
 
131
DEC, DECIMAL_SYM
 
132
DECIMAL, DECIMAL_SYM
 
133
DECLARE, DECLARE_SYM
 
134
DEFAULT, DEFAULT
 
135
DEFINER, DEFINER
 
136
DELETE, DELETE_SYM
 
137
DESC, DESC
 
138
DESCRIBE, DESCRIBE
 
139
DETERMINISTIC, DETERMINISTIC_SYM
 
140
DISABLE, DISABLE_SYM
 
141
DISCARD, DISCARD
 
142
DISTINCT, DISTINCT
 
143
DISTINCTROW, DISTINCT
 
144
DIV, DIV_SYM
 
145
DO, DO_SYM
 
146
DOUBLE, DOUBLE_SYM
 
147
DROP, DROP
 
148
DUMPFILE, DUMPFILE
 
149
DUPLICATE, DUPLICATE_SYM
 
150
DYNAMIC, DYNAMIC_SYM
 
151
EACH, EACH_SYM
 
152
ELSE, ELSE
 
153
ENABLE, ENABLE_SYM
 
154
ENCLOSED, ENCLOSED
 
155
END, END
 
156
ENDS, ENDS_SYM
 
157
ENGINE, ENGINE_SYM
 
158
ENUM, ENUM_SYM
 
159
ERRORS, ERRORS
 
160
ESCAPE, ESCAPE_SYM
 
161
ESCAPED, ESCAPED
 
162
EXCLUSIVE, EXCLUSIVE_SYM
 
163
EXECUTE, EXECUTE_SYM
 
164
EXISTS, EXISTS
 
165
EXPLAIN, DESCRIBE
 
166
EXTENDED, EXTENDED_SYM
 
167
FALSE, FALSE_SYM
 
168
FIELDS, COLUMNS
 
169
FILE, FILE_SYM
 
170
FIRST, FIRST_SYM
 
171
FIXED, FIXED_SYM
 
172
FLOAT, DOUBLE_SYM
 
173
FLUSH, FLUSH_SYM
 
174
FOR, FOR_SYM
 
175
FORCE, FORCE_SYM
 
176
FOREIGN, FOREIGN
 
177
FOUND, FOUND_SYM
 
178
FRAC_SECOND, FRAC_SECOND_SYM
 
179
FROM, FROM
 
180
FULL, FULL
 
181
GLOBAL, GLOBAL_SYM
 
182
GROUP, GROUP_SYM
 
183
HASH, HASH_SYM
 
184
HAVING, HAVING
 
185
HOUR, HOUR_SYM
 
186
HOUR_MICROSECOND, HOUR_MICROSECOND_SYM
 
187
HOUR_MINUTE, HOUR_MINUTE_SYM
 
188
HOUR_SECOND, HOUR_SECOND_SYM
 
189
IDENTIFIED, IDENTIFIED_SYM
 
190
IDENTITY, IDENTITY_SYM
 
191
IF, IF
 
192
IGNORE, IGNORE_SYM
 
193
IMPORT, IMPORT
 
194
IN, IN_SYM
 
195
INDEX, INDEX_SYM
 
196
INDEXES, INDEXES
 
197
INFILE, INFILE
 
198
INNER, INNER_SYM
 
199
INOUT, INOUT_SYM
 
200
INSENSITIVE, INSENSITIVE_SYM
 
201
INSERT, INSERT
 
202
INT, INT_SYM
 
203
INT4, INT_SYM
 
204
INT8, BIGINT_SYM
 
205
INTEGER, INT_SYM
 
206
INTERVAL, INTERVAL_SYM
 
207
INTO, INTO
 
208
INVOKER, INVOKER
 
209
IS, IS
 
210
ISOLATION, ISOLATION
 
211
ITERATE, ITERATE_SYM
 
212
IPV6, IPV6_SYM
 
213
JOIN, JOIN_SYM
 
214
KEY, KEY_SYM
 
215
KEYS, KEYS
 
216
KEY_BLOCK_SIZE, KEY_BLOCK_SIZE
 
217
KILL, KILL_SYM
 
218
LAST, LAST_SYM
 
219
LEADING, LEADING
 
220
LEFT, LEFT
 
221
LEVEL, LEVEL_SYM
 
222
LIKE, LIKE
 
223
LIMIT, LIMIT
 
224
LINES, LINES
 
225
LOAD, LOAD
 
226
LOCAL, LOCAL_SYM
 
227
LOCALTIME, NOW_SYM
 
228
LOCALTIMESTAMP, NOW_SYM
 
229
LOCK, LOCK_SYM
 
230
LOCKS, LOCKS_SYM
 
231
LOGS, LOGS_SYM
 
232
LONG, LONG_SYM
 
233
LONGBLOB, BLOB_SYM
 
234
LONGTEXT, TEXT_SYM
 
235
MATCH, MATCH
 
236
MAXVALUE, MAX_VALUE_SYM
 
237
MEDIUM, MEDIUM_SYM
 
238
MEDIUMBLOB, BLOB_SYM
 
239
MEDIUMTEXT, TEXT_SYM
 
240
MERGE, MERGE_SYM
 
241
MICROSECOND, MICROSECOND_SYM
 
242
MINUTE, MINUTE_SYM
 
243
MINUTE_MICROSECOND, MINUTE_MICROSECOND_SYM
 
244
MINUTE_SECOND, MINUTE_SECOND_SYM
 
245
MOD, MOD_SYM
 
246
MODE, MODE_SYM
 
247
MODIFIES, MODIFIES_SYM
 
248
MODIFY, MODIFY_SYM
 
249
MONTH, MONTH_SYM
 
250
NAME, NAME_SYM
 
251
NAMES, NAMES_SYM
 
252
NATIONAL, NATIONAL_SYM
 
253
NATURAL, NATURAL
 
254
NEW, NEW_SYM
 
255
NEXT, NEXT_SYM
 
256
NO, NO_SYM
 
257
NONE, NONE_SYM
 
258
NOT, NOT_SYM
 
259
NULL, NULL_SYM
 
260
NUMERIC, NUMERIC_SYM
 
261
OFFLINE, OFFLINE_SYM
 
262
OFFSET, OFFSET_SYM
 
263
ON, ON
 
264
ONE, ONE_SYM
 
265
ONLINE, ONLINE_SYM
 
266
OPEN, OPEN_SYM
 
267
OPTIMIZE, OPTIMIZE
 
268
OPTION, OPTION
 
269
OPTIONALLY, OPTIONALLY
 
270
OR, OR_SYM
 
271
ORDER, ORDER_SYM
 
272
OUT, OUT_SYM
 
273
OUTER, OUTER
 
274
OUTFILE, OUTFILE
 
275
PARTIAL, PARTIAL
 
276
PRECISION, PRECISION
 
277
PREV, PREV_SYM
 
278
PRIMARY, PRIMARY_SYM
 
279
PROCESS, PROCESS
 
280
PROCESSLIST, PROCESSLIST_SYM
 
281
QUARTER, QUARTER_SYM
 
282
QUERY, QUERY_SYM
 
283
RANGE, RANGE_SYM
 
284
READ, READ_SYM
 
285
READS, READS_SYM
 
286
READ_WRITE, READ_WRITE_SYM
 
287
REAL, REAL
 
288
REDUNDANT, REDUNDANT_SYM
 
289
REFERENCES, REFERENCES
 
290
REGEXP, REGEXP_SYM
 
291
RELEASE, RELEASE_SYM
 
292
RENAME, RENAME
 
293
REPEAT, REPEAT_SYM
 
294
REPEATABLE, REPEATABLE_SYM
 
295
REPLACE, REPLACE
 
296
REPLICATE,REPLICATE
 
297
REPLICATION,REPLICATION
 
298
RESTRICT, RESTRICT
 
299
RETURN, RETURN_SYM
 
300
RETURNS, RETURNS_SYM
 
301
REVOKE, REVOKE
 
302
RIGHT, RIGHT
 
303
RLIKE, REGEXP_SYM
 
304
ROLLBACK, ROLLBACK_SYM
 
305
ROLLUP, ROLLUP_SYM
 
306
ROUTINE, ROUTINE_SYM
 
307
ROW, ROW_SYM
 
308
ROWS, ROWS_SYM
 
309
ROW_FORMAT, ROW_FORMAT_SYM
 
310
SAVEPOINT, SAVEPOINT_SYM
 
311
SCHEMA, DATABASE
 
312
SCHEMAS, DATABASES
 
313
SECOND, SECOND_SYM
 
314
SECOND_MICROSECOND, SECOND_MICROSECOND_SYM
 
315
SECURITY, SECURITY_SYM
 
316
SELECT, SELECT_SYM
 
317
SENSITIVE, SENSITIVE_SYM
 
318
SEPARATOR, SEPARATOR_SYM
 
319
SERIAL, SERIAL_SYM
 
320
SERIALIZABLE, SERIALIZABLE_SYM
 
321
SERVER, SERVER_SYM
 
322
SESSION, SESSION_SYM
 
323
SET, SET_SYM
 
324
SHARE, SHARE_SYM
 
325
SHOW, SHOW
 
326
SIGNED, SIGNED_SYM
 
327
SIMPLE, SIMPLE_SYM
 
328
SNAPSHOT, SNAPSHOT_SYM
 
329
SOME, ANY_SYM
 
330
SPECIFIC, SPECIFIC_SYM
 
331
SQL, SQL_SYM
 
332
SQLEXCEPTION, SQLEXCEPTION_SYM
 
333
SQLSTATE, SQLSTATE_SYM
 
334
SQLWARNING, SQLWARNING_SYM
 
335
SQL_BIG_RESULT, SQL_BIG_RESULT
 
336
SQL_BUFFER_RESULT, SQL_BUFFER_RESULT
 
337
SQL_CALC_FOUND_ROWS, SQL_CALC_FOUND_ROWS
 
338
SQL_SMALL_RESULT, SQL_SMALL_RESULT
 
339
SQL_TSI_DAY, DAY_SYM
 
340
SQL_TSI_FRAC_SECOND, FRAC_SECOND_SYM
 
341
SQL_TSI_HOUR, HOUR_SYM
 
342
SQL_TSI_MINUTE, MINUTE_SYM
 
343
SQL_TSI_MONTH, MONTH_SYM
 
344
SQL_TSI_QUARTER, QUARTER_SYM
 
345
SQL_TSI_SECOND, SECOND_SYM
 
346
SQL_TSI_WEEK, WEEK_SYM
 
347
SQL_TSI_YEAR, YEAR_SYM
 
348
START, START_SYM
 
349
STARTING, STARTING
 
350
STATUS, STATUS_SYM
 
351
STOP, STOP_SYM
 
352
STORED, STORED_SYM
 
353
STRAIGHT_JOIN, STRAIGHT_JOIN
 
354
STRING, STRING_SYM
 
355
SUBJECT, SUBJECT_SYM
 
356
SUSPEND, SUSPEND_SYM
 
357
TABLE, TABLE_SYM
 
358
TABLES, TABLES
 
359
TABLESPACE, TABLESPACE
 
360
TEMPORARY, TEMPORARY_SYM
 
361
TERMINATED, TERMINATED
 
362
TEXT, TEXT_SYM
 
363
THEN, THEN_SYM
 
364
TIME, TIME_SYM
 
365
TIMESTAMP, TIMESTAMP_SYM
 
366
TIMESTAMPADD, TIMESTAMP_ADD
 
367
TIMESTAMPDIFF, TIMESTAMP_DIFF
 
368
TINYBLOB, BLOB_SYM
 
369
TINYTEXT, TEXT_SYM
 
370
TO, TO_SYM
 
371
TRAILING, TRAILING
 
372
TRANSACTION, TRANSACTION_SYM
 
373
TRUE, TRUE_SYM
 
374
TRUNCATE, TRUNCATE_SYM
 
375
TYPE, TYPE_SYM
 
376
UNCOMMITTED, UNCOMMITTED_SYM
 
377
UNDO, UNDO_SYM
 
378
UNDOFILE, UNDOFILE_SYM
 
379
UNION, UNION_SYM
 
380
UNIQUE, UNIQUE_SYM
 
381
UNKNOWN, UNKNOWN_SYM
 
382
UNLOCK, UNLOCK_SYM
 
383
UNSIGNED, UNSIGNED_SYM
 
384
UPDATE, UPDATE_SYM
 
385
USAGE, USAGE
 
386
USE, USE_SYM
 
387
USER, USER
 
388
USING, USING
 
389
UTC_DATE, UTC_DATE_SYM
 
390
UTC_TIMESTAMP, UTC_TIMESTAMP_SYM
 
391
UTF8, UTF8_SYM
 
392
UUID, UUID_SYM
 
393
VALUE, VALUE_SYM
 
394
VALUES, VALUES
 
395
VARBINARY, VARBINARY
 
396
VARCHAR, VARCHAR_SYM
 
397
VARCHARACTER, VARCHAR_SYM
 
398
VARIABLES, VARIABLES
 
399
VARYING, VARYING
 
400
WAIT, WAIT_SYM
 
401
WARNINGS, WARNINGS
 
402
WEEK, WEEK_SYM
 
403
WHEN, WHEN_SYM
 
404
WHERE, WHERE
 
405
WITH, WITH
 
406
WORK, WORK_SYM
 
407
WRITE, WRITE_SYM
 
408
XOR, XOR
 
409
YEAR, YEAR_SYM
 
410
YEAR_MONTH, YEAR_MONTH_SYM
 
411
ZEROFILL, ZEROFILL_SYM