← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/postgresql-9.1/oneiric-security

« back to all changes in this revision

Viewing changes to src/backend/bootstrap/bootparse.y

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2011-05-11 10:41:53 UTC
  • Revision ID: james.westby@ubuntu.com-20110511104153-psbh2o58553fv1m0
Tags: upstream-9.1~beta1
Import upstream version 9.1~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/backend/bootstrap/bootparse.y
 
1
%{
 
2
/*-------------------------------------------------------------------------
 
3
 *
 
4
 * bootparse.y
 
5
 *        yacc grammar for the "bootstrap" mode (BKI file format)
 
6
 *
 
7
 * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
 
8
 * Portions Copyright (c) 1994, Regents of the University of California
 
9
 *
 
10
 *
 
11
 * IDENTIFICATION
 
12
 *        src/backend/bootstrap/bootparse.y
 
13
 *
 
14
 *-------------------------------------------------------------------------
 
15
 */
 
16
 
 
17
#include "postgres.h"
 
18
 
 
19
#include <unistd.h>
 
20
 
 
21
#include "access/attnum.h"
 
22
#include "access/htup.h"
 
23
#include "access/itup.h"
 
24
#include "access/skey.h"
 
25
#include "access/tupdesc.h"
 
26
#include "access/xact.h"
 
27
#include "bootstrap/bootstrap.h"
 
28
#include "catalog/catalog.h"
 
29
#include "catalog/heap.h"
 
30
#include "catalog/pg_am.h"
 
31
#include "catalog/pg_attribute.h"
 
32
#include "catalog/pg_authid.h"
 
33
#include "catalog/pg_class.h"
 
34
#include "catalog/pg_namespace.h"
 
35
#include "catalog/pg_tablespace.h"
 
36
#include "catalog/toasting.h"
 
37
#include "commands/defrem.h"
 
38
#include "miscadmin.h"
 
39
#include "nodes/makefuncs.h"
 
40
#include "nodes/nodes.h"
 
41
#include "nodes/parsenodes.h"
 
42
#include "nodes/pg_list.h"
 
43
#include "nodes/primnodes.h"
 
44
#include "rewrite/prs2lock.h"
 
45
#include "storage/block.h"
 
46
#include "storage/fd.h"
 
47
#include "storage/ipc.h"
 
48
#include "storage/itemptr.h"
 
49
#include "storage/off.h"
 
50
#include "storage/smgr.h"
 
51
#include "tcop/dest.h"
 
52
#include "utils/rel.h"
 
53
 
 
54
#define atooid(x)       ((Oid) strtoul((x), NULL, 10))
 
55
 
 
56
 
 
57
/*
 
58
 * Bison doesn't allocate anything that needs to live across parser calls,
 
59
 * so we can easily have it use palloc instead of malloc.  This prevents
 
60
 * memory leaks if we error out during parsing.  Note this only works with
 
61
 * bison >= 2.0.  However, in bison 1.875 the default is to use alloca()
 
62
 * if possible, so there's not really much problem anyhow, at least if
 
63
 * you're building with gcc.
 
64
 */
 
65
#define YYMALLOC palloc
 
66
#define YYFREE   pfree
 
67
 
 
68
static void
 
69
do_start(void)
 
70
{
 
71
        StartTransactionCommand();
 
72
        elog(DEBUG4, "start transaction");
 
73
}
 
74
 
 
75
 
 
76
static void
 
77
do_end(void)
 
78
{
 
79
        CommitTransactionCommand();
 
80
        elog(DEBUG4, "commit transaction");
 
81
        CHECK_FOR_INTERRUPTS();         /* allow SIGINT to kill bootstrap run */
 
82
        if (isatty(0))
 
83
        {
 
84
                printf("bootstrap> ");
 
85
                fflush(stdout);
 
86
        }
 
87
}
 
88
 
 
89
 
 
90
static int num_columns_read = 0;
 
91
 
 
92
%}
 
93
 
 
94
%expect 0
 
95
%name-prefix="boot_yy"
 
96
 
 
97
%union
 
98
{
 
99
        List            *list;
 
100
        IndexElem       *ielem;
 
101
        char            *str;
 
102
        int                     ival;
 
103
        Oid                     oidval;
 
104
}
 
