← Back to branch summary

~ubuntu-branches/debian/sid/pgadmin3/sid

« back to all changes in this revision

Viewing changes to pgadmin/db/keywords.c

  • Committer: Bazaar Package Importer
  • Author(s): Gerfried Fuchs
  • Date: 2009-07-30 12:27:16 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20090730122716-fddbh42on721bbs2
Tags: 1.10.0-1
* New upstream release.
* Adjusted watch file to match release candidates.
* Updated to Standards-Version 3.8.2:
  - Moved to Section: database.
  - Add DEB_BUILD_OPTIONS support for parallel building.
  - Move from findstring to filter suggestion for DEB_BUILD_OPTIONS parsing.
* pgagent got split into its own separate source package by upstream.
* Exclude Docs.vcproj from installation.
* Move doc-base.enus from pgadmin3 to pgadmin3-data package, the files are
  in there too.

Show diffs side-by-side

added added

removed removed

Lines of Context:
pgadmin/db/keywords.c
59
59
        {"asymmetric", ASYMMETRIC, RESERVED_KEYWORD},
60
60
        {"at", AT, UNRESERVED_KEYWORD},
61
61
        {"authorization", AUTHORIZATION, TYPE_FUNC_NAME_KEYWORD},
 
62
        {"autovacuum_enabled", AUTOVACUUM_E, UNRESERVED_KEYWORD},
 
63
        {"autovacuum_vacuum_threshold", AUTOVACUUM_V_TH, UNRESERVED_KEYWORD},
 
64
        {"autovacuum_analyze_threshold", AUTOVACUUM_A_TH, UNRESERVED_KEYWORD},
 
65
        {"autovacuum_vacuum_scale_factor", AUTOVACUUM_V_SC_F, UNRESERVED_KEYWORD},
 
66
        {"autovacuum_analyze_scale_factor", AUTOVACUUM_A_SC_F, UNRESERVED_KEYWORD},
 
67
        {"autovacuum_vacuum_cost_delay", AUTOVACUUM_V_COST_D, UNRESERVED_KEYWORD},
 
68
        {"autovacuum_vacuum_cost_limit", AUTOVACUUM_V_COST_L, UNRESERVED_KEYWORD},
 
69
        {"autovacuum_freeze_min_age", AUTOVACUUM_F_MIN_AGE, UNRESERVED_KEYWORD},
 
70
        {"autovacuum_freeze_max_age", AUTOVACUUM_F_MAX_AGE, UNRESERVED_KEYWORD},
 
71
        {"autovacuum_freeze_table_age", AUTOVACUUM_F_TBL_AGE, UNRESERVED_KEYWORD},
62
72
        {"backward", BACKWARD, UNRESERVED_KEYWORD},
63
73
        {"before", BEFORE, UNRESERVED_KEYWORD},
64
74
        {"begin", BEGIN_P, UNRESERVED_KEYWORD},
107
117
        {"createuser", CREATEUSER, UNRESERVED_KEYWORD},
108
118
        {"cross", CROSS, TYPE_FUNC_NAME_KEYWORD},
109
119
        {"csv", CSV, UNRESERVED_KEYWORD},
110
 
        {"current", CURRENT_P, UNRESERVED_KEYWORD},
111
 
        {"current_date", CURRENT_DATE, RESERVED_KEYWORD},
112
 
        {"current_role", CURRENT_ROLE, RESERVED_KEYWORD},
113
 
        {"current_time", CURRENT_TIME, RESERVED_KEYWORD},
114
 
        {"current_timestamp", CURRENT_TIMESTAMP, RESERVED_KEYWORD},
115
 
        {"current_user", CURRENT_USER, RESERVED_KEYWORD},
116
 
        {"cursor", CURSOR, UNRESERVED_KEYWORD},
117
 
        {"cycle", CYCLE, UNRESERVED_KEYWORD},
118
 
        {"database", DATABASE, UNRESERVED_KEYWORD},
119
 
        {"day", DAY_P, UNRESERVED_KEYWORD},
120
 
        {"deallocate", DEALLOCATE, UNRESERVED_KEYWORD},
121
 
        {"dec", DEC, COL_NAME_KEYWORD},
122
 
        {"decimal", DECIMAL_P, COL_NAME_KEYWORD},
123
 
        {"declare", DECLARE, UNRESERVED_KEYWORD},
124
 
        {"default", DEFAULT, RESERVED_KEYWORD},
125
 
        {"defaults", DEFAULTS, UNRESERVED_KEYWORD},
126
 
        {"deferrable", DEFERRABLE, RESERVED_KEYWORD},
127
 
        {"deferred", DEFERRED, UNRESERVED_KEYWORD},
128
 
        {"definer", DEFINER, UNRESERVED_KEYWORD},
129
 
        {"delete", DELETE_P, UNRESERVED_KEYWORD},
130
 
        {"delimiter", DELIMITER, UNRESERVED_KEYWORD},
131
 
        {"delimiters", DELIMITERS, UNRESERVED_KEYWORD},
132
 
        {"desc", DESC, RESERVED_KEYWORD},
133
 
        {"dictionary", DICTIONARY, UNRESERVED_KEYWORD},
134
 
        {"disable", DISABLE_P, UNRESERVED_KEYWORD},
135
 
        {"discard", DISCARD, UNRESERVED_KEYWORD},
136
 
        {"distinct", DISTINCT, RESERVED_KEYWORD},
137
 
        {"do", DO, RESERVED_KEYWORD},
138
 
        {"document", DOCUMENT_P, UNRESERVED_KEYWORD},
139
 
        {"domain", DOMAIN_P, UNRESERVED_KEYWORD},
140
 
        {"double", DOUBLE_P, UNRESERVED_KEYWORD},
141
 
        {"drop", DROP, UNRESERVED_KEYWORD},
142
 
        {"each", EACH, UNRESERVED_KEYWORD},
