Coverage Report

Created: 2023-11-27 07:03

/src/libpg_query/protobuf/pg_query.pb-c.c
Line
Count
Source (jump to first uncovered line)
1
/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
2
/* Generated from: protobuf/pg_query.proto */
3
4
/* Do not generate deprecated warnings for self */
5
#ifndef PROTOBUF_C__NO_DEPRECATED
6
#define PROTOBUF_C__NO_DEPRECATED
7
#endif
8
9
#include "protobuf/pg_query.pb-c.h"
10
void   pg_query__parse_result__init
11
                     (PgQuery__ParseResult         *message)
12
0
{
13
0
  static const PgQuery__ParseResult init_value = PG_QUERY__PARSE_RESULT__INIT;
14
0
  *message = init_value;
15
0
}
16
size_t pg_query__parse_result__get_packed_size
17
                     (const PgQuery__ParseResult *message)
18
0
{
19
0
  assert(message->base.descriptor == &pg_query__parse_result__descriptor);
20
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
21
0
}
22
size_t pg_query__parse_result__pack
23
                     (const PgQuery__ParseResult *message,
24
                      uint8_t       *out)
25
0
{
26
0
  assert(message->base.descriptor == &pg_query__parse_result__descriptor);
27
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
28
0
}
29
size_t pg_query__parse_result__pack_to_buffer
30
                     (const PgQuery__ParseResult *message,
31
                      ProtobufCBuffer *buffer)
32
0
{
33
0
  assert(message->base.descriptor == &pg_query__parse_result__descriptor);
34
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
35
0
}
36
PgQuery__ParseResult *
37
       pg_query__parse_result__unpack
38
                     (ProtobufCAllocator  *allocator,
39
                      size_t               len,
40
                      const uint8_t       *data)
41
0
{
42
0
  return (PgQuery__ParseResult *)
43
0
     protobuf_c_message_unpack (&pg_query__parse_result__descriptor,
44
0
                                allocator, len, data);
45
0
}
46
void   pg_query__parse_result__free_unpacked
47
                     (PgQuery__ParseResult *message,
48
                      ProtobufCAllocator *allocator)
49
0
{
50
0
  if(!message)
51
0
    return;
52
0
  assert(message->base.descriptor == &pg_query__parse_result__descriptor);
53
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
54
0
}
55
void   pg_query__scan_result__init
56
                     (PgQuery__ScanResult         *message)
57
0
{
58
0
  static const PgQuery__ScanResult init_value = PG_QUERY__SCAN_RESULT__INIT;
59
0
  *message = init_value;
60
0
}
61
size_t pg_query__scan_result__get_packed_size
62
                     (const PgQuery__ScanResult *message)
63
0
{
64
0
  assert(message->base.descriptor == &pg_query__scan_result__descriptor);
65
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
66
0
}
67
size_t pg_query__scan_result__pack
68
                     (const PgQuery__ScanResult *message,
69
                      uint8_t       *out)
70
0
{
71
0
  assert(message->base.descriptor == &pg_query__scan_result__descriptor);
72
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
73
0
}
74
size_t pg_query__scan_result__pack_to_buffer
75
                     (const PgQuery__ScanResult *message,
76
                      ProtobufCBuffer *buffer)
77
0
{
78
0
  assert(message->base.descriptor == &pg_query__scan_result__descriptor);
79
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
80
0
}
81
PgQuery__ScanResult *
82
       pg_query__scan_result__unpack
83
                     (ProtobufCAllocator  *allocator,
84
                      size_t               len,
85
                      const uint8_t       *data)
86
0
{
87
0
  return (PgQuery__ScanResult *)
88
0
     protobuf_c_message_unpack (&pg_query__scan_result__descriptor,
89
0
                                allocator, len, data);
90
0
}
91
void   pg_query__scan_result__free_unpacked
92
                     (PgQuery__ScanResult *message,
93
                      ProtobufCAllocator *allocator)
94
0
{
95
0
  if(!message)
96
0
    return;
97
0
  assert(message->base.descriptor == &pg_query__scan_result__descriptor);
98
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
99
0
}
100
void   pg_query__node__init
101
                     (PgQuery__Node         *message)
102
0
{
103
0
  static const PgQuery__Node init_value = PG_QUERY__NODE__INIT;
104
0
  *message = init_value;
105
0
}
106
size_t pg_query__node__get_packed_size
107
                     (const PgQuery__Node *message)
108
0
{
109
0
  assert(message->base.descriptor == &pg_query__node__descriptor);
110
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
111
0
}
112
size_t pg_query__node__pack
113
                     (const PgQuery__Node *message,
114
                      uint8_t       *out)
115
0
{
116
0
  assert(message->base.descriptor == &pg_query__node__descriptor);
117
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
118
0
}
119
size_t pg_query__node__pack_to_buffer
120
                     (const PgQuery__Node *message,
121
                      ProtobufCBuffer *buffer)
122
0
{
123
0
  assert(message->base.descriptor == &pg_query__node__descriptor);
124
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
125
0
}
126
PgQuery__Node *
127
       pg_query__node__unpack
128
                     (ProtobufCAllocator  *allocator,
129
                      size_t               len,
130
                      const uint8_t       *data)
131
0
{
132
0
  return (PgQuery__Node *)
133
0
     protobuf_c_message_unpack (&pg_query__node__descriptor,
134
0
                                allocator, len, data);
135
0
}
136
void   pg_query__node__free_unpacked
137
                     (PgQuery__Node *message,
138
                      ProtobufCAllocator *allocator)
139
0
{
140
0
  if(!message)
141
0
    return;
142
0
  assert(message->base.descriptor == &pg_query__node__descriptor);
143
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
144
0
}
145
void   pg_query__integer__init
146
                     (PgQuery__Integer         *message)
147
0
{
148
0
  static const PgQuery__Integer init_value = PG_QUERY__INTEGER__INIT;
149
0
  *message = init_value;
150
0
}
151
size_t pg_query__integer__get_packed_size
152
                     (const PgQuery__Integer *message)
153
0
{
154
0
  assert(message->base.descriptor == &pg_query__integer__descriptor);
155
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
156
0
}
157
size_t pg_query__integer__pack
158
                     (const PgQuery__Integer *message,
159
                      uint8_t       *out)
160
0
{
161
0
  assert(message->base.descriptor == &pg_query__integer__descriptor);
162
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
163
0
}
164
size_t pg_query__integer__pack_to_buffer
165
                     (const PgQuery__Integer *message,
166
                      ProtobufCBuffer *buffer)
167
0
{
168
0
  assert(message->base.descriptor == &pg_query__integer__descriptor);
169
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
170
0
}
171
PgQuery__Integer *
172
       pg_query__integer__unpack
173
                     (ProtobufCAllocator  *allocator,
174
                      size_t               len,
175
                      const uint8_t       *data)
176
0
{
177
0
  return (PgQuery__Integer *)
178
0
     protobuf_c_message_unpack (&pg_query__integer__descriptor,
179
0
                                allocator, len, data);
180
0
}
181
void   pg_query__integer__free_unpacked
182
                     (PgQuery__Integer *message,
183
                      ProtobufCAllocator *allocator)
184
0
{
185
0
  if(!message)
186
0
    return;
187
0
  assert(message->base.descriptor == &pg_query__integer__descriptor);
188
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
189
0
}
190
void   pg_query__float__init
191
                     (PgQuery__Float         *message)
192
0
{
193
0
  static const PgQuery__Float init_value = PG_QUERY__FLOAT__INIT;
194
0
  *message = init_value;
195
0
}
196
size_t pg_query__float__get_packed_size
197
                     (const PgQuery__Float *message)
198
0
{
199
0
  assert(message->base.descriptor == &pg_query__float__descriptor);
200
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
201
0
}
202
size_t pg_query__float__pack
203
                     (const PgQuery__Float *message,
204
                      uint8_t       *out)
205
0
{
206
0
  assert(message->base.descriptor == &pg_query__float__descriptor);
207
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
208
0
}
209
size_t pg_query__float__pack_to_buffer
210
                     (const PgQuery__Float *message,
211
                      ProtobufCBuffer *buffer)
212
0
{
213
0
  assert(message->base.descriptor == &pg_query__float__descriptor);
214
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
215
0
}
216
PgQuery__Float *
217
       pg_query__float__unpack
218
                     (ProtobufCAllocator  *allocator,
219
                      size_t               len,
220
                      const uint8_t       *data)
221
0
{
222
0
  return (PgQuery__Float *)
223
0
     protobuf_c_message_unpack (&pg_query__float__descriptor,
224
0
                                allocator, len, data);
225
0
}
226
void   pg_query__float__free_unpacked
227
                     (PgQuery__Float *message,
228
                      ProtobufCAllocator *allocator)
229
0
{
230
0
  if(!message)
231
0
    return;
232
0
  assert(message->base.descriptor == &pg_query__float__descriptor);
233
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
234
0
}
235
void   pg_query__boolean__init
236
                     (PgQuery__Boolean         *message)
237
0
{
238
0
  static const PgQuery__Boolean init_value = PG_QUERY__BOOLEAN__INIT;
239
0
  *message = init_value;
240
0
}
241
size_t pg_query__boolean__get_packed_size
242
                     (const PgQuery__Boolean *message)
243
0
{
244
0
  assert(message->base.descriptor == &pg_query__boolean__descriptor);
245
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
246
0
}
247
size_t pg_query__boolean__pack
248
                     (const PgQuery__Boolean *message,
249
                      uint8_t       *out)
250
0
{
251
0
  assert(message->base.descriptor == &pg_query__boolean__descriptor);
252
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
253
0
}
254
size_t pg_query__boolean__pack_to_buffer
255
                     (const PgQuery__Boolean *message,
256
                      ProtobufCBuffer *buffer)
257
0
{
258
0
  assert(message->base.descriptor == &pg_query__boolean__descriptor);
259
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
260
0
}
261
PgQuery__Boolean *
262
       pg_query__boolean__unpack
263
                     (ProtobufCAllocator  *allocator,
264
                      size_t               len,
265
                      const uint8_t       *data)
266
0
{
267
0
  return (PgQuery__Boolean *)
268
0
     protobuf_c_message_unpack (&pg_query__boolean__descriptor,
269
0
                                allocator, len, data);
270
0
}
271
void   pg_query__boolean__free_unpacked
272
                     (PgQuery__Boolean *message,
273
                      ProtobufCAllocator *allocator)
274
0
{
275
0
  if(!message)
276
0
    return;
277
0
  assert(message->base.descriptor == &pg_query__boolean__descriptor);
278
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
279
0
}
280
void   pg_query__string__init
281
                     (PgQuery__String         *message)
282
0
{
283
0
  static const PgQuery__String init_value = PG_QUERY__STRING__INIT;
284
0
  *message = init_value;
285
0
}
286
size_t pg_query__string__get_packed_size
287
                     (const PgQuery__String *message)
288
0
{
289
0
  assert(message->base.descriptor == &pg_query__string__descriptor);
290
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
291
0
}
292
size_t pg_query__string__pack
293
                     (const PgQuery__String *message,
294
                      uint8_t       *out)
295
0
{
296
0
  assert(message->base.descriptor == &pg_query__string__descriptor);
297
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
298
0
}
299
size_t pg_query__string__pack_to_buffer
300
                     (const PgQuery__String *message,
301
                      ProtobufCBuffer *buffer)
302
0
{
303
0
  assert(message->base.descriptor == &pg_query__string__descriptor);
304
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
305
0
}
306
PgQuery__String *
307
       pg_query__string__unpack
308
                     (ProtobufCAllocator  *allocator,
309
                      size_t               len,
310
                      const uint8_t       *data)
311
0
{
312
0
  return (PgQuery__String *)
313
0
     protobuf_c_message_unpack (&pg_query__string__descriptor,
314
0
                                allocator, len, data);
315
0
}
316
void   pg_query__string__free_unpacked
317
                     (PgQuery__String *message,
318
                      ProtobufCAllocator *allocator)
319
0
{
320
0
  if(!message)
321
0
    return;
322
0
  assert(message->base.descriptor == &pg_query__string__descriptor);
323
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
324
0
}
325
void   pg_query__bit_string__init
326
                     (PgQuery__BitString         *message)
327
0
{
328
0
  static const PgQuery__BitString init_value = PG_QUERY__BIT_STRING__INIT;
329
0
  *message = init_value;
330
0
}
331
size_t pg_query__bit_string__get_packed_size
332
                     (const PgQuery__BitString *message)
333
0
{
334
0
  assert(message->base.descriptor == &pg_query__bit_string__descriptor);
335
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
336
0
}
337
size_t pg_query__bit_string__pack
338
                     (const PgQuery__BitString *message,
339
                      uint8_t       *out)
340
0
{
341
0
  assert(message->base.descriptor == &pg_query__bit_string__descriptor);
342
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
343
0
}
344
size_t pg_query__bit_string__pack_to_buffer
345
                     (const PgQuery__BitString *message,
346
                      ProtobufCBuffer *buffer)
347
0
{
348
0
  assert(message->base.descriptor == &pg_query__bit_string__descriptor);
349
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
350
0
}
351
PgQuery__BitString *
352
       pg_query__bit_string__unpack
353
                     (ProtobufCAllocator  *allocator,
354
                      size_t               len,
355
                      const uint8_t       *data)
356
0
{
357
0
  return (PgQuery__BitString *)
358
0
     protobuf_c_message_unpack (&pg_query__bit_string__descriptor,
359
0
                                allocator, len, data);
360
0
}
361
void   pg_query__bit_string__free_unpacked
362
                     (PgQuery__BitString *message,
363
                      ProtobufCAllocator *allocator)
364
0
{
365
0
  if(!message)
366
0
    return;
367
0
  assert(message->base.descriptor == &pg_query__bit_string__descriptor);
368
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
369
0
}
370
void   pg_query__list__init
371
                     (PgQuery__List         *message)
372
0
{
373
0
  static const PgQuery__List init_value = PG_QUERY__LIST__INIT;
374
0
  *message = init_value;
375
0
}
376
size_t pg_query__list__get_packed_size
377
                     (const PgQuery__List *message)
378
0
{
379
0
  assert(message->base.descriptor == &pg_query__list__descriptor);
380
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
381
0
}
382
size_t pg_query__list__pack
383
                     (const PgQuery__List *message,
384
                      uint8_t       *out)
385
0
{
386
0
  assert(message->base.descriptor == &pg_query__list__descriptor);
387
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
388
0
}
389
size_t pg_query__list__pack_to_buffer
390
                     (const PgQuery__List *message,
391
                      ProtobufCBuffer *buffer)
392
0
{
393
0
  assert(message->base.descriptor == &pg_query__list__descriptor);
394
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
395
0
}
396
PgQuery__List *
397
       pg_query__list__unpack
398
                     (ProtobufCAllocator  *allocator,
399
                      size_t               len,
400
                      const uint8_t       *data)
401
0
{
402
0
  return (PgQuery__List *)
403
0
     protobuf_c_message_unpack (&pg_query__list__descriptor,
404
0
                                allocator, len, data);
405
0
}
406
void   pg_query__list__free_unpacked
407
                     (PgQuery__List *message,
408
                      ProtobufCAllocator *allocator)
409
0
{
410
0
  if(!message)
411
0
    return;
412
0
  assert(message->base.descriptor == &pg_query__list__descriptor);
413
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
414
0
}
415
void   pg_query__oid_list__init
416
                     (PgQuery__OidList         *message)
417
0
{
418
0
  static const PgQuery__OidList init_value = PG_QUERY__OID_LIST__INIT;
419
0
  *message = init_value;
420
0
}
421
size_t pg_query__oid_list__get_packed_size
422
                     (const PgQuery__OidList *message)
423
0
{
424
0
  assert(message->base.descriptor == &pg_query__oid_list__descriptor);
425
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
426
0
}
427
size_t pg_query__oid_list__pack
428
                     (const PgQuery__OidList *message,
429
                      uint8_t       *out)
430
0
{
431
0
  assert(message->base.descriptor == &pg_query__oid_list__descriptor);
432
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
433
0
}
434
size_t pg_query__oid_list__pack_to_buffer
435
                     (const PgQuery__OidList *message,
436
                      ProtobufCBuffer *buffer)
437
0
{
438
0
  assert(message->base.descriptor == &pg_query__oid_list__descriptor);
439
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
440
0
}
441
PgQuery__OidList *
442
       pg_query__oid_list__unpack
443
                     (ProtobufCAllocator  *allocator,
444
                      size_t               len,
445
                      const uint8_t       *data)
446
0
{
447
0
  return (PgQuery__OidList *)
448
0
     protobuf_c_message_unpack (&pg_query__oid_list__descriptor,
449
0
                                allocator, len, data);
450
0
}
451
void   pg_query__oid_list__free_unpacked
452
                     (PgQuery__OidList *message,
453
                      ProtobufCAllocator *allocator)
454
0
{
455
0
  if(!message)
456
0
    return;
457
0
  assert(message->base.descriptor == &pg_query__oid_list__descriptor);
458
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
459
0
}
460
void   pg_query__int_list__init
461
                     (PgQuery__IntList         *message)
462
0
{
463
0
  static const PgQuery__IntList init_value = PG_QUERY__INT_LIST__INIT;
464
0
  *message = init_value;
465
0
}
466
size_t pg_query__int_list__get_packed_size
467
                     (const PgQuery__IntList *message)
468
0
{
469
0
  assert(message->base.descriptor == &pg_query__int_list__descriptor);
470
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
471
0
}
472
size_t pg_query__int_list__pack
473
                     (const PgQuery__IntList *message,
474
                      uint8_t       *out)
475
0
{
476
0
  assert(message->base.descriptor == &pg_query__int_list__descriptor);
477
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
478
0
}
479
size_t pg_query__int_list__pack_to_buffer
480
                     (const PgQuery__IntList *message,
481
                      ProtobufCBuffer *buffer)
482
0
{
483
0
  assert(message->base.descriptor == &pg_query__int_list__descriptor);
484
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
485
0
}
486
PgQuery__IntList *
487
       pg_query__int_list__unpack
488
                     (ProtobufCAllocator  *allocator,
489
                      size_t               len,
490
                      const uint8_t       *data)
491
0
{
492
0
  return (PgQuery__IntList *)
493
0
     protobuf_c_message_unpack (&pg_query__int_list__descriptor,
494
0
                                allocator, len, data);
495
0
}
496
void   pg_query__int_list__free_unpacked
497
                     (PgQuery__IntList *message,
498
                      ProtobufCAllocator *allocator)
499
0
{
500
0
  if(!message)
501
0
    return;
502
0
  assert(message->base.descriptor == &pg_query__int_list__descriptor);
503
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
504
0
}
505
void   pg_query__a__const__init
506
                     (PgQuery__AConst         *message)
507
0
{
508
0
  static const PgQuery__AConst init_value = PG_QUERY__A__CONST__INIT;
509
0
  *message = init_value;
510
0
}
511
size_t pg_query__a__const__get_packed_size
512
                     (const PgQuery__AConst *message)
513
0
{
514
0
  assert(message->base.descriptor == &pg_query__a__const__descriptor);
515
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
516
0
}
517
size_t pg_query__a__const__pack
518
                     (const PgQuery__AConst *message,
519
                      uint8_t       *out)
520
0
{
521
0
  assert(message->base.descriptor == &pg_query__a__const__descriptor);
522
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
523
0
}
524
size_t pg_query__a__const__pack_to_buffer
525
                     (const PgQuery__AConst *message,
526
                      ProtobufCBuffer *buffer)
527
0
{
528
0
  assert(message->base.descriptor == &pg_query__a__const__descriptor);
529
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
530
0
}
531
PgQuery__AConst *
532
       pg_query__a__const__unpack
533
                     (ProtobufCAllocator  *allocator,
534
                      size_t               len,
535
                      const uint8_t       *data)
536
0
{
537
0
  return (PgQuery__AConst *)
538
0
     protobuf_c_message_unpack (&pg_query__a__const__descriptor,
539
0
                                allocator, len, data);
540
0
}
541
void   pg_query__a__const__free_unpacked
542
                     (PgQuery__AConst *message,
543
                      ProtobufCAllocator *allocator)
544
0
{
545
0
  if(!message)
546
0
    return;
547
0
  assert(message->base.descriptor == &pg_query__a__const__descriptor);
548
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
549
0
}
550
void   pg_query__alias__init
551
                     (PgQuery__Alias         *message)
552
0
{
553
0
  static const PgQuery__Alias init_value = PG_QUERY__ALIAS__INIT;
554
0
  *message = init_value;
555
0
}
556
size_t pg_query__alias__get_packed_size
557
                     (const PgQuery__Alias *message)
558
0
{
559
0
  assert(message->base.descriptor == &pg_query__alias__descriptor);
560
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
561
0
}
562
size_t pg_query__alias__pack
563
                     (const PgQuery__Alias *message,
564
                      uint8_t       *out)
565
0
{
566
0
  assert(message->base.descriptor == &pg_query__alias__descriptor);
567
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
568
0
}
569
size_t pg_query__alias__pack_to_buffer
570
                     (const PgQuery__Alias *message,
571
                      ProtobufCBuffer *buffer)
572
0
{
573
0
  assert(message->base.descriptor == &pg_query__alias__descriptor);
574
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
575
0
}
576
PgQuery__Alias *
577
       pg_query__alias__unpack
578
                     (ProtobufCAllocator  *allocator,
579
                      size_t               len,
580
                      const uint8_t       *data)
581
0
{
582
0
  return (PgQuery__Alias *)
583
0
     protobuf_c_message_unpack (&pg_query__alias__descriptor,
584
0
                                allocator, len, data);
585
0
}
586
void   pg_query__alias__free_unpacked
587
                     (PgQuery__Alias *message,
588
                      ProtobufCAllocator *allocator)
589
0
{
590
0
  if(!message)
591
0
    return;
592
0
  assert(message->base.descriptor == &pg_query__alias__descriptor);
593
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
594
0
}
595
void   pg_query__range_var__init
596
                     (PgQuery__RangeVar         *message)
597
0
{
598
0
  static const PgQuery__RangeVar init_value = PG_QUERY__RANGE_VAR__INIT;
599
0
  *message = init_value;
600
0
}
601
size_t pg_query__range_var__get_packed_size
602
                     (const PgQuery__RangeVar *message)
603
0
{
604
0
  assert(message->base.descriptor == &pg_query__range_var__descriptor);
605
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
606
0
}
607
size_t pg_query__range_var__pack
608
                     (const PgQuery__RangeVar *message,
609
                      uint8_t       *out)
610
0
{
611
0
  assert(message->base.descriptor == &pg_query__range_var__descriptor);
612
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
613
0
}
614
size_t pg_query__range_var__pack_to_buffer
615
                     (const PgQuery__RangeVar *message,
616
                      ProtobufCBuffer *buffer)
617
0
{
618
0
  assert(message->base.descriptor == &pg_query__range_var__descriptor);
619
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
620
0
}
621
PgQuery__RangeVar *
622
       pg_query__range_var__unpack
623
                     (ProtobufCAllocator  *allocator,
624
                      size_t               len,
625
                      const uint8_t       *data)
626
0
{
627
0
  return (PgQuery__RangeVar *)
628
0
     protobuf_c_message_unpack (&pg_query__range_var__descriptor,
629
0
                                allocator, len, data);
630
0
}
631
void   pg_query__range_var__free_unpacked
632
                     (PgQuery__RangeVar *message,
633
                      ProtobufCAllocator *allocator)
634
0
{
635
0
  if(!message)
636
0
    return;
637
0
  assert(message->base.descriptor == &pg_query__range_var__descriptor);
638
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
639
0
}
640
void   pg_query__table_func__init
641
                     (PgQuery__TableFunc         *message)
642
0
{
643
0
  static const PgQuery__TableFunc init_value = PG_QUERY__TABLE_FUNC__INIT;
644
0
  *message = init_value;
645
0
}
646
size_t pg_query__table_func__get_packed_size
647
                     (const PgQuery__TableFunc *message)
648
0
{
649
0
  assert(message->base.descriptor == &pg_query__table_func__descriptor);
650
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
651
0
}
652
size_t pg_query__table_func__pack
653
                     (const PgQuery__TableFunc *message,
654
                      uint8_t       *out)
655
0
{
656
0
  assert(message->base.descriptor == &pg_query__table_func__descriptor);
657
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
658
0
}
659
size_t pg_query__table_func__pack_to_buffer
660
                     (const PgQuery__TableFunc *message,
661
                      ProtobufCBuffer *buffer)
662
0
{
663
0
  assert(message->base.descriptor == &pg_query__table_func__descriptor);
664
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
665
0
}
666
PgQuery__TableFunc *
667
       pg_query__table_func__unpack
668
                     (ProtobufCAllocator  *allocator,
669
                      size_t               len,
670
                      const uint8_t       *data)
