Have pg_itoa, pg_ltoa and pg_lltoa return the length of the string

david-rowley · david-rowley · commit dad75eb4a8d5 · 2020-06-13T12:32:00.000+12:00
Core by no means makes excessive use of these functions, but quite a large number of those usages do require the caller to call strlen() on the returned string. This is quite wasteful since these functions do already have a good idea of the length of the string, so we might as well just have them return that. Reviewed-by: Andrew Gierth Discussion: https://postgr.es/m/CAApHDvrm2A5x2uHYxsqriO2cUaGcFvND%2BksC9e7Tjep0t2RK_A%40mail.gmail.com
diff --git a/src/backend/access/common/printsimple.c b/src/backend/access/common/printsimple.c
@@ -103,19 +103,21 @@ printsimple(TupleTableSlot *slot, DestReceiver *self)
 				{
 					int32		num = DatumGetInt32(value);
 					char		str[12];	/* sign, 10 digits and '\0' */
+					int			len;
 
-					pg_ltoa(num, str);
-					pq_sendcountedtext(&buf, str, strlen(str), false);
+					len = pg_ltoa(num, str);
+					pq_sendcountedtext(&buf, str, len, false);
 				}
 				break;
 
 			case INT8OID:
 				{
 					int64		num = DatumGetInt64(value);
 					char		str[MAXINT8LEN + 1];
+					int			len;
 
-					pg_lltoa(num, str);
-					pq_sendcountedtext(&buf, str, strlen(str), false);
+					len = pg_lltoa(num, str);
+					pq_sendcountedtext(&buf, str, len, false);
 				}
 				break;
 
diff --git a/src/backend/utils/adt/int.c b/src/backend/utils/adt/int.c
@@ -191,9 +191,7 @@ int2vectorout(PG_FUNCTION_ARGS)
 	{
 		if (num != 0)
 			*rp++ = ' ';
-		pg_itoa(int2Array->values[num], rp);
-		while (*++rp != '\0')
-			;
+		rp += pg_itoa(int2Array->values[num], rp);
 	}
 	*rp = '\0';
 	PG_RETURN_CSTRING(result);
diff --git a/src/backend/utils/adt/int8.c b/src/backend/utils/adt/int8.c
@@ -149,9 +149,16 @@ int8out(PG_FUNCTION_ARGS)
 	int64		val = PG_GETARG_INT64(0);
 	char		buf[MAXINT8LEN + 1];
 	char	   *result;
+	int			len;
 
-	pg_lltoa(val, buf);
-	result = pstrdup(buf);
+	len = pg_lltoa(val, buf) + 1;
+
+	/*
+	 * Since the length is already known, we do a manual palloc() and memcpy()
+	 * to avoid the strlen() call that would otherwise be done in pstrdup().
+	 */
+	result = palloc(len);
+	memcpy(result, buf, len);
 	PG_RETURN_CSTRING(result);
 }
 
diff --git a/src/backend/utils/adt/numutils.c b/src/backend/utils/adt/numutils.c
@@ -327,16 +327,17 @@ pg_strtoint32(const char *s)
 
 /*
  * pg_itoa: converts a signed 16-bit integer to its string representation
+ * and returns strlen(a).
  *
  * Caller must ensure that 'a' points to enough memory to hold the result
  * (at least 7 bytes, counting a leading sign and trailing NUL).
  *
  * It doesn't seem worth implementing this separately.
  */
-void
+int
 pg_itoa(int16 i, char *a)
 {
-	pg_ltoa((int32) i, a);
+	return pg_ltoa((int32) i, a);
 }
 
 /*
@@ -404,25 +405,27 @@ pg_ultoa_n(uint32 value, char *a)
 }
 
 /*
- * NUL-terminate the output of pg_ultoa_n.
+ * pg_ltoa: converts a signed 32-bit integer to its string representation and
+ * returns strlen(a).
  *
  * It is the caller's responsibility to ensure that a is at least 12 bytes long,
  * which is enough room to hold a minus sign, a maximally long int32, and the
  * above terminating NUL.
  */
