pg_query 0.7.0 → 0.7.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (17) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +5 -2
  3. data/README.md +1 -3
  4. data/ext/pg_query/extconf.rb +13 -48
  5. data/ext/pg_query/pg_query_ruby.c +89 -0
  6. data/ext/pg_query/pg_query_ruby.h +10 -0
  7. data/ext/pg_query/{pg_query.sym → pg_query_ruby.sym} +0 -0
  8. data/lib/pg_query/version.rb +1 -1
  9. metadata +5 -11
  10. data/ext/pg_query/patches/01_output_nodes_as_json.patch +0 -4626
  11. data/ext/pg_query/patches/02_parse_replacement_char.patch +0 -370
  12. data/ext/pg_query/patches/03_regenerate_bison_flex_files.patch +0 -67225
  13. data/ext/pg_query/pg_polyfills.c +0 -41
  14. data/ext/pg_query/pg_query.c +0 -15
  15. data/ext/pg_query/pg_query.h +0 -18
  16. data/ext/pg_query/pg_query_normalize.c +0 -363
  17. data/ext/pg_query/pg_query_parse.c +0 -108
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 03f50d45442f732b290c62fc085b1ca6f14afcb3
4
- data.tar.gz: dd68a99eda75075a43e945f56f829892ee5b1a46
3
+ metadata.gz: 64ead8467a9aeb8238aff25b10396577e21e46c0
4
+ data.tar.gz: 0c1b17563b05e8216e06c6bbb9041c2c2d8f70bc
5
5
  SHA512:
6
- metadata.gz: 2537e341ea8cc0cbb485f050f4c1ce0f6d18373f9c23048e7d0d425e2779b1730a3cccb72e76cb9faf0c9db01ed2dce7f7e2237f1bf4a94ef3241bf943f78c80
7
- data.tar.gz: 540b814ab9bb053391f432c85d052fe49d9237a8e63af75353b657fb33a274ec4d608c4a9fa77f79e95e51b1218bffabf7b9053e3f153c0813dff066bd6633c5
6
+ metadata.gz: 6877feae2dd1e47c80d07dd684bc8036c42b539ed00adcce25bffc52d9df62043937f6fc572d8be7becfbdabbfaf4616aef69cca7bf3f2a4f626d67c0862450b
7
+ data.tar.gz: 7e28d3b841b94ad22fb4ff2a8229abd98ce84916811cf948e10f1013eddc3b85600af9d9e6c3b54bb717c34f5d7fc901c508f7fdf7c9855c9216cc062ca3b5e8
data/CHANGELOG.md CHANGED
@@ -1,8 +1,11 @@
1
1
  # Changelog
2
2
 
3
- ## 0.7.1 UNRELEASED
3
+ ## 0.7.1 2015-11-17
4
4
 