671
0
{
672
0
  return (PgQuery__TableFunc *)
673
0
     protobuf_c_message_unpack (&pg_query__table_func__descriptor,
674
0
                                allocator, len, data);
675
0
}
676
void   pg_query__table_func__free_unpacked
677
                     (PgQuery__TableFunc *message,
678
                      ProtobufCAllocator *allocator)
679
0
{
680
0
  if(!message)
681
0
    return;
682
0
  assert(message->base.descriptor == &pg_query__table_func__descriptor);
683
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
684
0
}
685
void   pg_query__var__init
686
                     (PgQuery__Var         *message)
687
0
{
688
0
  static const PgQuery__Var init_value = PG_QUERY__VAR__INIT;
689
0
  *message = init_value;
690
0
}
691
size_t pg_query__var__get_packed_size
692
                     (const PgQuery__Var *message)
693
0
{
694
0
  assert(message->base.descriptor == &pg_query__var__descriptor);
695
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
696
0
}
697
size_t pg_query__var__pack
698
                     (const PgQuery__Var *message,
699
                      uint8_t       *out)
700
0
{
701
0
  assert(message->base.descriptor == &pg_query__var__descriptor);
702
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
703
0
}
704
size_t pg_query__var__pack_to_buffer
705
                     (const PgQuery__Var *message,
706
                      ProtobufCBuffer *buffer)
707
0
{
708
0
  assert(message->base.descriptor == &pg_query__var__descriptor);
709
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
710
0
}
711
PgQuery__Var *
712
       pg_query__var__unpack
713
                     (ProtobufCAllocator  *allocator,
714
                      size_t               len,
715
                      const uint8_t       *data)
716
0
{
717
0
  return (PgQuery__Var *)
718
0
     protobuf_c_message_unpack (&pg_query__var__descriptor,
719
0
                                allocator, len, data);
720
0
}
721
void   pg_query__var__free_unpacked
722
                     (PgQuery__Var *message,
723
                      ProtobufCAllocator *allocator)
724
0
{
725
0
  if(!message)
726
0
    return;
727
0
  assert(message->base.descriptor == &pg_query__var__descriptor);
728
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
729
0
}
730
void   pg_query__param__init
731
                     (PgQuery__Param         *message)
732
0
{
733
0
  static const PgQuery__Param init_value = PG_QUERY__PARAM__INIT;
734
0
  *message = init_value;
735
0
}
736
size_t pg_query__param__get_packed_size
737
                     (const PgQuery__Param *message)
738
0
{
739
0
  assert(message->base.descriptor == &pg_query__param__descriptor);
740
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
741
0
}
742
size_t pg_query__param__pack
743
                     (const PgQuery__Param *message,
744
                      uint8_t       *out)
745
0
{
746
0
  assert(message->base.descriptor == &pg_query__param__descriptor);
747
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
748
0
}
749
size_t pg_query__param__pack_to_buffer
750
                     (const PgQuery__Param *message,
751
                      ProtobufCBuffer *buffer)
752
0
{
753
0
  assert(message->base.descriptor == &pg_query__param__descriptor);
754
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
755
0
}
756
PgQuery__Param *
757
       pg_query__param__unpack
758
                     (ProtobufCAllocator  *allocator,
759
                      size_t               len,
760
                      const uint8_t       *data)
761
0
{
762
0
  return (PgQuery__Param *)
763
0
     protobuf_c_message_unpack (&pg_query__param__descriptor,
764
0
                                allocator, len, data);
765
0
}
766
void   pg_query__param__free_unpacked
767
                     (PgQuery__Param *message,
768
                      ProtobufCAllocator *allocator)
769
0
{
770
0
  if(!message)
771
0
    return;
772
0
  assert(message->base.descriptor == &pg_query__param__descriptor);
773
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
774
0
}
775
void   pg_query__aggref__init
776
                     (PgQuery__Aggref         *message)
777
0
{
778
0
  static const PgQuery__Aggref init_value = PG_QUERY__AGGREF__INIT;
779
0
  *message = init_value;
780
0
}
781
size_t pg_query__aggref__get_packed_size
782
                     (const PgQuery__Aggref *message)
783
0
{
784
0
  assert(message->base.descriptor == &pg_query__aggref__descriptor);
785
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
786
0
}
787
size_t pg_query__aggref__pack
788
                     (const PgQuery__Aggref *message,
789
                      uint8_t       *out)
790
0
{
791
0
  assert(message->base.descriptor == &pg_query__aggref__descriptor);
792
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
793
0
}
794
size_t pg_query__aggref__pack_to_buffer
795
                     (const PgQuery__Aggref *message,
796
                      ProtobufCBuffer *buffer)
797
0
{
798
0
  assert(message->base.descriptor == &pg_query__aggref__descriptor);
799
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
800
0
}
801
PgQuery__Aggref *
802
       pg_query__aggref__unpack
803
                     (ProtobufCAllocator  *allocator,
804
                      size_t               len,
805
                      const uint8_t       *data)
806
0
{
807
0
  return (PgQuery__Aggref *)
808
0
     protobuf_c_message_unpack (&pg_query__aggref__descriptor,
809
0
                                allocator, len, data);
810
0
}
811
void   pg_query__aggref__free_unpacked
812
                     (PgQuery__Aggref *message,
813
                      ProtobufCAllocator *allocator)
814
0
{
815
0
  if(!message)
816
0
    return;
817
0
  assert(message->base.descriptor == &pg_query__aggref__descriptor);
818
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
819
0
}
820
void   pg_query__grouping_func__init
821
                     (PgQuery__GroupingFunc         *message)
822
0
{
823
0
  static const PgQuery__GroupingFunc init_value = PG_QUERY__GROUPING_FUNC__INIT;
824
0
  *message = init_value;
825
0
}
826
size_t pg_query__grouping_func__get_packed_size
827
                     (const PgQuery__GroupingFunc *message)
828
0
{
829
0
  assert(message->base.descriptor == &pg_query__grouping_func__descriptor);
830
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
831
0
}
832
size_t pg_query__grouping_func__pack
833
                     (const PgQuery__GroupingFunc *message,
834
                      uint8_t       *out)
835
0
{
836
0
  assert(message->base.descriptor == &pg_query__grouping_func__descriptor);
837
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
838
0
}
839
size_t pg_query__grouping_func__pack_to_buffer
840
                     (const PgQuery__GroupingFunc *message,
841
                      ProtobufCBuffer *buffer)
842
0
{
843
0
  assert(message->base.descriptor == &pg_query__grouping_func__descriptor);
844
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
845
0
}
846
PgQuery__GroupingFunc *
847
       pg_query__grouping_func__unpack
848
                     (ProtobufCAllocator  *allocator,
849
                      size_t               len,
850
                      const uint8_t       *data)
851
0
{
852
0
  return (PgQuery__GroupingFunc *)
853
0
     protobuf_c_message_unpack (&pg_query__grouping_func__descriptor,
854
0
                                allocator, len, data);
855
0
}
856
void   pg_query__grouping_func__free_unpacked
857
                     (PgQuery__GroupingFunc *message,
858
                      ProtobufCAllocator *allocator)
859
0
{
860
0
  if(!message)
861
0
    return;
862
0
  assert(message->base.descriptor == &pg_query__grouping_func__descriptor);
863
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
864
0
}
865
void   pg_query__window_func__init
866
                     (PgQuery__WindowFunc         *message)
867
0
{
868
0
  static const PgQuery__WindowFunc init_value = PG_QUERY__WINDOW_FUNC__INIT;
869
0
  *message = init_value;
870
0
}
871
size_t pg_query__window_func__get_packed_size
872
                     (const PgQuery__WindowFunc *message)
873
0
{
874
0
  assert(message->base.descriptor == &pg_query__window_func__descriptor);
875
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
876
0
}
877
size_t pg_query__window_func__pack
878
                     (const PgQuery__WindowFunc *message,
879
                      uint8_t       *out)
880
0
{
881
0
  assert(message->base.descriptor == &pg_query__window_func__descriptor);
882
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
883
0
}
884
size_t pg_query__window_func__pack_to_buffer
885
                     (const PgQuery__WindowFunc *message,
886
                      ProtobufCBuffer *buffer)
887
0
{
888
0
  assert(message->base.descriptor == &pg_query__window_func__descriptor);
889
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
890
0
}
891
PgQuery__WindowFunc *
892
       pg_query__window_func__unpack
893
                     (ProtobufCAllocator  *allocator,
894
                      size_t               len,
895
                      const uint8_t       *data)
896
0
{
897
0
  return (PgQuery__WindowFunc *)
898
0
     protobuf_c_message_unpack (&pg_query__window_func__descriptor,
899
0
                                allocator, len, data);
900
0
}
901
void   pg_query__window_func__free_unpacked
902
                     (PgQuery__WindowFunc *message,
903
                      ProtobufCAllocator *allocator)
904
0
{
905
0
  if(!message)
906
0
    return;
907
0
  assert(message->base.descriptor == &pg_query__window_func__descriptor);
908
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
909
0
}
910
void   pg_query__subscripting_ref__init
911
                     (PgQuery__SubscriptingRef         *message)
912
0
{
913
0
  static const PgQuery__SubscriptingRef init_value = PG_QUERY__SUBSCRIPTING_REF__INIT;
914
0
  *message = init_value;
915
0
}
916
size_t pg_query__subscripting_ref__get_packed_size
917
                     (const PgQuery__SubscriptingRef *message)
918
0
{
919
0
  assert(message->base.descriptor == &pg_query__subscripting_ref__descriptor);
920
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
921
0
}
922
size_t pg_query__subscripting_ref__pack
923
                     (const PgQuery__SubscriptingRef *message,
924
                      uint8_t       *out)
925
0
{
926
0
  assert(message->base.descriptor == &pg_query__subscripting_ref__descriptor);
927
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
928
0
}
929
size_t pg_query__subscripting_ref__pack_to_buffer
930
                     (const PgQuery__SubscriptingRef *message,
931
                      ProtobufCBuffer *buffer)
932
0
{
933
0
  assert(message->base.descriptor == &pg_query__subscripting_ref__descriptor);
934
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
935
0
}
936
PgQuery__SubscriptingRef *
937
       pg_query__subscripting_ref__unpack
938
                     (ProtobufCAllocator  *allocator,
939
                      size_t               len,
940
                      const uint8_t       *data)
941
0
{
942
0
  return (PgQuery__SubscriptingRef *)
943
0
     protobuf_c_message_unpack (&pg_query__subscripting_ref__descriptor,
944
0
                                allocator, len, data);
945
0
}
946
void   pg_query__subscripting_ref__free_unpacked
947
                     (PgQuery__SubscriptingRef *message,
948
                      ProtobufCAllocator *allocator)
949
0
{
950
0
  if(!message)
951
0
    return;
952
0
  assert(message->base.descriptor == &pg_query__subscripting_ref__descriptor);
953
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
954
0
}
955
void   pg_query__func_expr__init
956
                     (PgQuery__FuncExpr         *message)
957
0
{
958
0
  static const PgQuery__FuncExpr init_value = PG_QUERY__FUNC_EXPR__INIT;
959
0
  *message = init_value;
960
0
}
961
size_t pg_query__func_expr__get_packed_size
962
                     (const PgQuery__FuncExpr *message)
963
0
{
964
0
  assert(message->base.descriptor == &pg_query__func_expr__descriptor);
965
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
966
0
}
967
size_t pg_query__func_expr__pack
968
                     (const PgQuery__FuncExpr *message,
969
                      uint8_t       *out)
970
0
{
971
0
  assert(message->base.descriptor == &pg_query__func_expr__descriptor);
972
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
973
0
}
974
size_t pg_query__func_expr__pack_to_buffer
975
                     (const PgQuery__FuncExpr *message,
976
                      ProtobufCBuffer *buffer)
977
0
{
978
0
  assert(message->base.descriptor == &pg_query__func_expr__descriptor);
979
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
980
0
}
981
PgQuery__FuncExpr *
982
       pg_query__func_expr__unpack
983
                     (ProtobufCAllocator  *allocator,
984
                      size_t               len,
985
                      const uint8_t       *data)
986
0
{
987
0
  return (PgQuery__FuncExpr *)
988
0
     protobuf_c_message_unpack (&pg_query__func_expr__descriptor,
989
0
                                allocator, len, data);
990
0
}
991
void   pg_query__func_expr__free_unpacked
992
                     (PgQuery__FuncExpr *message,
993
                      ProtobufCAllocator *allocator)
994
0
{
995
0
  if(!message)
996
0
    return;
997
0
  assert(message->base.descriptor == &pg_query__func_expr__descriptor);
998
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
999
0
}
1000
void   pg_query__named_arg_expr__init
1001
                     (PgQuery__NamedArgExpr         *message)
1002
0
{
1003
0
  static const PgQuery__NamedArgExpr init_value = PG_QUERY__NAMED_ARG_EXPR__INIT;
1004
0
  *message = init_value;
1005
0
}
1006
size_t pg_query__named_arg_expr__get_packed_size
1007
                     (const PgQuery__NamedArgExpr *message)
1008
0
{
1009
0
  assert(message->base.descriptor == &pg_query__named_arg_expr__descriptor);
1010
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1011
0
}
1012
size_t pg_query__named_arg_expr__pack
1013
                     (const PgQuery__NamedArgExpr *message,
1014
                      uint8_t       *out)
1015
0
{
1016
0
  assert(message->base.descriptor == &pg_query__named_arg_expr__descriptor);
1017
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1018
0
}
1019
size_t pg_query__named_arg_expr__pack_to_buffer
1020
                     (const PgQuery__NamedArgExpr *message,
1021
                      ProtobufCBuffer *buffer)
1022
0
{
1023
0
  assert(message->base.descriptor == &pg_query__named_arg_expr__descriptor);
1024
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1025
0
}
1026
PgQuery__NamedArgExpr *
1027
       pg_query__named_arg_expr__unpack
1028
                     (ProtobufCAllocator  *allocator,
1029
                      size_t               len,
1030
                      const uint8_t       *data)
1031
0
{
1032
0
  return (PgQuery__NamedArgExpr *)
1033
0
     protobuf_c_message_unpack (&pg_query__named_arg_expr__descriptor,
1034
0
                                allocator, len, data);
1035
0
}
1036
void   pg_query__named_arg_expr__free_unpacked
1037
                     (PgQuery__NamedArgExpr *message,
1038
                      ProtobufCAllocator *allocator)
1039
0
{
1040
0
  if(!message)
1041
0
    return;
1042
0
  assert(message->base.descriptor == &pg_query__named_arg_expr__descriptor);
1043
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1044
0
}
1045
void   pg_query__op_expr__init
1046
                     (PgQuery__OpExpr         *message)
1047
0
{
1048
0
  static const PgQuery__OpExpr init_value = PG_QUERY__OP_EXPR__INIT;
1049
0
  *message = init_value;
1050
0
}
1051
size_t pg_query__op_expr__get_packed_size
1052
                     (const PgQuery__OpExpr *message)
1053
0
{
1054
0
  assert(message->base.descriptor == &pg_query__op_expr__descriptor);
1055
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1056
0
}
1057
size_t pg_query__op_expr__pack
1058
                     (const PgQuery__OpExpr *message,
1059
                      uint8_t       *out)
1060
0
{
1061
0
  assert(message->base.descriptor == &pg_query__op_expr__descriptor);
1062
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1063
0
}
1064
size_t pg_query__op_expr__pack_to_buffer
1065
                     (const PgQuery__OpExpr *message,
1066
                      ProtobufCBuffer *buffer)
1067
0
{
1068
0
  assert(message->base.descriptor == &pg_query__op_expr__descriptor);
1069
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1070
0
}
1071
PgQuery__OpExpr *
1072
       pg_query__op_expr__unpack
1073
                     (ProtobufCAllocator  *allocator,
1074
                      size_t               len,
1075
                      const uint8_t       *data)
1076
0
{
1077
0
  return (PgQuery__OpExpr *)
1078
0
     protobuf_c_message_unpack (&pg_query__op_expr__descriptor,
1079
0
                                allocator, len, data);
1080
0
}
1081
void   pg_query__op_expr__free_unpacked
1082
                     (PgQuery__OpExpr *message,
1083
                      ProtobufCAllocator *allocator)
1084
0
{
1085
0
  if(!message)
1086
0
    return;
1087
0
  assert(message->base.descriptor == &pg_query__op_expr__descriptor);
1088
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1089
0
}
1090
void   pg_query__distinct_expr__init
1091
                     (PgQuery__DistinctExpr         *message)
1092
0
{
1093
0
  static const PgQuery__DistinctExpr init_value = PG_QUERY__DISTINCT_EXPR__INIT;
1094
0
  *message = init_value;
1095
0
}
1096
size_t pg_query__distinct_expr__get_packed_size
1097
                     (const PgQuery__DistinctExpr *message)
1098
0
{
1099
0
  assert(message->base.descriptor == &pg_query__distinct_expr__descriptor);
1100
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1101
0
}
1102
size_t pg_query__distinct_expr__pack
1103
                     (const PgQuery__DistinctExpr *message,
1104
                      uint8_t       *out)
1105
0
{
1106
0
  assert(message->base.descriptor == &pg_query__distinct_expr__descriptor);
1107
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1108
0
}
1109
size_t pg_query__distinct_expr__pack_to_buffer
1110
                     (const PgQuery__DistinctExpr *message,
1111
                      ProtobufCBuffer *buffer)
1112
0
{
1113
0
  assert(message->base.descriptor == &pg_query__distinct_expr__descriptor);
1114
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1115
0
}
1116
PgQuery__DistinctExpr *
1117
       pg_query__distinct_expr__unpack
1118
                     (ProtobufCAllocator  *allocator,
1119
                      size_t               len,
1120
                      const uint8_t       *data)
1121
0
{
1122
0
  return (PgQuery__DistinctExpr *)
1123
0
     protobuf_c_message_unpack (&pg_query__distinct_expr__descriptor,
1124
0
                                allocator, len, data);
1125
0
}
1126
void   pg_query__distinct_expr__free_unpacked
1127
                     (PgQuery__DistinctExpr *message,
1128
                      ProtobufCAllocator *allocator)
1129
0
{
1130
0
  if(!message)
1131
0
    return;
1132
0
  assert(message->base.descriptor == &pg_query__distinct_expr__descriptor);
1133
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1134
0
}
1135
void   pg_query__null_if_expr__init
1136
                     (PgQuery__NullIfExpr         *message)
1137
0
{
1138
0
  static const PgQuery__NullIfExpr init_value = PG_QUERY__NULL_IF_EXPR__INIT;
1139
0
  *message = init_value;
1140
0
}
1141
size_t pg_query__null_if_expr__get_packed_size
1142
                     (const PgQuery__NullIfExpr *message)
1143
0
{
1144
0
  assert(message->base.descriptor == &pg_query__null_if_expr__descriptor);
1145
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1146
0
}
1147
size_t pg_query__null_if_expr__pack
1148
                     (const PgQuery__NullIfExpr *message,
1149
                      uint8_t       *out)
1150
0
{
1151
0
  assert(message->base.descriptor == &pg_query__null_if_expr__descriptor);
1152
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1153
0
}
1154
size_t pg_query__null_if_expr__pack_to_buffer
1155
                     (const PgQuery__NullIfExpr *message,
1156
                      ProtobufCBuffer *buffer)
1157
0
{
1158
0
  assert(message->base.descriptor == &pg_query__null_if_expr__descriptor);
1159
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1160
0
}
1161
PgQuery__NullIfExpr *
1162
       pg_query__null_if_expr__unpack
1163
                     (ProtobufCAllocator  *allocator,
1164
                      size_t               len,
1165
                      const uint8_t       *data)
1166
0
{
1167
0
  return (PgQuery__NullIfExpr *)
1168
0
     protobuf_c_message_unpack (&pg_query__null_if_expr__descriptor,
1169
0
                                allocator, len, data);
1170
0
}
1171
void   pg_query__null_if_expr__free_unpacked
1172
                     (PgQuery__NullIfExpr *message,
1173
                      ProtobufCAllocator *allocator)
1174
0
{
1175
0
  if(!message)
1176
0
    return;
1177
0
  assert(message->base.descriptor == &pg_query__null_if_expr__descriptor);
1178
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1179
0
}
1180
void   pg_query__scalar_array_op_expr__init
1181
                     (PgQuery__ScalarArrayOpExpr         *message)
1182
0
{
1183
0
  static const PgQuery__ScalarArrayOpExpr init_value = PG_QUERY__SCALAR_ARRAY_OP_EXPR__INIT;
1184
0
  *message = init_value;
1185
0
}
1186
size_t pg_query__scalar_array_op_expr__get_packed_size
1187
                     (const PgQuery__ScalarArrayOpExpr *message)
1188
0
{
1189
0
  assert(message->base.descriptor == &pg_query__scalar_array_op_expr__descriptor);
1190
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1191
0
}
1192
size_t pg_query__scalar_array_op_expr__pack
1193
                     (const PgQuery__ScalarArrayOpExpr *message,
1194
                      uint8_t       *out)
1195
0
{
1196
0
  assert(message->base.descriptor == &pg_query__scalar_array_op_expr__descriptor);
1197
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1198
0
}
1199
size_t pg_query__scalar_array_op_expr__pack_to_buffer
1200
                     (const PgQuery__ScalarArrayOpExpr *message,
1201
                      ProtobufCBuffer *buffer)
1202
0
{
1203
0
  assert(message->base.descriptor == &pg_query__scalar_array_op_expr__descriptor);
1204
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1205
0
}
1206
PgQuery__ScalarArrayOpExpr *
1207
       pg_query__scalar_array_op_expr__unpack
1208
                     (ProtobufCAllocator  *allocator,
1209
                      size_t               len,
1210
                      const uint8_t       *data)
1211
0
{
1212
0
  return (PgQuery__ScalarArrayOpExpr *)
1213
0
     protobuf_c_message_unpack (&pg_query__scalar_array_op_expr__descriptor,
1214
0
                                allocator, len, data);
1215
0
}
1216
void   pg_query__scalar_array_op_expr__free_unpacked
1217
                     (PgQuery__ScalarArrayOpExpr *message,
1218
                      ProtobufCAllocator *allocator)
1219
0
{
1220
0
  if(!message)
1221
0
    return;
1222
0
  assert(message->base.descriptor == &pg_query__scalar_array_op_expr__descriptor);
1223
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1224
0
}
1225
void   pg_query__bool_expr__init
1226
                     (PgQuery__BoolExpr         *message)
1227
0
{
1228
0
  static const PgQuery__BoolExpr init_value = PG_QUERY__BOOL_EXPR__INIT;
1229
0
  *message = init_value;
1230
0
}
1231
size_t pg_query__bool_expr__get_packed_size
1232
                     (const PgQuery__BoolExpr *message)
1233
0
{
1234
0
  assert(message->base.descriptor == &pg_query__bool_expr__descriptor);
1235
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1236
0
}
1237
size_t pg_query__bool_expr__pack
1238
                     (const PgQuery__BoolExpr *message,
1239
                      uint8_t       *out)
1240
0
{
1241
0
  assert(message->base.descriptor == &pg_query__bool_expr__descriptor);
1242
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1243
0
}
1244
size_t pg_query__bool_expr__pack_to_buffer
1245
                     (const PgQuery__BoolExpr *message,
1246
                      ProtobufCBuffer *buffer)
1247
0
{
1248
0
  assert(message->base.descriptor == &pg_query__bool_expr__descriptor);
1249
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1250
0
}
1251
PgQuery__BoolExpr *
1252
       pg_query__bool_expr__unpack
1253
                     (ProtobufCAllocator  *allocator,
1254
                      size_t               len,
1255
                      const uint8_t       *data)
1256
0
{
1257
0
  return (PgQuery__BoolExpr *)
1258
0
     protobuf_c_message_unpack (&pg_query__bool_expr__descriptor,
1259
0
                                allocator, len, data);
1260
0
}
1261
void   pg_query__bool_expr__free_unpacked
1262
                     (PgQuery__BoolExpr *message,
1263
                      ProtobufCAllocator *allocator)
1264
0
{
1265
0
  if(!message)
1266
0
    return;
1267
0
  assert(message->base.descriptor == &pg_query__bool_expr__descriptor);
1268
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1269
0
}
1270
void   pg_query__sub_link__init
1271
                     (PgQuery__SubLink         *message)
1272
0
{
1273
0
  static const PgQuery__SubLink init_value = PG_QUERY__SUB_LINK__INIT;
1274
0
  *message = init_value;
1275
0
}
1276
size_t pg_query__sub_link__get_packed_size
1277
                     (const PgQuery__SubLink *message)
1278
0
{
1279
0
  assert(message->base.descriptor == &pg_query__sub_link__descriptor);
1280
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1281
0
}
1282
size_t pg_query__sub_link__pack
1283
                     (const PgQuery__SubLink *message,
1284
                      uint8_t       *out)