105
 
 
106
%type <list>  boot_index_params
 
107
%type <ielem> boot_index_param
 
108
%type <str>   boot_const boot_ident
 
109
%type <ival>  optbootstrap optsharedrelation optwithoutoids
 
110
%type <oidval> oidspec optoideq optrowtypeoid
 
111
 
 
112
%token <str> CONST_P ID
 
113
%token OPEN XCLOSE XCREATE INSERT_TUPLE
 
114
%token XDECLARE INDEX ON USING XBUILD INDICES UNIQUE XTOAST
 
115
%token COMMA EQUALS LPAREN RPAREN
 
116
%token OBJ_ID XBOOTSTRAP XSHARED_RELATION XWITHOUT_OIDS XROWTYPE_OID NULLVAL
 
117
 
 
118
%start TopLevel
 
119
 
 
120
%nonassoc low
 
121
%nonassoc high
 
122
 
 
123
%%
 
124
 
 
125
TopLevel:
 
126
                  Boot_Queries
 
127
                |
 
128
                ;
 
129
 
 
130
Boot_Queries:
 
131
                  Boot_Query
 
132
                | Boot_Queries Boot_Query
 
133
                ;
 
134
 
 
135
Boot_Query :
 
136
                  Boot_OpenStmt
 
137
                | Boot_CloseStmt
 
138
                | Boot_CreateStmt
 
139
                | Boot_InsertStmt
 
140
                | Boot_DeclareIndexStmt
 
141
                | Boot_DeclareUniqueIndexStmt
 
142
                | Boot_DeclareToastStmt
 
143
                | Boot_BuildIndsStmt
 
144
                ;
 
145
 
 
146
Boot_OpenStmt:
 
147
                  OPEN boot_ident
 
148
                                {
 
149
                                        do_start();
 
150
                                        boot_openrel($2);
 
151
                                        do_end();
 
152
                                }
 
153
                ;
 
154
 
 
155
Boot_CloseStmt:
 
156
                  XCLOSE boot_ident %prec low
 
157
                                {
 
158
                                        do_start();
 
159
                                        closerel($2);
 
160
                                        do_end();
 
161
                                }
 
162
                | XCLOSE %prec high
 
163
                                {
 
164
                                        do_start();
 
165
                                        closerel(NULL);
 
166
                                        do_end();
 
167
                                }
 
168
                ;
 
169
 
 
170
Boot_CreateStmt:
 
171
                  XCREATE boot_ident oidspec optbootstrap optsharedrelation optwithoutoids optrowtypeoid LPAREN
 
172
                                {
 
173
                                        do_start();
 
174
                                        numattr = 0;
 
175
                                        elog(DEBUG4, "creating%s%s relation %s %u",
 
176
                                                 $4 ? " bootstrap" : "",
 
177
                                                 $5 ? " shared" : "",
 
178
                                                 $2,
 
179
                                                 $3);
 
180
                                }
 
181
                  boot_column_list
 
182
                                {
 
183
                                        do_end();
 
184
                                }
 
185
                  RPAREN
 