-void
+int
 pg_ltoa(int32 value, char *a)
 {
 	uint32		uvalue = (uint32) value;
-	int			len;
+	int			len = 0;
 
 	if (value < 0)
 	{
 		uvalue = (uint32) 0 - uvalue;
-		*a++ = '-';
+		a[len++] = '-';
 	}
-	len = pg_ultoa_n(uvalue, a);
+	len += pg_ultoa_n(uvalue, a + len);
 	a[len] = '\0';
+	return len;
 }
 
 /*
@@ -510,24 +513,27 @@ pg_ulltoa_n(uint64 value, char *a)
 }
 
 /*
- * pg_lltoa: convert a signed 64-bit integer to its string representation
+ * pg_lltoa: converts a signed 64-bit integer to its string representation and
+ * returns strlen(a).
  *
  * Caller must ensure that 'a' points to enough memory to hold the result
  * (at least MAXINT8LEN + 1 bytes, counting a leading sign and trailing NUL).
  */
-void
+int
 pg_lltoa(int64 value, char *a)
 {
-	int			len;
 	uint64		uvalue = value;
+	int			len = 0;
 
 	if (value < 0)
 	{
-		*a++ = '-';
 		uvalue = (uint64) 0 - uvalue;
+		a[len++] = '-';
 	}
-	len = pg_ulltoa_n(uvalue, a);
-	a[len] = 0;
+
+	len += pg_ulltoa_n(uvalue, a + len);
+	a[len] = '\0';
+	return len;
 }
 
 
diff --git a/src/include/utils/builtins.h b/src/include/utils/builtins.h
@@ -47,11 +47,11 @@ extern int	namestrcmp(Name name, const char *str);
 extern int32 pg_atoi(const char *s, int size, int c);
 extern int16 pg_strtoint16(const char *s);
 extern int32 pg_strtoint32(const char *s);
-extern void pg_itoa(int16 i, char *a);
+extern int pg_itoa(int16 i, char *a);
 extern int pg_ultoa_n(uint32 l, char *a);
 extern int pg_ulltoa_n(uint64 l, char *a);
-extern void pg_ltoa(int32 l, char *a);
-extern void pg_lltoa(int64 ll, char *a);
+extern int pg_ltoa(int32 l, char *a);
+extern int pg_lltoa(int64 ll, char *a);
 extern char *pg_ultostr_zeropad(char *str, uint32 value, int32 minwidth);
 extern char *pg_ultostr(char *str, uint32 value);
 extern uint64 pg_strtouint64(const char *str, char **endptr, int base);

Original file line number	Diff line number	Diff line change
`@@ -103,19 +103,21 @@ printsimple(TupleTableSlot slot, DestReceiver self)`
`103`	`103`	`{`
`104`	`104`	`int32 num = DatumGetInt32(value);`
`105`	`105`	`char str[12]; /* sign, 10 digits and '\0' */`
	`106`	`+ int len;`
`106`	`107`
`107`		`- pg_ltoa(num, str);`
`108`		`- pq_sendcountedtext(&buf, str, strlen(str), false);`
	`108`	`+ len = pg_ltoa(num, str);`
	`109`	`+ pq_sendcountedtext(&buf, str, len, false);`
`109`	`110`	`}`
`110`	`111`	`break;`
`111`	`112`
`112`	`113`	`case INT8OID:`
`113`	`114`	`{`
`114`	`115`	`int64 num = DatumGetInt64(value);`
`115`	`116`	`char str[MAXINT8LEN + 1];`
	`117`	`+ int len;`
`116`	`118`
`117`		`- pg_lltoa(num, str);`
`118`		`- pq_sendcountedtext(&buf, str, strlen(str), false);`
	`119`	`+ len = pg_lltoa(num, str);`
	`120`	`+ pq_sendcountedtext(&buf, str, len, false);`
`119`	`121`	`}`
`120`	`122`	`break;`
`121`	`123`
Original file line number	Diff line number	Diff line change
`@@ -191,9 +191,7 @@ int2vectorout(PG_FUNCTION_ARGS)`
`191`	`191`	`{`
`192`	`192`	`if (num != 0)`
`193`	`193`	`*rp++ = ' ';`
`194`		`- pg_itoa(int2Array->values[num], rp);`
`195`		`- while (*++rp != '\0')`
`196`		`- ;`
	`194`	`+ rp += pg_itoa(int2Array->values[num], rp);`