1285
0
{
1286
0
  assert(message->base.descriptor == &pg_query__sub_link__descriptor);
1287
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1288
0
}
1289
size_t pg_query__sub_link__pack_to_buffer
1290
                     (const PgQuery__SubLink *message,
1291
                      ProtobufCBuffer *buffer)
1292
0
{
1293
0
  assert(message->base.descriptor == &pg_query__sub_link__descriptor);
1294
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1295
0
}
1296
PgQuery__SubLink *
1297
       pg_query__sub_link__unpack
1298
                     (ProtobufCAllocator  *allocator,
1299
                      size_t               len,
1300
                      const uint8_t       *data)
1301
0
{
1302
0
  return (PgQuery__SubLink *)
1303
0
     protobuf_c_message_unpack (&pg_query__sub_link__descriptor,
1304
0
                                allocator, len, data);
1305
0
}
1306
void   pg_query__sub_link__free_unpacked
1307
                     (PgQuery__SubLink *message,
1308
                      ProtobufCAllocator *allocator)
1309
0
{
1310
0
  if(!message)
1311
0
    return;
1312
0
  assert(message->base.descriptor == &pg_query__sub_link__descriptor);
1313
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1314
0
}
1315
void   pg_query__sub_plan__init
1316
                     (PgQuery__SubPlan         *message)
1317
0
{
1318
0
  static const PgQuery__SubPlan init_value = PG_QUERY__SUB_PLAN__INIT;
1319
0
  *message = init_value;
1320
0
}
1321
size_t pg_query__sub_plan__get_packed_size
1322
                     (const PgQuery__SubPlan *message)
1323
0
{
1324
0
  assert(message->base.descriptor == &pg_query__sub_plan__descriptor);
1325
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1326
0
}
1327
size_t pg_query__sub_plan__pack
1328
                     (const PgQuery__SubPlan *message,
1329
                      uint8_t       *out)
1330
0
{
1331
0
  assert(message->base.descriptor == &pg_query__sub_plan__descriptor);
1332
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1333
0
}
1334
size_t pg_query__sub_plan__pack_to_buffer
1335
                     (const PgQuery__SubPlan *message,
1336
                      ProtobufCBuffer *buffer)
1337
0
{
1338
0
  assert(message->base.descriptor == &pg_query__sub_plan__descriptor);
1339
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1340
0
}
1341
PgQuery__SubPlan *
1342
       pg_query__sub_plan__unpack
1343
                     (ProtobufCAllocator  *allocator,
1344
                      size_t               len,
1345
                      const uint8_t       *data)
1346
0
{
1347
0
  return (PgQuery__SubPlan *)
1348
0
     protobuf_c_message_unpack (&pg_query__sub_plan__descriptor,
1349
0
                                allocator, len, data);
1350
0
}
1351
void   pg_query__sub_plan__free_unpacked
1352
                     (PgQuery__SubPlan *message,
1353
                      ProtobufCAllocator *allocator)
1354
0
{
1355
0
  if(!message)
1356
0
    return;
1357
0
  assert(message->base.descriptor == &pg_query__sub_plan__descriptor);
1358
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1359
0
}
1360
void   pg_query__alternative_sub_plan__init
1361
                     (PgQuery__AlternativeSubPlan         *message)
1362
0
{
1363
0
  static const PgQuery__AlternativeSubPlan init_value = PG_QUERY__ALTERNATIVE_SUB_PLAN__INIT;
1364
0
  *message = init_value;
1365
0
}
1366
size_t pg_query__alternative_sub_plan__get_packed_size
1367
                     (const PgQuery__AlternativeSubPlan *message)
1368
0
{
1369
0
  assert(message->base.descriptor == &pg_query__alternative_sub_plan__descriptor);
1370
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1371
0
}
1372
size_t pg_query__alternative_sub_plan__pack
1373
                     (const PgQuery__AlternativeSubPlan *message,
1374
                      uint8_t       *out)
1375
0
{
1376
0
  assert(message->base.descriptor == &pg_query__alternative_sub_plan__descriptor);
1377
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1378
0
}
1379
size_t pg_query__alternative_sub_plan__pack_to_buffer
1380
                     (const PgQuery__AlternativeSubPlan *message,
1381
                      ProtobufCBuffer *buffer)
1382
0
{
1383
0
  assert(message->base.descriptor == &pg_query__alternative_sub_plan__descriptor);
1384
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1385
0
}
1386
PgQuery__AlternativeSubPlan *
1387
       pg_query__alternative_sub_plan__unpack
1388
                     (ProtobufCAllocator  *allocator,
1389
                      size_t               len,
1390
                      const uint8_t       *data)
1391
0
{
1392
0
  return (PgQuery__AlternativeSubPlan *)
1393
0
     protobuf_c_message_unpack (&pg_query__alternative_sub_plan__descriptor,
1394
0
                                allocator, len, data);
1395
0
}
1396
void   pg_query__alternative_sub_plan__free_unpacked
1397
                     (PgQuery__AlternativeSubPlan *message,
1398
                      ProtobufCAllocator *allocator)
1399
0
{
1400
0
  if(!message)
1401
0
    return;
1402
0
  assert(message->base.descriptor == &pg_query__alternative_sub_plan__descriptor);
1403
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1404
0
}
1405
void   pg_query__field_select__init
1406
                     (PgQuery__FieldSelect         *message)
1407
0
{
1408
0
  static const PgQuery__FieldSelect init_value = PG_QUERY__FIELD_SELECT__INIT;
1409
0
  *message = init_value;
1410
0
}
1411
size_t pg_query__field_select__get_packed_size
1412
                     (const PgQuery__FieldSelect *message)
1413
0
{
1414
0
  assert(message->base.descriptor == &pg_query__field_select__descriptor);
1415
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1416
0
}
1417
size_t pg_query__field_select__pack
1418
                     (const PgQuery__FieldSelect *message,
1419
                      uint8_t       *out)
1420
0
{
1421
0
  assert(message->base.descriptor == &pg_query__field_select__descriptor);
1422
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1423
0
}
1424
size_t pg_query__field_select__pack_to_buffer
1425
                     (const PgQuery__FieldSelect *message,
1426
                      ProtobufCBuffer *buffer)
1427
0
{
1428
0
  assert(message->base.descriptor == &pg_query__field_select__descriptor);
1429
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1430
0
}
1431
PgQuery__FieldSelect *
1432
       pg_query__field_select__unpack
1433
                     (ProtobufCAllocator  *allocator,
1434
                      size_t               len,
1435
                      const uint8_t       *data)
1436
0
{
1437
0
  return (PgQuery__FieldSelect *)
1438
0
     protobuf_c_message_unpack (&pg_query__field_select__descriptor,
1439
0
                                allocator, len, data);
1440
0
}
1441
void   pg_query__field_select__free_unpacked
1442
                     (PgQuery__FieldSelect *message,
1443
                      ProtobufCAllocator *allocator)
1444
0
{
1445
0
  if(!message)
1446
0
    return;
1447
0
  assert(message->base.descriptor == &pg_query__field_select__descriptor);
1448
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1449
0
}
1450
void   pg_query__field_store__init
1451
                     (PgQuery__FieldStore         *message)
1452
0
{
1453
0
  static const PgQuery__FieldStore init_value = PG_QUERY__FIELD_STORE__INIT;
1454
0
  *message = init_value;
1455
0
}
1456
size_t pg_query__field_store__get_packed_size
1457
                     (const PgQuery__FieldStore *message)
1458
0
{
1459
0
  assert(message->base.descriptor == &pg_query__field_store__descriptor);
1460
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1461
0
}
1462
size_t pg_query__field_store__pack
1463
                     (const PgQuery__FieldStore *message,
1464
                      uint8_t       *out)
1465
0
{
1466
0
  assert(message->base.descriptor == &pg_query__field_store__descriptor);
1467
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1468
0
}
1469
size_t pg_query__field_store__pack_to_buffer
1470
                     (const PgQuery__FieldStore *message,
1471
                      ProtobufCBuffer *buffer)
1472
0
{
1473
0
  assert(message->base.descriptor == &pg_query__field_store__descriptor);
1474
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1475
0
}
1476
PgQuery__FieldStore *
1477
       pg_query__field_store__unpack
1478
                     (ProtobufCAllocator  *allocator,
1479
                      size_t               len,
1480
                      const uint8_t       *data)
1481
0
{
1482
0
  return (PgQuery__FieldStore *)
1483
0
     protobuf_c_message_unpack (&pg_query__field_store__descriptor,
1484
0
                                allocator, len, data);
1485
0
}
1486
void   pg_query__field_store__free_unpacked
1487
                     (PgQuery__FieldStore *message,
1488
                      ProtobufCAllocator *allocator)
1489
0
{
1490
0
  if(!message)
1491
0
    return;
1492
0
  assert(message->base.descriptor == &pg_query__field_store__descriptor);
1493
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1494
0
}
1495
void   pg_query__relabel_type__init
1496
                     (PgQuery__RelabelType         *message)
1497
0
{
1498
0
  static const PgQuery__RelabelType init_value = PG_QUERY__RELABEL_TYPE__INIT;
1499
0
  *message = init_value;
1500
0
}
1501
size_t pg_query__relabel_type__get_packed_size
1502
                     (const PgQuery__RelabelType *message)
1503
0
{
1504
0
  assert(message->base.descriptor == &pg_query__relabel_type__descriptor);
1505
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1506
0
}
1507
size_t pg_query__relabel_type__pack
1508
                     (const PgQuery__RelabelType *message,
1509
                      uint8_t       *out)
1510
0
{
1511
0
  assert(message->base.descriptor == &pg_query__relabel_type__descriptor);
1512
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1513
0
}
1514
size_t pg_query__relabel_type__pack_to_buffer
1515
                     (const PgQuery__RelabelType *message,
1516
                      ProtobufCBuffer *buffer)
1517
0
{
1518
0
  assert(message->base.descriptor == &pg_query__relabel_type__descriptor);
1519
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1520
0
}
1521
PgQuery__RelabelType *
1522
       pg_query__relabel_type__unpack
1523
                     (ProtobufCAllocator  *allocator,
1524
                      size_t               len,
1525
                      const uint8_t       *data)
1526
0
{
1527
0
  return (PgQuery__RelabelType *)
1528
0
     protobuf_c_message_unpack (&pg_query__relabel_type__descriptor,
1529
0
                                allocator, len, data);
1530
0
}
1531
void   pg_query__relabel_type__free_unpacked
1532
                     (PgQuery__RelabelType *message,
1533
                      ProtobufCAllocator *allocator)
1534
0
{
1535
0
  if(!message)
1536
0
    return;
1537
0
  assert(message->base.descriptor == &pg_query__relabel_type__descriptor);
1538
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1539
0
}
1540
void   pg_query__coerce_via_io__init
1541
                     (PgQuery__CoerceViaIO         *message)
1542
0
{
1543
0
  static const PgQuery__CoerceViaIO init_value = PG_QUERY__COERCE_VIA_IO__INIT;
1544
0
  *message = init_value;
1545
0
}
1546
size_t pg_query__coerce_via_io__get_packed_size
1547
                     (const PgQuery__CoerceViaIO *message)
1548
0
{
1549
0
  assert(message->base.descriptor == &pg_query__coerce_via_io__descriptor);
1550
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1551
0
}
1552
size_t pg_query__coerce_via_io__pack
1553
                     (const PgQuery__CoerceViaIO *message,
1554
                      uint8_t       *out)
1555
0
{
1556
0
  assert(message->base.descriptor == &pg_query__coerce_via_io__descriptor);
1557
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1558
0
}
1559
size_t pg_query__coerce_via_io__pack_to_buffer
1560
                     (const PgQuery__CoerceViaIO *message,
1561
                      ProtobufCBuffer *buffer)
1562
0
{
1563
0
  assert(message->base.descriptor == &pg_query__coerce_via_io__descriptor);
1564
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1565
0
}
1566
PgQuery__CoerceViaIO *
1567
       pg_query__coerce_via_io__unpack
1568
                     (ProtobufCAllocator  *allocator,
1569
                      size_t               len,
1570
                      const uint8_t       *data)
1571
0
{
1572
0
  return (PgQuery__CoerceViaIO *)
1573
0
     protobuf_c_message_unpack (&pg_query__coerce_via_io__descriptor,
1574
0
                                allocator, len, data);
1575
0
}
1576
void   pg_query__coerce_via_io__free_unpacked
1577
                     (PgQuery__CoerceViaIO *message,
1578
                      ProtobufCAllocator *allocator)
1579
0
{
1580
0
  if(!message)
1581
0
    return;
1582
0
  assert(message->base.descriptor == &pg_query__coerce_via_io__descriptor);
1583
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1584
0
}
1585
void   pg_query__array_coerce_expr__init
1586
                     (PgQuery__ArrayCoerceExpr         *message)
1587
0
{
1588
0
  static const PgQuery__ArrayCoerceExpr init_value = PG_QUERY__ARRAY_COERCE_EXPR__INIT;
1589
0
  *message = init_value;
1590
0
}
1591
size_t pg_query__array_coerce_expr__get_packed_size
1592
                     (const PgQuery__ArrayCoerceExpr *message)
1593
0
{
1594
0
  assert(message->base.descriptor == &pg_query__array_coerce_expr__descriptor);
1595
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1596
0
}
1597
size_t pg_query__array_coerce_expr__pack
1598
                     (const PgQuery__ArrayCoerceExpr *message,
1599
                      uint8_t       *out)
1600
0
{
1601
0
  assert(message->base.descriptor == &pg_query__array_coerce_expr__descriptor);
1602
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1603
0
}
1604
size_t pg_query__array_coerce_expr__pack_to_buffer
1605
                     (const PgQuery__ArrayCoerceExpr *message,
1606
                      ProtobufCBuffer *buffer)
1607
0
{
1608
0
  assert(message->base.descriptor == &pg_query__array_coerce_expr__descriptor);
1609
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1610
0
}
1611
PgQuery__ArrayCoerceExpr *
1612
       pg_query__array_coerce_expr__unpack
1613
                     (ProtobufCAllocator  *allocator,
1614
                      size_t               len,
1615
                      const uint8_t       *data)
1616
0
{
1617
0
  return (PgQuery__ArrayCoerceExpr *)
1618
0
     protobuf_c_message_unpack (&pg_query__array_coerce_expr__descriptor,
1619
0
                                allocator, len, data);
1620
0
}
1621
void   pg_query__array_coerce_expr__free_unpacked
1622
                     (PgQuery__ArrayCoerceExpr *message,
1623
                      ProtobufCAllocator *allocator)
1624
0
{
1625
0
  if(!message)
1626
0
    return;
1627
0
  assert(message->base.descriptor == &pg_query__array_coerce_expr__descriptor);
1628
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1629
0
}
1630
void   pg_query__convert_rowtype_expr__init
1631
                     (PgQuery__ConvertRowtypeExpr         *message)
1632
0
{
1633
0
  static const PgQuery__ConvertRowtypeExpr init_value = PG_QUERY__CONVERT_ROWTYPE_EXPR__INIT;
1634
0
  *message = init_value;
1635
0
}
1636
size_t pg_query__convert_rowtype_expr__get_packed_size
1637
                     (const PgQuery__ConvertRowtypeExpr *message)
1638
0
{
1639
0
  assert(message->base.descriptor == &pg_query__convert_rowtype_expr__descriptor);
1640
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1641
0
}
1642
size_t pg_query__convert_rowtype_expr__pack
1643
                     (const PgQuery__ConvertRowtypeExpr *message,
1644
                      uint8_t       *out)
1645
0
{
1646
0
  assert(message->base.descriptor == &pg_query__convert_rowtype_expr__descriptor);
1647
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1648
0
}
1649
size_t pg_query__convert_rowtype_expr__pack_to_buffer
1650
                     (const PgQuery__ConvertRowtypeExpr *message,
1651
                      ProtobufCBuffer *buffer)
1652
0
{
1653
0
  assert(message->base.descriptor == &pg_query__convert_rowtype_expr__descriptor);
1654
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1655
0
}
1656
PgQuery__ConvertRowtypeExpr *
1657
       pg_query__convert_rowtype_expr__unpack
1658
                     (ProtobufCAllocator  *allocator,
1659
                      size_t               len,
1660
                      const uint8_t       *data)
1661
0
{
1662
0
  return (PgQuery__ConvertRowtypeExpr *)
1663
0
     protobuf_c_message_unpack (&pg_query__convert_rowtype_expr__descriptor,
1664
0
                                allocator, len, data);
1665
0
}
1666
void   pg_query__convert_rowtype_expr__free_unpacked
1667
                     (PgQuery__ConvertRowtypeExpr *message,
1668
                      ProtobufCAllocator *allocator)
1669
0
{
1670
0
  if(!message)
1671
0
    return;
1672
0
  assert(message->base.descriptor == &pg_query__convert_rowtype_expr__descriptor);
1673
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1674
0
}
1675
void   pg_query__collate_expr__init
1676
                     (PgQuery__CollateExpr         *message)
1677
0
{
1678
0
  static const PgQuery__CollateExpr init_value = PG_QUERY__COLLATE_EXPR__INIT;
1679
0
  *message = init_value;
1680
0
}
1681
size_t pg_query__collate_expr__get_packed_size
1682
                     (const PgQuery__CollateExpr *message)
1683
0
{
1684
0
  assert(message->base.descriptor == &pg_query__collate_expr__descriptor);
1685
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1686
0
}
1687
size_t pg_query__collate_expr__pack
1688
                     (const PgQuery__CollateExpr *message,
1689
                      uint8_t       *out)
1690
0
{
1691
0
  assert(message->base.descriptor == &pg_query__collate_expr__descriptor);
1692
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1693
0
}
1694
size_t pg_query__collate_expr__pack_to_buffer
1695
                     (const PgQuery__CollateExpr *message,
1696
                      ProtobufCBuffer *buffer)
1697
0
{
1698
0
  assert(message->base.descriptor == &pg_query__collate_expr__descriptor);
1699
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1700
0
}
1701
PgQuery__CollateExpr *
1702
       pg_query__collate_expr__unpack
1703
                     (ProtobufCAllocator  *allocator,
1704
                      size_t               len,
1705
                      const uint8_t       *data)
1706
0
{
1707
0
  return (PgQuery__CollateExpr *)
1708
0
     protobuf_c_message_unpack (&pg_query__collate_expr__descriptor,
1709
0
                                allocator, len, data);
1710
0
}
1711
void   pg_query__collate_expr__free_unpacked
1712
                     (PgQuery__CollateExpr *message,
1713
                      ProtobufCAllocator *allocator)
1714
0
{
1715
0
  if(!message)
1716
0
    return;
1717
0
  assert(message->base.descriptor == &pg_query__collate_expr__descriptor);
1718
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1719
0
}
1720
void   pg_query__case_expr__init
1721
                     (PgQuery__CaseExpr         *message)
1722
0
{
1723
0
  static const PgQuery__CaseExpr init_value = PG_QUERY__CASE_EXPR__INIT;
1724
0
  *message = init_value;
1725
0
}
1726
size_t pg_query__case_expr__get_packed_size
1727
                     (const PgQuery__CaseExpr *message)
1728
0
{
1729
0
  assert(message->base.descriptor == &pg_query__case_expr__descriptor);
1730
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1731
0
}
1732
size_t pg_query__case_expr__pack
1733
                     (const PgQuery__CaseExpr *message,
1734
                      uint8_t       *out)
1735
0
{
1736
0
  assert(message->base.descriptor == &pg_query__case_expr__descriptor);
1737
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1738
0
}
1739
size_t pg_query__case_expr__pack_to_buffer
1740
                     (const PgQuery__CaseExpr *message,
1741
                      ProtobufCBuffer *buffer)
1742
0
{
1743
0
  assert(message->base.descriptor == &pg_query__case_expr__descriptor);
1744
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1745
0
}
1746
PgQuery__CaseExpr *
1747
       pg_query__case_expr__unpack
1748
                     (ProtobufCAllocator  *allocator,
1749
                      size_t               len,
1750
                      const uint8_t       *data)
1751
0
{
1752
0
  return (PgQuery__CaseExpr *)
1753
0
     protobuf_c_message_unpack (&pg_query__case_expr__descriptor,
1754
0
                                allocator, len, data);
1755
0
}
1756
void   pg_query__case_expr__free_unpacked
1757
                     (PgQuery__CaseExpr *message,
1758
                      ProtobufCAllocator *allocator)
1759
0
{
1760
0
  if(!message)
1761
0
    return;
1762
0
  assert(message->base.descriptor == &pg_query__case_expr__descriptor);
1763
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1764
0
}
1765
void   pg_query__case_when__init
1766
                     (PgQuery__CaseWhen         *message)
1767
0
{
1768
0
  static const PgQuery__CaseWhen init_value = PG_QUERY__CASE_WHEN__INIT;
1769
0
  *message = init_value;
1770
0
}
1771
size_t pg_query__case_when__get_packed_size
1772
                     (const PgQuery__CaseWhen *message)
1773
0
{
1774
0
  assert(message->base.descriptor == &pg_query__case_when__descriptor);
1775
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1776
0
}
1777
size_t pg_query__case_when__pack
1778
                     (const PgQuery__CaseWhen *message,
1779
                      uint8_t       *out)
1780
0
{
1781
0
  assert(message->base.descriptor == &pg_query__case_when__descriptor);
1782
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1783
0
}
1784
size_t pg_query__case_when__pack_to_buffer
1785
                     (const PgQuery__CaseWhen *message,
1786
                      ProtobufCBuffer *buffer)
1787
0
{
1788
0
  assert(message->base.descriptor == &pg_query__case_when__descriptor);
1789
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1790
0
}
1791
PgQuery__CaseWhen *
1792
       pg_query__case_when__unpack
1793
                     (ProtobufCAllocator  *allocator,
1794
                      size_t               len,
1795
                      const uint8_t       *data)
1796
0
{
1797
0
  return (PgQuery__CaseWhen *)
1798
0
     protobuf_c_message_unpack (&pg_query__case_when__descriptor,
1799
0
                                allocator, len, data);
1800
0
}
1801
void   pg_query__case_when__free_unpacked
1802
                     (PgQuery__CaseWhen *message,
1803
                      ProtobufCAllocator *allocator)
1804
0
{
1805
0
  if(!message)
1806
0
    return;
1807
0
  assert(message->base.descriptor == &pg_query__case_when__descriptor);
1808
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1809
0
}
1810
void   pg_query__case_test_expr__init
1811
                     (PgQuery__CaseTestExpr         *message)
1812
0
{
1813
0
  static const PgQuery__CaseTestExpr init_value = PG_QUERY__CASE_TEST_EXPR__INIT;
1814
0
  *message = init_value;
1815
0
}
1816
size_t pg_query__case_test_expr__get_packed_size
1817
                     (const PgQuery__CaseTestExpr *message)
1818
0
{
1819
0
  assert(message->base.descriptor == &pg_query__case_test_expr__descriptor);
1820
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1821
0
}
1822
size_t pg_query__case_test_expr__pack
1823
                     (const PgQuery__CaseTestExpr *message,
1824
                      uint8_t       *out)
1825
0
{
1826
0
  assert(message->base.descriptor == &pg_query__case_test_expr__descriptor);
1827
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1828
0
}
1829
size_t pg_query__case_test_expr__pack_to_buffer
1830
                     (const PgQuery__CaseTestExpr *message,
1831
                      ProtobufCBuffer *buffer)
1832
0
{
1833
0
  assert(message->base.descriptor == &pg_query__case_test_expr__descriptor);
1834
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1835
0
}
1836
PgQuery__CaseTestExpr *
1837
       pg_query__case_test_expr__unpack
1838
                     (ProtobufCAllocator  *allocator,
1839
                      size_t               len,
1840
                      const uint8_t       *data)
1841
0
{
1842
0
  return (PgQuery__CaseTestExpr *)
1843
0
     protobuf_c_message_unpack (&pg_query__case_test_expr__descriptor,
1844
0
                                allocator, len, data);
1845
0
}
1846
void   pg_query__case_test_expr__free_unpacked
1847
                     (PgQuery__CaseTestExpr *message,
1848
                      ProtobufCAllocator *allocator)
1849
0
{
1850
0
  if(!message)
1851
0
    return;
1852
0
  assert(message->base.descriptor == &pg_query__case_test_expr__descriptor);
1853
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1854
0
}
1855
void   pg_query__array_expr__init
1856
                     (PgQuery__ArrayExpr         *message)
1857
0
{
1858
0
  static const PgQuery__ArrayExpr init_value = PG_QUERY__ARRAY_EXPR__INIT;
1859
0
  *message = init_value;
1860
0
}
1861
size_t pg_query__array_expr__get_packed_size
1862
                     (const PgQuery__ArrayExpr *message)
1863
0
{
1864
0
  assert(message->base.descriptor == &pg_query__array_expr__descriptor);
1865
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1866
0
}
1867
size_t pg_query__array_expr__pack
1868
                     (const PgQuery__ArrayExpr *message,
1869
                      uint8_t       *out)
