← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/pgpool2/oneiric

« back to all changes in this revision

Viewing changes to parser/outfuncs.c

  • Committer: Bazaar Package Importer
  • Author(s): Marc Gariepy
  • Date: 2010-02-17 13:58:08 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20100217135808-vqxtfe80r5z8toje
Tags: 2.3.2.1-0ubuntu1
* New upstream release (2.3.2.1)
 * Lots of bug fixes
 * Add SSL support
 * Add support for large object replication
 * Enhanced replication (TIMESTAMP, DATES)
 * Save node status on restart
 * Some other minor changes

Show diffs side-by-side

added added

removed removed

Lines of Context:
parser/outfuncs.c
3
3
 * outfuncs.c
4
4
 *        Output functions for Postgres tree nodes.
5
5
 *
6
 
 * Portions Copyright (c) 2003-2008, PgPool Global Development Group
 
6
 * Portions Copyright (c) 1996-2009, PostgreSQL Global Development Group
7
7
 * Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
8
8
 * Portions Copyright (c) 1994, Regents of the University of California
9
9
 *
10
10
 *
11
11
 * IDENTIFICATION
12
 
 *        $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.261.2.1 2005/11/14 23:54:34 tgl Exp $
 
12
 *        $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.360 2009/06/11 14:48:58 momjian Exp $
13
13
 *
14
14
 * NOTES
15
15
 *        Every node type that can appear in stored rules' parsetrees *must*
81
81
static void _outTypeName(String *str, TypeName *node);
82
82
static void _outTypeCast(String *str, TypeCast *node);
83
83
static void _outIndexElem(String *str, IndexElem *node);
84
 
static void _outSortClause(String *str, SortClause *node);
85
 
static void _outGroupClause(String *str, GroupClause *node);
 
84
static void _outWithClause(String *str, WithClause *node);
 
85
static void _outCommonTableExpr(String *str, CommonTableExpr *node);
86
86
static void _outSetOperationStmt(String *str, SetOperationStmt *node);
87
87
static void _outAExpr(String *str, A_Expr *node);
88
88
static void _outValue(String *str, Value *value);
92
92
static void _outA_Indices(String *str, A_Indices *node);
93
93
static void _outA_Indirection(String *str, A_Indirection *node);
94
94
static void _outResTarget(String *str, ResTarget *node);
 
95
static void _outWindowDef(String *str, WindowDef *node);
95
96
static void _outConstraint(String *str, Constraint *node);
96
97
static void _outFkConstraint(String *str, FkConstraint *node);
97
98
 
171
172
static void _outAlterTableCmd(String *str, AlterTableCmd *node);
172
173
static void _outOptSeqList(String *str, List *options);
173
174
static void _outPrivGrantee(String *str, PrivGrantee *node);
174
 
static void _outPrivTarget(String *str, PrivTarget *node);
175
175
static void _outFuncWithArgs(String *str, FuncWithArgs *node);
176
176
static void _outFunctionParameter(String *str, FunctionParameter *node);
177
177
static void _outPrivilegeList(String *str, List *list);
769
769
_outNotifyStmt(String *str, NotifyStmt *node)
770
770
{
771
771
        string_append_char(str, "NOTIFY ");
772
 
        _outNode(str, node->relation);
 
772
        string_append_char(str, "\"");
 
773
        string_append_char(str, node->conditionname);
 
774
        string_append_char(str, "\"");
773
775
}
774
776
 
775
777
static void
834
836
                ListCell *lc;
835
837
                int comma = 0;
836
838
 
 
839
                string_append_char(str, " VALUES");
837
840
                foreach (lc, node->valuesLists)
838
841
                {
839
842
                        if (comma == 0)
841
844
                        else
842
845
                                string_append_char(str, ",");
843
846
 
844
 
                        string_append_char(str, " VALUES (");
 
847
                        string_append_char(str, " (");
845
848
                        _outNode(str, lfirst(lc));
846
849
                        string_append_char(str, ")");
847
850
                }
890
893
                        string_append_char(str, " AS");
891
894
                }
892
895
 
 
896
                if (node->withClause)
 
897
                        _outWithClause(str, node->withClause);
 
898
 
893
899
                string_append_char(str, " SELECT ");
894
900
 
895
901
                if (node->distinctClause)
928
934
                        string_append_char(str, " HAVING ");
929
935
                        _outNode(str, node->havingClause);
930
936
                }
 
937
 
 
938
                if (node->windowClause)
 
939
                {
 
940
                        string_append_char(str, " WINDOW ");
 
941
                        _outNode(str, node->windowClause);
 
942
                }
931
943
        }
932
944
 
933
945
        if (node->sortClause)
984
996
                _outNode(str, node->args);
985
997
 
986
998
        string_append_char(str, ")");
 
999
 
 
1000
        if (node->over)
 
