← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/lex.h

  • Committer: Brian Aker
  • Date: 2008-07-20 09:02:20 UTC
  • Revision ID: brian@tangent.org-20080720090220-bhrg1wemfnzutbgi
Convert default engine to Innodb

Show diffs side-by-side

added added

removed removed

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