1870
0
{
1871
0
  assert(message->base.descriptor == &pg_query__array_expr__descriptor);
1872
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1873
0
}
1874
size_t pg_query__array_expr__pack_to_buffer
1875
                     (const PgQuery__ArrayExpr *message,
1876
                      ProtobufCBuffer *buffer)
1877
0
{
1878
0
  assert(message->base.descriptor == &pg_query__array_expr__descriptor);
1879
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1880
0
}
1881
PgQuery__ArrayExpr *
1882
       pg_query__array_expr__unpack
1883
                     (ProtobufCAllocator  *allocator,
1884
                      size_t               len,
1885
                      const uint8_t       *data)
1886
0
{
1887
0
  return (PgQuery__ArrayExpr *)
1888
0
     protobuf_c_message_unpack (&pg_query__array_expr__descriptor,
1889
0
                                allocator, len, data);
1890
0
}
1891
void   pg_query__array_expr__free_unpacked
1892
                     (PgQuery__ArrayExpr *message,
1893
                      ProtobufCAllocator *allocator)
1894
0
{
1895
0
  if(!message)
1896
0
    return;
1897
0
  assert(message->base.descriptor == &pg_query__array_expr__descriptor);
1898
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1899
0
}
1900
void   pg_query__row_expr__init
1901
                     (PgQuery__RowExpr         *message)
1902
0
{
1903
0
  static const PgQuery__RowExpr init_value = PG_QUERY__ROW_EXPR__INIT;
1904
0
  *message = init_value;
1905
0
}
1906
size_t pg_query__row_expr__get_packed_size
1907
                     (const PgQuery__RowExpr *message)
1908
0
{
1909
0
  assert(message->base.descriptor == &pg_query__row_expr__descriptor);
1910
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1911
0
}
1912
size_t pg_query__row_expr__pack
1913
                     (const PgQuery__RowExpr *message,
1914
                      uint8_t       *out)
1915
0
{
1916
0
  assert(message->base.descriptor == &pg_query__row_expr__descriptor);
1917
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1918
0
}
1919
size_t pg_query__row_expr__pack_to_buffer
1920
                     (const PgQuery__RowExpr *message,
1921
                      ProtobufCBuffer *buffer)
1922
0
{
1923
0
  assert(message->base.descriptor == &pg_query__row_expr__descriptor);
1924
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1925
0
}
1926
PgQuery__RowExpr *
1927
       pg_query__row_expr__unpack
1928
                     (ProtobufCAllocator  *allocator,
1929
                      size_t               len,
1930
                      const uint8_t       *data)
1931
0
{
1932
0
  return (PgQuery__RowExpr *)
1933
0
     protobuf_c_message_unpack (&pg_query__row_expr__descriptor,
1934
0
                                allocator, len, data);
1935
0
}
1936
void   pg_query__row_expr__free_unpacked
1937
                     (PgQuery__RowExpr *message,
1938
                      ProtobufCAllocator *allocator)
1939
0
{
1940
0
  if(!message)
1941
0
    return;
1942
0
  assert(message->base.descriptor == &pg_query__row_expr__descriptor);
1943
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1944
0
}
1945
void   pg_query__row_compare_expr__init
1946
                     (PgQuery__RowCompareExpr         *message)
1947
0
{
1948
0
  static const PgQuery__RowCompareExpr init_value = PG_QUERY__ROW_COMPARE_EXPR__INIT;
1949
0
  *message = init_value;
1950
0
}
1951
size_t pg_query__row_compare_expr__get_packed_size
1952
                     (const PgQuery__RowCompareExpr *message)
1953
0
{
1954
0
  assert(message->base.descriptor == &pg_query__row_compare_expr__descriptor);
1955
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1956
0
}
1957
size_t pg_query__row_compare_expr__pack
1958
                     (const PgQuery__RowCompareExpr *message,
1959
                      uint8_t       *out)
1960
0
{
1961
0
  assert(message->base.descriptor == &pg_query__row_compare_expr__descriptor);
1962
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1963
0
}
1964
size_t pg_query__row_compare_expr__pack_to_buffer
1965
                     (const PgQuery__RowCompareExpr *message,
1966
                      ProtobufCBuffer *buffer)
1967
0
{
1968
0
  assert(message->base.descriptor == &pg_query__row_compare_expr__descriptor);
1969
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1970
0
}
1971
PgQuery__RowCompareExpr *
1972
       pg_query__row_compare_expr__unpack
1973
                     (ProtobufCAllocator  *allocator,
1974
                      size_t               len,
1975
                      const uint8_t       *data)
1976
0
{
1977
0
  return (PgQuery__RowCompareExpr *)
1978
0
     protobuf_c_message_unpack (&pg_query__row_compare_expr__descriptor,
1979
0
                                allocator, len, data);
1980
0
}
1981
void   pg_query__row_compare_expr__free_unpacked
1982
                     (PgQuery__RowCompareExpr *message,
1983
                      ProtobufCAllocator *allocator)
1984
0
{
1985
0
  if(!message)
1986
0
    return;
1987
0
  assert(message->base.descriptor == &pg_query__row_compare_expr__descriptor);
1988
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1989
0
}
1990
void   pg_query__coalesce_expr__init
1991
                     (PgQuery__CoalesceExpr         *message)
1992
0
{
1993
0
  static const PgQuery__CoalesceExpr init_value = PG_QUERY__COALESCE_EXPR__INIT;
1994
0
  *message = init_value;
1995
0
}
1996
size_t pg_query__coalesce_expr__get_packed_size
1997
                     (const PgQuery__CoalesceExpr *message)
1998
0
{
1999
0
  assert(message->base.descriptor == &pg_query__coalesce_expr__descriptor);
2000
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2001
0
}
2002
size_t pg_query__coalesce_expr__pack
2003
                     (const PgQuery__CoalesceExpr *message,
2004
                      uint8_t       *out)
2005
0
{
2006
0
  assert(message->base.descriptor == &pg_query__coalesce_expr__descriptor);
2007
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2008
0
}
2009
size_t pg_query__coalesce_expr__pack_to_buffer
2010
                     (const PgQuery__CoalesceExpr *message,
2011
                      ProtobufCBuffer *buffer)
2012
0
{
2013
0
  assert(message->base.descriptor == &pg_query__coalesce_expr__descriptor);
2014
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2015
0
}
2016
PgQuery__CoalesceExpr *
2017
       pg_query__coalesce_expr__unpack
2018
                     (ProtobufCAllocator  *allocator,
2019
                      size_t               len,
2020
                      const uint8_t       *data)
2021
0
{
2022
0
  return (PgQuery__CoalesceExpr *)
2023
0
     protobuf_c_message_unpack (&pg_query__coalesce_expr__descriptor,
2024
0
                                allocator, len, data);
2025
0
}
2026
void   pg_query__coalesce_expr__free_unpacked
2027
                     (PgQuery__CoalesceExpr *message,
2028
                      ProtobufCAllocator *allocator)
2029
0
{
2030
0
  if(!message)
2031
0
    return;
2032
0
  assert(message->base.descriptor == &pg_query__coalesce_expr__descriptor);
2033
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2034
0
}
2035
void   pg_query__min_max_expr__init
2036
                     (PgQuery__MinMaxExpr         *message)
2037
0
{
2038
0
  static const PgQuery__MinMaxExpr init_value = PG_QUERY__MIN_MAX_EXPR__INIT;
2039
0
  *message = init_value;
2040
0
}
2041
size_t pg_query__min_max_expr__get_packed_size
2042
                     (const PgQuery__MinMaxExpr *message)
2043
0
{
2044
0
  assert(message->base.descriptor == &pg_query__min_max_expr__descriptor);
2045
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2046
0
}
2047
size_t pg_query__min_max_expr__pack
2048
                     (const PgQuery__MinMaxExpr *message,
2049
                      uint8_t       *out)
2050
0
{
2051
0
  assert(message->base.descriptor == &pg_query__min_max_expr__descriptor);
2052
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2053
0
}
2054
size_t pg_query__min_max_expr__pack_to_buffer
2055
                     (const PgQuery__MinMaxExpr *message,
2056
                      ProtobufCBuffer *buffer)
2057
0
{
2058
0
  assert(message->base.descriptor == &pg_query__min_max_expr__descriptor);
2059
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2060
0
}
2061
PgQuery__MinMaxExpr *
2062
       pg_query__min_max_expr__unpack
2063
                     (ProtobufCAllocator  *allocator,
2064
                      size_t               len,
2065
                      const uint8_t       *data)
2066
0
{
2067
0
  return (PgQuery__MinMaxExpr *)
2068
0
     protobuf_c_message_unpack (&pg_query__min_max_expr__descriptor,
2069
0
                                allocator, len, data);
2070
0
}
2071
void   pg_query__min_max_expr__free_unpacked
2072
                     (PgQuery__MinMaxExpr *message,
2073
                      ProtobufCAllocator *allocator)
2074
0
{
2075
0
  if(!message)
2076
0
    return;
2077
0
  assert(message->base.descriptor == &pg_query__min_max_expr__descriptor);
2078
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2079
0
}
2080
void   pg_query__sqlvalue_function__init
2081
                     (PgQuery__SQLValueFunction         *message)
2082
0
{
2083
0
  static const PgQuery__SQLValueFunction init_value = PG_QUERY__SQLVALUE_FUNCTION__INIT;
2084
0
  *message = init_value;
2085
0
}
2086
size_t pg_query__sqlvalue_function__get_packed_size
2087
                     (const PgQuery__SQLValueFunction *message)
2088
0
{
2089
0
  assert(message->base.descriptor == &pg_query__sqlvalue_function__descriptor);
2090
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2091
0
}
2092
size_t pg_query__sqlvalue_function__pack
2093
                     (const PgQuery__SQLValueFunction *message,
2094
                      uint8_t       *out)
2095
0
{
2096
0
  assert(message->base.descriptor == &pg_query__sqlvalue_function__descriptor);
2097
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2098
0
}
2099
size_t pg_query__sqlvalue_function__pack_to_buffer
2100
                     (const PgQuery__SQLValueFunction *message,
2101
                      ProtobufCBuffer *buffer)
2102
0
{
2103
0
  assert(message->base.descriptor == &pg_query__sqlvalue_function__descriptor);
2104
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2105
0
}
2106
PgQuery__SQLValueFunction *
2107
       pg_query__sqlvalue_function__unpack
2108
                     (ProtobufCAllocator  *allocator,
2109
                      size_t               len,
2110
                      const uint8_t       *data)
2111
0
{
2112
0
  return (PgQuery__SQLValueFunction *)
2113
0
     protobuf_c_message_unpack (&pg_query__sqlvalue_function__descriptor,
2114
0
                                allocator, len, data);
2115
0
}
2116
void   pg_query__sqlvalue_function__free_unpacked
2117
                     (PgQuery__SQLValueFunction *message,
2118
                      ProtobufCAllocator *allocator)
2119
0
{
2120
0
  if(!message)
2121
0
    return;
2122
0
  assert(message->base.descriptor == &pg_query__sqlvalue_function__descriptor);
2123
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2124
0
}
2125
void   pg_query__xml_expr__init
2126
                     (PgQuery__XmlExpr         *message)
2127
0
{
2128
0
  static const PgQuery__XmlExpr init_value = PG_QUERY__XML_EXPR__INIT;
2129
0
  *message = init_value;
2130
0
}
2131
size_t pg_query__xml_expr__get_packed_size
2132
                     (const PgQuery__XmlExpr *message)
2133
0
{
2134
0
  assert(message->base.descriptor == &pg_query__xml_expr__descriptor);
2135
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2136
0
}
2137
size_t pg_query__xml_expr__pack
2138
                     (const PgQuery__XmlExpr *message,
2139
                      uint8_t       *out)
2140
0
{
2141
0
  assert(message->base.descriptor == &pg_query__xml_expr__descriptor);
2142
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2143
0
}
2144
size_t pg_query__xml_expr__pack_to_buffer
2145
                     (const PgQuery__XmlExpr *message,
2146
                      ProtobufCBuffer *buffer)
2147
0
{
2148
0
  assert(message->base.descriptor == &pg_query__xml_expr__descriptor);
2149
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2150
0
}
2151
PgQuery__XmlExpr *
2152
       pg_query__xml_expr__unpack
2153
                     (ProtobufCAllocator  *allocator,
2154
                      size_t               len,
2155
                      const uint8_t       *data)
2156
0
{
2157
0
  return (PgQuery__XmlExpr *)
2158
0
     protobuf_c_message_unpack (&pg_query__xml_expr__descriptor,
2159
0
                                allocator, len, data);
2160
0
}
2161
void   pg_query__xml_expr__free_unpacked
2162
                     (PgQuery__XmlExpr *message,
2163
                      ProtobufCAllocator *allocator)
2164
0
{
2165
0
  if(!message)
2166
0
    return;
2167
0
  assert(message->base.descriptor == &pg_query__xml_expr__descriptor);
2168
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2169
0
}
2170
void   pg_query__null_test__init
2171
                     (PgQuery__NullTest         *message)
2172
0
{
2173
0
  static const PgQuery__NullTest init_value = PG_QUERY__NULL_TEST__INIT;
2174
0
  *message = init_value;
2175
0
}
2176
size_t pg_query__null_test__get_packed_size
2177
                     (const PgQuery__NullTest *message)
2178
0
{
2179
0
  assert(message->base.descriptor == &pg_query__null_test__descriptor);
2180
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2181
0
}
2182
size_t pg_query__null_test__pack
2183
                     (const PgQuery__NullTest *message,
2184
                      uint8_t       *out)
2185
0
{
2186
0
  assert(message->base.descriptor == &pg_query__null_test__descriptor);
2187
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2188
0
}
2189
size_t pg_query__null_test__pack_to_buffer
2190
                     (const PgQuery__NullTest *message,
2191
                      ProtobufCBuffer *buffer)
2192
0
{
2193
0
  assert(message->base.descriptor == &pg_query__null_test__descriptor);
2194
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2195
0
}
2196
PgQuery__NullTest *
2197
       pg_query__null_test__unpack
2198
                     (ProtobufCAllocator  *allocator,
2199
                      size_t               len,
2200
                      const uint8_t       *data)
2201
0
{
2202
0
  return (PgQuery__NullTest *)
2203
0
     protobuf_c_message_unpack (&pg_query__null_test__descriptor,
2204
0
                                allocator, len, data);
2205
0
}
2206
void   pg_query__null_test__free_unpacked
2207
                     (PgQuery__NullTest *message,
2208
                      ProtobufCAllocator *allocator)
2209
0
{
2210
0
  if(!message)
2211
0
    return;
2212
0
  assert(message->base.descriptor == &pg_query__null_test__descriptor);
2213
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2214
0
}
2215
void   pg_query__boolean_test__init
2216
                     (PgQuery__BooleanTest         *message)
2217
0
{
2218
0
  static const PgQuery__BooleanTest init_value = PG_QUERY__BOOLEAN_TEST__INIT;
2219
0
  *message = init_value;
2220
0
}
2221
size_t pg_query__boolean_test__get_packed_size
2222
                     (const PgQuery__BooleanTest *message)
2223
0
{
2224
0
  assert(message->base.descriptor == &pg_query__boolean_test__descriptor);
2225
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2226
0
}
2227
size_t pg_query__boolean_test__pack
2228
                     (const PgQuery__BooleanTest *message,
2229
                      uint8_t       *out)
2230
0
{
2231
0
  assert(message->base.descriptor == &pg_query__boolean_test__descriptor);
2232
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2233
0
}
2234
size_t pg_query__boolean_test__pack_to_buffer
2235
                     (const PgQuery__BooleanTest *message,
2236
                      ProtobufCBuffer *buffer)
2237
0
{
2238
0
  assert(message->base.descriptor == &pg_query__boolean_test__descriptor);
2239
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2240
0
}
2241
PgQuery__BooleanTest *
2242
       pg_query__boolean_test__unpack
2243
                     (ProtobufCAllocator  *allocator,
2244
                      size_t               len,
2245
                      const uint8_t       *data)
2246
0
{
2247
0
  return (PgQuery__BooleanTest *)
2248
0
     protobuf_c_message_unpack (&pg_query__boolean_test__descriptor,
2249
0
                                allocator, len, data);
2250
0
}
2251
void   pg_query__boolean_test__free_unpacked
2252
                     (PgQuery__BooleanTest *message,
2253
                      ProtobufCAllocator *allocator)
2254
0
{
2255
0
  if(!message)
2256
0
    return;
2257
0
  assert(message->base.descriptor == &pg_query__boolean_test__descriptor);
2258
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2259
0
}
2260
void   pg_query__coerce_to_domain__init
2261
                     (PgQuery__CoerceToDomain         *message)
2262
0
{
2263
0
  static const PgQuery__CoerceToDomain init_value = PG_QUERY__COERCE_TO_DOMAIN__INIT;
2264
0
  *message = init_value;
2265
0
}
2266
size_t pg_query__coerce_to_domain__get_packed_size
2267
                     (const PgQuery__CoerceToDomain *message)
2268
0
{
2269
0
  assert(message->base.descriptor == &pg_query__coerce_to_domain__descriptor);
2270
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2271
0
}
2272
size_t pg_query__coerce_to_domain__pack
2273
                     (const PgQuery__CoerceToDomain *message,
2274
                      uint8_t       *out)
2275
0
{
2276
0
  assert(message->base.descriptor == &pg_query__coerce_to_domain__descriptor);
2277
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2278
0
}
2279
size_t pg_query__coerce_to_domain__pack_to_buffer
2280
                     (const PgQuery__CoerceToDomain *message,
2281
                      ProtobufCBuffer *buffer)
2282
0
{
2283
0
  assert(message->base.descriptor == &pg_query__coerce_to_domain__descriptor);
2284
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2285
0
}
2286
PgQuery__CoerceToDomain *
2287
       pg_query__coerce_to_domain__unpack
2288
                     (ProtobufCAllocator  *allocator,
2289
                      size_t               len,
2290
                      const uint8_t       *data)
2291
0
{
2292
0
  return (PgQuery__CoerceToDomain *)
2293
0
     protobuf_c_message_unpack (&pg_query__coerce_to_domain__descriptor,
2294
0
                                allocator, len, data);
2295
0
}
2296
void   pg_query__coerce_to_domain__free_unpacked
2297
                     (PgQuery__CoerceToDomain *message,
2298
                      ProtobufCAllocator *allocator)
2299
0
{
2300
0
  if(!message)
2301
0
    return;
2302
0
  assert(message->base.descriptor == &pg_query__coerce_to_domain__descriptor);
2303
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2304
0
}
2305
void   pg_query__coerce_to_domain_value__init
2306
                     (PgQuery__CoerceToDomainValue         *message)
2307
0
{
2308
0
  static const PgQuery__CoerceToDomainValue init_value = PG_QUERY__COERCE_TO_DOMAIN_VALUE__INIT;
2309
0
  *message = init_value;
2310
0
}
2311
size_t pg_query__coerce_to_domain_value__get_packed_size
2312
                     (const PgQuery__CoerceToDomainValue *message)
2313
0
{
2314
0
  assert(message->base.descriptor == &pg_query__coerce_to_domain_value__descriptor);
2315
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2316
0
}
2317
size_t pg_query__coerce_to_domain_value__pack
2318
                     (const PgQuery__CoerceToDomainValue *message,
2319
                      uint8_t       *out)
2320
0
{
2321
0
  assert(message->base.descriptor == &pg_query__coerce_to_domain_value__descriptor);
2322
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2323
0
}
2324
size_t pg_query__coerce_to_domain_value__pack_to_buffer
2325
                     (const PgQuery__CoerceToDomainValue *message,
2326
                      ProtobufCBuffer *buffer)
2327
0
{
2328
0
  assert(message->base.descriptor == &pg_query__coerce_to_domain_value__descriptor);
2329
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2330
0
}
2331
PgQuery__CoerceToDomainValue *
2332
       pg_query__coerce_to_domain_value__unpack
2333
                     (ProtobufCAllocator  *allocator,
2334
                      size_t               len,
2335
                      const uint8_t       *data)
2336
0
{
2337
0
  return (PgQuery__CoerceToDomainValue *)
2338
0
     protobuf_c_message_unpack (&pg_query__coerce_to_domain_value__descriptor,
2339
0
                                allocator, len, data);
2340
0
}
2341
void   pg_query__coerce_to_domain_value__free_unpacked
2342
                     (PgQuery__CoerceToDomainValue *message,
2343
                      ProtobufCAllocator *allocator)
2344
0
{
2345
0
  if(!message)
2346
0
    return;
2347
0
  assert(message->base.descriptor == &pg_query__coerce_to_domain_value__descriptor);
2348
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2349
0
}
2350
void   pg_query__set_to_default__init
2351
                     (PgQuery__SetToDefault         *message)
2352
0
{
2353
0
  static const PgQuery__SetToDefault init_value = PG_QUERY__SET_TO_DEFAULT__INIT;
2354
0
  *message = init_value;
2355
0
}
2356
size_t pg_query__set_to_default__get_packed_size
2357
                     (const PgQuery__SetToDefault *message)
2358
0
{
2359
0
  assert(message->base.descriptor == &pg_query__set_to_default__descriptor);
2360
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2361
0
}
2362
size_t pg_query__set_to_default__pack
2363
                     (const PgQuery__SetToDefault *message,
2364
                      uint8_t       *out)
2365
0
{
2366
0
  assert(message->base.descriptor == &pg_query__set_to_default__descriptor);
2367
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2368
0
}
2369
size_t pg_query__set_to_default__pack_to_buffer
2370
                     (const PgQuery__SetToDefault *message,
2371
                      ProtobufCBuffer *buffer)
2372
0
{
2373
0
  assert(message->base.descriptor == &pg_query__set_to_default__descriptor);
2374
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2375
0
}
2376
PgQuery__SetToDefault *
2377
       pg_query__set_to_default__unpack
2378
                     (ProtobufCAllocator  *allocator,
2379
                      size_t               len,
2380
                      const uint8_t       *data)
2381
0
{
2382
0
  return (PgQuery__SetToDefault *)
2383
0
     protobuf_c_message_unpack (&pg_query__set_to_default__descriptor,
2384
0
                                allocator, len, data);
2385
0
}
2386
void   pg_query__set_to_default__free_unpacked
2387
                     (PgQuery__SetToDefault *message,
2388
                      ProtobufCAllocator *allocator)
2389
0
{
2390
0
  if(!message)
2391
0
    return;
2392
0
  assert(message->base.descriptor == &pg_query__set_to_default__descriptor);
2393
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2394
0
}
2395
void   pg_query__current_of_expr__init
2396
                     (PgQuery__CurrentOfExpr         *message)
2397
0
{
2398
0
  static const PgQuery__CurrentOfExpr init_value = PG_QUERY__CURRENT_OF_EXPR__INIT;
2399
0
  *message = init_value;
2400
0
}
2401
size_t pg_query__current_of_expr__get_packed_size
2402
                     (const PgQuery__CurrentOfExpr *message)
2403
0
{
2404
0
  assert(message->base.descriptor == &pg_query__current_of_expr__descriptor);
2405
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2406
0
}
2407
size_t pg_query__current_of_expr__pack
2408
                     (const PgQuery__CurrentOfExpr *message,
2409
                      uint8_t       *out)
2410
0
{
2411
0
  assert(message->base.descriptor == &pg_query__current_of_expr__descriptor);
2412
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2413
0
}
2414
size_t pg_query__current_of_expr__pack_to_buffer
2415
                     (const PgQuery__CurrentOfExpr *message,
2416
                      ProtobufCBuffer *buffer)
2417
0
{
2418
0
  assert(message->base.descriptor == &pg_query__current_of_expr__descriptor);
2419
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2420
0
}
2421
PgQuery__CurrentOfExpr *
2422
       pg_query__current_of_expr__unpack
2423
                     (ProtobufCAllocator  *allocator,
2424
                      size_t               len,
2425
                      const uint8_t       *data)
2426
0
{
2427
0
  return (PgQuery__CurrentOfExpr *)
2428
0
     protobuf_c_message_unpack (&pg_query__current_of_expr__descriptor,
2429
0
                                allocator, len, data);
2430
0
}
2431
void   pg_query__current_of_expr__free_unpacked
2432
                     (PgQuery__CurrentOfExpr *message,
2433
                      ProtobufCAllocator *allocator)
2434
0
{
2435
0
  if(!message)
2436
0
    return;
2437
0
  assert(message->base.descriptor == &pg_query__current_of_expr__descriptor);
2438
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2439
0
}
2440
void   pg_query__next_value_expr__init
2441
                     (PgQuery__NextValueExpr         *message)
2442
0
{
2443
0
  static const PgQuery__NextValueExpr init_value = PG_QUERY__NEXT_VALUE_EXPR__INIT;
2444
0
  *message = init_value;
2445
0
}
2446
size_t pg_query__next_value_expr__get_packed_size
2447
                     (const PgQuery__NextValueExpr *message)
