database/postgres
1
0
Fork 0
mirror of https://github.com/postgres/postgres.git synced 2025-07-11 10:01:57 +03:00
Code Activity

Remove Value node struct

Browse Source 
The Value node struct is a weird construct.  It is its own node type,
but most of the time, it actually has a node type of Integer, Float,
String, or BitString.  As a consequence, the struct name and the node
type don't match most of the time, and so it has to be treated
specially a lot.  There doesn't seem to be any value in the special
construct.  There is very little code that wants to accept all Value
variants but nothing else (and even if it did, this doesn't provide
any convenient way to check it), and most code wants either just one
particular node type (usually String), or it accepts a broader set of
node types besides just Value.

This change removes the Value struct and node type and replaces them
by separate Integer, Float, String, and BitString node types that are
proper node types and structs of their own and behave mostly like
normal node types.

Also, this removes the T_Null node tag, which was previously also a
possible variant of Value but wasn't actually used outside of the
Value contained in A_Const.  Replace that by an isnull field in
A_Const.

Reviewed-by: Dagfinn Ilmari Mannsåker <ilmari@ilmari.org>
Reviewed-by: Kyotaro Horiguchi <horikyota.ntt@gmail.com>
Discussion: https://www.postgresql.org/message-id/flat/5ba6bc5b-3f95-04f2-2419-f8ddb4c046fb@enterprisedb.com
This commit is contained in:
Peter Eisentraut
2021-09-09 07:58:12 +02:00
parent cbdf75bf80
commit 639a86e36a
30 changed files with 371 additions and 335 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
src/backend/nodes/copyfuncs.c
View File

@ -2729,25 +2729,30 @@ _copyA_Const(const A_Const *from)
{
A_Const *newnode = makeNode(A_Const);
/* This part must duplicate _copyValue */
COPY_SCALAR_FIELD(val.type);
switch (from->val.type)
COPY_SCALAR_FIELD(isnull);
if (!from->isnull)
{
case T_Integer:
COPY_SCALAR_FIELD(val.val.ival);
break;
case T_Float:
case T_String:
case T_BitString:
COPY_STRING_FIELD(val.val.str);
break;
case T_Null:
/* nothing to do */
break;
default:
elog(ERROR, "unrecognized node type: %d",
(int) from->val.type);
break;
/* This part must duplicate other _copy*() functions. */
COPY_SCALAR_FIELD(val.node.type);
switch (nodeTag(&from->val))
{
case T_Integer:
COPY_SCALAR_FIELD(val.ival.val);
break;
case T_Float:
COPY_STRING_FIELD(val.fval.val);
break;
case T_String:
COPY_STRING_FIELD(val.sval.val);
break;
case T_BitString:
COPY_STRING_FIELD(val.bsval.val);
break;
default:
elog(ERROR, "unrecognized node type: %d",
(int) nodeTag(&from->val));
break;
}
}
COPY_LOCATION_FIELD(location);
@ -4892,32 +4897,43 @@ _copyExtensibleNode(const ExtensibleNode *from)
* value.h copy functions
* ****************************************************************
*/
static Value *
_copyValue(const Value *from)
static Integer *
_copyInteger(const Integer *from)
{
Value *newnode = makeNode(Value);
Integer *newnode = makeNode(Integer);
/* See also _copyAConst when changing this code! */
COPY_SCALAR_FIELD(val);
return newnode;
}
static Float *
_copyFloat(const Float *from)
{
Float *newnode = makeNode(Float);
COPY_STRING_FIELD(val);
return newnode;
}
static String *
_copyString(const String *from)
{
String *newnode = makeNode(String);
COPY_STRING_FIELD(val);
return newnode;
}
static BitString *
_copyBitString(const BitString *from)
{
BitString *newnode = makeNode(BitString);
COPY_STRING_FIELD(val);
COPY_SCALAR_FIELD(type);
switch (from->type)
{
case T_Integer:
COPY_SCALAR_FIELD(val.ival);
break;
case T_Float:
case T_String:
case T_BitString:
COPY_STRING_FIELD(val.str);
break;
case T_Null:
/* nothing to do */
break;
default:
elog(ERROR, "unrecognized node type: %d",
(int) from->type);
break;
}
return newnode;
}
@ -5314,11 +5330,16 @@ copyObjectImpl(const void *from)
* VALUE NODES
*/
case T_Integer:
retval = _copyInteger(from);
break;
case T_Float:
retval = _copyFloat(from);
break;
case T_String:
retval = _copyString(from);
break;
case T_BitString:
case T_Null:
retval = _copyValue(from);
retval = _copyBitString(from);
break;
/*