Rename value node fields

petere · petere · commit c4cc2850f4d1 · 2022-01-14T11:26:08.000+01:00
For the formerly-Value node types, rename the "val" field to a name specific to the node type, namely "ival", "fval", "sval", and "bsval". This makes some code clearer and catches mixups better. Reviewed-by: Pavel Stehule <pavel.stehule@gmail.com> Discussion: https://www.postgresql.org/message-id/flat/8c1a2e37-c68d-703c-5a83-7a6077f4f997@enterprisedb.com
diff --git a/src/backend/commands/define.c b/src/backend/commands/define.c
@@ -58,7 +58,7 @@ defGetString(DefElem *def)
 		case T_Integer:
 			return psprintf("%ld", (long) intVal(def->arg));
 		case T_Float:
-			return castNode(Float, def->arg)->val;
+			return castNode(Float, def->arg)->fval;
 		case T_String:
 			return strVal(def->arg);
 		case T_TypeName:
@@ -201,7 +201,7 @@ defGetInt64(DefElem *def)
 			 * strings.
 			 */
 			return DatumGetInt64(DirectFunctionCall1(int8in,
-													 CStringGetDatum(castNode(Float, def->arg)->val)));
+													 CStringGetDatum(castNode(Float, def->arg)->fval)));
 		default:
 			ereport(ERROR,
 					(errcode(ERRCODE_SYNTAX_ERROR),
diff --git a/src/backend/nodes/copyfuncs.c b/src/backend/nodes/copyfuncs.c
@@ -2745,16 +2745,16 @@ _copyA_Const(const A_Const *from)
 		switch (nodeTag(&from->val))
 		{
 			case T_Integer:
-				COPY_SCALAR_FIELD(val.ival.val);
+				COPY_SCALAR_FIELD(val.ival.ival);
 				break;
 			case T_Float:
-				COPY_STRING_FIELD(val.fval.val);
+				COPY_STRING_FIELD(val.fval.fval);
 				break;
 			case T_String:
-				COPY_STRING_FIELD(val.sval.val);
+				COPY_STRING_FIELD(val.sval.sval);
 				break;
 			case T_BitString:
-				COPY_STRING_FIELD(val.bsval.val);
+				COPY_STRING_FIELD(val.bsval.bsval);
 				break;
 			default:
 				elog(ERROR, "unrecognized node type: %d",
@@ -4934,7 +4934,7 @@ _copyInteger(const Integer *from)
 {
 	Integer	   *newnode = makeNode(Integer);
 
-	COPY_SCALAR_FIELD(val);
+	COPY_SCALAR_FIELD(ival);
 
 	return newnode;
 }
@@ -4944,7 +4944,7 @@ _copyFloat(const Float *from)
 {
 	Float	   *newnode = makeNode(Float);
 
-	COPY_STRING_FIELD(val);
+	COPY_STRING_FIELD(fval);
 
 	return newnode;
 }
@@ -4954,7 +4954,7 @@ _copyString(const String *from)
 {
 	String	   *newnode = makeNode(String);
 
-	COPY_STRING_FIELD(val);
+	COPY_STRING_FIELD(sval);
 
 	return newnode;
 }
@@ -4964,7 +4964,7 @@ _copyBitString(const BitString *from)
 {
 	BitString   *newnode = makeNode(BitString);
 
-	COPY_STRING_FIELD(val);
+	COPY_STRING_FIELD(bsval);
 
 	return newnode;
 }
diff --git a/src/backend/nodes/equalfuncs.c b/src/backend/nodes/equalfuncs.c
@@ -3125,31 +3125,31 @@ _equalList(const List *a, const List *b)
 static bool
 _equalInteger(const Integer *a, const Integer *b)
 {
-	COMPARE_SCALAR_FIELD(val);
+	COMPARE_SCALAR_FIELD(ival);
 
 	return true;
 }
 
 static bool
 _equalFloat(const Float *a, const Float *b)
 {
-	COMPARE_STRING_FIELD(val);
+	COMPARE_STRING_FIELD(fval);
 
 	return true;
 }
 
 static bool
 _equalString(const String *a, const String *b)
 {
-	COMPARE_STRING_FIELD(val);
+	COMPARE_STRING_FIELD(sval);
 
 	return true;
 }
 
 static bool
 _equalBitString(const BitString *a, const BitString *b)
 {
-	COMPARE_STRING_FIELD(val);
+	COMPARE_STRING_FIELD(bsval);
 
 	return true;
 }
diff --git a/src/backend/nodes/outfuncs.c b/src/backend/nodes/outfuncs.c
@@ -3421,7 +3421,7 @@ _outA_Expr(StringInfo str, const A_Expr *node)
 static void
 _outInteger(StringInfo str, const Integer *node)
 {
-	appendStringInfo(str, "%d", node->val);
+	appendStringInfo(str, "%d", node->ival);
 }
 
 static void
@@ -3431,7 +3431,7 @@ _outFloat(StringInfo str, const Float *node)
 	 * We assume the value is a valid numeric literal and so does not
 	 * need quoting.
 	 */
-	appendStringInfoString(str, node->val);
+	appendStringInfoString(str, node->fval);
 }
 
 static void
@@ -3442,16 +3442,16 @@ _outString(StringInfo str, const String *node)
 	 * but we don't want it to do anything with an empty string.
 	 */
 	appendStringInfoChar(str, '"');
-	if (node->val[0] != '\0')
-		outToken(str, node->val);
+	if (node->sval[0] != '\0')
+		outToken(str, node->sval);
 	appendStringInfoChar(str, '"');
 }
 
 static void
 _outBitString(StringInfo str, const BitString *node)
 {
 	/* internal representation already has leading 'b' */
-	appendStringInfoString(str, node->val);
+	appendStringInfoString(str, node->bsval);
 }
 
 static void
diff --git a/src/backend/nodes/value.c b/src/backend/nodes/value.c
@@ -24,7 +24,7 @@ makeInteger(int i)
 {
 	Integer	   *v = makeNode(Integer);
 
-	v->val = i;
+	v->ival = i;
 	return v;
 }
 
@@ -38,7 +38,7 @@ makeFloat(char *numericStr)
 {
 	Float	   *v = makeNode(Float);
 
-	v->val = numericStr;
+	v->fval = numericStr;
 	return v;
 }
 
@@ -52,7 +52,7 @@ makeString(char *str)
 {
 	String	   *v = makeNode(String);
 
-	v->val = str;
+	v->sval = str;
 	return v;
 }
 
@@ -66,6 +66,6 @@ makeBitString(char *str)
 {
 	BitString  *v = makeNode(BitString);
 
-	v->val = str;
+	v->bsval = str;
 	return v;
 }
diff --git a/src/backend/parser/gram.y b/src/backend/parser/gram.y
@@ -1719,7 +1719,7 @@ zone_value:
 					if ($3 != NIL)
 					{
 						A_Const *n = (A_Const *) linitial($3);
-						if ((n->val.ival.val & ~(INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE))) != 0)
+						if ((n->val.ival.ival & ~(INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE))) != 0)
 							ereport(ERROR,
 									(errcode(ERRCODE_SYNTAX_ERROR),
 									 errmsg("time zone interval must be HOUR or HOUR TO MINUTE"),
@@ -16667,7 +16667,7 @@ makeStringConst(char *str, int location)
 	A_Const *n = makeNode(A_Const);
 
 	n->val.sval.type = T_String;
-	n->val.sval.val = str;
+	n->val.sval.sval = str;
 	n->location = location;
 
    return (Node *)n;
@@ -16687,7 +16687,7 @@ makeIntConst(int val, int location)
 	A_Const *n = makeNode(A_Const);
 
 	n->val.ival.type = T_Integer;
-	n->val.ival.val = val;
+	n->val.ival.ival = val;
 	n->location = location;
 
    return (Node *)n;
@@ -16699,7 +16699,7 @@ makeFloatConst(char *str, int location)
 	A_Const *n = makeNode(A_Const);
 
 	n->val.fval.type = T_Float;
-	n->val.fval.val = str;
+	n->val.fval.fval = str;
 	n->location = location;
 
    return (Node *)n;
@@ -16711,7 +16711,7 @@ makeBitStringConst(char *str, int location)
 	A_Const *n = makeNode(A_Const);
 
 	n->val.bsval.type = T_BitString;
-	n->val.bsval.val = str;
+	n->val.bsval.bsval = str;
 	n->location = location;
 
    return (Node *)n;
@@ -16736,16 +16736,16 @@ makeAConst(Node *v, int location)
 	switch (v->type)
 	{
 		case T_Float:
-			n = makeFloatConst(castNode(Float, v)->val, location);
+			n = makeFloatConst(castNode(Float, v)->fval, location);
 			break;
 
 		case T_Integer:
-			n = makeIntConst(castNode(Integer, v)->val, location);
+			n = makeIntConst(castNode(Integer, v)->ival, location);
 			break;
 
 		case T_String:
 		default:
-			n = makeStringConst(castNode(String, v)->val, location);
+			n = makeStringConst(castNode(String, v)->sval, location);
 			break;
 	}
 
@@ -17049,7 +17049,7 @@ doNegate(Node *n, int location)
 
 		if (IsA(&con->val, Integer))
 		{
-			con->val.ival.val = -con->val.ival.val;
+			con->val.ival.ival = -con->val.ival.ival;
 			return n;
 		}
 		if (IsA(&con->val, Float))
@@ -17065,14 +17065,14 @@ doNegate(Node *n, int location)
 static void
 doNegateFloat(Float *v)
 {
-	char   *oldval = v->val;
+	char   *oldval = v->fval;
 
 	if (*oldval == '+')
 		oldval++;
 	if (*oldval == '-')
-		v->val = oldval+1;	/* just strip the '-' */
+		v->fval = oldval+1;	/* just strip the '-' */
 	else
-		v->val = psprintf("-%s", oldval);
+		v->fval = psprintf("-%s", oldval);
 }
 
 static Node *
diff --git a/src/backend/parser/parse_node.c b/src/backend/parser/parse_node.c
@@ -376,7 +376,7 @@ make_const(ParseState *pstate, A_Const *aconst)
 	switch (nodeTag(&aconst->val))
 	{
 		case T_Integer:
-			val = Int32GetDatum(aconst->val.ival.val);
+			val = Int32GetDatum(intVal(&aconst->val));
 
 			typeid = INT4OID;
 			typelen = sizeof(int32);
@@ -385,7 +385,7 @@ make_const(ParseState *pstate, A_Const *aconst)
 
 		case T_Float:
 			/* could be an oversize integer as well as a float ... */
-			if (scanint8(aconst->val.fval.val, true, &val64))
+			if (scanint8(aconst->val.fval.fval, true, &val64))
 			{
 				/*
 				 * It might actually fit in int32. Probably only INT_MIN can
@@ -415,7 +415,7 @@ make_const(ParseState *pstate, A_Const *aconst)
 				/* arrange to report location if numeric_in() fails */
 				setup_parser_errposition_callback(&pcbstate, pstate, aconst->location);
 				val = DirectFunctionCall3(numeric_in,
-										  CStringGetDatum(aconst->val.fval.val),
+										  CStringGetDatum(aconst->val.fval.fval),
 										  ObjectIdGetDatum(InvalidOid),
 										  Int32GetDatum(-1));
 				cancel_parser_errposition_callback(&pcbstate);
@@ -432,7 +432,7 @@ make_const(ParseState *pstate, A_Const *aconst)
 			 * We assume here that UNKNOWN's internal representation is the
 			 * same as CSTRING
 			 */
-			val = CStringGetDatum(aconst->val.sval.val);
+			val = CStringGetDatum(strVal(&aconst->val));
 
 			typeid = UNKNOWNOID;	/* will be coerced later */
 			typelen = -2;		/* cstring-style varwidth type */
@@ -443,7 +443,7 @@ make_const(ParseState *pstate, A_Const *aconst)
 			/* arrange to report location if bit_in() fails */
 			setup_parser_errposition_callback(&pcbstate, pstate, aconst->location);
 			val = DirectFunctionCall3(bit_in,
-									  CStringGetDatum(aconst->val.bsval.val),
+									  CStringGetDatum(aconst->val.bsval.bsval),
 									  ObjectIdGetDatum(InvalidOid),
 									  Int32GetDatum(-1));
 			cancel_parser_errposition_callback(&pcbstate);
diff --git a/src/backend/parser/parse_type.c b/src/backend/parser/parse_type.c
@@ -382,17 +382,17 @@ typenameTypeMod(ParseState *pstate, const TypeName *typeName, Type typ)
 
 			if (IsA(&ac->val, Integer))
 			{
-				cstr = psprintf("%ld", (long) ac->val.ival.val);
+				cstr = psprintf("%ld", (long) intVal(&ac->val));
 			}
 			else if (IsA(&ac->val, Float))
 			{
 				/* we can just use the string representation directly. */
-				cstr = ac->val.fval.val;
+				cstr = ac->val.fval.fval;
 			}
 			else if (IsA(&ac->val, String))
 			{
 				/* we can just use the string representation directly. */
-				cstr = ac->val.sval.val;
+				cstr = strVal(&ac->val);
 			}
 		}
 		else if (IsA(tm, ColumnRef))
diff --git a/src/backend/parser/parse_utilcmd.c b/src/backend/parser/parse_utilcmd.c
@@ -603,7 +603,7 @@ transformColumnDefinition(CreateStmtContext *cxt, ColumnDef *column)
 		qstring = quote_qualified_identifier(snamespace, sname);
 		snamenode = makeNode(A_Const);
 		snamenode->val.node.type = T_String;
-		snamenode->val.sval.val = qstring;
+		snamenode->val.sval.sval = qstring;
 		snamenode->location = -1;
 		castnode = makeNode(TypeCast);
 		castnode->typeName = SystemTypeName("regclass");
diff --git a/src/backend/utils/adt/oid.c b/src/backend/utils/adt/oid.c
@@ -324,7 +324,7 @@ oidparse(Node *node)
 			 * constants by the lexer.  Accept these if they are valid OID
 			 * strings.
 			 */
-			return oidin_subr(castNode(Float, node)->val, NULL);
+			return oidin_subr(castNode(Float, node)->fval, NULL);
 		default:
 			elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
 	}
diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
@@ -8332,7 +8332,7 @@ flatten_set_variable_args(const char *name, List *args)
 				break;
 			case T_Float:
 				/* represented as a string, so just copy it */
-				appendStringInfoString(&buf, castNode(Float, &con->val)->val);
+				appendStringInfoString(&buf, castNode(Float, &con->val)->fval);
 				break;
 			case T_String:
 				val = strVal(&con->val);
diff --git a/src/include/nodes/value.h b/src/include/nodes/value.h

Original file line number	Diff line number	Diff line change
`@@ -2745,16 +2745,16 @@ _copyA_Const(const A_Const *from)`
`2745`	`2745`	`switch (nodeTag(&from->val))`
`2746`	`2746`	`{`
`2747`	`2747`	`case T_Integer:`
`2748`		`- COPY_SCALAR_FIELD(val.ival.val);`
	`2748`	`+ COPY_SCALAR_FIELD(val.ival.ival);`
`2749`	`2749`	`break;`
`2750`	`2750`	`case T_Float:`
`2751`		`- COPY_STRING_FIELD(val.fval.val);`
	`2751`	`+ COPY_STRING_FIELD(val.fval.fval);`
`2752`	`2752`	`break;`
`2753`	`2753`	`case T_String:`
`2754`		`- COPY_STRING_FIELD(val.sval.val);`
	`2754`	`+ COPY_STRING_FIELD(val.sval.sval);`
`2755`	`2755`	`break;`
`2756`	`2756`	`case T_BitString:`
`2757`		`- COPY_STRING_FIELD(val.bsval.val);`
	`2757`	`+ COPY_STRING_FIELD(val.bsval.bsval);`
`2758`	`2758`	`break;`
`2759`	`2759`	`default:`
`2760`	`2760`	`elog(ERROR, "unrecognized node type: %d",`
`@@ -4934,7 +4934,7 @@ _copyInteger(const Integer *from)`
`4934`	`4934`	`{`
`4935`	`4935`	`Integer *newnode = makeNode(Integer);`
`4936`	`4936`
`4937`		`- COPY_SCALAR_FIELD(val);`
	`4937`	`+ COPY_SCALAR_FIELD(ival);`
`4938`	`4938`
`4939`	`4939`	`return newnode;`
`4940`	`4940`	`}`
`@@ -4944,7 +4944,7 @@ _copyFloat(const Float *from)`
`4944`	`4944`	`{`
`4945`	`4945`	`Float *newnode = makeNode(Float);`
`4946`	`4946`
`4947`		`- COPY_STRING_FIELD(val);`
	`4947`	`+ COPY_STRING_FIELD(fval);`
`4948`	`4948`
`4949`	`4949`	`return newnode;`
`4950`	`4950`	`}`
`@@ -4954,7 +4954,7 @@ _copyString(const String *from)`
`4954`	`4954`	`{`
`4955`	`4955`	`String *newnode = makeNode(String);`
`4956`	`4956`
`4957`		`- COPY_STRING_FIELD(val);`
	`4957`	`+ COPY_STRING_FIELD(sval);`
`4958`	`4958`
`4959`	`4959`	`return newnode;`
`4960`	`4960`	`}`
`@@ -4964,7 +4964,7 @@ _copyBitString(const BitString *from)`
`4964`	`4964`	`{`
`4965`	`4965`	`BitString *newnode = makeNode(BitString);`
`4966`	`4966`
`4967`		`- COPY_STRING_FIELD(val);`
	`4967`	`+ COPY_STRING_FIELD(bsval);`
`4968`	`4968`
`4969`	`4969`	`return newnode;`
`4970`	`4970`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3125,31 +3125,31 @@ _equalList(const List a, const List b)`
`3125`	`3125`	`static bool`
`3126`	`3126`	`_equalInteger(const Integer a, const Integer b)`
`3127`	`3127`	`{`
`3128`		`- COMPARE_SCALAR_FIELD(val);`
	`3128`	`+ COMPARE_SCALAR_FIELD(ival);`
`3129`	`3129`
`3130`	`3130`	`return true;`
`3131`	`3131`	`}`
`3132`	`3132`
`3133`	`3133`	`static bool`
`3134`	`3134`	`_equalFloat(const Float a, const Float b)`
`3135`	`3135`	`{`
`3136`		`- COMPARE_STRING_FIELD(val);`
	`3136`	`+ COMPARE_STRING_FIELD(fval);`
`3137`	`3137`
`3138`	`3138`	`return true;`
`3139`	`3139`	`}`
`3140`	`3140`
`3141`	`3141`	`static bool`
`3142`	`3142`	`_equalString(const String a, const String b)`
`3143`	`3143`	`{`
`3144`		`- COMPARE_STRING_FIELD(val);`
	`3144`	`+ COMPARE_STRING_FIELD(sval);`
`3145`	`3145`
`3146`	`3146`	`return true;`
`3147`	`3147`	`}`
`3148`	`3148`
`3149`	`3149`	`static bool`
`3150`	`3150`	`_equalBitString(const BitString a, const BitString b)`
`3151`	`3151`	`{`
`3152`		`- COMPARE_STRING_FIELD(val);`
	`3152`	`+ COMPARE_STRING_FIELD(bsval);`
`3153`	`3153`
`3154`	`3154`	`return true;`
`3155`	`3155`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3421,7 +3421,7 @@ _outA_Expr(StringInfo str, const A_Expr *node)`
`3421`	`3421`	`static void`
`3422`	`3422`	`_outInteger(StringInfo str, const Integer *node)`
`3423`	`3423`	`{`
`3424`		`- appendStringInfo(str, "%d", node->val);`
	`3424`	`+ appendStringInfo(str, "%d", node->ival);`
`3425`	`3425`	`}`
`3426`	`3426`
`3427`	`3427`	`static void`
`@@ -3431,7 +3431,7 @@ _outFloat(StringInfo str, const Float *node)`
`3431`	`3431`	`* We assume the value is a valid numeric literal and so does not`
`3432`	`3432`	`* need quoting.`
`3433`	`3433`	`*/`
`3434`		`- appendStringInfoString(str, node->val);`
	`3434`	`+ appendStringInfoString(str, node->fval);`
`3435`	`3435`	`}`
`3436`	`3436`
`3437`	`3437`	`static void`
`@@ -3442,16 +3442,16 @@ _outString(StringInfo str, const String *node)`
`3442`	`3442`	`* but we don't want it to do anything with an empty string.`
`3443`	`3443`	`*/`
`3444`	`3444`	`appendStringInfoChar(str, '"');`
`3445`		`- if (node->val[0] != '\0')`
`3446`		`- outToken(str, node->val);`
	`3445`	`+ if (node->sval[0] != '\0')`
	`3446`	`+ outToken(str, node->sval);`
`3447`	`3447`	`appendStringInfoChar(str, '"');`
`3448`	`3448`	`}`
`3449`	`3449`
`3450`	`3450`	`static void`
`3451`	`3451`	`_outBitString(StringInfo str, const BitString *node)`
`3452`	`3452`	`{`
`3453`	`3453`	`/* internal representation already has leading 'b' */`
`3454`		`- appendStringInfoString(str, node->val);`
	`3454`	`+ appendStringInfoString(str, node->bsval);`
`3455`	`3455`	`}`
`3456`	`3456`
`3457`	`3457`	`static void`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ makeInteger(int i)`
`24`	`24`	`{`
`25`	`25`	`Integer *v = makeNode(Integer);`
`26`	`26`
`27`		`- v->val = i;`
	`27`	`+ v->ival = i;`
`28`	`28`	`return v;`
`29`	`29`	`}`
`30`	`30`
`@@ -38,7 +38,7 @@ makeFloat(char *numericStr)`
`38`	`38`	`{`
`39`	`39`	`Float *v = makeNode(Float);`
`40`	`40`
`41`		`- v->val = numericStr;`
	`41`	`+ v->fval = numericStr;`
`42`	`42`	`return v;`
`43`	`43`	`}`
`44`	`44`
`@@ -52,7 +52,7 @@ makeString(char *str)`
`52`	`52`	`{`
`53`	`53`	`String *v = makeNode(String);`
`54`	`54`
`55`		`- v->val = str;`
	`55`	`+ v->sval = str;`
`56`	`56`	`return v;`
`57`	`57`	`}`
`58`	`58`
`@@ -66,6 +66,6 @@ makeBitString(char *str)`
`66`	`66`	`{`
`67`	`67`	`BitString *v = makeNode(BitString);`
`68`	`68`
`69`		`- v->val = str;`
	`69`	`+ v->bsval = str;`
`70`	`70`	`return v;`
`71`	`71`	`}`
Original file line number	Diff line number	Diff line change
`@@ -382,17 +382,17 @@ typenameTypeMod(ParseState pstate, const TypeName typeName, Type typ)`
`382`	`382`
`383`	`383`	`if (IsA(&ac->val, Integer))`
`384`	`384`	`{`
`385`		`- cstr = psprintf("%ld", (long) ac->val.ival.val);`
	`385`	`+ cstr = psprintf("%ld", (long) intVal(&ac->val));`
`386`	`386`	`}`
`387`	`387`	`else if (IsA(&ac->val, Float))`
`388`	`388`	`{`
`389`	`389`	`/* we can just use the string representation directly. */`
`390`		`- cstr = ac->val.fval.val;`
	`390`	`+ cstr = ac->val.fval.fval;`
`391`	`391`	`}`
`392`	`392`	`else if (IsA(&ac->val, String))`
`393`	`393`	`{`
`394`	`394`	`/* we can just use the string representation directly. */`
`395`		`- cstr = ac->val.sval.val;`
	`395`	`+ cstr = strVal(&ac->val);`
`396`	`396`	`}`
`397`	`397`	`}`
`398`	`398`	`else if (IsA(tm, ColumnRef))`
Original file line number	Diff line number	Diff line change
`@@ -324,7 +324,7 @@ oidparse(Node *node)`
`324`	`324`	`* constants by the lexer. Accept these if they are valid OID`
`325`	`325`	`* strings.`
`326`	`326`	`*/`
`327`		`- return oidin_subr(castNode(Float, node)->val, NULL);`
	`327`	`+ return oidin_subr(castNode(Float, node)->fval, NULL);`
`328`	`328`	`default:`
`329`	`329`	`elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));`
`330`	`330`	`}`