2448
0
{
2449
0
  assert(message->base.descriptor == &pg_query__next_value_expr__descriptor);
2450
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2451
0
}
2452
size_t pg_query__next_value_expr__pack
2453
                     (const PgQuery__NextValueExpr *message,
2454
                      uint8_t       *out)
2455
0
{
2456
0
  assert(message->base.descriptor == &pg_query__next_value_expr__descriptor);
2457
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2458
0
}
2459
size_t pg_query__next_value_expr__pack_to_buffer
2460
                     (const PgQuery__NextValueExpr *message,
2461
                      ProtobufCBuffer *buffer)
2462
0
{
2463
0
  assert(message->base.descriptor == &pg_query__next_value_expr__descriptor);
2464
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2465
0
}
2466
PgQuery__NextValueExpr *
2467
       pg_query__next_value_expr__unpack
2468
                     (ProtobufCAllocator  *allocator,
2469
                      size_t               len,
2470
                      const uint8_t       *data)
2471
0
{
2472
0
  return (PgQuery__NextValueExpr *)
2473
0
     protobuf_c_message_unpack (&pg_query__next_value_expr__descriptor,
2474
0
                                allocator, len, data);
2475
0
}
2476
void   pg_query__next_value_expr__free_unpacked
2477
                     (PgQuery__NextValueExpr *message,
2478
                      ProtobufCAllocator *allocator)
2479
0
{
2480
0
  if(!message)
2481
0
    return;
2482
0
  assert(message->base.descriptor == &pg_query__next_value_expr__descriptor);
2483
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2484
0
}
2485
void   pg_query__inference_elem__init
2486
                     (PgQuery__InferenceElem         *message)
2487
0
{
2488
0
  static const PgQuery__InferenceElem init_value = PG_QUERY__INFERENCE_ELEM__INIT;
2489
0
  *message = init_value;
2490
0
}
2491
size_t pg_query__inference_elem__get_packed_size
2492
                     (const PgQuery__InferenceElem *message)
2493
0
{
2494
0
  assert(message->base.descriptor == &pg_query__inference_elem__descriptor);
2495
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2496
0
}
2497
size_t pg_query__inference_elem__pack
2498
                     (const PgQuery__InferenceElem *message,
2499
                      uint8_t       *out)
2500
0
{
2501
0
  assert(message->base.descriptor == &pg_query__inference_elem__descriptor);
2502
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2503
0
}
2504
size_t pg_query__inference_elem__pack_to_buffer
2505
                     (const PgQuery__InferenceElem *message,
2506
                      ProtobufCBuffer *buffer)
2507
0
{
2508
0
  assert(message->base.descriptor == &pg_query__inference_elem__descriptor);
2509
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2510
0
}
2511
PgQuery__InferenceElem *
2512
       pg_query__inference_elem__unpack
2513
                     (ProtobufCAllocator  *allocator,
2514
                      size_t               len,
2515
                      const uint8_t       *data)
2516
0
{
2517
0
  return (PgQuery__InferenceElem *)
2518
0
     protobuf_c_message_unpack (&pg_query__inference_elem__descriptor,
2519
0
                                allocator, len, data);
2520
0
}
2521
void   pg_query__inference_elem__free_unpacked
2522
                     (PgQuery__InferenceElem *message,
2523
                      ProtobufCAllocator *allocator)
2524
0
{
2525
0
  if(!message)
2526
0
    return;
2527
0
  assert(message->base.descriptor == &pg_query__inference_elem__descriptor);
2528
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2529
0
}
2530
void   pg_query__target_entry__init
2531
                     (PgQuery__TargetEntry         *message)
2532
0
{
2533
0
  static const PgQuery__TargetEntry init_value = PG_QUERY__TARGET_ENTRY__INIT;
2534
0
  *message = init_value;
2535
0
}
2536
size_t pg_query__target_entry__get_packed_size
2537
                     (const PgQuery__TargetEntry *message)
2538
0
{
2539
0
  assert(message->base.descriptor == &pg_query__target_entry__descriptor);
2540
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2541
0
}
2542
size_t pg_query__target_entry__pack
2543
                     (const PgQuery__TargetEntry *message,
2544
                      uint8_t       *out)
2545
0
{
2546
0
  assert(message->base.descriptor == &pg_query__target_entry__descriptor);
2547
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2548
0
}
2549
size_t pg_query__target_entry__pack_to_buffer
2550
                     (const PgQuery__TargetEntry *message,
2551
                      ProtobufCBuffer *buffer)
2552
0
{
2553
0
  assert(message->base.descriptor == &pg_query__target_entry__descriptor);
2554
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2555
0
}
2556
PgQuery__TargetEntry *
2557
       pg_query__target_entry__unpack
2558
                     (ProtobufCAllocator  *allocator,
2559
                      size_t               len,
2560
                      const uint8_t       *data)
2561
0
{
2562
0
  return (PgQuery__TargetEntry *)
2563
0
     protobuf_c_message_unpack (&pg_query__target_entry__descriptor,
2564
0
                                allocator, len, data);
2565
0
}
2566
void   pg_query__target_entry__free_unpacked
2567
                     (PgQuery__TargetEntry *message,
2568
                      ProtobufCAllocator *allocator)
2569
0
{
2570
0
  if(!message)
2571
0
    return;
2572
0
  assert(message->base.descriptor == &pg_query__target_entry__descriptor);
2573
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2574
0
}
2575
void   pg_query__range_tbl_ref__init
2576
                     (PgQuery__RangeTblRef         *message)
2577
0
{
2578
0
  static const PgQuery__RangeTblRef init_value = PG_QUERY__RANGE_TBL_REF__INIT;
2579
0
  *message = init_value;
2580
0
}
2581
size_t pg_query__range_tbl_ref__get_packed_size
2582
                     (const PgQuery__RangeTblRef *message)
2583
0
{
2584
0
  assert(message->base.descriptor == &pg_query__range_tbl_ref__descriptor);
2585
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2586
0
}
2587
size_t pg_query__range_tbl_ref__pack
2588
                     (const PgQuery__RangeTblRef *message,
2589
                      uint8_t       *out)
2590
0
{
2591
0
  assert(message->base.descriptor == &pg_query__range_tbl_ref__descriptor);
2592
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2593
0
}
2594
size_t pg_query__range_tbl_ref__pack_to_buffer
2595
                     (const PgQuery__RangeTblRef *message,
2596
                      ProtobufCBuffer *buffer)
2597
0
{
2598
0
  assert(message->base.descriptor == &pg_query__range_tbl_ref__descriptor);
2599
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2600
0
}
2601
PgQuery__RangeTblRef *
2602
       pg_query__range_tbl_ref__unpack
2603
                     (ProtobufCAllocator  *allocator,
2604
                      size_t               len,
2605
                      const uint8_t       *data)
2606
0
{
2607
0
  return (PgQuery__RangeTblRef *)
2608
0
     protobuf_c_message_unpack (&pg_query__range_tbl_ref__descriptor,
2609
0
                                allocator, len, data);
2610
0
}
2611
void   pg_query__range_tbl_ref__free_unpacked
2612
                     (PgQuery__RangeTblRef *message,
2613
                      ProtobufCAllocator *allocator)
2614
0
{
2615
0
  if(!message)
2616
0
    return;
2617
0
  assert(message->base.descriptor == &pg_query__range_tbl_ref__descriptor);
2618
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2619
0
}
2620
void   pg_query__join_expr__init
2621
                     (PgQuery__JoinExpr         *message)
2622
0
{
2623
0
  static const PgQuery__JoinExpr init_value = PG_QUERY__JOIN_EXPR__INIT;
2624
0
  *message = init_value;
2625
0
}
2626
size_t pg_query__join_expr__get_packed_size
2627
                     (const PgQuery__JoinExpr *message)
2628
0
{
2629
0
  assert(message->base.descriptor == &pg_query__join_expr__descriptor);
2630
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2631
0
}
2632
size_t pg_query__join_expr__pack
2633
                     (const PgQuery__JoinExpr *message,
2634
                      uint8_t       *out)
2635
0
{
2636
0
  assert(message->base.descriptor == &pg_query__join_expr__descriptor);
2637
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2638
0
}
2639
size_t pg_query__join_expr__pack_to_buffer
2640
                     (const PgQuery__JoinExpr *message,
2641
                      ProtobufCBuffer *buffer)
2642
0
{
2643
0
  assert(message->base.descriptor == &pg_query__join_expr__descriptor);
2644
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2645
0
}
2646
PgQuery__JoinExpr *
2647
       pg_query__join_expr__unpack
2648
                     (ProtobufCAllocator  *allocator,
2649
                      size_t               len,
2650
                      const uint8_t       *data)
2651
0
{
2652
0
  return (PgQuery__JoinExpr *)
2653
0
     protobuf_c_message_unpack (&pg_query__join_expr__descriptor,
2654
0
                                allocator, len, data);
2655
0
}
2656
void   pg_query__join_expr__free_unpacked
2657
                     (PgQuery__JoinExpr *message,
2658
                      ProtobufCAllocator *allocator)
2659
0
{
2660
0
  if(!message)
2661
0
    return;
2662
0
  assert(message->base.descriptor == &pg_query__join_expr__descriptor);
2663
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2664
0
}
2665
void   pg_query__from_expr__init
2666
                     (PgQuery__FromExpr         *message)
2667
0
{
2668
0
  static const PgQuery__FromExpr init_value = PG_QUERY__FROM_EXPR__INIT;
2669
0
  *message = init_value;
2670
0
}
2671
size_t pg_query__from_expr__get_packed_size
2672
                     (const PgQuery__FromExpr *message)
2673
0
{
2674
0
  assert(message->base.descriptor == &pg_query__from_expr__descriptor);
2675
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2676
0
}
2677
size_t pg_query__from_expr__pack
2678
                     (const PgQuery__FromExpr *message,
2679
                      uint8_t       *out)
2680
0
{
2681
0
  assert(message->base.descriptor == &pg_query__from_expr__descriptor);
2682
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2683
0
}
2684
size_t pg_query__from_expr__pack_to_buffer
2685
                     (const PgQuery__FromExpr *message,
2686
                      ProtobufCBuffer *buffer)
2687
0
{
2688
0
  assert(message->base.descriptor == &pg_query__from_expr__descriptor);
2689
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2690
0
}
2691
PgQuery__FromExpr *
2692
       pg_query__from_expr__unpack
2693
                     (ProtobufCAllocator  *allocator,
2694
                      size_t               len,
2695
                      const uint8_t       *data)
2696
0
{
2697
0
  return (PgQuery__FromExpr *)
2698
0
     protobuf_c_message_unpack (&pg_query__from_expr__descriptor,
2699
0
                                allocator, len, data);
2700
0
}
2701
void   pg_query__from_expr__free_unpacked
2702
                     (PgQuery__FromExpr *message,
2703
                      ProtobufCAllocator *allocator)
2704
0
{
2705
0
  if(!message)
2706
0
    return;
2707
0
  assert(message->base.descriptor == &pg_query__from_expr__descriptor);
2708
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2709
0
}
2710
void   pg_query__on_conflict_expr__init
2711
                     (PgQuery__OnConflictExpr         *message)
2712
0
{
2713
0
  static const PgQuery__OnConflictExpr init_value = PG_QUERY__ON_CONFLICT_EXPR__INIT;
2714
0
  *message = init_value;
2715
0
}
2716
size_t pg_query__on_conflict_expr__get_packed_size
2717
                     (const PgQuery__OnConflictExpr *message)
2718
0
{
2719
0
  assert(message->base.descriptor == &pg_query__on_conflict_expr__descriptor);
2720
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2721
0
}
2722
size_t pg_query__on_conflict_expr__pack
2723
                     (const PgQuery__OnConflictExpr *message,
2724
                      uint8_t       *out)
2725
0
{
2726
0
  assert(message->base.descriptor == &pg_query__on_conflict_expr__descriptor);
2727
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2728
0
}
2729
size_t pg_query__on_conflict_expr__pack_to_buffer
2730
                     (const PgQuery__OnConflictExpr *message,
2731
                      ProtobufCBuffer *buffer)
2732
0
{
2733
0
  assert(message->base.descriptor == &pg_query__on_conflict_expr__descriptor);
2734
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2735
0
}
2736
PgQuery__OnConflictExpr *
2737
       pg_query__on_conflict_expr__unpack
2738
                     (ProtobufCAllocator  *allocator,
2739
                      size_t               len,
2740
                      const uint8_t       *data)
2741
0
{
2742
0
  return (PgQuery__OnConflictExpr *)
2743
0
     protobuf_c_message_unpack (&pg_query__on_conflict_expr__descriptor,
2744
0
                                allocator, len, data);
2745
0
}
2746
void   pg_query__on_conflict_expr__free_unpacked
2747
                     (PgQuery__OnConflictExpr *message,
2748
                      ProtobufCAllocator *allocator)
2749
0
{
2750
0
  if(!message)
2751
0
    return;
2752
0
  assert(message->base.descriptor == &pg_query__on_conflict_expr__descriptor);
2753
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2754
0
}
2755
void   pg_query__into_clause__init
2756
                     (PgQuery__IntoClause         *message)
2757
0
{
2758
0
  static const PgQuery__IntoClause init_value = PG_QUERY__INTO_CLAUSE__INIT;
2759
0
  *message = init_value;
2760
0
}
2761
size_t pg_query__into_clause__get_packed_size
2762
                     (const PgQuery__IntoClause *message)
2763
0
{
2764
0
  assert(message->base.descriptor == &pg_query__into_clause__descriptor);
2765
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2766
0
}
2767
size_t pg_query__into_clause__pack
2768
                     (const PgQuery__IntoClause *message,
2769
                      uint8_t       *out)
2770
0
{
2771
0
  assert(message->base.descriptor == &pg_query__into_clause__descriptor);
2772
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2773
0
}
2774
size_t pg_query__into_clause__pack_to_buffer
2775
                     (const PgQuery__IntoClause *message,
2776
                      ProtobufCBuffer *buffer)
2777
0
{
2778
0
  assert(message->base.descriptor == &pg_query__into_clause__descriptor);
2779
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2780
0
}
2781
PgQuery__IntoClause *
2782
       pg_query__into_clause__unpack
2783
                     (ProtobufCAllocator  *allocator,
2784
                      size_t               len,
2785
                      const uint8_t       *data)
2786
0
{
2787
0
  return (PgQuery__IntoClause *)
2788
0
     protobuf_c_message_unpack (&pg_query__into_clause__descriptor,
2789
0
                                allocator, len, data);
2790
0
}
2791
void   pg_query__into_clause__free_unpacked
2792
                     (PgQuery__IntoClause *message,
2793
                      ProtobufCAllocator *allocator)
2794
0
{
2795
0
  if(!message)
2796
0
    return;
2797
0
  assert(message->base.descriptor == &pg_query__into_clause__descriptor);
2798
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2799
0
}
2800
void   pg_query__merge_action__init
2801
                     (PgQuery__MergeAction         *message)
2802
0
{
2803
0
  static const PgQuery__MergeAction init_value = PG_QUERY__MERGE_ACTION__INIT;
2804
0
  *message = init_value;
2805
0
}
2806
size_t pg_query__merge_action__get_packed_size
2807
                     (const PgQuery__MergeAction *message)
2808
0
{
2809
0
  assert(message->base.descriptor == &pg_query__merge_action__descriptor);
2810
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2811
0
}
2812
size_t pg_query__merge_action__pack
2813
                     (const PgQuery__MergeAction *message,
2814
                      uint8_t       *out)
2815
0
{
2816
0
  assert(message->base.descriptor == &pg_query__merge_action__descriptor);
2817
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2818
0
}
2819
size_t pg_query__merge_action__pack_to_buffer
2820
                     (const PgQuery__MergeAction *message,
2821
                      ProtobufCBuffer *buffer)
2822
0
{
2823
0
  assert(message->base.descriptor == &pg_query__merge_action__descriptor);
2824
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2825
0
}
2826
PgQuery__MergeAction *
2827
       pg_query__merge_action__unpack
2828
                     (ProtobufCAllocator  *allocator,
2829
                      size_t               len,
2830
                      const uint8_t       *data)
2831
0
{
2832
0
  return (PgQuery__MergeAction *)
2833
0
     protobuf_c_message_unpack (&pg_query__merge_action__descriptor,
2834
0
                                allocator, len, data);
2835
0
}
2836
void   pg_query__merge_action__free_unpacked
2837
                     (PgQuery__MergeAction *message,
2838
                      ProtobufCAllocator *allocator)
2839
0
{
2840
0
  if(!message)
2841
0
    return;
2842
0
  assert(message->base.descriptor == &pg_query__merge_action__descriptor);
2843
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2844
0
}
2845
void   pg_query__raw_stmt__init
2846
                     (PgQuery__RawStmt         *message)
2847
0
{
2848
0
  static const PgQuery__RawStmt init_value = PG_QUERY__RAW_STMT__INIT;
2849
0
  *message = init_value;
2850
0
}
2851
size_t pg_query__raw_stmt__get_packed_size
2852
                     (const PgQuery__RawStmt *message)
2853
0
{
2854
0
  assert(message->base.descriptor == &pg_query__raw_stmt__descriptor);
2855
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2856
0
}
2857
size_t pg_query__raw_stmt__pack
2858
                     (const PgQuery__RawStmt *message,
2859
                      uint8_t       *out)
2860
0
{
2861
0
  assert(message->base.descriptor == &pg_query__raw_stmt__descriptor);
2862
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2863
0
}
2864
size_t pg_query__raw_stmt__pack_to_buffer
2865
                     (const PgQuery__RawStmt *message,
2866
                      ProtobufCBuffer *buffer)
2867
0
{
2868
0
  assert(message->base.descriptor == &pg_query__raw_stmt__descriptor);
2869
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2870
0
}
2871
PgQuery__RawStmt *
2872
       pg_query__raw_stmt__unpack
2873
                     (ProtobufCAllocator  *allocator,
2874
                      size_t               len,
2875
                      const uint8_t       *data)
2876
0
{
2877
0
  return (PgQuery__RawStmt *)
2878
0
     protobuf_c_message_unpack (&pg_query__raw_stmt__descriptor,
2879
0
                                allocator, len, data);
2880
0
}
2881
void   pg_query__raw_stmt__free_unpacked
2882
                     (PgQuery__RawStmt *message,
2883
                      ProtobufCAllocator *allocator)
2884
0
{
2885
0
  if(!message)
2886
0
    return;
2887
0
  assert(message->base.descriptor == &pg_query__raw_stmt__descriptor);
2888
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2889
0
}
2890
void   pg_query__query__init
2891
                     (PgQuery__Query         *message)
2892
0
{
2893
0
  static const PgQuery__Query init_value = PG_QUERY__QUERY__INIT;
2894
0
  *message = init_value;
2895
0
}
2896
size_t pg_query__query__get_packed_size
2897
                     (const PgQuery__Query *message)
2898
0
{
2899
0
  assert(message->base.descriptor == &pg_query__query__descriptor);
2900
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2901
0
}
2902
size_t pg_query__query__pack
2903
                     (const PgQuery__Query *message,
2904
                      uint8_t       *out)
2905
0
{
2906
0
  assert(message->base.descriptor == &pg_query__query__descriptor);
2907
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2908
0
}
2909
size_t pg_query__query__pack_to_buffer
2910
                     (const PgQuery__Query *message,
2911
                      ProtobufCBuffer *buffer)
2912
0
{
2913
0
  assert(message->base.descriptor == &pg_query__query__descriptor);
2914
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2915
0
}
2916
PgQuery__Query *
2917
       pg_query__query__unpack
2918
                     (ProtobufCAllocator  *allocator,
2919
                      size_t               len,
2920
                      const uint8_t       *data)
2921
0
{
2922
0
  return (PgQuery__Query *)
2923
0
     protobuf_c_message_unpack (&pg_query__query__descriptor,
2924
0
                                allocator, len, data);
2925
0
}
2926
void   pg_query__query__free_unpacked
2927
                     (PgQuery__Query *message,
2928
                      ProtobufCAllocator *allocator)
2929
0
{
2930
0
  if(!message)
2931
0
    return;
2932
0
  assert(message->base.descriptor == &pg_query__query__descriptor);
2933
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2934
0
}
2935
void   pg_query__insert_stmt__init
2936
                     (PgQuery__InsertStmt         *message)
2937
0
{
2938
0
  static const PgQuery__InsertStmt init_value = PG_QUERY__INSERT_STMT__INIT;
2939
0
  *message = init_value;
2940
0
}
2941
size_t pg_query__insert_stmt__get_packed_size
2942
                     (const PgQuery__InsertStmt *message)
2943
0
{
2944
0
  assert(message->base.descriptor == &pg_query__insert_stmt__descriptor);
2945
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2946
0
}
2947
size_t pg_query__insert_stmt__pack
2948
                     (const PgQuery__InsertStmt *message,
2949
                      uint8_t       *out)
2950
0
{
2951
0
  assert(message->base.descriptor == &pg_query__insert_stmt__descriptor);
2952
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2953
0
}
2954
size_t pg_query__insert_stmt__pack_to_buffer
2955
                     (const PgQuery__InsertStmt *message,
2956
                      ProtobufCBuffer *buffer)
2957
0
{
2958
0
  assert(message->base.descriptor == &pg_query__insert_stmt__descriptor);
2959
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2960
0
}
2961
PgQuery__InsertStmt *
2962
       pg_query__insert_stmt__unpack
2963
                     (ProtobufCAllocator  *allocator,
2964
                      size_t               len,
2965
                      const uint8_t       *data)
2966
0
{
2967
0
  return (PgQuery__InsertStmt *)
2968
0
     protobuf_c_message_unpack (&pg_query__insert_stmt__descriptor,
2969
0
                                allocator, len, data);
2970
0
}
2971
void   pg_query__insert_stmt__free_unpacked
2972
                     (PgQuery__InsertStmt *message,
2973
                      ProtobufCAllocator *allocator)
2974
0
{
2975
0
  if(!message)
2976
0
    return;
2977
0
  assert(message->base.descriptor == &pg_query__insert_stmt__descriptor);
2978
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2979
0
}
2980
void   pg_query__delete_stmt__init
2981
                     (PgQuery__DeleteStmt         *message)
2982
0
{
2983
0
  static const PgQuery__DeleteStmt init_value = PG_QUERY__DELETE_STMT__INIT;
2984
0
  *message = init_value;
2985
0
}
2986
size_t pg_query__delete_stmt__get_packed_size
2987
                     (const PgQuery__DeleteStmt *message)
2988
0
{
2989
0
  assert(message->base.descriptor == &pg_query__delete_stmt__descriptor);
2990
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2991
0
}
2992
size_t pg_query__delete_stmt__pack
2993
                     (const PgQuery__DeleteStmt *message,
2994
                      uint8_t       *out)
2995
0
{
2996
0
  assert(message->base.descriptor == &pg_query__delete_stmt__descriptor);
2997
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2998
0
}
2999
size_t pg_query__delete_stmt__pack_to_buffer
3000
                     (const PgQuery__DeleteStmt *message,
3001
                      ProtobufCBuffer *buffer)
3002
0
{
3003
0
  assert(message->base.descriptor == &pg_query__delete_stmt__descriptor);
3004
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3005
0
}
3006
PgQuery__DeleteStmt *
3007
       pg_query__delete_stmt__unpack
3008
                     (ProtobufCAllocator  *allocator,
3009
                      size_t               len,
3010
                      const uint8_t       *data)
3011
0
{
3012
0
  return (PgQuery__DeleteStmt *)
3013
0
     protobuf_c_message_unpack (&pg_query__delete_stmt__descriptor,
3014
0
                                allocator, len, data);
3015
0
}
3016
void   pg_query__delete_stmt__free_unpacked
3017
                     (PgQuery__DeleteStmt *message,
3018
                      ProtobufCAllocator *allocator)
3019
0
{
3020
0
  if(!message)
3021
0
    return;
3022
0
  assert(message->base.descriptor == &pg_query__delete_stmt__descriptor);
3023
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3024
0
}
3025
void   pg_query__update_stmt__init
3026
                     (PgQuery__UpdateStmt         *message)
3027
0
{
3028
0
  static const PgQuery__UpdateStmt init_value = PG_QUERY__UPDATE_STMT__INIT;
3029
0
  *message = init_value;
3030
0
}
3031
size_t pg_query__update_stmt__get_packed_size
3032
                     (const PgQuery__UpdateStmt *message)
3033
0
{
3034
0
  assert(message->base.descriptor == &pg_query__update_stmt__descriptor);
3035
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3036
0
}
3037
size_t pg_query__update_stmt__pack
3038
                     (const PgQuery__UpdateStmt *message,
3039
                      uint8_t       *out)
