On 2012-12-20 21:17:04 +0100, Andres Freund wrote:
> On 2012-12-20 12:40:44 +0000, no...@nix.hu wrote:
> > The following bug has been logged on the website:
> >
> > Bug reference: 7763
> > Logged by: Norbert Buchmuller
> > Email address: no...@nix.hu
> > PostgreSQL version: 9.2.2
> > Operating system: Linux 2.6.32, i386, Debian GNU/Linux 6.0.5
> > Description:
> >
> > There's a table that has a B-Tree index on a composite type expression. When
> > attempting to create another table just like the first table and with the
> > indexes also "copied" using the "CREATE TABLE ... (LIKE ... INCLUDING
> > INDEXES ...)" statement, it throws an error (see below) and the table is not
> > created.
> >
> > I believe it's a bug, from the documentation i assumed that it should create
> > the table with a similar index, no matter that the index is on a composite
> > type expression.
> >
> > postgres@vger:~$ cat
> > create_table_like_including_indexes-and-index_on_composite_type.sql
> > \set VERBOSITY verbose
> > \set ECHO all
> > SELECT version();
> > CREATE TYPE type1 AS (x int, y int);
> > CREATE TABLE table1 (a int, b int);
> > CREATE INDEX index1 ON table1 ( ( (a, b)::type1 ) );
> > CREATE TABLE table2 ( LIKE table1 INCLUDING INDEXES );
> > \d table2
> > postgres@vger:~$ dropdb test1; createdb test1 && psql --no-align --tuples -d
> > test1 -f create_table_like_including_indexes-and-index_on_composite_type.sql
> >
> > SELECT version();
> > PostgreSQL 9.2.2 on i686-pc-linux-gnu, compiled by gcc-4.4.real (Debian
> > 4.4.5-8) 4.4.5, 32-bit
> > CREATE TYPE type1 AS (x int, y int);
> > CREATE TYPE
> > CREATE TABLE table1 (a int, b int);
> > CREATE TABLE
> > CREATE INDEX index1 ON table1 ( ( (a, b)::type1 ) );
> > CREATE INDEX
> > CREATE TABLE table2 ( LIKE table1 INCLUDING INDEXES );
> > psql:create_table_like_including_indexes-and-index_on_composite_type.sql:7:
> > ERROR: 42P16: column "" has pseudo-type record
> > LOCATION: CheckAttributeType, heap.c:496
> > \d table2
> > Did not find any relation named "table2".
>
> Concretely that seems to be transformRowExpr's fault. It overwrites
> row_typeid even though its marked as COERCE_EXPLICIT_CAST.
>
> Now the original problem seems to be that we are transforming an already
> transformed expression. generateClonedIndexStmt gets the expression from
> the old index via nodeToString, remaps some attnos, but thats about
> it.
> ISTM IndexElem grow a cooked_expr member.
+should
Ok, here are two patches:
* Add a cooked_expr member to IndexElem and use it for transformed
expressions, including filling it directly in generateClonedIndexStmt.
* Follow the pattern set by other routines in parse_expr.c and don't
transformRowExpr the same expression twice.
While the first one fixes the above bug - and I think its the right
approach not to analyze the expression twice, the second one seems like
a good idea anyway because as transformExpr says:
* 1. At least one construct (BETWEEN/AND) puts the same nodes
* into two branches of the parse tree; hence, some nodes
* are transformed twice.
* 2. Another way it can happen is that coercion of an operator or
* function argument to the required type (via coerce_type())
* can apply transformExpr to an already-transformed subexpression.
* An example here is "SELECT count(*) + 1.0 FROM table".
There unfortunately is not sufficient padding in IndexElem to do that
without changing its size. Not sure whether we consider that to be a big
problem for the back branches, its nothing user code should do, but ...
Greetings,
Andres Freund
--
Andres Freund http://www.2ndQuadrant.com/
PostgreSQL Development, 24x7 Support, Training & Services
>From 8aa997a790d7ef8bbcf9c9f3ec186f08fa4324ea Mon Sep 17 00:00:00 2001
From: Andres Freund <and...@anarazel.de>
Date: Thu, 20 Dec 2012 21:59:33 +0100
Subject: [PATCH 1/2] Treat transformed index expression differently from raw
ones during index creation
When doing a CREATE TABLE ... (LIKE ... INCLUDING INDEXES) index expression
would get transformed twice as the old indexes pg_index.indexpr is used to
create build a new IndexStmt which would then get transformed again.
For that introduce a separate cooked_expr memer in IndexElem.
This fixes problems #7763 reported by Norbert Buchmuller where required casts
are lost due to transforming twice.
---
src/backend/bootstrap/bootparse.y | 1 +
src/backend/commands/indexcmds.c | 3 +-
src/backend/nodes/copyfuncs.c | 1 +
src/backend/nodes/equalfuncs.c | 1 +
src/backend/nodes/outfuncs.c | 1 +
src/backend/parser/gram.y | 3 ++
src/backend/parser/parse_utilcmd.c | 15 ++++---
src/backend/utils/cache/catcache.c | 87 +++++++++++++++++++++-----------------
src/include/access/valid.h | 54 +++++++++++++++++++++++
src/include/nodes/parsenodes.h | 8 +++-
10 files changed, 127 insertions(+), 47 deletions(-)
diff --git a/src/backend/bootstrap/bootparse.y b/src/backend/bootstrap/bootparse.y
index ec7786a..0f94763 100644
--- a/src/backend/bootstrap/bootparse.y
+++ b/src/backend/bootstrap/bootparse.y
@@ -378,6 +378,7 @@ boot_index_param:
IndexElem *n = makeNode(IndexElem);
n->name = $1;
n->expr = NULL;
+ n->cooked_expr = NULL;
n->indexcolname = NULL;
n->collation = NIL;
n->opclass = list_make1(makeString($2));
diff --git a/src/backend/commands/indexcmds.c b/src/backend/commands/indexcmds.c
index 75f9ff1..7311222 100644
--- a/src/backend/commands/indexcmds.c
+++ b/src/backend/commands/indexcmds.c
@@ -1007,8 +1007,9 @@ ComputeIndexAttrs(IndexInfo *indexInfo,
else
{
/* Index expression */
- Node *expr = attribute->expr;
+ Node *expr = attribute->cooked_expr;
+ Assert(attribute->expr == NULL);
Assert(expr != NULL);
atttype = exprType(expr);
attcollation = exprCollation(expr);
diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
index 9387ee9..8b33e9a 100644
--- a/src/backend/nodes/copyfuncs.c
+++ b/src/backend/nodes/copyfuncs.c
@@ -2316,6 +2316,7 @@ _copyIndexElem(const IndexElem *from)
COPY_STRING_FIELD(name);
COPY_NODE_FIELD(expr);
+ COPY_NODE_FIELD(cooked_expr);
COPY_STRING_FIELD(indexcolname);
COPY_NODE_FIELD(collation);
COPY_NODE_FIELD(opclass);
diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c
index 95a95f4..0b26f0d 100644
--- a/src/backend/nodes/equalfuncs.c
+++ b/src/backend/nodes/equalfuncs.c
@@ -2134,6 +2134,7 @@ _equalIndexElem(const IndexElem *a, const IndexElem *b)
{
COMPARE_STRING_FIELD(name);
COMPARE_NODE_FIELD(expr);
+ COMPARE_NODE_FIELD(cooked_expr);
COMPARE_STRING_FIELD(indexcolname);
COMPARE_NODE_FIELD(collation);
COMPARE_NODE_FIELD(opclass);
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
index 35c6287..cf53cdd 100644
--- a/src/backend/nodes/outfuncs.c
+++ b/src/backend/nodes/outfuncs.c
@@ -2184,6 +2184,7 @@ _outIndexElem(StringInfo str, const IndexElem *node)
WRITE_STRING_FIELD(name);
WRITE_NODE_FIELD(expr);
+ WRITE_NODE_FIELD(cooked_expr);
WRITE_STRING_FIELD(indexcolname);
WRITE_NODE_FIELD(collation);
WRITE_NODE_FIELD(opclass);
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
index ad98b36..b991d80 100644
--- a/src/backend/parser/gram.y
+++ b/src/backend/parser/gram.y
@@ -6044,6 +6044,7 @@ index_elem: ColId opt_collate opt_class opt_asc_desc opt_nulls_order
$$ = makeNode(IndexElem);
$$->name = $1;
$$->expr = NULL;
+ $$->cooked_expr = NULL;
$$->indexcolname = NULL;
$$->collation = $2;
$$->opclass = $3;
@@ -6055,6 +6056,7 @@ index_elem: ColId opt_collate opt_class opt_asc_desc opt_nulls_order
$$ = makeNode(IndexElem);
$$->name = NULL;
$$->expr = $1;
+ $$->cooked_expr = NULL;
$$->indexcolname = NULL;
$$->collation = $2;
$$->opclass = $3;
@@ -6066,6 +6068,7 @@ index_elem: ColId opt_collate opt_class opt_asc_desc opt_nulls_order
$$ = makeNode(IndexElem);
$$->name = NULL;
$$->expr = $2;
+ $$->cooked_expr = NULL;
$$->indexcolname = NULL;
$$->collation = $4;
$$->opclass = $5;
diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c
index 086cc75..edb353e 100644
--- a/src/backend/parser/parse_utilcmd.c
+++ b/src/backend/parser/parse_utilcmd.c
@@ -1124,6 +1124,7 @@ generateClonedIndexStmt(CreateStmtContext *cxt, Relation source_idx,
int16 opt = source_idx->rd_indoption[keyno];
iparam = makeNode(IndexElem);
+ iparam->expr = NULL;
if (AttributeNumberIsValid(attnum))
{
@@ -1134,7 +1135,7 @@ generateClonedIndexStmt(CreateStmtContext *cxt, Relation source_idx,
keycoltype = get_atttype(indrelid, attnum);
iparam->name = attname;
- iparam->expr = NULL;
+ iparam->cooked_expr = NULL;
}
else
{
@@ -1162,7 +1163,7 @@ generateClonedIndexStmt(CreateStmtContext *cxt, Relation source_idx,
RelationGetRelationName(source_idx))));
iparam->name = NULL;
- iparam->expr = indexkey;
+ iparam->cooked_expr = indexkey;
keycoltype = exprType(indexkey);
}
@@ -1787,6 +1788,7 @@ transformIndexConstraint(Constraint *constraint, CreateStmtContext *cxt)
iparam = makeNode(IndexElem);
iparam->name = pstrdup(key);
iparam->expr = NULL;
+ iparam->cooked_expr = NULL;
iparam->indexcolname = NULL;
iparam->collation = NIL;
iparam->opclass = NIL;
@@ -1930,11 +1932,12 @@ transformIndexStmt(IndexStmt *stmt, const char *queryString)
ielem->indexcolname = FigureIndexColname(ielem->expr);
/* Now do parse transformation of the expression */
- ielem->expr = transformExpr(pstate, ielem->expr,
- EXPR_KIND_INDEX_EXPRESSION);
+ ielem->cooked_expr = transformExpr(pstate, ielem->expr,
+ EXPR_KIND_INDEX_EXPRESSION);
+ ielem->expr = NULL;
/* We have to fix its collations too */
- assign_expr_collations(pstate, ielem->expr);
+ assign_expr_collations(pstate, ielem->cooked_expr);
/*
* transformExpr() should have already rejected subqueries,
@@ -1945,7 +1948,7 @@ transformIndexStmt(IndexStmt *stmt, const char *queryString)
* with what transformWhereClause() checks for the predicate.
* DefineIndex() will make more checks.
*/
- if (expression_returns_set(ielem->expr))
+ if (expression_returns_set(ielem->cooked_expr))
ereport(ERROR,
(errcode(ERRCODE_DATATYPE_MISMATCH),
errmsg("index expression cannot return a set")));
diff --git a/src/backend/utils/cache/catcache.c b/src/backend/utils/cache/catcache.c
index 9ae1432..bee6f3d 100644
--- a/src/backend/utils/cache/catcache.c
+++ b/src/backend/utils/cache/catcache.c
@@ -73,7 +73,7 @@ static CatCacheHeader *CacheHdr = NULL;
static uint32 CatalogCacheComputeHashValue(CatCache *cache, int nkeys,
- ScanKey cur_skey);
+ ScanKey cur_skey, Datum *argument);
static uint32 CatalogCacheComputeTupleHashValue(CatCache *cache,
HeapTuple tuple);
@@ -173,7 +173,7 @@ GetCCHashEqFuncs(Oid keytype, PGFunction *hashfunc, RegProcedure *eqfunc)
* Compute the hash value associated with a given set of lookup keys
*/
static uint32
-CatalogCacheComputeHashValue(CatCache *cache, int nkeys, ScanKey cur_skey)
+CatalogCacheComputeHashValue(CatCache *cache, int nkeys, ScanKey cur_skey, Datum *argument)
{
uint32 hashValue = 0;
uint32 oneHash;
@@ -188,28 +188,28 @@ CatalogCacheComputeHashValue(CatCache *cache, int nkeys, ScanKey cur_skey)
case 4:
oneHash =
DatumGetUInt32(DirectFunctionCall1(cache->cc_hashfunc[3],
- cur_skey[3].sk_argument));
+ argument[3]));
hashValue ^= oneHash << 24;
hashValue ^= oneHash >> 8;
/* FALLTHROUGH */
case 3:
oneHash =
DatumGetUInt32(DirectFunctionCall1(cache->cc_hashfunc[2],
- cur_skey[2].sk_argument));
+ argument[2]));
hashValue ^= oneHash << 16;
hashValue ^= oneHash >> 16;
/* FALLTHROUGH */
case 2:
oneHash =
DatumGetUInt32(DirectFunctionCall1(cache->cc_hashfunc[1],
- cur_skey[1].sk_argument));
+ argument[1]));
hashValue ^= oneHash << 8;
hashValue ^= oneHash >> 24;
/* FALLTHROUGH */
case 1:
oneHash =
DatumGetUInt32(DirectFunctionCall1(cache->cc_hashfunc[0],
- cur_skey[0].sk_argument));
+ argument[0]));
hashValue ^= oneHash;
break;
default:
@@ -228,17 +228,14 @@ CatalogCacheComputeHashValue(CatCache *cache, int nkeys, ScanKey cur_skey)
static uint32
CatalogCacheComputeTupleHashValue(CatCache *cache, HeapTuple tuple)
{
- ScanKeyData cur_skey[CATCACHE_MAXKEYS];
+ Datum arguments[CATCACHE_MAXKEYS];
bool isNull = false;
- /* Copy pre-initialized overhead data for scankey */
- memcpy(cur_skey, cache->cc_skey, sizeof(cur_skey));
-
/* Now extract key fields from tuple, insert into scankey */
switch (cache->cc_nkeys)
{
case 4:
- cur_skey[3].sk_argument =
+ arguments[3] =
(cache->cc_key[3] == ObjectIdAttributeNumber)
? ObjectIdGetDatum(HeapTupleGetOid(tuple))
: fastgetattr(tuple,
@@ -248,7 +245,7 @@ CatalogCacheComputeTupleHashValue(CatCache *cache, HeapTuple tuple)
Assert(!isNull);
/* FALLTHROUGH */
case 3:
- cur_skey[2].sk_argument =
+ arguments[2] =
(cache->cc_key[2] == ObjectIdAttributeNumber)
? ObjectIdGetDatum(HeapTupleGetOid(tuple))
: fastgetattr(tuple,
@@ -258,7 +255,7 @@ CatalogCacheComputeTupleHashValue(CatCache *cache, HeapTuple tuple)
Assert(!isNull);
/* FALLTHROUGH */
case 2:
- cur_skey[1].sk_argument =
+ arguments[1] =
(cache->cc_key[1] == ObjectIdAttributeNumber)
? ObjectIdGetDatum(HeapTupleGetOid(tuple))
: fastgetattr(tuple,
@@ -268,7 +265,7 @@ CatalogCacheComputeTupleHashValue(CatCache *cache, HeapTuple tuple)
Assert(!isNull);
/* FALLTHROUGH */
case 1:
- cur_skey[0].sk_argument =
+ arguments[0] =
(cache->cc_key[0] == ObjectIdAttributeNumber)
? ObjectIdGetDatum(HeapTupleGetOid(tuple))
: fastgetattr(tuple,
@@ -282,7 +279,7 @@ CatalogCacheComputeTupleHashValue(CatCache *cache, HeapTuple tuple)
break;
}
- return CatalogCacheComputeHashValue(cache, cache->cc_nkeys, cur_skey);
+ return CatalogCacheComputeHashValue(cache, cache->cc_nkeys, cache->cc_skey, arguments);
}
@@ -1058,6 +1055,7 @@ SearchCatCache(CatCache *cache,
Datum v4)
{
ScanKeyData cur_skey[CATCACHE_MAXKEYS];
+ Datum arguments[CATCACHE_MAXKEYS];
uint32 hashValue;
Index hashIndex;
dlist_iter iter;
@@ -1080,16 +1078,15 @@ SearchCatCache(CatCache *cache,
/*
* initialize the search key information
*/
- memcpy(cur_skey, cache->cc_skey, sizeof(cur_skey));
- cur_skey[0].sk_argument = v1;
- cur_skey[1].sk_argument = v2;
- cur_skey[2].sk_argument = v3;
- cur_skey[3].sk_argument = v4;
+ arguments[0] = v1;
+ arguments[1] = v2;
+ arguments[2] = v3;
+ arguments[3] = v4;
/*
* find the hash bucket in which to look for the tuple
*/
- hashValue = CatalogCacheComputeHashValue(cache, cache->cc_nkeys, cur_skey);
+ hashValue = CatalogCacheComputeHashValue(cache, cache->cc_nkeys, cache->cc_skey, arguments);
hashIndex = HASH_INDEX(hashValue, cache->cc_nbuckets);
/*
@@ -1114,10 +1111,11 @@ SearchCatCache(CatCache *cache,
/*
* see if the cached tuple matches our key.
*/
- HeapKeyTest(&ct->tuple,
+ HeapKeyTestArg(&ct->tuple,
cache->cc_tupdesc,
cache->cc_nkeys,
- cur_skey,
+ cache->cc_skey,
+ arguments,
res);
if (!res)
continue;
@@ -1162,6 +1160,12 @@ SearchCatCache(CatCache *cache,
}
}
+ memcpy(cur_skey, cache->cc_skey, sizeof(cur_skey));
+ cur_skey[0].sk_argument = v1;
+ cur_skey[1].sk_argument = v2;
+ cur_skey[2].sk_argument = v3;
+ cur_skey[3].sk_argument = v4;
+
/*
* Tuple was not found in cache, so we have to try to retrieve it directly
* from the relation. If found, we will add it to the cache; if not
@@ -1300,7 +1304,7 @@ GetCatCacheHashValue(CatCache *cache,
Datum v3,
Datum v4)
{
- ScanKeyData cur_skey[CATCACHE_MAXKEYS];
+ Datum arguments[CATCACHE_MAXKEYS];
/*
* one-time startup overhead for each cache
@@ -1311,16 +1315,15 @@ GetCatCacheHashValue(CatCache *cache,
/*
* initialize the search key information
*/
- memcpy(cur_skey, cache->cc_skey, sizeof(cur_skey));
- cur_skey[0].sk_argument = v1;
- cur_skey[1].sk_argument = v2;
- cur_skey[2].sk_argument = v3;
- cur_skey[3].sk_argument = v4;
+ arguments[0] = v1;
+ arguments[1] = v2;
+ arguments[2] = v3;
+ arguments[3] = v4;
/*
* calculate the hash value
*/
- return CatalogCacheComputeHashValue(cache, cache->cc_nkeys, cur_skey);
+ return CatalogCacheComputeHashValue(cache, cache->cc_nkeys, cache->cc_skey, arguments);
}
@@ -1342,6 +1345,7 @@ SearchCatCacheList(CatCache *cache,
Datum v4)
{
ScanKeyData cur_skey[CATCACHE_MAXKEYS];
+ Datum arguments[CATCACHE_MAXKEYS];
uint32 lHashValue;
dlist_iter iter;
CatCList *cl;
@@ -1369,18 +1373,18 @@ SearchCatCacheList(CatCache *cache,
/*
* initialize the search key information
*/
- memcpy(cur_skey, cache->cc_skey, sizeof(cur_skey));
- cur_skey[0].sk_argument = v1;
- cur_skey[1].sk_argument = v2;
- cur_skey[2].sk_argument = v3;
- cur_skey[3].sk_argument = v4;
+
+ arguments[0] = v1;
+ arguments[1] = v2;
+ arguments[2] = v3;
+ arguments[3] = v4;
/*
* compute a hash value of the given keys for faster search. We don't
* presently divide the CatCList items into buckets, but this still lets
* us skip non-matching items quickly most of the time.
*/
- lHashValue = CatalogCacheComputeHashValue(cache, nkeys, cur_skey);
+ lHashValue = CatalogCacheComputeHashValue(cache, nkeys, cache->cc_skey, arguments);
/*
* scan the items until we find a match or exhaust our list
@@ -1405,10 +1409,11 @@ SearchCatCacheList(CatCache *cache,
*/
if (cl->nkeys != nkeys)
continue;
- HeapKeyTest(&cl->tuple,
+ HeapKeyTestArg(&cl->tuple,
cache->cc_tupdesc,
nkeys,
- cur_skey,
+ cache->cc_skey,
+ arguments,
res);
if (!res)
continue;
@@ -1451,6 +1456,12 @@ SearchCatCacheList(CatCache *cache,
ctlist = NIL;
+ memcpy(cur_skey, cache->cc_skey, sizeof(cur_skey));
+ cur_skey[0].sk_argument = v1;
+ cur_skey[1].sk_argument = v2;
+ cur_skey[2].sk_argument = v3;
+ cur_skey[3].sk_argument = v4;
+
PG_TRY();
{
Relation relation;
diff --git a/src/include/access/valid.h b/src/include/access/valid.h
index ce970e4..283623d 100644
--- a/src/include/access/valid.h
+++ b/src/include/access/valid.h
@@ -66,4 +66,58 @@ do \
} \
} while (0)
+/*
+ * HeapKeyTest
+ *
+ * Test a heap tuple to see if it satisfies a scan key.
+ */
+#define HeapKeyTestArg(tuple, \
+ tupdesc, \
+ nkeys, \
+ keys, \
+ arguments, \
+ result) \
+do \
+{ \
+ /* Use underscores to protect the variables passed in as parameters */ \
+ int __cur_nkeys = (nkeys); \
+ ScanKey __cur_keys = (keys); \
+ Datum *__cur_args = (arguments); \
+ \
+ (result) = true; /* may change */ \
+ for (; __cur_nkeys--; __cur_keys++, __cur_args++) \
+ { \
+ Datum __atp; \
+ bool __isnull; \
+ Datum __test; \
+ \
+ if (__cur_keys->sk_flags & SK_ISNULL) \
+ { \
+ (result) = false; \
+ break; \
+ } \
+ \
+ __atp = heap_getattr((tuple), \
+ __cur_keys->sk_attno, \
+ (tupdesc), \
+ &__isnull); \
+ \
+ if (__isnull) \
+ { \
+ (result) = false; \
+ break; \
+ } \
+ \
+ __test = FunctionCall2Coll(&__cur_keys->sk_func, \
+ __cur_keys->sk_collation, \
+ __atp, *__cur_args); \
+ \
+ if (!DatumGetBool(__test)) \
+ { \
+ (result) = false; \
+ break; \
+ } \
+ } \
+} while (0)
+
#endif /* VALID_H */
diff --git a/src/include/nodes/parsenodes.h b/src/include/nodes/parsenodes.h
index 8834499..8dddb09 100644
--- a/src/include/nodes/parsenodes.h
+++ b/src/include/nodes/parsenodes.h
@@ -530,13 +530,17 @@ typedef enum TableLikeOption
*
* For a plain index attribute, 'name' is the name of the table column to
* index, and 'expr' is NULL. For an index expression, 'name' is NULL and
- * 'expr' is the expression tree.
+ * 'expr' is the expression tree. During transformation the transformed
+ * expression is stored in 'cooked_expr'. It is also used when an IndexElem is
+ * built to clone an existing index. Only one of expr and cooked_expr should be
+ * valid.
*/
typedef struct IndexElem
{
NodeTag type;
char *name; /* name of attribute to index, or NULL */
- Node *expr; /* expression to index, or NULL */
+ Node *expr; /* untransformed index expression, or NULL */
+ Node *cooked_expr; /* transformed index expression, or NULL */
char *indexcolname; /* name for index column; NULL = default */
List *collation; /* name of collation; NIL = default */
List *opclass; /* name of desired opclass; NIL = default */
--
1.7.12.289.g0ce9864.dirty
>From c6e5cf906e14136c478dc579131aceed364a234e Mon Sep 17 00:00:00 2001
From: Andres Freund <and...@anarazel.de>
Date: Thu, 20 Dec 2012 22:41:32 +0100
Subject: [PATCH 2/2] Don't loose information when transforming a RowExpr
twice
---
src/backend/parser/parse_expr.c | 8 +++++++-
1 file changed, 7 insertions(+), 1 deletion(-)
diff --git a/src/backend/parser/parse_expr.c b/src/backend/parser/parse_expr.c
index e9267c5..fdcd1a1 100644
--- a/src/backend/parser/parse_expr.c
+++ b/src/backend/parser/parse_expr.c
@@ -1775,11 +1775,17 @@ transformArrayExpr(ParseState *pstate, A_ArrayExpr *a,
static Node *
transformRowExpr(ParseState *pstate, RowExpr *r)
{
- RowExpr *newr = makeNode(RowExpr);
+ RowExpr *newr;
char fname[16];
int fnum;
ListCell *lc;
+ /* If we already transformed this node, do nothing */
+ if (OidIsValid(r->row_typeid))
+ return (Node*) r;
+
+ newr = makeNode(RowExpr);
+
/* Transform the field expressions */
newr->args = transformExpressionList(pstate, r->args, pstate->p_expr_kind);
--
1.7.12.289.g0ce9864.dirty
--
Sent via pgsql-bugs mailing list (pgsql-bugs@postgresql.org)
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgsql-bugs