186
                                {
 
187
                                        TupleDesc tupdesc;
 
188
                                        bool    shared_relation;
 
189
                                        bool    mapped_relation;
 
190
 
 
191
                                        do_start();
 
192
 
 
193
                                        tupdesc = CreateTupleDesc(numattr, !($6), attrtypes);
 
194
 
 
195
                                        shared_relation = $5;
 
196
 
 
197
                                        /*
 
198
                                         * The catalogs that use the relation mapper are the
 
199
                                         * bootstrap catalogs plus the shared catalogs.  If this
 
200
                                         * ever gets more complicated, we should invent a BKI
 
201
                                         * keyword to mark the mapped catalogs, but for now a
 
202
                                         * quick hack seems the most appropriate thing.  Note in
 
203
                                         * particular that all "nailed" heap rels (see formrdesc
 
204
                                         * in relcache.c) must be mapped.
 
205
                                         */
 
206
                                        mapped_relation = ($4 || shared_relation);
 
207
 
 
208
                                        if ($4)
 
209
                                        {
 
210
                                                if (boot_reldesc)
 
211
                                                {
 
212
                                                        elog(DEBUG4, "create bootstrap: warning, open relation exists, closing first");
 
213
                                                        closerel(NULL);
 
214
                                                }
 
215
 
 
216
                                                boot_reldesc = heap_create($2,
 
217
                                                                                                   PG_CATALOG_NAMESPACE,
 
218
                                                                                                   shared_relation ? GLOBALTABLESPACE_OID : 0,
 
219
                                                                                                   $3,
 
220
                                                                                                   tupdesc,
 
221
                                                                                                   RELKIND_RELATION,
 
222
                                                                                                   RELPERSISTENCE_PERMANENT,
 
223
                                                                                                   shared_relation,
 
224
                                                                                                   mapped_relation,
 
225
                                                                                                   true);
 
226
                                                elog(DEBUG4, "bootstrap relation created");
 
227
                                        }
 
228
                                        else
 
229
                                        {
 
230
                                                Oid id;
 
231
 
 
232
                                                id = heap_create_with_catalog($2,
 
233
                                                                                                          PG_CATALOG_NAMESPACE,
 
234
                                                                                                          shared_relation ? GLOBALTABLESPACE_OID : 0,
 
235
                                                                                                          $3,
 
236
                                                                                                          $7,
 
237
                                                                                                          InvalidOid,
 
238
                                                                                                          BOOTSTRAP_SUPERUSERID,
 
239
                                                                                                          tupdesc,
 
240
                                                                                                          NIL,
 
241
                                                                                                          RELKIND_RELATION,
 
242
                                                                                                          RELPERSISTENCE_PERMANENT,
 
243
                                                                                                          shared_relation,
 
244
                                                                                                          mapped_relation,
 
245
                                                                                                          true,
 
246
                                                                                                          0,
 
247
                                                                                                          ONCOMMIT_NOOP,
 
248
                                                                                                          (Datum) 0,
 
249
                                                                                                          false,
 
250
                                                                                                          true);
 
251
                                                elog(DEBUG4, "relation created with oid %u", id);
 
252
                                        }
 
253
                                        do_end();
 
254
                                }
 
255
                ;
 
256
 
 
257
Boot_InsertStmt:
 
258
                  INSERT_TUPLE optoideq
 
259
                                {
 
260
                                        do_start();
 
261
                                        if ($2)
 
262
                                                elog(DEBUG4, "inserting row with oid %u", $2);
 
263
                                        else
 
264
                                                elog(DEBUG4, "inserting row");
 
265
                                        num_columns_read = 0;
 
266
                                }
 
267
                  LPAREN boot_column_val_list RPAREN
 
268
                                {
 
269
                                        if (num_columns_read != numattr)
 
270
                                                elog(ERROR, "incorrect number of columns in row (expected %d, got %d)",
 
271
                                                         numattr, num_columns_read);
 
272
                                        if (boot_reldesc == NULL)
 
273
                                                elog(FATAL, "relation not open");
 
274
                                        InsertOneTuple($2);
 
275
                                        do_end();
 
276
                                }
 
277
                ;
 
278
 
 
279
Boot_DeclareIndexStmt:
 
280
                  XDECLARE INDEX boot_ident oidspec ON boot_ident USING boot_ident LPAREN boot_index_params RPAREN
 
281
                                {
 
282
                                        do_start();
 
283
 
 
284
                                        DefineIndex(makeRangeVar(NULL, $6, -1),
 
285
                                                                $3,
 
286
                                                                $4,
 
287
                                                                $8,
 
288
                                                                NULL,
 
289
                                                                $10,
 
290
                                                                NULL, NIL, NIL,
 
291
                                                                false, false, false, false, false,
 
292
                                                                false, false, true, false, false);
 
293
                                        do_end();
 
294
                                }
 
295
                ;
 
296
 
 
297
Boot_DeclareUniqueIndexStmt:
 
298
                  XDECLARE UNIQUE INDEX boot_ident oidspec ON boot_ident USING boot_ident LPAREN boot_index_params RPAREN
 
299
                                {
 
300
                                        do_start();
 
301
 
 
302
                                        DefineIndex(makeRangeVar(NULL, $7, -1),
 
303
                                                                $4,
 
304
                                                                $5,
 
305
                                                                $9,
 
306
                                                                NULL,
 
307
                                                                $11,
 
308
                                                                NULL, NIL, NIL,
 
309
                                                                true, false, false, false, false,
 
310
                                                                false, false, true, false, false);
 
311
                                        do_end();
 
312
                                }
 