3040
0
{
3041
0
  assert(message->base.descriptor == &pg_query__update_stmt__descriptor);
3042
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3043
0
}
3044
size_t pg_query__update_stmt__pack_to_buffer
3045
                     (const PgQuery__UpdateStmt *message,
3046
                      ProtobufCBuffer *buffer)
3047
0
{
3048
0
  assert(message->base.descriptor == &pg_query__update_stmt__descriptor);
3049
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3050
0
}
3051
PgQuery__UpdateStmt *
3052
       pg_query__update_stmt__unpack
3053
                     (ProtobufCAllocator  *allocator,
3054
                      size_t               len,
3055
                      const uint8_t       *data)
3056
0
{
3057
0
  return (PgQuery__UpdateStmt *)
3058
0
     protobuf_c_message_unpack (&pg_query__update_stmt__descriptor,
3059
0
                                allocator, len, data);
3060
0
}
3061
void   pg_query__update_stmt__free_unpacked
3062
                     (PgQuery__UpdateStmt *message,
3063
                      ProtobufCAllocator *allocator)
3064
0
{
3065
0
  if(!message)
3066
0
    return;
3067
0
  assert(message->base.descriptor == &pg_query__update_stmt__descriptor);
3068
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3069
0
}
3070
void   pg_query__merge_stmt__init
3071
                     (PgQuery__MergeStmt         *message)
3072
0
{
3073
0
  static const PgQuery__MergeStmt init_value = PG_QUERY__MERGE_STMT__INIT;
3074
0
  *message = init_value;
3075
0
}
3076
size_t pg_query__merge_stmt__get_packed_size
3077
                     (const PgQuery__MergeStmt *message)
3078
0
{
3079
0
  assert(message->base.descriptor == &pg_query__merge_stmt__descriptor);
3080
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3081
0
}
3082
size_t pg_query__merge_stmt__pack
3083
                     (const PgQuery__MergeStmt *message,
3084
                      uint8_t       *out)
3085
0
{
3086
0
  assert(message->base.descriptor == &pg_query__merge_stmt__descriptor);
3087
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3088
0
}
3089
size_t pg_query__merge_stmt__pack_to_buffer
3090
                     (const PgQuery__MergeStmt *message,
3091
                      ProtobufCBuffer *buffer)
3092
0
{
3093
0
  assert(message->base.descriptor == &pg_query__merge_stmt__descriptor);
3094
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3095
0
}
3096
PgQuery__MergeStmt *
3097
       pg_query__merge_stmt__unpack
3098
                     (ProtobufCAllocator  *allocator,
3099
                      size_t               len,
3100
                      const uint8_t       *data)
3101
0
{
3102
0
  return (PgQuery__MergeStmt *)
3103
0
     protobuf_c_message_unpack (&pg_query__merge_stmt__descriptor,
3104
0
                                allocator, len, data);
3105
0
}
3106
void   pg_query__merge_stmt__free_unpacked
3107
                     (PgQuery__MergeStmt *message,
3108
                      ProtobufCAllocator *allocator)
3109
0
{
3110
0
  if(!message)
3111
0
    return;
3112
0
  assert(message->base.descriptor == &pg_query__merge_stmt__descriptor);
3113
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3114
0
}
3115
void   pg_query__select_stmt__init
3116
                     (PgQuery__SelectStmt         *message)
3117
0
{
3118
0
  static const PgQuery__SelectStmt init_value = PG_QUERY__SELECT_STMT__INIT;
3119
0
  *message = init_value;
3120
0
}
3121
size_t pg_query__select_stmt__get_packed_size
3122
                     (const PgQuery__SelectStmt *message)
3123
0
{
3124
0
  assert(message->base.descriptor == &pg_query__select_stmt__descriptor);
3125
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3126
0
}
3127
size_t pg_query__select_stmt__pack
3128
                     (const PgQuery__SelectStmt *message,
3129
                      uint8_t       *out)
3130
0
{
3131
0
  assert(message->base.descriptor == &pg_query__select_stmt__descriptor);
3132
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3133
0
}
3134
size_t pg_query__select_stmt__pack_to_buffer
3135
                     (const PgQuery__SelectStmt *message,
3136
                      ProtobufCBuffer *buffer)
3137
0
{
3138
0
  assert(message->base.descriptor == &pg_query__select_stmt__descriptor);
3139
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3140
0
}
3141
PgQuery__SelectStmt *
3142
       pg_query__select_stmt__unpack
3143
                     (ProtobufCAllocator  *allocator,
3144
                      size_t               len,
3145
                      const uint8_t       *data)
3146
0
{
3147
0
  return (PgQuery__SelectStmt *)
3148
0
     protobuf_c_message_unpack (&pg_query__select_stmt__descriptor,
3149
0
                                allocator, len, data);
3150
0
}
3151
void   pg_query__select_stmt__free_unpacked
3152
                     (PgQuery__SelectStmt *message,
3153
                      ProtobufCAllocator *allocator)
3154
0
{
3155
0
  if(!message)
3156
0
    return;
3157
0
  assert(message->base.descriptor == &pg_query__select_stmt__descriptor);
3158
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3159
0
}
3160
void   pg_query__return_stmt__init
3161
                     (PgQuery__ReturnStmt         *message)
3162
0
{
3163
0
  static const PgQuery__ReturnStmt init_value = PG_QUERY__RETURN_STMT__INIT;
3164
0
  *message = init_value;
3165
0
}
3166
size_t pg_query__return_stmt__get_packed_size
3167
                     (const PgQuery__ReturnStmt *message)
3168
0
{
3169
0
  assert(message->base.descriptor == &pg_query__return_stmt__descriptor);
3170
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3171
0
}
3172
size_t pg_query__return_stmt__pack
3173
                     (const PgQuery__ReturnStmt *message,
3174
                      uint8_t       *out)
3175
0
{
3176
0
  assert(message->base.descriptor == &pg_query__return_stmt__descriptor);
3177
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3178
0
}
3179
size_t pg_query__return_stmt__pack_to_buffer
3180
                     (const PgQuery__ReturnStmt *message,
3181
                      ProtobufCBuffer *buffer)
3182
0
{
3183
0
  assert(message->base.descriptor == &pg_query__return_stmt__descriptor);
3184
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3185
0
}
3186
PgQuery__ReturnStmt *
3187
       pg_query__return_stmt__unpack
3188
                     (ProtobufCAllocator  *allocator,
3189
                      size_t               len,
3190
                      const uint8_t       *data)
3191
0
{
3192
0
  return (PgQuery__ReturnStmt *)
3193
0
     protobuf_c_message_unpack (&pg_query__return_stmt__descriptor,
3194
0
                                allocator, len, data);
3195
0
}
3196
void   pg_query__return_stmt__free_unpacked
3197
                     (PgQuery__ReturnStmt *message,
3198
                      ProtobufCAllocator *allocator)
3199
0
{
3200
0
  if(!message)
3201
0
    return;
3202
0
  assert(message->base.descriptor == &pg_query__return_stmt__descriptor);
3203
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3204
0
}
3205
void   pg_query__plassign_stmt__init
3206
                     (PgQuery__PLAssignStmt         *message)
3207
0
{
3208
0
  static const PgQuery__PLAssignStmt init_value = PG_QUERY__PLASSIGN_STMT__INIT;
3209
0
  *message = init_value;
3210
0
}
3211
size_t pg_query__plassign_stmt__get_packed_size
3212
                     (const PgQuery__PLAssignStmt *message)
3213
0
{
3214
0
  assert(message->base.descriptor == &pg_query__plassign_stmt__descriptor);
3215
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3216
0
}
3217
size_t pg_query__plassign_stmt__pack
3218
                     (const PgQuery__PLAssignStmt *message,
3219
                      uint8_t       *out)
3220
0
{
3221
0
  assert(message->base.descriptor == &pg_query__plassign_stmt__descriptor);
3222
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3223
0
}
3224
size_t pg_query__plassign_stmt__pack_to_buffer
3225
                     (const PgQuery__PLAssignStmt *message,
3226
                      ProtobufCBuffer *buffer)
3227
0
{
3228
0
  assert(message->base.descriptor == &pg_query__plassign_stmt__descriptor);
3229
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3230
0
}
3231
PgQuery__PLAssignStmt *
3232
       pg_query__plassign_stmt__unpack
3233
                     (ProtobufCAllocator  *allocator,
3234
                      size_t               len,
3235
                      const uint8_t       *data)
3236
0
{
3237
0
  return (PgQuery__PLAssignStmt *)
3238
0
     protobuf_c_message_unpack (&pg_query__plassign_stmt__descriptor,
3239
0
                                allocator, len, data);
3240
0
}
3241
void   pg_query__plassign_stmt__free_unpacked
3242
                     (PgQuery__PLAssignStmt *message,
3243
                      ProtobufCAllocator *allocator)
3244
0
{
3245
0
  if(!message)
3246
0
    return;
3247
0
  assert(message->base.descriptor == &pg_query__plassign_stmt__descriptor);
3248
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3249
0
}
3250
void   pg_query__alter_table_stmt__init
3251
                     (PgQuery__AlterTableStmt         *message)
3252
0
{
3253
0
  static const PgQuery__AlterTableStmt init_value = PG_QUERY__ALTER_TABLE_STMT__INIT;
3254
0
  *message = init_value;
3255
0
}
3256
size_t pg_query__alter_table_stmt__get_packed_size
3257
                     (const PgQuery__AlterTableStmt *message)
3258
0
{
3259
0
  assert(message->base.descriptor == &pg_query__alter_table_stmt__descriptor);
3260
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3261
0
}
3262
size_t pg_query__alter_table_stmt__pack
3263
                     (const PgQuery__AlterTableStmt *message,
3264
                      uint8_t       *out)
3265
0
{
3266
0
  assert(message->base.descriptor == &pg_query__alter_table_stmt__descriptor);
3267
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3268
0
}
3269
size_t pg_query__alter_table_stmt__pack_to_buffer
3270
                     (const PgQuery__AlterTableStmt *message,
3271
                      ProtobufCBuffer *buffer)
3272
0
{
3273
0
  assert(message->base.descriptor == &pg_query__alter_table_stmt__descriptor);
3274
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3275
0
}
3276
PgQuery__AlterTableStmt *
3277
       pg_query__alter_table_stmt__unpack
3278
                     (ProtobufCAllocator  *allocator,
3279
                      size_t               len,
3280
                      const uint8_t       *data)
3281
0
{
3282
0
  return (PgQuery__AlterTableStmt *)
3283
0
     protobuf_c_message_unpack (&pg_query__alter_table_stmt__descriptor,
3284
0
                                allocator, len, data);
3285
0
}
3286
void   pg_query__alter_table_stmt__free_unpacked
3287
                     (PgQuery__AlterTableStmt *message,
3288
                      ProtobufCAllocator *allocator)
3289
0
{
3290
0
  if(!message)
3291
0
    return;
3292
0
  assert(message->base.descriptor == &pg_query__alter_table_stmt__descriptor);
3293
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3294
0
}
3295
void   pg_query__alter_table_cmd__init
3296
                     (PgQuery__AlterTableCmd         *message)
3297
0
{
3298
0
  static const PgQuery__AlterTableCmd init_value = PG_QUERY__ALTER_TABLE_CMD__INIT;
3299
0
  *message = init_value;
3300
0
}
3301
size_t pg_query__alter_table_cmd__get_packed_size
3302
                     (const PgQuery__AlterTableCmd *message)
3303
0
{
3304
0
  assert(message->base.descriptor == &pg_query__alter_table_cmd__descriptor);
3305
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3306
0
}
3307
size_t pg_query__alter_table_cmd__pack
3308
                     (const PgQuery__AlterTableCmd *message,
3309
                      uint8_t       *out)
3310
0
{
3311
0
  assert(message->base.descriptor == &pg_query__alter_table_cmd__descriptor);
3312
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3313
0
}
3314
size_t pg_query__alter_table_cmd__pack_to_buffer
3315
                     (const PgQuery__AlterTableCmd *message,
3316
                      ProtobufCBuffer *buffer)
3317
0
{
3318
0
  assert(message->base.descriptor == &pg_query__alter_table_cmd__descriptor);
3319
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3320
0
}
3321
PgQuery__AlterTableCmd *
3322
       pg_query__alter_table_cmd__unpack
3323
                     (ProtobufCAllocator  *allocator,
3324
                      size_t               len,
3325
                      const uint8_t       *data)
3326
0
{
3327
0
  return (PgQuery__AlterTableCmd *)
3328
0
     protobuf_c_message_unpack (&pg_query__alter_table_cmd__descriptor,
3329
0
                                allocator, len, data);
3330
0
}
3331
void   pg_query__alter_table_cmd__free_unpacked
3332
                     (PgQuery__AlterTableCmd *message,
3333
                      ProtobufCAllocator *allocator)
3334
0
{
3335
0
  if(!message)
3336
0
    return;
3337
0
  assert(message->base.descriptor == &pg_query__alter_table_cmd__descriptor);
3338
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3339
0
}
3340
void   pg_query__alter_domain_stmt__init
3341
                     (PgQuery__AlterDomainStmt         *message)
3342
0
{
3343
0
  static const PgQuery__AlterDomainStmt init_value = PG_QUERY__ALTER_DOMAIN_STMT__INIT;
3344
0
  *message = init_value;
3345
0
}
3346
size_t pg_query__alter_domain_stmt__get_packed_size
3347
                     (const PgQuery__AlterDomainStmt *message)
3348
0
{
3349
0
  assert(message->base.descriptor == &pg_query__alter_domain_stmt__descriptor);
3350
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3351
0
}
3352
size_t pg_query__alter_domain_stmt__pack
3353
                     (const PgQuery__AlterDomainStmt *message,
3354
                      uint8_t       *out)
3355
0
{
3356
0
  assert(message->base.descriptor == &pg_query__alter_domain_stmt__descriptor);
3357
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3358
0
}
3359
size_t pg_query__alter_domain_stmt__pack_to_buffer
3360
                     (const PgQuery__AlterDomainStmt *message,
3361
                      ProtobufCBuffer *buffer)
3362
0
{
3363
0
  assert(message->base.descriptor == &pg_query__alter_domain_stmt__descriptor);
3364
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3365
0
}
3366
PgQuery__AlterDomainStmt *
3367
       pg_query__alter_domain_stmt__unpack
3368
                     (ProtobufCAllocator  *allocator,
3369
                      size_t               len,
3370
                      const uint8_t       *data)
3371
0
{
3372
0
  return (PgQuery__AlterDomainStmt *)
3373
0
     protobuf_c_message_unpack (&pg_query__alter_domain_stmt__descriptor,
3374
0
                                allocator, len, data);
3375
0
}
3376
void   pg_query__alter_domain_stmt__free_unpacked
3377
                     (PgQuery__AlterDomainStmt *message,
3378
                      ProtobufCAllocator *allocator)
3379
0
{
3380
0
  if(!message)
3381
0
    return;
3382
0
  assert(message->base.descriptor == &pg_query__alter_domain_stmt__descriptor);
3383
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3384
0
}
3385
void   pg_query__set_operation_stmt__init
3386
                     (PgQuery__SetOperationStmt         *message)
3387
0
{
3388
0
  static const PgQuery__SetOperationStmt init_value = PG_QUERY__SET_OPERATION_STMT__INIT;
3389
0
  *message = init_value;
3390
0
}
3391
size_t pg_query__set_operation_stmt__get_packed_size
3392
                     (const PgQuery__SetOperationStmt *message)
3393
0
{
3394
0
  assert(message->base.descriptor == &pg_query__set_operation_stmt__descriptor);
3395
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3396
0
}
3397
size_t pg_query__set_operation_stmt__pack
3398
                     (const PgQuery__SetOperationStmt *message,
3399
                      uint8_t       *out)
3400
0
{
3401
0
  assert(message->base.descriptor == &pg_query__set_operation_stmt__descriptor);
3402
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3403
0
}
3404
size_t pg_query__set_operation_stmt__pack_to_buffer
3405
                     (const PgQuery__SetOperationStmt *message,
3406
                      ProtobufCBuffer *buffer)
3407
0
{
3408
0
  assert(message->base.descriptor == &pg_query__set_operation_stmt__descriptor);
3409
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3410
0
}
3411
PgQuery__SetOperationStmt *
3412
       pg_query__set_operation_stmt__unpack
3413
                     (ProtobufCAllocator  *allocator,
3414
                      size_t               len,
3415
                      const uint8_t       *data)
3416
0
{
3417
0
  return (PgQuery__SetOperationStmt *)
3418
0
     protobuf_c_message_unpack (&pg_query__set_operation_stmt__descriptor,
3419
0
                                allocator, len, data);
3420
0
}
3421
void   pg_query__set_operation_stmt__free_unpacked
3422
                     (PgQuery__SetOperationStmt *message,
3423
                      ProtobufCAllocator *allocator)
3424
0
{
3425
0
  if(!message)
3426
0
    return;
3427
0
  assert(message->base.descriptor == &pg_query__set_operation_stmt__descriptor);
3428
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3429
0
}
3430
void   pg_query__grant_stmt__init
3431
                     (PgQuery__GrantStmt         *message)
3432
0
{
3433
0
  static const PgQuery__GrantStmt init_value = PG_QUERY__GRANT_STMT__INIT;
3434
0
  *message = init_value;
3435
0
}
3436
size_t pg_query__grant_stmt__get_packed_size
3437
                     (const PgQuery__GrantStmt *message)
3438
0
{
3439
0
  assert(message->base.descriptor == &pg_query__grant_stmt__descriptor);
3440
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3441
0
}
3442
size_t pg_query__grant_stmt__pack
3443
                     (const PgQuery__GrantStmt *message,
3444
                      uint8_t       *out)
3445
0
{
3446
0
  assert(message->base.descriptor == &pg_query__grant_stmt__descriptor);
3447
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3448
0
}
3449
size_t pg_query__grant_stmt__pack_to_buffer
3450
                     (const PgQuery__GrantStmt *message,
3451
                      ProtobufCBuffer *buffer)
3452
0
{
3453
0
  assert(message->base.descriptor == &pg_query__grant_stmt__descriptor);
3454
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3455
0
}
3456
PgQuery__GrantStmt *
3457
       pg_query__grant_stmt__unpack
3458
                     (ProtobufCAllocator  *allocator,
3459
                      size_t               len,
3460
                      const uint8_t       *data)
3461
0
{
3462
0
  return (PgQuery__GrantStmt *)
3463
0
     protobuf_c_message_unpack (&pg_query__grant_stmt__descriptor,
3464
0
                                allocator, len, data);
3465
0
}
3466
void   pg_query__grant_stmt__free_unpacked
3467
                     (PgQuery__GrantStmt *message,
3468
                      ProtobufCAllocator *allocator)
3469
0
{
3470
0
  if(!message)
3471
0
    return;
3472
0
  assert(message->base.descriptor == &pg_query__grant_stmt__descriptor);
3473
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3474
0
}
3475
void   pg_query__grant_role_stmt__init
3476
                     (PgQuery__GrantRoleStmt         *message)
3477
0
{
3478
0
  static const PgQuery__GrantRoleStmt init_value = PG_QUERY__GRANT_ROLE_STMT__INIT;
3479
0
  *message = init_value;
3480
0
}
3481
size_t pg_query__grant_role_stmt__get_packed_size
3482
                     (const PgQuery__GrantRoleStmt *message)
3483
0
{
3484
0
  assert(message->base.descriptor == &pg_query__grant_role_stmt__descriptor);
3485
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3486
0
}
3487
size_t pg_query__grant_role_stmt__pack
3488
                     (const PgQuery__GrantRoleStmt *message,
3489
                      uint8_t       *out)
3490
0
{
3491
0
  assert(message->base.descriptor == &pg_query__grant_role_stmt__descriptor);
3492
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3493
0
}
3494
size_t pg_query__grant_role_stmt__pack_to_buffer
3495
                     (const PgQuery__GrantRoleStmt *message,
3496
                      ProtobufCBuffer *buffer)
3497
0
{
3498
0
  assert(message->base.descriptor == &pg_query__grant_role_stmt__descriptor);
3499
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3500
0
}
3501
PgQuery__GrantRoleStmt *
3502
       pg_query__grant_role_stmt__unpack
3503
                     (ProtobufCAllocator  *allocator,
3504
                      size_t               len,
3505
                      const uint8_t       *data)
3506
0
{
3507
0
  return (PgQuery__GrantRoleStmt *)
3508
0
     protobuf_c_message_unpack (&pg_query__grant_role_stmt__descriptor,
3509
0
                                allocator, len, data);
3510
0
}
3511
void   pg_query__grant_role_stmt__free_unpacked
3512
                     (PgQuery__GrantRoleStmt *message,
3513
                      ProtobufCAllocator *allocator)
3514
0
{
3515
0
  if(!message)
3516
0
    return;
3517
0
  assert(message->base.descriptor == &pg_query__grant_role_stmt__descriptor);
3518
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3519
0
}
3520
void   pg_query__alter_default_privileges_stmt__init
3521
                     (PgQuery__AlterDefaultPrivilegesStmt         *message)
3522
0
{
3523
0
  static const PgQuery__AlterDefaultPrivilegesStmt init_value = PG_QUERY__ALTER_DEFAULT_PRIVILEGES_STMT__INIT;
3524
0
  *message = init_value;
3525
0
}
3526
size_t pg_query__alter_default_privileges_stmt__get_packed_size
3527
                     (const PgQuery__AlterDefaultPrivilegesStmt *message)
3528
0
{
3529
0
  assert(message->base.descriptor == &pg_query__alter_default_privileges_stmt__descriptor);
3530
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3531
0
}
3532
size_t pg_query__alter_default_privileges_stmt__pack
3533
                     (const PgQuery__AlterDefaultPrivilegesStmt *message,
3534
                      uint8_t       *out)
3535
0
{
3536
0
  assert(message->base.descriptor == &pg_query__alter_default_privileges_stmt__descriptor);
3537
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3538
0
}
3539
size_t pg_query__alter_default_privileges_stmt__pack_to_buffer
3540
                     (const PgQuery__AlterDefaultPrivilegesStmt *message,
3541
                      ProtobufCBuffer *buffer)
3542
0
{
3543
0
  assert(message->base.descriptor == &pg_query__alter_default_privileges_stmt__descriptor);
3544
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3545
0
}
3546
PgQuery__AlterDefaultPrivilegesStmt *
3547
       pg_query__alter_default_privileges_stmt__unpack
3548
                     (ProtobufCAllocator  *allocator,
3549
                      size_t               len,
3550
                      const uint8_t       *data)
3551
0
{
3552
0
  return (PgQuery__AlterDefaultPrivilegesStmt *)
3553
0
     protobuf_c_message_unpack (&pg_query__alter_default_privileges_stmt__descriptor,
3554
0
                                allocator, len, data);
3555
0
}
3556
void   pg_query__alter_default_privileges_stmt__free_unpacked
3557
                     (PgQuery__AlterDefaultPrivilegesStmt *message,
3558
                      ProtobufCAllocator *allocator)
3559
0
{
3560
0
  if(!message)
3561
0
    return;
3562
0
  assert(message->base.descriptor == &pg_query__alter_default_privileges_stmt__descriptor);
3563
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3564
0
}
3565
void   pg_query__close_portal_stmt__init
3566
                     (PgQuery__ClosePortalStmt         *message)
3567
0
{
3568
0
  static const PgQuery__ClosePortalStmt init_value = PG_QUERY__CLOSE_PORTAL_STMT__INIT;
3569
0
  *message = init_value;
3570
0
}
3571
size_t pg_query__close_portal_stmt__get_packed_size
3572
                     (const PgQuery__ClosePortalStmt *message)
3573
0
{
3574
0
  assert(message->base.descriptor == &pg_query__close_portal_stmt__descriptor);
3575
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3576
0
}
3577
size_t pg_query__close_portal_stmt__pack
3578
                     (const PgQuery__ClosePortalStmt *message,
3579
                      uint8_t       *out)
3580
0
{
3581
0
  assert(message->base.descriptor == &pg_query__close_portal_stmt__descriptor);
3582
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3583
0
}
3584
size_t pg_query__close_portal_stmt__pack_to_buffer
3585
                     (const PgQuery__ClosePortalStmt *message,
3586
                      ProtobufCBuffer *buffer)
3587
0
{
3588
0
  assert(message->base.descriptor == &pg_query__close_portal_stmt__descriptor);
3589
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3590
0
}
3591
PgQuery__ClosePortalStmt *
3592
       pg_query__close_portal_stmt__unpack
3593
                     (ProtobufCAllocator  *allocator,
3594
                      size_t               len,
3595
                      const uint8_t       *data)
3596
0
{
3597
0
  return (PgQuery__ClosePortalStmt *)
3598
0
     protobuf_c_message_unpack (&pg_query__close_portal_stmt__descriptor,
3599
0
                                allocator, len, data);
3600
0
}
3601
void   pg_query__close_portal_stmt__free_unpacked
3602
                     (PgQuery__ClosePortalStmt *message,
3603
                      ProtobufCAllocator *allocator)