1001
        {
 
1002
                string_append_char(str, " OVER ");
 
1003
                if (node->over->name)
 
1004
                {
 
1005
                        string_append_char(str, "\"");
 
1006
                        string_append_char(str, node->over->name);
 
1007
                        string_append_char(str, "\"");
 
1008
                }
 
1009
                else
 
1010
                        _outWindowDef(str, node->over);
 
1011
        }
987
1012
}
988
1013
 
989
1014
static void
1022
1047
static void
1023
1048
_outTypeName(String *str, TypeName *node)
1024
1049
{
1025
 
        ListCell *lc;
1026
 
        char dot = 0;
1027
 
 
1028
 
        foreach (lc, node->names)
 
1050
 
 
1051
        /* don't quote SystemType name, because
 
1052
         * 1. char is not "char".
 
1053
         * 2. in 8.4, interval with fields cause error.
 
1054
         * =# SELECT '1'::"interval" year;
 
1055
         * ERROR:  syntax error at or near "year"
 
1056
         * LINE 1: SELECT '1'::"interval" year;
 
1057
         */
 
1058
        if (list_length(node->names) == 2 && 
 
1059
                strcmp("pg_catalog", strVal(linitial(node->names))) == 0)
 
1060
        {
 
1061
                string_append_char(str, strVal(lsecond(node->names)));
 
1062
 
 
1063
                if (strcmp("interval", strVal(lsecond(node->names))) == 0)
 
1064
                {
 
1065
                        if (node->typmods != NIL)
 
1066
                        {
 
1067
                                A_Const         *v = (A_Const *) linitial(node->typmods);
 
1068
                                int                     mask = v->val.val.ival;
 
1069
 
 
1070
                                /* precision for SECOND field.
 
1071
                                 * backword comaptibility.
 
1072
                                 * use `'1.2 second'::interval(0) second'
 
1073
                                 * not `'1.2 second'::interval second(0)'(standarad for 8.4).
 
1074
                                 */
 
1075
                                if ((INTERVAL_MASK(SECOND) & mask) && 
 
1076
                                        list_length(node->typmods) == 2)
 
1077
                                {
 
1078
                                        string_append_char(str, "(");
 
1079
                                        _outAConst(str, lsecond(node->typmods));
 
1080
                                        string_append_char(str, ")");
 
1081
                                }
 
1082
 
 
1083
                                /* optional fields */
 
1084
                                if (mask == INTERVAL_MASK(YEAR))
 
1085
                                        string_append_char(str, " YEAR");
 
1086
                                else if (mask == INTERVAL_MASK(MONTH))
 
1087
                                        string_append_char(str, " MONTH");
 
1088
                                else if (mask == INTERVAL_MASK(DAY))
 
1089
                                        string_append_char(str, " DAY");
 
1090
                                else if (mask == INTERVAL_MASK(HOUR))
 
1091
                                        string_append_char(str, " HOUR");
 
1092
                                else if (mask == INTERVAL_MASK(MINUTE))
 
1093
                                        string_append_char(str, " MINUTE");
 
1094
                                else if (mask == INTERVAL_MASK(SECOND))
 
1095
                                        string_append_char(str, " SECOND");
 
1096
                                else if (mask == (INTERVAL_MASK(YEAR) | INTERVAL_MASK(MONTH)))
 
1097
                                        string_append_char(str, " YEAR TO MONTH");
 
1098
                                else if (mask == (INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR)))
 
1099
                                        string_append_char(str, " DAY TO HOUR");
 
1100
                                else if (mask == (INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) |
 
1101
                                                                  INTERVAL_MASK(MINUTE)))
 
1102
                                        string_append_char(str, " DAY TO MINUTE");
 
1103
                                else if (mask == (INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) | 
 
1104
                                                                  INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND)))
 
1105
                                        string_append_char(str, " DAY TO SECOND");
 
1106
                                else if (mask == (INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE)))
 
1107
                                        string_append_char(str, " HOUR TO MINUTE");
 
1108
                                else if (mask == (INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE) |
 
1109
                                                                  INTERVAL_MASK(SECOND)))
 
1110
                                        string_append_char(str, " HOUR TO SECOND");
 
1111
                                else if (mask == (INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND)))
 
1112
                                        string_append_char(str, " MINUTE TO SECOND");
 
1113
                        }
 
1114
 
 
1115
                        return;
 
1116
                }
 
1117
        }
 
1118
        else
1029
1119
        {
1030
 
                Value *v = (Value *) lfirst(lc);
1031
 
                char *typename = v->val.str;
 
1120
                ListCell *lc;
 
1121
                char dot = 0;
1032
1122
 
1033
 
                if (dot == 0)
1034
 
                        dot = 1;
1035
 
                else
1036
 
                        string_append_char(str, ".");
1037
 
                if(node->typemod < 0)
 
1123
                foreach (lc, node->names)
1038
1124
                {
1039
 
                        string_append_char(str, "\"");
1040
 
                        string_append_char(str, typename);
1041
 
                        string_append_char(str, "\"");
1042
 
                } else 
1043
 
                        string_append_char(str, typename);
 
1125
                        Value *v = (Value *) lfirst(lc);
 
1126
                        char *typename = v->val.str;
 
1127
 
 
1128
                        if (dot == 0)
 
1129
                                dot = 1;
 
1130
                        else
 
1131
                                string_append_char(str, ".");
 
1132
                        if(node->typemod < 0)
 
1133
                        {
 
1134
                                string_append_char(str, "\"");
 
1135
                                string_append_char(str, typename);
 
1136
                                string_append_char(str, "\"");
 
1137
                        } else 
 
1138
                                string_append_char(str, typename);
 
1139
                }
