← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/symbol_hash.gperf

  • Committer: Monty Taylor
  • Date: 2009-01-30 00:53:14 UTC
  • mto: (779.3.19 devel)
  • mto: This revision was merged to the branch mainline in revision 823.
  • Revision ID: mordred@inaugust.com-20090130005314-3ufwrbqxnxu2aevi
Replaced gen_lex_hash with gperf. Yay for no more building tools to build source!!!

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