3604
0
{
3605
0
  if(!message)
3606
0
    return;
3607
0
  assert(message->base.descriptor == &pg_query__close_portal_stmt__descriptor);
3608
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3609
0
}
3610
void   pg_query__cluster_stmt__init
3611
                     (PgQuery__ClusterStmt         *message)
3612
0
{
3613
0
  static const PgQuery__ClusterStmt init_value = PG_QUERY__CLUSTER_STMT__INIT;
3614
0
  *message = init_value;
3615
0
}
3616
size_t pg_query__cluster_stmt__get_packed_size
3617
                     (const PgQuery__ClusterStmt *message)
3618
0
{
3619
0
  assert(message->base.descriptor == &pg_query__cluster_stmt__descriptor);
3620
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3621
0
}
3622
size_t pg_query__cluster_stmt__pack
3623
                     (const PgQuery__ClusterStmt *message,
3624
                      uint8_t       *out)
3625
0
{
3626
0
  assert(message->base.descriptor == &pg_query__cluster_stmt__descriptor);
3627
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3628
0
}
3629
size_t pg_query__cluster_stmt__pack_to_buffer
3630
                     (const PgQuery__ClusterStmt *message,
3631
                      ProtobufCBuffer *buffer)
3632
0
{
3633
0
  assert(message->base.descriptor == &pg_query__cluster_stmt__descriptor);
3634
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3635
0
}
3636
PgQuery__ClusterStmt *
3637
       pg_query__cluster_stmt__unpack
3638
                     (ProtobufCAllocator  *allocator,
3639
                      size_t               len,
3640
                      const uint8_t       *data)
3641
0
{
3642
0
  return (PgQuery__ClusterStmt *)
3643
0
     protobuf_c_message_unpack (&pg_query__cluster_stmt__descriptor,
3644
0
                                allocator, len, data);
3645
0
}
3646
void   pg_query__cluster_stmt__free_unpacked
3647
                     (PgQuery__ClusterStmt *message,
3648
                      ProtobufCAllocator *allocator)
3649
0
{
3650
0
  if(!message)
3651
0
    return;
3652
0
  assert(message->base.descriptor == &pg_query__cluster_stmt__descriptor);
3653
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3654
0
}
3655
void   pg_query__copy_stmt__init
3656
                     (PgQuery__CopyStmt         *message)
3657
0
{
3658
0
  static const PgQuery__CopyStmt init_value = PG_QUERY__COPY_STMT__INIT;
3659
0
  *message = init_value;
3660
0
}
3661
size_t pg_query__copy_stmt__get_packed_size
3662
                     (const PgQuery__CopyStmt *message)
3663
0
{
3664
0
  assert(message->base.descriptor == &pg_query__copy_stmt__descriptor);
3665
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3666
0
}
3667
size_t pg_query__copy_stmt__pack
3668
                     (const PgQuery__CopyStmt *message,
3669
                      uint8_t       *out)
3670
0
{
3671
0
  assert(message->base.descriptor == &pg_query__copy_stmt__descriptor);
3672
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3673
0
}
3674
size_t pg_query__copy_stmt__pack_to_buffer
3675
                     (const PgQuery__CopyStmt *message,
3676
                      ProtobufCBuffer *buffer)
3677
0
{
3678
0
  assert(message->base.descriptor == &pg_query__copy_stmt__descriptor);
3679
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3680
0
}
3681
PgQuery__CopyStmt *
3682
       pg_query__copy_stmt__unpack
3683
                     (ProtobufCAllocator  *allocator,
3684
                      size_t               len,
3685
                      const uint8_t       *data)
3686
0
{
3687
0
  return (PgQuery__CopyStmt *)
3688
0
     protobuf_c_message_unpack (&pg_query__copy_stmt__descriptor,
3689
0
                                allocator, len, data);
3690
0
}
3691
void   pg_query__copy_stmt__free_unpacked
3692
                     (PgQuery__CopyStmt *message,
3693
                      ProtobufCAllocator *allocator)
3694
0
{
3695
0
  if(!message)
3696
0
    return;
3697
0
  assert(message->base.descriptor == &pg_query__copy_stmt__descriptor);
3698
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3699
0
}
3700
void   pg_query__create_stmt__init
3701
                     (PgQuery__CreateStmt         *message)
3702
0
{
3703
0
  static const PgQuery__CreateStmt init_value = PG_QUERY__CREATE_STMT__INIT;
3704
0
  *message = init_value;
3705
0
}
3706
size_t pg_query__create_stmt__get_packed_size
3707
                     (const PgQuery__CreateStmt *message)
3708
0
{
3709
0
  assert(message->base.descriptor == &pg_query__create_stmt__descriptor);
3710
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3711
0
}
3712
size_t pg_query__create_stmt__pack
3713
                     (const PgQuery__CreateStmt *message,
3714
                      uint8_t       *out)
3715
0
{
3716
0
  assert(message->base.descriptor == &pg_query__create_stmt__descriptor);
3717
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3718
0
}
3719
size_t pg_query__create_stmt__pack_to_buffer
3720
                     (const PgQuery__CreateStmt *message,
3721
                      ProtobufCBuffer *buffer)
3722
0
{
3723
0
  assert(message->base.descriptor == &pg_query__create_stmt__descriptor);
3724
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3725
0
}
3726
PgQuery__CreateStmt *
3727
       pg_query__create_stmt__unpack
3728
                     (ProtobufCAllocator  *allocator,
3729
                      size_t               len,
3730
                      const uint8_t       *data)
3731
0
{
3732
0
  return (PgQuery__CreateStmt *)
3733
0
     protobuf_c_message_unpack (&pg_query__create_stmt__descriptor,
3734
0
                                allocator, len, data);
3735
0
}
3736
void   pg_query__create_stmt__free_unpacked
3737
                     (PgQuery__CreateStmt *message,
3738
                      ProtobufCAllocator *allocator)
3739
0
{
3740
0
  if(!message)
3741
0
    return;
3742
0
  assert(message->base.descriptor == &pg_query__create_stmt__descriptor);
3743
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3744
0
}
3745
void   pg_query__define_stmt__init
3746
                     (PgQuery__DefineStmt         *message)
3747
0
{
3748
0
  static const PgQuery__DefineStmt init_value = PG_QUERY__DEFINE_STMT__INIT;
3749
0
  *message = init_value;
3750
0
}
3751
size_t pg_query__define_stmt__get_packed_size
3752
                     (const PgQuery__DefineStmt *message)
3753
0
{
3754
0
  assert(message->base.descriptor == &pg_query__define_stmt__descriptor);
3755
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3756
0
}
3757
size_t pg_query__define_stmt__pack
3758
                     (const PgQuery__DefineStmt *message,
3759
                      uint8_t       *out)
3760
0
{
3761
0
  assert(message->base.descriptor == &pg_query__define_stmt__descriptor);
3762
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3763
0
}
3764
size_t pg_query__define_stmt__pack_to_buffer
3765
                     (const PgQuery__DefineStmt *message,
3766
                      ProtobufCBuffer *buffer)
3767
0
{
3768
0
  assert(message->base.descriptor == &pg_query__define_stmt__descriptor);
3769
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3770
0
}
3771
PgQuery__DefineStmt *
3772
       pg_query__define_stmt__unpack
3773
                     (ProtobufCAllocator  *allocator,
3774
                      size_t               len,
3775
                      const uint8_t       *data)
3776
0
{
3777
0
  return (PgQuery__DefineStmt *)
3778
0
     protobuf_c_message_unpack (&pg_query__define_stmt__descriptor,
3779
0
                                allocator, len, data);
3780
0
}
3781
void   pg_query__define_stmt__free_unpacked
3782
                     (PgQuery__DefineStmt *message,
3783
                      ProtobufCAllocator *allocator)
3784
0
{
3785
0
  if(!message)
3786
0
    return;
3787
0
  assert(message->base.descriptor == &pg_query__define_stmt__descriptor);
3788
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3789
0
}
3790
void   pg_query__drop_stmt__init
3791
                     (PgQuery__DropStmt         *message)
3792
0
{
3793
0
  static const PgQuery__DropStmt init_value = PG_QUERY__DROP_STMT__INIT;
3794
0
  *message = init_value;
3795
0
}
3796
size_t pg_query__drop_stmt__get_packed_size
3797
                     (const PgQuery__DropStmt *message)
3798
0
{
3799
0
  assert(message->base.descriptor == &pg_query__drop_stmt__descriptor);
3800
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3801
0
}
3802
size_t pg_query__drop_stmt__pack
3803
                     (const PgQuery__DropStmt *message,
3804
                      uint8_t       *out)
3805
0
{
3806
0
  assert(message->base.descriptor == &pg_query__drop_stmt__descriptor);
3807
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3808
0
}
3809
size_t pg_query__drop_stmt__pack_to_buffer
3810
                     (const PgQuery__DropStmt *message,
3811
                      ProtobufCBuffer *buffer)
3812
0
{
3813
0
  assert(message->base.descriptor == &pg_query__drop_stmt__descriptor);
3814
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3815
0
}
3816
PgQuery__DropStmt *
3817
       pg_query__drop_stmt__unpack
3818
                     (ProtobufCAllocator  *allocator,
3819
                      size_t               len,
3820
                      const uint8_t       *data)
3821
0
{
3822
0
  return (PgQuery__DropStmt *)
3823
0
     protobuf_c_message_unpack (&pg_query__drop_stmt__descriptor,
3824
0
                                allocator, len, data);
3825
0
}
3826
void   pg_query__drop_stmt__free_unpacked
3827
                     (PgQuery__DropStmt *message,
3828
                      ProtobufCAllocator *allocator)
3829
0
{
3830
0
  if(!message)
3831
0
    return;
3832
0
  assert(message->base.descriptor == &pg_query__drop_stmt__descriptor);
3833
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3834
0
}
3835
void   pg_query__truncate_stmt__init
3836
                     (PgQuery__TruncateStmt         *message)
3837
0
{
3838
0
  static const PgQuery__TruncateStmt init_value = PG_QUERY__TRUNCATE_STMT__INIT;
3839
0
  *message = init_value;
3840
0
}
3841
size_t pg_query__truncate_stmt__get_packed_size
3842
                     (const PgQuery__TruncateStmt *message)
3843
0
{
3844
0
  assert(message->base.descriptor == &pg_query__truncate_stmt__descriptor);
3845
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3846
0
}
3847
size_t pg_query__truncate_stmt__pack
3848
                     (const PgQuery__TruncateStmt *message,
3849
                      uint8_t       *out)
3850
0
{
3851
0
  assert(message->base.descriptor == &pg_query__truncate_stmt__descriptor);
3852
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3853
0
}
3854
size_t pg_query__truncate_stmt__pack_to_buffer
3855
                     (const PgQuery__TruncateStmt *message,
3856
                      ProtobufCBuffer *buffer)
3857
0
{
3858
0
  assert(message->base.descriptor == &pg_query__truncate_stmt__descriptor);
3859
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3860
0
}
3861
PgQuery__TruncateStmt *
3862
       pg_query__truncate_stmt__unpack
3863
                     (ProtobufCAllocator  *allocator,
3864
                      size_t               len,
3865
                      const uint8_t       *data)
3866
0
{
3867
0
  return (PgQuery__TruncateStmt *)
3868
0
     protobuf_c_message_unpack (&pg_query__truncate_stmt__descriptor,
3869
0
                                allocator, len, data);
3870
0
}
3871
void   pg_query__truncate_stmt__free_unpacked
3872
                     (PgQuery__TruncateStmt *message,
3873
                      ProtobufCAllocator *allocator)
3874
0
{
3875
0
  if(!message)
3876
0
    return;
3877
0
  assert(message->base.descriptor == &pg_query__truncate_stmt__descriptor);
3878
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3879
0
}
3880
void   pg_query__comment_stmt__init
3881
                     (PgQuery__CommentStmt         *message)
3882
0
{
3883
0
  static const PgQuery__CommentStmt init_value = PG_QUERY__COMMENT_STMT__INIT;
3884
0
  *message = init_value;
3885
0
}
3886
size_t pg_query__comment_stmt__get_packed_size
3887
                     (const PgQuery__CommentStmt *message)
3888
0
{
3889
0
  assert(message->base.descriptor == &pg_query__comment_stmt__descriptor);
3890
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3891
0
}
3892
size_t pg_query__comment_stmt__pack
3893
                     (const PgQuery__CommentStmt *message,
3894
                      uint8_t       *out)
3895
0
{
3896
0
  assert(message->base.descriptor == &pg_query__comment_stmt__descriptor);
3897
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3898
0
}
3899
size_t pg_query__comment_stmt__pack_to_buffer
3900
                     (const PgQuery__CommentStmt *message,
3901
                      ProtobufCBuffer *buffer)
3902
0
{
3903
0
  assert(message->base.descriptor == &pg_query__comment_stmt__descriptor);
3904
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3905
0
}
3906
PgQuery__CommentStmt *
3907
       pg_query__comment_stmt__unpack
3908
                     (ProtobufCAllocator  *allocator,
3909
                      size_t               len,
3910
                      const uint8_t       *data)
3911
0
{
3912
0
  return (PgQuery__CommentStmt *)
3913
0
     protobuf_c_message_unpack (&pg_query__comment_stmt__descriptor,
3914
0
                                allocator, len, data);
3915
0
}
3916
void   pg_query__comment_stmt__free_unpacked
3917
                     (PgQuery__CommentStmt *message,
3918
                      ProtobufCAllocator *allocator)
3919
0
{
3920
0
  if(!message)
3921
0
    return;
3922
0
  assert(message->base.descriptor == &pg_query__comment_stmt__descriptor);
3923
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3924
0
}
3925
void   pg_query__fetch_stmt__init
3926
                     (PgQuery__FetchStmt         *message)
3927
0
{
3928
0
  static const PgQuery__FetchStmt init_value = PG_QUERY__FETCH_STMT__INIT;
3929
0
  *message = init_value;
3930
0
}
3931
size_t pg_query__fetch_stmt__get_packed_size
3932
                     (const PgQuery__FetchStmt *message)
3933
0
{
3934
0
  assert(message->base.descriptor == &pg_query__fetch_stmt__descriptor);
3935
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3936
0
}
3937
size_t pg_query__fetch_stmt__pack
3938
                     (const PgQuery__FetchStmt *message,
3939
                      uint8_t       *out)
3940
0
{
3941
0
  assert(message->base.descriptor == &pg_query__fetch_stmt__descriptor);
3942
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3943
0
}
3944
size_t pg_query__fetch_stmt__pack_to_buffer
3945
                     (const PgQuery__FetchStmt *message,
3946
                      ProtobufCBuffer *buffer)
3947
0
{
3948
0
  assert(message->base.descriptor == &pg_query__fetch_stmt__descriptor);
3949
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3950
0
}
3951
PgQuery__FetchStmt *
3952
       pg_query__fetch_stmt__unpack
3953
                     (ProtobufCAllocator  *allocator,
3954
                      size_t               len,
3955
                      const uint8_t       *data)
3956
0
{
3957
0
  return (PgQuery__FetchStmt *)
3958
0
     protobuf_c_message_unpack (&pg_query__fetch_stmt__descriptor,
3959
0
                                allocator, len, data);
3960
0
}
3961
void   pg_query__fetch_stmt__free_unpacked
3962
                     (PgQuery__FetchStmt *message,
3963
                      ProtobufCAllocator *allocator)
3964
0
{
3965
0
  if(!message)
3966
0
    return;
3967
0
  assert(message->base.descriptor == &pg_query__fetch_stmt__descriptor);
3968
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3969
0
}
3970
void   pg_query__index_stmt__init
3971
                     (PgQuery__IndexStmt         *message)
3972
0
{
3973
0
  static const PgQuery__IndexStmt init_value = PG_QUERY__INDEX_STMT__INIT;
3974
0
  *message = init_value;
3975
0
}
3976
size_t pg_query__index_stmt__get_packed_size
3977
                     (const PgQuery__IndexStmt *message)
3978
0
{
3979
0
  assert(message->base.descriptor == &pg_query__index_stmt__descriptor);
3980
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3981
0
}
3982
size_t pg_query__index_stmt__pack
3983
                     (const PgQuery__IndexStmt *message,
3984
                      uint8_t       *out)
3985
0
{
3986
0
  assert(message->base.descriptor == &pg_query__index_stmt__descriptor);
3987
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3988
0
}
3989
size_t pg_query__index_stmt__pack_to_buffer
3990
                     (const PgQuery__IndexStmt *message,
3991
                      ProtobufCBuffer *buffer)
3992
0
{
3993
0
  assert(message->base.descriptor == &pg_query__index_stmt__descriptor);
3994
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3995
0
}
3996
PgQuery__IndexStmt *
3997
       pg_query__index_stmt__unpack
3998
                     (ProtobufCAllocator  *allocator,
3999
                      size_t               len,
4000
                      const uint8_t       *data)
4001
0
{
4002
0
  return (PgQuery__IndexStmt *)
4003
0
     protobuf_c_message_unpack (&pg_query__index_stmt__descriptor,
4004
0
                                allocator, len, data);
4005
0
}
4006
void   pg_query__index_stmt__free_unpacked
4007
                     (PgQuery__IndexStmt *message,
4008
                      ProtobufCAllocator *allocator)
4009
0
{
4010
0
  if(!message)
4011
0
    return;
4012
0
  assert(message->base.descriptor == &pg_query__index_stmt__descriptor);
4013
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
4014
0
}
4015
void   pg_query__create_function_stmt__init
4016
                     (PgQuery__CreateFunctionStmt         *message)
4017
0
{
4018
0
  static const PgQuery__CreateFunctionStmt init_value = PG_QUERY__CREATE_FUNCTION_STMT__INIT;
4019
0
  *message = init_value;
4020
0
}
4021
size_t pg_query__create_function_stmt__get_packed_size
4022
                     (const PgQuery__CreateFunctionStmt *message)
4023
0
{
4024
0
  assert(message->base.descriptor == &pg_query__create_function_stmt__descriptor);
4025
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
4026
0
}
4027
size_t pg_query__create_function_stmt__pack
4028
                     (const PgQuery__CreateFunctionStmt *message,
4029
                      uint8_t       *out)
4030
0
{
4031
0
  assert(message->base.descriptor == &pg_query__create_function_stmt__descriptor);
4032
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
4033
0
}
4034
size_t pg_query__create_function_stmt__pack_to_buffer
4035
                     (const PgQuery__CreateFunctionStmt *message,
4036
                      ProtobufCBuffer *buffer)
4037
0
{
4038
0
  assert(message->base.descriptor == &pg_query__create_function_stmt__descriptor);
4039
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
4040
0
}
4041
PgQuery__CreateFunctionStmt *
4042
       pg_query__create_function_stmt__unpack
4043
                     (ProtobufCAllocator  *allocator,
4044
                      size_t               len,
4045
                      const uint8_t       *data)
4046
0
{
4047
0
  return (PgQuery__CreateFunctionStmt *)
4048
0
     protobuf_c_message_unpack (&pg_query__create_function_stmt__descriptor,
4049
0
                                allocator, len, data);
4050
0
}
4051
void   pg_query__create_function_stmt__free_unpacked
4052
                     (PgQuery__CreateFunctionStmt *message,
4053
                      ProtobufCAllocator *allocator)
4054
0
{
4055
0
  if(!message)
4056
0
    return;
4057
0
  assert(message->base.descriptor == &pg_query__create_function_stmt__descriptor);
4058
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
4059
0
}
4060
void   pg_query__alter_function_stmt__init
4061
                     (PgQuery__AlterFunctionStmt         *message)
4062
0
{
4063
0
  static const PgQuery__AlterFunctionStmt init_value = PG_QUERY__ALTER_FUNCTION_STMT__INIT;
4064
0
  *message = init_value;
4065
0
}
4066
size_t pg_query__alter_function_stmt__get_packed_size
4067
                     (const PgQuery__AlterFunctionStmt *message)
4068
0
{
4069
0
  assert(message->base.descriptor == &pg_query__alter_function_stmt__descriptor);
4070
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
4071
0
}
4072
size_t pg_query__alter_function_stmt__pack
4073
                     (const PgQuery__AlterFunctionStmt *message,
4074
                      uint8_t       *out)
4075
0
{
4076
0
  assert(message->base.descriptor == &pg_query__alter_function_stmt__descriptor);
4077
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
4078
0
}
4079
size_t pg_query__alter_function_stmt__pack_to_buffer
4080
                     (const PgQuery__AlterFunctionStmt *message,
4081
                      ProtobufCBuffer *buffer)
4082
0
{
4083
0
  assert(message->base.descriptor == &pg_query__alter_function_stmt__descriptor);
4084
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
4085
0
}
4086
PgQuery__AlterFunctionStmt *
4087
       pg_query__alter_function_stmt__unpack
4088
                     (ProtobufCAllocator  *allocator,
4089
                      size_t               len,
4090
                      const uint8_t       *data)
4091
0
{
4092
0
  return (PgQuery__AlterFunctionStmt *)
4093
0
     protobuf_c_message_unpack (&pg_query__alter_function_stmt__descriptor,
4094
0
                                allocator, len, data);
4095
0
}
4096
void   pg_query__alter_function_stmt__free_unpacked
4097
                     (PgQuery__AlterFunctionStmt *message,
4098
                      ProtobufCAllocator *allocator)
4099
0
{
4100
0
  if(!message)
4101
0
    return;
4102
0
  assert(message->base.descriptor == &pg_query__alter_function_stmt__descriptor);
4103
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
4104
0
}
4105
void   pg_query__do_stmt__init
4106
                     (PgQuery__DoStmt         *message)
4107
0
{
4108
0
  static const PgQuery__DoStmt init_value = PG_QUERY__DO_STMT__INIT;
4109
0
  *message = init_value;
4110
0
}
4111
size_t pg_query__do_stmt__get_packed_size
4112
                     (const PgQuery__DoStmt *message)
4113
0
{
4114
0
  assert(message->base.descriptor == &pg_query__do_stmt__descriptor);
4115
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
4116
0
}
4117
size_t pg_query__do_stmt__pack
4118
                     (const PgQuery__DoStmt *message,
4119
                      uint8_t       *out)
4120
0
{
4121
0
  assert(message->base.descriptor == &pg_query__do_stmt__descriptor);
4122
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
4123
0
}
4124
size_t pg_query__do_stmt__pack_to_buffer
4125
                     (const PgQuery__DoStmt *message,
4126
                      ProtobufCBuffer *buffer)
4127
0
{
4128
0
  assert(message->base.descriptor == &pg_query__do_stmt__descriptor);
4129
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
4130
0
}
4131
PgQuery__DoStmt *
4132
       pg_query__do_stmt__unpack
4133
                     (ProtobufCAllocator  *allocator,
4134
                      size_t               len,
4135
                      const uint8_t       *data)
4136
0
{
4137
0
  return (PgQuery__DoStmt *)
4138
0
     protobuf_c_message_unpack (&pg_query__do_stmt__descriptor,
4139
0
                                allocator, len, data);
4140
0
}
4141
void   pg_query__do_stmt__free_unpacked
4142
                     (PgQuery__DoStmt *message,
4143
                      ProtobufCAllocator *allocator)
4144
0
{
4145
0
  if(!message)
4146
0
    return;
4147
0
  assert(message->base.descriptor == &pg_query__do_stmt__descriptor);
4148
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
4149
0
}
4150
void   pg_query__rename_stmt__init
4151
                     (PgQuery__RenameStmt         *message)
4152
0
{
4153
0
  static const PgQuery__RenameStmt init_value = PG_QUERY__RENAME_STMT__INIT;
4154
0
  *message = init_value;
4155
0
}
4156
size_t pg_query__rename_stmt__get_packed_size
4157
                     (const PgQuery__RenameStmt *message)
4158
0
{
4159
0
  assert(message->base.descriptor == &pg_query__rename_stmt__descriptor);
4160
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
4161
0
}
4162
size_t pg_query__rename_stmt__pack
4163
                     (const PgQuery__RenameStmt *message,
4164
                      uint8_t       *out)
4165
0
{
4166
0
  assert(message->base.descriptor == &pg_query__rename_stmt__descriptor);
4167
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
4168
0
}
4169
size_t pg_query__rename_stmt__pack_to_buffer
4170
                     (const PgQuery__RenameStmt *message,
4171
                      ProtobufCBuffer *buffer)
4172
0
{
4173
0
  assert(message->base.descriptor == &pg_query__rename_stmt__descriptor);
4174
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
4175
0
}
4176
PgQuery__RenameStmt *
4177
       pg_query__rename_stmt__unpack
4178
                     (ProtobufCAllocator  *allocator,
4179
                      size_t               len,
4180
                      const uint8_t       *data)