5
- * ...
5
+ * Abstracted parser access into libpg_query [#24](https://github.com/lfittl/pg_query/pull/35)
6
+ * libpg_query
7
+ * Use UTF-8 encoding for parsing [#4](https://github.com/lfittl/libpg_query/pull/4) [@zhm](https://github.com/zhm)
8
+ * Add type to A_CONST nodes[#5](https://github.com/lfittl/libpg_query/pull/5) [@zhm](https://github.com/zhm)
6
9
 
7
10
 
8
11
  ## 0.7.0 2015-10-17
data/README.md CHANGED
@@ -16,9 +16,7 @@ You can find further examples and a longer rationale here: https://pganalyze.com
16
16
  gem install pg_query
17
17
  ```
18
18
 
19
- Due to compiling parts of PostgreSQL, installation will take a while. Expect between 2 and 10 minutes.
20
-
21
- Note: On some Linux systems you'll have to install the ```flex``` package beforehand.
19
+ Due to compiling parts of PostgreSQL, installation might take a while on slower systems. Expect up to 5 minutes.
22
20
 
23
21
  ## Usage
24
22
 
data/ext/pg_query/extconf.rb CHANGED
@@ -4,65 +4,30 @@ require 'mkmf'
4
4
  require 'open-uri'
5
5
 
6
6
  workdir = Dir.pwd
7
- pgdir = File.join(workdir, 'postgres')
7
+ libdir = File.join(workdir, 'libpg_query-master')
8
8
 
9
- PG_VERSION = '9.4.5'
10
-
11
- # Limit the objects we build to speed up compilation times
12
- PG_OBJS = {
13
- 'backend/utils' => [
14
- 'mb/wchar.o', 'mb/encnames.o', 'mb/mbutils.o',
15
- 'mmgr/mcxt.o', 'mmgr/aset.o',
16
- 'error/elog.o', 'init/globals.o',
17
- 'adt/name.o' # namein
18
- ],
19
- 'backend/parser' => [
20
- 'gram.o', 'parser.o', 'keywords.o', 'kwlookup.o', 'scansup.o'
21
- ],
22
- 'backend/nodes' => [
23
- 'copyfuncs.o', 'nodeFuncs.o', 'makefuncs.o', 'value.o', 'list.o', 'outfuncs_json.o'
24
- ],
25
- 'backend/lib' => ['stringinfo.o'],
26
- 'port' => ['qsort.o'],
27
- 'common' => ['psprintf.o'],
28
- 'timezone' => ['pgtz.o']
29
- }
30
-
31
- # Download PostgreSQL if we don't have it yet
32
- unless File.exist?("#{workdir}/postgres.tar.gz")
33
- File.open("#{workdir}/postgres.tar.gz", 'wb') do |target_file|
34
- open(format('https://ftp.postgresql.org/pub/source/v%s/postgresql-%s.tar.bz2', PG_VERSION, PG_VERSION), 'rb') do |read_file|
9
+ unless File.exist?("#{workdir}/libpg_query.tar.gz")
10
+ File.open("#{workdir}/libpg_query.tar.gz", 'wb') do |target_file|
11
+ open('https://codeload.github.com/lfittl/libpg_query/tar.gz/master', 'rb') do |read_file|
35
12
  target_file.write(read_file.read)
36
13
  end
37
14
  end
38
15
  end
39
16
 
40
- unless Dir.exist?(pgdir)
41
- system("tar -xf #{workdir}/postgres.tar.gz") || fail('ERROR')
42
- system("mv #{workdir}/postgresql-#{PG_VERSION} #{pgdir}") || fail('ERROR')
43
-
44
- # Apply patches
45
- Dir[File.join(File.absolute_path(File.dirname(__FILE__)), 'patches/*')].each do |patch|
46
- system("cd #{pgdir}; patch -p1 < #{patch}")
47
- end
48
- end
49
-
50
- # We always run the build process in case this was cached between build (e.g. on Heroku)
51
- system("cd #{pgdir}; CFLAGS=-fPIC ./configure -q --without-readline --without-zlib") || fail('ERROR')
52
- system("cd #{pgdir}; make -C src/backend lib-recursive") # Ensures headers are generated
53
- PG_OBJS.each do |directory, objs|
54
- system("cd #{pgdir}; make -C src/#{directory} #{objs.join(' ')}") || fail('ERROR')
17
+ unless Dir.exist?(libdir)
18
+ system("tar -xf #{workdir}/libpg_query.tar.gz") || fail('ERROR')
55
19
  end
56
20
 
57
- $objs = PG_OBJS.map { |directory, objs| objs.map { |obj| "#{pgdir}/src/#{directory}/#{obj}" } }.flatten
58
- $objs += %w(pg_query.o pg_query_parse.o pg_query_normalize.o pg_polyfills.o)
21
+ # Build libpg_query (and parts of PostgreSQL)
22
+ system("cd #{libdir}; make")
59
23
 
60
- $CFLAGS << " -I #{pgdir}/src/include"
24
+ $objs = ['pg_query_ruby.o']
61
25
 
62
- # Similar to those used by PostgreSQL
63
- $CFLAGS << ' -O2 -Wall -Wmissing-prototypes -Wpointer-arith -Wdeclaration-after-statement -Wendif-labels -Wmissing-format-attribute -Wformat-security -fno-strict-aliasing -fwrapv'
26
+ $LOCAL_LIBS << '-lpg_query'
27
+ $LIBPATH << libdir
28
+ $CFLAGS << " -I #{libdir} -O2 -Wall -Wmissing-prototypes -Wpointer-arith -Wdeclaration-after-statement -Wendif-labels -Wmissing-format-attribute -Wformat-security -fno-strict-aliasing -fwrapv"
64
29
 
65
- SYMFILE = File.join(File.dirname(__FILE__), 'pg_query.sym')
30
+ SYMFILE = File.join(File.dirname(__FILE__), 'pg_query_ruby.sym')
66
31
  if RUBY_PLATFORM =~ /darwin/
67
32
  $DLDFLAGS << " -Wl,-exported_symbols_list #{SYMFILE}" unless defined?(::Rubinius)
68
33
  else
data/ext/pg_query/pg_query_ruby.c ADDED
@@ -0,0 +1,89 @@
1
+ #include "pg_query_ruby.h"
2
+
3
+ void raise_ruby_parse_error(PgQueryParseResult result);
4
+ void raise_ruby_normalize_error(PgQueryNormalizeResult result);
5
+ VALUE pg_query_ruby_parse(VALUE self, VALUE input);
6
+ VALUE pg_query_ruby_normalize(VALUE self, VALUE input);
7
+
8
+ void Init_pg_query(void)
9
+ {
10
+ VALUE cPgQuery;
11
+
12
+ pg_query_init();
13
+
14
+ cPgQuery = rb_const_get(rb_cObject, rb_intern("PgQuery"));
15
+
16
+ rb_define_singleton_method(cPgQuery, "_raw_parse", pg_query_ruby_parse, 1);
17
+ rb_define_singleton_method(cPgQuery, "normalize", pg_query_ruby_normalize, 1);
18
+ }
19
+
20
+ void raise_ruby_parse_error(PgQueryParseResult result)
21
+ {
22
+ VALUE cPgQuery, cParseError;
23
+ VALUE args[4];
24
+
25
+ cPgQuery = rb_const_get(rb_cObject, rb_intern("PgQuery"));
26
+ cParseError = rb_const_get_at(cPgQuery, rb_intern("ParseError"));
27
+
28
+ args[0] = rb_str_new2(result.error->message);
29
+ args[1] = rb_str_new2(result.error->filename);
30
+ args[2] = INT2NUM(result.error->lineno);
31
+ args[3] = INT2NUM(result.error->cursorpos);
32
+
33
+ pg_query_free_parse_result(result);
34
+
35
+ rb_exc_raise(rb_class_new_instance(4, args, cParseError));
36
+ }
37
+
38
+ void raise_ruby_normalize_error(PgQueryNormalizeResult result)
39
+ {
40
+ VALUE cPgQuery, cParseError;
41
+ VALUE args[4];
42
+
43
+ cPgQuery = rb_const_get(rb_cObject, rb_intern("PgQuery"));
44
+ cParseError = rb_const_get_at(cPgQuery, rb_intern("ParseError"));
45
+
46
+ args[0] = rb_str_new2(result.error->message);
47
+ args[1] = rb_str_new2(result.error->filename);
48
+ args[2] = INT2NUM(result.error->lineno);
49
+ args[3] = INT2NUM(result.error->cursorpos);
50
+
51
+ pg_query_free_normalize_result(result);
52
+
53
+ rb_exc_raise(rb_class_new_instance(4, args, cParseError));
54
+ }
55
+
56
+ VALUE pg_query_ruby_parse(VALUE self, VALUE input)
57
+ {
58
+ Check_Type(input, T_STRING);
59
+
60
+ VALUE output;
61
+ PgQueryParseResult result = pg_query_parse(StringValueCStr(input));
62
+
63
+ if (result.error) raise_ruby_parse_error(result);
64
+
65
+ output = rb_ary_new();
66
+
67
+ rb_ary_push(output, rb_str_new2(result.parse_tree));
68
+ rb_ary_push(output, rb_str_new2(result.stderr_buffer));
69
+
70
+ pg_query_free_parse_result(result);
71
+
72
+ return output;
73
+ }
74
+
75
+ VALUE pg_query_ruby_normalize(VALUE self, VALUE input)
76
+ {
77
+ Check_Type(input, T_STRING);
78
+
79
+ VALUE output;
80
+ PgQueryNormalizeResult result = pg_query_normalize(StringValueCStr(input));
81
+
82
+ if (result.error) raise_ruby_normalize_error(result);
83
+
84
+ output = rb_str_new2(result.normalized_query);
85
+
86
+ pg_query_free_normalize_result(result);
87
+
88
+ return output;
89
+ }
data/ext/pg_query/pg_query_ruby.h ADDED
@@ -0,0 +1,10 @@
1
+ #ifndef PG_QUERY_RUBY_H
2
+ #define PG_QUERY_RUBY_H
3
+
4
+ #include "pg_query.h"
5
+
6
+ #include <ruby.h>
7
+
8
+ void Init_pg_query(void);
9
+
10
+ #endif
data/lib/pg_query/version.rb CHANGED
@@ -1,3 +1,3 @@
1
1
  class PgQuery
2
- VERSION = '0.7.0'
2
+ VERSION = '0.7.1'
3
3
  end
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: pg_query
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.7.0
4
+ version: 0.7.1
5
5
  platform: ruby
6
6
  authors:
7
7
  - Lukas Fittl
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2015-10-18 00:00:00.000000000 Z
11
+ date: 2015-11-17 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: rake-compiler
@@ -94,15 +94,9 @@ files:
94
94
  - README.md
95
95
  - Rakefile
96
96
  - ext/pg_query/extconf.rb
97
- - ext/pg_query/patches/01_output_nodes_as_json.patch
98
- - ext/pg_query/patches/02_parse_replacement_char.patch
99
- - ext/pg_query/patches/03_regenerate_bison_flex_files.patch
100
- - ext/pg_query/pg_polyfills.c
101
- - ext/pg_query/pg_query.c
102
- - ext/pg_query/pg_query.h
103
- - ext/pg_query/pg_query.sym
104
- - ext/pg_query/pg_query_normalize.c
105
- - ext/pg_query/pg_query_parse.c
97
+ - ext/pg_query/pg_query_ruby.c
98
+ - ext/pg_query/pg_query_ruby.h
99
+ - ext/pg_query/pg_query_ruby.sym
106
100
  - lib/pg_query.rb
107
101
  - lib/pg_query/deparse.rb
108
102
  - lib/pg_query/deparse/alter_table.rb
data/ext/pg_query/patches/01_output_nodes_as_json.patch DELETED
@@ -1,4626 +0,0 @@
1
- diff --git a/src/backend/nodes/Makefile b/src/backend/nodes/Makefile
2
- index fe2e460..df2b494 100644
3
- --- a/src/backend/nodes/Makefile
4
- +++ b/src/backend/nodes/Makefile
5
- @@ -14,6 +14,8 @@ include $(top_builddir)/src/Makefile.global
6
-
7
- OBJS = nodeFuncs.o nodes.o list.o bitmapset.o tidbitmap.o \
8
- copyfuncs.o equalfuncs.o makefuncs.o \
9
- - outfuncs.o readfuncs.o print.o read.o params.o value.o
10
- + outfuncs.o outfuncs_json.o readfuncs.o print.o read.o params.o value.o
11
- +
12
- +outfuncs_json.o: outfuncs_shared_conds.c outfuncs_shared_defs.c
13
-
14
- include $(top_srcdir)/src/backend/common.mk
15
- diff --git a/src/backend/nodes/outfuncs_json.c b/src/backend/nodes/outfuncs_json.c
16
- new file mode 100644
17
- index 0000000..eaded0f
18
- --- /dev/null
19
- +++ b/src/backend/nodes/outfuncs_json.c
20
- @@ -0,0 +1,1035 @@
21
- +/*-------------------------------------------------------------------------
22
- + *
23
- + * outfuncs_json.c
24
- + * JSON Output functions for Postgres tree nodes.
25
- + *
26
- + * Portions Copyright (c) 1996-2014, PostgreSQL Global Development Group
27
- + * Portions Copyright (c) 1994, Regents of the University of California
28
- + *
29
- + *
30
- + * IDENTIFICATION
31
- + * src/backend/nodes/outfuncs_json.c
32
- + *
33
- + * NOTES
34
- + * This is a copy of outfuncs.c modified to output JSON.
35
- + *
36
- + * The focus of this is to make parse trees available to external tools,
37
- + * it is not used internally right now.
38
- + *
39
- + *-------------------------------------------------------------------------
40
- + */
41
- +#include "postgres.h"
42
- +
43
- +#include <ctype.h>
44
- +
45
- +#include "lib/stringinfo.h"
46
- +#include "nodes/plannodes.h"
47
- +#include "nodes/relation.h"
48
- +#include "utils/datum.h"
49
- +
50
- +
51
- +/*
52
- + * Macros to simplify output of different kinds of fields. Use these
53
- + * wherever possible to reduce the chance for silly typos. Note that these
54
- + * hard-wire conventions about the names of the local variables in an Out
55
- + * routine.
56
- + */
57
- +
58
- +/* Write the label for the node type */
59
- +#define WRITE_NODE_TYPE(nodelabel) \
60
- + appendStringInfoString(str, "\"" nodelabel "\": {")
61
- +
62
- +/* Write an integer field (anything written as ":fldname %d") */
63
- +#define WRITE_INT_FIELD(fldname) \
64
- + appendStringInfo(str, "\"" CppAsString(fldname) "\": %d, ", node->fldname)
65
- +
66
- +/* Write an unsigned integer field (anything written as ":fldname %u") */
67
- +#define WRITE_UINT_FIELD(fldname) \
68
- + appendStringInfo(str, "\"" CppAsString(fldname) "\": %u, ", node->fldname)
69
- +
70
- +/* Write an OID field (don't hard-wire assumption that OID is same as uint) */
71
- +#define WRITE_OID_FIELD(fldname) \
72
- + appendStringInfo(str, "\"" CppAsString(fldname) "\": %u, ", node->fldname)
73
- +
74
- +/* Write a long-integer field */
75
- +#define WRITE_LONG_FIELD(fldname) \
76
- + appendStringInfo(str, "\"" CppAsString(fldname) "\": %ld, ", node->fldname)
77
- +
78
- +/* Write a char field (ie, one ascii character) */
79
- +#define WRITE_CHAR_FIELD(fldname) \
80
- + if (node->fldname == 0) { appendStringInfo(str, "\"" CppAsString(fldname) "\": null, "); \
81
- + } else { appendStringInfo(str, "\"" CppAsString(fldname) "\": \"%c\", ", node->fldname); }
82
- +
83
- +/* Write an enumerated-type field as an integer code */
84
- +#define WRITE_ENUM_FIELD(fldname, enumtype) \
85
- + appendStringInfo(str, "\"" CppAsString(fldname) "\": %d, ", \
86
- + (int) node->fldname)
87
- +
88
- +/* Write a float field --- caller must give format to define precision */
89
- +#define WRITE_FLOAT_FIELD(fldname,format) \
90
- + appendStringInfo(str, "\"" CppAsString(fldname) "\": " format ", ", node->fldname)
91
- +
92
- +/* Write a boolean field */
93
- +#define WRITE_BOOL_FIELD(fldname) \
94
- + appendStringInfo(str, "\"" CppAsString(fldname) "\": %s, ", \
95
- + booltostr(node->fldname))
96
- +
97
- +/* Write a character-string (possibly NULL) field */
98
- +#define WRITE_STRING_FIELD(fldname) \
99
- + (appendStringInfo(str, "\"" CppAsString(fldname) "\": "), \
100
- + _outToken(str, node->fldname), \
101
- + appendStringInfo(str, ", "))
102
- +
103
- +/* Write a parse location field (actually same as INT case) */
104
- +#define WRITE_LOCATION_FIELD(fldname) \
105
- + appendStringInfo(str, "\"" CppAsString(fldname) "\": %d, ", node->fldname)
106
- +
107
- +/* Write a Node field */
108
- +#define WRITE_NODE_FIELD(fldname) \
109
- + (appendStringInfo(str, "\"" CppAsString(fldname) "\": "), \
110
- + _outNode(str, node->fldname), \
111
- + appendStringInfo(str, ", "))
112
- +
113
- +/* Write a bitmapset field */
114
- +#define WRITE_BITMAPSET_FIELD(fldname) \
115
- + (appendStringInfo(str, "\"" CppAsString(fldname) "\": "), \
116
- + _outBitmapset(str, node->fldname), \
117
- + appendStringInfo(str, ", "))
118
- +
119
- +
120
- +#define booltostr(x) ((x) ? "true" : "false")
121
- +
122
- +static void _outNode(StringInfo str, const void *obj);
123
- +
124
- +static void
125
- +removeTrailingDelimiter(StringInfo str)
126
- +{
127
- + if (str->len >= 2 && str->data[str->len - 2] == ',' && str->data[str->len - 1] == ' ') {
128
- + str->len -= 2;
129
- + str->data[str->len] = '\0';
130
- + }
131
- +}
132
- +
133
- +/*
134
- + * _outToken
135
- + * Convert an ordinary string (eg, an identifier) into a form that
136
- + * will be decoded back to a plain token by read.c's functions.
137
- + *
138
- + * If a null or empty string is given, it is encoded as "<>".
139
- + */
140
- +static void
141
- +_outToken(StringInfo str, const char *s)
142
- +{
143
- + if (s == NULL || *s == '\0')
144
- + {
145
- + appendStringInfoString(str, "null");
146
- + return;
147
- + }
148
- +
149
- + appendStringInfoChar(str, '"');
150
- + while (*s)
151
- + {
152
- + /* These chars must be backslashed anywhere in the string */
153
- + if (*s == '\n')
154
- + appendStringInfoString(str, "\\n");
155
- + else if (*s == '\r')
156
- + appendStringInfoString(str, "\\r");
157
- + else if (*s == '\t')
158
- + appendStringInfoString(str, "\\t");
159
- + else if (*s == '\\' || *s == '"') {
160
- + appendStringInfoChar(str, '\\');
161
- + appendStringInfoChar(str, *s);
162
- + } else
163
- + appendStringInfoChar(str, *s);
164
- + s++;
165
- + }
166
- + appendStringInfoChar(str, '"');
167
- +}
168
- +
169
- +static void
170
- +_outList(StringInfo str, const List *node)
171
- +{
172
- + const ListCell *lc;
173
- +
174
- + appendStringInfoChar(str, '[');
175
- +
176
- + /*if (IsA(node, IntList))
177
- + appendStringInfoChar(str, 'i');
178
- + else if (IsA(node, OidList))
179
- + appendStringInfoChar(str, 'o');*/
180
- +
181
- + foreach(lc, node)
182
- + {
183
- + /*
184
- + * For the sake of backward compatibility, we emit a slightly
185
- + * different whitespace format for lists of nodes vs. other types of
186
- + * lists. XXX: is this necessary?
187
- + */
188
- + if (IsA(node, List))
189
- + _outNode(str, lfirst(lc));
190
- + else if (IsA(node, IntList))
191
- + appendStringInfo(str, " %d", lfirst_int(lc));
192
- + else if (IsA(node, OidList))
193
- + appendStringInfo(str, " %u", lfirst_oid(lc));
194
- + else
195
- + elog(ERROR, "unrecognized list node type: %d",
196
- + (int) node->type);
197
- +
198
- + if (lnext(lc))
199
- + appendStringInfoString(str, ", ");
200
- + }
201
- +
202
- + appendStringInfoChar(str, ']');
203
- +}
204
- +
205
- +/*
206
- + * _outBitmapset -
207
- + * converts a bitmap set of integers
208
- + *
209
- + * Note: the output format is "(b int int ...)", similar to an integer List.
210
- + */
211
- +static void
212
- +_outBitmapset(StringInfo str, const Bitmapset *bms)
213
- +{
214
- + Bitmapset *tmpset;
215
- + int x;
216
- +
217
- + appendStringInfoChar(str, '[');
218
- + /*appendStringInfoChar(str, 'b');*/
219
- + tmpset = bms_copy(bms);
220
- + while ((x = bms_first_member(tmpset)) >= 0)
221
- + appendStringInfo(str, "%d, ", x);
222
- + bms_free(tmpset);
223
- + removeTrailingDelimiter(str);
224
- + appendStringInfoChar(str, ']');
225
- +}
226
- +
227
- +/*
228
- + * Print the value of a Datum given its type.
229
- + */
230
- +static void
231
- +_outDatum(StringInfo str, Datum value, int typlen, bool typbyval)
232
- +{
233
- + Size length,
234
- + i;
235
- + char *s;
236
- +
237
- + length = datumGetSize(value, typbyval, typlen);
238
- +
239
- + if (typbyval)
240
- + {
241
- + s = (char *) (&value);
242
- + /*appendStringInfo(str, "%u [ ", (unsigned int) length);*/
243
- + appendStringInfoChar(str, '[');
244
- + for (i = 0; i < (Size) sizeof(Datum); i++)
245
- + appendStringInfo(str, "%d, ", (int) (s[i]));
246
- + removeTrailingDelimiter(str);
247
- + appendStringInfoChar(str, ']');
248
- + }
249
- + else
250
- + {
251
- + s = (char *) DatumGetPointer(value);
252
- + if (!PointerIsValid(s))
253
- + appendStringInfoString(str, "[]");
254
- + else
255
- + {
256
- + /*appendStringInfo(str, "%u [ ", (unsigned int) length);*/
257
- + appendStringInfoChar(str, '[');
258
- + for (i = 0; i < length; i++)
259
- + appendStringInfo(str, "%d, ", (int) (s[i]));
260
- + removeTrailingDelimiter(str);
261
- + appendStringInfoChar(str, ']');
262
- + }
263
- + }
264
- +}
265
- +
266
- +/*
267
- +* print the basic stuff of all nodes that inherit from Path
268
- +*
269
- +* Note we do NOT print the parent, else we'd be in infinite recursion.
270
- +* We can print the parent's relids for identification purposes, though.
271
- +* We also do not print the whole of param_info, since it's printed by
272
- +* _outRelOptInfo; it's sufficient and less cluttering to print just the
273
- +* required outer relids.
274
- +*/
275
- +static void
276
- +_outPathInfo(StringInfo str, const Path *node)
277
- +{
278
- + WRITE_ENUM_FIELD(pathtype, NodeTag);
279
- + appendStringInfoString(str, "\"parent_relids\": ");
280
- + _outBitmapset(str, node->parent->relids);
281
- + appendStringInfoString(str, ", ");
282
- + appendStringInfoString(str, "\"required_outer\": ");
283
- + if (node->param_info)
284
- + _outBitmapset(str, node->param_info->ppi_req_outer);
285
- + else
286
- + _outBitmapset(str, NULL);
287
- + appendStringInfoString(str, ", ");
288
- + WRITE_FLOAT_FIELD(rows, "%.0f");
289
- + WRITE_FLOAT_FIELD(startup_cost, "%.2f");
290
- + WRITE_FLOAT_FIELD(total_cost, "%.2f");
291
- + WRITE_NODE_FIELD(pathkeys);
292
- +}
293
- +
294
- +#include "outfuncs_shared_defs.c"
295
- +
296
- +/*
297
- + * Stuff from plannodes.h
298
- + */
299
- +
300
- +static void
301
- +_outMergeAppend(StringInfo str, const MergeAppend *node)
302
- +{
303
- + int i;
304
- +
305
- + WRITE_NODE_TYPE("MERGEAPPEND");
306
- +
307
- + _outPlanInfo(str, (const Plan *) node);
308
- +
309
- + WRITE_NODE_FIELD(mergeplans);
310
- +
311
- + WRITE_INT_FIELD(numCols);
312
- +
313
- + appendStringInfoString(str, "\"sortColIdx\": [");
314
- + for (i = 0; i < node->numCols; i++)
315
- + appendStringInfo(str, "%d, ", node->sortColIdx[i]);
316
- + removeTrailingDelimiter(str);
317
- + appendStringInfoString(str, "], ");
318
- +
319
- + appendStringInfo(str, "\"sortOperators\": [");
320
- + for (i = 0; i < node->numCols; i++)
321
- + appendStringInfo(str, "%u, ", node->sortOperators[i]);
322
- + removeTrailingDelimiter(str);
323
- + appendStringInfoString(str, "], ");
324
- +
325
- + appendStringInfoString(str, "\"collations\": [");
326
- + for (i = 0; i < node->numCols; i++)
327
- + appendStringInfo(str, "%u, ", node->collations[i]);
328
- + removeTrailingDelimiter(str);
329
- + appendStringInfoString(str, "], ");
330
- +
331
- + appendStringInfoString(str, "\"nullsFirst\": [");
332
- + for (i = 0; i < node->numCols; i++)
333
- + appendStringInfo(str, "%s, ", booltostr(node->nullsFirst[i]));
334
- + removeTrailingDelimiter(str);
335
- + appendStringInfoString(str, "], ");
336
- +}
337
- +
338
- +static void
339
- +_outRecursiveUnion(StringInfo str, const RecursiveUnion *node)
340
- +{
341
- + int i;
342
- +
343
- + WRITE_NODE_TYPE("RECURSIVEUNION");
344
- +
345
- + _outPlanInfo(str, (const Plan *) node);
346
- +
347
- + WRITE_INT_FIELD(wtParam);
348
- + WRITE_INT_FIELD(numCols);
349
- +
350
- + appendStringInfoString(str, "\"dupColIdx\": [");
351
- + for (i = 0; i < node->numCols; i++)
352
- + appendStringInfo(str, "%d, ", node->dupColIdx[i]);
353
- + removeTrailingDelimiter(str);
354
- + appendStringInfoString(str, "], ");
355
- +
356
- + appendStringInfoString(str, "\"dupOperators\": [");
357
- + for (i = 0; i < node->numCols; i++)
358
- + appendStringInfo(str, "%u, ", node->dupOperators[i]);
359
- + removeTrailingDelimiter(str);
360
- + appendStringInfoString(str, "], ");
361
- +
362
- + WRITE_LONG_FIELD(numGroups);
363
- +}
364
- +
365
- +static void
366
- +_outMergeJoin(StringInfo str, const MergeJoin *node)
367
- +{
368
- + int numCols;
369
- + int i;
370
- +
371
- + WRITE_NODE_TYPE("MERGEJOIN");
372
- +
373
- + _outJoinInfo(str, (const Join *) node);
374
- +
375
- + WRITE_NODE_FIELD(mergeclauses);
376
- +
377
- + numCols = list_length(node->mergeclauses);
378
- +
379
- + appendStringInfoString(str, "\"mergeFamilies\": [");
380
- + for (i = 0; i < numCols; i++)
381
- + appendStringInfo(str, "%u, ", node->mergeFamilies[i]);
382
- + removeTrailingDelimiter(str);
383
- + appendStringInfoString(str, "], ");
384
- +
385
- + appendStringInfoString(str, "\"mergeCollations\": [");
386
- + for (i = 0; i < numCols; i++)
387
- + appendStringInfo(str, "%u, ", node->mergeCollations[i]);
388
- + removeTrailingDelimiter(str);
389
- + appendStringInfoString(str, "], ");
390
- +
391
- + appendStringInfoString(str, "\"mergeStrategies\": [");
392
- + for (i = 0; i < numCols; i++)
393
- + appendStringInfo(str, "%d, ", node->mergeStrategies[i]);
394
- + removeTrailingDelimiter(str);
395
- + appendStringInfoString(str, "], ");
396
- +
397
- + appendStringInfoString(str, "\"mergeNullsFirst\": [");
398
- + for (i = 0; i < numCols; i++)
399
- + appendStringInfo(str, "%d, ", (int) node->mergeNullsFirst[i]);
400
- + removeTrailingDelimiter(str);
401
- + appendStringInfoString(str, "], ");
402
- +}
403
- +
404
- +static void
405
- +_outAgg(StringInfo str, const Agg *node)
406
- +{
407
- + int i;
408
- +
409
- + WRITE_NODE_TYPE("AGG");
410
- +
411
- + _outPlanInfo(str, (const Plan *) node);
412
- +
413
- + WRITE_ENUM_FIELD(aggstrategy, AggStrategy);
414
- + WRITE_INT_FIELD(numCols);
415
- +
416
- + appendStringInfoString(str, "\"grpColIdx\": [");
417
- + for (i = 0; i < node->numCols; i++)
418
- + appendStringInfo(str, "%d, ", node->grpColIdx[i]);
419
- + removeTrailingDelimiter(str);
420
- + appendStringInfoString(str, "], ");
421
- +
422
- + appendStringInfoString(str, "\"grpOperators\": [");
423
- + for (i = 0; i < node->numCols; i++)
424
- + appendStringInfo(str, "%u, ", node->grpOperators[i]);
425
- + removeTrailingDelimiter(str);
426
- + appendStringInfoString(str, "], ");
427
- +
428
- + WRITE_LONG_FIELD(numGroups);
429
- +}
430
- +
431
- +static void
432
- +_outWindowAgg(StringInfo str, const WindowAgg *node)
433
- +{
434
- + int i;
435
- +
436
- + WRITE_NODE_TYPE("WINDOWAGG");
437
- +
438
- + _outPlanInfo(str, (const Plan *) node);
439
- +
440
- + WRITE_UINT_FIELD(winref);
441
- + WRITE_INT_FIELD(partNumCols);
442
- +
443
- + appendStringInfoString(str, "\"partColIdx\": [");
444
- + for (i = 0; i < node->partNumCols; i++)
445
- + appendStringInfo(str, "%d, ", node->partColIdx[i]);
446
- + removeTrailingDelimiter(str);
447
- + appendStringInfoString(str, "], ");
448
- +
449
- + appendStringInfoString(str, "\"partOperations\": [");
450
- + for (i = 0; i < node->partNumCols; i++)
451
- + appendStringInfo(str, "%u, ", node->partOperators[i]);
452
- + removeTrailingDelimiter(str);
453
- + appendStringInfoString(str, "], ");
454
- +
455
- + WRITE_INT_FIELD(ordNumCols);
456
- +
457
- + appendStringInfoString(str, "\"ordColIdx\": [");
458
- + for (i = 0; i < node->ordNumCols; i++)
459
- + appendStringInfo(str, "%d, ", node->ordColIdx[i]);
460
- + removeTrailingDelimiter(str);
461
- + appendStringInfoString(str, "], ");
462
- +
463
- + appendStringInfoString(str, "\"ordOperations\": [");
464
- + for (i = 0; i < node->ordNumCols; i++)
465
- + appendStringInfo(str, "%u, ", node->ordOperators[i]);
466
- + removeTrailingDelimiter(str);
467
- + appendStringInfoString(str, "], ");
468
- +
469
- + WRITE_INT_FIELD(frameOptions);
470
- + WRITE_NODE_FIELD(startOffset);
471
- + WRITE_NODE_FIELD(endOffset);
472
- +}
473
- +
474
- +static void
475
- +_outGroup(StringInfo str, const Group *node)
476
- +{
477
- + int i;
478
- +
479
- + WRITE_NODE_TYPE("GROUP");
480
- +
481
- + _outPlanInfo(str, (const Plan *) node);
482
- +
483
- + WRITE_INT_FIELD(numCols);
484
- +
485
- + appendStringInfoString(str, "\"grpColIdx\": [");
486
- + for (i = 0; i < node->numCols; i++)
487
- + appendStringInfo(str, "%d, ", node->grpColIdx[i]);
488
- + removeTrailingDelimiter(str);
489
- + appendStringInfoString(str, "], ");
490
- +
491
- + appendStringInfoString(str, "\"grpOperators\": [");
492
- + for (i = 0; i < node->numCols; i++)
493
- + appendStringInfo(str, "%u, ", node->grpOperators[i]);
494
- + removeTrailingDelimiter(str);
495
- + appendStringInfoString(str, "], ");
496
- +}
497
- +
498
- +static void
499
- +_outSort(StringInfo str, const Sort *node)
500
- +{
501
- + int i;
502
- +
503
- + WRITE_NODE_TYPE("SORT");
504
- +
505
- + _outPlanInfo(str, (const Plan *) node);
506
- +
507
- + WRITE_INT_FIELD(numCols);
508
- +
509
- + appendStringInfoString(str, "\"sortColIdx\": [");
510
- + for (i = 0; i < node->numCols; i++)
511
- + appendStringInfo(str, "%d, ", node->sortColIdx[i]);
512
- + removeTrailingDelimiter(str);
513
- + appendStringInfoString(str, "], ");
514
- +
515
- + appendStringInfoString(str, "\"sortOperators\": [");
516
- + for (i = 0; i < node->numCols; i++)
517
- + appendStringInfo(str, "%u, ", node->sortOperators[i]);
518
- + removeTrailingDelimiter(str);
519
- + appendStringInfoString(str, "], ");
520
- +
521
- + appendStringInfoString(str, "\"collations\": [");
522
- + for (i = 0; i < node->numCols; i++)
523
- + appendStringInfo(str, "%u, ", node->collations[i]);
524
- + removeTrailingDelimiter(str);
525
- + appendStringInfoString(str, "], ");
526
- +
527
- + appendStringInfoString(str, "\"nullsFirst\": [");
528
- + for (i = 0; i < node->numCols; i++)
529
- + appendStringInfo(str, "%s, ", booltostr(node->nullsFirst[i]));
530
- + removeTrailingDelimiter(str);
531
- + appendStringInfoString(str, "], ");
532
- +}
533
- +
534
- +static void
535
- +_outUnique(StringInfo str, const Unique *node)
536
- +{
537
- + int i;
538
- +
539
- + WRITE_NODE_TYPE("UNIQUE");
540
- +
541
- + _outPlanInfo(str, (const Plan *) node);
542
- +
543
- + WRITE_INT_FIELD(numCols);
544
- +
545
- + appendStringInfoString(str, "\"uniqColIdx\": [");
546
- + for (i = 0; i < node->numCols; i++)
547
- + appendStringInfo(str, "%d, ", node->uniqColIdx[i]);
548
- + removeTrailingDelimiter(str);
549
- + appendStringInfoString(str, "], ");
550
- +
551
- + appendStringInfoString(str, "\"uniqOperators\": [");
552
- + for (i = 0; i < node->numCols; i++)
553
- + appendStringInfo(str, "%u, ", node->uniqOperators[i]);
554
- + removeTrailingDelimiter(str);
555
- + appendStringInfoString(str, "], ");
556
- +}
557
- +
558
- +static void
559
- +_outSetOp(StringInfo str, const SetOp *node)
560
- +{
561
- + int i;
562
- +
563
- + WRITE_NODE_TYPE("SETOP");
564
- +
565
- + _outPlanInfo(str, (const Plan *) node);
566
- +
567
- + WRITE_ENUM_FIELD(cmd, SetOpCmd);
568
- + WRITE_ENUM_FIELD(strategy, SetOpStrategy);
569
- + WRITE_INT_FIELD(numCols);
570
- +
571
- + appendStringInfoString(str, "\"dupColIdx\": [");
572
- + for (i = 0; i < node->numCols; i++)
573
- + appendStringInfo(str, "%d, ", node->dupColIdx[i]);
574
- + removeTrailingDelimiter(str);
575
- + appendStringInfoString(str, "], ");
576
- +
577
- + appendStringInfoString(str, "\"dupOperators\": [");
578
- + for (i = 0; i < node->numCols; i++)
579
- + appendStringInfo(str, "%u, ", node->dupOperators[i]);
580
- + removeTrailingDelimiter(str);
581
- + appendStringInfoString(str, "], ");
582
- +
583
- + WRITE_INT_FIELD(flagColIdx);
584
- + WRITE_INT_FIELD(firstFlag);
585
- + WRITE_LONG_FIELD(numGroups);
586
- +}
587
- +
588
- +/*****************************************************************************
589
- + *
590
- + * Stuff from primnodes.h.
591
- + *
592
- + *****************************************************************************/
593
- +
594
- +static void
595
- +_outConst(StringInfo str, const Const *node)
596
- +{
597
- + WRITE_NODE_TYPE("CONST");
598
- +
599
- + WRITE_OID_FIELD(consttype);
600
- + WRITE_INT_FIELD(consttypmod);
601
- + WRITE_OID_FIELD(constcollid);
602
- + WRITE_INT_FIELD(constlen);
603
- + WRITE_BOOL_FIELD(constbyval);
604
- + WRITE_BOOL_FIELD(constisnull);
605
- + WRITE_LOCATION_FIELD(location);
606
- +
607
- + appendStringInfoString(str, "\"constvalue\": ");
608
- + if (node->constisnull)
609
- + appendStringInfoString(str, "null");
610
- + else
611
- + _outDatum(str, node->constvalue, node->constlen, node->constbyval);
612
- + appendStringInfoString(str, ", ");
613
- +}
614
- +
615
- +static void
616
- +_outBoolExpr(StringInfo str, const BoolExpr *node)
617
- +{
618
- + char *opstr = NULL;
619
- +
620
- + WRITE_NODE_TYPE("BOOLEXPR");
621
- +
622
- + /* do-it-yourself enum representation */
623
- + switch (node->boolop)
624
- + {
625
- + case AND_EXPR:
626
- + opstr = "and";
627
- + break;
628
- + case OR_EXPR:
629
- + opstr = "or";
630
- + break;
631
- + case NOT_EXPR:
632
- + opstr = "not";
633
- + break;
634
- + }
635
- + appendStringInfoString(str, "\"boolop\": ");
636
- + _outToken(str, opstr);
637
- + appendStringInfoString(str, ", ");
638
- +
639
- + WRITE_NODE_FIELD(args);
640
- + WRITE_LOCATION_FIELD(location);
641
- +}
642
- +
643
- +/*****************************************************************************
644
- + *
645
- + * Stuff from relation.h.
646
- + *
647
- + *****************************************************************************/
648
- +
649
- +static void
650
- +_outPath(StringInfo str, const Path *node)
651
- +{
652
- + WRITE_NODE_TYPE("PATH");
653
- +
654
- + _outPathInfo(str, (const Path *) node);
655
- +}
656
- +
657
- +static void
658
- +_outEquivalenceClass(StringInfo str, const EquivalenceClass *node)
659
- +{
660
- + /*
661
- + * To simplify reading, we just chase up to the topmost merged EC and
662
- + * print that, without bothering to show the merge-ees separately.
663
- + */
664
- + while (node->ec_merged)
665
- + node = node->ec_merged;
666
- +
667
- + WRITE_NODE_TYPE("EQUIVALENCECLASS");
668
- +
669
- + WRITE_NODE_FIELD(ec_opfamilies);
670
- + WRITE_OID_FIELD(ec_collation);
671
- + WRITE_NODE_FIELD(ec_members);
672
- + WRITE_NODE_FIELD(ec_sources);
673
- + WRITE_NODE_FIELD(ec_derives);
674
- + WRITE_BITMAPSET_FIELD(ec_relids);
675
- + WRITE_BOOL_FIELD(ec_has_const);
676
- + WRITE_BOOL_FIELD(ec_has_volatile);
677
- + WRITE_BOOL_FIELD(ec_below_outer_join);
678
- + WRITE_BOOL_FIELD(ec_broken);
679
- + WRITE_UINT_FIELD(ec_sortref);
680
- +}
681
- +
682
- +/*****************************************************************************
683
- + *
684
- + * Stuff from parsenodes.h.
685
- + *
686
- + *****************************************************************************/
687
- +
688
- +static void
689
- +_outRangeTblEntry(StringInfo str, const RangeTblEntry *node)
690
- +{
691
- + WRITE_NODE_TYPE("RTE");
692
- +
693
- + /* put alias + eref first to make dump more legible */
694
- + WRITE_NODE_FIELD(alias);
695
- + WRITE_NODE_FIELD(eref);
696
- + WRITE_ENUM_FIELD(rtekind, RTEKind);
697
- +
698
- + switch (node->rtekind)
699
- + {
700
- + case RTE_RELATION:
701
- + WRITE_OID_FIELD(relid);
702
- + WRITE_CHAR_FIELD(relkind);
703
- + break;
704
- + case RTE_SUBQUERY:
705
- + WRITE_NODE_FIELD(subquery);
706
- + WRITE_BOOL_FIELD(security_barrier);
707
- + break;
708
- + case RTE_JOIN:
709
- + WRITE_ENUM_FIELD(jointype, JoinType);
710
- + WRITE_NODE_FIELD(joinaliasvars);
711
- + break;
712
- + case RTE_FUNCTION:
713
- + WRITE_NODE_FIELD(functions);
714
- + WRITE_BOOL_FIELD(funcordinality);
715
- + break;
716
- + case RTE_VALUES:
717
- + WRITE_NODE_FIELD(values_lists);
718
- + WRITE_NODE_FIELD(values_collations);
719
- + break;
720
- + case RTE_CTE:
721
- + WRITE_STRING_FIELD(ctename);
722
- + WRITE_UINT_FIELD(ctelevelsup);
723
- + WRITE_BOOL_FIELD(self_reference);
724
- + WRITE_NODE_FIELD(ctecoltypes);
725
- + WRITE_NODE_FIELD(ctecoltypmods);
726
- + WRITE_NODE_FIELD(ctecolcollations);
727
- + break;
728
- + default:
729
- + elog(ERROR, "unrecognized RTE kind: %d", (int) node->rtekind);
730
- + break;
731
- + }
732
- +
733
- + WRITE_BOOL_FIELD(lateral);
734
- + WRITE_BOOL_FIELD(inh);
735
- + WRITE_BOOL_FIELD(inFromCl);
736
- + WRITE_UINT_FIELD(requiredPerms);
737
- + WRITE_OID_FIELD(checkAsUser);
738
- + WRITE_BITMAPSET_FIELD(selectedCols);
739
- + WRITE_BITMAPSET_FIELD(modifiedCols);
740
- + WRITE_NODE_FIELD(securityQuals);
741
- +}
742
- +
743
- +static void
744
- +_outAExpr(StringInfo str, const A_Expr *node)
745
- +{
746
- + switch (node->kind)
747
- + {
748
- + case AEXPR_OP:
749
- + WRITE_NODE_TYPE("AEXPR");
750
- + WRITE_NODE_FIELD(name);
751
- + break;
752
- + case AEXPR_AND:
753
- + WRITE_NODE_TYPE("AEXPR AND");
754
- + break;
755
- + case AEXPR_OR:
756
- + WRITE_NODE_TYPE("AEXPR OR");
757
- + break;
758
- + case AEXPR_NOT:
759
- + WRITE_NODE_TYPE("AEXPR NOT");
760
- + break;
761
- + case AEXPR_OP_ANY:
762
- + WRITE_NODE_TYPE("AEXPR ANY");
763
- + WRITE_NODE_FIELD(name);
764
- + break;
765
- + case AEXPR_OP_ALL:
766
- + WRITE_NODE_TYPE("AEXPR ALL");
767
- + WRITE_NODE_FIELD(name);
768
- + break;
769
- + case AEXPR_DISTINCT:
770
- + WRITE_NODE_TYPE("AEXPR DISTINCT");
771
- + WRITE_NODE_FIELD(name);
772
- + break;
773
- + case AEXPR_NULLIF:
774
- + WRITE_NODE_TYPE("AEXPR NULLIF");
775
- + WRITE_NODE_FIELD(name);
776
- + break;
777
- + case AEXPR_OF:
778
- + WRITE_NODE_TYPE("AEXPR OF");
779
- + WRITE_NODE_FIELD(name);
780
- + break;
781
- + case AEXPR_IN:
782
- + WRITE_NODE_TYPE("AEXPR IN");
783
- + WRITE_NODE_FIELD(name);
784
- + break;
785
- + default:
786
- + WRITE_NODE_TYPE("AEXPR ??");
787
- + break;
788
- + }
789
- +
790
- + WRITE_NODE_FIELD(lexpr);
791
- + WRITE_NODE_FIELD(rexpr);
792
- + WRITE_LOCATION_FIELD(location);
793
- +}
794
- +
795
- +static void
796
- +_outValue(StringInfo str, const Value *value)
797
- +{
798
- + switch (value->type)
799
- + {
800
- + case T_Integer:
801
- + appendStringInfo(str, "%ld", value->val.ival);
802
- + break;
803
- + case T_Float:
804
- +
805
- + /*
806
- + * We assume the value is a valid numeric literal and so does not
807
- + * need quoting.
808
- + */
809
- + if (strlen(value->val.str) > 0 && value->val.str[0] == '.')
810
- + appendStringInfoChar(str, '0');
811
- + appendStringInfoString(str, value->val.str);
812
- + if (strlen(value->val.str) > 0 && value->val.str[strlen(value->val.str) - 1] == '.')
813
- + appendStringInfoChar(str, '0');
814
- + break;
815
- + case T_String:
816
- + _outToken(str, value->val.str);
817
- + break;
818
- + case T_BitString:
819
- + /* internal representation already has leading 'b' */
820
- + appendStringInfoString(str, value->val.str);
821
- + break;
822
- + case T_Null:
823
- + /* this is seen only within A_Const, not in transformed trees */
824
- + appendStringInfoString(str, "null");
825
- + break;
826
- + default:
827
- + elog(ERROR, "unrecognized node type: %d", (int) value->type);
828
- + break;
829
- + }
830
- +}
831
- +
832
- +static void
833
- +_outAConst(StringInfo str, const A_Const *node)
834
- +{
835
- + WRITE_NODE_TYPE("A_CONST");
836
- +
837
- + appendStringInfoString(str, "\"val\": ");
838
- + _outValue(str, &(node->val));
839
- + appendStringInfoString(str, ", ");
840
- + WRITE_LOCATION_FIELD(location);
841
- +}
842
- +
843
- +static void
844
- +_outConstraint(StringInfo str, const Constraint *node)
845
- +{
846
- + WRITE_NODE_TYPE("CONSTRAINT");
847
- +
848
- + WRITE_STRING_FIELD(conname);
849
- + WRITE_BOOL_FIELD(deferrable);
850
- + WRITE_BOOL_FIELD(initdeferred);
851
- + WRITE_LOCATION_FIELD(location);
852
- +
853
- + switch (node->contype)
854
- + {
855
- + case CONSTR_NULL:
856
- + appendStringInfoString(str, "\"contype\": \"NULL\", ");
857
- + break;
858
- +
859
- + case CONSTR_NOTNULL:
860
- + appendStringInfoString(str, "\"contype\": \"NOT_NULL\", ");
861
- + break;
862
- +
863
- + case CONSTR_DEFAULT:
864
- + appendStringInfoString(str, "\"contype\": \"DEFAULT\", ");
865
- + WRITE_NODE_FIELD(raw_expr);
866
- + WRITE_STRING_FIELD(cooked_expr);
867
- + break;
868
- +
869
- + case CONSTR_CHECK:
870
- + appendStringInfoString(str, "\"contype\": \"CHECK\", ");
871
- + WRITE_BOOL_FIELD(is_no_inherit);
872
- + WRITE_NODE_FIELD(raw_expr);
873
- + WRITE_STRING_FIELD(cooked_expr);
874
- + break;
875
- +
876
- + case CONSTR_PRIMARY:
877
- + appendStringInfoString(str, "\"contype\": \"PRIMARY_KEY\", ");
878
- + WRITE_NODE_FIELD(keys);
879
- + WRITE_NODE_FIELD(options);
880
- + WRITE_STRING_FIELD(indexname);
881
- + WRITE_STRING_FIELD(indexspace);
882
- + /* access_method and where_clause not currently used */
883
- + break;
884
- +
885
- + case CONSTR_UNIQUE:
886
- + appendStringInfoString(str, "\"contype\": \"UNIQUE\", ");
887
- + WRITE_NODE_FIELD(keys);
888
- + WRITE_NODE_FIELD(options);
889
- + WRITE_STRING_FIELD(indexname);
890
- + WRITE_STRING_FIELD(indexspace);
891
- + /* access_method and where_clause not currently used */
892
- + break;
893
- +
894
- + case CONSTR_EXCLUSION:
895
- + appendStringInfoString(str, "\"contype\": \"EXCLUSION\", ");
896
- + WRITE_NODE_FIELD(exclusions);
897
- + WRITE_NODE_FIELD(options);
898
- + WRITE_STRING_FIELD(indexname);
899
- + WRITE_STRING_FIELD(indexspace);
900
- + WRITE_STRING_FIELD(access_method);
901
- + WRITE_NODE_FIELD(where_clause);
902
- + break;
903
- +
904
- + case CONSTR_FOREIGN:
905
- + appendStringInfoString(str, "\"contype\": \"FOREIGN_KEY\", ");
906
- + WRITE_NODE_FIELD(pktable);
907
- + WRITE_NODE_FIELD(fk_attrs);
908
- + WRITE_NODE_FIELD(pk_attrs);
909
- + WRITE_CHAR_FIELD(fk_matchtype);
910
- + WRITE_CHAR_FIELD(fk_upd_action);
911
- + WRITE_CHAR_FIELD(fk_del_action);
912
- + WRITE_NODE_FIELD(old_conpfeqop);
913
- + WRITE_OID_FIELD(old_pktable_oid);
914
- + WRITE_BOOL_FIELD(skip_validation);
915
- + WRITE_BOOL_FIELD(initially_valid);
916
- + break;
917
- +
918
- + case CONSTR_ATTR_DEFERRABLE:
919
- + appendStringInfoString(str, "\"contype\": \"ATTR_DEFERRABLE\", ");
920
- + break;
921
- +
922
- + case CONSTR_ATTR_NOT_DEFERRABLE:
923
- + appendStringInfoString(str, "\"contype\": \"ATTR_NOT_DEFERRABLE\", ");
924
- + break;
925
- +
926
- + case CONSTR_ATTR_DEFERRED:
927
- + appendStringInfoString(str, "\"contype\": \"ATTR_DEFERRED\", ");
928
- + break;
929
- +
930
- + case CONSTR_ATTR_IMMEDIATE:
931
- + appendStringInfoString(str, "\"contype\": \"ATTR_IMMEDIATE\", ");
932
- + break;
933
- +
934
- + default:
935
- + /*appendStringInfo(str, "<unrecognized_constraint %d>",
936
- + (int) node->contype);*/
937
- + appendStringInfoString(str, "\"contype\": null, ");
938
- + break;
939
- + }
940
- +}
941
- +
942
- +/*
943
- + * _outNode -
944
- + * converts a Node into ascii string and append it to 'str'
945
- + */
946
- +static void
947
- +_outNode(StringInfo str, const void *obj)
948
- +{
949
- + if (obj == NULL)
950
- + appendStringInfoString(str, "null");
951
- + else if (IsA(obj, List) ||IsA(obj, IntList) || IsA(obj, OidList))
952
- + _outList(str, obj);
953
- + else if (IsA(obj, Integer) ||
954
- + IsA(obj, Float) ||
955
- + IsA(obj, String) ||
956
- + IsA(obj, BitString))
957
- + {
958
- + /* nodeRead does not want to see { } around these! */
959
- + _outValue(str, obj);
960
- + }
961
- + else
962
- + {
963
- + appendStringInfoChar(str, '{');
964
- + switch (nodeTag(obj))
965
- + {
966
- + case T_MergeAppend:
967
- + _outMergeAppend(str, obj);
968
- + break;
969
- + case T_RecursiveUnion:
970
- + _outRecursiveUnion(str, obj);
971
- + break;
972
- + case T_MergeJoin:
973
- + _outMergeJoin(str, obj);
974
- + break;
975
- + case T_Agg:
976
- + _outAgg(str, obj);
977
- + break;
978
- + case T_WindowAgg:
979
- + _outWindowAgg(str, obj);
980
- + break;
981
- + case T_Group:
982
- + _outGroup(str, obj);
983
- + break;
984
- + case T_Sort:
985
- + _outSort(str, obj);
986
- + break;
987
- + case T_Unique:
988
- + _outUnique(str, obj);
989
- + break;
990
- + case T_SetOp:
991
- + _outSetOp(str, obj);
992
- + break;
993
- + case T_Const:
994
- + _outConst(str, obj);
995
- + break;
996
- + case T_BoolExpr:
997
- + _outBoolExpr(str, obj);
998
- + break;
999
- + case T_Path:
1000
- + _outPath(str, obj);
1001
- + break;
1002
- + case T_EquivalenceClass:
1003
- + _outEquivalenceClass(str, obj);
1004
- + break;
1005
- + case T_RangeTblEntry:
1006
- + _outRangeTblEntry(str, obj);
1007
- + break;
1008
- + case T_A_Expr:
1009
- + _outAExpr(str, obj);
1010
- + break;
1011
- + case T_A_Const:
1012
- + _outAConst(str, obj);
1013
- + break;
1014
- + case T_Constraint:
1015
- + _outConstraint(str, obj);
1016
- + break;
1017
- +
1018
- + #include "outfuncs_shared_conds.c"
1019
- +
1020
- + default:
1021
- +
1022
- + /*
1023
- + * This should be an ERROR, but it's too useful to be able to
1024
- + * dump structures that _outNode only understands part of.
1025
- + */
1026
- + elog(WARNING, "could not dump unrecognized node type: %d",
1027
- + (int) nodeTag(obj));
1028
- +
1029
- + appendStringInfo(str, "}");
1030
- + return;
1031
- + }
1032
- + removeTrailingDelimiter(str);
1033
- + appendStringInfo(str, "}}");
1034
- + }
1035
- +}
1036
- +
1037
- +/*
1038
- + * nodeToJSONString -
1039
- + * returns the JSON representation of the Node as a palloc'd string
1040
- + */
1041
- +char *
1042
- +nodeToJSONString(const void *obj)
1043
- +{
1044
- + StringInfoData str;
1045
- +
1046
- + /* see stringinfo.h for an explanation of this maneuver */
1047
- + initStringInfo(&str);
1048
- +
1049
- + if (obj == NULL) /* Make sure we generate valid JSON for empty queries */
1050
- + appendStringInfoString(&str, "[]");
1051
- + else
1052
- + _outNode(&str, obj);
1053
- +
1054
- + return str.data;
1055
- +}
1056
- diff --git a/src/backend/nodes/outfuncs_shared_conds.c b/src/backend/nodes/outfuncs_shared_conds.c
1057
- new file mode 100644
1058
- index 0000000..d502f84
1059
- --- /dev/null
1060
- +++ b/src/backend/nodes/outfuncs_shared_conds.c
1061
- @@ -0,0 +1,699 @@
1062
- +case T_Plan:
1063
- + _outPlan(str, obj);
1064
- + break;
1065
- +case T_Result:
1066
- + _outResult(str, obj);
1067
- + break;
1068
- +case T_ModifyTable:
1069
- + _outModifyTable(str, obj);
1070
- + break;
1071
- +case T_Append:
1072
- + _outAppend(str, obj);
1073
- + break;
1074
- +case T_BitmapAnd:
1075
- + _outBitmapAnd(str, obj);
1076
- + break;
1077
- +case T_BitmapOr:
1078
- + _outBitmapOr(str, obj);
1079
- + break;
1080
- +case T_Scan:
1081
- + _outScan(str, obj);
1082
- + break;
1083
- +case T_SeqScan:
1084
- + _outSeqScan(str, obj);
1085
- + break;
1086
- +case T_IndexScan:
1087
- + _outIndexScan(str, obj);
1088
- + break;
1089
- +case T_IndexOnlyScan:
1090
- + _outIndexOnlyScan(str, obj);
1091
- + break;
1092
- +case T_BitmapIndexScan:
1093
- + _outBitmapIndexScan(str, obj);
1094
- + break;
1095
- +case T_BitmapHeapScan:
1096
- + _outBitmapHeapScan(str, obj);
1097
- + break;
1098
- +case T_TidScan:
1099
- + _outTidScan(str, obj);
1100
- + break;
1101
- +case T_SubqueryScan:
1102
- + _outSubqueryScan(str, obj);
1103
- + break;
1104
- +case T_FunctionScan:
1105
- + _outFunctionScan(str, obj);
1106
- + break;
1107
- +case T_ValuesScan:
1108
- + _outValuesScan(str, obj);
1109
- + break;
1110
- +case T_CteScan:
1111
- + _outCteScan(str, obj);
1112
- + break;
1113
- +case T_WorkTableScan:
1114
- + _outWorkTableScan(str, obj);
1115
- + break;
1116
- +case T_ForeignScan:
1117
- + _outForeignScan(str, obj);
1118
- + break;
1119
- +case T_Join:
1120
- + _outJoin(str, obj);
1121
- + break;
1122
- +case T_NestLoop:
1123
- + _outNestLoop(str, obj);
1124
- + break;
1125
- +case T_HashJoin:
1126
- + _outHashJoin(str, obj);
1127
- + break;
1128
- +case T_Material:
1129
- + _outMaterial(str, obj);
1130
- + break;
1131
- +case T_Hash:
1132
- + _outHash(str, obj);
1133
- + break;
1134
- +case T_LockRows:
1135
- + _outLockRows(str, obj);
1136
- + break;
1137
- +case T_Limit:
1138
- + _outLimit(str, obj);
1139
- + break;
1140
- +case T_NestLoopParam:
1141
- + _outNestLoopParam(str, obj);
1142
- + break;
1143
- +case T_PlanRowMark:
1144
- + _outPlanRowMark(str, obj);
1145
- + break;
1146
- +case T_PlanInvalItem:
1147
- + _outPlanInvalItem(str, obj);
1148
- + break;
1149
- +case T_Alias:
1150
- + _outAlias(str, obj);
1151
- + break;
1152
- +case T_RangeVar:
1153
- + _outRangeVar(str, obj);
1154
- + break;
1155
- +case T_Var:
1156
- + _outVar(str, obj);
1157
- + break;
1158
- +case T_Param:
1159
- + _outParam(str, obj);
1160
- + break;
1161
- +case T_Aggref:
1162
- + _outAggref(str, obj);
1163
- + break;
1164
- +case T_WindowFunc:
1165
- + _outWindowFunc(str, obj);
1166
- + break;
1167
- +case T_ArrayRef:
1168
- + _outArrayRef(str, obj);
1169
- + break;
1170
- +case T_FuncExpr:
1171
- + _outFuncExpr(str, obj);
1172
- + break;
1173
- +case T_NamedArgExpr:
1174
- + _outNamedArgExpr(str, obj);
1175
- + break;
1176
- +case T_OpExpr:
1177
- + _outOpExpr(str, obj);
1178
- + break;
1179
- +case T_DistinctExpr:
1180
- + _outDistinctExpr(str, obj);
1181
- + break;
1182
- +case T_NullIfExpr:
1183
- + _outNullIfExpr(str, obj);
1184
- + break;
1185
- +case T_ScalarArrayOpExpr:
1186
- + _outScalarArrayOpExpr(str, obj);
1187
- + break;
1188
- +case T_SubLink:
1189
- + _outSubLink(str, obj);
1190
- + break;
1191
- +case T_SubPlan:
1192
- + _outSubPlan(str, obj);
1193
- + break;
1194
- +case T_AlternativeSubPlan:
1195
- + _outAlternativeSubPlan(str, obj);
1196
- + break;
1197
- +case T_FieldSelect:
1198
- + _outFieldSelect(str, obj);
1199
- + break;
1200
- +case T_FieldStore:
1201
- + _outFieldStore(str, obj);
1202
- + break;
1203
- +case T_RelabelType:
1204
- + _outRelabelType(str, obj);
1205
- + break;
1206
- +case T_CoerceViaIO:
1207
- + _outCoerceViaIO(str, obj);
1208
- + break;
1209
- +case T_ArrayCoerceExpr:
1210
- + _outArrayCoerceExpr(str, obj);
1211
- + break;
1212
- +case T_ConvertRowtypeExpr:
1213
- + _outConvertRowtypeExpr(str, obj);
1214
- + break;
1215
- +case T_CollateExpr:
1216
- + _outCollateExpr(str, obj);
1217
- + break;
1218
- +case T_CaseExpr:
1219
- + _outCaseExpr(str, obj);
1220
- + break;
1221
- +case T_CaseWhen:
1222
- + _outCaseWhen(str, obj);
1223
- + break;
1224
- +case T_CaseTestExpr:
1225
- + _outCaseTestExpr(str, obj);
1226
- + break;
1227
- +case T_ArrayExpr:
1228
- + _outArrayExpr(str, obj);
1229
- + break;
1230
- +case T_RowExpr:
1231
- + _outRowExpr(str, obj);
1232
- + break;
1233
- +case T_RowCompareExpr:
1234
- + _outRowCompareExpr(str, obj);
1235
- + break;
1236
- +case T_CoalesceExpr:
1237
- + _outCoalesceExpr(str, obj);
1238
- + break;
1239
- +case T_MinMaxExpr:
1240
- + _outMinMaxExpr(str, obj);
1241
- + break;
1242
- +case T_XmlExpr:
1243
- + _outXmlExpr(str, obj);
1244
- + break;
1245
- +case T_NullTest:
1246
- + _outNullTest(str, obj);
1247
- + break;
1248
- +case T_BooleanTest:
1249
- + _outBooleanTest(str, obj);
1250
- + break;
1251
- +case T_CoerceToDomain:
1252
- + _outCoerceToDomain(str, obj);
1253
- + break;
1254
- +case T_CoerceToDomainValue:
1255
- + _outCoerceToDomainValue(str, obj);
1256
- + break;
1257
- +case T_SetToDefault:
1258
- + _outSetToDefault(str, obj);
1259
- + break;
1260
- +case T_CurrentOfExpr:
1261
- + _outCurrentOfExpr(str, obj);
1262
- + break;
1263
- +case T_TargetEntry:
1264
- + _outTargetEntry(str, obj);
1265
- + break;
1266
- +case T_RangeTblRef:
1267
- + _outRangeTblRef(str, obj);
1268
- + break;
1269
- +case T_JoinExpr:
1270
- + _outJoinExpr(str, obj);
1271
- + break;
1272
- +case T_FromExpr:
1273
- + _outFromExpr(str, obj);
1274
- + break;
1275
- +case T_IntoClause:
1276
- + _outIntoClause(str, obj);
1277
- + break;
1278
- +case T_PlannerInfo:
1279
- + _outPlannerInfo(str, obj);
1280
- + break;
1281
- +case T_PlannerGlobal:
1282
- + _outPlannerGlobal(str, obj);
1283
- + break;
1284
- +case T_RelOptInfo:
1285
- + _outRelOptInfo(str, obj);
1286
- + break;
1287
- +case T_IndexOptInfo:
1288
- + _outIndexOptInfo(str, obj);
1289
- + break;
1290
- +case T_ParamPathInfo:
1291
- + _outParamPathInfo(str, obj);
1292
- + break;
1293
- +case T_IndexPath:
1294
- + _outIndexPath(str, obj);
1295
- + break;
1296
- +case T_BitmapHeapPath:
1297
- + _outBitmapHeapPath(str, obj);
1298
- + break;
1299
- +case T_BitmapAndPath:
1300
- + _outBitmapAndPath(str, obj);
1301
- + break;
1302
- +case T_BitmapOrPath:
1303
- + _outBitmapOrPath(str, obj);
1304
- + break;
1305
- +case T_NestPath:
1306
- + _outNestPath(str, obj);
1307
- + break;
1308
- +case T_MergePath:
1309
- + _outMergePath(str, obj);
1310
- + break;
1311
- +case T_HashPath:
1312
- + _outHashPath(str, obj);
1313
- + break;
1314
- +case T_TidPath:
1315
- + _outTidPath(str, obj);
1316
- + break;
1317
- +case T_ForeignPath:
1318
- + _outForeignPath(str, obj);
1319
- + break;
1320
- +case T_AppendPath:
1321
- + _outAppendPath(str, obj);
1322
- + break;
1323
- +case T_MergeAppendPath:
1324
- + _outMergeAppendPath(str, obj);
1325
- + break;
1326
- +case T_ResultPath:
1327
- + _outResultPath(str, obj);
1328
- + break;
1329
- +case T_MaterialPath:
1330
- + _outMaterialPath(str, obj);
1331
- + break;
1332
- +case T_UniquePath:
1333
- + _outUniquePath(str, obj);
1334
- + break;
1335
- +case T_EquivalenceMember:
1336
- + _outEquivalenceMember(str, obj);
1337
- + break;
1338
- +case T_PathKey:
1339
- + _outPathKey(str, obj);
1340
- + break;
1341
- +case T_RestrictInfo:
1342
- + _outRestrictInfo(str, obj);
1343
- + break;
1344
- +case T_PlaceHolderVar:
1345
- + _outPlaceHolderVar(str, obj);
1346
- + break;
1347
- +case T_SpecialJoinInfo:
1348
- + _outSpecialJoinInfo(str, obj);
1349
- + break;
1350
- +case T_LateralJoinInfo:
1351
- + _outLateralJoinInfo(str, obj);
1352
- + break;
1353
- +case T_AppendRelInfo:
1354
- + _outAppendRelInfo(str, obj);
1355
- + break;
1356
- +case T_PlaceHolderInfo:
1357
- + _outPlaceHolderInfo(str, obj);
1358
- + break;
1359
- +case T_MinMaxAggInfo:
1360
- + _outMinMaxAggInfo(str, obj);
1361
- + break;
1362
- +case T_PlannerParamItem:
1363
- + _outPlannerParamItem(str, obj);
1364
- + break;
1365
- +case T_Query:
1366
- + _outQuery(str, obj);
1367
- + break;
1368
- +case T_PlannedStmt:
1369
- + _outPlannedStmt(str, obj);
1370
- + break;
1371
- +case T_InsertStmt:
1372
- + _outInsertStmt(str, obj);
1373
- + break;
1374
- +case T_DeleteStmt:
1375
- + _outDeleteStmt(str, obj);
1376
- + break;
1377
- +case T_UpdateStmt:
1378
- + _outUpdateStmt(str, obj);
1379
- + break;
1380
- +case T_SelectStmt:
1381
- + _outSelectStmt(str, obj);
1382
- + break;
1383
- +case T_AlterTableStmt:
1384
- + _outAlterTableStmt(str, obj);
1385
- + break;
1386
- +case T_AlterTableCmd:
1387
- + _outAlterTableCmd(str, obj);
1388
- + break;
1389
- +case T_AlterDomainStmt:
1390
- + _outAlterDomainStmt(str, obj);
1391
- + break;
1392
- +case T_SetOperationStmt:
1393
- + _outSetOperationStmt(str, obj);
1394
- + break;
1395
- +case T_GrantStmt:
1396
- + _outGrantStmt(str, obj);
1397
- + break;
1398
- +case T_GrantRoleStmt:
1399
- + _outGrantRoleStmt(str, obj);
1400
- + break;
1401
- +case T_AlterDefaultPrivilegesStmt:
1402
- + _outAlterDefaultPrivilegesStmt(str, obj);
1403
- + break;
1404
- +case T_ClosePortalStmt:
1405
- + _outClosePortalStmt(str, obj);
1406
- + break;
1407
- +case T_ClusterStmt:
1408
- + _outClusterStmt(str, obj);
1409
- + break;
1410
- +case T_CopyStmt:
1411
- + _outCopyStmt(str, obj);
1412
- + break;
1413
- +case T_CreateStmt:
1414
- + _outCreateStmt(str, obj);
1415
- + break;
1416
- +case T_DefineStmt:
1417
- + _outDefineStmt(str, obj);
1418
- + break;
1419
- +case T_DropStmt:
1420
- + _outDropStmt(str, obj);
1421
- + break;
1422
- +case T_TruncateStmt:
1423
- + _outTruncateStmt(str, obj);
1424
- + break;
1425
- +case T_CommentStmt:
1426
- + _outCommentStmt(str, obj);
1427
- + break;
1428
- +case T_FetchStmt:
1429
- + _outFetchStmt(str, obj);
1430
- + break;
1431
- +case T_IndexStmt:
1432
- + _outIndexStmt(str, obj);
1433
- + break;
1434
- +case T_CreateFunctionStmt:
1435
- + _outCreateFunctionStmt(str, obj);
1436
- + break;
1437
- +case T_AlterFunctionStmt:
1438
- + _outAlterFunctionStmt(str, obj);
1439
- + break;
1440
- +case T_DoStmt:
1441
- + _outDoStmt(str, obj);
1442
- + break;
1443
- +case T_RenameStmt:
1444
- + _outRenameStmt(str, obj);
1445
- + break;
1446
- +case T_RuleStmt:
1447
- + _outRuleStmt(str, obj);
1448
- + break;
1449
- +case T_NotifyStmt:
1450
- + _outNotifyStmt(str, obj);
1451
- + break;
1452
- +case T_ListenStmt:
1453
- + _outListenStmt(str, obj);
1454
- + break;
1455
- +case T_UnlistenStmt:
1456
- + _outUnlistenStmt(str, obj);
1457
- + break;
1458
- +case T_TransactionStmt:
1459
- + _outTransactionStmt(str, obj);
1460
- + break;
1461
- +case T_ViewStmt:
1462
- + _outViewStmt(str, obj);
1463
- + break;
1464
- +case T_LoadStmt:
1465
- + _outLoadStmt(str, obj);
1466
- + break;
1467
- +case T_CreateDomainStmt:
1468
- + _outCreateDomainStmt(str, obj);
1469
- + break;
1470
- +case T_CreatedbStmt:
1471
- + _outCreatedbStmt(str, obj);
1472
- + break;
1473
- +case T_DropdbStmt:
1474
- + _outDropdbStmt(str, obj);
1475
- + break;
1476
- +case T_VacuumStmt:
1477
- + _outVacuumStmt(str, obj);
1478
- + break;
1479
- +case T_ExplainStmt:
1480
- + _outExplainStmt(str, obj);
1481
- + break;
1482
- +case T_CreateTableAsStmt:
1483
- + _outCreateTableAsStmt(str, obj);
1484
- + break;
1485
- +case T_CreateSeqStmt:
1486
- + _outCreateSeqStmt(str, obj);
1487
- + break;
1488
- +case T_AlterSeqStmt:
1489
- + _outAlterSeqStmt(str, obj);
1490
- + break;
1491
- +case T_VariableSetStmt:
1492
- + _outVariableSetStmt(str, obj);
1493
- + break;
1494
- +case T_VariableShowStmt:
1495
- + _outVariableShowStmt(str, obj);
1496
- + break;
1497
- +case T_DiscardStmt:
1498
- + _outDiscardStmt(str, obj);
1499
- + break;
1500
- +case T_CreateTrigStmt:
1501
- + _outCreateTrigStmt(str, obj);
1502
- + break;
1503
- +case T_CreatePLangStmt:
1504
- + _outCreatePLangStmt(str, obj);
1505
- + break;
1506
- +case T_CreateRoleStmt:
1507
- + _outCreateRoleStmt(str, obj);
1508
- + break;
1509
- +case T_AlterRoleStmt:
1510
- + _outAlterRoleStmt(str, obj);
1511
- + break;
1512
- +case T_DropRoleStmt:
1513
- + _outDropRoleStmt(str, obj);
1514
- + break;
1515
- +case T_LockStmt:
1516
- + _outLockStmt(str, obj);
1517
- + break;
1518
- +case T_ConstraintsSetStmt:
1519
- + _outConstraintsSetStmt(str, obj);
1520
- + break;
1521
- +case T_ReindexStmt:
1522
- + _outReindexStmt(str, obj);
1523
- + break;
1524
- +case T_CheckPointStmt:
1525
- + _outCheckPointStmt(str, obj);
1526
- + break;
1527
- +case T_CreateSchemaStmt:
1528
- + _outCreateSchemaStmt(str, obj);
1529
- + break;
1530
- +case T_AlterDatabaseStmt:
1531
- + _outAlterDatabaseStmt(str, obj);
1532
- + break;
1533
- +case T_AlterDatabaseSetStmt:
1534
- + _outAlterDatabaseSetStmt(str, obj);
1535
- + break;
1536
- +case T_AlterRoleSetStmt:
1537
- + _outAlterRoleSetStmt(str, obj);
1538
- + break;
1539
- +case T_CreateConversionStmt:
1540
- + _outCreateConversionStmt(str, obj);
1541
- + break;
1542
- +case T_CreateCastStmt:
1543
- + _outCreateCastStmt(str, obj);
1544
- + break;
1545
- +case T_CreateOpClassStmt:
1546
- + _outCreateOpClassStmt(str, obj);
1547
- + break;
1548
- +case T_CreateOpFamilyStmt:
1549
- + _outCreateOpFamilyStmt(str, obj);
1550
- + break;
1551
- +case T_AlterOpFamilyStmt:
1552
- + _outAlterOpFamilyStmt(str, obj);
1553
- + break;
1554
- +case T_PrepareStmt:
1555
- + _outPrepareStmt(str, obj);
1556
- + break;
1557
- +case T_ExecuteStmt:
1558
- + _outExecuteStmt(str, obj);
1559
- + break;
1560
- +case T_DeallocateStmt:
1561
- + _outDeallocateStmt(str, obj);
1562
- + break;
1563
- +case T_DeclareCursorStmt:
1564
- + _outDeclareCursorStmt(str, obj);
1565
- + break;
1566
- +case T_CreateTableSpaceStmt:
1567
- + _outCreateTableSpaceStmt(str, obj);
1568
- + break;
1569
- +case T_DropTableSpaceStmt:
1570
- + _outDropTableSpaceStmt(str, obj);
1571
- + break;
1572
- +case T_AlterObjectSchemaStmt:
1573
- + _outAlterObjectSchemaStmt(str, obj);
1574
- + break;
1575
- +case T_AlterOwnerStmt:
1576
- + _outAlterOwnerStmt(str, obj);
1577
- + break;
1578
- +case T_DropOwnedStmt:
1579
- + _outDropOwnedStmt(str, obj);
1580
- + break;
1581
- +case T_ReassignOwnedStmt:
1582
- + _outReassignOwnedStmt(str, obj);
1583
- + break;
1584
- +case T_CompositeTypeStmt:
1585
- + _outCompositeTypeStmt(str, obj);
1586
- + break;
1587
- +case T_CreateEnumStmt:
1588
- + _outCreateEnumStmt(str, obj);
1589
- + break;
1590
- +case T_CreateRangeStmt:
1591
- + _outCreateRangeStmt(str, obj);
1592
- + break;
1593
- +case T_AlterEnumStmt:
1594
- + _outAlterEnumStmt(str, obj);
1595
- + break;
1596
- +case T_AlterTSDictionaryStmt:
1597
- + _outAlterTSDictionaryStmt(str, obj);
1598
- + break;
1599
- +case T_AlterTSConfigurationStmt:
1600
- + _outAlterTSConfigurationStmt(str, obj);
1601
- + break;
1602
- +case T_CreateFdwStmt:
1603
- + _outCreateFdwStmt(str, obj);
1604
- + break;
1605
- +case T_AlterFdwStmt:
1606
- + _outAlterFdwStmt(str, obj);
1607
- + break;
1608
- +case T_CreateForeignServerStmt:
1609
- + _outCreateForeignServerStmt(str, obj);
1610
- + break;
1611
- +case T_AlterForeignServerStmt:
1612
- + _outAlterForeignServerStmt(str, obj);
1613
- + break;
1614
- +case T_CreateUserMappingStmt:
1615
- + _outCreateUserMappingStmt(str, obj);
1616
- + break;
1617
- +case T_AlterUserMappingStmt:
1618
- + _outAlterUserMappingStmt(str, obj);
1619
- + break;
1620
- +case T_DropUserMappingStmt:
1621
- + _outDropUserMappingStmt(str, obj);
1622
- + break;
1623
- +case T_AlterTableSpaceOptionsStmt:
1624
- + _outAlterTableSpaceOptionsStmt(str, obj);
1625
- + break;
1626
- +case T_AlterTableMoveAllStmt:
1627
- + _outAlterTableMoveAllStmt(str, obj);
1628
- + break;
1629
- +case T_SecLabelStmt:
1630
- + _outSecLabelStmt(str, obj);
1631
- + break;
1632
- +case T_CreateForeignTableStmt:
1633
- + _outCreateForeignTableStmt(str, obj);
1634
- + break;
1635
- +case T_CreateExtensionStmt:
1636
- + _outCreateExtensionStmt(str, obj);
1637
- + break;
1638
- +case T_AlterExtensionStmt:
1639
- + _outAlterExtensionStmt(str, obj);
1640
- + break;
1641
- +case T_AlterExtensionContentsStmt:
1642
- + _outAlterExtensionContentsStmt(str, obj);
1643
- + break;
1644
- +case T_CreateEventTrigStmt:
1645
- + _outCreateEventTrigStmt(str, obj);
1646
- + break;
1647
- +case T_AlterEventTrigStmt:
1648
- + _outAlterEventTrigStmt(str, obj);
1649
- + break;
1650
- +case T_RefreshMatViewStmt:
1651
- + _outRefreshMatViewStmt(str, obj);
1652
- + break;
1653
- +case T_ReplicaIdentityStmt:
1654
- + _outReplicaIdentityStmt(str, obj);
1655
- + break;
1656
- +case T_AlterSystemStmt:
1657
- + _outAlterSystemStmt(str, obj);
1658
- + break;
1659
- +case T_ColumnRef:
1660
- + _outColumnRef(str, obj);
1661
- + break;
1662
- +case T_ParamRef:
1663
- + _outParamRef(str, obj);
1664
- + break;
1665
- +case T_FuncCall:
1666
- + _outFuncCall(str, obj);
1667
- + break;
1668
- +case T_A_Star:
1669
- + _outA_Star(str, obj);
1670
- + break;
1671
- +case T_A_Indices:
1672
- + _outA_Indices(str, obj);
1673
- + break;
1674
- +case T_A_Indirection:
1675
- + _outA_Indirection(str, obj);
1676
- + break;
1677
- +case T_A_ArrayExpr:
1678
- + _outA_ArrayExpr(str, obj);
1679
- + break;
1680
- +case T_ResTarget:
1681
- + _outResTarget(str, obj);
1682
- + break;
1683
- +case T_TypeCast:
1684
- + _outTypeCast(str, obj);
1685
- + break;
1686
- +case T_CollateClause:
1687
- + _outCollateClause(str, obj);
1688
- + break;
1689
- +case T_SortBy:
1690
- + _outSortBy(str, obj);
1691
- + break;
1692
- +case T_WindowDef:
1693
- + _outWindowDef(str, obj);
1694
- + break;
1695
- +case T_RangeSubselect:
1696
- + _outRangeSubselect(str, obj);
1697
- + break;
1698
- +case T_RangeFunction:
1699
- + _outRangeFunction(str, obj);
1700
- + break;
1701
- +case T_TypeName:
1702
- + _outTypeName(str, obj);
1703
- + break;
1704
- +case T_ColumnDef:
1705
- + _outColumnDef(str, obj);
1706
- + break;
1707
- +case T_IndexElem:
1708
- + _outIndexElem(str, obj);
1709
- + break;
1710
- +case T_DefElem:
1711
- + _outDefElem(str, obj);
1712
- + break;
1713
- +case T_RangeTblFunction:
1714
- + _outRangeTblFunction(str, obj);
1715
- + break;
1716
- +case T_WithCheckOption:
1717
- + _outWithCheckOption(str, obj);
1718
- + break;
1719
- +case T_SortGroupClause:
1720
- + _outSortGroupClause(str, obj);
1721
- + break;
1722
- +case T_WindowClause:
1723
- + _outWindowClause(str, obj);
1724
- + break;
1725
- +case T_PrivGrantee:
1726
- + _outPrivGrantee(str, obj);
1727
- + break;
1728
- +case T_FuncWithArgs:
1729
- + _outFuncWithArgs(str, obj);
1730
- + break;
1731
- +case T_AccessPriv:
1732
- + _outAccessPriv(str, obj);
1733
- + break;
1734
- +case T_CreateOpClassItem:
1735
- + _outCreateOpClassItem(str, obj);
1736
- + break;
1737
- +case T_TableLikeClause:
1738
- + _outTableLikeClause(str, obj);
1739
- + break;
1740
- +case T_FunctionParameter:
1741
- + _outFunctionParameter(str, obj);
1742
- + break;
1743
- +case T_LockingClause:
1744
- + _outLockingClause(str, obj);
1745
- + break;
1746
- +case T_RowMarkClause:
1747
- + _outRowMarkClause(str, obj);
1748
- + break;
1749
- +case T_XmlSerialize:
1750
- + _outXmlSerialize(str, obj);
1751
- + break;
1752
- +case T_WithClause:
1753
- + _outWithClause(str, obj);
1754
- + break;
1755
- +case T_CommonTableExpr:
1756
- + _outCommonTableExpr(str, obj);
1757
- + break;
1758
- +case T_InlineCodeBlock:
1759
- + _outInlineCodeBlock(str, obj);
1760
- + break;
1761
- diff --git a/src/backend/nodes/outfuncs_shared_defs.c b/src/backend/nodes/outfuncs_shared_defs.c
1762
- new file mode 100644
1763
- index 0000000..9645e69
1764
- --- /dev/null
1765
- +++ b/src/backend/nodes/outfuncs_shared_defs.c
1766
- @@ -0,0 +1,2844 @@
1767
- +static void
1768
- +_outPlanInfo(StringInfo str, const Plan *node)
1769
- +{
1770
- + WRITE_FLOAT_FIELD(startup_cost, "%.2f");
1771
- + WRITE_FLOAT_FIELD(total_cost, "%.2f");
1772
- + WRITE_FLOAT_FIELD(plan_rows, "%.0f");
1773
- + WRITE_INT_FIELD(plan_width);
1774
- + WRITE_NODE_FIELD(targetlist);
1775
- + WRITE_NODE_FIELD(qual);
1776
- + WRITE_NODE_FIELD(lefttree);
1777
- + WRITE_NODE_FIELD(righttree);
1778
- + WRITE_NODE_FIELD(initPlan);
1779
- + WRITE_BITMAPSET_FIELD(extParam);
1780
- + WRITE_BITMAPSET_FIELD(allParam);
1781
- +}
1782
- +
1783
- +static void
1784
- +_outScanInfo(StringInfo str, const Scan *node)
1785
- +{
1786
- + _outPlanInfo(str, (const Plan *) node);
1787
- +
1788
- + WRITE_UINT_FIELD(scanrelid);
1789
- +}
1790
- +
1791
- +static void
1792
- +_outJoinInfo(StringInfo str, const Join *node)
1793
- +{
1794
- + _outPlanInfo(str, (const Plan *) node);
1795
- +
1796
- + WRITE_ENUM_FIELD(jointype, JoinType);
1797
- + WRITE_NODE_FIELD(joinqual);
1798
- +}
1799
- +
1800
- +static void
1801
- +_outJoinPathInfo(StringInfo str, const JoinPath *node)
1802
- +{
1803
- + _outPathInfo(str, (const Path *) node);
1804
- +
1805
- + WRITE_ENUM_FIELD(jointype, JoinType);
1806
- + WRITE_NODE_FIELD(outerjoinpath);
1807
- + WRITE_NODE_FIELD(innerjoinpath);
1808
- + WRITE_NODE_FIELD(joinrestrictinfo);
1809
- +}
1810
- +
1811
- +static void
1812
- +_outCreateStmtInfo(StringInfo str, const CreateStmt *node)
1813
- +{
1814
- + WRITE_NODE_FIELD(relation);
1815
- + WRITE_NODE_FIELD(tableElts);
1816
- + WRITE_NODE_FIELD(inhRelations);
1817
- + WRITE_NODE_FIELD(ofTypename);
1818
- + WRITE_NODE_FIELD(constraints);
1819
- + WRITE_NODE_FIELD(options);
1820
- + WRITE_ENUM_FIELD(oncommit, OnCommitAction);
1821
- + WRITE_STRING_FIELD(tablespacename);
1822
- + WRITE_BOOL_FIELD(if_not_exists);
1823
- +}
1824
- +
1825
- +static void
1826
- +_outPlan(StringInfo str, const Plan *node)
1827
- +{
1828
- + WRITE_NODE_TYPE("PLAN");
1829
- +
1830
- + _outPlanInfo(str, (const Plan *) node);
1831
- +
1832
- +}
1833
- +
1834
- +static void
1835
- +_outResult(StringInfo str, const Result *node)
1836
- +{
1837
- + WRITE_NODE_TYPE("RESULT");
1838
- +
1839
- + _outPlanInfo(str, (const Plan *) node);
1840
- +
1841
- + WRITE_NODE_FIELD(resconstantqual);
1842
- +}
1843
- +
1844
- +static void
1845
- +_outModifyTable(StringInfo str, const ModifyTable *node)
1846
- +{
1847
- + WRITE_NODE_TYPE("MODIFYTABLE");
1848
- +
1849
- + _outPlanInfo(str, (const Plan *) node);
1850
- +
1851
- + WRITE_ENUM_FIELD(operation, CmdType);
1852
- + WRITE_BOOL_FIELD(canSetTag);
1853
- + WRITE_NODE_FIELD(resultRelations);
1854
- + WRITE_INT_FIELD(resultRelIndex);
1855
- + WRITE_NODE_FIELD(plans);
1856
- + WRITE_NODE_FIELD(withCheckOptionLists);
1857
- + WRITE_NODE_FIELD(returningLists);
1858
- + WRITE_NODE_FIELD(fdwPrivLists);
1859
- + WRITE_NODE_FIELD(rowMarks);
1860
- + WRITE_INT_FIELD(epqParam);
1861
- +}
1862
- +
1863
- +static void
1864
- +_outAppend(StringInfo str, const Append *node)
1865
- +{
1866
- + WRITE_NODE_TYPE("APPEND");
1867
- +
1868
- + _outPlanInfo(str, (const Plan *) node);
1869
- +
1870
- + WRITE_NODE_FIELD(appendplans);
1871
- +}
1872
- +
1873
- +static void
1874
- +_outBitmapAnd(StringInfo str, const BitmapAnd *node)
1875
- +{
1876
- + WRITE_NODE_TYPE("BITMAPAND");
1877
- +
1878
- + _outPlanInfo(str, (const Plan *) node);
1879
- +
1880
- + WRITE_NODE_FIELD(bitmapplans);
1881
- +}
1882
- +
1883
- +static void
1884
- +_outBitmapOr(StringInfo str, const BitmapOr *node)
1885
- +{
1886
- + WRITE_NODE_TYPE("BITMAPOR");
1887
- +
1888
- + _outPlanInfo(str, (const Plan *) node);
1889
- +
1890
- + WRITE_NODE_FIELD(bitmapplans);
1891
- +}
1892
- +
1893
- +static void
1894
- +_outScan(StringInfo str, const Scan *node)
1895
- +{
1896
- + WRITE_NODE_TYPE("SCAN");
1897
- +
1898
- + _outScanInfo(str, (const Scan *) node);
1899
- +
1900
- +}
1901
- +
1902
- +static void
1903
- +_outSeqScan(StringInfo str, const SeqScan *node)
1904
- +{
1905
- + WRITE_NODE_TYPE("SEQSCAN");
1906
- +
1907
- + _outScanInfo(str, (const Scan *) node);
1908
- +
1909
- +}
1910
- +
1911
- +static void
1912
- +_outIndexScan(StringInfo str, const IndexScan *node)
1913
- +{
1914
- + WRITE_NODE_TYPE("INDEXSCAN");
1915
- +
1916
- + _outScanInfo(str, (const Scan *) node);
1917
- +
1918
- + WRITE_OID_FIELD(indexid);
1919
- + WRITE_NODE_FIELD(indexqual);
1920
- + WRITE_NODE_FIELD(indexqualorig);
1921
- + WRITE_NODE_FIELD(indexorderby);
1922
- + WRITE_NODE_FIELD(indexorderbyorig);
1923
- + WRITE_ENUM_FIELD(indexorderdir, ScanDirection);
1924
- +}
1925
- +
1926
- +static void
1927
- +_outIndexOnlyScan(StringInfo str, const IndexOnlyScan *node)
1928
- +{
1929
- + WRITE_NODE_TYPE("INDEXONLYSCAN");
1930
- +
1931
- + _outScanInfo(str, (const Scan *) node);
1932
- +
1933
- + WRITE_OID_FIELD(indexid);
1934
- + WRITE_NODE_FIELD(indexqual);
1935
- + WRITE_NODE_FIELD(indexorderby);
1936
- + WRITE_NODE_FIELD(indextlist);
1937
- + WRITE_ENUM_FIELD(indexorderdir, ScanDirection);
1938
- +}
1939
- +
1940
- +static void
1941
- +_outBitmapIndexScan(StringInfo str, const BitmapIndexScan *node)
1942
- +{
1943
- + WRITE_NODE_TYPE("BITMAPINDEXSCAN");
1944
- +
1945
- + _outScanInfo(str, (const Scan *) node);
1946
- +
1947
- + WRITE_OID_FIELD(indexid);
1948
- + WRITE_NODE_FIELD(indexqual);
1949
- + WRITE_NODE_FIELD(indexqualorig);
1950
- +}
1951
- +
1952
- +static void
1953
- +_outBitmapHeapScan(StringInfo str, const BitmapHeapScan *node)
1954
- +{
1955
- + WRITE_NODE_TYPE("BITMAPHEAPSCAN");
1956
- +
1957
- + _outScanInfo(str, (const Scan *) node);
1958
- +
1959
- + WRITE_NODE_FIELD(bitmapqualorig);
1960
- +}
1961
- +
1962
- +static void
1963
- +_outTidScan(StringInfo str, const TidScan *node)
1964
- +{
1965
- + WRITE_NODE_TYPE("TIDSCAN");
1966
- +
1967
- + _outScanInfo(str, (const Scan *) node);
1968
- +
1969
- + WRITE_NODE_FIELD(tidquals);
1970
- +}
1971
- +
1972
- +static void
1973
- +_outSubqueryScan(StringInfo str, const SubqueryScan *node)
1974
- +{
1975
- + WRITE_NODE_TYPE("SUBQUERYSCAN");
1976
- +
1977
- + _outScanInfo(str, (const Scan *) node);
1978
- +
1979
- + WRITE_NODE_FIELD(subplan);
1980
- +}
1981
- +
1982
- +static void
1983
- +_outFunctionScan(StringInfo str, const FunctionScan *node)
1984
- +{
1985
- + WRITE_NODE_TYPE("FUNCTIONSCAN");
1986
- +
1987
- + _outScanInfo(str, (const Scan *) node);
1988
- +
1989
- + WRITE_NODE_FIELD(functions);
1990
- + WRITE_BOOL_FIELD(funcordinality);
1991
- +}
1992
- +
1993
- +static void
1994
- +_outValuesScan(StringInfo str, const ValuesScan *node)
1995
- +{
1996
- + WRITE_NODE_TYPE("VALUESSCAN");
1997
- +
1998
- + _outScanInfo(str, (const Scan *) node);
1999
- +
2000
- + WRITE_NODE_FIELD(values_lists);
2001
- +}
2002
- +
2003
- +static void
2004
- +_outCteScan(StringInfo str, const CteScan *node)
2005
- +{
2006
- + WRITE_NODE_TYPE("CTESCAN");
2007
- +
2008
- + _outScanInfo(str, (const Scan *) node);
2009
- +
2010
- + WRITE_INT_FIELD(ctePlanId);
2011
- + WRITE_INT_FIELD(cteParam);
2012
- +}
2013
- +
2014
- +static void
2015
- +_outWorkTableScan(StringInfo str, const WorkTableScan *node)
2016
- +{
2017
- + WRITE_NODE_TYPE("WORKTABLESCAN");
2018
- +
2019
- + _outScanInfo(str, (const Scan *) node);
2020
- +
2021
- + WRITE_INT_FIELD(wtParam);
2022
- +}
2023
- +
2024
- +static void
2025
- +_outForeignScan(StringInfo str, const ForeignScan *node)
2026
- +{
2027
- + WRITE_NODE_TYPE("FOREIGNSCAN");
2028
- +
2029
- + _outScanInfo(str, (const Scan *) node);
2030
- +
2031
- + WRITE_NODE_FIELD(fdw_exprs);
2032
- + WRITE_NODE_FIELD(fdw_private);
2033
- + WRITE_BOOL_FIELD(fsSystemCol);
2034
- +}
2035
- +
2036
- +static void
2037
- +_outJoin(StringInfo str, const Join *node)
2038
- +{
2039
- + WRITE_NODE_TYPE("JOIN");
2040
- +
2041
- + _outJoinInfo(str, (const Join *) node);
2042
- +
2043
- +}
2044
- +
2045
- +static void
2046
- +_outNestLoop(StringInfo str, const NestLoop *node)
2047
- +{
2048
- + WRITE_NODE_TYPE("NESTLOOP");
2049
- +
2050
- + _outJoinInfo(str, (const Join *) node);
2051
- +
2052
- + WRITE_NODE_FIELD(nestParams);
2053
- +}
2054
- +
2055
- +static void
2056
- +_outHashJoin(StringInfo str, const HashJoin *node)
2057
- +{
2058
- + WRITE_NODE_TYPE("HASHJOIN");
2059
- +
2060
- + _outJoinInfo(str, (const Join *) node);
2061
- +
2062
- + WRITE_NODE_FIELD(hashclauses);
2063
- +}
2064
- +
2065
- +static void
2066
- +_outMaterial(StringInfo str, const Material *node)
2067
- +{
2068
- + WRITE_NODE_TYPE("MATERIAL");
2069
- +
2070
- + _outPlanInfo(str, (const Plan *) node);
2071
- +
2072
- +}
2073
- +
2074
- +static void
2075
- +_outHash(StringInfo str, const Hash *node)
2076
- +{
2077
- + WRITE_NODE_TYPE("HASH");
2078
- +
2079
- + _outPlanInfo(str, (const Plan *) node);
2080
- +
2081
- + WRITE_OID_FIELD(skewTable);
2082
- + WRITE_INT_FIELD(skewColumn);
2083
- + WRITE_BOOL_FIELD(skewInherit);
2084
- + WRITE_OID_FIELD(skewColType);
2085
- + WRITE_INT_FIELD(skewColTypmod);
2086
- +}
2087
- +
2088
- +static void
2089
- +_outLockRows(StringInfo str, const LockRows *node)
2090
- +{
2091
- + WRITE_NODE_TYPE("LOCKROWS");
2092
- +
2093
- + _outPlanInfo(str, (const Plan *) node);
2094
- +
2095
- + WRITE_NODE_FIELD(rowMarks);
2096
- + WRITE_INT_FIELD(epqParam);
2097
- +}
2098
- +
2099
- +static void
2100
- +_outLimit(StringInfo str, const Limit *node)
2101
- +{
2102
- + WRITE_NODE_TYPE("LIMIT");
2103
- +
2104
- + _outPlanInfo(str, (const Plan *) node);
2105
- +
2106
- + WRITE_NODE_FIELD(limitOffset);
2107
- + WRITE_NODE_FIELD(limitCount);
2108
- +}
2109
- +
2110
- +static void
2111
- +_outNestLoopParam(StringInfo str, const NestLoopParam *node)
2112
- +{
2113
- + WRITE_NODE_TYPE("NESTLOOPPARAM");
2114
- +
2115
- + WRITE_INT_FIELD(paramno);
2116
- + WRITE_NODE_FIELD(paramval);
2117
- +}
2118
- +
2119
- +static void
2120
- +_outPlanRowMark(StringInfo str, const PlanRowMark *node)
2121
- +{
2122
- + WRITE_NODE_TYPE("PLANROWMARK");
2123
- +
2124
- + WRITE_UINT_FIELD(rti);
2125
- + WRITE_UINT_FIELD(prti);
2126
- + WRITE_UINT_FIELD(rowmarkId);
2127
- + WRITE_ENUM_FIELD(markType, RowMarkType);
2128
- + WRITE_BOOL_FIELD(noWait);
2129
- + WRITE_BOOL_FIELD(isParent);
2130
- +}
2131
- +
2132
- +static void
2133
- +_outPlanInvalItem(StringInfo str, const PlanInvalItem *node)
2134
- +{
2135
- + WRITE_NODE_TYPE("PLANINVALITEM");
2136
- +
2137
- + WRITE_INT_FIELD(cacheId);
2138
- + WRITE_UINT_FIELD(hashValue);
2139
- +}
2140
- +
2141
- +static void
2142
- +_outAlias(StringInfo str, const Alias *node)
2143
- +{
2144
- + WRITE_NODE_TYPE("ALIAS");
2145
- +
2146
- + WRITE_STRING_FIELD(aliasname);
2147
- + WRITE_NODE_FIELD(colnames);
2148
- +}
2149
- +
2150
- +static void
2151
- +_outRangeVar(StringInfo str, const RangeVar *node)
2152
- +{
2153
- + WRITE_NODE_TYPE("RANGEVAR");
2154
- +
2155
- + WRITE_STRING_FIELD(schemaname);
2156
- + WRITE_STRING_FIELD(relname);
2157
- + WRITE_ENUM_FIELD(inhOpt, InhOption);
2158
- + WRITE_CHAR_FIELD(relpersistence);
2159
- + WRITE_NODE_FIELD(alias);
2160
- + WRITE_LOCATION_FIELD(location);
2161
- +}
2162
- +
2163
- +static void
2164
- +_outVar(StringInfo str, const Var *node)
2165
- +{
2166
- + WRITE_NODE_TYPE("VAR");
2167
- +
2168
- + WRITE_UINT_FIELD(varno);
2169
- + WRITE_INT_FIELD(varattno);
2170
- + WRITE_OID_FIELD(vartype);
2171
- + WRITE_INT_FIELD(vartypmod);
2172
- + WRITE_OID_FIELD(varcollid);
2173
- + WRITE_UINT_FIELD(varlevelsup);
2174
- + WRITE_UINT_FIELD(varnoold);
2175
- + WRITE_INT_FIELD(varoattno);
2176
- + WRITE_LOCATION_FIELD(location);
2177
- +}
2178
- +
2179
- +static void
2180
- +_outParam(StringInfo str, const Param *node)
2181
- +{
2182
- + WRITE_NODE_TYPE("PARAM");
2183
- +
2184
- + WRITE_ENUM_FIELD(paramkind, ParamKind);
2185
- + WRITE_INT_FIELD(paramid);
2186
- + WRITE_OID_FIELD(paramtype);
2187
- + WRITE_INT_FIELD(paramtypmod);
2188
- + WRITE_OID_FIELD(paramcollid);
2189
- + WRITE_LOCATION_FIELD(location);
2190
- +}
2191
- +
2192
- +static void
2193
- +_outAggref(StringInfo str, const Aggref *node)
2194
- +{
2195
- + WRITE_NODE_TYPE("AGGREF");
2196
- +
2197
- + WRITE_OID_FIELD(aggfnoid);
2198
- + WRITE_OID_FIELD(aggtype);
2199
- + WRITE_OID_FIELD(aggcollid);
2200
- + WRITE_OID_FIELD(inputcollid);
2201
- + WRITE_NODE_FIELD(aggdirectargs);
2202
- + WRITE_NODE_FIELD(args);
2203
- + WRITE_NODE_FIELD(aggorder);
2204
- + WRITE_NODE_FIELD(aggdistinct);
2205
- + WRITE_NODE_FIELD(aggfilter);
2206
- + WRITE_BOOL_FIELD(aggstar);
2207
- + WRITE_BOOL_FIELD(aggvariadic);
2208
- + WRITE_CHAR_FIELD(aggkind);
2209
- + WRITE_UINT_FIELD(agglevelsup);
2210
- + WRITE_LOCATION_FIELD(location);
2211
- +}
2212
- +
2213
- +static void
2214
- +_outWindowFunc(StringInfo str, const WindowFunc *node)
2215
- +{
2216
- + WRITE_NODE_TYPE("WINDOWFUNC");
2217
- +
2218
- + WRITE_OID_FIELD(winfnoid);
2219
- + WRITE_OID_FIELD(wintype);
2220
- + WRITE_OID_FIELD(wincollid);
2221
- + WRITE_OID_FIELD(inputcollid);
2222
- + WRITE_NODE_FIELD(args);
2223
- + WRITE_NODE_FIELD(aggfilter);
2224
- + WRITE_UINT_FIELD(winref);
2225
- + WRITE_BOOL_FIELD(winstar);
2226
- + WRITE_BOOL_FIELD(winagg);
2227
- + WRITE_LOCATION_FIELD(location);
2228
- +}
2229
- +
2230
- +static void
2231
- +_outArrayRef(StringInfo str, const ArrayRef *node)
2232
- +{
2233
- + WRITE_NODE_TYPE("ARRAYREF");
2234
- +
2235
- + WRITE_OID_FIELD(refarraytype);
2236
- + WRITE_OID_FIELD(refelemtype);
2237
- + WRITE_INT_FIELD(reftypmod);
2238
- + WRITE_OID_FIELD(refcollid);
2239
- + WRITE_NODE_FIELD(refupperindexpr);
2240
- + WRITE_NODE_FIELD(reflowerindexpr);
2241
- + WRITE_NODE_FIELD(refexpr);
2242
- + WRITE_NODE_FIELD(refassgnexpr);
2243
- +}
2244
- +
2245
- +static void
2246
- +_outFuncExpr(StringInfo str, const FuncExpr *node)
2247
- +{
2248
- + WRITE_NODE_TYPE("FUNCEXPR");
2249
- +
2250
- + WRITE_OID_FIELD(funcid);
2251
- + WRITE_OID_FIELD(funcresulttype);
2252
- + WRITE_BOOL_FIELD(funcretset);
2253
- + WRITE_BOOL_FIELD(funcvariadic);
2254
- + WRITE_ENUM_FIELD(funcformat, CoercionForm);
2255
- + WRITE_OID_FIELD(funccollid);
2256
- + WRITE_OID_FIELD(inputcollid);
2257
- + WRITE_NODE_FIELD(args);
2258
- + WRITE_LOCATION_FIELD(location);
2259
- +}
2260
- +
2261
- +static void
2262
- +_outNamedArgExpr(StringInfo str, const NamedArgExpr *node)
2263
- +{
2264
- + WRITE_NODE_TYPE("NAMEDARGEXPR");
2265
- +
2266
- + WRITE_NODE_FIELD(arg);
2267
- + WRITE_STRING_FIELD(name);
2268
- + WRITE_INT_FIELD(argnumber);
2269
- + WRITE_LOCATION_FIELD(location);
2270
- +}
2271
- +
2272
- +static void
2273
- +_outOpExpr(StringInfo str, const OpExpr *node)
2274
- +{
2275
- + WRITE_NODE_TYPE("OPEXPR");
2276
- +
2277
- + WRITE_OID_FIELD(opno);
2278
- + WRITE_OID_FIELD(opfuncid);
2279
- + WRITE_OID_FIELD(opresulttype);
2280
- + WRITE_BOOL_FIELD(opretset);
2281
- + WRITE_OID_FIELD(opcollid);
2282
- + WRITE_OID_FIELD(inputcollid);
2283
- + WRITE_NODE_FIELD(args);
2284
- + WRITE_LOCATION_FIELD(location);
2285
- +}
2286
- +
2287
- +static void
2288
- +_outDistinctExpr(StringInfo str, const DistinctExpr *node)
2289
- +{
2290
- + WRITE_NODE_TYPE("DISTINCTEXPR");
2291
- +
2292
- + WRITE_OID_FIELD(opno);
2293
- + WRITE_OID_FIELD(opfuncid);
2294
- + WRITE_OID_FIELD(opresulttype);
2295
- + WRITE_BOOL_FIELD(opretset);
2296
- + WRITE_OID_FIELD(opcollid);
2297
- + WRITE_OID_FIELD(inputcollid);
2298
- + WRITE_NODE_FIELD(args);
2299
- + WRITE_LOCATION_FIELD(location);
2300
- +}
2301
- +
2302
- +static void
2303
- +_outNullIfExpr(StringInfo str, const NullIfExpr *node)
2304
- +{
2305
- + WRITE_NODE_TYPE("NULLIFEXPR");
2306
- +
2307
- + WRITE_OID_FIELD(opno);
2308
- + WRITE_OID_FIELD(opfuncid);
2309
- + WRITE_OID_FIELD(opresulttype);
2310
- + WRITE_BOOL_FIELD(opretset);
2311
- + WRITE_OID_FIELD(opcollid);
2312
- + WRITE_OID_FIELD(inputcollid);
2313
- + WRITE_NODE_FIELD(args);
2314
- + WRITE_LOCATION_FIELD(location);
2315
- +}
2316
- +
2317
- +static void
2318
- +_outScalarArrayOpExpr(StringInfo str, const ScalarArrayOpExpr *node)
2319
- +{
2320
- + WRITE_NODE_TYPE("SCALARARRAYOPEXPR");
2321
- +
2322
- + WRITE_OID_FIELD(opno);
2323
- + WRITE_OID_FIELD(opfuncid);
2324
- + WRITE_BOOL_FIELD(useOr);
2325
- + WRITE_OID_FIELD(inputcollid);
2326
- + WRITE_NODE_FIELD(args);
2327
- + WRITE_LOCATION_FIELD(location);
2328
- +}
2329
- +
2330
- +static void
2331
- +_outSubLink(StringInfo str, const SubLink *node)
2332
- +{
2333
- + WRITE_NODE_TYPE("SUBLINK");
2334
- +
2335
- + WRITE_ENUM_FIELD(subLinkType, SubLinkType);
2336
- + WRITE_NODE_FIELD(testexpr);
2337
- + WRITE_NODE_FIELD(operName);
2338
- + WRITE_NODE_FIELD(subselect);
2339
- + WRITE_LOCATION_FIELD(location);
2340
- +}
2341
- +
2342
- +static void
2343
- +_outSubPlan(StringInfo str, const SubPlan *node)
2344
- +{
2345
- + WRITE_NODE_TYPE("SUBPLAN");
2346
- +
2347
- + WRITE_ENUM_FIELD(subLinkType, SubLinkType);
2348
- + WRITE_NODE_FIELD(testexpr);
2349
- + WRITE_NODE_FIELD(paramIds);
2350
- + WRITE_INT_FIELD(plan_id);
2351
- + WRITE_STRING_FIELD(plan_name);
2352
- + WRITE_OID_FIELD(firstColType);
2353
- + WRITE_INT_FIELD(firstColTypmod);
2354
- + WRITE_OID_FIELD(firstColCollation);
2355
- + WRITE_BOOL_FIELD(useHashTable);
2356
- + WRITE_BOOL_FIELD(unknownEqFalse);
2357
- + WRITE_NODE_FIELD(setParam);
2358
- + WRITE_NODE_FIELD(parParam);
2359
- + WRITE_NODE_FIELD(args);
2360
- + WRITE_FLOAT_FIELD(startup_cost, "%.2f");
2361
- + WRITE_FLOAT_FIELD(per_call_cost, "%.2f");
2362
- +}
2363
- +
2364
- +static void
2365
- +_outAlternativeSubPlan(StringInfo str, const AlternativeSubPlan *node)
2366
- +{
2367
- + WRITE_NODE_TYPE("ALTERNATIVESUBPLAN");
2368
- +
2369
- + WRITE_NODE_FIELD(subplans);
2370
- +}
2371
- +
2372
- +static void
2373
- +_outFieldSelect(StringInfo str, const FieldSelect *node)
2374
- +{
2375
- + WRITE_NODE_TYPE("FIELDSELECT");
2376
- +
2377
- + WRITE_NODE_FIELD(arg);
2378
- + WRITE_INT_FIELD(fieldnum);
2379
- + WRITE_OID_FIELD(resulttype);
2380
- + WRITE_INT_FIELD(resulttypmod);
2381
- + WRITE_OID_FIELD(resultcollid);
2382
- +}
2383
- +
2384
- +static void
2385
- +_outFieldStore(StringInfo str, const FieldStore *node)
2386
- +{
2387
- + WRITE_NODE_TYPE("FIELDSTORE");
2388
- +
2389
- + WRITE_NODE_FIELD(arg);
2390
- + WRITE_NODE_FIELD(newvals);
2391
- + WRITE_NODE_FIELD(fieldnums);
2392
- + WRITE_OID_FIELD(resulttype);
2393
- +}
2394
- +
2395
- +static void
2396
- +_outRelabelType(StringInfo str, const RelabelType *node)
2397
- +{
2398
- + WRITE_NODE_TYPE("RELABELTYPE");
2399
- +
2400
- + WRITE_NODE_FIELD(arg);
2401
- + WRITE_OID_FIELD(resulttype);
2402
- + WRITE_INT_FIELD(resulttypmod);
2403
- + WRITE_OID_FIELD(resultcollid);
2404
- + WRITE_ENUM_FIELD(relabelformat, CoercionForm);
2405
- + WRITE_LOCATION_FIELD(location);
2406
- +}
2407
- +
2408
- +static void
2409
- +_outCoerceViaIO(StringInfo str, const CoerceViaIO *node)
2410
- +{
2411
- + WRITE_NODE_TYPE("COERCEVIAIO");
2412
- +
2413
- + WRITE_NODE_FIELD(arg);
2414
- + WRITE_OID_FIELD(resulttype);
2415
- + WRITE_OID_FIELD(resultcollid);
2416
- + WRITE_ENUM_FIELD(coerceformat, CoercionForm);
2417
- + WRITE_LOCATION_FIELD(location);
2418
- +}
2419
- +
2420
- +static void
2421
- +_outArrayCoerceExpr(StringInfo str, const ArrayCoerceExpr *node)
2422
- +{
2423
- + WRITE_NODE_TYPE("ARRAYCOERCEEXPR");
2424
- +
2425
- + WRITE_NODE_FIELD(arg);
2426
- + WRITE_OID_FIELD(elemfuncid);
2427
- + WRITE_OID_FIELD(resulttype);
2428
- + WRITE_INT_FIELD(resulttypmod);
2429
- + WRITE_OID_FIELD(resultcollid);
2430
- + WRITE_BOOL_FIELD(isExplicit);
2431
- + WRITE_ENUM_FIELD(coerceformat, CoercionForm);
2432
- + WRITE_LOCATION_FIELD(location);
2433
- +}
2434
- +
2435
- +static void
2436
- +_outConvertRowtypeExpr(StringInfo str, const ConvertRowtypeExpr *node)
2437
- +{
2438
- + WRITE_NODE_TYPE("CONVERTROWTYPEEXPR");
2439
- +
2440
- + WRITE_NODE_FIELD(arg);
2441
- + WRITE_OID_FIELD(resulttype);
2442
- + WRITE_ENUM_FIELD(convertformat, CoercionForm);
2443
- + WRITE_LOCATION_FIELD(location);
2444
- +}
2445
- +
2446
- +static void
2447
- +_outCollateExpr(StringInfo str, const CollateExpr *node)
2448
- +{
2449
- + WRITE_NODE_TYPE("COLLATE");
2450
- +
2451
- + WRITE_NODE_FIELD(arg);
2452
- + WRITE_OID_FIELD(collOid);
2453
- + WRITE_LOCATION_FIELD(location);
2454
- +}
2455
- +
2456
- +static void
2457
- +_outCaseExpr(StringInfo str, const CaseExpr *node)
2458
- +{
2459
- + WRITE_NODE_TYPE("CASE");
2460
- +
2461
- + WRITE_OID_FIELD(casetype);
2462
- + WRITE_OID_FIELD(casecollid);
2463
- + WRITE_NODE_FIELD(arg);
2464
- + WRITE_NODE_FIELD(args);
2465
- + WRITE_NODE_FIELD(defresult);
2466
- + WRITE_LOCATION_FIELD(location);
2467
- +}
2468
- +
2469
- +static void
2470
- +_outCaseWhen(StringInfo str, const CaseWhen *node)
2471
- +{
2472
- + WRITE_NODE_TYPE("WHEN");
2473
- +
2474
- + WRITE_NODE_FIELD(expr);
2475
- + WRITE_NODE_FIELD(result);
2476
- + WRITE_LOCATION_FIELD(location);
2477
- +}
2478
- +
2479
- +static void
2480
- +_outCaseTestExpr(StringInfo str, const CaseTestExpr *node)
2481
- +{
2482
- + WRITE_NODE_TYPE("CASETESTEXPR");
2483
- +
2484
- + WRITE_OID_FIELD(typeId);
2485
- + WRITE_INT_FIELD(typeMod);
2486
- + WRITE_OID_FIELD(collation);
2487
- +}
2488
- +
2489
- +static void
2490
- +_outArrayExpr(StringInfo str, const ArrayExpr *node)
2491
- +{
2492
- + WRITE_NODE_TYPE("ARRAY");
2493
- +
2494
- + WRITE_OID_FIELD(array_typeid);
2495
- + WRITE_OID_FIELD(array_collid);
2496
- + WRITE_OID_FIELD(element_typeid);
2497
- + WRITE_NODE_FIELD(elements);
2498
- + WRITE_BOOL_FIELD(multidims);
2499
- + WRITE_LOCATION_FIELD(location);
2500
- +}
2501
- +
2502
- +static void
2503
- +_outRowExpr(StringInfo str, const RowExpr *node)
2504
- +{
2505
- + WRITE_NODE_TYPE("ROW");
2506
- +
2507
- + WRITE_NODE_FIELD(args);
2508
- + WRITE_OID_FIELD(row_typeid);
2509
- + WRITE_ENUM_FIELD(row_format, CoercionForm);
2510
- + WRITE_NODE_FIELD(colnames);
2511
- + WRITE_LOCATION_FIELD(location);
2512
- +}
2513
- +
2514
- +static void
2515
- +_outRowCompareExpr(StringInfo str, const RowCompareExpr *node)
2516
- +{
2517
- + WRITE_NODE_TYPE("ROWCOMPARE");
2518
- +
2519
- + WRITE_ENUM_FIELD(rctype, RowCompareType);
2520
- + WRITE_NODE_FIELD(opnos);
2521
- + WRITE_NODE_FIELD(opfamilies);
2522
- + WRITE_NODE_FIELD(inputcollids);
2523
- + WRITE_NODE_FIELD(largs);
2524
- + WRITE_NODE_FIELD(rargs);
2525
- +}
2526
- +
2527
- +static void
2528
- +_outCoalesceExpr(StringInfo str, const CoalesceExpr *node)
2529
- +{
2530
- + WRITE_NODE_TYPE("COALESCE");
2531
- +
2532
- + WRITE_OID_FIELD(coalescetype);
2533
- + WRITE_OID_FIELD(coalescecollid);
2534
- + WRITE_NODE_FIELD(args);
2535
- + WRITE_LOCATION_FIELD(location);
2536
- +}
2537
- +
2538
- +static void
2539
- +_outMinMaxExpr(StringInfo str, const MinMaxExpr *node)
2540
- +{
2541
- + WRITE_NODE_TYPE("MINMAX");
2542
- +
2543
- + WRITE_OID_FIELD(minmaxtype);
2544
- + WRITE_OID_FIELD(minmaxcollid);
2545
- + WRITE_OID_FIELD(inputcollid);
2546
- + WRITE_ENUM_FIELD(op, MinMaxOp);
2547
- + WRITE_NODE_FIELD(args);
2548
- + WRITE_LOCATION_FIELD(location);
2549
- +}
2550
- +
2551
- +static void
2552
- +_outXmlExpr(StringInfo str, const XmlExpr *node)
2553
- +{
2554
- + WRITE_NODE_TYPE("XMLEXPR");
2555
- +
2556
- + WRITE_ENUM_FIELD(op, XmlExprOp);
2557
- + WRITE_STRING_FIELD(name);
2558
- + WRITE_NODE_FIELD(named_args);
2559
- + WRITE_NODE_FIELD(arg_names);
2560
- + WRITE_NODE_FIELD(args);
2561
- + WRITE_ENUM_FIELD(xmloption, XmlOptionType);
2562
- + WRITE_OID_FIELD(type);
2563
- + WRITE_INT_FIELD(typmod);
2564
- + WRITE_LOCATION_FIELD(location);
2565
- +}
2566
- +
2567
- +static void
2568
- +_outNullTest(StringInfo str, const NullTest *node)
2569
- +{
2570
- + WRITE_NODE_TYPE("NULLTEST");
2571
- +
2572
- + WRITE_NODE_FIELD(arg);
2573
- + WRITE_ENUM_FIELD(nulltesttype, NullTestType);
2574
- + WRITE_BOOL_FIELD(argisrow);
2575
- +}
2576
- +
2577
- +static void
2578
- +_outBooleanTest(StringInfo str, const BooleanTest *node)
2579
- +{
2580
- + WRITE_NODE_TYPE("BOOLEANTEST");
2581
- +
2582
- + WRITE_NODE_FIELD(arg);
2583
- + WRITE_ENUM_FIELD(booltesttype, BoolTestType);
2584
- +}
2585
- +
2586
- +static void
2587
- +_outCoerceToDomain(StringInfo str, const CoerceToDomain *node)
2588
- +{
2589
- + WRITE_NODE_TYPE("COERCETODOMAIN");
2590
- +
2591
- + WRITE_NODE_FIELD(arg);
2592
- + WRITE_OID_FIELD(resulttype);
2593
- + WRITE_INT_FIELD(resulttypmod);
2594
- + WRITE_OID_FIELD(resultcollid);
2595
- + WRITE_ENUM_FIELD(coercionformat, CoercionForm);
2596
- + WRITE_LOCATION_FIELD(location);
2597
- +}
2598
- +
2599
- +static void
2600
- +_outCoerceToDomainValue(StringInfo str, const CoerceToDomainValue *node)
2601
- +{
2602
- + WRITE_NODE_TYPE("COERCETODOMAINVALUE");
2603
- +
2604
- + WRITE_OID_FIELD(typeId);
2605
- + WRITE_INT_FIELD(typeMod);
2606
- + WRITE_OID_FIELD(collation);
2607
- + WRITE_LOCATION_FIELD(location);
2608
- +}
2609
- +
2610
- +static void
2611
- +_outSetToDefault(StringInfo str, const SetToDefault *node)
2612
- +{
2613
- + WRITE_NODE_TYPE("SETTODEFAULT");
2614
- +
2615
- + WRITE_OID_FIELD(typeId);
2616
- + WRITE_INT_FIELD(typeMod);
2617
- + WRITE_OID_FIELD(collation);
2618
- + WRITE_LOCATION_FIELD(location);
2619
- +}
2620
- +
2621
- +static void
2622
- +_outCurrentOfExpr(StringInfo str, const CurrentOfExpr *node)
2623
- +{
2624
- + WRITE_NODE_TYPE("CURRENTOFEXPR");
2625
- +
2626
- + WRITE_UINT_FIELD(cvarno);
2627
- + WRITE_STRING_FIELD(cursor_name);
2628
- + WRITE_INT_FIELD(cursor_param);
2629
- +}
2630
- +
2631
- +static void
2632
- +_outTargetEntry(StringInfo str, const TargetEntry *node)
2633
- +{
2634
- + WRITE_NODE_TYPE("TARGETENTRY");
2635
- +
2636
- + WRITE_NODE_FIELD(expr);
2637
- + WRITE_INT_FIELD(resno);
2638
- + WRITE_STRING_FIELD(resname);
2639
- + WRITE_UINT_FIELD(ressortgroupref);
2640
- + WRITE_OID_FIELD(resorigtbl);
2641
- + WRITE_INT_FIELD(resorigcol);
2642
- + WRITE_BOOL_FIELD(resjunk);
2643
- +}
2644
- +
2645
- +static void
2646
- +_outRangeTblRef(StringInfo str, const RangeTblRef *node)
2647
- +{
2648
- + WRITE_NODE_TYPE("RANGETBLREF");
2649
- +
2650
- + WRITE_INT_FIELD(rtindex);
2651
- +}
2652
- +
2653
- +static void
2654
- +_outJoinExpr(StringInfo str, const JoinExpr *node)
2655
- +{
2656
- + WRITE_NODE_TYPE("JOINEXPR");
2657
- +
2658
- + WRITE_ENUM_FIELD(jointype, JoinType);
2659
- + WRITE_BOOL_FIELD(isNatural);
2660
- + WRITE_NODE_FIELD(larg);
2661
- + WRITE_NODE_FIELD(rarg);
2662
- + WRITE_NODE_FIELD(usingClause);
2663
- + WRITE_NODE_FIELD(quals);
2664
- + WRITE_NODE_FIELD(alias);
2665
- + WRITE_INT_FIELD(rtindex);
2666
- +}
2667
- +
2668
- +static void
2669
- +_outFromExpr(StringInfo str, const FromExpr *node)
2670
- +{
2671
- + WRITE_NODE_TYPE("FROMEXPR");
2672
- +
2673
- + WRITE_NODE_FIELD(fromlist);
2674
- + WRITE_NODE_FIELD(quals);
2675
- +}
2676
- +
2677
- +static void
2678
- +_outIntoClause(StringInfo str, const IntoClause *node)
2679
- +{
2680
- + WRITE_NODE_TYPE("INTOCLAUSE");
2681
- +
2682
- + WRITE_NODE_FIELD(rel);
2683
- + WRITE_NODE_FIELD(colNames);
2684
- + WRITE_NODE_FIELD(options);
2685
- + WRITE_ENUM_FIELD(onCommit, OnCommitAction);
2686
- + WRITE_STRING_FIELD(tableSpaceName);
2687
- + WRITE_NODE_FIELD(viewQuery);
2688
- + WRITE_BOOL_FIELD(skipData);
2689
- +}
2690
- +
2691
- +static void
2692
- +_outPlannerInfo(StringInfo str, const PlannerInfo *node)
2693
- +{
2694
- + WRITE_NODE_TYPE("PLANNERINFO");
2695
- +
2696
- + WRITE_NODE_FIELD(parse);
2697
- + WRITE_NODE_FIELD(glob);
2698
- + WRITE_UINT_FIELD(query_level);
2699
- + WRITE_NODE_FIELD(plan_params);
2700
- + WRITE_BITMAPSET_FIELD(all_baserels);
2701
- + WRITE_BITMAPSET_FIELD(nullable_baserels);
2702
- + WRITE_NODE_FIELD(join_rel_list);
2703
- + WRITE_INT_FIELD(join_cur_level);
2704
- + WRITE_NODE_FIELD(init_plans);
2705
- + WRITE_NODE_FIELD(cte_plan_ids);
2706
- + WRITE_NODE_FIELD(eq_classes);
2707
- + WRITE_NODE_FIELD(canon_pathkeys);
2708
- + WRITE_NODE_FIELD(left_join_clauses);
2709
- + WRITE_NODE_FIELD(right_join_clauses);
2710
- + WRITE_NODE_FIELD(full_join_clauses);
2711
- + WRITE_NODE_FIELD(join_info_list);
2712
- + WRITE_NODE_FIELD(lateral_info_list);
2713
- + WRITE_NODE_FIELD(append_rel_list);
2714
- + WRITE_NODE_FIELD(rowMarks);
2715
- + WRITE_NODE_FIELD(placeholder_list);
2716
- + WRITE_NODE_FIELD(query_pathkeys);
2717
- + WRITE_NODE_FIELD(group_pathkeys);
2718
- + WRITE_NODE_FIELD(window_pathkeys);
2719
- + WRITE_NODE_FIELD(distinct_pathkeys);
2720
- + WRITE_NODE_FIELD(sort_pathkeys);
2721
- + WRITE_NODE_FIELD(minmax_aggs);
2722
- + WRITE_FLOAT_FIELD(total_table_pages, "%.0f");
2723
- + WRITE_FLOAT_FIELD(tuple_fraction, "%.4f");
2724
- + WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
2725
- + WRITE_BOOL_FIELD(hasInheritedTarget);
2726
- + WRITE_BOOL_FIELD(hasJoinRTEs);
2727
- + WRITE_BOOL_FIELD(hasLateralRTEs);
2728
- + WRITE_BOOL_FIELD(hasHavingQual);
2729
- + WRITE_BOOL_FIELD(hasPseudoConstantQuals);
2730
- + WRITE_BOOL_FIELD(hasRecursion);
2731
- + WRITE_INT_FIELD(wt_param_id);
2732
- + WRITE_BITMAPSET_FIELD(curOuterRels);
2733
- + WRITE_NODE_FIELD(curOuterParams);
2734
- +}
2735
- +
2736
- +static void
2737
- +_outPlannerGlobal(StringInfo str, const PlannerGlobal *node)
2738
- +{
2739
- + WRITE_NODE_TYPE("PLANNERGLOBAL");
2740
- +
2741
- + WRITE_NODE_FIELD(subplans);
2742
- + WRITE_BITMAPSET_FIELD(rewindPlanIDs);
2743
- + WRITE_NODE_FIELD(finalrtable);
2744
- + WRITE_NODE_FIELD(finalrowmarks);
2745
- + WRITE_NODE_FIELD(resultRelations);
2746
- + WRITE_NODE_FIELD(relationOids);
2747
- + WRITE_NODE_FIELD(invalItems);
2748
- + WRITE_INT_FIELD(nParamExec);
2749
- + WRITE_UINT_FIELD(lastPHId);
2750
- + WRITE_UINT_FIELD(lastRowMarkId);
2751
- + WRITE_BOOL_FIELD(transientPlan);
2752
- +}
2753
- +
2754
- +static void
2755
- +_outRelOptInfo(StringInfo str, const RelOptInfo *node)
2756
- +{
2757
- + WRITE_NODE_TYPE("RELOPTINFO");
2758
- +
2759
- + WRITE_ENUM_FIELD(reloptkind, RelOptKind);
2760
- + WRITE_BITMAPSET_FIELD(relids);
2761
- + WRITE_FLOAT_FIELD(rows, "%.0f");
2762
- + WRITE_INT_FIELD(width);
2763
- + WRITE_BOOL_FIELD(consider_startup);
2764
- + WRITE_NODE_FIELD(reltargetlist);
2765
- + WRITE_NODE_FIELD(pathlist);
2766
- + WRITE_NODE_FIELD(ppilist);
2767
- + WRITE_NODE_FIELD(cheapest_startup_path);
2768
- + WRITE_NODE_FIELD(cheapest_total_path);
2769
- + WRITE_NODE_FIELD(cheapest_unique_path);
2770
- + WRITE_NODE_FIELD(cheapest_parameterized_paths);
2771
- + WRITE_UINT_FIELD(relid);
2772
- + WRITE_UINT_FIELD(reltablespace);
2773
- + WRITE_ENUM_FIELD(rtekind, RTEKind);
2774
- + WRITE_INT_FIELD(min_attr);
2775
- + WRITE_INT_FIELD(max_attr);
2776
- + WRITE_NODE_FIELD(lateral_vars);
2777
- + WRITE_BITMAPSET_FIELD(lateral_relids);
2778
- + WRITE_BITMAPSET_FIELD(lateral_referencers);
2779
- + WRITE_NODE_FIELD(indexlist);
2780
- + WRITE_UINT_FIELD(pages);
2781
- + WRITE_FLOAT_FIELD(tuples, "%.0f");
2782
- + WRITE_FLOAT_FIELD(allvisfrac, "%.6f");
2783
- + WRITE_NODE_FIELD(subplan);
2784
- + WRITE_NODE_FIELD(subroot);
2785
- + WRITE_NODE_FIELD(subplan_params);
2786
- + WRITE_NODE_FIELD(baserestrictinfo);
2787
- + WRITE_NODE_FIELD(joininfo);
2788
- + WRITE_BOOL_FIELD(has_eclass_joins);
2789
- +}
2790
- +
2791
- +static void
2792
- +_outIndexOptInfo(StringInfo str, const IndexOptInfo *node)
2793
- +{
2794
- + WRITE_NODE_TYPE("INDEXOPTINFO");
2795
- +
2796
- + WRITE_OID_FIELD(indexoid);
2797
- + WRITE_UINT_FIELD(pages);
2798
- + WRITE_FLOAT_FIELD(tuples, "%.0f");
2799
- + WRITE_INT_FIELD(tree_height);
2800
- + WRITE_INT_FIELD(ncolumns);
2801
- + WRITE_OID_FIELD(relam);
2802
- + WRITE_NODE_FIELD(indpred);
2803
- + WRITE_NODE_FIELD(indextlist);
2804
- + WRITE_BOOL_FIELD(predOK);
2805
- + WRITE_BOOL_FIELD(unique);
2806
- + WRITE_BOOL_FIELD(immediate);
2807
- + WRITE_BOOL_FIELD(hypothetical);
2808
- +}
2809
- +
2810
- +static void
2811
- +_outParamPathInfo(StringInfo str, const ParamPathInfo *node)
2812
- +{
2813
- + WRITE_NODE_TYPE("PARAMPATHINFO");
2814
- +
2815
- + WRITE_BITMAPSET_FIELD(ppi_req_outer);
2816
- + WRITE_FLOAT_FIELD(ppi_rows, "%.0f");
2817
- + WRITE_NODE_FIELD(ppi_clauses);
2818
- +}
2819
- +
2820
- +static void
2821
- +_outIndexPath(StringInfo str, const IndexPath *node)
2822
- +{
2823
- + WRITE_NODE_TYPE("INDEXPATH");
2824
- +
2825
- + _outPathInfo(str, (const Path *) node);
2826
- +
2827
- + WRITE_NODE_FIELD(indexinfo);
2828
- + WRITE_NODE_FIELD(indexclauses);
2829
- + WRITE_NODE_FIELD(indexquals);
2830
- + WRITE_NODE_FIELD(indexqualcols);
2831
- + WRITE_NODE_FIELD(indexorderbys);
2832
- + WRITE_NODE_FIELD(indexorderbycols);
2833
- + WRITE_ENUM_FIELD(indexscandir, ScanDirection);
2834
- + WRITE_FLOAT_FIELD(indextotalcost, "%.2f");
2835
- + WRITE_FLOAT_FIELD(indexselectivity, "%.4f");
2836
- +}
2837
- +
2838
- +static void
2839
- +_outBitmapHeapPath(StringInfo str, const BitmapHeapPath *node)
2840
- +{
2841
- + WRITE_NODE_TYPE("BITMAPHEAPPATH");
2842
- +
2843
- + _outPathInfo(str, (const Path *) node);
2844
- +
2845
- + WRITE_NODE_FIELD(bitmapqual);
2846
- +}
2847
- +
2848
- +static void
2849
- +_outBitmapAndPath(StringInfo str, const BitmapAndPath *node)
2850
- +{
2851
- + WRITE_NODE_TYPE("BITMAPANDPATH");
2852
- +
2853
- + _outPathInfo(str, (const Path *) node);
2854
- +
2855
- + WRITE_NODE_FIELD(bitmapquals);
2856
- + WRITE_FLOAT_FIELD(bitmapselectivity, "%.4f");
2857
- +}
2858
- +
2859
- +static void
2860
- +_outBitmapOrPath(StringInfo str, const BitmapOrPath *node)
2861
- +{
2862
- + WRITE_NODE_TYPE("BITMAPORPATH");
2863
- +
2864
- + _outPathInfo(str, (const Path *) node);
2865
- +
2866
- + WRITE_NODE_FIELD(bitmapquals);
2867
- + WRITE_FLOAT_FIELD(bitmapselectivity, "%.4f");
2868
- +}
2869
- +
2870
- +static void
2871
- +_outNestPath(StringInfo str, const NestPath *node)
2872
- +{
2873
- + WRITE_NODE_TYPE("NESTPATH");
2874
- +
2875
- + _outJoinPathInfo(str, (const JoinPath *) node);
2876
- +
2877
- +}
2878
- +
2879
- +static void
2880
- +_outMergePath(StringInfo str, const MergePath *node)
2881
- +{
2882
- + WRITE_NODE_TYPE("MERGEPATH");
2883
- +
2884
- + _outJoinPathInfo(str, (const JoinPath *) node);
2885
- +
2886
- + WRITE_NODE_FIELD(path_mergeclauses);
2887
- + WRITE_NODE_FIELD(outersortkeys);
2888
- + WRITE_NODE_FIELD(innersortkeys);
2889
- + WRITE_BOOL_FIELD(materialize_inner);
2890
- +}
2891
- +
2892
- +static void
2893
- +_outHashPath(StringInfo str, const HashPath *node)
2894
- +{
2895
- + WRITE_NODE_TYPE("HASHPATH");
2896
- +
2897
- + _outJoinPathInfo(str, (const JoinPath *) node);
2898
- +
2899
- + WRITE_NODE_FIELD(path_hashclauses);
2900
- + WRITE_INT_FIELD(num_batches);
2901
- +}
2902
- +
2903
- +static void
2904
- +_outTidPath(StringInfo str, const TidPath *node)
2905
- +{
2906
- + WRITE_NODE_TYPE("TIDPATH");
2907
- +
2908
- + _outPathInfo(str, (const Path *) node);
2909
- +
2910
- + WRITE_NODE_FIELD(tidquals);
2911
- +}
2912
- +
2913
- +static void
2914
- +_outForeignPath(StringInfo str, const ForeignPath *node)
2915
- +{
2916
- + WRITE_NODE_TYPE("FOREIGNPATH");
2917
- +
2918
- + _outPathInfo(str, (const Path *) node);
2919
- +
2920
- + WRITE_NODE_FIELD(fdw_private);
2921
- +}
2922
- +
2923
- +static void
2924
- +_outAppendPath(StringInfo str, const AppendPath *node)
2925
- +{
2926
- + WRITE_NODE_TYPE("APPENDPATH");
2927
- +
2928
- + _outPathInfo(str, (const Path *) node);
2929
- +
2930
- + WRITE_NODE_FIELD(subpaths);
2931
- +}
2932
- +
2933
- +static void
2934
- +_outMergeAppendPath(StringInfo str, const MergeAppendPath *node)
2935
- +{
2936
- + WRITE_NODE_TYPE("MERGEAPPENDPATH");
2937
- +
2938
- + _outPathInfo(str, (const Path *) node);
2939
- +
2940
- + WRITE_NODE_FIELD(subpaths);
2941
- + WRITE_FLOAT_FIELD(limit_tuples, "%.0f");
2942
- +}
2943
- +
2944
- +static void
2945
- +_outResultPath(StringInfo str, const ResultPath *node)
2946
- +{
2947
- + WRITE_NODE_TYPE("RESULTPATH");
2948
- +
2949
- + _outPathInfo(str, (const Path *) node);
2950
- +
2951
- + WRITE_NODE_FIELD(quals);
2952
- +}
2953
- +
2954
- +static void
2955
- +_outMaterialPath(StringInfo str, const MaterialPath *node)
2956
- +{
2957
- + WRITE_NODE_TYPE("MATERIALPATH");
2958
- +
2959
- + _outPathInfo(str, (const Path *) node);
2960
- +
2961
- + WRITE_NODE_FIELD(subpath);
2962
- +}
2963
- +
2964
- +static void
2965
- +_outUniquePath(StringInfo str, const UniquePath *node)
2966
- +{
2967
- + WRITE_NODE_TYPE("UNIQUEPATH");
2968
- +
2969
- + _outPathInfo(str, (const Path *) node);
2970
- +
2971
- + WRITE_NODE_FIELD(subpath);
2972
- + WRITE_ENUM_FIELD(umethod, UniquePathMethod);
2973
- + WRITE_NODE_FIELD(in_operators);
2974
- + WRITE_NODE_FIELD(uniq_exprs);
2975
- +}
2976
- +
2977
- +static void
2978
- +_outEquivalenceMember(StringInfo str, const EquivalenceMember *node)
2979
- +{
2980
- + WRITE_NODE_TYPE("EQUIVALENCEMEMBER");
2981
- +
2982
- + WRITE_NODE_FIELD(em_expr);
2983
- + WRITE_BITMAPSET_FIELD(em_relids);
2984
- + WRITE_BITMAPSET_FIELD(em_nullable_relids);
2985
- + WRITE_BOOL_FIELD(em_is_const);
2986
- + WRITE_BOOL_FIELD(em_is_child);
2987
- + WRITE_OID_FIELD(em_datatype);
2988
- +}
2989
- +
2990
- +static void
2991
- +_outPathKey(StringInfo str, const PathKey *node)
2992
- +{
2993
- + WRITE_NODE_TYPE("PATHKEY");
2994
- +
2995
- + WRITE_NODE_FIELD(pk_eclass);
2996
- + WRITE_OID_FIELD(pk_opfamily);
2997
- + WRITE_INT_FIELD(pk_strategy);
2998
- + WRITE_BOOL_FIELD(pk_nulls_first);
2999
- +}
3000
- +
3001
- +static void
3002
- +_outRestrictInfo(StringInfo str, const RestrictInfo *node)
3003
- +{
3004
- + WRITE_NODE_TYPE("RESTRICTINFO");
3005
- +
3006
- + WRITE_NODE_FIELD(clause);
3007
- + WRITE_BOOL_FIELD(is_pushed_down);
3008
- + WRITE_BOOL_FIELD(outerjoin_delayed);
3009
- + WRITE_BOOL_FIELD(can_join);
3010
- + WRITE_BOOL_FIELD(pseudoconstant);
3011
- + WRITE_BITMAPSET_FIELD(clause_relids);
3012
- + WRITE_BITMAPSET_FIELD(required_relids);
3013
- + WRITE_BITMAPSET_FIELD(outer_relids);
3014
- + WRITE_BITMAPSET_FIELD(nullable_relids);
3015
- + WRITE_BITMAPSET_FIELD(left_relids);
3016
- + WRITE_BITMAPSET_FIELD(right_relids);
3017
- + WRITE_NODE_FIELD(orclause);
3018
- + WRITE_FLOAT_FIELD(norm_selec, "%.4f");
3019
- + WRITE_FLOAT_FIELD(outer_selec, "%.4f");
3020
- + WRITE_NODE_FIELD(mergeopfamilies);
3021
- + WRITE_NODE_FIELD(left_em);
3022
- + WRITE_NODE_FIELD(right_em);
3023
- + WRITE_BOOL_FIELD(outer_is_left);
3024
- + WRITE_OID_FIELD(hashjoinoperator);
3025
- +}
3026
- +
3027
- +static void
3028
- +_outPlaceHolderVar(StringInfo str, const PlaceHolderVar *node)
3029
- +{
3030
- + WRITE_NODE_TYPE("PLACEHOLDERVAR");
3031
- +
3032
- + WRITE_NODE_FIELD(phexpr);
3033
- + WRITE_BITMAPSET_FIELD(phrels);
3034
- + WRITE_UINT_FIELD(phid);
3035
- + WRITE_UINT_FIELD(phlevelsup);
3036
- +}
3037
- +
3038
- +static void
3039
- +_outSpecialJoinInfo(StringInfo str, const SpecialJoinInfo *node)
3040
- +{
3041
- + WRITE_NODE_TYPE("SPECIALJOININFO");
3042
- +
3043
- + WRITE_BITMAPSET_FIELD(min_lefthand);
3044
- + WRITE_BITMAPSET_FIELD(min_righthand);
3045
- + WRITE_BITMAPSET_FIELD(syn_lefthand);
3046
- + WRITE_BITMAPSET_FIELD(syn_righthand);
3047
- + WRITE_ENUM_FIELD(jointype, JoinType);
3048
- + WRITE_BOOL_FIELD(lhs_strict);
3049
- + WRITE_BOOL_FIELD(delay_upper_joins);
3050
- + WRITE_NODE_FIELD(join_quals);
3051
- +}
3052
- +
3053
- +static void
3054
- +_outLateralJoinInfo(StringInfo str, const LateralJoinInfo *node)
3055
- +{
3056
- + WRITE_NODE_TYPE("LATERALJOININFO");
3057
- +
3058
- + WRITE_BITMAPSET_FIELD(lateral_lhs);
3059
- + WRITE_BITMAPSET_FIELD(lateral_rhs);
3060
- +}
3061
- +
3062
- +static void
3063
- +_outAppendRelInfo(StringInfo str, const AppendRelInfo *node)
3064
- +{
3065
- + WRITE_NODE_TYPE("APPENDRELINFO");
3066
- +
3067
- + WRITE_UINT_FIELD(parent_relid);
3068
- + WRITE_UINT_FIELD(child_relid);
3069
- + WRITE_OID_FIELD(parent_reltype);
3070
- + WRITE_OID_FIELD(child_reltype);
3071
- + WRITE_NODE_FIELD(translated_vars);
3072
- + WRITE_OID_FIELD(parent_reloid);
3073
- +}
3074
- +
3075
- +static void
3076
- +_outPlaceHolderInfo(StringInfo str, const PlaceHolderInfo *node)
3077
- +{
3078
- + WRITE_NODE_TYPE("PLACEHOLDERINFO");
3079
- +
3080
- + WRITE_UINT_FIELD(phid);
3081
- + WRITE_NODE_FIELD(ph_var);
3082
- + WRITE_BITMAPSET_FIELD(ph_eval_at);
3083
- + WRITE_BITMAPSET_FIELD(ph_lateral);
3084
- + WRITE_BITMAPSET_FIELD(ph_needed);
3085
- + WRITE_INT_FIELD(ph_width);
3086
- +}
3087
- +
3088
- +static void
3089
- +_outMinMaxAggInfo(StringInfo str, const MinMaxAggInfo *node)
3090
- +{
3091
- + WRITE_NODE_TYPE("MINMAXAGGINFO");
3092
- +
3093
- + WRITE_OID_FIELD(aggfnoid);
3094
- + WRITE_OID_FIELD(aggsortop);
3095
- + WRITE_NODE_FIELD(target);
3096
- + WRITE_NODE_FIELD(path);
3097
- + WRITE_FLOAT_FIELD(pathcost, "%.2f");
3098
- + WRITE_NODE_FIELD(param);
3099
- +}
3100
- +
3101
- +static void
3102
- +_outPlannerParamItem(StringInfo str, const PlannerParamItem *node)
3103
- +{
3104
- + WRITE_NODE_TYPE("PLANNERPARAMITEM");
3105
- +
3106
- + WRITE_NODE_FIELD(item);
3107
- + WRITE_INT_FIELD(paramId);
3108
- +}
3109
- +
3110
- +static void
3111
- +_outQuery(StringInfo str, const Query *node)
3112
- +{
3113
- + WRITE_NODE_TYPE("QUERY");
3114
- +
3115
- + WRITE_ENUM_FIELD(commandType, CmdType);
3116
- + WRITE_ENUM_FIELD(querySource, QuerySource);
3117
- + WRITE_BOOL_FIELD(canSetTag);
3118
- + WRITE_NODE_FIELD(utilityStmt);
3119
- + WRITE_INT_FIELD(resultRelation);
3120
- + WRITE_BOOL_FIELD(hasAggs);
3121
- + WRITE_BOOL_FIELD(hasWindowFuncs);
3122
- + WRITE_BOOL_FIELD(hasSubLinks);
3123
- + WRITE_BOOL_FIELD(hasDistinctOn);
3124
- + WRITE_BOOL_FIELD(hasRecursive);
3125
- + WRITE_BOOL_FIELD(hasModifyingCTE);
3126
- + WRITE_BOOL_FIELD(hasForUpdate);
3127
- + WRITE_NODE_FIELD(cteList);
3128
- + WRITE_NODE_FIELD(rtable);
3129
- + WRITE_NODE_FIELD(jointree);
3130
- + WRITE_NODE_FIELD(targetList);
3131
- + WRITE_NODE_FIELD(withCheckOptions);
3132
- + WRITE_NODE_FIELD(returningList);
3133
- + WRITE_NODE_FIELD(groupClause);
3134
- + WRITE_NODE_FIELD(havingQual);
3135
- + WRITE_NODE_FIELD(windowClause);
3136
- + WRITE_NODE_FIELD(distinctClause);
3137
- + WRITE_NODE_FIELD(sortClause);
3138
- + WRITE_NODE_FIELD(limitOffset);
3139
- + WRITE_NODE_FIELD(limitCount);
3140
- + WRITE_NODE_FIELD(rowMarks);
3141
- + WRITE_NODE_FIELD(setOperations);
3142
- + WRITE_NODE_FIELD(constraintDeps);
3143
- +}
3144
- +
3145
- +static void
3146
- +_outPlannedStmt(StringInfo str, const PlannedStmt *node)
3147
- +{
3148
- + WRITE_NODE_TYPE("PLANNEDSTMT");
3149
- +
3150
- + WRITE_ENUM_FIELD(commandType, CmdType);
3151
- + WRITE_UINT_FIELD(queryId);
3152
- + WRITE_BOOL_FIELD(hasReturning);
3153
- + WRITE_BOOL_FIELD(hasModifyingCTE);
3154
- + WRITE_BOOL_FIELD(canSetTag);
3155
- + WRITE_BOOL_FIELD(transientPlan);
3156
- + WRITE_NODE_FIELD(planTree);
3157
- + WRITE_NODE_FIELD(rtable);
3158
- + WRITE_NODE_FIELD(resultRelations);
3159
- + WRITE_NODE_FIELD(utilityStmt);
3160
- + WRITE_NODE_FIELD(subplans);
3161
- + WRITE_BITMAPSET_FIELD(rewindPlanIDs);
3162
- + WRITE_NODE_FIELD(rowMarks);
3163
- + WRITE_NODE_FIELD(relationOids);
3164
- + WRITE_NODE_FIELD(invalItems);
3165
- + WRITE_INT_FIELD(nParamExec);
3166
- +}
3167
- +
3168
- +static void
3169
- +_outInsertStmt(StringInfo str, const InsertStmt *node)
3170
- +{
3171
- + WRITE_NODE_TYPE("INSERT INTO");
3172
- +
3173
- + WRITE_NODE_FIELD(relation);
3174
- + WRITE_NODE_FIELD(cols);
3175
- + WRITE_NODE_FIELD(selectStmt);
3176
- + WRITE_NODE_FIELD(returningList);
3177
- + WRITE_NODE_FIELD(withClause);
3178
- +}
3179
- +
3180
- +static void
3181
- +_outDeleteStmt(StringInfo str, const DeleteStmt *node)
3182
- +{
3183
- + WRITE_NODE_TYPE("DELETE FROM");
3184
- +
3185
- + WRITE_NODE_FIELD(relation);
3186
- + WRITE_NODE_FIELD(usingClause);
3187
- + WRITE_NODE_FIELD(whereClause);
3188
- + WRITE_NODE_FIELD(returningList);
3189
- + WRITE_NODE_FIELD(withClause);
3190
- +}
3191
- +
3192
- +static void
3193
- +_outUpdateStmt(StringInfo str, const UpdateStmt *node)
3194
- +{
3195
- + WRITE_NODE_TYPE("UPDATE");
3196
- +
3197
- + WRITE_NODE_FIELD(relation);
3198
- + WRITE_NODE_FIELD(targetList);
3199
- + WRITE_NODE_FIELD(whereClause);
3200
- + WRITE_NODE_FIELD(fromClause);
3201
- + WRITE_NODE_FIELD(returningList);
3202
- + WRITE_NODE_FIELD(withClause);
3203
- +}
3204
- +
3205
- +static void
3206
- +_outSelectStmt(StringInfo str, const SelectStmt *node)
3207
- +{
3208
- + WRITE_NODE_TYPE("SELECT");
3209
- +
3210
- + WRITE_NODE_FIELD(distinctClause);
3211
- + WRITE_NODE_FIELD(intoClause);
3212
- + WRITE_NODE_FIELD(targetList);
3213
- + WRITE_NODE_FIELD(fromClause);
3214
- + WRITE_NODE_FIELD(whereClause);
3215
- + WRITE_NODE_FIELD(groupClause);
3216
- + WRITE_NODE_FIELD(havingClause);
3217
- + WRITE_NODE_FIELD(windowClause);
3218
- + WRITE_NODE_FIELD(valuesLists);
3219
- + WRITE_NODE_FIELD(sortClause);
3220
- + WRITE_NODE_FIELD(limitOffset);
3221
- + WRITE_NODE_FIELD(limitCount);
3222
- + WRITE_NODE_FIELD(lockingClause);
3223
- + WRITE_NODE_FIELD(withClause);
3224
- + WRITE_ENUM_FIELD(op, SetOperation);
3225
- + WRITE_BOOL_FIELD(all);
3226
- + WRITE_NODE_FIELD(larg);
3227
- + WRITE_NODE_FIELD(rarg);
3228
- +}
3229
- +
3230
- +static void
3231
- +_outAlterTableStmt(StringInfo str, const AlterTableStmt *node)
3232
- +{
3233
- + WRITE_NODE_TYPE("ALTER TABLE");
3234
- +
3235
- + WRITE_NODE_FIELD(relation);
3236
- + WRITE_NODE_FIELD(cmds);
3237
- + WRITE_ENUM_FIELD(relkind, ObjectType);
3238
- + WRITE_BOOL_FIELD(missing_ok);
3239
- +}
3240
- +
3241
- +static void
3242
- +_outAlterTableCmd(StringInfo str, const AlterTableCmd *node)
3243
- +{
3244
- + WRITE_NODE_TYPE("ALTER TABLE CMD");
3245
- +
3246
- + WRITE_ENUM_FIELD(subtype, AlterTableType);
3247
- + WRITE_STRING_FIELD(name);
3248
- + WRITE_NODE_FIELD(def);
3249
- + WRITE_ENUM_FIELD(behavior, DropBehavior);
3250
- + WRITE_BOOL_FIELD(missing_ok);
3251
- +}
3252
- +
3253
- +static void
3254
- +_outAlterDomainStmt(StringInfo str, const AlterDomainStmt *node)
3255
- +{
3256
- + WRITE_NODE_TYPE("ALTERDOMAINSTMT");
3257
- +
3258
- + WRITE_CHAR_FIELD(subtype);
3259
- + WRITE_NODE_FIELD(typeName);
3260
- + WRITE_STRING_FIELD(name);
3261
- + WRITE_NODE_FIELD(def);
3262
- + WRITE_ENUM_FIELD(behavior, DropBehavior);
3263
- + WRITE_BOOL_FIELD(missing_ok);
3264
- +}
3265
- +
3266
- +static void
3267
- +_outSetOperationStmt(StringInfo str, const SetOperationStmt *node)
3268
- +{
3269
- + WRITE_NODE_TYPE("SETOPERATIONSTMT");
3270
- +
3271
- + WRITE_ENUM_FIELD(op, SetOperation);
3272
- + WRITE_BOOL_FIELD(all);
3273
- + WRITE_NODE_FIELD(larg);
3274
- + WRITE_NODE_FIELD(rarg);
3275
- + WRITE_NODE_FIELD(colTypes);
3276
- + WRITE_NODE_FIELD(colTypmods);
3277
- + WRITE_NODE_FIELD(colCollations);
3278
- + WRITE_NODE_FIELD(groupClauses);
3279
- +}
3280
- +
3281
- +static void
3282
- +_outGrantStmt(StringInfo str, const GrantStmt *node)
3283
- +{
3284
- + WRITE_NODE_TYPE("GRANTSTMT");
3285
- +
3286
- + WRITE_BOOL_FIELD(is_grant);
3287
- + WRITE_ENUM_FIELD(targtype, GrantTargetType);
3288
- + WRITE_ENUM_FIELD(objtype, GrantObjectType);
3289
- + WRITE_NODE_FIELD(objects);
3290
- + WRITE_NODE_FIELD(privileges);
3291
- + WRITE_NODE_FIELD(grantees);
3292
- + WRITE_BOOL_FIELD(grant_option);
3293
- + WRITE_ENUM_FIELD(behavior, DropBehavior);
3294
- +}
3295
- +
3296
- +static void
3297
- +_outGrantRoleStmt(StringInfo str, const GrantRoleStmt *node)
3298
- +{
3299
- + WRITE_NODE_TYPE("GRANTROLESTMT");
3300
- +
3301
- + WRITE_NODE_FIELD(granted_roles);
3302
- + WRITE_NODE_FIELD(grantee_roles);
3303
- + WRITE_BOOL_FIELD(is_grant);
3304
- + WRITE_BOOL_FIELD(admin_opt);
3305
- + WRITE_STRING_FIELD(grantor);
3306
- + WRITE_ENUM_FIELD(behavior, DropBehavior);
3307
- +}
3308
- +
3309
- +static void
3310
- +_outAlterDefaultPrivilegesStmt(StringInfo str, const AlterDefaultPrivilegesStmt *node)
3311
- +{
3312
- + WRITE_NODE_TYPE("ALTERDEFAULTPRIVILEGESSTMT");
3313
- +
3314
- + WRITE_NODE_FIELD(options);
3315
- + WRITE_NODE_FIELD(action);
3316
- +}
3317
- +
3318
- +static void
3319
- +_outClosePortalStmt(StringInfo str, const ClosePortalStmt *node)
3320
- +{
3321
- + WRITE_NODE_TYPE("CLOSEPORTALSTMT");
3322
- +
3323
- + WRITE_STRING_FIELD(portalname);
3324
- +}
3325
- +
3326
- +static void
3327
- +_outClusterStmt(StringInfo str, const ClusterStmt *node)
3328
- +{
3329
- + WRITE_NODE_TYPE("CLUSTERSTMT");
3330
- +
3331
- + WRITE_NODE_FIELD(relation);
3332
- + WRITE_STRING_FIELD(indexname);
3333
- + WRITE_BOOL_FIELD(verbose);
3334
- +}
3335
- +
3336
- +static void
3337
- +_outCopyStmt(StringInfo str, const CopyStmt *node)
3338
- +{
3339
- + WRITE_NODE_TYPE("COPY");
3340
- +
3341
- + WRITE_NODE_FIELD(relation);
3342
- + WRITE_NODE_FIELD(query);
3343
- + WRITE_NODE_FIELD(attlist);
3344
- + WRITE_BOOL_FIELD(is_from);
3345
- + WRITE_BOOL_FIELD(is_program);
3346
- + WRITE_STRING_FIELD(filename);
3347
- + WRITE_NODE_FIELD(options);
3348
- +}
3349
- +
3350
- +static void
3351
- +_outCreateStmt(StringInfo str, const CreateStmt *node)
3352
- +{
3353
- + WRITE_NODE_TYPE("CREATESTMT");
3354
- +
3355
- + _outCreateStmtInfo(str, (const CreateStmt *) node);
3356
- +
3357
- +}
3358
- +
3359
- +static void
3360
- +_outDefineStmt(StringInfo str, const DefineStmt *node)
3361
- +{
3362
- + WRITE_NODE_TYPE("DEFINESTMT");
3363
- +
3364
- + WRITE_ENUM_FIELD(kind, ObjectType);
3365
- + WRITE_BOOL_FIELD(oldstyle);
3366
- + WRITE_NODE_FIELD(defnames);
3367
- + WRITE_NODE_FIELD(args);
3368
- + WRITE_NODE_FIELD(definition);
3369
- +}
3370
- +
3371
- +static void
3372
- +_outDropStmt(StringInfo str, const DropStmt *node)
3373
- +{
3374
- + WRITE_NODE_TYPE("DROP");
3375
- +
3376
- + WRITE_NODE_FIELD(objects);
3377
- + WRITE_NODE_FIELD(arguments);
3378
- + WRITE_ENUM_FIELD(removeType, ObjectType);
3379
- + WRITE_ENUM_FIELD(behavior, DropBehavior);
3380
- + WRITE_BOOL_FIELD(missing_ok);
3381
- + WRITE_BOOL_FIELD(concurrent);
3382
- +}
3383
- +
3384
- +static void
3385
- +_outTruncateStmt(StringInfo str, const TruncateStmt *node)
3386
- +{
3387
- + WRITE_NODE_TYPE("TRUNCATE");
3388
- +
3389
- + WRITE_NODE_FIELD(relations);
3390
- + WRITE_BOOL_FIELD(restart_seqs);
3391
- + WRITE_ENUM_FIELD(behavior, DropBehavior);
3392
- +}
3393
- +
3394
- +static void
3395
- +_outCommentStmt(StringInfo str, const CommentStmt *node)
3396
- +{
3397
- + WRITE_NODE_TYPE("COMMENTSTMT");
3398
- +
3399
- + WRITE_ENUM_FIELD(objtype, ObjectType);
3400
- + WRITE_NODE_FIELD(objname);
3401
- + WRITE_NODE_FIELD(objargs);
3402
- + WRITE_STRING_FIELD(comment);
3403
- +}
3404
- +
3405
- +static void
3406
- +_outFetchStmt(StringInfo str, const FetchStmt *node)
3407
- +{
3408
- + WRITE_NODE_TYPE("FETCHSTMT");
3409
- +
3410
- + WRITE_ENUM_FIELD(direction, FetchDirection);
3411
- + WRITE_LONG_FIELD(howMany);
3412
- + WRITE_STRING_FIELD(portalname);
3413
- + WRITE_BOOL_FIELD(ismove);
3414
- +}
3415
- +
3416
- +static void
3417
- +_outIndexStmt(StringInfo str, const IndexStmt *node)
3418
- +{
3419
- + WRITE_NODE_TYPE("INDEXSTMT");
3420
- +
3421
- + WRITE_STRING_FIELD(idxname);
3422
- + WRITE_NODE_FIELD(relation);
3423
- + WRITE_STRING_FIELD(accessMethod);
3424
- + WRITE_STRING_FIELD(tableSpace);
3425
- + WRITE_NODE_FIELD(indexParams);
3426
- + WRITE_NODE_FIELD(options);
3427
- + WRITE_NODE_FIELD(whereClause);
3428
- + WRITE_NODE_FIELD(excludeOpNames);
3429
- + WRITE_STRING_FIELD(idxcomment);
3430
- + WRITE_OID_FIELD(indexOid);
3431
- + WRITE_OID_FIELD(oldNode);
3432
- + WRITE_BOOL_FIELD(unique);
3433
- + WRITE_BOOL_FIELD(primary);
3434
- + WRITE_BOOL_FIELD(isconstraint);
3435
- + WRITE_BOOL_FIELD(deferrable);
3436
- + WRITE_BOOL_FIELD(initdeferred);
3437
- + WRITE_BOOL_FIELD(concurrent);
3438
- +}
3439
- +
3440
- +static void
3441
- +_outCreateFunctionStmt(StringInfo str, const CreateFunctionStmt *node)
3442
- +{
3443
- + WRITE_NODE_TYPE("CREATEFUNCTIONSTMT");
3444
- +
3445
- + WRITE_BOOL_FIELD(replace);
3446
- + WRITE_NODE_FIELD(funcname);
3447
- + WRITE_NODE_FIELD(parameters);
3448
- + WRITE_NODE_FIELD(returnType);
3449
- + WRITE_NODE_FIELD(options);
3450
- + WRITE_NODE_FIELD(withClause);
3451
- +}
3452
- +
3453
- +static void
3454
- +_outAlterFunctionStmt(StringInfo str, const AlterFunctionStmt *node)
3455
- +{
3456
- + WRITE_NODE_TYPE("ALTERFUNCTIONSTMT");
3457
- +
3458
- + WRITE_NODE_FIELD(func);
3459
- + WRITE_NODE_FIELD(actions);
3460
- +}
3461
- +
3462
- +static void
3463
- +_outDoStmt(StringInfo str, const DoStmt *node)
3464
- +{
3465
- + WRITE_NODE_TYPE("DOSTMT");
3466
- +
3467
- + WRITE_NODE_FIELD(args);
3468
- +}
3469
- +
3470
- +static void
3471
- +_outRenameStmt(StringInfo str, const RenameStmt *node)
3472
- +{
3473
- + WRITE_NODE_TYPE("RENAMESTMT");
3474
- +
3475
- + WRITE_ENUM_FIELD(renameType, ObjectType);
3476
- + WRITE_ENUM_FIELD(relationType, ObjectType);
3477
- + WRITE_NODE_FIELD(relation);
3478
- + WRITE_NODE_FIELD(object);
3479
- + WRITE_NODE_FIELD(objarg);
3480
- + WRITE_STRING_FIELD(subname);
3481
- + WRITE_STRING_FIELD(newname);
3482
- + WRITE_ENUM_FIELD(behavior, DropBehavior);
3483
- + WRITE_BOOL_FIELD(missing_ok);
3484
- +}
3485
- +
3486
- +static void
3487
- +_outRuleStmt(StringInfo str, const RuleStmt *node)
3488
- +{
3489
- + WRITE_NODE_TYPE("RULESTMT");
3490
- +
3491
- + WRITE_NODE_FIELD(relation);
3492
- + WRITE_STRING_FIELD(rulename);
3493
- + WRITE_NODE_FIELD(whereClause);
3494
- + WRITE_ENUM_FIELD(event, CmdType);
3495
- + WRITE_BOOL_FIELD(instead);
3496
- + WRITE_NODE_FIELD(actions);
3497
- + WRITE_BOOL_FIELD(replace);
3498
- +}
3499
- +
3500
- +static void
3501
- +_outNotifyStmt(StringInfo str, const NotifyStmt *node)
3502
- +{
3503
- + WRITE_NODE_TYPE("NOTIFYSTMT");
3504
- +
3505
- + WRITE_STRING_FIELD(conditionname);
3506
- + WRITE_STRING_FIELD(payload);
3507
- +}
3508
- +
3509
- +static void
3510
- +_outListenStmt(StringInfo str, const ListenStmt *node)
3511
- +{
3512
- + WRITE_NODE_TYPE("LISTENSTMT");
3513
- +
3514
- + WRITE_STRING_FIELD(conditionname);
3515
- +}
3516
- +
3517
- +static void
3518
- +_outUnlistenStmt(StringInfo str, const UnlistenStmt *node)
3519
- +{
3520
- + WRITE_NODE_TYPE("UNLISTENSTMT");
3521
- +
3522
- + WRITE_STRING_FIELD(conditionname);
3523
- +}
3524
- +
3525
- +static void
3526
- +_outTransactionStmt(StringInfo str, const TransactionStmt *node)
3527
- +{
3528
- + WRITE_NODE_TYPE("TRANSACTION");
3529
- +
3530
- + WRITE_ENUM_FIELD(kind, TransactionStmtKind);
3531
- + WRITE_NODE_FIELD(options);
3532
- + WRITE_STRING_FIELD(gid);
3533
- +}
3534
- +
3535
- +static void
3536
- +_outViewStmt(StringInfo str, const ViewStmt *node)
3537
- +{
3538
- + WRITE_NODE_TYPE("VIEWSTMT");
3539
- +
3540
- + WRITE_NODE_FIELD(view);
3541
- + WRITE_NODE_FIELD(aliases);
3542
- + WRITE_NODE_FIELD(query);
3543
- + WRITE_BOOL_FIELD(replace);
3544
- + WRITE_NODE_FIELD(options);
3545
- + WRITE_ENUM_FIELD(withCheckOption, ViewCheckOption);
3546
- +}
3547
- +
3548
- +static void
3549
- +_outLoadStmt(StringInfo str, const LoadStmt *node)
3550
- +{
3551
- + WRITE_NODE_TYPE("LOADSTMT");
3552
- +
3553
- + WRITE_STRING_FIELD(filename);
3554
- +}
3555
- +
3556
- +static void
3557
- +_outCreateDomainStmt(StringInfo str, const CreateDomainStmt *node)
3558
- +{
3559
- + WRITE_NODE_TYPE("CREATEDOMAINSTMT");
3560
- +
3561
- + WRITE_NODE_FIELD(domainname);
3562
- + WRITE_NODE_FIELD(typeName);
3563
- + WRITE_NODE_FIELD(collClause);
3564
- + WRITE_NODE_FIELD(constraints);
3565
- +}
3566
- +
3567
- +static void
3568
- +_outCreatedbStmt(StringInfo str, const CreatedbStmt *node)
3569
- +{
3570
- + WRITE_NODE_TYPE("CREATEDBSTMT");
3571
- +
3572
- + WRITE_STRING_FIELD(dbname);
3573
- + WRITE_NODE_FIELD(options);
3574
- +}
3575
- +
3576
- +static void
3577
- +_outDropdbStmt(StringInfo str, const DropdbStmt *node)
3578
- +{
3579
- + WRITE_NODE_TYPE("DROPDBSTMT");
3580
- +
3581
- + WRITE_STRING_FIELD(dbname);
3582
- + WRITE_BOOL_FIELD(missing_ok);
3583
- +}
3584
- +
3585
- +static void
3586
- +_outVacuumStmt(StringInfo str, const VacuumStmt *node)
3587
- +{
3588
- + WRITE_NODE_TYPE("VACUUM");
3589
- +
3590
- + WRITE_ENUM_FIELD(options, VacuumOption);
3591
- + WRITE_INT_FIELD(freeze_min_age);
3592
- + WRITE_INT_FIELD(freeze_table_age);
3593
- + WRITE_INT_FIELD(multixact_freeze_min_age);
3594
- + WRITE_INT_FIELD(multixact_freeze_table_age);
3595
- + WRITE_NODE_FIELD(relation);
3596
- + WRITE_NODE_FIELD(va_cols);
3597
- +}
3598
- +
3599
- +static void
3600
- +_outExplainStmt(StringInfo str, const ExplainStmt *node)
3601
- +{
3602
- + WRITE_NODE_TYPE("EXPLAIN");
3603
- +
3604
- + WRITE_NODE_FIELD(query);
3605
- + WRITE_NODE_FIELD(options);
3606
- +}
3607
- +
3608
- +static void
3609
- +_outCreateTableAsStmt(StringInfo str, const CreateTableAsStmt *node)
3610
- +{
3611
- + WRITE_NODE_TYPE("CREATE TABLE AS");
3612
- +
3613
- + WRITE_NODE_FIELD(query);
3614
- + WRITE_NODE_FIELD(into);
3615
- + WRITE_ENUM_FIELD(relkind, ObjectType);
3616
- + WRITE_BOOL_FIELD(is_select_into);
3617
- +}
3618
- +
3619
- +static void
3620
- +_outCreateSeqStmt(StringInfo str, const CreateSeqStmt *node)
3621
- +{
3622
- + WRITE_NODE_TYPE("CREATESEQSTMT");
3623
- +
3624
- + WRITE_NODE_FIELD(sequence);
3625
- + WRITE_NODE_FIELD(options);
3626
- + WRITE_OID_FIELD(ownerId);
3627
- +}
3628
- +
3629
- +static void
3630
- +_outAlterSeqStmt(StringInfo str, const AlterSeqStmt *node)
3631
- +{
3632
- + WRITE_NODE_TYPE("ALTERSEQSTMT");
3633
- +
3634
- + WRITE_NODE_FIELD(sequence);
3635
- + WRITE_NODE_FIELD(options);
3636
- + WRITE_BOOL_FIELD(missing_ok);
3637
- +}
3638
- +
3639
- +static void
3640
- +_outVariableSetStmt(StringInfo str, const VariableSetStmt *node)
3641
- +{
3642
- + WRITE_NODE_TYPE("SET");
3643
- +
3644
- + WRITE_ENUM_FIELD(kind, VariableSetKind);
3645
- + WRITE_STRING_FIELD(name);
3646
- + WRITE_NODE_FIELD(args);
3647
- + WRITE_BOOL_FIELD(is_local);
3648
- +}
3649
- +
3650
- +static void
3651
- +_outVariableShowStmt(StringInfo str, const VariableShowStmt *node)
3652
- +{
3653
- + WRITE_NODE_TYPE("SHOW");
3654
- +
3655
- + WRITE_STRING_FIELD(name);
3656
- +}
3657
- +
3658
- +static void
3659
- +_outDiscardStmt(StringInfo str, const DiscardStmt *node)
3660
- +{
3661
- + WRITE_NODE_TYPE("DISCARDSTMT");
3662
- +
3663
- + WRITE_ENUM_FIELD(target, DiscardMode);
3664
- +}
3665
- +
3666
- +static void
3667
- +_outCreateTrigStmt(StringInfo str, const CreateTrigStmt *node)
3668
- +{
3669
- + WRITE_NODE_TYPE("CREATETRIGSTMT");
3670
- +
3671
- + WRITE_STRING_FIELD(trigname);
3672
- + WRITE_NODE_FIELD(relation);
3673
- + WRITE_NODE_FIELD(funcname);
3674
- + WRITE_NODE_FIELD(args);
3675
- + WRITE_BOOL_FIELD(row);
3676
- + WRITE_INT_FIELD(timing);
3677
- + WRITE_INT_FIELD(events);
3678
- + WRITE_NODE_FIELD(columns);
3679
- + WRITE_NODE_FIELD(whenClause);
3680
- + WRITE_BOOL_FIELD(isconstraint);
3681
- + WRITE_BOOL_FIELD(deferrable);
3682
- + WRITE_BOOL_FIELD(initdeferred);
3683
- + WRITE_NODE_FIELD(constrrel);
3684
- +}
3685
- +
3686
- +static void
3687
- +_outCreatePLangStmt(StringInfo str, const CreatePLangStmt *node)
3688
- +{
3689
- + WRITE_NODE_TYPE("CREATEPLANGSTMT");
3690
- +
3691
- + WRITE_BOOL_FIELD(replace);
3692
- + WRITE_STRING_FIELD(plname);
3693
- + WRITE_NODE_FIELD(plhandler);
3694
- + WRITE_NODE_FIELD(plinline);
3695
- + WRITE_NODE_FIELD(plvalidator);
3696
- + WRITE_BOOL_FIELD(pltrusted);
3697
- +}
3698
- +
3699
- +static void
3700
- +_outCreateRoleStmt(StringInfo str, const CreateRoleStmt *node)
3701
- +{
3702
- + WRITE_NODE_TYPE("CREATEROLESTMT");
3703
- +
3704
- + WRITE_ENUM_FIELD(stmt_type, RoleStmtType);
3705
- + WRITE_STRING_FIELD(role);
3706
- + WRITE_NODE_FIELD(options);
3707
- +}
3708
- +
3709
- +static void
3710
- +_outAlterRoleStmt(StringInfo str, const AlterRoleStmt *node)
3711
- +{
3712
- + WRITE_NODE_TYPE("ALTERROLESTMT");
3713
- +
3714
- + WRITE_STRING_FIELD(role);
3715
- + WRITE_NODE_FIELD(options);
3716
- + WRITE_INT_FIELD(action);
3717
- +}
3718
- +
3719
- +static void
3720
- +_outDropRoleStmt(StringInfo str, const DropRoleStmt *node)
3721
- +{
3722
- + WRITE_NODE_TYPE("DROPROLESTMT");
3723
- +
3724
- + WRITE_NODE_FIELD(roles);
3725
- + WRITE_BOOL_FIELD(missing_ok);
3726
- +}
3727
- +
3728
- +static void
3729
- +_outLockStmt(StringInfo str, const LockStmt *node)
3730
- +{
3731
- + WRITE_NODE_TYPE("LOCK");
3732
- +
3733
- + WRITE_NODE_FIELD(relations);
3734
- + WRITE_INT_FIELD(mode);
3735
- + WRITE_BOOL_FIELD(nowait);
3736
- +}
3737
- +
3738
- +static void
3739
- +_outConstraintsSetStmt(StringInfo str, const ConstraintsSetStmt *node)
3740
- +{
3741
- + WRITE_NODE_TYPE("CONSTRAINTSSETSTMT");
3742
- +
3743
- + WRITE_NODE_FIELD(constraints);
3744
- + WRITE_BOOL_FIELD(deferred);
3745
- +}
3746
- +
3747
- +static void
3748
- +_outReindexStmt(StringInfo str, const ReindexStmt *node)
3749
- +{
3750
- + WRITE_NODE_TYPE("REINDEXSTMT");
3751
- +
3752
- + WRITE_ENUM_FIELD(kind, ObjectType);
3753
- + WRITE_NODE_FIELD(relation);
3754
- + WRITE_STRING_FIELD(name);
3755
- + WRITE_BOOL_FIELD(do_system);
3756
- + WRITE_BOOL_FIELD(do_user);
3757
- +}
3758
- +
3759
- +static void
3760
- +_outCheckPointStmt(StringInfo str, const CheckPointStmt *node)
3761
- +{
3762
- + WRITE_NODE_TYPE("CHECKPOINT");
3763
- +
3764
- +}
3765
- +
3766
- +static void
3767
- +_outCreateSchemaStmt(StringInfo str, const CreateSchemaStmt *node)
3768
- +{
3769
- + WRITE_NODE_TYPE("CREATE SCHEMA");
3770
- +
3771
- + WRITE_STRING_FIELD(schemaname);
3772
- + WRITE_STRING_FIELD(authid);
3773
- + WRITE_NODE_FIELD(schemaElts);
3774
- + WRITE_BOOL_FIELD(if_not_exists);
3775
- +}
3776
- +
3777
- +static void
3778
- +_outAlterDatabaseStmt(StringInfo str, const AlterDatabaseStmt *node)
3779
- +{
3780
- + WRITE_NODE_TYPE("ALTERDATABASESTMT");
3781
- +
3782
- + WRITE_STRING_FIELD(dbname);
3783
- + WRITE_NODE_FIELD(options);
3784
- +}
3785
- +
3786
- +static void
3787
- +_outAlterDatabaseSetStmt(StringInfo str, const AlterDatabaseSetStmt *node)
3788
- +{
3789
- + WRITE_NODE_TYPE("ALTERDATABASESETSTMT");
3790
- +
3791
- + WRITE_STRING_FIELD(dbname);
3792
- + WRITE_NODE_FIELD(setstmt);
3793
- +}
3794
- +
3795
- +static void
3796
- +_outAlterRoleSetStmt(StringInfo str, const AlterRoleSetStmt *node)
3797
- +{
3798
- + WRITE_NODE_TYPE("ALTERROLESETSTMT");
3799
- +
3800
- + WRITE_STRING_FIELD(role);
3801
- + WRITE_STRING_FIELD(database);
3802
- + WRITE_NODE_FIELD(setstmt);
3803
- +}
3804
- +
3805
- +static void
3806
- +_outCreateConversionStmt(StringInfo str, const CreateConversionStmt *node)
3807
- +{
3808
- + WRITE_NODE_TYPE("CREATECONVERSIONSTMT");
3809
- +
3810
- + WRITE_NODE_FIELD(conversion_name);
3811
- + WRITE_STRING_FIELD(for_encoding_name);
3812
- + WRITE_STRING_FIELD(to_encoding_name);
3813
- + WRITE_NODE_FIELD(func_name);
3814
- + WRITE_BOOL_FIELD(def);
3815
- +}
3816
- +
3817
- +static void
3818
- +_outCreateCastStmt(StringInfo str, const CreateCastStmt *node)
3819
- +{
3820
- + WRITE_NODE_TYPE("CREATECASTSTMT");
3821
- +
3822
- + WRITE_NODE_FIELD(sourcetype);
3823
- + WRITE_NODE_FIELD(targettype);
3824
- + WRITE_NODE_FIELD(func);
3825
- + WRITE_ENUM_FIELD(context, CoercionContext);
3826
- + WRITE_BOOL_FIELD(inout);
3827
- +}
3828
- +
3829
- +static void
3830
- +_outCreateOpClassStmt(StringInfo str, const CreateOpClassStmt *node)
3831
- +{
3832
- + WRITE_NODE_TYPE("CREATEOPCLASSSTMT");
3833
- +
3834
- + WRITE_NODE_FIELD(opclassname);
3835
- + WRITE_NODE_FIELD(opfamilyname);
3836
- + WRITE_STRING_FIELD(amname);
3837
- + WRITE_NODE_FIELD(datatype);
3838
- + WRITE_NODE_FIELD(items);
3839
- + WRITE_BOOL_FIELD(isDefault);
3840
- +}
3841
- +
3842
- +static void
3843
- +_outCreateOpFamilyStmt(StringInfo str, const CreateOpFamilyStmt *node)
3844
- +{
3845
- + WRITE_NODE_TYPE("CREATEOPFAMILYSTMT");
3846
- +
3847
- + WRITE_NODE_FIELD(opfamilyname);
3848
- + WRITE_STRING_FIELD(amname);
3849
- +}
3850
- +
3851
- +static void
3852
- +_outAlterOpFamilyStmt(StringInfo str, const AlterOpFamilyStmt *node)
3853
- +{
3854
- + WRITE_NODE_TYPE("ALTEROPFAMILYSTMT");
3855
- +
3856
- + WRITE_NODE_FIELD(opfamilyname);
3857
- + WRITE_STRING_FIELD(amname);
3858
- + WRITE_BOOL_FIELD(isDrop);
3859
- + WRITE_NODE_FIELD(items);
3860
- +}
3861
- +
3862
- +static void
3863
- +_outPrepareStmt(StringInfo str, const PrepareStmt *node)
3864
- +{
3865
- + WRITE_NODE_TYPE("PREPARESTMT");
3866
- +
3867
- + WRITE_STRING_FIELD(name);
3868
- + WRITE_NODE_FIELD(argtypes);
3869
- + WRITE_NODE_FIELD(query);
3870
- +}
3871
- +
3872
- +static void
3873
- +_outExecuteStmt(StringInfo str, const ExecuteStmt *node)
3874
- +{
3875
- + WRITE_NODE_TYPE("EXECUTESTMT");
3876
- +
3877
- + WRITE_STRING_FIELD(name);
3878
- + WRITE_NODE_FIELD(params);
3879
- +}
3880
- +
3881
- +static void
3882
- +_outDeallocateStmt(StringInfo str, const DeallocateStmt *node)
3883
- +{
3884
- + WRITE_NODE_TYPE("DEALLOCATESTMT");
3885
- +
3886
- + WRITE_STRING_FIELD(name);
3887
- +}
3888
- +
3889
- +static void
3890
- +_outDeclareCursorStmt(StringInfo str, const DeclareCursorStmt *node)
3891
- +{
3892
- + WRITE_NODE_TYPE("DECLARECURSOR");
3893
- +
3894
- + WRITE_STRING_FIELD(portalname);
3895
- + WRITE_INT_FIELD(options);
3896
- + WRITE_NODE_FIELD(query);
3897
- +}
3898
- +
3899
- +static void
3900
- +_outCreateTableSpaceStmt(StringInfo str, const CreateTableSpaceStmt *node)
3901
- +{
3902
- + WRITE_NODE_TYPE("CREATETABLESPACESTMT");
3903
- +
3904
- + WRITE_STRING_FIELD(tablespacename);
3905
- + WRITE_STRING_FIELD(owner);
3906
- + WRITE_STRING_FIELD(location);
3907
- + WRITE_NODE_FIELD(options);
3908
- +}
3909
- +
3910
- +static void
3911
- +_outDropTableSpaceStmt(StringInfo str, const DropTableSpaceStmt *node)
3912
- +{
3913
- + WRITE_NODE_TYPE("DROPTABLESPACESTMT");
3914
- +
3915
- + WRITE_STRING_FIELD(tablespacename);
3916
- + WRITE_BOOL_FIELD(missing_ok);
3917
- +}
3918
- +
3919
- +static void
3920
- +_outAlterObjectSchemaStmt(StringInfo str, const AlterObjectSchemaStmt *node)
3921
- +{
3922
- + WRITE_NODE_TYPE("ALTEROBJECTSCHEMASTMT");
3923
- +
3924
- + WRITE_ENUM_FIELD(objectType, ObjectType);
3925
- + WRITE_NODE_FIELD(relation);
3926
- + WRITE_NODE_FIELD(object);
3927
- + WRITE_NODE_FIELD(objarg);
3928
- + WRITE_STRING_FIELD(newschema);
3929
- + WRITE_BOOL_FIELD(missing_ok);
3930
- +}
3931
- +
3932
- +static void
3933
- +_outAlterOwnerStmt(StringInfo str, const AlterOwnerStmt *node)
3934
- +{
3935
- + WRITE_NODE_TYPE("ALTEROWNERSTMT");
3936
- +
3937
- + WRITE_ENUM_FIELD(objectType, ObjectType);
3938
- + WRITE_NODE_FIELD(relation);
3939
- + WRITE_NODE_FIELD(object);
3940
- + WRITE_NODE_FIELD(objarg);
3941
- + WRITE_STRING_FIELD(newowner);
3942
- +}
3943
- +
3944
- +static void
3945
- +_outDropOwnedStmt(StringInfo str, const DropOwnedStmt *node)
3946
- +{
3947
- + WRITE_NODE_TYPE("DROPOWNEDSTMT");
3948
- +
3949
- + WRITE_NODE_FIELD(roles);
3950
- + WRITE_ENUM_FIELD(behavior, DropBehavior);
3951
- +}
3952
- +
3953
- +static void
3954
- +_outReassignOwnedStmt(StringInfo str, const ReassignOwnedStmt *node)
3955
- +{
3956
- + WRITE_NODE_TYPE("REASSIGNOWNEDSTMT");
3957
- +
3958
- + WRITE_NODE_FIELD(roles);
3959
- + WRITE_STRING_FIELD(newrole);
3960
- +}
3961
- +
3962
- +static void
3963
- +_outCompositeTypeStmt(StringInfo str, const CompositeTypeStmt *node)
3964
- +{
3965
- + WRITE_NODE_TYPE("COMPOSITETYPESTMT");
3966
- +
3967
- + WRITE_NODE_FIELD(typevar);
3968
- + WRITE_NODE_FIELD(coldeflist);
3969
- +}
3970
- +
3971
- +static void
3972
- +_outCreateEnumStmt(StringInfo str, const CreateEnumStmt *node)
3973
- +{
3974
- + WRITE_NODE_TYPE("CREATEENUMSTMT");
3975
- +
3976
- + WRITE_NODE_FIELD(typeName);
3977
- + WRITE_NODE_FIELD(vals);
3978
- +}
3979
- +
3980
- +static void
3981
- +_outCreateRangeStmt(StringInfo str, const CreateRangeStmt *node)
3982
- +{
3983
- + WRITE_NODE_TYPE("CREATERANGESTMT");
3984
- +
3985
- + WRITE_NODE_FIELD(typeName);
3986
- + WRITE_NODE_FIELD(params);
3987
- +}
3988
- +
3989
- +static void
3990
- +_outAlterEnumStmt(StringInfo str, const AlterEnumStmt *node)
3991
- +{
3992
- + WRITE_NODE_TYPE("ALTERENUMSTMT");
3993
- +
3994
- + WRITE_NODE_FIELD(typeName);
3995
- + WRITE_STRING_FIELD(newVal);
3996
- + WRITE_STRING_FIELD(newValNeighbor);
3997
- + WRITE_BOOL_FIELD(newValIsAfter);
3998
- + WRITE_BOOL_FIELD(skipIfExists);
3999
- +}
4000
- +
4001
- +static void
4002
- +_outAlterTSDictionaryStmt(StringInfo str, const AlterTSDictionaryStmt *node)
4003
- +{
4004
- + WRITE_NODE_TYPE("ALTERTSDICTIONARYSTMT");
4005
- +
4006
- + WRITE_NODE_FIELD(dictname);
4007
- + WRITE_NODE_FIELD(options);
4008
- +}
4009
- +
4010
- +static void
4011
- +_outAlterTSConfigurationStmt(StringInfo str, const AlterTSConfigurationStmt *node)
4012
- +{
4013
- + WRITE_NODE_TYPE("ALTERTSCONFIGURATIONSTMT");
4014
- +
4015
- + WRITE_NODE_FIELD(cfgname);
4016
- + WRITE_NODE_FIELD(tokentype);
4017
- + WRITE_NODE_FIELD(dicts);
4018
- + WRITE_BOOL_FIELD(override);
4019
- + WRITE_BOOL_FIELD(replace);
4020
- + WRITE_BOOL_FIELD(missing_ok);
4021
- +}
4022
- +
4023
- +static void
4024
- +_outCreateFdwStmt(StringInfo str, const CreateFdwStmt *node)
4025
- +{
4026
- + WRITE_NODE_TYPE("CREATEFDWSTMT");
4027
- +
4028
- + WRITE_STRING_FIELD(fdwname);
4029
- + WRITE_NODE_FIELD(func_options);
4030
- + WRITE_NODE_FIELD(options);
4031
- +}
4032
- +
4033
- +static void
4034
- +_outAlterFdwStmt(StringInfo str, const AlterFdwStmt *node)
4035
- +{
4036
- + WRITE_NODE_TYPE("ALTERFDWSTMT");
4037
- +
4038
- + WRITE_STRING_FIELD(fdwname);
4039
- + WRITE_NODE_FIELD(func_options);
4040
- + WRITE_NODE_FIELD(options);
4041
- +}
4042
- +
4043
- +static void
4044
- +_outCreateForeignServerStmt(StringInfo str, const CreateForeignServerStmt *node)
4045
- +{
4046
- + WRITE_NODE_TYPE("CREATEFOREIGNSERVERSTMT");
4047
- +
4048
- + WRITE_STRING_FIELD(servername);
4049
- + WRITE_STRING_FIELD(servertype);
4050
- + WRITE_STRING_FIELD(version);
4051
- + WRITE_STRING_FIELD(fdwname);
4052
- + WRITE_NODE_FIELD(options);
4053
- +}
4054
- +
4055
- +static void
4056
- +_outAlterForeignServerStmt(StringInfo str, const AlterForeignServerStmt *node)
4057
- +{
4058
- + WRITE_NODE_TYPE("ALTERFOREIGNSERVERSTMT");
4059
- +
4060
- + WRITE_STRING_FIELD(servername);
4061
- + WRITE_STRING_FIELD(version);
4062
- + WRITE_NODE_FIELD(options);
4063
- + WRITE_BOOL_FIELD(has_version);
4064
- +}
4065
- +
4066
- +static void
4067
- +_outCreateUserMappingStmt(StringInfo str, const CreateUserMappingStmt *node)
4068
- +{
4069
- + WRITE_NODE_TYPE("CREATEUSERMAPPINGSTMT");
4070
- +
4071
- + WRITE_STRING_FIELD(username);
4072
- + WRITE_STRING_FIELD(servername);
4073
- + WRITE_NODE_FIELD(options);
4074
- +}
4075
- +
4076
- +static void
4077
- +_outAlterUserMappingStmt(StringInfo str, const AlterUserMappingStmt *node)
4078
- +{
4079
- + WRITE_NODE_TYPE("ALTERUSERMAPPINGSTMT");
4080
- +
4081
- + WRITE_STRING_FIELD(username);
4082
- + WRITE_STRING_FIELD(servername);
4083
- + WRITE_NODE_FIELD(options);
4084
- +}
4085
- +
4086
- +static void
4087
- +_outDropUserMappingStmt(StringInfo str, const DropUserMappingStmt *node)
4088
- +{
4089
- + WRITE_NODE_TYPE("DROPUSERMAPPINGSTMT");
4090
- +
4091
- + WRITE_STRING_FIELD(username);
4092
- + WRITE_STRING_FIELD(servername);
4093
- + WRITE_BOOL_FIELD(missing_ok);
4094
- +}
4095
- +
4096
- +static void
4097
- +_outAlterTableSpaceOptionsStmt(StringInfo str, const AlterTableSpaceOptionsStmt *node)
4098
- +{
4099
- + WRITE_NODE_TYPE("ALTERTABLESPACEOPTIONSSTMT");
4100
- +
4101
- + WRITE_STRING_FIELD(tablespacename);
4102
- + WRITE_NODE_FIELD(options);
4103
- + WRITE_BOOL_FIELD(isReset);
4104
- +}
4105
- +
4106
- +static void
4107
- +_outAlterTableMoveAllStmt(StringInfo str, const AlterTableMoveAllStmt *node)
4108
- +{
4109
- + WRITE_NODE_TYPE("ALTERTABLEMOVEALLSTMT");
4110
- +
4111
- + WRITE_STRING_FIELD(orig_tablespacename);
4112
- + WRITE_ENUM_FIELD(objtype, ObjectType);
4113
- + WRITE_NODE_FIELD(roles);
4114
- + WRITE_STRING_FIELD(new_tablespacename);
4115
- + WRITE_BOOL_FIELD(nowait);
4116
- +}
4117
- +
4118
- +static void
4119
- +_outSecLabelStmt(StringInfo str, const SecLabelStmt *node)
4120
- +{
4121
- + WRITE_NODE_TYPE("SECLABELSTMT");
4122
- +
4123
- + WRITE_ENUM_FIELD(objtype, ObjectType);
4124
- + WRITE_NODE_FIELD(objname);
4125
- + WRITE_NODE_FIELD(objargs);
4126
- + WRITE_STRING_FIELD(provider);
4127
- + WRITE_STRING_FIELD(label);
4128
- +}
4129
- +
4130
- +static void
4131
- +_outCreateForeignTableStmt(StringInfo str, const CreateForeignTableStmt *node)
4132
- +{
4133
- + WRITE_NODE_TYPE("CREATEFOREIGNTABLESTMT");
4134
- +
4135
- + _outCreateStmtInfo(str, (const CreateStmt *) node);
4136
- +
4137
- + WRITE_STRING_FIELD(servername);
4138
- + WRITE_NODE_FIELD(options);
4139
- +}
4140
- +
4141
- +static void
4142
- +_outCreateExtensionStmt(StringInfo str, const CreateExtensionStmt *node)
4143
- +{
4144
- + WRITE_NODE_TYPE("CREATEEXTENSIONSTMT");
4145
- +
4146
- + WRITE_STRING_FIELD(extname);
4147
- + WRITE_BOOL_FIELD(if_not_exists);
4148
- + WRITE_NODE_FIELD(options);
4149
- +}
4150
- +
4151
- +static void
4152
- +_outAlterExtensionStmt(StringInfo str, const AlterExtensionStmt *node)
4153
- +{
4154
- + WRITE_NODE_TYPE("ALTEREXTENSIONSTMT");
4155
- +
4156
- + WRITE_STRING_FIELD(extname);
4157
- + WRITE_NODE_FIELD(options);
4158
- +}
4159
- +
4160
- +static void
4161
- +_outAlterExtensionContentsStmt(StringInfo str, const AlterExtensionContentsStmt *node)
4162
- +{
4163
- + WRITE_NODE_TYPE("ALTEREXTENSIONCONTENTSSTMT");
4164
- +
4165
- + WRITE_STRING_FIELD(extname);
4166
- + WRITE_INT_FIELD(action);
4167
- + WRITE_ENUM_FIELD(objtype, ObjectType);
4168
- + WRITE_NODE_FIELD(objname);
4169
- + WRITE_NODE_FIELD(objargs);
4170
- +}
4171
- +
4172
- +static void
4173
- +_outCreateEventTrigStmt(StringInfo str, const CreateEventTrigStmt *node)
4174
- +{
4175
- + WRITE_NODE_TYPE("CREATEEVENTTRIGSTMT");
4176
- +
4177
- + WRITE_STRING_FIELD(trigname);
4178
- + WRITE_STRING_FIELD(eventname);
4179
- + WRITE_NODE_FIELD(whenclause);
4180
- + WRITE_NODE_FIELD(funcname);
4181
- +}
4182
- +
4183
- +static void
4184
- +_outAlterEventTrigStmt(StringInfo str, const AlterEventTrigStmt *node)
4185
- +{
4186
- + WRITE_NODE_TYPE("ALTEREVENTTRIGSTMT");
4187
- +
4188
- + WRITE_STRING_FIELD(trigname);
4189
- + WRITE_CHAR_FIELD(tgenabled);
4190
- +}
4191
- +
4192
- +static void
4193
- +_outRefreshMatViewStmt(StringInfo str, const RefreshMatViewStmt *node)
4194
- +{
4195
- + WRITE_NODE_TYPE("REFRESHMATVIEWSTMT");
4196
- +
4197
- + WRITE_BOOL_FIELD(concurrent);
4198
- + WRITE_BOOL_FIELD(skipData);
4199
- + WRITE_NODE_FIELD(relation);
4200
- +}
4201
- +
4202
- +static void
4203
- +_outReplicaIdentityStmt(StringInfo str, const ReplicaIdentityStmt *node)
4204
- +{
4205
- + WRITE_NODE_TYPE("REPLICAIDENTITYSTMT");
4206
- +
4207
- + WRITE_CHAR_FIELD(identity_type);
4208
- + WRITE_STRING_FIELD(name);
4209
- +}
4210
- +
4211
- +static void
4212
- +_outAlterSystemStmt(StringInfo str, const AlterSystemStmt *node)
4213
- +{
4214
- + WRITE_NODE_TYPE("ALTERSYSTEMSTMT");
4215
- +
4216
- + WRITE_NODE_FIELD(setstmt);
4217
- +}
4218
- +
4219
- +static void
4220
- +_outColumnRef(StringInfo str, const ColumnRef *node)
4221
- +{
4222
- + WRITE_NODE_TYPE("COLUMNREF");
4223
- +
4224
- + WRITE_NODE_FIELD(fields);
4225
- + WRITE_LOCATION_FIELD(location);
4226
- +}
4227
- +
4228
- +static void
4229
- +_outParamRef(StringInfo str, const ParamRef *node)
4230
- +{
4231
- + WRITE_NODE_TYPE("PARAMREF");
4232
- +
4233
- + WRITE_INT_FIELD(number);
4234
- + WRITE_LOCATION_FIELD(location);
4235
- +}
4236
- +
4237
- +static void
4238
- +_outFuncCall(StringInfo str, const FuncCall *node)
4239
- +{
4240
- + WRITE_NODE_TYPE("FUNCCALL");
4241
- +
4242
- + WRITE_NODE_FIELD(funcname);
4243
- + WRITE_NODE_FIELD(args);
4244
- + WRITE_NODE_FIELD(agg_order);
4245
- + WRITE_NODE_FIELD(agg_filter);
4246
- + WRITE_BOOL_FIELD(agg_within_group);
4247
- + WRITE_BOOL_FIELD(agg_star);
4248
- + WRITE_BOOL_FIELD(agg_distinct);
4249
- + WRITE_BOOL_FIELD(func_variadic);
4250
- + WRITE_NODE_FIELD(over);
4251
- + WRITE_LOCATION_FIELD(location);
4252
- +}
4253
- +
4254
- +static void
4255
- +_outA_Star(StringInfo str, const A_Star *node)
4256
- +{
4257
- + WRITE_NODE_TYPE("A_STAR");
4258
- +
4259
- +}
4260
- +
4261
- +static void
4262
- +_outA_Indices(StringInfo str, const A_Indices *node)
4263
- +{
4264
- + WRITE_NODE_TYPE("A_INDICES");
4265
- +
4266
- + WRITE_NODE_FIELD(lidx);
4267
- + WRITE_NODE_FIELD(uidx);
4268
- +}
4269
- +
4270
- +static void
4271
- +_outA_Indirection(StringInfo str, const A_Indirection *node)
4272
- +{
4273
- + WRITE_NODE_TYPE("A_INDIRECTION");
4274
- +
4275
- + WRITE_NODE_FIELD(arg);
4276
- + WRITE_NODE_FIELD(indirection);
4277
- +}
4278
- +
4279
- +static void
4280
- +_outA_ArrayExpr(StringInfo str, const A_ArrayExpr *node)
4281
- +{
4282
- + WRITE_NODE_TYPE("A_ARRAYEXPR");
4283
- +
4284
- + WRITE_NODE_FIELD(elements);
4285
- + WRITE_LOCATION_FIELD(location);
4286
- +}
4287
- +
4288
- +static void
4289
- +_outResTarget(StringInfo str, const ResTarget *node)
4290
- +{
4291
- + WRITE_NODE_TYPE("RESTARGET");
4292
- +
4293
- + WRITE_STRING_FIELD(name);
4294
- + WRITE_NODE_FIELD(indirection);
4295
- + WRITE_NODE_FIELD(val);
4296
- + WRITE_LOCATION_FIELD(location);
4297
- +}
4298
- +
4299
- +static void
4300
- +_outTypeCast(StringInfo str, const TypeCast *node)
4301
- +{
4302
- + WRITE_NODE_TYPE("TYPECAST");
4303
- +
4304
- + WRITE_NODE_FIELD(arg);
4305
- + WRITE_NODE_FIELD(typeName);
4306
- + WRITE_LOCATION_FIELD(location);
4307
- +}
4308
- +
4309
- +static void
4310
- +_outCollateClause(StringInfo str, const CollateClause *node)
4311
- +{
4312
- + WRITE_NODE_TYPE("COLLATECLAUSE");
4313
- +
4314
- + WRITE_NODE_FIELD(arg);
4315
- + WRITE_NODE_FIELD(collname);
4316
- + WRITE_LOCATION_FIELD(location);
4317
- +}
4318
- +
4319
- +static void
4320
- +_outSortBy(StringInfo str, const SortBy *node)
4321
- +{
4322
- + WRITE_NODE_TYPE("SORTBY");
4323
- +
4324
- + WRITE_NODE_FIELD(node);
4325
- + WRITE_ENUM_FIELD(sortby_dir, SortByDir);
4326
- + WRITE_ENUM_FIELD(sortby_nulls, SortByNulls);
4327
- + WRITE_NODE_FIELD(useOp);
4328
- + WRITE_LOCATION_FIELD(location);
4329
- +}
4330
- +
4331
- +static void
4332
- +_outWindowDef(StringInfo str, const WindowDef *node)
4333
- +{
4334
- + WRITE_NODE_TYPE("WINDOWDEF");
4335
- +
4336
- + WRITE_STRING_FIELD(name);
4337
- + WRITE_STRING_FIELD(refname);
4338
- + WRITE_NODE_FIELD(partitionClause);
4339
- + WRITE_NODE_FIELD(orderClause);
4340
- + WRITE_INT_FIELD(frameOptions);
4341
- + WRITE_NODE_FIELD(startOffset);
4342
- + WRITE_NODE_FIELD(endOffset);
4343
- + WRITE_LOCATION_FIELD(location);
4344
- +}
4345
- +
4346
- +static void
4347
- +_outRangeSubselect(StringInfo str, const RangeSubselect *node)
4348
- +{
4349
- + WRITE_NODE_TYPE("RANGESUBSELECT");
4350
- +
4351
- + WRITE_BOOL_FIELD(lateral);
4352
- + WRITE_NODE_FIELD(subquery);
4353
- + WRITE_NODE_FIELD(alias);
4354
- +}
4355
- +
4356
- +static void
4357
- +_outRangeFunction(StringInfo str, const RangeFunction *node)
4358
- +{
4359
- + WRITE_NODE_TYPE("RANGEFUNCTION");
4360
- +
4361
- + WRITE_BOOL_FIELD(lateral);
4362
- + WRITE_BOOL_FIELD(ordinality);
4363
- + WRITE_BOOL_FIELD(is_rowsfrom);
4364
- + WRITE_NODE_FIELD(functions);
4365
- + WRITE_NODE_FIELD(alias);
4366
- + WRITE_NODE_FIELD(coldeflist);
4367
- +}
4368
- +
4369
- +static void
4370
- +_outTypeName(StringInfo str, const TypeName *node)
4371
- +{
4372
- + WRITE_NODE_TYPE("TYPENAME");
4373
- +
4374
- + WRITE_NODE_FIELD(names);
4375
- + WRITE_OID_FIELD(typeOid);
4376
- + WRITE_BOOL_FIELD(setof);
4377
- + WRITE_BOOL_FIELD(pct_type);
4378
- + WRITE_NODE_FIELD(typmods);
4379
- + WRITE_INT_FIELD(typemod);
4380
- + WRITE_NODE_FIELD(arrayBounds);
4381
- + WRITE_LOCATION_FIELD(location);
4382
- +}
4383
- +
4384
- +static void
4385
- +_outColumnDef(StringInfo str, const ColumnDef *node)
4386
- +{
4387
- + WRITE_NODE_TYPE("COLUMNDEF");
4388
- +
4389
- + WRITE_STRING_FIELD(colname);
4390
- + WRITE_NODE_FIELD(typeName);
4391
- + WRITE_INT_FIELD(inhcount);
4392
- + WRITE_BOOL_FIELD(is_local);
4393
- + WRITE_BOOL_FIELD(is_not_null);
4394
- + WRITE_BOOL_FIELD(is_from_type);
4395
- + WRITE_CHAR_FIELD(storage);
4396
- + WRITE_NODE_FIELD(raw_default);
4397
- + WRITE_NODE_FIELD(cooked_default);
4398
- + WRITE_NODE_FIELD(collClause);
4399
- + WRITE_OID_FIELD(collOid);
4400
- + WRITE_NODE_FIELD(constraints);
4401
- + WRITE_NODE_FIELD(fdwoptions);
4402
- + WRITE_LOCATION_FIELD(location);
4403
- +}
4404
- +
4405
- +static void
4406
- +_outIndexElem(StringInfo str, const IndexElem *node)
4407
- +{
4408
- + WRITE_NODE_TYPE("INDEXELEM");
4409
- +
4410
- + WRITE_STRING_FIELD(name);
4411
- + WRITE_NODE_FIELD(expr);
4412
- + WRITE_STRING_FIELD(indexcolname);
4413
- + WRITE_NODE_FIELD(collation);
4414
- + WRITE_NODE_FIELD(opclass);
4415
- + WRITE_ENUM_FIELD(ordering, SortByDir);
4416
- + WRITE_ENUM_FIELD(nulls_ordering, SortByNulls);
4417
- +}
4418
- +
4419
- +static void
4420
- +_outDefElem(StringInfo str, const DefElem *node)
4421
- +{
4422
- + WRITE_NODE_TYPE("DEFELEM");
4423
- +
4424
- + WRITE_STRING_FIELD(defnamespace);
4425
- + WRITE_STRING_FIELD(defname);
4426
- + WRITE_NODE_FIELD(arg);
4427
- + WRITE_ENUM_FIELD(defaction, DefElemAction);
4428
- +}
4429
- +
4430
- +static void
4431
- +_outRangeTblFunction(StringInfo str, const RangeTblFunction *node)
4432
- +{
4433
- + WRITE_NODE_TYPE("RANGETBLFUNCTION");
4434
- +
4435
- + WRITE_NODE_FIELD(funcexpr);
4436
- + WRITE_INT_FIELD(funccolcount);
4437
- + WRITE_NODE_FIELD(funccolnames);
4438
- + WRITE_NODE_FIELD(funccoltypes);
4439
- + WRITE_NODE_FIELD(funccoltypmods);
4440
- + WRITE_NODE_FIELD(funccolcollations);
4441
- + WRITE_BITMAPSET_FIELD(funcparams);
4442
- +}
4443
- +
4444
- +static void
4445
- +_outWithCheckOption(StringInfo str, const WithCheckOption *node)
4446
- +{
4447
- + WRITE_NODE_TYPE("WITHCHECKOPTION");
4448
- +
4449
- + WRITE_STRING_FIELD(viewname);
4450
- + WRITE_NODE_FIELD(qual);
4451
- + WRITE_BOOL_FIELD(cascaded);
4452
- +}
4453
- +
4454
- +static void
4455
- +_outSortGroupClause(StringInfo str, const SortGroupClause *node)
4456
- +{
4457
- + WRITE_NODE_TYPE("SORTGROUPCLAUSE");
4458
- +
4459
- + WRITE_UINT_FIELD(tleSortGroupRef);
4460
- + WRITE_OID_FIELD(eqop);
4461
- + WRITE_OID_FIELD(sortop);
4462
- + WRITE_BOOL_FIELD(nulls_first);
4463
- + WRITE_BOOL_FIELD(hashable);
4464
- +}
4465
- +
4466
- +static void
4467
- +_outWindowClause(StringInfo str, const WindowClause *node)
4468
- +{
4469
- + WRITE_NODE_TYPE("WINDOWCLAUSE");
4470
- +
4471
- + WRITE_STRING_FIELD(name);
4472
- + WRITE_STRING_FIELD(refname);
4473
- + WRITE_NODE_FIELD(partitionClause);
4474
- + WRITE_NODE_FIELD(orderClause);
4475
- + WRITE_INT_FIELD(frameOptions);
4476
- + WRITE_NODE_FIELD(startOffset);
4477
- + WRITE_NODE_FIELD(endOffset);
4478
- + WRITE_UINT_FIELD(winref);
4479
- + WRITE_BOOL_FIELD(copiedOrder);
4480
- +}
4481
- +
4482
- +static void
4483
- +_outPrivGrantee(StringInfo str, const PrivGrantee *node)
4484
- +{
4485
- + WRITE_NODE_TYPE("PRIVGRANTEE");
4486
- +
4487
- + WRITE_STRING_FIELD(rolname);
4488
- +}
4489
- +
4490
- +static void
4491
- +_outFuncWithArgs(StringInfo str, const FuncWithArgs *node)
4492
- +{
4493
- + WRITE_NODE_TYPE("FUNCWITHARGS");
4494
- +
4495
- + WRITE_NODE_FIELD(funcname);
4496
- + WRITE_NODE_FIELD(funcargs);
4497
- +}
4498
- +
4499
- +static void
4500
- +_outAccessPriv(StringInfo str, const AccessPriv *node)
4501
- +{
4502
- + WRITE_NODE_TYPE("ACCESSPRIV");
4503
- +
4504
- + WRITE_STRING_FIELD(priv_name);
4505
- + WRITE_NODE_FIELD(cols);
4506
- +}
4507
- +
4508
- +static void
4509
- +_outCreateOpClassItem(StringInfo str, const CreateOpClassItem *node)
4510
- +{
4511
- + WRITE_NODE_TYPE("CREATEOPCLASSITEM");
4512
- +
4513
- + WRITE_INT_FIELD(itemtype);
4514
- + WRITE_NODE_FIELD(name);
4515
- + WRITE_NODE_FIELD(args);
4516
- + WRITE_INT_FIELD(number);
4517
- + WRITE_NODE_FIELD(order_family);
4518
- + WRITE_NODE_FIELD(class_args);
4519
- + WRITE_NODE_FIELD(storedtype);
4520
- +}
4521
- +
4522
- +static void
4523
- +_outTableLikeClause(StringInfo str, const TableLikeClause *node)
4524
- +{
4525
- + WRITE_NODE_TYPE("TABLELIKECLAUSE");
4526
- +
4527
- + WRITE_NODE_FIELD(relation);
4528
- + WRITE_UINT_FIELD(options);
4529
- +}
4530
- +
4531
- +static void
4532
- +_outFunctionParameter(StringInfo str, const FunctionParameter *node)
4533
- +{
4534
- + WRITE_NODE_TYPE("FUNCTIONPARAMETER");
4535
- +
4536
- + WRITE_STRING_FIELD(name);
4537
- + WRITE_NODE_FIELD(argType);
4538
- + WRITE_ENUM_FIELD(mode, FunctionParameterMode);
4539
- + WRITE_NODE_FIELD(defexpr);
4540
- +}
4541
- +
4542
- +static void
4543
- +_outLockingClause(StringInfo str, const LockingClause *node)
4544
- +{
4545
- + WRITE_NODE_TYPE("LOCKINGCLAUSE");
4546
- +
4547
- + WRITE_NODE_FIELD(lockedRels);
4548
- + WRITE_ENUM_FIELD(strength, LockClauseStrength);
4549
- + WRITE_BOOL_FIELD(noWait);
4550
- +}
4551
- +
4552
- +static void
4553
- +_outRowMarkClause(StringInfo str, const RowMarkClause *node)
4554
- +{
4555
- + WRITE_NODE_TYPE("ROWMARKCLAUSE");
4556
- +
4557
- + WRITE_UINT_FIELD(rti);
4558
- + WRITE_ENUM_FIELD(strength, LockClauseStrength);
4559
- + WRITE_BOOL_FIELD(noWait);
4560
- + WRITE_BOOL_FIELD(pushedDown);
4561
- +}
4562
- +
4563
- +static void
4564
- +_outXmlSerialize(StringInfo str, const XmlSerialize *node)
4565
- +{
4566
- + WRITE_NODE_TYPE("XMLSERIALIZE");
4567
- +
4568
- + WRITE_ENUM_FIELD(xmloption, XmlOptionType);
4569
- + WRITE_NODE_FIELD(expr);
4570
- + WRITE_NODE_FIELD(typeName);
4571
- + WRITE_LOCATION_FIELD(location);
4572
- +}
4573
- +
4574
- +static void
4575
- +_outWithClause(StringInfo str, const WithClause *node)
4576
- +{
4577
- + WRITE_NODE_TYPE("WITHCLAUSE");
4578
- +
4579
- + WRITE_NODE_FIELD(ctes);
4580
- + WRITE_BOOL_FIELD(recursive);
4581
- + WRITE_LOCATION_FIELD(location);
4582
- +}
4583
- +
4584
- +static void
4585
- +_outCommonTableExpr(StringInfo str, const CommonTableExpr *node)
4586
- +{
4587
- + WRITE_NODE_TYPE("COMMONTABLEEXPR");
4588
- +
4589
- + WRITE_STRING_FIELD(ctename);
4590
- + WRITE_NODE_FIELD(aliascolnames);
4591
- + WRITE_NODE_FIELD(ctequery);
4592
- + WRITE_LOCATION_FIELD(location);
4593
- + WRITE_BOOL_FIELD(cterecursive);
4594
- + WRITE_INT_FIELD(cterefcount);
4595
- + WRITE_NODE_FIELD(ctecolnames);
4596
- + WRITE_NODE_FIELD(ctecoltypes);
4597
- + WRITE_NODE_FIELD(ctecoltypmods);
4598
- + WRITE_NODE_FIELD(ctecolcollations);
4599
- +}
4600
- +
4601
- +static void
4602
- +_outInlineCodeBlock(StringInfo str, const InlineCodeBlock *node)
4603
- +{
4604
- + WRITE_NODE_TYPE("INLINECODEBLOCK");
4605
- +
4606
- + WRITE_STRING_FIELD(source_text);
4607
- + WRITE_OID_FIELD(langOid);
4608
- + WRITE_BOOL_FIELD(langIsTrusted);
4609
- +}
4610
- +
4611
- diff --git a/src/include/nodes/nodes.h b/src/include/nodes/nodes.h
4612
- index 5dcc66f..c9ce432 100644
4613
- --- a/src/include/nodes/nodes.h
4614
- +++ b/src/include/nodes/nodes.h
4615
- @@ -504,6 +504,11 @@ extern PGDLLIMPORT Node *newNodeMacroHolder;
4616
- extern char *nodeToString(const void *obj);
4617
-
4618
- /*
4619
- +* nodes/outfuncs_json.c
4620
- +*/
4621
- +extern char *nodeToJSONString(const void *obj);
4622
- +
4623
- +/*
4624
- * nodes/{readfuncs.c,read.c}
4625
- */
4626
- extern void *stringToNode(char *str);