143
 
        {"else", ELSE, RESERVED_KEYWORD},
144
 
        {"enable", ENABLE_P, UNRESERVED_KEYWORD},
145
 
        {"encoding", ENCODING, UNRESERVED_KEYWORD},
146
 
        {"encrypted", ENCRYPTED, UNRESERVED_KEYWORD},
147
 
        {"end", END_P, RESERVED_KEYWORD},
148
 
        {"enum", ENUM_P, UNRESERVED_KEYWORD},
149
 
        {"escape", ESCAPE, UNRESERVED_KEYWORD},
150
 
        {"except", EXCEPT, RESERVED_KEYWORD},
151
 
        {"excluding", EXCLUDING, UNRESERVED_KEYWORD},
152
 
        {"exclusive", EXCLUSIVE, UNRESERVED_KEYWORD},
 
120
    {"ctype", CTYPE, RESERVED_KEYWORD},
 
121
    {"current", CURRENT_P, UNRESERVED_KEYWORD},
 
122
    {"current_date", CURRENT_DATE, RESERVED_KEYWORD},
 
123
    {"current_role", CURRENT_ROLE, RESERVED_KEYWORD},
 
124
    {"current_time", CURRENT_TIME, RESERVED_KEYWORD},
 
125
    {"current_timestamp", CURRENT_TIMESTAMP, RESERVED_KEYWORD},
 
126
    {"current_user", CURRENT_USER, RESERVED_KEYWORD},
 
127
    {"cursor", CURSOR, UNRESERVED_KEYWORD},
 
128
    {"cycle", CYCLE, UNRESERVED_KEYWORD},
 
129
    {"database", DATABASE, UNRESERVED_KEYWORD},
 
130
    {"day", DAY_P, UNRESERVED_KEYWORD},
 
131
    {"deallocate", DEALLOCATE, UNRESERVED_KEYWORD},
 
132
    {"dec", DEC, COL_NAME_KEYWORD},
 
133
    {"decimal", DECIMAL_P, COL_NAME_KEYWORD},
 
134
    {"declare", DECLARE, UNRESERVED_KEYWORD},
 
135
    {"default", DEFAULT, RESERVED_KEYWORD},
 
136
    {"defaults", DEFAULTS, UNRESERVED_KEYWORD},
 
137
    {"deferrable", DEFERRABLE, RESERVED_KEYWORD},
 
138
    {"deferred", DEFERRED, UNRESERVED_KEYWORD},
 
139
    {"definer", DEFINER, UNRESERVED_KEYWORD},
 
140
    {"delete", DELETE_P, UNRESERVED_KEYWORD},
 
141
    {"delimiter", DELIMITER, UNRESERVED_KEYWORD},
 
142
    {"delimiters", DELIMITERS, UNRESERVED_KEYWORD},
 
143
    {"desc", DESC, RESERVED_KEYWORD},
 
144
    {"dictionary", DICTIONARY, UNRESERVED_KEYWORD},
 
145
    {"disable", DISABLE_P, UNRESERVED_KEYWORD},
 
146
    {"discard", DISCARD, UNRESERVED_KEYWORD},
 
147
    {"distinct", DISTINCT, RESERVED_KEYWORD},
 
148
    {"distributed", DISTRIBUTED_GP, UNRESERVED_KEYWORD}, /* Greenplum Keyword */
 
149
    {"do", DO, RESERVED_KEYWORD},
 
150
    {"document", DOCUMENT_P, UNRESERVED_KEYWORD},
 
151
    {"domain", DOMAIN_P, UNRESERVED_KEYWORD},
 
152
    {"double", DOUBLE_P, UNRESERVED_KEYWORD},
 
153
    {"drop", DROP, UNRESERVED_KEYWORD},
 
154
    {"each", EACH, UNRESERVED_KEYWORD},
 
155
    {"else", ELSE, RESERVED_KEYWORD},
 
156
    {"enable", ENABLE_P, UNRESERVED_KEYWORD},
 
157
    {"encoding", ENCODING, UNRESERVED_KEYWORD},
 
158
    {"encrypted", ENCRYPTED, UNRESERVED_KEYWORD},
 
159
    {"end", END_P, RESERVED_KEYWORD},
 
160
    {"enum", ENUM_P, UNRESERVED_KEYWORD},
 
161
    {"escape", ESCAPE, UNRESERVED_KEYWORD},
 
162
    {"except", EXCEPT, RESERVED_KEYWORD},
 
163
    {"excluding", EXCLUDING, UNRESERVED_KEYWORD},
 
164
    {"exclusive", EXCLUSIVE, UNRESERVED_KEYWORD},