1044
1140
        }
1045
1141
        
1046
 
        if (node->typemod > 0)
 
1142
        /* precisions */
 
1143
        if (node->typmods)
1047
1144
        {
1048
 
        int lower;
1049
 
        char buf[16];
1050
 
        string_append_char(str, "(");
1051
 
        snprintf(buf, 16, "%d", ((node->typemod - VARHDRSZ) >> 16) & 0x00FF);
1052
 
        string_append_char(str, buf);
1053
 
        lower = (node->typemod-VARHDRSZ) & 0x00FF;
1054
 
 
1055
 
        if(lower != 0)
1056
 
        {
1057
 
            char buf2[16];
1058
 
            string_append_char(str, ",");
1059
 
            snprintf(buf2, 16, "%d",lower);
1060
 
            string_append_char(str, buf2);
1061
 
        }
1062
 
 
1063
 
        string_append_char(str, ")");
 
1145
                string_append_char(str, "(");
 
1146
                _outList(str, node->typmods);
 
1147
                string_append_char(str, ")");
1064
1148
        }
1065
1149
}
1066
1150
 
1094
1178
        }
1095
1179
}
1096
1180
 
1097
 
 
1098
1181
static void
1099
 
_outSortClause(String *str, SortClause *node)
 
1182
_outWithClause(String *str, WithClause *node)
1100
1183
{
 
1184
        string_append_char(str, " WITH ");
 
1185
        if (node->recursive)
 
1186
                string_append_char(str, "RECURSIVE ");
1101
1187
 
 
1188
        _outList(str, node->ctes);
1102
1189
}
1103
1190
 
1104
1191
static void
1105
 
_outGroupClause(String *str, GroupClause *node)
 
1192
_outCommonTableExpr(String *str, CommonTableExpr *node)
1106
1193
{
1107
 
 
 
1194
        string_append_char(str, "\"");
 
1195
        string_append_char(str, node->ctename);
 
1196
        string_append_char(str, "\" ");
 
1197
 
 
1198
        if (node->aliascolnames)
 
1199
        {
 
1200
                string_append_char(str, "(");
 
1201
                _outIdList(str, node->aliascolnames);
 
1202
                string_append_char(str, ") ");
 
1203
        }
 
1204
 
 
1205
        string_append_char(str, "AS (");
 
1206
        _outNode(str, node->ctequery);
 
1207
        string_append_char(str, ")");
1108
1208
}
1109
1209
 
1110
1210
static void
1271
1371
                        string_append_char(str, v->val.str);
1272
1372
                        string_append_char(str, "\"");
1273
1373
                }
 
1374
                else if (IsA(n, A_Star)) 
 
1375
                {
 
1376
                        if (first == 0)
 
1377
                                first = 1;
 
1378
                        else
 
1379
                                string_append_char(str, ".");
 
1380
 
 
1381
                        string_append_char(str, "*");
 
1382
                }
1274
1383
        }
1275
1384
}
1276
1385
 
1288
1397
_outAConst(String *str, A_Const *node)
1289
1398
{
1290
1399
        char buf[16];
1291
 
        char *name = NULL;
1292
 
 
1293
 
        if (node->typename)
1294
 
        {
1295
 
                Value *v = linitial(node->typename->names);
1296
 
                name = v->val.str;
1297
 
                _outNode(str, node->typename);
1298
 
                string_append_char(str, " ");
1299
 
        }
1300
1400
 
1301
1401
        switch (node->val.type)
1302
1402
        {
1322
1422
                default:
1323
1423
                        break;
1324
1424
        }
1325
 
 
1326
 
        if (name && (strcmp(name, "interval") == 0) &&
1327
 
                node->typename->typmods)
1328
 
        {
1329
 
                A_Const *v = linitial(node->typename->typmods);
1330
 
                int mask = v->val.val.ival;
1331
 
 
1332
 
                if (mask == INTERVAL_MASK(YEAR))
1333
 
                        string_append_char(str, " YEAR");
1334
 
                else if (mask == INTERVAL_MASK(MONTH))
1335
 
                        string_append_char(str, " MONTH");
1336
 
                else if (mask == INTERVAL_MASK(DAY))
1337
 
                        string_append_char(str, " DAY");
1338
 
                else if (mask == INTERVAL_MASK(HOUR))
1339
 
                        string_append_char(str, " HOUR");
1340
 
                else if (mask == INTERVAL_MASK(MINUTE))
1341
 
                        string_append_char(str, " MINUTE");
1342
 
                else if (mask == INTERVAL_MASK(SECOND))
1343
 
                        string_append_char(str, " SECOND");
1344
 
                else if (mask == (INTERVAL_MASK(YEAR) | INTERVAL_MASK(MONTH)))
1345
 
                        string_append_char(str, " YEAR TO MONTH");
1346
 
                else if (mask == (INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR)))
1347
 
                        string_append_char(str, " DAY TO HOUR");
1348
 
                else if (mask == (INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) |
1349
 
                                                  INTERVAL_MASK(MINUTE)))