`197`	`195`	`}`
`198`	`196`	`*rp = '\0';`
`199`	`197`	`PG_RETURN_CSTRING(result);`
Original file line number	Diff line number	Diff line change
`@@ -327,16 +327,17 @@ pg_strtoint32(const char *s)`
`327`	`327`
`328`	`328`	`/*`
`329`	`329`	`* pg_itoa: converts a signed 16-bit integer to its string representation`
	`330`	`+ * and returns strlen(a).`
`330`	`331`	`*`
`331`	`332`	`* Caller must ensure that 'a' points to enough memory to hold the result`
`332`	`333`	`* (at least 7 bytes, counting a leading sign and trailing NUL).`
`333`	`334`	`*`
`334`	`335`	`* It doesn't seem worth implementing this separately.`
`335`	`336`	`*/`
`336`		`-void`
	`337`	`+int`
`337`	`338`	`pg_itoa(int16 i, char *a)`
`338`	`339`	`{`
`339`		`- pg_ltoa((int32) i, a);`
	`340`	`+ return pg_ltoa((int32) i, a);`
`340`	`341`	`}`
`341`	`342`
`342`	`343`	`/*`
`@@ -404,25 +405,27 @@ pg_ultoa_n(uint32 value, char *a)`
`404`	`405`	`}`
`405`	`406`
`406`	`407`	`/*`
`407`		`- * NUL-terminate the output of pg_ultoa_n.`
	`408`	`+ * pg_ltoa: converts a signed 32-bit integer to its string representation and`
	`409`	`+ * returns strlen(a).`
`408`	`410`	`*`
`409`	`411`	`* It is the caller's responsibility to ensure that a is at least 12 bytes long,`
`410`	`412`	`* which is enough room to hold a minus sign, a maximally long int32, and the`
`411`	`413`	`* above terminating NUL.`
`412`	`414`	`*/`
`413`		`-void`
	`415`	`+int`
`414`	`416`	`pg_ltoa(int32 value, char *a)`
`415`	`417`	`{`
`416`	`418`	`uint32 uvalue = (uint32) value;`
`417`		`- int len;`
	`419`	`+ int len = 0;`
`418`	`420`
`419`	`421`	`if (value < 0)`
`420`	`422`	`{`
`421`	`423`	`uvalue = (uint32) 0 - uvalue;`
`422`		`- *a++ = '-';`
	`424`	`+ a[len++] = '-';`
`423`	`425`	`}`
`424`		`- len = pg_ultoa_n(uvalue, a);`
	`426`	`+ len += pg_ultoa_n(uvalue, a + len);`
`425`	`427`	`a[len] = '\0';`
	`428`	`+ return len;`
`426`	`429`	`}`
`427`	`430`
`428`	`431`	`/*`
`@@ -510,24 +513,27 @@ pg_ulltoa_n(uint64 value, char *a)`
`510`	`513`	`}`
`511`	`514`
`512`	`515`	`/*`
`513`		`- * pg_lltoa: convert a signed 64-bit integer to its string representation`
	`516`	`+ * pg_lltoa: converts a signed 64-bit integer to its string representation and`
	`517`	`+ * returns strlen(a).`
`514`	`518`	`*`
`515`	`519`	`* Caller must ensure that 'a' points to enough memory to hold the result`
`516`	`520`	`* (at least MAXINT8LEN + 1 bytes, counting a leading sign and trailing NUL).`
`517`	`521`	`*/`
`518`		`-void`
	`522`	`+int`
`519`	`523`	`pg_lltoa(int64 value, char *a)`
`520`	`524`	`{`
`521`		`- int len;`
`522`	`525`	`uint64 uvalue = value;`
	`526`	`+ int len = 0;`
`523`	`527`
`524`	`528`	`if (value < 0)`
`525`	`529`	`{`
`526`		`- *a++ = '-';`
`527`	`530`	`uvalue = (uint64) 0 - uvalue;`
	`531`	`+ a[len++] = '-';`
`528`	`532`	`}`
`529`		`- len = pg_ulltoa_n(uvalue, a);`
`530`		`- a[len] = 0;`
	`533`	`+`
	`534`	`+ len += pg_ulltoa_n(uvalue, a + len);`
	`535`	`+ a[len] = '\0';`
	`536`	`+ return len;`
`531`	`537`	`}`
`532`	`538`
`533`	`539`