From 2c8e68000bc60c4c5226dd64507f48e897243f14 Mon Sep 17 00:00:00 2001 From: Evan Jones Date: Sat, 30 Sep 2023 15:01:47 -0400 Subject: [PATCH] pg_query.proto: Add Token ASCII_36; Add scan test Postgres's scanner will scan $ into a single token. For example: SELECT $identifier; The parser will later reject this. However, since the scanner returns this value, we should define a Token for it in the protobuf. test/scan.c: * Add a check so the test does not crash if token_kind is NULL, which it was before I defined the token. The test now prints an error: INVALID result for "...": scan_result token 1 token_kind == NULL * Make tests constant to prevent accidental modification. Unnecessary but could be helpful. * Define testsCount automatically so it no longer needs to be changed. * Add an assert to help ensure tests are defined correctly. --- protobuf/pg_query.pb-c.c | 1030 +++++++++++++++++++------------------- protobuf/pg_query.pb-c.h | 4 + protobuf/pg_query.proto | 1 + test/scan.c | 8 + test/scan_tests.c | 10 +- 5 files changed, 536 insertions(+), 517 deletions(-) diff --git a/protobuf/pg_query.pb-c.c b/protobuf/pg_query.pb-c.c index b54ae9ad..88b655cd 100644 --- a/protobuf/pg_query.pb-c.c +++ b/protobuf/pg_query.pb-c.c @@ -38612,9 +38612,10 @@ const ProtobufCEnumDescriptor pg_query__keyword_kind__descriptor = pg_query__keyword_kind__value_ranges, NULL,NULL,NULL,NULL /* reserved[1234] */ }; -static const ProtobufCEnumValue pg_query__token__enum_values_by_number[508] = +static const ProtobufCEnumValue pg_query__token__enum_values_by_number[509] = { { "NUL", "PG_QUERY__TOKEN__NUL", 0 }, + { "ASCII_36", "PG_QUERY__TOKEN__ASCII_36", 36 }, { "ASCII_37", "PG_QUERY__TOKEN__ASCII_37", 37 }, { "ASCII_40", "PG_QUERY__TOKEN__ASCII_40", 40 }, { "ASCII_41", "PG_QUERY__TOKEN__ASCII_41", 41 }, @@ -39124,518 +39125,519 @@ static const ProtobufCEnumValue pg_query__token__enum_values_by_number[508] = { "UMINUS", "PG_QUERY__TOKEN__UMINUS", 745 }, }; static const ProtobufCIntRange pg_query__token__value_ranges[] = { -{0, 0},{37, 1},{40, 2},{58, 10},{91, 16},{258, 20},{0, 508} -}; -static const ProtobufCEnumValueIndex pg_query__token__enum_values_by_name[508] = -{ - { "ABORT_P", 39 }, - { "ABSOLUTE_P", 40 }, - { "ACCESS", 41 }, - { "ACTION", 42 }, - { "ADD_P", 43 }, - { "ADMIN", 44 }, - { "AFTER", 45 }, - { "AGGREGATE", 46 }, - { "ALL", 47 }, - { "ALSO", 48 }, - { "ALTER", 49 }, - { "ALWAYS", 50 }, - { "ANALYSE", 51 }, - { "ANALYZE", 52 }, - { "AND", 53 }, - { "ANY", 54 }, - { "ARRAY", 55 }, - { "AS", 56 }, - { "ASC", 57 }, - { "ASCII_37", 1 }, - { "ASCII_40", 2 }, - { "ASCII_41", 3 }, - { "ASCII_42", 4 }, - { "ASCII_43", 5 }, - { "ASCII_44", 6 }, - { "ASCII_45", 7 }, - { "ASCII_46", 8 }, - { "ASCII_47", 9 }, - { "ASCII_58", 10 }, - { "ASCII_59", 11 }, - { "ASCII_60", 12 }, - { "ASCII_61", 13 }, - { "ASCII_62", 14 }, - { "ASCII_63", 15 }, - { "ASCII_91", 16 }, - { "ASCII_92", 17 }, - { "ASCII_93", 18 }, - { "ASCII_94", 19 }, - { "ASENSITIVE", 58 }, - { "ASSERTION", 59 }, - { "ASSIGNMENT", 60 }, - { "ASYMMETRIC", 61 }, - { "AT", 63 }, - { "ATOMIC", 62 }, - { "ATTACH", 64 }, - { "ATTRIBUTE", 65 }, - { "AUTHORIZATION", 66 }, - { "BACKWARD", 67 }, - { "BCONST", 25 }, - { "BEFORE", 68 }, - { "BEGIN_P", 69 }, - { "BETWEEN", 70 }, - { "BIGINT", 71 }, - { "BINARY", 72 }, - { "BIT", 73 }, - { "BOOLEAN_P", 74 }, - { "BOTH", 75 }, - { "BREADTH", 76 }, - { "BY", 77 }, - { "CACHE", 78 }, - { "CALL", 79 }, - { "CALLED", 80 }, - { "CASCADE", 81 }, - { "CASCADED", 82 }, - { "CASE", 83 }, - { "CAST", 84 }, - { "CATALOG_P", 85 }, - { "CHAIN", 86 }, - { "CHARACTER", 88 }, - { "CHARACTERISTICS", 89 }, - { "CHAR_P", 87 }, - { "CHECK", 90 }, - { "CHECKPOINT", 91 }, - { "CLASS", 92 }, - { "CLOSE", 93 }, - { "CLUSTER", 94 }, - { "COALESCE", 95 }, - { "COLLATE", 96 }, - { "COLLATION", 97 }, - { "COLON_EQUALS", 32 }, - { "COLUMN", 98 }, - { "COLUMNS", 99 }, - { "COMMENT", 100 }, - { "COMMENTS", 101 }, - { "COMMIT", 102 }, - { "COMMITTED", 103 }, - { "COMPRESSION", 104 }, - { "CONCURRENTLY", 105 }, - { "CONFIGURATION", 106 }, - { "CONFLICT", 107 }, - { "CONNECTION", 108 }, - { "CONSTRAINT", 109 }, - { "CONSTRAINTS", 110 }, - { "CONTENT_P", 111 }, - { "CONTINUE_P", 112 }, - { "CONVERSION_P", 113 }, - { "COPY", 114 }, - { "COST", 115 }, - { "CREATE", 116 }, - { "CROSS", 117 }, - { "CSV", 118 }, - { "CUBE", 119 }, - { "CURRENT_CATALOG", 121 }, - { "CURRENT_DATE", 122 }, - { "CURRENT_P", 120 }, - { "CURRENT_ROLE", 123 }, - { "CURRENT_SCHEMA", 124 }, - { "CURRENT_TIME", 125 }, - { "CURRENT_TIMESTAMP", 126 }, - { "CURRENT_USER", 127 }, - { "CURSOR", 128 }, - { "CYCLE", 129 }, - { "C_COMMENT", 38 }, - { "DATABASE", 131 }, - { "DATA_P", 130 }, - { "DAY_P", 132 }, - { "DEALLOCATE", 133 }, - { "DEC", 134 }, - { "DECIMAL_P", 135 }, - { "DECLARE", 136 }, - { "DEFAULT", 137 }, - { "DEFAULTS", 138 }, - { "DEFERRABLE", 139 }, - { "DEFERRED", 140 }, - { "DEFINER", 141 }, - { "DELETE_P", 142 }, - { "DELIMITER", 143 }, - { "DELIMITERS", 144 }, - { "DEPENDS", 145 }, - { "DEPTH", 146 }, - { "DESC", 147 }, - { "DETACH", 148 }, - { "DICTIONARY", 149 }, - { "DISABLE_P", 150 }, - { "DISCARD", 151 }, - { "DISTINCT", 152 }, - { "DO", 153 }, - { "DOCUMENT_P", 154 }, - { "DOMAIN_P", 155 }, - { "DOT_DOT", 31 }, - { "DOUBLE_P", 156 }, - { "DROP", 157 }, - { "EACH", 158 }, - { "ELSE", 159 }, - { "ENABLE_P", 160 }, - { "ENCODING", 161 }, - { "ENCRYPTED", 162 }, - { "END_P", 163 }, - { "ENUM_P", 164 }, - { "EQUALS_GREATER", 33 }, - { "ESCAPE", 165 }, - { "EVENT", 166 }, - { "EXCEPT", 167 }, - { "EXCLUDE", 168 }, - { "EXCLUDING", 169 }, - { "EXCLUSIVE", 170 }, - { "EXECUTE", 171 }, - { "EXISTS", 172 }, - { "EXPLAIN", 173 }, - { "EXPRESSION", 174 }, - { "EXTENSION", 175 }, - { "EXTERNAL", 176 }, - { "EXTRACT", 177 }, - { "FALSE_P", 178 }, - { "FAMILY", 179 }, - { "FCONST", 22 }, - { "FETCH", 180 }, - { "FILTER", 181 }, - { "FINALIZE", 182 }, - { "FIRST_P", 183 }, - { "FLOAT_P", 184 }, - { "FOLLOWING", 185 }, - { "FOR", 186 }, - { "FORCE", 187 }, - { "FOREIGN", 188 }, - { "FORWARD", 189 }, - { "FREEZE", 190 }, - { "FROM", 191 }, - { "FULL", 192 }, - { "FUNCTION", 193 }, - { "FUNCTIONS", 194 }, - { "GENERATED", 195 }, - { "GLOBAL", 196 }, - { "GRANT", 197 }, - { "GRANTED", 198 }, - { "GREATER_EQUALS", 35 }, - { "GREATEST", 199 }, - { "GROUPING", 201 }, - { "GROUPS", 202 }, - { "GROUP_P", 200 }, - { "HANDLER", 203 }, - { "HAVING", 204 }, - { "HEADER_P", 205 }, - { "HOLD", 206 }, - { "HOUR_P", 207 }, - { "ICONST", 28 }, - { "IDENT", 20 }, - { "IDENTITY_P", 208 }, - { "IF_P", 209 }, - { "ILIKE", 210 }, - { "IMMEDIATE", 211 }, - { "IMMUTABLE", 212 }, - { "IMPLICIT_P", 213 }, - { "IMPORT_P", 214 }, - { "INCLUDE", 216 }, - { "INCLUDING", 217 }, - { "INCREMENT", 218 }, - { "INDEX", 219 }, - { "INDEXES", 220 }, - { "INHERIT", 221 }, - { "INHERITS", 222 }, - { "INITIALLY", 223 }, - { "INLINE_P", 224 }, - { "INNER_P", 225 }, - { "INOUT", 226 }, - { "INPUT_P", 227 }, - { "INSENSITIVE", 228 }, - { "INSERT", 229 }, - { "INSTEAD", 230 }, - { "INTEGER", 232 }, - { "INTERSECT", 233 }, - { "INTERVAL", 234 }, - { "INTO", 235 }, - { "INT_P", 231 }, - { "INVOKER", 236 }, - { "IN_P", 215 }, - { "IS", 237 }, - { "ISNULL", 238 }, - { "ISOLATION", 239 }, - { "JOIN", 240 }, - { "KEY", 241 }, - { "LABEL", 242 }, - { "LANGUAGE", 243 }, - { "LARGE_P", 244 }, - { "LAST_P", 245 }, - { "LATERAL_P", 246 }, - { "LEADING", 247 }, - { "LEAKPROOF", 248 }, - { "LEAST", 249 }, - { "LEFT", 250 }, - { "LESS_EQUALS", 34 }, - { "LEVEL", 251 }, - { "LIKE", 252 }, - { "LIMIT", 253 }, - { "LISTEN", 254 }, - { "LOAD", 255 }, - { "LOCAL", 256 }, - { "LOCALTIME", 257 }, - { "LOCALTIMESTAMP", 258 }, - { "LOCATION", 259 }, - { "LOCKED", 261 }, - { "LOCK_P", 260 }, - { "LOGGED", 262 }, - { "MAPPING", 263 }, - { "MATCH", 264 }, - { "MATCHED", 265 }, - { "MATERIALIZED", 266 }, - { "MAXVALUE", 267 }, - { "MERGE", 268 }, - { "METHOD", 269 }, - { "MINUTE_P", 270 }, - { "MINVALUE", 271 }, - { "MODE", 272 }, - { "MODE_PLPGSQL_ASSIGN1", 504 }, - { "MODE_PLPGSQL_ASSIGN2", 505 }, - { "MODE_PLPGSQL_ASSIGN3", 506 }, - { "MODE_PLPGSQL_EXPR", 503 }, - { "MODE_TYPE_NAME", 502 }, - { "MONTH_P", 273 }, - { "MOVE", 274 }, - { "NAMES", 276 }, - { "NAME_P", 275 }, - { "NATIONAL", 277 }, - { "NATURAL", 278 }, - { "NCHAR", 279 }, - { "NEW", 280 }, - { "NEXT", 281 }, - { "NFC", 282 }, - { "NFD", 283 }, - { "NFKC", 284 }, - { "NFKD", 285 }, - { "NO", 286 }, - { "NONE", 287 }, - { "NORMALIZE", 288 }, - { "NORMALIZED", 289 }, - { "NOT", 290 }, - { "NOTHING", 291 }, - { "NOTIFY", 292 }, - { "NOTNULL", 293 }, - { "NOT_EQUALS", 36 }, - { "NOT_LA", 499 }, - { "NOWAIT", 294 }, +{0, 0},{36, 1},{40, 3},{58, 11},{91, 17},{258, 21},{0, 509} +}; +static const ProtobufCEnumValueIndex pg_query__token__enum_values_by_name[509] = +{ + { "ABORT_P", 40 }, + { "ABSOLUTE_P", 41 }, + { "ACCESS", 42 }, + { "ACTION", 43 }, + { "ADD_P", 44 }, + { "ADMIN", 45 }, + { "AFTER", 46 }, + { "AGGREGATE", 47 }, + { "ALL", 48 }, + { "ALSO", 49 }, + { "ALTER", 50 }, + { "ALWAYS", 51 }, + { "ANALYSE", 52 }, + { "ANALYZE", 53 }, + { "AND", 54 }, + { "ANY", 55 }, + { "ARRAY", 56 }, + { "AS", 57 }, + { "ASC", 58 }, + { "ASCII_36", 1 }, + { "ASCII_37", 2 }, + { "ASCII_40", 3 }, + { "ASCII_41", 4 }, + { "ASCII_42", 5 }, + { "ASCII_43", 6 }, + { "ASCII_44", 7 }, + { "ASCII_45", 8 }, + { "ASCII_46", 9 }, + { "ASCII_47", 10 }, + { "ASCII_58", 11 }, + { "ASCII_59", 12 }, + { "ASCII_60", 13 }, + { "ASCII_61", 14 }, + { "ASCII_62", 15 }, + { "ASCII_63", 16 }, + { "ASCII_91", 17 }, + { "ASCII_92", 18 }, + { "ASCII_93", 19 }, + { "ASCII_94", 20 }, + { "ASENSITIVE", 59 }, + { "ASSERTION", 60 }, + { "ASSIGNMENT", 61 }, + { "ASYMMETRIC", 62 }, + { "AT", 64 }, + { "ATOMIC", 63 }, + { "ATTACH", 65 }, + { "ATTRIBUTE", 66 }, + { "AUTHORIZATION", 67 }, + { "BACKWARD", 68 }, + { "BCONST", 26 }, + { "BEFORE", 69 }, + { "BEGIN_P", 70 }, + { "BETWEEN", 71 }, + { "BIGINT", 72 }, + { "BINARY", 73 }, + { "BIT", 74 }, + { "BOOLEAN_P", 75 }, + { "BOTH", 76 }, + { "BREADTH", 77 }, + { "BY", 78 }, + { "CACHE", 79 }, + { "CALL", 80 }, + { "CALLED", 81 }, + { "CASCADE", 82 }, + { "CASCADED", 83 }, + { "CASE", 84 }, + { "CAST", 85 }, + { "CATALOG_P", 86 }, + { "CHAIN", 87 }, + { "CHARACTER", 89 }, + { "CHARACTERISTICS", 90 }, + { "CHAR_P", 88 }, + { "CHECK", 91 }, + { "CHECKPOINT", 92 }, + { "CLASS", 93 }, + { "CLOSE", 94 }, + { "CLUSTER", 95 }, + { "COALESCE", 96 }, + { "COLLATE", 97 }, + { "COLLATION", 98 }, + { "COLON_EQUALS", 33 }, + { "COLUMN", 99 }, + { "COLUMNS", 100 }, + { "COMMENT", 101 }, + { "COMMENTS", 102 }, + { "COMMIT", 103 }, + { "COMMITTED", 104 }, + { "COMPRESSION", 105 }, + { "CONCURRENTLY", 106 }, + { "CONFIGURATION", 107 }, + { "CONFLICT", 108 }, + { "CONNECTION", 109 }, + { "CONSTRAINT", 110 }, + { "CONSTRAINTS", 111 }, + { "CONTENT_P", 112 }, + { "CONTINUE_P", 113 }, + { "CONVERSION_P", 114 }, + { "COPY", 115 }, + { "COST", 116 }, + { "CREATE", 117 }, + { "CROSS", 118 }, + { "CSV", 119 }, + { "CUBE", 120 }, + { "CURRENT_CATALOG", 122 }, + { "CURRENT_DATE", 123 }, + { "CURRENT_P", 121 }, + { "CURRENT_ROLE", 124 }, + { "CURRENT_SCHEMA", 125 }, + { "CURRENT_TIME", 126 }, + { "CURRENT_TIMESTAMP", 127 }, + { "CURRENT_USER", 128 }, + { "CURSOR", 129 }, + { "CYCLE", 130 }, + { "C_COMMENT", 39 }, + { "DATABASE", 132 }, + { "DATA_P", 131 }, + { "DAY_P", 133 }, + { "DEALLOCATE", 134 }, + { "DEC", 135 }, + { "DECIMAL_P", 136 }, + { "DECLARE", 137 }, + { "DEFAULT", 138 }, + { "DEFAULTS", 139 }, + { "DEFERRABLE", 140 }, + { "DEFERRED", 141 }, + { "DEFINER", 142 }, + { "DELETE_P", 143 }, + { "DELIMITER", 144 }, + { "DELIMITERS", 145 }, + { "DEPENDS", 146 }, + { "DEPTH", 147 }, + { "DESC", 148 }, + { "DETACH", 149 }, + { "DICTIONARY", 150 }, + { "DISABLE_P", 151 }, + { "DISCARD", 152 }, + { "DISTINCT", 153 }, + { "DO", 154 }, + { "DOCUMENT_P", 155 }, + { "DOMAIN_P", 156 }, + { "DOT_DOT", 32 }, + { "DOUBLE_P", 157 }, + { "DROP", 158 }, + { "EACH", 159 }, + { "ELSE", 160 }, + { "ENABLE_P", 161 }, + { "ENCODING", 162 }, + { "ENCRYPTED", 163 }, + { "END_P", 164 }, + { "ENUM_P", 165 }, + { "EQUALS_GREATER", 34 }, + { "ESCAPE", 166 }, + { "EVENT", 167 }, + { "EXCEPT", 168 }, + { "EXCLUDE", 169 }, + { "EXCLUDING", 170 }, + { "EXCLUSIVE", 171 }, + { "EXECUTE", 172 }, + { "EXISTS", 173 }, + { "EXPLAIN", 174 }, + { "EXPRESSION", 175 }, + { "EXTENSION", 176 }, + { "EXTERNAL", 177 }, + { "EXTRACT", 178 }, + { "FALSE_P", 179 }, + { "FAMILY", 180 }, + { "FCONST", 23 }, + { "FETCH", 181 }, + { "FILTER", 182 }, + { "FINALIZE", 183 }, + { "FIRST_P", 184 }, + { "FLOAT_P", 185 }, + { "FOLLOWING", 186 }, + { "FOR", 187 }, + { "FORCE", 188 }, + { "FOREIGN", 189 }, + { "FORWARD", 190 }, + { "FREEZE", 191 }, + { "FROM", 192 }, + { "FULL", 193 }, + { "FUNCTION", 194 }, + { "FUNCTIONS", 195 }, + { "GENERATED", 196 }, + { "GLOBAL", 197 }, + { "GRANT", 198 }, + { "GRANTED", 199 }, + { "GREATER_EQUALS", 36 }, + { "GREATEST", 200 }, + { "GROUPING", 202 }, + { "GROUPS", 203 }, + { "GROUP_P", 201 }, + { "HANDLER", 204 }, + { "HAVING", 205 }, + { "HEADER_P", 206 }, + { "HOLD", 207 }, + { "HOUR_P", 208 }, + { "ICONST", 29 }, + { "IDENT", 21 }, + { "IDENTITY_P", 209 }, + { "IF_P", 210 }, + { "ILIKE", 211 }, + { "IMMEDIATE", 212 }, + { "IMMUTABLE", 213 }, + { "IMPLICIT_P", 214 }, + { "IMPORT_P", 215 }, + { "INCLUDE", 217 }, + { "INCLUDING", 218 }, + { "INCREMENT", 219 }, + { "INDEX", 220 }, + { "INDEXES", 221 }, + { "INHERIT", 222 }, + { "INHERITS", 223 }, + { "INITIALLY", 224 }, + { "INLINE_P", 225 }, + { "INNER_P", 226 }, + { "INOUT", 227 }, + { "INPUT_P", 228 }, + { "INSENSITIVE", 229 }, + { "INSERT", 230 }, + { "INSTEAD", 231 }, + { "INTEGER", 233 }, + { "INTERSECT", 234 }, + { "INTERVAL", 235 }, + { "INTO", 236 }, + { "INT_P", 232 }, + { "INVOKER", 237 }, + { "IN_P", 216 }, + { "IS", 238 }, + { "ISNULL", 239 }, + { "ISOLATION", 240 }, + { "JOIN", 241 }, + { "KEY", 242 }, + { "LABEL", 243 }, + { "LANGUAGE", 244 }, + { "LARGE_P", 245 }, + { "LAST_P", 246 }, + { "LATERAL_P", 247 }, + { "LEADING", 248 }, + { "LEAKPROOF", 249 }, + { "LEAST", 250 }, + { "LEFT", 251 }, + { "LESS_EQUALS", 35 }, + { "LEVEL", 252 }, + { "LIKE", 253 }, + { "LIMIT", 254 }, + { "LISTEN", 255 }, + { "LOAD", 256 }, + { "LOCAL", 257 }, + { "LOCALTIME", 258 }, + { "LOCALTIMESTAMP", 259 }, + { "LOCATION", 260 }, + { "LOCKED", 262 }, + { "LOCK_P", 261 }, + { "LOGGED", 263 }, + { "MAPPING", 264 }, + { "MATCH", 265 }, + { "MATCHED", 266 }, + { "MATERIALIZED", 267 }, + { "MAXVALUE", 268 }, + { "MERGE", 269 }, + { "METHOD", 270 }, + { "MINUTE_P", 271 }, + { "MINVALUE", 272 }, + { "MODE", 273 }, + { "MODE_PLPGSQL_ASSIGN1", 505 }, + { "MODE_PLPGSQL_ASSIGN2", 506 }, + { "MODE_PLPGSQL_ASSIGN3", 507 }, + { "MODE_PLPGSQL_EXPR", 504 }, + { "MODE_TYPE_NAME", 503 }, + { "MONTH_P", 274 }, + { "MOVE", 275 }, + { "NAMES", 277 }, + { "NAME_P", 276 }, + { "NATIONAL", 278 }, + { "NATURAL", 279 }, + { "NCHAR", 280 }, + { "NEW", 281 }, + { "NEXT", 282 }, + { "NFC", 283 }, + { "NFD", 284 }, + { "NFKC", 285 }, + { "NFKD", 286 }, + { "NO", 287 }, + { "NONE", 288 }, + { "NORMALIZE", 289 }, + { "NORMALIZED", 290 }, + { "NOT", 291 }, + { "NOTHING", 292 }, + { "NOTIFY", 293 }, + { "NOTNULL", 294 }, + { "NOT_EQUALS", 37 }, + { "NOT_LA", 500 }, + { "NOWAIT", 295 }, { "NUL", 0 }, - { "NULLIF", 296 }, - { "NULLS_LA", 500 }, - { "NULLS_P", 297 }, - { "NULL_P", 295 }, - { "NUMERIC", 298 }, - { "OBJECT_P", 299 }, - { "OF", 300 }, - { "OFF", 301 }, - { "OFFSET", 302 }, - { "OIDS", 303 }, - { "OLD", 304 }, - { "ON", 305 }, - { "ONLY", 306 }, - { "OPERATOR", 307 }, - { "OPTION", 308 }, - { "OPTIONS", 309 }, - { "OR", 310 }, - { "ORDER", 311 }, - { "ORDINALITY", 312 }, - { "OTHERS", 313 }, - { "OUTER_P", 315 }, - { "OUT_P", 314 }, - { "OVER", 316 }, - { "OVERLAPS", 317 }, - { "OVERLAY", 318 }, - { "OVERRIDING", 319 }, - { "OWNED", 320 }, - { "OWNER", 321 }, - { "Op", 27 }, - { "PARALLEL", 322 }, - { "PARAM", 29 }, - { "PARAMETER", 323 }, - { "PARSER", 324 }, - { "PARTIAL", 325 }, - { "PARTITION", 326 }, - { "PASSING", 327 }, - { "PASSWORD", 328 }, - { "PLACING", 329 }, - { "PLANS", 330 }, - { "POLICY", 331 }, - { "POSITION", 332 }, - { "PRECEDING", 333 }, - { "PRECISION", 334 }, - { "PREPARE", 336 }, - { "PREPARED", 337 }, - { "PRESERVE", 335 }, - { "PRIMARY", 338 }, - { "PRIOR", 339 }, - { "PRIVILEGES", 340 }, - { "PROCEDURAL", 341 }, - { "PROCEDURE", 342 }, - { "PROCEDURES", 343 }, - { "PROGRAM", 344 }, - { "PUBLICATION", 345 }, - { "QUOTE", 346 }, - { "RANGE", 347 }, - { "READ", 348 }, - { "REAL", 349 }, - { "REASSIGN", 350 }, - { "RECHECK", 351 }, - { "RECURSIVE", 352 }, - { "REFERENCES", 354 }, - { "REFERENCING", 355 }, - { "REFRESH", 356 }, - { "REF_P", 353 }, - { "REINDEX", 357 }, - { "RELATIVE_P", 358 }, - { "RELEASE", 359 }, - { "RENAME", 360 }, - { "REPEATABLE", 361 }, - { "REPLACE", 362 }, - { "REPLICA", 363 }, - { "RESET", 364 }, - { "RESTART", 365 }, - { "RESTRICT", 366 }, - { "RETURN", 367 }, - { "RETURNING", 368 }, - { "RETURNS", 369 }, - { "REVOKE", 370 }, - { "RIGHT", 371 }, - { "ROLE", 372 }, - { "ROLLBACK", 373 }, - { "ROLLUP", 374 }, - { "ROUTINE", 375 }, - { "ROUTINES", 376 }, - { "ROW", 377 }, - { "ROWS", 378 }, - { "RULE", 379 }, - { "SAVEPOINT", 380 }, - { "SCHEMA", 381 }, - { "SCHEMAS", 382 }, - { "SCONST", 23 }, - { "SCROLL", 383 }, - { "SEARCH", 384 }, - { "SECOND_P", 385 }, - { "SECURITY", 386 }, - { "SELECT", 387 }, - { "SEQUENCE", 388 }, - { "SEQUENCES", 389 }, - { "SERIALIZABLE", 390 }, - { "SERVER", 391 }, - { "SESSION", 392 }, - { "SESSION_USER", 393 }, - { "SET", 394 }, - { "SETOF", 396 }, - { "SETS", 395 }, - { "SHARE", 397 }, - { "SHOW", 398 }, - { "SIMILAR", 399 }, - { "SIMPLE", 400 }, - { "SKIP", 401 }, - { "SMALLINT", 402 }, - { "SNAPSHOT", 403 }, - { "SOME", 404 }, - { "SQL_COMMENT", 37 }, - { "SQL_P", 405 }, - { "STABLE", 406 }, - { "STANDALONE_P", 407 }, - { "START", 408 }, - { "STATEMENT", 409 }, - { "STATISTICS", 410 }, - { "STDIN", 411 }, - { "STDOUT", 412 }, - { "STORAGE", 413 }, - { "STORED", 414 }, - { "STRICT_P", 415 }, - { "STRIP_P", 416 }, - { "SUBSCRIPTION", 417 }, - { "SUBSTRING", 418 }, - { "SUPPORT", 419 }, - { "SYMMETRIC", 420 }, - { "SYSID", 421 }, - { "SYSTEM_P", 422 }, - { "TABLE", 423 }, - { "TABLES", 424 }, - { "TABLESAMPLE", 425 }, - { "TABLESPACE", 426 }, - { "TEMP", 427 }, - { "TEMPLATE", 428 }, - { "TEMPORARY", 429 }, - { "TEXT_P", 430 }, - { "THEN", 431 }, - { "TIES", 432 }, - { "TIME", 433 }, - { "TIMESTAMP", 434 }, - { "TO", 435 }, - { "TRAILING", 436 }, - { "TRANSACTION", 437 }, - { "TRANSFORM", 438 }, - { "TREAT", 439 }, - { "TRIGGER", 440 }, - { "TRIM", 441 }, - { "TRUE_P", 442 }, - { "TRUNCATE", 443 }, - { "TRUSTED", 444 }, - { "TYPECAST", 30 }, - { "TYPES_P", 446 }, - { "TYPE_P", 445 }, - { "UESCAPE", 447 }, - { "UIDENT", 21 }, - { "UMINUS", 507 }, - { "UNBOUNDED", 448 }, - { "UNCOMMITTED", 449 }, - { "UNENCRYPTED", 450 }, - { "UNION", 451 }, - { "UNIQUE", 452 }, - { "UNKNOWN", 453 }, - { "UNLISTEN", 454 }, - { "UNLOGGED", 455 }, - { "UNTIL", 456 }, - { "UPDATE", 457 }, - { "USCONST", 24 }, - { "USER", 458 }, - { "USING", 459 }, - { "VACUUM", 460 }, - { "VALID", 461 }, - { "VALIDATE", 462 }, - { "VALIDATOR", 463 }, - { "VALUES", 465 }, - { "VALUE_P", 464 }, - { "VARCHAR", 466 }, - { "VARIADIC", 467 }, - { "VARYING", 468 }, - { "VERBOSE", 469 }, - { "VERSION_P", 470 }, - { "VIEW", 471 }, - { "VIEWS", 472 }, - { "VOLATILE", 473 }, - { "WHEN", 474 }, - { "WHERE", 475 }, - { "WHITESPACE_P", 476 }, - { "WINDOW", 477 }, - { "WITH", 478 }, - { "WITHIN", 479 }, - { "WITHOUT", 480 }, - { "WITH_LA", 501 }, - { "WORK", 481 }, - { "WRAPPER", 482 }, - { "WRITE", 483 }, - { "XCONST", 26 }, - { "XMLATTRIBUTES", 485 }, - { "XMLCONCAT", 486 }, - { "XMLELEMENT", 487 }, - { "XMLEXISTS", 488 }, - { "XMLFOREST", 489 }, - { "XMLNAMESPACES", 490 }, - { "XMLPARSE", 491 }, - { "XMLPI", 492 }, - { "XMLROOT", 493 }, - { "XMLSERIALIZE", 494 }, - { "XMLTABLE", 495 }, - { "XML_P", 484 }, - { "YEAR_P", 496 }, - { "YES_P", 497 }, - { "ZONE", 498 }, + { "NULLIF", 297 }, + { "NULLS_LA", 501 }, + { "NULLS_P", 298 }, + { "NULL_P", 296 }, + { "NUMERIC", 299 }, + { "OBJECT_P", 300 }, + { "OF", 301 }, + { "OFF", 302 }, + { "OFFSET", 303 }, + { "OIDS", 304 }, + { "OLD", 305 }, + { "ON", 306 }, + { "ONLY", 307 }, + { "OPERATOR", 308 }, + { "OPTION", 309 }, + { "OPTIONS", 310 }, + { "OR", 311 }, + { "ORDER", 312 }, + { "ORDINALITY", 313 }, + { "OTHERS", 314 }, + { "OUTER_P", 316 }, + { "OUT_P", 315 }, + { "OVER", 317 }, + { "OVERLAPS", 318 }, + { "OVERLAY", 319 }, + { "OVERRIDING", 320 }, + { "OWNED", 321 }, + { "OWNER", 322 }, + { "Op", 28 }, + { "PARALLEL", 323 }, + { "PARAM", 30 }, + { "PARAMETER", 324 }, + { "PARSER", 325 }, + { "PARTIAL", 326 }, + { "PARTITION", 327 }, + { "PASSING", 328 }, + { "PASSWORD", 329 }, + { "PLACING", 330 }, + { "PLANS", 331 }, + { "POLICY", 332 }, + { "POSITION", 333 }, + { "PRECEDING", 334 }, + { "PRECISION", 335 }, + { "PREPARE", 337 }, + { "PREPARED", 338 }, + { "PRESERVE", 336 }, + { "PRIMARY", 339 }, + { "PRIOR", 340 }, + { "PRIVILEGES", 341 }, + { "PROCEDURAL", 342 }, + { "PROCEDURE", 343 }, + { "PROCEDURES", 344 }, + { "PROGRAM", 345 }, + { "PUBLICATION", 346 }, + { "QUOTE", 347 }, + { "RANGE", 348 }, + { "READ", 349 }, + { "REAL", 350 }, + { "REASSIGN", 351 }, + { "RECHECK", 352 }, + { "RECURSIVE", 353 }, + { "REFERENCES", 355 }, + { "REFERENCING", 356 }, + { "REFRESH", 357 }, + { "REF_P", 354 }, + { "REINDEX", 358 }, + { "RELATIVE_P", 359 }, + { "RELEASE", 360 }, + { "RENAME", 361 }, + { "REPEATABLE", 362 }, + { "REPLACE", 363 }, + { "REPLICA", 364 }, + { "RESET", 365 }, + { "RESTART", 366 }, + { "RESTRICT", 367 }, + { "RETURN", 368 }, + { "RETURNING", 369 }, + { "RETURNS", 370 }, + { "REVOKE", 371 }, + { "RIGHT", 372 }, + { "ROLE", 373 }, + { "ROLLBACK", 374 }, + { "ROLLUP", 375 }, + { "ROUTINE", 376 }, + { "ROUTINES", 377 }, + { "ROW", 378 }, + { "ROWS", 379 }, + { "RULE", 380 }, + { "SAVEPOINT", 381 }, + { "SCHEMA", 382 }, + { "SCHEMAS", 383 }, + { "SCONST", 24 }, + { "SCROLL", 384 }, + { "SEARCH", 385 }, + { "SECOND_P", 386 }, + { "SECURITY", 387 }, + { "SELECT", 388 }, + { "SEQUENCE", 389 }, + { "SEQUENCES", 390 }, + { "SERIALIZABLE", 391 }, + { "SERVER", 392 }, + { "SESSION", 393 }, + { "SESSION_USER", 394 }, + { "SET", 395 }, + { "SETOF", 397 }, + { "SETS", 396 }, + { "SHARE", 398 }, + { "SHOW", 399 }, + { "SIMILAR", 400 }, + { "SIMPLE", 401 }, + { "SKIP", 402 }, + { "SMALLINT", 403 }, + { "SNAPSHOT", 404 }, + { "SOME", 405 }, + { "SQL_COMMENT", 38 }, + { "SQL_P", 406 }, + { "STABLE", 407 }, + { "STANDALONE_P", 408 }, + { "START", 409 }, + { "STATEMENT", 410 }, + { "STATISTICS", 411 }, + { "STDIN", 412 }, + { "STDOUT", 413 }, + { "STORAGE", 414 }, + { "STORED", 415 }, + { "STRICT_P", 416 }, + { "STRIP_P", 417 }, + { "SUBSCRIPTION", 418 }, + { "SUBSTRING", 419 }, + { "SUPPORT", 420 }, + { "SYMMETRIC", 421 }, + { "SYSID", 422 }, + { "SYSTEM_P", 423 }, + { "TABLE", 424 }, + { "TABLES", 425 }, + { "TABLESAMPLE", 426 }, + { "TABLESPACE", 427 }, + { "TEMP", 428 }, + { "TEMPLATE", 429 }, + { "TEMPORARY", 430 }, + { "TEXT_P", 431 }, + { "THEN", 432 }, + { "TIES", 433 }, + { "TIME", 434 }, + { "TIMESTAMP", 435 }, + { "TO", 436 }, + { "TRAILING", 437 }, + { "TRANSACTION", 438 }, + { "TRANSFORM", 439 }, + { "TREAT", 440 }, + { "TRIGGER", 441 }, + { "TRIM", 442 }, + { "TRUE_P", 443 }, + { "TRUNCATE", 444 }, + { "TRUSTED", 445 }, + { "TYPECAST", 31 }, + { "TYPES_P", 447 }, + { "TYPE_P", 446 }, + { "UESCAPE", 448 }, + { "UIDENT", 22 }, + { "UMINUS", 508 }, + { "UNBOUNDED", 449 }, + { "UNCOMMITTED", 450 }, + { "UNENCRYPTED", 451 }, + { "UNION", 452 }, + { "UNIQUE", 453 }, + { "UNKNOWN", 454 }, + { "UNLISTEN", 455 }, + { "UNLOGGED", 456 }, + { "UNTIL", 457 }, + { "UPDATE", 458 }, + { "USCONST", 25 }, + { "USER", 459 }, + { "USING", 460 }, + { "VACUUM", 461 }, + { "VALID", 462 }, + { "VALIDATE", 463 }, + { "VALIDATOR", 464 }, + { "VALUES", 466 }, + { "VALUE_P", 465 }, + { "VARCHAR", 467 }, + { "VARIADIC", 468 }, + { "VARYING", 469 }, + { "VERBOSE", 470 }, + { "VERSION_P", 471 }, + { "VIEW", 472 }, + { "VIEWS", 473 }, + { "VOLATILE", 474 }, + { "WHEN", 475 }, + { "WHERE", 476 }, + { "WHITESPACE_P", 477 }, + { "WINDOW", 478 }, + { "WITH", 479 }, + { "WITHIN", 480 }, + { "WITHOUT", 481 }, + { "WITH_LA", 502 }, + { "WORK", 482 }, + { "WRAPPER", 483 }, + { "WRITE", 484 }, + { "XCONST", 27 }, + { "XMLATTRIBUTES", 486 }, + { "XMLCONCAT", 487 }, + { "XMLELEMENT", 488 }, + { "XMLEXISTS", 489 }, + { "XMLFOREST", 490 }, + { "XMLNAMESPACES", 491 }, + { "XMLPARSE", 492 }, + { "XMLPI", 493 }, + { "XMLROOT", 494 }, + { "XMLSERIALIZE", 495 }, + { "XMLTABLE", 496 }, + { "XML_P", 485 }, + { "YEAR_P", 497 }, + { "YES_P", 498 }, + { "ZONE", 499 }, }; const ProtobufCEnumDescriptor pg_query__token__descriptor = { @@ -39644,9 +39646,9 @@ const ProtobufCEnumDescriptor pg_query__token__descriptor = "Token", "PgQuery__Token", "pg_query", - 508, + 509, pg_query__token__enum_values_by_number, - 508, + 509, pg_query__token__enum_values_by_name, 6, pg_query__token__value_ranges, diff --git a/protobuf/pg_query.pb-c.h b/protobuf/pg_query.pb-c.h index 621776c3..fb3e5dbd 100644 --- a/protobuf/pg_query.pb-c.h +++ b/protobuf/pg_query.pb-c.h @@ -906,6 +906,10 @@ typedef enum _PgQuery__Token { * Either supporting syntax, or single-character operators (some can be both) * Also see https://www.postgresql.org/docs/12/sql-syntax-lexical.html#SQL-SYNTAX-SPECIAL-CHARS */ + /* + * "$" + */ + PG_QUERY__TOKEN__ASCII_36 = 36, /* * "%" */ diff --git a/protobuf/pg_query.proto b/protobuf/pg_query.proto index 1b6add0d..f4dabe18 100644 --- a/protobuf/pg_query.proto +++ b/protobuf/pg_query.proto @@ -3161,6 +3161,7 @@ enum Token { // Single-character tokens that are returned 1:1 (identical with "self" list in scan.l) // Either supporting syntax, or single-character operators (some can be both) // Also see https://www.postgresql.org/docs/12/sql-syntax-lexical.html#SQL-SYNTAX-SPECIAL-CHARS + ASCII_36 = 36; // "$" ASCII_37 = 37; // "%" ASCII_40 = 40; // "(" ASCII_41 = 41; // ")" diff --git a/test/scan.c b/test/scan.c index f51459d1..991ee3ab 100644 --- a/test/scan.c +++ b/test/scan.c @@ -19,6 +19,9 @@ int main() { const ProtobufCEnumValue *keyword_kind; PgQueryScanResult result; + // tests contains pairs of strings + assert(testsCount % 2 == 0); + for (i = 0; i < testsCount * 2; i += 2) { char buffer[1024]; buffer[0] = '\0'; @@ -36,6 +39,11 @@ int main() { scan_token = scan_result->tokens[j]; token_kind = protobuf_c_enum_descriptor_get_value(&pg_query__token__descriptor, scan_token->token); keyword_kind = protobuf_c_enum_descriptor_get_value(&pg_query__keyword_kind__descriptor, scan_token->keyword_kind); + if (token_kind == NULL) { + ret_code = -1; + printf("INVALID result for \"%s\": scan_result token %zu token_kind == NULL\n", tests[i], j); + break; + } sprintf(buffer2, "%.*s = %s, %s\n", scan_token->end - scan_token->start, &(tests[i][scan_token->start]), token_kind->name, keyword_kind->name); strcat(buffer, buffer2); } diff --git a/test/scan_tests.c b/test/scan_tests.c index 0f979624..1d847462 100644 --- a/test/scan_tests.c +++ b/test/scan_tests.c @@ -1,4 +1,4 @@ -const char* tests[] = { +const char* const tests[] = { "SELECT 1", "SELECT = SELECT, RESERVED_KEYWORD\n" "1 = ICONST, NO_KEYWORD\n", @@ -87,7 +87,11 @@ const char* tests[] = { "; = ASCII_59, NO_KEYWORD\n" "SELECT = SELECT, RESERVED_KEYWORD\n" "2 = ICONST, NO_KEYWORD\n" - ") = ASCII_41, NO_KEYWORD\n" + ") = ASCII_41, NO_KEYWORD\n", + "SELECT $identifier", + "SELECT = SELECT, RESERVED_KEYWORD\n" + "$ = ASCII_36, NO_KEYWORD\n" + "identifier = IDENT, NO_KEYWORD\n", }; -size_t testsCount = 11; +const size_t testsCount = sizeof(tests)/sizeof(*tests)/2;