1350
 
                        string_append_char(str, " DAY TO MINUTE");
1351
 
                else if (mask == (INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) |
1352
 
                                                  INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND)))
1353
 
                        string_append_char(str, " DAY TO SECOND");
1354
 
                else if (mask == (INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE)))
1355
 
                        string_append_char(str, " HOUR TO MINUTE");
1356
 
                else if (mask == (INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE) |
1357
 
                                                  INTERVAL_MASK(SECOND)))
1358
 
                        string_append_char(str, " HOUR TO SECOND");
1359
 
        }
1360
1425
}
1361
1426
 
1362
1427
static void
1404
1469
}
1405
1470
 
1406
1471
static void
 
1472
_outWindowDef(String *str, WindowDef *node)
 
1473
{
 
1474
        if (node->name)
 
1475
        {
 
1476
                string_append_char(str, "\"");
 
1477
                string_append_char(str, node->name);
 
1478
                string_append_char(str, "\" AS ");
 
1479
        }
 
1480
        string_append_char(str, "(");
 
1481
 
 
1482
        if (node->refname)
 
1483
        {
 
1484
                string_append_char(str, "\"");
 
1485
                string_append_char(str, node->refname);
 
1486
                string_append_char(str, "\" ");
 
1487
        }
 
1488
 
 
1489
        if (node->partitionClause)
 
1490
        {
 
1491
                string_append_char(str, " PARTITION BY ");
 
1492
                _outNode(str, node->partitionClause);
 
1493
        }
 
1494
 
 
1495
        if (node->orderClause)
 
1496
        {
 
1497
                string_append_char(str, " ORDER BY ");
 
1498
                _outNode(str, node->orderClause);
 
1499
        }
 
1500
 
 
1501
        if (node->frameOptions != FRAMEOPTION_DEFAULTS)
 
1502
        {
 
1503
                if (node->frameOptions & FRAMEOPTION_RANGE)
 
1504
                        string_append_char(str, " RANGE");
 
1505
                else if (node->frameOptions & FRAMEOPTION_ROWS)
 
1506
                        string_append_char(str, " ROWS");
 
1507
 
 
1508
                if (node->frameOptions & FRAMEOPTION_BETWEEN)
 
1509
                        string_append_char(str, " BETWEEN");
 
1510
 
 
1511
                if (node->frameOptions & FRAMEOPTION_START_UNBOUNDED_PRECEDING)
 
1512
                        string_append_char(str, " UNBOUNDED PRECEDING");
 
1513
                else if (node->frameOptions & FRAMEOPTION_START_UNBOUNDED_FOLLOWING)
 
1514
                        string_append_char(str, " UNBOUNDED FOLLOWING");
 
1515
                else if (node->frameOptions & FRAMEOPTION_START_CURRENT_ROW)
 
1516
                        string_append_char(str, " UNBOUNDED CURRENT ROW");
 
1517
 
 
1518
                if (node->frameOptions & FRAMEOPTION_BETWEEN)
 
1519
                {
 
1520
                        string_append_char(str, " AND");
 
1521
                        if (node->frameOptions & FRAMEOPTION_END_UNBOUNDED_PRECEDING)
 
1522
                                string_append_char(str, " UNBOUNDED PRECEDING");
 
1523
                        else if (node->frameOptions & FRAMEOPTION_END_UNBOUNDED_FOLLOWING)
 
1524
                                string_append_char(str, " UNBOUNDED FOLLOWING");
 
1525
                        else if (node->frameOptions & FRAMEOPTION_END_CURRENT_ROW)
 
1526
                                string_append_char(str, " UNBOUNDED CURRENT ROW");
 
1527
                }
 
1528
        }
 
1529
        string_append_char(str, ")");
 
1530
}
 