153
165
    {"exec", EXEC_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
154
166
        {"execute", EXECUTE, UNRESERVED_KEYWORD},
155
167
        {"exists", EXISTS, COL_NAME_KEYWORD},
159
171
        {"false", FALSE_P, RESERVED_KEYWORD},
160
172
        {"family", FAMILY, UNRESERVED_KEYWORD},
161
173
        {"fetch", FETCH, UNRESERVED_KEYWORD},
 
174
        {"fillfactor", FILLFACTOR, UNRESERVED_KEYWORD},
162
175
        {"first", FIRST_P, UNRESERVED_KEYWORD},
163
176
        {"float", FLOAT_P, COL_NAME_KEYWORD},
164
177
        {"for", FOR, RESERVED_KEYWORD},
226
239
        {"localtimestamp", LOCALTIMESTAMP, RESERVED_KEYWORD},
227
240
        {"location", LOCATION, UNRESERVED_KEYWORD},
228
241
        {"lock", LOCK_P, UNRESERVED_KEYWORD},
 
242
    {"log", LOG_P_GP, RESERVED_KEYWORD},  /* Greenplum Keyword */
229
243
        {"login", LOGIN_P, UNRESERVED_KEYWORD},
230
244
    {"long", LONG_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
231
 
        {"mapping", MAPPING, UNRESERVED_KEYWORD},
232
 
        {"match", MATCH, UNRESERVED_KEYWORD},
233
 
        {"maxvalue", MAXVALUE, UNRESERVED_KEYWORD},
234
 
        {"minus", MINUS_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
235
 
        {"minute", MINUTE_P, UNRESERVED_KEYWORD},
236
 
        {"minvalue", MINVALUE, UNRESERVED_KEYWORD},
237
 
        {"mode", MODE, UNRESERVED_KEYWORD},
238
 
        {"month", MONTH_P, UNRESERVED_KEYWORD},
239
 
        {"move", MOVE, UNRESERVED_KEYWORD},
240
 
        {"name", NAME_P, UNRESERVED_KEYWORD},
241
 
        {"names", NAMES, UNRESERVED_KEYWORD},
242
 
        {"national", NATIONAL, COL_NAME_KEYWORD},
243
 
        {"natural", NATURAL, TYPE_FUNC_NAME_KEYWORD},
244
 
        {"nchar", NCHAR, COL_NAME_KEYWORD},
245
 
        {"new", NEW, RESERVED_KEYWORD},
246
 
        {"next", NEXT, UNRESERVED_KEYWORD},
247
 
        {"no", NO, UNRESERVED_KEYWORD},
 
245
    {"mapping", MAPPING, UNRESERVED_KEYWORD},
 
246
    {"match", MATCH, UNRESERVED_KEYWORD},
 
247
    {"maxvalue", MAXVALUE, UNRESERVED_KEYWORD},
 
248
    {"minus", MINUS_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
 
249
    {"minute", MINUTE_P, UNRESERVED_KEYWORD},
 
250
    {"minvalue", MINVALUE, UNRESERVED_KEYWORD},
 
251
    {"mode", MODE, UNRESERVED_KEYWORD},
 
252
    {"month", MONTH_P, UNRESERVED_KEYWORD},
 
253
    {"move", MOVE, UNRESERVED_KEYWORD},
 
254
    {"name", NAME_P, UNRESERVED_KEYWORD},
 
255
    {"names", NAMES, UNRESERVED_KEYWORD},
 
256
    {"national", NATIONAL, COL_NAME_KEYWORD},
 
257
    {"natural", NATURAL, TYPE_FUNC_NAME_KEYWORD},
 
258
    {"nchar", NCHAR, COL_NAME_KEYWORD},
 
259
    {"new", NEW, RESERVED_KEYWORD},
 
260
    {"next", NEXT, UNRESERVED_KEYWORD},
 
261
    {"no", NO, UNRESERVED_KEYWORD},
248
262
    {"nocache", NOCACHE_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
249
 
        {"nocreatedb", NOCREATEDB, UNRESERVED_KEYWORD},
250
 
        {"nocreaterole", NOCREATEROLE, UNRESERVED_KEYWORD},
251
 
        {"nocreateuser", NOCREATEUSER, UNRESERVED_KEYWORD},
252
 
        {"noinherit", NOINHERIT, UNRESERVED_KEYWORD},
253
 
        {"nologin", NOLOGIN_P, UNRESERVED_KEYWORD},
254
 
        {"none", NONE, COL_NAME_KEYWORD},
255
 
        {"nosuperuser", NOSUPERUSER, UNRESERVED_KEYWORD},
256
 
        {"not", NOT, RESERVED_KEYWORD},
257
 
        {"nothing", NOTHING, UNRESERVED_KEYWORD},
258
 
        {"notify", NOTIFY, UNRESERVED_KEYWORD},
259
 
        {"notnull", NOTNULL, TYPE_FUNC_NAME_KEYWORD},
260
 
        {"nowait", NOWAIT, UNRESERVED_KEYWORD},
261
 
        {"null", NULL_P, RESERVED_KEYWORD},
262
 
        {"nullif", NULLIF, COL_NAME_KEYWORD},
263
 
        {"nulls", NULLS_P, UNRESERVED_KEYWORD},
 
263
    {"nocreatedb", NOCREATEDB, UNRESERVED_KEYWORD},
 
264
    {"nocreaterole", NOCREATEROLE, UNRESERVED_KEYWORD},
 
265
    {"nocreateuser", NOCREATEUSER, UNRESERVED_KEYWORD},
 
266
    {"noinherit", NOINHERIT, UNRESERVED_KEYWORD},
 
267
    {"nologin", NOLOGIN_P, UNRESERVED_KEYWORD},
 
268
    {"none", NONE, COL_NAME_KEYWORD},
 
269
    {"nosuperuser", NOSUPERUSER, UNRESERVED_KEYWORD},
 
270
    {"not", NOT, RESERVED_KEYWORD},
 
271
    {"nothing", NOTHING, UNRESERVED_KEYWORD},
 
272
    {"notify", NOTIFY, UNRESERVED_KEYWORD},
 
273
    {"notnull", NOTNULL, TYPE_FUNC_NAME_KEYWORD},
 
274
    {"nowait", NOWAIT, UNRESERVED_KEYWORD},
 
275
    {"null", NULL_P, RESERVED_KEYWORD},
 
276
    {"nullif", NULLIF, COL_NAME_KEYWORD},
 
277
    {"nulls", NULLS_P, UNRESERVED_KEYWORD},
264
278
    {"number", NUMBER_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
265
 
        {"numeric", NUMERIC, COL_NAME_KEYWORD},
266
 
        {"object", OBJECT_P, UNRESERVED_KEYWORD},
267
 
        {"of", OF, UNRESERVED_KEYWORD},
268
 
        {"off", OFF, RESERVED_KEYWORD},
269
 
        {"offset", OFFSET, RESERVED_KEYWORD},
270
 
        {"oids", OIDS, UNRESERVED_KEYWORD},
271
 
        {"old", OLD, RESERVED_KEYWORD},
272
 
        {"on", ON, RESERVED_KEYWORD},
273
 
        {"only", ONLY, RESERVED_KEYWORD},
274
 
        {"operator", OPERATOR, UNRESERVED_KEYWORD},
275
 
        {"option", OPTION, UNRESERVED_KEYWORD},
276
 
        {"or", OR, RESERVED_KEYWORD},
277
 
        {"order", ORDER, RESERVED_KEYWORD},
278
 
        {"out", OUT_P, COL_NAME_KEYWORD},
279
 
        {"outer", OUTER_P, TYPE_FUNC_NAME_KEYWORD},
280
 
        {"overlaps", OVERLAPS, TYPE_FUNC_NAME_KEYWORD},
281
 
        {"overlay", OVERLAY, COL_NAME_KEYWORD},
282
 
        {"owned", OWNED, UNRESERVED_KEYWORD},
283
 
        {"owner", OWNER, UNRESERVED_KEYWORD},
 
279
    {"numeric", NUMERIC, COL_NAME_KEYWORD},
 
280
    {"object", OBJECT_P, UNRESERVED_KEYWORD},
 
281
    {"of", OF, UNRESERVED_KEYWORD},
 
282
    {"off", OFF, RESERVED_KEYWORD},
 
283
    {"offset", OFFSET, RESERVED_KEYWORD},
 
284
    {"oids", OIDS, UNRESERVED_KEYWORD},
 
285
    {"old", OLD, RESERVED_KEYWORD},
 
286
    {"on", ON, RESERVED_KEYWORD},
 
287
    {"only", ONLY, RESERVED_KEYWORD},
 
288
    {"operator", OPERATOR, UNRESERVED_KEYWORD},
 
289
    {"option", OPTION, UNRESERVED_KEYWORD},
 
290
    {"or", OR, RESERVED_KEYWORD},
 
291
    {"order", ORDER, RESERVED_KEYWORD},
 
292
    {"out", OUT_P, COL_NAME_KEYWORD},
 
293
    {"outer", OUTER_P, TYPE_FUNC_NAME_KEYWORD},
 
294
    {"overlaps", OVERLAPS, TYPE_FUNC_NAME_KEYWORD},
 
295
    {"overlay", OVERLAY, COL_NAME_KEYWORD},
 
296
    {"owned", OWNED, UNRESERVED_KEYWORD},
 
297
    {"owner", OWNER, UNRESERVED_KEYWORD},
284
298
    {"package", PACKAGE_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
285
 
        {"parser", PARSER, UNRESERVED_KEYWORD},
286
 
        {"partial", PARTIAL, UNRESERVED_KEYWORD},
287
 
        {"password", PASSWORD, UNRESERVED_KEYWORD},
288
 
        {"placing", PLACING, RESERVED_KEYWORD},
289
 
        {"plans", PLANS, UNRESERVED_KEYWORD},
 
299
    {"parser", PARSER, UNRESERVED_KEYWORD},
 
300
    {"partial", PARTIAL, UNRESERVED_KEYWORD},
 
301
    {"password", PASSWORD, UNRESERVED_KEYWORD},
 
302
    {"placing", PLACING, RESERVED_KEYWORD},
 
303
    {"plans", PLANS, UNRESERVED_KEYWORD},
290
304
    {"pls_integer", PLS_INTEGER_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
291
 
        {"position", POSITION, COL_NAME_KEYWORD},
292
 
        {"precision", PRECISION, COL_NAME_KEYWORD},
293
 
        {"prepare", PREPARE, UNRESERVED_KEYWORD},
294
 
        {"prepared", PREPARED, UNRESERVED_KEYWORD},
295
 
        {"preserve", PRESERVE, UNRESERVED_KEYWORD},
296
 
        {"primary", PRIMARY, RESERVED_KEYWORD},
297
 
        {"prior", PRIOR, UNRESERVED_KEYWORD},
298
 
        {"privileges", PRIVILEGES, UNRESERVED_KEYWORD},
299
 
        {"procedural", PROCEDURAL, UNRESERVED_KEYWORD},
300
 
        {"procedure", PROCEDURE, UNRESERVED_KEYWORD},
301
 
        {"quote", QUOTE, UNRESERVED_KEYWORD},
 
305
    {"position", POSITION, COL_NAME_KEYWORD},
 
306
    {"precision", PRECISION, COL_NAME_KEYWORD},
 
307
    {"prepare", PREPARE, UNRESERVED_KEYWORD},
 
308
    {"prepared", PREPARED, UNRESERVED_KEYWORD},
 
309
    {"preserve", PRESERVE, UNRESERVED_KEYWORD},
 
310
    {"primary", PRIMARY, RESERVED_KEYWORD},
 
311
    {"prior", PRIOR, UNRESERVED_KEYWORD},
 
312
    {"privileges", PRIVILEGES, UNRESERVED_KEYWORD},
 
313
    {"procedural", PROCEDURAL, UNRESERVED_KEYWORD},
 
314
    {"procedure", PROCEDURE, UNRESERVED_KEYWORD},
 
315
    {"quote", QUOTE, UNRESERVED_KEYWORD},
302
316
    {"raw", RAW_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
303
 
        {"read", READ, UNRESERVED_KEYWORD},
304
 
        {"real", REAL, COL_NAME_KEYWORD},
305
 
        {"reassign", REASSIGN, UNRESERVED_KEYWORD},
306
 
        {"recheck", RECHECK, UNRESERVED_KEYWORD},
307
 
        {"references", REFERENCES, RESERVED_KEYWORD},
308
 
        {"reindex", REINDEX, UNRESERVED_KEYWORD},
309
 
        {"relative", RELATIVE_P, UNRESERVED_KEYWORD},
310
 
        {"release", RELEASE, UNRESERVED_KEYWORD},
311
 
        {"rename", RENAME, UNRESERVED_KEYWORD},
312
 
        {"repeatable", REPEATABLE, UNRESERVED_KEYWORD},
313
 
        {"replace", REPLACE, UNRESERVED_KEYWORD},
314
 
        {"replica", REPLICA, UNRESERVED_KEYWORD},
315
 
        {"reset", RESET, UNRESERVED_KEYWORD},
316
 
        {"restart", RESTART, UNRESERVED_KEYWORD},
317
 
        {"restrict", RESTRICT, UNRESERVED_KEYWORD},
 
317
    {"read", READ, UNRESERVED_KEYWORD},
 
318
    {"real", REAL, COL_NAME_KEYWORD},
 
319
    {"reassign", REASSIGN, UNRESERVED_KEYWORD},
 
320
    {"recheck", RECHECK, UNRESERVED_KEYWORD},
 
321
    {"references", REFERENCES, RESERVED_KEYWORD},
 
322
    {"reindex", REINDEX, UNRESERVED_KEYWORD},
 
323
    {"relative", RELATIVE_P, UNRESERVED_KEYWORD},
 
324
    {"release", RELEASE, UNRESERVED_KEYWORD},
 
325
    {"rename", RENAME, UNRESERVED_KEYWORD},
 
326
    {"repeatable", REPEATABLE, UNRESERVED_KEYWORD},
 
327
    {"replace", REPLACE, UNRESERVED_KEYWORD},
 
328
    {"replica", REPLICA, UNRESERVED_KEYWORD},
 
329
    {"reset", RESET, UNRESERVED_KEYWORD},
 
330
    {"restart", RESTART, UNRESERVED_KEYWORD},
 
331
    {"restrict", RESTRICT, UNRESERVED_KEYWORD},
318
332
    {"return", RETURN_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
319
 
        {"returning", RETURNING, RESERVED_KEYWORD},
320
 
        {"returns", RETURNS, UNRESERVED_KEYWORD},
321
 
        {"revoke", REVOKE, UNRESERVED_KEYWORD},
322
 
        {"right", RIGHT, TYPE_FUNC_NAME_KEYWORD},
323
 
        {"role", ROLE, UNRESERVED_KEYWORD},
324
 
        {"rollback", ROLLBACK, UNRESERVED_KEYWORD},
325
 
        {"row", ROW, COL_NAME_KEYWORD},
326
 
        {"rows", ROWS, UNRESERVED_KEYWORD},
327
 
        {"rule", RULE, UNRESERVED_KEYWORD},
328
 
        {"savepoint", SAVEPOINT, UNRESERVED_KEYWORD},
329
 
        {"schema", SCHEMA, UNRESERVED_KEYWORD},
330
 
        {"scroll", SCROLL, UNRESERVED_KEYWORD},
331
 
        {"search", SEARCH, UNRESERVED_KEYWORD},
332
 
        {"second", SECOND_P, UNRESERVED_KEYWORD},
333
 
        {"security", SECURITY, UNRESERVED_KEYWORD},
334
 
        {"select", SELECT, RESERVED_KEYWORD},
335
 
        {"sequence", SEQUENCE, UNRESERVED_KEYWORD},
336
 
        {"serializable", SERIALIZABLE, UNRESERVED_KEYWORD},
337
 
        {"session", SESSION, UNRESERVED_KEYWORD},
338
 
        {"session_user", SESSION_USER, RESERVED_KEYWORD},
339
 
        {"set", SET, UNRESERVED_KEYWORD},
340
 
        {"setof", SETOF, COL_NAME_KEYWORD},
341
 
        {"share", SHARE, UNRESERVED_KEYWORD},
342
 
        {"show", SHOW, UNRESERVED_KEYWORD},
343
 
        {"similar", SIMILAR, TYPE_FUNC_NAME_KEYWORD},
344
 
        {"simple", SIMPLE, UNRESERVED_KEYWORD},
 
333
    {"returning", RETURNING, RESERVED_KEYWORD},
 
334
    {"returns", RETURNS, UNRESERVED_KEYWORD},
 
335
    {"revoke", REVOKE, UNRESERVED_KEYWORD},
 
336
    {"right", RIGHT, TYPE_FUNC_NAME_KEYWORD},
 
337
    {"role", ROLE, UNRESERVED_KEYWORD},
 
338
    {"rollback", ROLLBACK, UNRESERVED_KEYWORD},
 
339
    {"row", ROW, COL_NAME_KEYWORD},
 
340
    {"rows", ROWS, UNRESERVED_KEYWORD},
 
341
    {"rule", RULE, UNRESERVED_KEYWORD},
 
342
    {"savepoint", SAVEPOINT, UNRESERVED_KEYWORD},
 
343
    {"schema", SCHEMA, UNRESERVED_KEYWORD},
 
344
    {"scroll", SCROLL, UNRESERVED_KEYWORD},
 
345
    {"search", SEARCH, UNRESERVED_KEYWORD},
 
346
    {"second", SECOND_P, UNRESERVED_KEYWORD},
 
347
    {"security", SECURITY, UNRESERVED_KEYWORD},
 
348
    {"select", SELECT, RESERVED_KEYWORD},
 
349
    {"sequence", SEQUENCE, UNRESERVED_KEYWORD},
 
350
    {"serializable", SERIALIZABLE, UNRESERVED_KEYWORD},
 
351
    {"session", SESSION, UNRESERVED_KEYWORD},
 
352
    {"session_user", SESSION_USER, RESERVED_KEYWORD},
 
353
    {"set", SET, UNRESERVED_KEYWORD},
 
354
    {"setof", SETOF, COL_NAME_KEYWORD},
 
355
    {"share", SHARE, UNRESERVED_KEYWORD},
 
356
    {"show", SHOW, UNRESERVED_KEYWORD},
 
357
    {"similar", SIMILAR, TYPE_FUNC_NAME_KEYWORD},
 
358
    {"simple", SIMPLE, UNRESERVED_KEYWORD},
345
359
    {"smalldatetime", SMALLDATETIME_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
346
 
        {"smallfloat", SMALLFLOAT_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
347
 
        {"smallint", SMALLINT, COL_NAME_KEYWORD},
348
 
        {"smallmoney", SMALLMONEY_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
349
 
        {"some", SOME, RESERVED_KEYWORD},
350
 
        {"stable", STABLE, UNRESERVED_KEYWORD},
351
 
        {"standalone", STANDALONE_P, UNRESERVED_KEYWORD},
352
 
        {"start", START, UNRESERVED_KEYWORD},
353
 
        {"statement", STATEMENT, UNRESERVED_KEYWORD},
354
 
        {"statistics", STATISTICS, UNRESERVED_KEYWORD},
355
 
        {"stdin", STDIN, UNRESERVED_KEYWORD},
356
 
        {"stdout", STDOUT, UNRESERVED_KEYWORD},
357
 
        {"storage", STORAGE, UNRESERVED_KEYWORD},
358
 
        {"strict", STRICT_P, UNRESERVED_KEYWORD},
359
 
        {"strip", STRIP_P, UNRESERVED_KEYWORD},
360
 
        {"substring", SUBSTRING, COL_NAME_KEYWORD},
361
 
        {"superuser", SUPERUSER_P, UNRESERVED_KEYWORD},
362
 
        {"symmetric", SYMMETRIC, RESERVED_KEYWORD},
 
360
    {"smallfloat", SMALLFLOAT_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
 
361
    {"smallint", SMALLINT, COL_NAME_KEYWORD},
 
362
    {"smallmoney", SMALLMONEY_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
 
363
    {"some", SOME, RESERVED_KEYWORD},
 
364
    {"stable", STABLE, UNRESERVED_KEYWORD},
 
365
    {"standalone", STANDALONE_P, UNRESERVED_KEYWORD},
 
366
    {"start", START, UNRESERVED_KEYWORD},
 
367
    {"statement", STATEMENT, UNRESERVED_KEYWORD},
 
368
    {"statistics", STATISTICS, UNRESERVED_KEYWORD},
 
369
    {"stdin", STDIN, UNRESERVED_KEYWORD},
 
370
    {"stdout", STDOUT, UNRESERVED_KEYWORD},
 
371
    {"storage", STORAGE, UNRESERVED_KEYWORD},
 
372
    {"strict", STRICT_P, UNRESERVED_KEYWORD},
 
373
    {"strip", STRIP_P, UNRESERVED_KEYWORD},
 
374
    {"substring", SUBSTRING, COL_NAME_KEYWORD},
 
375
    {"superuser", SUPERUSER_P, UNRESERVED_KEYWORD},
 
376
    {"symmetric", SYMMETRIC, RESERVED_KEYWORD},
363
377
    {"sysdate", SYSDATE_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
364
 
        {"sysid", SYSID, UNRESERVED_KEYWORD},
365
 
        {"system", SYSTEM_P, UNRESERVED_KEYWORD},
 
378
    {"sysid", SYSID, UNRESERVED_KEYWORD},
 
379
    {"system", SYSTEM_P, UNRESERVED_KEYWORD},
366
380
    {"systimestamp", SYSTIMESTAMP_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
367
 
        {"table", TABLE, RESERVED_KEYWORD},
368
 
        {"tablespace", TABLESPACE, UNRESERVED_KEYWORD},
369
 
        {"temp", TEMP, UNRESERVED_KEYWORD},
370
 
        {"template", TEMPLATE, UNRESERVED_KEYWORD},
371
 
        {"temporary", TEMPORARY, UNRESERVED_KEYWORD},
372
 
        {"text", TEXT_P, UNRESERVED_KEYWORD},
373
 
        {"then", THEN, RESERVED_KEYWORD},
374
 
        {"time", TIME, COL_NAME_KEYWORD},
375
 
        {"timestamp", TIMESTAMP, COL_NAME_KEYWORD},
376
 
        {"tinyint", TINYINT_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
377
 
        {"tinytext", TINYTEXT_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
378
 
        {"to", TO, RESERVED_KEYWORD},
379
 
        {"trailing", TRAILING, RESERVED_KEYWORD},
380
 
        {"transaction", TRANSACTION, UNRESERVED_KEYWORD},
381
 
        {"treat", TREAT, COL_NAME_KEYWORD},
382
 
        {"trigger", TRIGGER, UNRESERVED_KEYWORD},
383
 
        {"trim", TRIM, COL_NAME_KEYWORD},
384
 
        {"true", TRUE_P, RESERVED_KEYWORD},
385
 
        {"truncate", TRUNCATE, UNRESERVED_KEYWORD},
386
 
        {"trusted", TRUSTED, UNRESERVED_KEYWORD},
387
 
        {"type", TYPE_P, UNRESERVED_KEYWORD},
388
 
        {"uncommitted", UNCOMMITTED, UNRESERVED_KEYWORD},
389
 
        {"unencrypted", UNENCRYPTED, UNRESERVED_KEYWORD},
390
 
        {"union", UNION, RESERVED_KEYWORD},
391
 
        {"unique", UNIQUE, RESERVED_KEYWORD},
392
 
        {"unknown", UNKNOWN, UNRESERVED_KEYWORD},
393
 
        {"unlisten", UNLISTEN, UNRESERVED_KEYWORD},
394
 
        {"until", UNTIL, UNRESERVED_KEYWORD},
395
 
        {"update", UPDATE, UNRESERVED_KEYWORD},
396
 
        {"user", USER, RESERVED_KEYWORD},
397
 
        {"using", USING, RESERVED_KEYWORD},
398
 
        {"vacuum", VACUUM, UNRESERVED_KEYWORD},
399
 
        {"valid", VALID, UNRESERVED_KEYWORD},
400
 
        {"validator", VALIDATOR, UNRESERVED_KEYWORD},
401
 
        {"value", VALUE_P, UNRESERVED_KEYWORD},
402
 
        {"values", VALUES, COL_NAME_KEYWORD},
403
 
        {"varchar", VARCHAR, COL_NAME_KEYWORD},
 
381
    {"table", TABLE, RESERVED_KEYWORD},
 
382
    {"tablespace", TABLESPACE, UNRESERVED_KEYWORD},
 
383
    {"temp", TEMP, UNRESERVED_KEYWORD},
 
384
    {"template", TEMPLATE, UNRESERVED_KEYWORD},
 
385
    {"temporary", TEMPORARY, UNRESERVED_KEYWORD},
 
386
    {"text", TEXT_P, UNRESERVED_KEYWORD},
 
387
    {"then", THEN, RESERVED_KEYWORD},
 
388
    {"time", TIME, COL_NAME_KEYWORD},
 
389
    {"timestamp", TIMESTAMP, COL_NAME_KEYWORD},
 
390
    {"tinyint", TINYINT_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
 
391
    {"tinytext", TINYTEXT_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
 
392
    {"to", TO, RESERVED_KEYWORD},
 
393
    {"trailing", TRAILING, RESERVED_KEYWORD},
 
394
    {"transaction", TRANSACTION, UNRESERVED_KEYWORD},
 
395
    {"treat", TREAT, COL_NAME_KEYWORD},
 
396
    {"trigger", TRIGGER, UNRESERVED_KEYWORD},
 
397
    {"trim", TRIM, COL_NAME_KEYWORD},
 
398
    {"true", TRUE_P, RESERVED_KEYWORD},
 
399
    {"truncate", TRUNCATE, UNRESERVED_KEYWORD},
 
400
    {"trusted", TRUSTED, UNRESERVED_KEYWORD},
 
401
    {"type", TYPE_P, UNRESERVED_KEYWORD},
 
402
    {"uncommitted", UNCOMMITTED, UNRESERVED_KEYWORD},
 
403
    {"unencrypted", UNENCRYPTED, UNRESERVED_KEYWORD},
 
404
    {"union", UNION, RESERVED_KEYWORD},
 
405
    {"unique", UNIQUE, RESERVED_KEYWORD},
 
406
    {"unknown", UNKNOWN, UNRESERVED_KEYWORD},
 
407
    {"unlisten", UNLISTEN, UNRESERVED_KEYWORD},
 
408
    {"until", UNTIL, UNRESERVED_KEYWORD},
 
409
    {"update", UPDATE, UNRESERVED_KEYWORD},
 
410
    {"user", USER, RESERVED_KEYWORD},
 
411
    {"using", USING, RESERVED_KEYWORD},
 
412
    {"vacuum", VACUUM, UNRESERVED_KEYWORD},
 
413
    {"valid", VALID, UNRESERVED_KEYWORD},
 
414
    {"validator", VALIDATOR, UNRESERVED_KEYWORD},
 
415
    {"value", VALUE_P, UNRESERVED_KEYWORD},
 
416
    {"values", VALUES, COL_NAME_KEYWORD},
 
417
    {"varchar", VARCHAR, COL_NAME_KEYWORD},
404
418
    {"varchar2", VARCHAR2_EDB, RESERVED_KEYWORD}, /* EnterpriseDB Keyword */
405
 
        {"varying", VARYING, UNRESERVED_KEYWORD},
406
 
        {"verbose", VERBOSE, TYPE_FUNC_NAME_KEYWORD},
407
 
        {"version", VERSION_P, UNRESERVED_KEYWORD},
408
 
        {"view", VIEW, UNRESERVED_KEYWORD},
409
 
        {"volatile", VOLATILE, UNRESERVED_KEYWORD},
410
 
        {"when", WHEN, RESERVED_KEYWORD},
411
 
        {"where", WHERE, RESERVED_KEYWORD},
412
 
        {"whitespace", WHITESPACE_P, UNRESERVED_KEYWORD},
 
419
    {"varying", VARYING, UNRESERVED_KEYWORD},
 
420
    {"verbose", VERBOSE, TYPE_FUNC_NAME_KEYWORD},
 
421
    {"version", VERSION_P, UNRESERVED_KEYWORD},
 
422
    {"view", VIEW, UNRESERVED_KEYWORD},
 
423
    {"volatile", VOLATILE, UNRESERVED_KEYWORD},
 
424
    {"when", WHEN, RESERVED_KEYWORD},
 
425
    {"where", WHERE, RESERVED_KEYWORD},
 
426
    {"whitespace", WHITESPACE_P, UNRESERVED_KEYWORD},
413
427
 
414
 
        /*
415
 
         * XXX we mark WITH as reserved to force it to be quoted in dumps, even
416
 
         * though it is currently unreserved according to gram.y.  This is because
417
 
         * we expect we'll have to make it reserved to implement SQL WITH clauses.
418
 
         * If that patch manages to do without reserving WITH, adjust this entry
419
 
         * at that time; in any case this should be back in sync with gram.y after
420
 
         * WITH clauses are implemented.
421
 
         */
422
 
        {"with", WITH, RESERVED_KEYWORD},
423
 
        {"without", WITHOUT, UNRESERVED_KEYWORD},
424
 
        {"work", WORK, UNRESERVED_KEYWORD},
425
 
        {"write", WRITE, UNRESERVED_KEYWORD},
426
 
        {"xml", XML_P, UNRESERVED_KEYWORD},
427
 
        {"xmlattributes", XMLATTRIBUTES, COL_NAME_KEYWORD},
428
 
        {"xmlconcat", XMLCONCAT, COL_NAME_KEYWORD},
429
 
        {"xmlelement", XMLELEMENT, COL_NAME_KEYWORD},
430
 
        {"xmlforest", XMLFOREST, COL_NAME_KEYWORD},
431
 
        {"xmlparse", XMLPARSE, COL_NAME_KEYWORD},
432
 
        {"xmlpi", XMLPI, COL_NAME_KEYWORD},
433
 
        {"xmlroot", XMLROOT, COL_NAME_KEYWORD},
434
 
        {"xmlserialize", XMLSERIALIZE, COL_NAME_KEYWORD},
435
 
        {"year", YEAR_P, UNRESERVED_KEYWORD},
436
 
        {"yes", YES_P, UNRESERVED_KEYWORD},
437
 
        {"zone", ZONE, UNRESERVED_KEYWORD},
 
428
    /*
 
429
     * XXX we mark WITH as reserved to force it to be quoted in dumps, even
 
430
     * though it is currently unreserved according to gram.y.  This is because
 
431
     * we expect we'll have to make it reserved to implement SQL WITH clauses.
 
432
     * If that patch manages to do without reserving WITH, adjust this entry
 
433
     * at that time; in any case this should be back in sync with gram.y after
 
434
     * WITH clauses are implemented.
 
435
     */
 
436
    {"window", WINDOW, RESERVED_KEYWORD},
 
437
    {"with", WITH, RESERVED_KEYWORD},
 
438
    {"without", WITHOUT, UNRESERVED_KEYWORD},
 
439
    {"work", WORK, UNRESERVED_KEYWORD},
 
440
    {"write", WRITE, UNRESERVED_KEYWORD},
 
441
    {"xml", XML_P, UNRESERVED_KEYWORD},
 
442
    {"xmlattributes", XMLATTRIBUTES, COL_NAME_KEYWORD},
 
443
    {"xmlconcat", XMLCONCAT, COL_NAME_KEYWORD},
 
444
    {"xmlelement", XMLELEMENT, COL_NAME_KEYWORD},
 
445
    {"xmlforest", XMLFOREST, COL_NAME_KEYWORD},
 
446
    {"xmlparse", XMLPARSE, COL_NAME_KEYWORD},
 
447
    {"xmlpi", XMLPI, COL_NAME_KEYWORD},
 
448
    {"xmlroot", XMLROOT, COL_NAME_KEYWORD},
 
449
    {"xmlserialize", XMLSERIALIZE, COL_NAME_KEYWORD},
 
450
    {"year", YEAR_P, UNRESERVED_KEYWORD},
 
451
    {"yes", YES_P, UNRESERVED_KEYWORD},
 
452
    {"zone", ZONE, UNRESERVED_KEYWORD},
438
453
};
439
454
 
440
455
/*
452
467
const ScanKeyword *
453
468
ScanKeywordLookup(const char *text)
454
469
{
455
 
        int                     len,
456
 
                                i;
457
 
        char            word[NAMEDATALEN];
458
 
        const ScanKeyword *low;
459
 
        const ScanKeyword *high;
460
 
 
461
 
        len = strlen(text);
462
 
        /* We assume all keywords are shorter than NAMEDATALEN. */
463
 
        if (len >= NAMEDATALEN)
464
 
                return NULL;
465
 
 
466
 
        /*
467
 
         * Apply an ASCII-only downcasing.      We must not use tolower() since it may
468
 
         * produce the wrong translation in some locales (eg, Turkish).
469
 
         */
470
 
        for (i = 0; i < len; i++)
471
 
        {
472
 
                char            ch = text[i];
473
 
 
474
 
                if (ch >= 'A' && ch <= 'Z')
475
 
                        ch += 'a' - 'A';
476
 
                word[i] = ch;
477
 
        }
478
 
        word[len] = '\0';
479
 
 
480
 
        /*
481
 
         * Now do a binary search using plain strcmp() comparison.
482
 
         */
483
 
        low = &ScanKeywords[0];
484
 
        high = endof(ScanKeywords) - 1;
485
 
        while (low <= high)
486
 
        {
487
 
                const ScanKeyword *middle;
488
 
                int                     difference;
489
 
 
490
 
                middle = low + (high - low) / 2;
491
 
                difference = strcmp(middle->name, word);
492
 
                if (difference == 0)
493
 
                        return middle;
494
 
                else if (difference < 0)
495
 
                        low = middle + 1;
496
 
                else
497
 
                        high = middle - 1;
498
 
        }
499
 
 
500
 
        return NULL;
 
470
    int                 len,
 
471
                i;
 
472
    char                word[NAMEDATALEN];
 
473
    const ScanKeyword *low;
 
474
    const ScanKeyword *high;
 
475
 
 
476
    len = strlen(text);
 
477
    /* We assume all keywords are shorter than NAMEDATALEN. */
 
478
    if (len >= NAMEDATALEN)
 
479
        return NULL;
 
480
 
 
481
    /*
 
482
     * Apply an ASCII-only downcasing.  We must not use tolower() since it may
 
483
     * produce the wrong translation in some locales (eg, Turkish).
 
484
     */
 
485
    for (i = 0; i < len; i++)
 
486
    {
 
487
        char            ch = text[i];
 
488
 
 
489
        if (ch >= 'A' && ch <= 'Z')
 
490
            ch += 'a' - 'A';
 
491
        word[i] = ch;
 
492
    }
 
493
    word[len] = '\0';
 
494
 
 
495
    /*
 
496
     * Now do a binary search using plain strcmp() comparison.
 
497
     */
 
498
    low = &ScanKeywords[0];
 
499
    high = endof(ScanKeywords) - 1;
 
500
    while (low <= high)
 
501
    {
 
502
        const ScanKeyword *middle;
 
503
        int                     difference;
 
504
 
 
505
        middle = low + (high - low) / 2;
 
506
        difference = strcmp(middle->name, word);
 
507
        if (difference == 0)
 
508
            return middle;
 
509
        else if (difference < 0)
 
510
            low = middle + 1;
 
511
        else
 
512
            high = middle - 1;
 
513
    }
 
514
 
 
515
    return NULL;
501
516
}
502