4181
0
{
4182
0
  return (PgQuery__RenameStmt *)
4183
0
     protobuf_c_message_unpack (&pg_query__rename_stmt__descriptor,
4184
0
                                allocator, len, data);
4185
0
}
4186
void   pg_query__rename_stmt__free_unpacked
4187
                     (PgQuery__RenameStmt *message,
4188
                      ProtobufCAllocator *allocator)
4189
0
{
4190
0
  if(!message)
4191
0
    return;
4192
0
  assert(message->base.descriptor == &pg_query__rename_stmt__descriptor);
4193
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
4194
0
}
4195
void   pg_query__rule_stmt__init
4196
                     (PgQuery__RuleStmt         *message)
4197
0
{
4198
0
  static const PgQuery__RuleStmt init_value = PG_QUERY__RULE_STMT__INIT;
4199
0
  *message = init_value;
4200
0
}
4201
size_t pg_query__rule_stmt__get_packed_size
4202
                     (const PgQuery__RuleStmt *message)
4203
0
{
4204
0
  assert(message->base.descriptor == &pg_query__rule_stmt__descriptor);
4205
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
4206
0
}
4207
size_t pg_query__rule_stmt__pack
4208
                     (const PgQuery__RuleStmt *message,
4209
                      uint8_t       *out)
4210
0
{
4211
0
  assert(message->base.descriptor == &pg_query__rule_stmt__descriptor);
4212
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
4213
0
}
4214
size_t pg_query__rule_stmt__pack_to_buffer
4215
                     (const PgQuery__RuleStmt *message,
4216
                      ProtobufCBuffer *buffer)
4217
0
{
4218
0
  assert(message->base.descriptor == &pg_query__rule_stmt__descriptor);
4219
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
4220
0
}
4221
PgQuery__RuleStmt *
4222
       pg_query__rule_stmt__unpack
4223
                     (ProtobufCAllocator  *allocator,
4224
                      size_t               len,
4225
                      const uint8_t       *data)
4226
0
{
4227
0
  return (PgQuery__RuleStmt *)
4228
0
     protobuf_c_message_unpack (&pg_query__rule_stmt__descriptor,
4229
0
                                allocator, len, data);
4230
0
}
4231
void   pg_query__rule_stmt__free_unpacked
4232
                     (PgQuery__RuleStmt *message,
4233
                      ProtobufCAllocator *allocator)
4234
0
{
4235
0
  if(!message)
4236
0
    return;
4237
0
  assert(message->base.descriptor == &pg_query__rule_stmt__descriptor);
4238
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
4239
0
}
4240
void   pg_query__notify_stmt__init
4241
                     (PgQuery__NotifyStmt         *message)
4242
0
{
4243
0
  static const PgQuery__NotifyStmt init_value = PG_QUERY__NOTIFY_STMT__INIT;
4244
0
  *message = init_value;
4245
0
}
4246
size_t pg_query__notify_stmt__get_packed_size
4247
                     (const PgQuery__NotifyStmt *message)
4248
0
{
4249
0
  assert(message->base.descriptor == &pg_query__notify_stmt__descriptor);
4250
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
4251
0
}
4252
size_t pg_query__notify_stmt__pack
4253
                     (const PgQuery__NotifyStmt *message,
4254
                      uint8_t       *out)
4255
0
{
4256
0
  assert(message->base.descriptor == &pg_query__notify_stmt__descriptor);
4257
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
4258
0
}
4259
size_t pg_query__notify_stmt__pack_to_buffer
4260
                     (const PgQuery__NotifyStmt *message,
4261
                      ProtobufCBuffer *buffer)
4262
0
{
4263
0
  assert(message->base.descriptor == &pg_query__notify_stmt__descriptor);
4264
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
4265
0
}
4266
PgQuery__NotifyStmt *
4267
       pg_query__notify_stmt__unpack
4268
                     (ProtobufCAllocator  *allocator,
4269
                      size_t               len,
4270
                      const uint8_t       *data)
4271
0
{
4272
0
  return (PgQuery__NotifyStmt *)
4273
0
     protobuf_c_message_unpack (&pg_query__notify_stmt__descriptor,
4274
0
                                allocator, len, data);
4275
0
}
4276
void   pg_query__notify_stmt__free_unpacked
4277
                     (PgQuery__NotifyStmt *message,
4278
                      ProtobufCAllocator *allocator)
4279
0
{
4280
0
  if(!message)
4281
0
    return;
4282
0
  assert(message->base.descriptor == &pg_query__notify_stmt__descriptor);
4283
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
4284
0
}
4285
void   pg_query__listen_stmt__init
4286
                     (PgQuery__ListenStmt         *message)
4287
0
{
4288
0
  static const PgQuery__ListenStmt init_value = PG_QUERY__LISTEN_STMT__INIT;
4289
0
  *message = init_value;
4290
0
}
4291
size_t pg_query__listen_stmt__get_packed_size
4292
                     (const PgQuery__ListenStmt *message)
4293
0
{
4294
0
  assert(message->base.descriptor == &pg_query__listen_stmt__descriptor);
4295
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
4296
0
}
4297
size_t pg_query__listen_stmt__pack
4298
                     (const PgQuery__ListenStmt *message,
4299
                      uint8_t       *out)
4300
0
{
4301
0
  assert(message->base.descriptor == &pg_query__listen_stmt__descriptor);
4302
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
4303
0
}
4304
size_t pg_query__listen_stmt__pack_to_buffer
4305
                     (const PgQuery__ListenStmt *message,
4306
                      ProtobufCBuffer *buffer)
4307
0
{
4308
0
  assert(message->base.descriptor == &pg_query__listen_stmt__descriptor);
4309
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
4310
0
}
4311
PgQuery__ListenStmt *
4312
       pg_query__listen_stmt__unpack
4313
                     (ProtobufCAllocator  *allocator,
4314
                      size_t               len,
4315
                      const uint8_t       *data)
4316
0
{
4317
0
  return (PgQuery__ListenStmt *)
4318
0
     protobuf_c_message_unpack (&pg_query__listen_stmt__descriptor,
4319
0
                                allocator, len, data);
4320
0
}
4321
void   pg_query__listen_stmt__free_unpacked
4322
                     (PgQuery__ListenStmt *message,
4323
                      ProtobufCAllocator *allocator)
4324
0
{
4325
0
  if(!message)
4326
0
    return;
4327
0
  assert(message->base.descriptor == &pg_query__listen_stmt__descriptor);
4328
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
4329
0
}
4330
void   pg_query__unlisten_stmt__init
4331
                     (PgQuery__UnlistenStmt         *message)
4332
0
{
4333
0
  static const PgQuery__UnlistenStmt init_value = PG_QUERY__UNLISTEN_STMT__INIT;
4334
0
  *message = init_value;
4335
0
}
4336
size_t pg_query__unlisten_stmt__get_packed_size
4337
                     (const PgQuery__UnlistenStmt *message)
4338
0
{
4339
0
  assert(message->base.descriptor == &pg_query__unlisten_stmt__descriptor);
4340
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
4341
0
}
4342
size_t pg_query__unlisten_stmt__pack
4343
                     (const PgQuery__UnlistenStmt *message,
4344
                      uint8_t       *out)
4345
0
{
4346
0
  assert(message->base.descriptor == &pg_query__unlisten_stmt__descriptor);
4347
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
4348
0
}
4349
size_t pg_query__unlisten_stmt__pack_to_buffer
4350
                     (const PgQuery__UnlistenStmt *message,
4351
                      ProtobufCBuffer *buffer)
4352
0
{
4353
0
  assert(message->base.descriptor == &pg_query__unlisten_stmt__descriptor);
4354
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
4355
0
}
4356
PgQuery__UnlistenStmt *
4357
       pg_query__unlisten_stmt__unpack
4358
                     (ProtobufCAllocator  *allocator,
4359
                      size_t               len,
4360
                      const uint8_t       *data)
4361
0
{
4362
0
  return (PgQuery__UnlistenStmt *)
4363
0
     protobuf_c_message_unpack (&pg_query__unlisten_stmt__descriptor,
4364
0
                                allocator, len, data);
4365
0
}
4366
void   pg_query__unlisten_stmt__free_unpacked
4367
                     (PgQuery__UnlistenStmt *message,
4368
                      ProtobufCAllocator *allocator)
4369
0
{
4370
0
  if(!message)
4371
0
    return;
4372
0
  assert(message->base.descriptor == &pg_query__unlisten_stmt__descriptor);
4373
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
4374
0
}
4375
void   pg_query__transaction_stmt__init
4376
                     (PgQuery__TransactionStmt         *message)
4377
0
{
4378
0
  static const PgQuery__TransactionStmt init_value = PG_QUERY__TRANSACTION_STMT__INIT;
4379
0
  *message = init_value;
4380
0
}
4381
size_t pg_query__transaction_stmt__get_packed_size
4382
                     (const PgQuery__TransactionStmt *message)
4383
0
{
4384
0
  assert(message->base.descriptor == &pg_query__transaction_stmt__descriptor);
4385
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
4386
0
}
4387
size_t pg_query__transaction_stmt__pack
4388
                     (const PgQuery__TransactionStmt *message,
4389
                      uint8_t       *out)
4390
0
{
4391
0
  assert(message->base.descriptor == &pg_query__transaction_stmt__descriptor);
4392
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
4393
0
}
4394
size_t pg_query__transaction_stmt__pack_to_buffer
4395
                     (const PgQuery__TransactionStmt *message,
4396
                      ProtobufCBuffer *buffer)
4397
0
{
4398
0
  assert(message->base.descriptor == &pg_query__transaction_stmt__descriptor);
4399
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
4400
0
}
4401
PgQuery__TransactionStmt *
4402
       pg_query__transaction_stmt__unpack
4403
                     (ProtobufCAllocator  *allocator,
4404
                      size_t               len,
4405
                      const uint8_t       *data)
4406
0
{
4407
0
  return (PgQuery__TransactionStmt *)
4408
0
     protobuf_c_message_unpack (&pg_query__transaction_stmt__descriptor,
4409
0
                                allocator, len, data);
4410
0
}
4411
void   pg_query__transaction_stmt__free_unpacked
4412
                     (PgQuery__TransactionStmt *message,
4413
                      ProtobufCAllocator *allocator)
4414
0
{
4415
0
  if(!message)
4416
0
    return;
4417
0
  assert(message->base.descriptor == &pg_query__transaction_stmt__descriptor);
4418
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
4419
0
}
4420
void   pg_query__view_stmt__init
4421
                     (PgQuery__ViewStmt         *message)
4422
0
{
4423
0
  static const PgQuery__ViewStmt init_value = PG_QUERY__VIEW_STMT__INIT;
4424
0
  *message = init_value;
4425
0
}
4426
size_t pg_query__view_stmt__get_packed_size
4427
                     (const PgQuery__ViewStmt *message)
4428
0
{
4429
0
  assert(message->base.descriptor == &pg_query__view_stmt__descriptor);
4430
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
4431
0
}
4432
size_t pg_query__view_stmt__pack
4433
                     (const PgQuery__ViewStmt *message,
4434
                      uint8_t       *out)
4435
0
{
4436
0
  assert(message->base.descriptor == &pg_query__view_stmt__descriptor);
4437
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
4438
0
}
4439
size_t pg_query__view_stmt__pack_to_buffer
4440
                     (const PgQuery__ViewStmt *message,
4441
                      ProtobufCBuffer *buffer)
4442
0
{
4443
0
  assert(message->base.descriptor == &pg_query__view_stmt__descriptor);
4444
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
4445
0
}
4446
PgQuery__ViewStmt *
4447
       pg_query__view_stmt__unpack
4448
                     (ProtobufCAllocator  *allocator,
4449
                      size_t               len,
4450
                      const uint8_t       *data)
4451
0
{
4452
0
  return (PgQuery__ViewStmt *)
4453
0
     protobuf_c_message_unpack (&pg_query__view_stmt__descriptor,
4454
0
                                allocator, len, data);
4455
0
}
4456
void   pg_query__view_stmt__free_unpacked
4457
                     (PgQuery__ViewStmt *message,
4458
                      ProtobufCAllocator *allocator)
4459
0
{
4460
0
  if(!message)
4461
0
    return;
4462
0
  assert(message->base.descriptor == &pg_query__view_stmt__descriptor);
4463
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
4464
0
}
4465
void   pg_query__load_stmt__init
4466
                     (PgQuery__LoadStmt         *message)
4467
0
{
4468
0
  static const PgQuery__LoadStmt init_value = PG_QUERY__LOAD_STMT__INIT;
4469
0
  *message = init_value;
4470
0
}
4471
size_t pg_query__load_stmt__get_packed_size
4472
                     (const PgQuery__LoadStmt *message)
4473
0
{
4474
0
  assert(message->base.descriptor == &pg_query__load_stmt__descriptor);
4475
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
4476
0
}
4477
size_t pg_query__load_stmt__pack
4478
                     (const PgQuery__LoadStmt *message,
4479
                      uint8_t       *out)
4480
0
{
4481
0
  assert(message->base.descriptor == &pg_query__load_stmt__descriptor);
4482
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
4483
0
}
4484
size_t pg_query__load_stmt__pack_to_buffer
4485
                     (const PgQuery__LoadStmt *message,
4486
                      ProtobufCBuffer *buffer)
4487
0
{
4488
0
  assert(message->base.descriptor == &pg_query__load_stmt__descriptor);
4489
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
4490
0
}
4491
PgQuery__LoadStmt *
4492
       pg_query__load_stmt__unpack
4493
                     (ProtobufCAllocator  *allocator,
4494
                      size_t               len,
4495
                      const uint8_t       *data)
4496
0
{
4497
0
  return (PgQuery__LoadStmt *)
4498
0
     protobuf_c_message_unpack (&pg_query__load_stmt__descriptor,
4499
0
                                allocator, len, data);
4500
0
}
4501
void   pg_query__load_stmt__free_unpacked
4502
                     (PgQuery__LoadStmt *message,
4503
                      ProtobufCAllocator *allocator)
4504
0
{
4505
0
  if(!message)
4506
0
    return;
4507
0
  assert(message->base.descriptor == &pg_query__load_stmt__descriptor);
4508
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
4509
0
}
4510
void   pg_query__create_domain_stmt__init
4511
                     (PgQuery__CreateDomainStmt         *message)
4512
0
{
4513
0
  static const PgQuery__CreateDomainStmt init_value = PG_QUERY__CREATE_DOMAIN_STMT__INIT;
4514
0
  *message = init_value;
4515
0
}
4516
size_t pg_query__create_domain_stmt__get_packed_size
4517
                     (const PgQuery__CreateDomainStmt *message)
4518
0
{
4519
0
  assert(message->base.descriptor == &pg_query__create_domain_stmt__descriptor);
4520
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
4521
0
}
4522
size_t pg_query__create_domain_stmt__pack
4523
                     (const PgQuery__CreateDomainStmt *message,
4524
                      uint8_t       *out)
4525
0
{
4526
0
  assert(message->base.descriptor == &pg_query__create_domain_stmt__descriptor);
4527
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
4528
0
}
4529
size_t pg_query__create_domain_stmt__pack_to_buffer
4530
                     (const PgQuery__CreateDomainStmt *message,
4531
                      ProtobufCBuffer *buffer)
4532
0
{
4533
0
  assert(message->base.descriptor == &pg_query__create_domain_stmt__descriptor);
4534
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
4535
0
}
4536
PgQuery__CreateDomainStmt *
4537
       pg_query__create_domain_stmt__unpack
4538
                     (ProtobufCAllocator  *allocator,
4539
                      size_t               len,
4540
                      const uint8_t       *data)
4541
0
{
4542
0
  return (PgQuery__CreateDomainStmt *)
4543
0
     protobuf_c_message_unpack (&pg_query__create_domain_stmt__descriptor,
4544
0
                                allocator, len, data);
4545
0
}
4546
void   pg_query__create_domain_stmt__free_unpacked
4547
                     (PgQuery__CreateDomainStmt *message,
4548
                      ProtobufCAllocator *allocator)
4549
0
{
4550
0
  if(!message)
4551
0
    return;
4552
0
  assert(message->base.descriptor == &pg_query__create_domain_stmt__descriptor);
4553
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
4554
0
}
4555
void   pg_query__createdb_stmt__init
4556
                     (PgQuery__CreatedbStmt         *message)
4557
0
{
4558
0
  static const PgQuery__CreatedbStmt init_value = PG_QUERY__CREATEDB_STMT__INIT;
4559
0
  *message = init_value;
4560
0
}
4561
size_t pg_query__createdb_stmt__get_packed_size
4562
                     (const PgQuery__CreatedbStmt *message)
4563
0
{
4564
0
  assert(message->base.descriptor == &pg_query__createdb_stmt__descriptor);
4565
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
4566
0
}
4567
size_t pg_query__createdb_stmt__pack
4568
                     (const PgQuery__CreatedbStmt *message,
4569
                      uint8_t       *out)
4570
0
{
4571
0
  assert(message->base.descriptor == &pg_query__createdb_stmt__descriptor);
4572
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
4573
0
}
4574
size_t pg_query__createdb_stmt__pack_to_buffer
4575
                     (const PgQuery__CreatedbStmt *message,
4576
                      ProtobufCBuffer *buffer)
4577
0
{
4578
0
  assert(message->base.descriptor == &pg_query__createdb_stmt__descriptor);
4579
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
4580
0
}
4581
PgQuery__CreatedbStmt *
4582
       pg_query__createdb_stmt__unpack
4583
                     (ProtobufCAllocator  *allocator,
4584
                      size_t               len,
4585
                      const uint8_t       *data)
4586
0
{
4587
0
  return (PgQuery__CreatedbStmt *)
4588
0
     protobuf_c_message_unpack (&pg_query__createdb_stmt__descriptor,
4589
0
                                allocator, len, data);
4590
0
}
4591
void   pg_query__createdb_stmt__free_unpacked
4592
                     (PgQuery__CreatedbStmt *message,
4593
                      ProtobufCAllocator *allocator)
4594
0
{
4595
0
  if(!message)
4596
0
    return;
4597
0
  assert(message->base.descriptor == &pg_query__createdb_stmt__descriptor);
4598
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
4599
0
}
4600
void   pg_query__dropdb_stmt__init
4601
                     (PgQuery__DropdbStmt         *message)
4602
0
{
4603
0
  static const PgQuery__DropdbStmt init_value = PG_QUERY__DROPDB_STMT__INIT;
4604
0
  *message = init_value;
4605
0
}
4606
size_t pg_query__dropdb_stmt__get_packed_size
4607
                     (const PgQuery__DropdbStmt *message)
4608
0
{
4609
0
  assert(message->base.descriptor == &pg_query__dropdb_stmt__descriptor);
4610
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
4611
0
}
4612
size_t pg_query__dropdb_stmt__pack
4613
                     (const PgQuery__DropdbStmt *message,
4614
                      uint8_t       *out)
4615
0
{
4616
0
  assert(message->base.descriptor == &pg_query__dropdb_stmt__descriptor);
4617
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
4618
0
}
4619
size_t pg_query__dropdb_stmt__pack_to_buffer
4620
                     (const PgQuery__DropdbStmt *message,
4621
                      ProtobufCBuffer *buffer)
4622
0
{
4623
0
  assert(message->base.descriptor == &pg_query__dropdb_stmt__descriptor);
4624
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
4625
0
}
4626
PgQuery__DropdbStmt *
4627
       pg_query__dropdb_stmt__unpack
4628
                     (ProtobufCAllocator  *allocator,
4629
                      size_t               len,
4630
                      const uint8_t       *data)
4631
0
{
4632
0
  return (PgQuery__DropdbStmt *)
4633
0
     protobuf_c_message_unpack (&pg_query__dropdb_stmt__descriptor,
4634
0
                                allocator, len, data);
4635
0
}
4636
void   pg_query__dropdb_stmt__free_unpacked
4637
                     (PgQuery__DropdbStmt *message,
4638
                      ProtobufCAllocator *allocator)
4639
0
{
4640
0
  if(!message)
4641
0
    return;
4642
0
  assert(message->base.descriptor == &pg_query__dropdb_stmt__descriptor);
4643
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
4644
0
}
4645
void   pg_query__vacuum_stmt__init
4646
                     (PgQuery__VacuumStmt         *message)
4647
0
{
4648
0
  static const PgQuery__VacuumStmt init_value = PG_QUERY__VACUUM_STMT__INIT;
4649
0
  *message = init_value;
4650
0
}
4651
size_t pg_query__vacuum_stmt__get_packed_size
4652
                     (const PgQuery__VacuumStmt *message)
4653
0
{
4654
0
  assert(message->base.descriptor == &pg_query__vacuum_stmt__descriptor);
4655
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
4656
0
}
4657
size_t pg_query__vacuum_stmt__pack
4658
                     (const PgQuery__VacuumStmt *message,
4659
                      uint8_t       *out)
4660
0
{
4661
0
  assert(message->base.descriptor == &pg_query__vacuum_stmt__descriptor);
4662
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
4663
0
}
4664
size_t pg_query__vacuum_stmt__pack_to_buffer
4665
                     (const PgQuery__VacuumStmt *message,
4666
                      ProtobufCBuffer *buffer)
4667
0
{
4668
0
  assert(message->base.descriptor == &pg_query__vacuum_stmt__descriptor);
4669
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
4670
0
}
4671
PgQuery__VacuumStmt *
4672
       pg_query__vacuum_stmt__unpack
4673
                     (ProtobufCAllocator  *allocator,
4674
                      size_t               len,
4675
                      const uint8_t       *data)
4676
0
{
4677
0
  return (PgQuery__VacuumStmt *)
4678
0
     protobuf_c_message_unpack (&pg_query__vacuum_stmt__descriptor,
4679
0
                                allocator, len, data);
4680
0
}
4681
void   pg_query__vacuum_stmt__free_unpacked
4682
                     (PgQuery__VacuumStmt *message,
4683
                      ProtobufCAllocator *allocator)
4684
0
{
4685
0
  if(!message)
4686
0
    return;
4687
0
  assert(message->base.descriptor == &pg_query__vacuum_stmt__descriptor);
4688
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
4689
0
}
4690
void   pg_query__explain_stmt__init
4691
                     (PgQuery__ExplainStmt         *message)
4692
0
{
4693
0
  static const PgQuery__ExplainStmt init_value = PG_QUERY__EXPLAIN_STMT__INIT;
4694
0
  *message = init_value;
4695
0
}
4696
size_t pg_query__explain_stmt__get_packed_size
4697
                     (const PgQuery__ExplainStmt *message)
4698
0
{
4699
0
  assert(message->base.descriptor == &pg_query__explain_stmt__descriptor);
4700
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
4701
0
}
4702
size_t pg_query__explain_stmt__pack
4703
                     (const PgQuery__ExplainStmt *message,
4704
                      uint8_t       *out)
4705
0
{
4706
0
  assert(message->base.descriptor == &pg_query__explain_stmt__descriptor);
4707
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
4708
0
}
4709
size_t pg_query__explain_stmt__pack_to_buffer
4710
                     (const PgQuery__ExplainStmt *message,
4711
                      ProtobufCBuffer *buffer)
4712
0
{
4713
0
  assert(message->base.descriptor == &pg_query__explain_stmt__descriptor);
4714
0
  return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
4715
0
}
4716
PgQuery__ExplainStmt *
4717
       pg_query__explain_stmt__unpack
4718
                     (ProtobufCAllocator  *allocator,
4719
                      size_t               len,
4720
                      const uint8_t       *data)
4721
0
{
4722
0
  return (PgQuery__ExplainStmt *)
4723
0
     protobuf_c_message_unpack (&pg_query__explain_stmt__descriptor,
4724
0
                                allocator, len, data);
4725
0
}
4726
void   pg_query__explain_stmt__free_unpacked
4727
                     (PgQuery__ExplainStmt *message,
4728
                      ProtobufCAllocator *allocator)
4729
0
{
4730
0
  if(!message)
4731
0
    return;
4732
0
  assert(message->base.descriptor == &pg_query__explain_stmt__descriptor);
4733
0
  protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
4734
0
}
4735
void   pg_query__create_table_as_stmt__init
4736
                     (PgQuery__CreateTableAsStmt         *message)
4737
0
{
4738
0
  static const PgQuery__CreateTableAsStmt init_value = PG_QUERY__CREATE_TABLE_AS_STMT__INIT;
4739
0
  *message = init_value;
4740
0
}
4741
size_t pg_query__create_table_as_stmt__get_packed_size
4742
                     (const PgQuery__CreateTableAsStmt *message)
4743
0
{
4744
0
  assert(message->base.descriptor == &pg_query__create_table_as_stmt__descriptor);
4745
0
  return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
4746
0
}
4747
size_t pg_query__create_table_as_stmt__pack
4748
                     (const PgQuery__CreateTableAsStmt *message,
4749
                      uint8_t       *out)
4750
0
{
4751
0
  assert(message->base.descriptor == &pg_query__create_table_as_stmt__descriptor);
4752
0
  return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
4753
0
}
4754
size_t pg_query__create_table_as_stmt__pack_to