1531
 
 
1532
static void
1407
1533
_outConstraint(String *str, Constraint *node)
1408
1534
{
1409
1535
        if (node->name)
1834
1960
static void _outListenStmt(String *str, ListenStmt *node)
1835
1961
{
1836
1962
        string_append_char(str, "LISTEN ");
1837
 
        _outNode(str, node->relation);
 
1963
        string_append_char(str, "\"");
 
1964
        string_append_char(str, node->conditionname);
 
1965
        string_append_char(str, "\"");
1838
1966
}
1839
1967
 
1840
1968
static void _outUnlistenStmt(String *str, UnlistenStmt *node)
1841
1969
{
1842
1970
        string_append_char(str, "UNLISTEN ");
1843
 
        _outNode(str, node->relation);
 
1971
        if (node->conditionname == NULL) 
 
1972
                string_append_char(str, "*");
 
1973
        else {
 
1974
                string_append_char(str, "\"");
 
1975
                string_append_char(str, node->conditionname);
 
1976
                string_append_char(str, "\"");
 
1977
        }
1844
1978
}
1845
1979
 
1846
1980
static void _outLoadStmt(String *str, LoadStmt *node)
2852
2986
static void
2853
2987
_outCreateTrigStmt(String *str, CreateTrigStmt *node)
2854
2988
{
2855
 
        int i, len;
 
2989
        bool    has_events = false;
2856
2990
 
2857
2991
        if (node->isconstraint == TRUE)
2858
2992
                string_append_char(str, "CREATE CONSTRAINT TRIGGER \"");
2866
3000
        else
2867
3001
                string_append_char(str, "AFTER ");
2868
3002
 
2869
 
        len = strlen(node->actions);
2870
 
        for (i = 0; i < len; i++)
2871
 
        {
2872
 
                if (i)
2873
 
                        string_append_char(str, "OR ");
2874
 
                
2875
 
                if (node->actions[i] == 'i')
2876
 
                        string_append_char(str, "INSERT ");
2877
 
                else if (node->actions[i] == 'd')
2878
 
                        string_append_char(str, "DELETE ");
2879
 
                else
2880
 
                        string_append_char(str, "UPDATE ");
 
3003
        if (node->events & TRIGGER_TYPE_INSERT)
 
3004
        {
 
3005
                if (has_events)
 
3006
                        string_append_char(str, "OR ");
 
3007
                string_append_char(str, "INSERT ");
 
3008
                has_events = true;
 
3009
        }
 
3010
        if (node->events & TRIGGER_TYPE_DELETE)
 
3011
        {
 
3012
                if (has_events)
 
3013
                        string_append_char(str, "OR ");
 
3014
                string_append_char(str, "DELETE ");
 
3015
                has_events = true;
 
3016
        }
 
3017
        if (node->events & TRIGGER_TYPE_UPDATE)
 
3018
        {
 
3019
                if (has_events)
 
3020
                        string_append_char(str, "OR ");
 
3021
                string_append_char(str, "UPDATE ");
 
3022
                has_events = true;
 
3023
        }
 
3024
        if (node->events & TRIGGER_TYPE_TRUNCATE)
 
3025
        {
 
3026
                if (has_events)
 
3027
                        string_append_char(str, "OR ");
 
3028
                string_append_char(str, "TRUNCATE ");
 
3029
                has_events = true;
2881
3030
        }
2882
3031
 
2883
3032
        string_append_char(str, "ON ");
3076
3225
                                _outNode(str, node->args);
3077
3226
                                string_append_char(str, ")");
3078
3227
                        }
 
3228
                        /* XXX
3079
3229
                        if (node->recheck == TRUE)
3080
3230
                                string_append_char(str, " RECHECK");
 
3231
                        */
3081
3232
                        break;
3082
3233
 
3083
3234
                case OPCLASS_ITEM_FUNCTION:
3311
3462
}
3312
3463
 
3313
3464
static void
3314
 
_outPrivTarget(String *str, PrivTarget *node)
3315
 
{
 
3465
_outPrivGrantee(String *str, PrivGrantee *node)
 
3466
{
 
3467
        if (node->rolname == NULL)
 
3468
                string_append_char(str, "PUBLIC");
 
3469
        else
 
3470
        {
 
3471
                string_append_char(str, "\"");
 
3472
                string_append_char(str, node->rolname);
 
3473
                string_append_char(str, "\"");
 
3474
        }
 
3475
}
 
3476
 
 
3477
static void
 
3478
_outGrantStmt(String *str, GrantStmt *node)
 
3479
{
 
3480
        if (node->is_grant == true)
 
3481
                string_append_char(str, "GRANT ");
 
3482
        else
 
3483
        {
 
3484
                string_append_char(str, "REVOKE ");
 
3485
                if (node->grant_option == true)
 
3486
                        string_append_char(str, "GRANT OPTION FOR ");
 
3487
        }
 
3488
        
 
3489
        _outPrivilegeList(str, node->privileges);
 
3490
 
 
3491
        string_append_char(str, " ON ");
 
3492
 
3316
3493
        switch (node->objtype)
3317
3494
        {
3318
3495
                case ACL_OBJECT_RELATION:
3319
 
                        _outNode(str, node->objs);
 
3496
                        _outNode(str, node->objects);
3320
3497
                        break;
3321
3498
 
3322
3499
                case ACL_OBJECT_SEQUENCE:
3323
3500
                        string_append_char(str, "SEQUENCE ");
3324
 
                        _outNode(str, node->objs);
 
3501
                        _outNode(str, node->objects);
3325
3502
                        break;
3326
3503
 
3327
3504
                case ACL_OBJECT_FUNCTION:
3328
3505
                        string_append_char(str, "FUNCTION ");
3329
 
                        _outNode(str, node->objs);
 
3506
                        _outNode(str, node->objects);
3330
3507
                        break;
3331
3508
 
3332
3509
                case ACL_OBJECT_DATABASE:
3333
3510
                        string_append_char(str, "DATABASE ");
3334
 
                        _outIdList(str, node->objs);
 
3511
                        _outIdList(str, node->objects);
3335
3512
                        break;
3336
3513
 
3337
3514
                case ACL_OBJECT_LANGUAGE:
3338
3515
                        string_append_char(str, "LANGUAGE ");
3339
 
                        _outIdList(str, node->objs);
 
3516
                        _outIdList(str, node->objects);
3340
3517
                        break;
3341
3518
 
3342
3519
                case ACL_OBJECT_NAMESPACE:
3343
3520
                        string_append_char(str, "SCHEMA ");
3344
 
                        _outIdList(str, node->objs);
 
3521
                        _outIdList(str, node->objects);
3345
3522
                        break;
3346
3523
 
3347
3524
                case ACL_OBJECT_TABLESPACE:
3348
3525
                        string_append_char(str, "TABLESPACE ");
3349
 
                        _outIdList(str, node->objs);
 
3526
                        _outIdList(str, node->objects);
3350
3527
                        break;
3351
3528
        }
3352
 
}
3353
 
 
3354
 
static void
3355
 
_outPrivGrantee(String *str, PrivGrantee *node)
3356
 
{
3357
 
        if (node->rolname == NULL)
3358
 
                string_append_char(str, "PUBLIC");
3359
 
        else
3360
 
        {
3361
 
                string_append_char(str, "\"");
3362
 
                string_append_char(str, node->rolname);
3363
 
                string_append_char(str, "\"");
3364
 
        }
3365
 
}
3366
 
 
3367
 
static void
3368
 
_outGrantStmt(String *str, GrantStmt *node)
3369
 
{
3370
 
        PrivTarget *n;
3371
 
        
3372
 
        if (node->is_grant == true)
3373
 
                string_append_char(str, "GRANT ");
3374
 
        else
3375
 
        {
3376
 
                string_append_char(str, "REVOKE ");
3377
 
                if (node->grant_option == true)
3378
 
                        string_append_char(str, "GRANT OPTION FOR ");
3379
 
        }
3380
 
        
3381
 
        _outPrivilegeList(str, node->privileges);
3382
 
 
3383
 
        string_append_char(str, " ON ");
3384
 
 
3385
 
        n = makeNode(PrivTarget);
3386
 
        n->objtype = node->objtype;
3387
 
        n->objs = node->objects;
3388
 
        _outNode(str, n);
3389
 
        pfree(n);
3390
3529
 
3391
3530
        if (node->is_grant == true)
3392
3531
                string_append_char(str, " TO ");
3716
3855
                        break;
3717
3856
 
3718
3857
                case OBJECT_CONVERSION:
3719
 
                        string_append_char(str, "CONVERSION ");
3720
 
                        _outFuncName(str, node->object);
3721
 
                        string_append_char(str, " OWNER TO \"");
 
3858
                        string_append_char(str, "CONVERSION \"");
 
3859
                        string_append_char(str, strVal(linitial(node->object)));
 
3860
                        string_append_char(str, "\" OWNER TO \"");
3722
3861
                        string_append_char(str, node->newowner);
3723
3862
                        string_append_char(str, "\"");
3724
3863
                        break;
3725
3864
 
3726
3865
                case OBJECT_DATABASE:
3727
3866
                        string_append_char(str, "DATABASE \"");
3728
 
                        _outIdList(str, node->object);
 
3867
                        string_append_char(str, strVal(linitial(node->object)));
3729
3868
                        string_append_char(str, "\" OWNER TO \"");
3730
3869
                        string_append_char(str, node->newowner);
3731
3870
                        string_append_char(str, "\"");
3732
3871
                        break;
3733
3872
 
3734
3873
                case OBJECT_DOMAIN:
3735
 
                        string_append_char(str, "DOMAIN ");
3736
 
                        _outFuncName(str, node->object);
3737
 
                        string_append_char(str, " OWNER TO \"");
 
3874
                        string_append_char(str, "DOMAIN \"");
 
3875
                        string_append_char(str, strVal(linitial(node->object)));
 
3876
                        string_append_char(str, "\" OWNER TO \"");
3738
3877
                        string_append_char(str, node->newowner);
3739
3878
                        string_append_char(str, "\"");
3740
3879
                        break;
3749
3888
                        string_append_char(str, "\"");
3750
3889
                        break;
3751
3890
 
 
3891
                case OBJECT_LANGUAGE:
 
3892
                        string_append_char(str, "LANGUAGE \"");
 
3893
                        string_append_char(str, strVal(linitial(node->object)));
 
3894
                        string_append_char(str, "\" OWNER TO \"");
 
3895
                        string_append_char(str, node->newowner);
 
3896
                        string_append_char(str, "\"");
 
3897
                        break;
 
3898
 
3752
3899
                case OBJECT_OPERATOR:
3753
3900
                        string_append_char(str, "OPERATOR ");
3754
3901
                        _outOperatorName(str, node->object);
3769
3916
                        string_append_char(str, "\"");
3770
3917
                        break;
3771
3918
 
 
3919
                case OBJECT_OPFAMILY:
 
3920
                        string_append_char(str, "OPERATOR FAMILY ");
 
3921
                        _outFuncName(str, node->object);
 
3922
                        string_append_char(str, " USING ");
 
3923
                        string_append_char(str, node->addname);
 
3924
                        string_append_char(str, " OWNER TO \"");
 
3925
                        string_append_char(str, node->newowner);
 
3926
                        string_append_char(str, "\"");
 
3927
                        break;
 
3928
 
3772
3929
                case OBJECT_SCHEMA:
3773
3930
                        string_append_char(str, "SCHEMA \"");
3774
 
                        string_append_char(str, linitial(node->object));
 
3931
                        string_append_char(str, strVal(linitial(node->object)));
3775
3932
                        string_append_char(str, "\" OWNER TO \"");
3776
3933
                        string_append_char(str, node->newowner);
3777
3934
                        string_append_char(str, "\"");
3778
3935
                        break;
3779
3936
 
3780
3937
                case OBJECT_TYPE:
3781
 
                        string_append_char(str, "TYPE ");
3782
 
                        _outFuncName(str, node->object);
3783
 
                        string_append_char(str, " OWNER TO \"");
 
3938
                        string_append_char(str, "TYPE \"");
 
3939
                        string_append_char(str, strVal(linitial(node->object)));
 
3940
                        string_append_char(str, "\" OWNER TO \"");
3784
3941
                        string_append_char(str, node->newowner);
3785
3942
                        string_append_char(str, "\"");
3786
3943
                        break;
3787
3944
 
3788
3945
                case OBJECT_TABLESPACE:
3789
3946
                        string_append_char(str, "TABLESPACE \"");
3790
 
                        string_append_char(str, linitial(node->object));
 
3947
                        string_append_char(str, strVal(linitial(node->object)));
 
3948
                        string_append_char(str, "\" OWNER TO \"");
 
3949
                        string_append_char(str, node->newowner);
 
3950
                        string_append_char(str, "\"");
 
3951
                        break;
 
3952
 
 
3953
                case OBJECT_TSDICTIONARY:
 
3954
                        string_append_char(str, "TEXT SEARCH DICTIONARY \"");
 
3955
                        string_append_char(str, strVal(linitial(node->object)));
 
3956
                        string_append_char(str, "\" OWNER TO \"");
 
3957
                        string_append_char(str, node->newowner);
 
3958
                        string_append_char(str, "\"");
 
3959
                        break;
 
3960
 
 
3961
                case OBJECT_TSCONFIGURATION:
 
3962
                        string_append_char(str, "TEXT SEARCH CONFIGURATION \"");
 
3963
                        string_append_char(str, strVal(linitial(node->object)));
 
3964
                        string_append_char(str, "\" OWNER TO \"");
 
3965
                        string_append_char(str, node->newowner);
 
3966
                        string_append_char(str, "\"");
 
3967
                        break;
 
3968
 
 
3969
                case OBJECT_FDW:
 
3970
                        string_append_char(str, "FOREIGN DATA WRAPPER \"");
 
3971
                        string_append_char(str, strVal(linitial(node->object)));
 
3972
                        string_append_char(str, "\" OWNER TO \"");
 
3973
                        string_append_char(str, node->newowner);
 
3974
                        string_append_char(str, "\"");
 
3975
                        break;
 
3976
 
 
3977
                case OBJECT_FOREIGN_SERVER:
 
3978
                        string_append_char(str, "SERVER \"");
 
3979
                        string_append_char(str, strVal(linitial(node->object)));
3791
3980
                        string_append_char(str, "\" OWNER TO \"");
3792
3981
                        string_append_char(str, node->newowner);
3793
3982
                        string_append_char(str, "\"");
4530
4719
 
4531
4720
                        _outNode(str, linitial(node->args));
4532
4721
                        n = lsecond(node->args);
4533
 
                        if (n->val.val.str[0] == 't')
4534
 
                                string_append_char(str, " PRESERVE WHITESPACE");
 
4722
                        {
 
4723
                                Node *arg = ((TypeCast *) n)->arg;
 
4724
 
 
4725
                                if (((A_Const *) arg)->val.val.str[0] == 't')
 
4726
                                        string_append_char(str, " PRESERVE WHITESPACE");
 
4727
                        }
4535
4728
 
4536
4729
                        string_append_char(str, ")");
4537
4730
                        break;
4665
4858
                        case T_RangeVar:
4666
4859
                                _outRangeVar(str, obj);
4667
4860
                                break;
 
4861
                                /*
 
4862
                        case T_IntoClause:
 
4863
                                _outIntoClause(str, obj);
 
4864
                                break;
 
4865
                                */
4668
4866
                        case T_Var:
4669
4867
                                _outVar(str, obj);
4670
4868
                                break;
4677
4875
                        case T_Aggref:
4678
4876
                                _outAggref(str, obj);
4679
4877
                                break;
 
4878
                                /*
 
4879
                        case T_WindowFunc:
 
4880
                                _outWindowFunc(str, obj);
 
4881
                                break;
 
4882
                                */
4680
4883
                        case T_ArrayRef:
4681
4884
                                _outArrayRef(str, obj);
4682
4885
                                break;
4701
4904
                        case T_SubPlan:
4702
4905
                                _outSubPlan(str, obj);
4703
4906
                                break;
 
4907
                                /*
 
4908
                        case T_AlternativeSubPlan:
 
4909
                                _outAlternativeSubPlan(str, obj);
 
4910
                                break;
 
4911
                                */
4704
4912
                        case T_FieldSelect:
4705
4913
                                _outFieldSelect(str, obj);
4706
4914
                                break;
4710
4918
                        case T_RelabelType:
4711
4919
                                _outRelabelType(str, obj);
4712
4920
                                break;
 
4921
                                /*
 
4922
                        case T_CoerceViaIO:
 
4923
                                _outCoerceViaIO(str, obj);
 
4924
                                break;
 
4925
                        case T_ArrayCoerceExpr:
 
4926
                                _outArrayCoerceExpr(str, obj);
 
4927
                                break;
 
4928
                                */
4713
4929
                        case T_ConvertRowtypeExpr:
4714
4930
                                _outConvertRowtypeExpr(str, obj);
4715
4931
                                break;
4728
4944
                        case T_RowExpr:
4729
4945
                                _outRowExpr(str, obj);
4730
4946
                                break;
 
4947
                                /*
 
4948
                        case T_RowCompareExpr:
 
4949
                                _outRowCompareExpr(str, obj);
 
4950
                                break;
 
4951
                                */
4731
4952
                        case T_CoalesceExpr:
4732
4953
                                _outCoalesceExpr(str, obj);
4733
4954
                                break;
4792
5013
                        case T_IndexElem:
4793
5014
                                _outIndexElem(str, obj);
4794
5015
                                break;
4795
 
                        case T_SortClause:
4796
 
                                _outSortClause(str, obj);
4797
 
                                break;
4798
 
                        case T_GroupClause:
4799
 
                                _outGroupClause(str, obj);
 
5016
                                /*
 
5017
                        case T_RowMarkClause:
 
5018
                                _outRowMarkClause(str, obj);
 
5019
                                break;
 
5020
                                */
 
5021
                        case T_WithClause:
 
5022
                                _outWithClause(str, obj);
 
5023
                                break;
 
5024
                        case T_CommonTableExpr:
 
5025
                                _outCommonTableExpr(str, obj);
4800
5026
                                break;
4801
5027
                        case T_SetOperationStmt:
4802
5028
                                _outSetOperationStmt(str, obj);
4816
5042
                        case T_A_Const:
4817
5043
                                _outAConst(str, obj);
4818
5044
                                break;
 
5045
                                /*
 
5046
                        case T_A_Star:
 
5047
                                _outA_Star(str, obj);
 
5048
                                break;
 
5049
                                */
4819
5050
                        case T_A_Indices:
4820
5051
                                _outA_Indices(str, obj);
4821
5052
                                break;
4822
5053
                        case T_A_Indirection:
4823
5054
                                _outA_Indirection(str, obj);
4824
5055
                                break;
 
5056
                                /*
 
5057
                        case T_A_ArrayExpr:
 
5058
                                _outA_ArrayExpr(str, obj);
 
5059
                                break;
 
5060
                                */
4825
5061
                        case T_ResTarget:
4826
5062
                                _outResTarget(str, obj);
4827
5063
                                break;
 
5064
                        case T_WindowDef:
 
5065
                                _outWindowDef(str, obj);
 
5066
                                break;
4828
5067
                        case T_Constraint:
4829
5068
                                _outConstraint(str, obj);
4830
5069
                                break;
5009
5248
                                _outGrantStmt(str, obj);
5010
5249
                                break;
5011
5250
 
5012
 
                        case T_PrivTarget:
5013
 
                                _outPrivTarget(str, obj);
5014
 
                                break;
5015
 
 
5016
5251
                        case T_FuncWithArgs:
5017
5252
                                _outFuncWithArgs(str, obj);
5018
5253
                                break;
5172
5407
 
5173
5408
                        case T_CurrentOfExpr:
5174
5409
                                _outCurrentOfExpr(str, obj);
 
5410
                                break;
5175
5411
 
5176
5412
                        default:
5177
5413
                                break;