Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
|
|
|
* jsonapi.c
|
|
|
|
* JSON parser and lexer interfaces
|
|
|
|
*
|
2024-01-04 02:49:05 +01:00
|
|
|
* Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
* Portions Copyright (c) 1994, Regents of the University of California
|
|
|
|
*
|
|
|
|
* IDENTIFICATION
|
2020-01-29 16:19:24 +01:00
|
|
|
* src/common/jsonapi.c
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
*
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
2020-01-29 16:19:24 +01:00
|
|
|
#ifndef FRONTEND
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
#include "postgres.h"
|
2020-01-29 16:19:24 +01:00
|
|
|
#else
|
|
|
|
#include "postgres_fe.h"
|
|
|
|
#endif
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
2020-01-29 16:19:24 +01:00
|
|
|
#include "common/jsonapi.h"
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
#include "mb/pg_wchar.h"
|
2022-08-31 05:39:17 +02:00
|
|
|
#include "port/pg_lfind.h"
|
2020-01-29 16:19:24 +01:00
|
|
|
|
2021-07-02 02:35:12 +02:00
|
|
|
#ifndef FRONTEND
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
#include "miscadmin.h"
|
2020-01-29 16:19:24 +01:00
|
|
|
#endif
|
|
|
|
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
/*
|
|
|
|
* The context of the parser is maintained by the recursive descent
|
|
|
|
* mechanism, but is passed explicitly to the error reporting routine
|
|
|
|
* for better diagnostics.
|
|
|
|
*/
|
|
|
|
typedef enum /* contexts of JSON parser */
|
|
|
|
{
|
|
|
|
JSON_PARSE_VALUE, /* expecting a value */
|
|
|
|
JSON_PARSE_STRING, /* expecting a string (for a field name) */
|
|
|
|
JSON_PARSE_ARRAY_START, /* saw '[', expecting value or ']' */
|
|
|
|
JSON_PARSE_ARRAY_NEXT, /* saw array element, expecting ',' or ']' */
|
|
|
|
JSON_PARSE_OBJECT_START, /* saw '{', expecting label or '}' */
|
|
|
|
JSON_PARSE_OBJECT_LABEL, /* saw object label, expecting ':' */
|
|
|
|
JSON_PARSE_OBJECT_NEXT, /* saw object value, expecting ',' or '}' */
|
|
|
|
JSON_PARSE_OBJECT_COMMA, /* saw object ',', expecting next label */
|
|
|
|
JSON_PARSE_END, /* saw the end of a document, expect nothing */
|
|
|
|
} JsonParseContext;
|
|
|
|
|
2020-01-27 17:03:21 +01:00
|
|
|
static inline JsonParseErrorType json_lex_string(JsonLexContext *lex);
|
|
|
|
static inline JsonParseErrorType json_lex_number(JsonLexContext *lex, char *s,
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
bool *num_err, int *total_len);
|
2020-01-27 17:03:21 +01:00
|
|
|
static inline JsonParseErrorType parse_scalar(JsonLexContext *lex, JsonSemAction *sem);
|
|
|
|
static JsonParseErrorType parse_object_field(JsonLexContext *lex, JsonSemAction *sem);
|
|
|
|
static JsonParseErrorType parse_object(JsonLexContext *lex, JsonSemAction *sem);
|
|
|
|
static JsonParseErrorType parse_array_element(JsonLexContext *lex, JsonSemAction *sem);
|
|
|
|
static JsonParseErrorType parse_array(JsonLexContext *lex, JsonSemAction *sem);
|
|
|
|
static JsonParseErrorType report_parse_error(JsonParseContext ctx, JsonLexContext *lex);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
/* the null action object used for pure validation */
|
|
|
|
JsonSemAction nullSemAction =
|
|
|
|
{
|
|
|
|
NULL, NULL, NULL, NULL, NULL,
|
|
|
|
NULL, NULL, NULL, NULL, NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Recursive Descent parser support routines */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* lex_peek
|
|
|
|
*
|
|
|
|
* what is the current look_ahead token?
|
|
|
|
*/
|
|
|
|
static inline JsonTokenType
|
|
|
|
lex_peek(JsonLexContext *lex)
|
|
|
|
{
|
|
|
|
return lex->token_type;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2020-01-17 20:06:41 +01:00
|
|
|
* lex_expect
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
*
|
|
|
|
* move the lexer to the next token if the current look_ahead token matches
|
|
|
|
* the parameter token. Otherwise, report an error.
|
|
|
|
*/
|
2020-01-27 17:03:21 +01:00
|
|
|
static inline JsonParseErrorType
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
lex_expect(JsonParseContext ctx, JsonLexContext *lex, JsonTokenType token)
|
|
|
|
{
|
2020-01-17 20:06:41 +01:00
|
|
|
if (lex_peek(lex) == token)
|
2020-01-27 17:03:21 +01:00
|
|
|
return json_lex(lex);
|
2020-01-17 20:06:41 +01:00
|
|
|
else
|
2020-01-27 17:03:21 +01:00
|
|
|
return report_parse_error(ctx, lex);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/* chars to consider as part of an alphanumeric token */
|
|
|
|
#define JSON_ALPHANUMERIC_CHAR(c) \
|
|
|
|
(((c) >= 'a' && (c) <= 'z') || \
|
|
|
|
((c) >= 'A' && (c) <= 'Z') || \
|
|
|
|
((c) >= '0' && (c) <= '9') || \
|
|
|
|
(c) == '_' || \
|
|
|
|
IS_HIGHBIT_SET(c))
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Utility function to check if a string is a valid JSON number.
|
|
|
|
*
|
|
|
|
* str is of length len, and need not be null-terminated.
|
|
|
|
*/
|
|
|
|
bool
|
|
|
|
IsValidJsonNumber(const char *str, int len)
|
|
|
|
{
|
|
|
|
bool numeric_error;
|
|
|
|
int total_len;
|
|
|
|
JsonLexContext dummy_lex;
|
|
|
|
|
|
|
|
if (len <= 0)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* json_lex_number expects a leading '-' to have been eaten already.
|
|
|
|
*
|
|
|
|
* having to cast away the constness of str is ugly, but there's not much
|
|
|
|
* easy alternative.
|
|
|
|
*/
|
|
|
|
if (*str == '-')
|
|
|
|
{
|
|
|
|
dummy_lex.input = unconstify(char *, str) + 1;
|
|
|
|
dummy_lex.input_length = len - 1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
dummy_lex.input = unconstify(char *, str);
|
|
|
|
dummy_lex.input_length = len;
|
|
|
|
}
|
|
|
|
|
|
|
|
json_lex_number(&dummy_lex, dummy_lex.input, &numeric_error, &total_len);
|
|
|
|
|
|
|
|
return (!numeric_error) && (total_len == dummy_lex.input_length);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2020-01-27 17:22:13 +01:00
|
|
|
* makeJsonLexContextCstringLen
|
2023-10-05 10:59:08 +02:00
|
|
|
* Initialize the given JsonLexContext object, or create one
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
*
|
2023-10-05 10:59:08 +02:00
|
|
|
* If a valid 'lex' pointer is given, it is initialized. This can
|
|
|
|
* be used for stack-allocated structs, saving overhead. If NULL is
|
|
|
|
* given, a new struct is allocated.
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
*
|
2023-10-05 10:59:08 +02:00
|
|
|
* If need_escapes is true, ->strval stores the unescaped lexemes.
|
|
|
|
* Unescaping is expensive, so only request it when necessary.
|
|
|
|
*
|
|
|
|
* If need_escapes is true or lex was given as NULL, then caller is
|
|
|
|
* responsible for freeing the returned struct, either by calling
|
|
|
|
* freeJsonLexContext() or (in backend environment) via memory context
|
|
|
|
* cleanup.
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
*/
|
|
|
|
JsonLexContext *
|
2023-10-05 10:59:08 +02:00
|
|
|
makeJsonLexContextCstringLen(JsonLexContext *lex, char *json,
|
|
|
|
int len, int encoding, bool need_escapes)
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
{
|
2023-10-05 10:59:08 +02:00
|
|
|
if (lex == NULL)
|
|
|
|
{
|
|
|
|
lex = palloc0(sizeof(JsonLexContext));
|
|
|
|
lex->flags |= JSONLEX_FREE_STRUCT;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
memset(lex, 0, sizeof(JsonLexContext));
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
lex->input = lex->token_terminator = lex->line_start = json;
|
|
|
|
lex->line_number = 1;
|
|
|
|
lex->input_length = len;
|
2020-01-29 16:19:24 +01:00
|
|
|
lex->input_encoding = encoding;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
if (need_escapes)
|
2023-10-05 10:59:08 +02:00
|
|
|
{
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
lex->strval = makeStringInfo();
|
2023-10-05 10:59:08 +02:00
|
|
|
lex->flags |= JSONLEX_FREE_STRVAL;
|
|
|
|
}
|
|
|
|
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
return lex;
|
|
|
|
}
|
|
|
|
|
2023-10-05 10:59:08 +02:00
|
|
|
/*
|
|
|
|
* Free memory in a JsonLexContext. There's no need for this if a *lex
|
|
|
|
* pointer was given when the object was made and need_escapes was false,
|
|
|
|
* or (in backend environment) a memory context delete/reset is imminent.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
freeJsonLexContext(JsonLexContext *lex)
|
|
|
|
{
|
|
|
|
if (lex->flags & JSONLEX_FREE_STRVAL)
|
|
|
|
{
|
|
|
|
pfree(lex->strval->data);
|
|
|
|
pfree(lex->strval);
|
|
|
|
}
|
|
|
|
if (lex->flags & JSONLEX_FREE_STRUCT)
|
|
|
|
pfree(lex);
|
|
|
|
}
|
|
|
|
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
/*
|
|
|
|
* pg_parse_json
|
|
|
|
*
|
|
|
|
* Publicly visible entry point for the JSON parser.
|
|
|
|
*
|
|
|
|
* lex is a lexing context, set up for the json to be processed by calling
|
|
|
|
* makeJsonLexContext(). sem is a structure of function pointers to semantic
|
|
|
|
* action routines to be called at appropriate spots during parsing, and a
|
|
|
|
* pointer to a state object to be passed to those routines.
|
|
|
|
*/
|
2020-01-27 17:03:21 +01:00
|
|
|
JsonParseErrorType
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
pg_parse_json(JsonLexContext *lex, JsonSemAction *sem)
|
|
|
|
{
|
|
|
|
JsonTokenType tok;
|
2020-01-27 17:03:21 +01:00
|
|
|
JsonParseErrorType result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
/* get the initial token */
|
2020-01-27 17:03:21 +01:00
|
|
|
result = json_lex(lex);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
tok = lex_peek(lex);
|
|
|
|
|
|
|
|
/* parse by recursive descent */
|
|
|
|
switch (tok)
|
|
|
|
{
|
|
|
|
case JSON_TOKEN_OBJECT_START:
|
2020-01-27 17:03:21 +01:00
|
|
|
result = parse_object(lex, sem);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
break;
|
|
|
|
case JSON_TOKEN_ARRAY_START:
|
2020-01-27 17:03:21 +01:00
|
|
|
result = parse_array(lex, sem);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
break;
|
|
|
|
default:
|
2020-01-27 17:03:21 +01:00
|
|
|
result = parse_scalar(lex, sem); /* json can be a bare scalar */
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
|
2020-01-27 17:03:21 +01:00
|
|
|
if (result == JSON_SUCCESS)
|
|
|
|
result = lex_expect(JSON_PARSE_END, lex, JSON_TOKEN_END);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
/*
|
|
|
|
* json_count_array_elements
|
|
|
|
*
|
|
|
|
* Returns number of array elements in lex context at start of array token
|
|
|
|
* until end of array token at same nesting level.
|
|
|
|
*
|
|
|
|
* Designed to be called from array_start routines.
|
|
|
|
*/
|
2020-01-27 17:03:21 +01:00
|
|
|
JsonParseErrorType
|
|
|
|
json_count_array_elements(JsonLexContext *lex, int *elements)
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
{
|
|
|
|
JsonLexContext copylex;
|
|
|
|
int count;
|
2020-01-27 17:03:21 +01:00
|
|
|
JsonParseErrorType result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* It's safe to do this with a shallow copy because the lexical routines
|
|
|
|
* don't scribble on the input. They do scribble on the other pointers
|
|
|
|
* etc, so doing this with a copy makes that safe.
|
|
|
|
*/
|
|
|
|
memcpy(©lex, lex, sizeof(JsonLexContext));
|
|
|
|
copylex.strval = NULL; /* not interested in values here */
|
|
|
|
copylex.lex_level++;
|
|
|
|
|
|
|
|
count = 0;
|
2020-01-27 17:03:21 +01:00
|
|
|
result = lex_expect(JSON_PARSE_ARRAY_START, ©lex,
|
|
|
|
JSON_TOKEN_ARRAY_START);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
if (lex_peek(©lex) != JSON_TOKEN_ARRAY_END)
|
|
|
|
{
|
2020-01-17 20:06:41 +01:00
|
|
|
while (1)
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
{
|
|
|
|
count++;
|
2020-01-27 17:03:21 +01:00
|
|
|
result = parse_array_element(©lex, &nullSemAction);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
2020-01-17 20:06:41 +01:00
|
|
|
if (copylex.token_type != JSON_TOKEN_COMMA)
|
|
|
|
break;
|
2020-01-27 17:03:21 +01:00
|
|
|
result = json_lex(©lex);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
}
|
2020-01-27 17:03:21 +01:00
|
|
|
result = lex_expect(JSON_PARSE_ARRAY_NEXT, ©lex,
|
|
|
|
JSON_TOKEN_ARRAY_END);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
2020-01-27 17:03:21 +01:00
|
|
|
*elements = count;
|
|
|
|
return JSON_SUCCESS;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Recursive Descent parse routines. There is one for each structural
|
|
|
|
* element in a json document:
|
|
|
|
* - scalar (string, number, true, false, null)
|
|
|
|
* - array ( [ ] )
|
|
|
|
* - array element
|
|
|
|
* - object ( { } )
|
|
|
|
* - object field
|
|
|
|
*/
|
2020-01-27 17:03:21 +01:00
|
|
|
static inline JsonParseErrorType
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
parse_scalar(JsonLexContext *lex, JsonSemAction *sem)
|
|
|
|
{
|
|
|
|
char *val = NULL;
|
|
|
|
json_scalar_action sfunc = sem->scalar;
|
|
|
|
JsonTokenType tok = lex_peek(lex);
|
2020-01-27 17:03:21 +01:00
|
|
|
JsonParseErrorType result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
/* a scalar must be a string, a number, true, false, or null */
|
2020-01-17 20:06:41 +01:00
|
|
|
if (tok != JSON_TOKEN_STRING && tok != JSON_TOKEN_NUMBER &&
|
|
|
|
tok != JSON_TOKEN_TRUE && tok != JSON_TOKEN_FALSE &&
|
|
|
|
tok != JSON_TOKEN_NULL)
|
2020-01-27 17:03:21 +01:00
|
|
|
return report_parse_error(JSON_PARSE_VALUE, lex);
|
2020-01-17 20:06:41 +01:00
|
|
|
|
|
|
|
/* if no semantic function, just consume the token */
|
|
|
|
if (sfunc == NULL)
|
2020-01-27 17:03:21 +01:00
|
|
|
return json_lex(lex);
|
2020-01-17 20:06:41 +01:00
|
|
|
|
|
|
|
/* extract the de-escaped string value, or the raw lexeme */
|
|
|
|
if (lex_peek(lex) == JSON_TOKEN_STRING)
|
|
|
|
{
|
|
|
|
if (lex->strval != NULL)
|
|
|
|
val = pstrdup(lex->strval->data);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
2020-01-17 20:06:41 +01:00
|
|
|
else
|
|
|
|
{
|
|
|
|
int len = (lex->token_terminator - lex->token_start);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
2020-01-17 20:06:41 +01:00
|
|
|
val = palloc(len + 1);
|
|
|
|
memcpy(val, lex->token_start, len);
|
|
|
|
val[len] = '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
/* consume the token */
|
2020-01-27 17:03:21 +01:00
|
|
|
result = json_lex(lex);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
2020-01-17 20:06:41 +01:00
|
|
|
|
|
|
|
/* invoke the callback */
|
2022-12-11 16:39:05 +01:00
|
|
|
result = (*sfunc) (sem->semstate, val, tok);
|
2020-01-27 17:03:21 +01:00
|
|
|
|
2022-12-11 16:39:05 +01:00
|
|
|
return result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
|
2020-01-27 17:03:21 +01:00
|
|
|
static JsonParseErrorType
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
parse_object_field(JsonLexContext *lex, JsonSemAction *sem)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* An object field is "fieldname" : value where value can be a scalar,
|
|
|
|
* object or array. Note: in user-facing docs and error messages, we
|
|
|
|
* generally call a field name a "key".
|
|
|
|
*/
|
|
|
|
|
|
|
|
char *fname = NULL; /* keep compiler quiet */
|
|
|
|
json_ofield_action ostart = sem->object_field_start;
|
|
|
|
json_ofield_action oend = sem->object_field_end;
|
|
|
|
bool isnull;
|
|
|
|
JsonTokenType tok;
|
2020-01-27 17:03:21 +01:00
|
|
|
JsonParseErrorType result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
2020-01-17 20:06:41 +01:00
|
|
|
if (lex_peek(lex) != JSON_TOKEN_STRING)
|
2020-01-27 17:03:21 +01:00
|
|
|
return report_parse_error(JSON_PARSE_STRING, lex);
|
2020-01-17 20:06:41 +01:00
|
|
|
if ((ostart != NULL || oend != NULL) && lex->strval != NULL)
|
|
|
|
fname = pstrdup(lex->strval->data);
|
2020-01-27 17:03:21 +01:00
|
|
|
result = json_lex(lex);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
2020-01-27 17:03:21 +01:00
|
|
|
result = lex_expect(JSON_PARSE_OBJECT_LABEL, lex, JSON_TOKEN_COLON);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
tok = lex_peek(lex);
|
|
|
|
isnull = tok == JSON_TOKEN_NULL;
|
|
|
|
|
|
|
|
if (ostart != NULL)
|
2022-12-11 16:39:05 +01:00
|
|
|
{
|
|
|
|
result = (*ostart) (sem->semstate, fname, isnull);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
|
|
|
}
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
switch (tok)
|
|
|
|
{
|
|
|
|
case JSON_TOKEN_OBJECT_START:
|
2020-01-27 17:03:21 +01:00
|
|
|
result = parse_object(lex, sem);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
break;
|
|
|
|
case JSON_TOKEN_ARRAY_START:
|
2020-01-27 17:03:21 +01:00
|
|
|
result = parse_array(lex, sem);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
break;
|
|
|
|
default:
|
2020-01-27 17:03:21 +01:00
|
|
|
result = parse_scalar(lex, sem);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
2020-01-27 17:03:21 +01:00
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
if (oend != NULL)
|
2022-12-11 16:39:05 +01:00
|
|
|
{
|
|
|
|
result = (*oend) (sem->semstate, fname, isnull);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2020-01-27 17:03:21 +01:00
|
|
|
return JSON_SUCCESS;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
|
2020-01-27 17:03:21 +01:00
|
|
|
static JsonParseErrorType
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
parse_object(JsonLexContext *lex, JsonSemAction *sem)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* an object is a possibly empty sequence of object fields, separated by
|
|
|
|
* commas and surrounded by curly braces.
|
|
|
|
*/
|
|
|
|
json_struct_action ostart = sem->object_start;
|
|
|
|
json_struct_action oend = sem->object_end;
|
|
|
|
JsonTokenType tok;
|
2020-01-27 17:03:21 +01:00
|
|
|
JsonParseErrorType result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
2021-07-02 02:35:12 +02:00
|
|
|
#ifndef FRONTEND
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
check_stack_depth();
|
2021-07-02 02:35:12 +02:00
|
|
|
#endif
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
if (ostart != NULL)
|
2022-12-11 16:39:05 +01:00
|
|
|
{
|
|
|
|
result = (*ostart) (sem->semstate);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
|
|
|
}
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Data inside an object is at a higher nesting level than the object
|
|
|
|
* itself. Note that we increment this after we call the semantic routine
|
|
|
|
* for the object start and restore it before we call the routine for the
|
|
|
|
* object end.
|
|
|
|
*/
|
|
|
|
lex->lex_level++;
|
|
|
|
|
2020-01-17 20:06:41 +01:00
|
|
|
Assert(lex_peek(lex) == JSON_TOKEN_OBJECT_START);
|
2020-01-27 17:03:21 +01:00
|
|
|
result = json_lex(lex);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
tok = lex_peek(lex);
|
|
|
|
switch (tok)
|
|
|
|
{
|
|
|
|
case JSON_TOKEN_STRING:
|
2020-01-27 17:03:21 +01:00
|
|
|
result = parse_object_field(lex, sem);
|
|
|
|
while (result == JSON_SUCCESS && lex_peek(lex) == JSON_TOKEN_COMMA)
|
2020-01-17 20:06:41 +01:00
|
|
|
{
|
2020-01-27 17:03:21 +01:00
|
|
|
result = json_lex(lex);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
break;
|
|
|
|
result = parse_object_field(lex, sem);
|
2020-01-17 20:06:41 +01:00
|
|
|
}
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
break;
|
|
|
|
case JSON_TOKEN_OBJECT_END:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* case of an invalid initial token inside the object */
|
2020-01-27 17:03:21 +01:00
|
|
|
result = report_parse_error(JSON_PARSE_OBJECT_START, lex);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
2020-01-27 17:03:21 +01:00
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
2020-01-27 17:03:21 +01:00
|
|
|
result = lex_expect(JSON_PARSE_OBJECT_NEXT, lex, JSON_TOKEN_OBJECT_END);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
lex->lex_level--;
|
|
|
|
|
|
|
|
if (oend != NULL)
|
2022-12-11 16:39:05 +01:00
|
|
|
{
|
|
|
|
result = (*oend) (sem->semstate);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
|
|
|
}
|
2020-01-27 17:03:21 +01:00
|
|
|
|
|
|
|
return JSON_SUCCESS;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
|
2020-01-27 17:03:21 +01:00
|
|
|
static JsonParseErrorType
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
parse_array_element(JsonLexContext *lex, JsonSemAction *sem)
|
|
|
|
{
|
|
|
|
json_aelem_action astart = sem->array_element_start;
|
|
|
|
json_aelem_action aend = sem->array_element_end;
|
|
|
|
JsonTokenType tok = lex_peek(lex);
|
2020-01-27 17:03:21 +01:00
|
|
|
JsonParseErrorType result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
bool isnull;
|
|
|
|
|
|
|
|
isnull = tok == JSON_TOKEN_NULL;
|
|
|
|
|
|
|
|
if (astart != NULL)
|
2022-12-11 16:39:05 +01:00
|
|
|
{
|
|
|
|
result = (*astart) (sem->semstate, isnull);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
|
|
|
}
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
/* an array element is any object, array or scalar */
|
|
|
|
switch (tok)
|
|
|
|
{
|
|
|
|
case JSON_TOKEN_OBJECT_START:
|
2020-01-27 17:03:21 +01:00
|
|
|
result = parse_object(lex, sem);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
break;
|
|
|
|
case JSON_TOKEN_ARRAY_START:
|
2020-01-27 17:03:21 +01:00
|
|
|
result = parse_array(lex, sem);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
break;
|
|
|
|
default:
|
2020-01-27 17:03:21 +01:00
|
|
|
result = parse_scalar(lex, sem);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
|
2020-01-27 17:03:21 +01:00
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
|
|
|
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
if (aend != NULL)
|
2022-12-11 16:39:05 +01:00
|
|
|
{
|
|
|
|
result = (*aend) (sem->semstate, isnull);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
|
|
|
}
|
2020-01-27 17:03:21 +01:00
|
|
|
|
|
|
|
return JSON_SUCCESS;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
|
2020-01-27 17:03:21 +01:00
|
|
|
static JsonParseErrorType
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
parse_array(JsonLexContext *lex, JsonSemAction *sem)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* an array is a possibly empty sequence of array elements, separated by
|
|
|
|
* commas and surrounded by square brackets.
|
|
|
|
*/
|
|
|
|
json_struct_action astart = sem->array_start;
|
|
|
|
json_struct_action aend = sem->array_end;
|
2020-01-27 17:03:21 +01:00
|
|
|
JsonParseErrorType result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
2021-07-02 02:35:12 +02:00
|
|
|
#ifndef FRONTEND
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
check_stack_depth();
|
2021-07-02 02:35:12 +02:00
|
|
|
#endif
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
if (astart != NULL)
|
2022-12-11 16:39:05 +01:00
|
|
|
{
|
|
|
|
result = (*astart) (sem->semstate);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
|
|
|
}
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Data inside an array is at a higher nesting level than the array
|
|
|
|
* itself. Note that we increment this after we call the semantic routine
|
|
|
|
* for the array start and restore it before we call the routine for the
|
|
|
|
* array end.
|
|
|
|
*/
|
|
|
|
lex->lex_level++;
|
|
|
|
|
2020-01-27 17:03:21 +01:00
|
|
|
result = lex_expect(JSON_PARSE_ARRAY_START, lex, JSON_TOKEN_ARRAY_START);
|
|
|
|
if (result == JSON_SUCCESS && lex_peek(lex) != JSON_TOKEN_ARRAY_END)
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
{
|
2020-01-27 17:03:21 +01:00
|
|
|
result = parse_array_element(lex, sem);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
2020-01-27 17:03:21 +01:00
|
|
|
while (result == JSON_SUCCESS && lex_peek(lex) == JSON_TOKEN_COMMA)
|
2020-01-17 20:06:41 +01:00
|
|
|
{
|
2020-01-27 17:03:21 +01:00
|
|
|
result = json_lex(lex);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
break;
|
|
|
|
result = parse_array_element(lex, sem);
|
2020-01-17 20:06:41 +01:00
|
|
|
}
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
2020-01-27 17:03:21 +01:00
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
2020-01-27 17:03:21 +01:00
|
|
|
result = lex_expect(JSON_PARSE_ARRAY_NEXT, lex, JSON_TOKEN_ARRAY_END);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
lex->lex_level--;
|
|
|
|
|
|
|
|
if (aend != NULL)
|
2022-12-11 16:39:05 +01:00
|
|
|
{
|
|
|
|
result = (*aend) (sem->semstate);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
|
|
|
}
|
2020-01-27 17:03:21 +01:00
|
|
|
|
|
|
|
return JSON_SUCCESS;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Lex one token from the input stream.
|
|
|
|
*/
|
2020-01-27 17:03:21 +01:00
|
|
|
JsonParseErrorType
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
json_lex(JsonLexContext *lex)
|
|
|
|
{
|
|
|
|
char *s;
|
2022-07-08 09:53:20 +02:00
|
|
|
char *const end = lex->input + lex->input_length;
|
2020-01-27 17:03:21 +01:00
|
|
|
JsonParseErrorType result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
/* Skip leading whitespace. */
|
|
|
|
s = lex->token_terminator;
|
2022-07-08 09:53:20 +02:00
|
|
|
while (s < end && (*s == ' ' || *s == '\t' || *s == '\n' || *s == '\r'))
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
{
|
2021-03-01 22:44:17 +01:00
|
|
|
if (*s++ == '\n')
|
|
|
|
{
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
++lex->line_number;
|
2021-03-01 22:44:17 +01:00
|
|
|
lex->line_start = s;
|
|
|
|
}
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
lex->token_start = s;
|
|
|
|
|
|
|
|
/* Determine token type. */
|
2022-07-08 09:53:20 +02:00
|
|
|
if (s >= end)
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
{
|
|
|
|
lex->token_start = NULL;
|
|
|
|
lex->prev_token_terminator = lex->token_terminator;
|
|
|
|
lex->token_terminator = s;
|
|
|
|
lex->token_type = JSON_TOKEN_END;
|
|
|
|
}
|
|
|
|
else
|
2020-01-27 17:03:21 +01:00
|
|
|
{
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
switch (*s)
|
|
|
|
{
|
|
|
|
/* Single-character token, some kind of punctuation mark. */
|
|
|
|
case '{':
|
|
|
|
lex->prev_token_terminator = lex->token_terminator;
|
|
|
|
lex->token_terminator = s + 1;
|
|
|
|
lex->token_type = JSON_TOKEN_OBJECT_START;
|
|
|
|
break;
|
|
|
|
case '}':
|
|
|
|
lex->prev_token_terminator = lex->token_terminator;
|
|
|
|
lex->token_terminator = s + 1;
|
|
|
|
lex->token_type = JSON_TOKEN_OBJECT_END;
|
|
|
|
break;
|
|
|
|
case '[':
|
|
|
|
lex->prev_token_terminator = lex->token_terminator;
|
|
|
|
lex->token_terminator = s + 1;
|
|
|
|
lex->token_type = JSON_TOKEN_ARRAY_START;
|
|
|
|
break;
|
|
|
|
case ']':
|
|
|
|
lex->prev_token_terminator = lex->token_terminator;
|
|
|
|
lex->token_terminator = s + 1;
|
|
|
|
lex->token_type = JSON_TOKEN_ARRAY_END;
|
|
|
|
break;
|
|
|
|
case ',':
|
|
|
|
lex->prev_token_terminator = lex->token_terminator;
|
|
|
|
lex->token_terminator = s + 1;
|
|
|
|
lex->token_type = JSON_TOKEN_COMMA;
|
|
|
|
break;
|
|
|
|
case ':':
|
|
|
|
lex->prev_token_terminator = lex->token_terminator;
|
|
|
|
lex->token_terminator = s + 1;
|
|
|
|
lex->token_type = JSON_TOKEN_COLON;
|
|
|
|
break;
|
|
|
|
case '"':
|
|
|
|
/* string */
|
2020-01-27 17:03:21 +01:00
|
|
|
result = json_lex_string(lex);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
lex->token_type = JSON_TOKEN_STRING;
|
|
|
|
break;
|
|
|
|
case '-':
|
|
|
|
/* Negative number. */
|
2020-01-27 17:03:21 +01:00
|
|
|
result = json_lex_number(lex, s + 1, NULL, NULL);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
lex->token_type = JSON_TOKEN_NUMBER;
|
|
|
|
break;
|
|
|
|
case '0':
|
|
|
|
case '1':
|
|
|
|
case '2':
|
|
|
|
case '3':
|
|
|
|
case '4':
|
|
|
|
case '5':
|
|
|
|
case '6':
|
|
|
|
case '7':
|
|
|
|
case '8':
|
|
|
|
case '9':
|
|
|
|
/* Positive number. */
|
2020-01-27 17:03:21 +01:00
|
|
|
result = json_lex_number(lex, s, NULL, NULL);
|
|
|
|
if (result != JSON_SUCCESS)
|
|
|
|
return result;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
lex->token_type = JSON_TOKEN_NUMBER;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We're not dealing with a string, number, legal
|
|
|
|
* punctuation mark, or end of string. The only legal
|
|
|
|
* tokens we might find here are true, false, and null,
|
|
|
|
* but for error reporting purposes we scan until we see a
|
|
|
|
* non-alphanumeric character. That way, we can report
|
|
|
|
* the whole word as an unexpected token, rather than just
|
|
|
|
* some unintuitive prefix thereof.
|
|
|
|
*/
|
2022-07-08 09:53:20 +02:00
|
|
|
for (p = s; p < end && JSON_ALPHANUMERIC_CHAR(*p); p++)
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
/* skip */ ;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We got some sort of unexpected punctuation or an
|
|
|
|
* otherwise unexpected character, so just complain about
|
|
|
|
* that one character.
|
|
|
|
*/
|
|
|
|
if (p == s)
|
|
|
|
{
|
|
|
|
lex->prev_token_terminator = lex->token_terminator;
|
|
|
|
lex->token_terminator = s + 1;
|
2020-01-27 17:03:21 +01:00
|
|
|
return JSON_INVALID_TOKEN;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We've got a real alphanumeric token here. If it
|
|
|
|
* happens to be true, false, or null, all is well. If
|
|
|
|
* not, error out.
|
|
|
|
*/
|
|
|
|
lex->prev_token_terminator = lex->token_terminator;
|
|
|
|
lex->token_terminator = p;
|
|
|
|
if (p - s == 4)
|
|
|
|
{
|
|
|
|
if (memcmp(s, "true", 4) == 0)
|
|
|
|
lex->token_type = JSON_TOKEN_TRUE;
|
|
|
|
else if (memcmp(s, "null", 4) == 0)
|
|
|
|
lex->token_type = JSON_TOKEN_NULL;
|
|
|
|
else
|
2020-01-27 17:03:21 +01:00
|
|
|
return JSON_INVALID_TOKEN;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
else if (p - s == 5 && memcmp(s, "false", 5) == 0)
|
|
|
|
lex->token_type = JSON_TOKEN_FALSE;
|
|
|
|
else
|
2020-01-27 17:03:21 +01:00
|
|
|
return JSON_INVALID_TOKEN;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
} /* end of switch */
|
2020-01-27 17:03:21 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
return JSON_SUCCESS;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The next token in the input stream is known to be a string; lex it.
|
2023-03-13 20:19:00 +01:00
|
|
|
*
|
|
|
|
* If lex->strval isn't NULL, fill it with the decoded string.
|
|
|
|
* Set lex->token_terminator to the end of the decoded input, and in
|
|
|
|
* success cases, transfer its previous value to lex->prev_token_terminator.
|
|
|
|
* Return JSON_SUCCESS or an error code.
|
|
|
|
*
|
|
|
|
* Note: be careful that all error exits advance lex->token_terminator
|
|
|
|
* to the point after the character we detected the error on.
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
*/
|
2020-01-27 17:03:21 +01:00
|
|
|
static inline JsonParseErrorType
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
json_lex_string(JsonLexContext *lex)
|
|
|
|
{
|
|
|
|
char *s;
|
2022-07-08 09:53:20 +02:00
|
|
|
char *const end = lex->input + lex->input_length;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
int hi_surrogate = -1;
|
|
|
|
|
2023-03-13 20:19:00 +01:00
|
|
|
/* Convenience macros for error exits */
|
|
|
|
#define FAIL_AT_CHAR_START(code) \
|
|
|
|
do { \
|
|
|
|
lex->token_terminator = s; \
|
|
|
|
return code; \
|
|
|
|
} while (0)
|
|
|
|
#define FAIL_AT_CHAR_END(code) \
|
|
|
|
do { \
|
|
|
|
lex->token_terminator = \
|
|
|
|
s + pg_encoding_mblen_bounded(lex->input_encoding, s); \
|
|
|
|
return code; \
|
|
|
|
} while (0)
|
|
|
|
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
if (lex->strval != NULL)
|
|
|
|
resetStringInfo(lex->strval);
|
|
|
|
|
|
|
|
Assert(lex->input_length > 0);
|
|
|
|
s = lex->token_start;
|
|
|
|
for (;;)
|
|
|
|
{
|
|
|
|
s++;
|
|
|
|
/* Premature end of the string. */
|
2022-07-08 09:53:20 +02:00
|
|
|
if (s >= end)
|
2023-03-13 20:19:00 +01:00
|
|
|
FAIL_AT_CHAR_START(JSON_INVALID_TOKEN);
|
2022-07-12 06:13:41 +02:00
|
|
|
else if (*s == '"')
|
|
|
|
break;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
else if (*s == '\\')
|
|
|
|
{
|
|
|
|
/* OK, we have an escape character. */
|
|
|
|
s++;
|
2022-07-08 09:53:20 +02:00
|
|
|
if (s >= end)
|
2023-03-13 20:19:00 +01:00
|
|
|
FAIL_AT_CHAR_START(JSON_INVALID_TOKEN);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
else if (*s == 'u')
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int ch = 0;
|
|
|
|
|
|
|
|
for (i = 1; i <= 4; i++)
|
|
|
|
{
|
|
|
|
s++;
|
2022-07-08 09:53:20 +02:00
|
|
|
if (s >= end)
|
2023-03-13 20:19:00 +01:00
|
|
|
FAIL_AT_CHAR_START(JSON_INVALID_TOKEN);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
else if (*s >= '0' && *s <= '9')
|
|
|
|
ch = (ch * 16) + (*s - '0');
|
|
|
|
else if (*s >= 'a' && *s <= 'f')
|
|
|
|
ch = (ch * 16) + (*s - 'a') + 10;
|
|
|
|
else if (*s >= 'A' && *s <= 'F')
|
|
|
|
ch = (ch * 16) + (*s - 'A') + 10;
|
|
|
|
else
|
2023-03-13 20:19:00 +01:00
|
|
|
FAIL_AT_CHAR_END(JSON_UNICODE_ESCAPE_FORMAT);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
if (lex->strval != NULL)
|
|
|
|
{
|
2020-03-06 20:17:43 +01:00
|
|
|
/*
|
|
|
|
* Combine surrogate pairs.
|
|
|
|
*/
|
|
|
|
if (is_utf16_surrogate_first(ch))
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
{
|
|
|
|
if (hi_surrogate != -1)
|
2023-03-13 20:19:00 +01:00
|
|
|
FAIL_AT_CHAR_END(JSON_UNICODE_HIGH_SURROGATE);
|
2020-03-06 20:17:43 +01:00
|
|
|
hi_surrogate = ch;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
continue;
|
|
|
|
}
|
2020-03-06 20:17:43 +01:00
|
|
|
else if (is_utf16_surrogate_second(ch))
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
{
|
|
|
|
if (hi_surrogate == -1)
|
2023-03-13 20:19:00 +01:00
|
|
|
FAIL_AT_CHAR_END(JSON_UNICODE_LOW_SURROGATE);
|
2020-03-06 20:17:43 +01:00
|
|
|
ch = surrogate_pair_to_codepoint(hi_surrogate, ch);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
hi_surrogate = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (hi_surrogate != -1)
|
2023-03-13 20:19:00 +01:00
|
|
|
FAIL_AT_CHAR_END(JSON_UNICODE_LOW_SURROGATE);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
/*
|
2020-03-06 20:17:43 +01:00
|
|
|
* Reject invalid cases. We can't have a value above
|
|
|
|
* 0xFFFF here (since we only accepted 4 hex digits
|
|
|
|
* above), so no need to test for out-of-range chars.
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
*/
|
|
|
|
if (ch == 0)
|
|
|
|
{
|
|
|
|
/* We can't allow this, since our TEXT type doesn't */
|
2023-03-13 20:19:00 +01:00
|
|
|
FAIL_AT_CHAR_END(JSON_UNICODE_CODE_POINT_ZERO);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
2020-03-06 20:17:43 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Add the represented character to lex->strval. In the
|
2022-12-11 17:28:15 +01:00
|
|
|
* backend, we can let pg_unicode_to_server_noerror()
|
|
|
|
* handle any required character set conversion; in
|
|
|
|
* frontend, we can only deal with trivial conversions.
|
2020-03-06 20:17:43 +01:00
|
|
|
*/
|
|
|
|
#ifndef FRONTEND
|
|
|
|
{
|
|
|
|
char cbuf[MAX_UNICODE_EQUIVALENT_STRING + 1];
|
|
|
|
|
2022-12-11 17:28:15 +01:00
|
|
|
if (!pg_unicode_to_server_noerror(ch, (unsigned char *) cbuf))
|
2023-03-13 20:19:00 +01:00
|
|
|
FAIL_AT_CHAR_END(JSON_UNICODE_UNTRANSLATABLE);
|
2020-03-06 20:17:43 +01:00
|
|
|
appendStringInfoString(lex->strval, cbuf);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
if (lex->input_encoding == PG_UTF8)
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
{
|
2020-03-06 20:17:43 +01:00
|
|
|
/* OK, we can map the code point to UTF8 easily */
|
|
|
|
char utf8str[5];
|
|
|
|
int utf8len;
|
|
|
|
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
unicode_to_utf8(ch, (unsigned char *) utf8str);
|
|
|
|
utf8len = pg_utf_mblen((unsigned char *) utf8str);
|
|
|
|
appendBinaryStringInfo(lex->strval, utf8str, utf8len);
|
|
|
|
}
|
|
|
|
else if (ch <= 0x007f)
|
|
|
|
{
|
2020-03-06 20:17:43 +01:00
|
|
|
/* The ASCII range is the same in all encodings */
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
appendStringInfoChar(lex->strval, (char) ch);
|
|
|
|
}
|
|
|
|
else
|
2023-03-13 20:19:00 +01:00
|
|
|
FAIL_AT_CHAR_END(JSON_UNICODE_HIGH_ESCAPE);
|
2020-03-06 20:17:43 +01:00
|
|
|
#endif /* FRONTEND */
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (lex->strval != NULL)
|
|
|
|
{
|
|
|
|
if (hi_surrogate != -1)
|
2023-03-13 20:19:00 +01:00
|
|
|
FAIL_AT_CHAR_END(JSON_UNICODE_LOW_SURROGATE);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
|
|
|
switch (*s)
|
|
|
|
{
|
|
|
|
case '"':
|
|
|
|
case '\\':
|
|
|
|
case '/':
|
|
|
|
appendStringInfoChar(lex->strval, *s);
|
|
|
|
break;
|
|
|
|
case 'b':
|
|
|
|
appendStringInfoChar(lex->strval, '\b');
|
|
|
|
break;
|
|
|
|
case 'f':
|
|
|
|
appendStringInfoChar(lex->strval, '\f');
|
|
|
|
break;
|
|
|
|
case 'n':
|
|
|
|
appendStringInfoChar(lex->strval, '\n');
|
|
|
|
break;
|
|
|
|
case 'r':
|
|
|
|
appendStringInfoChar(lex->strval, '\r');
|
|
|
|
break;
|
|
|
|
case 't':
|
|
|
|
appendStringInfoChar(lex->strval, '\t');
|
|
|
|
break;
|
|
|
|
default:
|
2023-03-13 20:19:00 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Not a valid string escape, so signal error. We
|
|
|
|
* adjust token_start so that just the escape sequence
|
|
|
|
* is reported, not the whole string.
|
|
|
|
*/
|
2020-01-27 17:03:21 +01:00
|
|
|
lex->token_start = s;
|
2023-03-13 20:19:00 +01:00
|
|
|
FAIL_AT_CHAR_END(JSON_ESCAPING_INVALID);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (strchr("\"\\/bfnrt", *s) == NULL)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Simpler processing if we're not bothered about de-escaping
|
|
|
|
*
|
|
|
|
* It's very tempting to remove the strchr() call here and
|
|
|
|
* replace it with a switch statement, but testing so far has
|
|
|
|
* shown it's not a performance win.
|
|
|
|
*/
|
2020-01-27 17:03:21 +01:00
|
|
|
lex->token_start = s;
|
2023-03-13 20:19:00 +01:00
|
|
|
FAIL_AT_CHAR_END(JSON_ESCAPING_INVALID);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
}
|
2022-07-01 12:28:20 +02:00
|
|
|
else
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
{
|
2022-08-31 05:39:17 +02:00
|
|
|
char *p = s;
|
2022-07-01 12:28:20 +02:00
|
|
|
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
if (hi_surrogate != -1)
|
2023-03-13 20:19:00 +01:00
|
|
|
FAIL_AT_CHAR_END(JSON_UNICODE_LOW_SURROGATE);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
2022-07-01 12:28:20 +02:00
|
|
|
/*
|
|
|
|
* Skip to the first byte that requires special handling, so we
|
|
|
|
* can batch calls to appendBinaryStringInfo.
|
|
|
|
*/
|
2022-08-31 05:39:17 +02:00
|
|
|
while (p < end - sizeof(Vector8) &&
|
|
|
|
!pg_lfind8('\\', (uint8 *) p, sizeof(Vector8)) &&
|
|
|
|
!pg_lfind8('"', (uint8 *) p, sizeof(Vector8)) &&
|
|
|
|
!pg_lfind8_le(31, (uint8 *) p, sizeof(Vector8)))
|
|
|
|
p += sizeof(Vector8);
|
|
|
|
|
|
|
|
for (; p < end; p++)
|
2022-07-01 12:28:20 +02:00
|
|
|
{
|
|
|
|
if (*p == '\\' || *p == '"')
|
|
|
|
break;
|
2022-08-31 05:39:17 +02:00
|
|
|
else if ((unsigned char) *p <= 31)
|
2022-07-01 12:28:20 +02:00
|
|
|
{
|
|
|
|
/* Per RFC4627, these characters MUST be escaped. */
|
|
|
|
/*
|
|
|
|
* Since *p isn't printable, exclude it from the context
|
|
|
|
* string
|
|
|
|
*/
|
|
|
|
lex->token_terminator = p;
|
|
|
|
return JSON_ESCAPING_REQUIRED;
|
|
|
|
}
|
|
|
|
}
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
2022-07-01 12:28:20 +02:00
|
|
|
if (lex->strval != NULL)
|
|
|
|
appendBinaryStringInfo(lex->strval, s, p - s);
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
2022-07-01 12:28:20 +02:00
|
|
|
/*
|
|
|
|
* s will be incremented at the top of the loop, so set it to just
|
|
|
|
* behind our lookahead position
|
|
|
|
*/
|
|
|
|
s = p - 1;
|
|
|
|
}
|
|
|
|
}
|
2022-07-12 06:13:41 +02:00
|
|
|
|
|
|
|
if (hi_surrogate != -1)
|
2023-03-13 20:19:00 +01:00
|
|
|
{
|
|
|
|
lex->token_terminator = s + 1;
|
2022-07-12 06:13:41 +02:00
|
|
|
return JSON_UNICODE_LOW_SURROGATE;
|
2023-03-13 20:19:00 +01:00
|
|
|
}
|
2022-07-12 06:13:41 +02:00
|
|
|
|
|
|
|
/* Hooray, we found the end of the string! */
|
|
|
|
lex->prev_token_terminator = lex->token_terminator;
|
|
|
|
lex->token_terminator = s + 1;
|
|
|
|
return JSON_SUCCESS;
|
2023-03-13 20:19:00 +01:00
|
|
|
|
|
|
|
#undef FAIL_AT_CHAR_START
|
|
|
|
#undef FAIL_AT_CHAR_END
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The next token in the input stream is known to be a number; lex it.
|
|
|
|
*
|
|
|
|
* In JSON, a number consists of four parts:
|
|
|
|
*
|
|
|
|
* (1) An optional minus sign ('-').
|
|
|
|
*
|
|
|
|
* (2) Either a single '0', or a string of one or more digits that does not
|
|
|
|
* begin with a '0'.
|
|
|
|
*
|
|
|
|
* (3) An optional decimal part, consisting of a period ('.') followed by
|
|
|
|
* one or more digits. (Note: While this part can be omitted
|
|
|
|
* completely, it's not OK to have only the decimal point without
|
|
|
|
* any digits afterwards.)
|
|
|
|
*
|
|
|
|
* (4) An optional exponent part, consisting of 'e' or 'E', optionally
|
|
|
|
* followed by '+' or '-', followed by one or more digits. (Note:
|
|
|
|
* As with the decimal part, if 'e' or 'E' is present, it must be
|
|
|
|
* followed by at least one digit.)
|
|
|
|
*
|
|
|
|
* The 's' argument to this function points to the ostensible beginning
|
|
|
|
* of part 2 - i.e. the character after any optional minus sign, or the
|
|
|
|
* first character of the string if there is none.
|
|
|
|
*
|
|
|
|
* If num_err is not NULL, we return an error flag to *num_err rather than
|
|
|
|
* raising an error for a badly-formed number. Also, if total_len is not NULL
|
|
|
|
* the distance from lex->input to the token end+1 is returned to *total_len.
|
|
|
|
*/
|
2020-01-27 17:03:21 +01:00
|
|
|
static inline JsonParseErrorType
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
json_lex_number(JsonLexContext *lex, char *s,
|
|
|
|
bool *num_err, int *total_len)
|
|
|
|
{
|
|
|
|
bool error = false;
|
|
|
|
int len = s - lex->input;
|
|
|
|
|
|
|
|
/* Part (1): leading sign indicator. */
|
|
|
|
/* Caller already did this for us; so do nothing. */
|
|
|
|
|
|
|
|
/* Part (2): parse main digit string. */
|
|
|
|
if (len < lex->input_length && *s == '0')
|
|
|
|
{
|
|
|
|
s++;
|
|
|
|
len++;
|
|
|
|
}
|
|
|
|
else if (len < lex->input_length && *s >= '1' && *s <= '9')
|
|
|
|
{
|
|
|
|
do
|
|
|
|
{
|
|
|
|
s++;
|
|
|
|
len++;
|
|
|
|
} while (len < lex->input_length && *s >= '0' && *s <= '9');
|
|
|
|
}
|
|
|
|
else
|
|
|
|
error = true;
|
|
|
|
|
|
|
|
/* Part (3): parse optional decimal portion. */
|
|
|
|
if (len < lex->input_length && *s == '.')
|
|
|
|
{
|
|
|
|
s++;
|
|
|
|
len++;
|
|
|
|
if (len == lex->input_length || *s < '0' || *s > '9')
|
|
|
|
error = true;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
do
|
|
|
|
{
|
|
|
|
s++;
|
|
|
|
len++;
|
|
|
|
} while (len < lex->input_length && *s >= '0' && *s <= '9');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Part (4): parse optional exponent. */
|
|
|
|
if (len < lex->input_length && (*s == 'e' || *s == 'E'))
|
|
|
|
{
|
|
|
|
s++;
|
|
|
|
len++;
|
|
|
|
if (len < lex->input_length && (*s == '+' || *s == '-'))
|
|
|
|
{
|
|
|
|
s++;
|
|
|
|
len++;
|
|
|
|
}
|
|
|
|
if (len == lex->input_length || *s < '0' || *s > '9')
|
|
|
|
error = true;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
do
|
|
|
|
{
|
|
|
|
s++;
|
|
|
|
len++;
|
|
|
|
} while (len < lex->input_length && *s >= '0' && *s <= '9');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check for trailing garbage. As in json_lex(), any alphanumeric stuff
|
|
|
|
* here should be considered part of the token for error-reporting
|
|
|
|
* purposes.
|
|
|
|
*/
|
|
|
|
for (; len < lex->input_length && JSON_ALPHANUMERIC_CHAR(*s); s++, len++)
|
|
|
|
error = true;
|
|
|
|
|
|
|
|
if (total_len != NULL)
|
|
|
|
*total_len = len;
|
|
|
|
|
|
|
|
if (num_err != NULL)
|
|
|
|
{
|
|
|
|
/* let the caller handle any error */
|
|
|
|
*num_err = error;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* return token endpoint */
|
|
|
|
lex->prev_token_terminator = lex->token_terminator;
|
|
|
|
lex->token_terminator = s;
|
|
|
|
/* handle error if any */
|
|
|
|
if (error)
|
2020-01-27 17:03:21 +01:00
|
|
|
return JSON_INVALID_TOKEN;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
2020-01-27 17:03:21 +01:00
|
|
|
|
|
|
|
return JSON_SUCCESS;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Report a parse error.
|
|
|
|
*
|
|
|
|
* lex->token_start and lex->token_terminator must identify the current token.
|
|
|
|
*/
|
2020-01-27 17:03:21 +01:00
|
|
|
static JsonParseErrorType
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
report_parse_error(JsonParseContext ctx, JsonLexContext *lex)
|
|
|
|
{
|
|
|
|
/* Handle case where the input ended prematurely. */
|
|
|
|
if (lex->token_start == NULL || lex->token_type == JSON_TOKEN_END)
|
2020-01-27 17:03:21 +01:00
|
|
|
return JSON_EXPECTED_MORE;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
2020-01-27 17:03:21 +01:00
|
|
|
/* Otherwise choose the error type based on the parsing context. */
|
|
|
|
switch (ctx)
|
|
|
|
{
|
|
|
|
case JSON_PARSE_END:
|
|
|
|
return JSON_EXPECTED_END;
|
|
|
|
case JSON_PARSE_VALUE:
|
|
|
|
return JSON_EXPECTED_JSON;
|
|
|
|
case JSON_PARSE_STRING:
|
|
|
|
return JSON_EXPECTED_STRING;
|
|
|
|
case JSON_PARSE_ARRAY_START:
|
|
|
|
return JSON_EXPECTED_ARRAY_FIRST;
|
|
|
|
case JSON_PARSE_ARRAY_NEXT:
|
|
|
|
return JSON_EXPECTED_ARRAY_NEXT;
|
|
|
|
case JSON_PARSE_OBJECT_START:
|
|
|
|
return JSON_EXPECTED_OBJECT_FIRST;
|
|
|
|
case JSON_PARSE_OBJECT_LABEL:
|
|
|
|
return JSON_EXPECTED_COLON;
|
|
|
|
case JSON_PARSE_OBJECT_NEXT:
|
|
|
|
return JSON_EXPECTED_OBJECT_NEXT;
|
|
|
|
case JSON_PARSE_OBJECT_COMMA:
|
|
|
|
return JSON_EXPECTED_STRING;
|
|
|
|
}
|
2020-01-28 00:46:30 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We don't use a default: case, so that the compiler will warn about
|
2021-07-02 02:35:12 +02:00
|
|
|
* unhandled enum values.
|
2020-01-28 00:46:30 +01:00
|
|
|
*/
|
2021-07-02 02:35:12 +02:00
|
|
|
Assert(false);
|
2020-01-28 00:46:30 +01:00
|
|
|
return JSON_SUCCESS; /* silence stupider compilers */
|
2020-01-27 17:03:21 +01:00
|
|
|
}
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
|
2021-07-02 02:35:12 +02:00
|
|
|
|
|
|
|
#ifndef FRONTEND
|
|
|
|
/*
|
|
|
|
* Extract the current token from a lexing context, for error reporting.
|
|
|
|
*/
|
|
|
|
static char *
|
|
|
|
extract_token(JsonLexContext *lex)
|
|
|
|
{
|
|
|
|
int toklen = lex->token_terminator - lex->token_start;
|
|
|
|
char *token = palloc(toklen + 1);
|
|
|
|
|
|
|
|
memcpy(token, lex->token_start, toklen);
|
|
|
|
token[toklen] = '\0';
|
|
|
|
return token;
|
|
|
|
}
|
|
|
|
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
/*
|
2022-09-28 17:14:53 +02:00
|
|
|
* Construct an (already translated) detail message for a JSON error.
|
2021-07-02 02:35:12 +02:00
|
|
|
*
|
|
|
|
* Note that the error message generated by this routine may not be
|
|
|
|
* palloc'd, making it unsafe for frontend code as there is no way to
|
2022-09-28 17:14:53 +02:00
|
|
|
* know if this can be safely pfree'd or not.
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
*/
|
2020-01-27 17:03:21 +01:00
|
|
|
char *
|
|
|
|
json_errdetail(JsonParseErrorType error, JsonLexContext *lex)
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
{
|
2020-01-27 17:03:21 +01:00
|
|
|
switch (error)
|
|
|
|
{
|
|
|
|
case JSON_SUCCESS:
|
2020-01-28 00:46:30 +01:00
|
|
|
/* fall through to the error code after switch */
|
2020-01-27 17:03:21 +01:00
|
|
|
break;
|
|
|
|
case JSON_ESCAPING_INVALID:
|
|
|
|
return psprintf(_("Escape sequence \"\\%s\" is invalid."),
|
|
|
|
extract_token(lex));
|
|
|
|
case JSON_ESCAPING_REQUIRED:
|
|
|
|
return psprintf(_("Character with value 0x%02x must be escaped."),
|
|
|
|
(unsigned char) *(lex->token_terminator));
|
|
|
|
case JSON_EXPECTED_END:
|
|
|
|
return psprintf(_("Expected end of input, but found \"%s\"."),
|
|
|
|
extract_token(lex));
|
|
|
|
case JSON_EXPECTED_ARRAY_FIRST:
|
|
|
|
return psprintf(_("Expected array element or \"]\", but found \"%s\"."),
|
|
|
|
extract_token(lex));
|
|
|
|
case JSON_EXPECTED_ARRAY_NEXT:
|
|
|
|
return psprintf(_("Expected \",\" or \"]\", but found \"%s\"."),
|
|
|
|
extract_token(lex));
|
|
|
|
case JSON_EXPECTED_COLON:
|
|
|
|
return psprintf(_("Expected \":\", but found \"%s\"."),
|
|
|
|
extract_token(lex));
|
|
|
|
case JSON_EXPECTED_JSON:
|
|
|
|
return psprintf(_("Expected JSON value, but found \"%s\"."),
|
|
|
|
extract_token(lex));
|
|
|
|
case JSON_EXPECTED_MORE:
|
|
|
|
return _("The input string ended unexpectedly.");
|
|
|
|
case JSON_EXPECTED_OBJECT_FIRST:
|
|
|
|
return psprintf(_("Expected string or \"}\", but found \"%s\"."),
|
|
|
|
extract_token(lex));
|
|
|
|
case JSON_EXPECTED_OBJECT_NEXT:
|
|
|
|
return psprintf(_("Expected \",\" or \"}\", but found \"%s\"."),
|
|
|
|
extract_token(lex));
|
|
|
|
case JSON_EXPECTED_STRING:
|
|
|
|
return psprintf(_("Expected string, but found \"%s\"."),
|
|
|
|
extract_token(lex));
|
|
|
|
case JSON_INVALID_TOKEN:
|
|
|
|
return psprintf(_("Token \"%s\" is invalid."),
|
|
|
|
extract_token(lex));
|
|
|
|
case JSON_UNICODE_CODE_POINT_ZERO:
|
|
|
|
return _("\\u0000 cannot be converted to text.");
|
|
|
|
case JSON_UNICODE_ESCAPE_FORMAT:
|
|
|
|
return _("\"\\u\" must be followed by four hexadecimal digits.");
|
|
|
|
case JSON_UNICODE_HIGH_ESCAPE:
|
2020-03-06 20:17:43 +01:00
|
|
|
/* note: this case is only reachable in frontend not backend */
|
|
|
|
return _("Unicode escape values cannot be used for code point values above 007F when the encoding is not UTF8.");
|
2022-12-11 17:28:15 +01:00
|
|
|
case JSON_UNICODE_UNTRANSLATABLE:
|
|
|
|
/* note: this case is only reachable in backend not frontend */
|
|
|
|
return psprintf(_("Unicode escape value could not be translated to the server's encoding %s."),
|
|
|
|
GetDatabaseEncodingName());
|
2020-01-27 17:03:21 +01:00
|
|
|
case JSON_UNICODE_HIGH_SURROGATE:
|
|
|
|
return _("Unicode high surrogate must not follow a high surrogate.");
|
|
|
|
case JSON_UNICODE_LOW_SURROGATE:
|
|
|
|
return _("Unicode low surrogate must follow a high surrogate.");
|
2022-12-11 16:39:05 +01:00
|
|
|
case JSON_SEM_ACTION_FAILED:
|
|
|
|
/* fall through to the error code after switch */
|
|
|
|
break;
|
2020-01-27 17:03:21 +01:00
|
|
|
}
|
2020-01-28 00:46:30 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We don't use a default: case, so that the compiler will warn about
|
|
|
|
* unhandled enum values. But this needs to be here anyway to cover the
|
|
|
|
* possibility of an incorrect input.
|
|
|
|
*/
|
2021-07-02 02:35:12 +02:00
|
|
|
elog(ERROR, "unexpected json parse error type: %d", (int) error);
|
|
|
|
return NULL;
|
Split JSON lexer/parser from 'json' data type support.
Keep the code that pertains to the 'json' data type in json.c, but
move the lexing and parsing code to a new file jsonapi.c, a name
I chose because the corresponding prototypes are in jsonapi.h.
This seems like a logical division, because the JSON lexer and parser
are also used by the 'jsonb' data type, but the SQL-callable functions
in json.c are a separate thing. Also, the new jsonapi.c file needs to
include far fewer header files than json.c, which seems like a good
sign that this is an appropriate place to insert an abstraction
boundary. I took the opportunity to remove a few apparently-unneeded
includes from json.c at the same time.
Patch by me, reviewed by David Steele, Mark Dilger, and Andrew
Dunstan. The previous commit was, too, but I forgot to note it
in the commit message.
Discussion: http://postgr.es/m/CA+TgmoYfOXhd27MUDGioVh6QtpD0C1K-f6ObSA10AWiHBAL5bA@mail.gmail.com
2020-01-24 19:17:43 +01:00
|
|
|
}
|
2021-07-02 02:35:12 +02:00
|
|
|
#endif
|