313
                ;
 
314
 
 
315
Boot_DeclareToastStmt:
 
316
                  XDECLARE XTOAST oidspec oidspec ON boot_ident
 
317
                                {
 
318
                                        do_start();
 
319
 
 
320
                                        BootstrapToastTable($6, $3, $4);
 
321
                                        do_end();
 
322
                                }
 
323
                ;
 
324
 
 
325
Boot_BuildIndsStmt:
 
326
                  XBUILD INDICES
 
327
                                {
 
328
                                        do_start();
 
329
                                        build_indices();
 
330
                                        do_end();
 
331
                                }
 
332
                ;
 
333
 
 
334
 
 
335
boot_index_params:
 
336
                boot_index_params COMMA boot_index_param        { $$ = lappend($1, $3); }
 
337
                | boot_index_param                                                      { $$ = list_make1($1); }
 
338
                ;
 
339
 
 
340
boot_index_param:
 
341
                boot_ident boot_ident
 
342
                                {
 
343
                                        IndexElem *n = makeNode(IndexElem);
 
344
                                        n->name = $1;
 
345
                                        n->expr = NULL;
 
346
                                        n->indexcolname = NULL;
 
347
                                        n->collation = NIL;
 
348
                                        n->opclass = list_make1(makeString($2));
 
349
                                        n->ordering = SORTBY_DEFAULT;
 
350
                                        n->nulls_ordering = SORTBY_NULLS_DEFAULT;
 
351
                                        $$ = n;
 
352
                                }
 
353
                ;
 
354
 
 
355
optbootstrap:
 
356
                        XBOOTSTRAP      { $$ = 1; }
 
357
                |                               { $$ = 0; }
 
358
                ;
 
359
 
 
360
optsharedrelation:
 
361
                        XSHARED_RELATION        { $$ = 1; }
 
362
                |                                               { $$ = 0; }
 
363
                ;
 
364
 
 
365
optwithoutoids:
 
366
                        XWITHOUT_OIDS   { $$ = 1; }
 
367
                |                                       { $$ = 0; }
 
368
                ;
 
369
 
 
370
optrowtypeoid:
 
371
                        XROWTYPE_OID oidspec    { $$ = $2; }
 
372
                |                                                       { $$ = InvalidOid; }
 
373
                ;
 
374
 
 
375
boot_column_list:
 
376
                  boot_column_def
 
377
                | boot_column_list COMMA boot_column_def
 
378
                ;
 
379
 
 
380
boot_column_def:
 
381
                  boot_ident EQUALS boot_ident
 
382
                                {
 
383
                                   if (++numattr > MAXATTR)
 
384
                                                elog(FATAL, "too many columns");
 
385
                                   DefineAttr($1, $3, numattr-1);
 
386
                                }
 
387
                ;
 
388
 
 
389
oidspec:
 
390
                        boot_ident                                                      { $$ = atooid($1); }
 
391
                ;
 
392
 
 
393
optoideq:
 
394
                        OBJ_ID EQUALS oidspec                           { $$ = $3; }
 
395
                |                                                                               { $$ = InvalidOid; }
 
396
                ;
 
397
 
 
398
boot_column_val_list:
 
399
                   boot_column_val
 
400
                |  boot_column_val_list boot_column_val
 
401
                |  boot_column_val_list COMMA boot_column_val
 
402
                ;
 
403
 
 
404
boot_column_val:
 
405
                  boot_ident
 
406
                        { InsertOneValue($1, num_columns_read++); }
 
407
                | boot_const
 
408
                        { InsertOneValue($1, num_columns_read++); }
 
409
                | NULLVAL
 
410
                        { InsertOneNull(num_columns_read++); }
 
411
                ;
 
412
 
 
413
boot_const :
 
414
                  CONST_P { $$ = yylval.str; }
 
415
                ;
 
416
 
 
417
boot_ident :
 
418
                  ID    { $$ = yylval.str; }
 
419
                ;
 
420
%%
 
421
 
 
422
#include "bootscanner.c"