Rationalize handling of array type names in bootstrap data.

tglsfdc · tglsfdc · commit 9ffcccdb958d · 2018-04-17T18:29:11.000-04:00
Formerly, Catalog.pm turned a C array type declaration in the catalog header files into a SQL type, e.g., 'foo[]'. Along the way, genbki.pl turned this into '_foo' for the purpose of type lookups, but wrote 'foo[]' to postgres.bki. During bootstrap, bootscanner.l had to have a special case rule to tokenize this, and then MapArrayTypeName() would turn 'foo[]' into '_foo' one more time. This seems unnecessarily complicated, especially since nobody cares that much about the readability of postgres.bki. Instead, make Catalog.pm convert the C declaration into '_foo' to start with, and preserve that representation of the type name throughout bootstrap data processing. Then rip out the special-case code in bootscanner.l and bootstrap.c. This changes postgres.bki to the extent that array fields are now declared like proconfig = _text , rather than proconfig = text[] , No documentation update, since the SGML docs didn't mention any of this in the first place, and it's all pretty transparent to writers of catalog header files anyway. John Naylor Discussion: https://postgr.es/m/CAJVSVGUNao=-Q2-vAN3PYcdF5tnL5JAHwGwzZGuYHtq+Mk_9ng@mail.gmail.com
diff --git a/src/backend/bootstrap/bootscanner.l b/src/backend/bootstrap/bootscanner.l
@@ -65,10 +65,8 @@ static int	yyline = 1;			/* line number for error reporting */
 %option prefix="boot_yy"
 
 
-D		[0-9]
 id		[-A-Za-z0-9_]+
 sid		\"([^\"])*\"
-arrayid [A-Za-z0-9_]+\[{D}*\]
 
 %%
 
@@ -111,10 +109,6 @@ insert			{ return INSERT_TUPLE; }
 "NOT"			{ return XNOT; }
 "NULL"			{ return XNULL; }
 
-{arrayid}		{
-					yylval.str = MapArrayTypeName(yytext);
-					return ID;
-				}
 {id}			{
 					yylval.str = scanstr(yytext);
 					return ID;
diff --git a/src/backend/bootstrap/bootstrap.c b/src/backend/bootstrap/bootstrap.c
@@ -1036,36 +1036,6 @@ AllocateAttribute(void)
 		MemoryContextAllocZero(TopMemoryContext, ATTRIBUTE_FIXED_PART_SIZE);
 }
 
-/*
- *		MapArrayTypeName
- *
- * Given a type name, produce the corresponding array type name by prepending
- * '_' and truncating as needed to fit in NAMEDATALEN-1 bytes.  This is only
- * used in bootstrap mode, so we can get away with assuming that the input is
- * ASCII and we don't need multibyte-aware truncation.
- *
- * The given string normally ends with '[]' or '[digits]'; we discard that.
- *
- * The result is a palloc'd string.
- */
-char *
-MapArrayTypeName(const char *s)
-{
-	int			i,
-				j;
-	char		newStr[NAMEDATALEN];
-
-	newStr[0] = '_';
-	j = 1;
-	for (i = 0; i < NAMEDATALEN - 2 && s[i] != '['; i++, j++)
-		newStr[j] = s[i];
-
-	newStr[j] = '\0';
-
-	return pstrdup(newStr);
-}
-
-
 /*
  *	index_register() -- record an index that has been set up for building
  *						later.
diff --git a/src/backend/catalog/Catalog.pm b/src/backend/catalog/Catalog.pm
@@ -161,10 +161,14 @@ sub ParseHeader
 					{
 						$atttype = $RENAME_ATTTYPE{$atttype};
 					}
-					if ($attname =~ /(.*)\[.*\]/)    # array attribute
+
+					# If the C name ends with '[]' or '[digits]', we have
+					# an array type, so we discard that from the name and
+					# prepend '_' to the type.
+					if ($attname =~ /(\w+)\[\d*\]/)
 					{
 						$attname = $1;
-						$atttype .= '[]';
+						$atttype = '_' . $atttype;
 					}
 
 					$column{type} = $atttype;
diff --git a/src/backend/catalog/genbki.pl b/src/backend/catalog/genbki.pl
@@ -351,7 +351,7 @@
 
 			# Replace OID synonyms with OIDs per the appropriate lookup rule.
 			#
-			# If the column type is oidvector or oid[], we have to replace
+			# If the column type is oidvector or _oid, we have to replace
 			# each element of the array as per the lookup rule.
 			if ($column->{lookup})
 			{
@@ -369,7 +369,7 @@
 											  \%bki_values, @lookupnames);
 					$bki_values{$attname} = join(' ', @lookupoids);
 				}
-				elsif ($atttype eq 'oid[]')
+				elsif ($atttype eq '_oid')
 				{
 					if ($bki_values{$attname} ne '_null_')
 					{
@@ -598,10 +598,6 @@ sub morph_row_for_pgattr
 
 	$row->{attname} = $attname;
 
-	# Adjust type name for arrays: foo[] becomes _foo, so we can look it up in
-	# pg_type
-	$atttype = '_' . $1 if $atttype =~ /(.+)\[\]$/;
-
 	# Copy the type data from pg_type, and add some type-dependent items
 	my $type = $types{$atttype};
 
diff --git a/src/include/bootstrap/bootstrap.h b/src/include/bootstrap/bootstrap.h
@@ -44,8 +44,6 @@ extern void InsertOneTuple(Oid objectid);
 extern void InsertOneValue(char *value, int i);
 extern void InsertOneNull(int i);
 
-extern char *MapArrayTypeName(const char *s);
-
 extern void index_register(Oid heap, Oid ind, IndexInfo *indexInfo);
 extern void build_indices(void);
 

Original file line number	Diff line number	Diff line change
`@@ -161,10 +161,14 @@ sub ParseHeader`
`161`	`161`	`{`
`162`	`162`	`$atttype = $RENAME_ATTTYPE{$atttype};`
`163`	`163`	`}`
`164`		`- if ($attname =~ /(.)\[.\]/) # array attribute`
	`164`	`+`
	`165`	`+ # If the C name ends with '[]' or '[digits]', we have`
	`166`	`+ # an array type, so we discard that from the name and`
	`167`	`+ # prepend '_' to the type.`
	`168`	`+ if ($attname =~ /(\w+)\[\d*\]/)`
`165`	`169`	`{`
`166`	`170`	`$attname = $1;`
`167`		`- $atttype .= '[]';`
	`171`	`+ $atttype = '_' . $atttype;`
`168`	`172`	`}`
`169`	`173`
`170`	`174`	`$column{type} = $atttype;`
Original file line number	Diff line number	Diff line change
`@@ -351,7 +351,7 @@`
`351`	`351`
`352`	`352`	`# Replace OID synonyms with OIDs per the appropriate lookup rule.`
`353`	`353`	`#`
`354`		`- # If the column type is oidvector or oid[], we have to replace`
	`354`	`+ # If the column type is oidvector or _oid, we have to replace`
`355`	`355`	`# each element of the array as per the lookup rule.`
`356`	`356`	`if ($column->{lookup})`
`357`	`357`	`{`
`@@ -369,7 +369,7 @@`
`369`	`369`	`\%bki_values, @lookupnames);`
`370`	`370`	`$bki_values{$attname} = join(' ', @lookupoids);`
`371`	`371`	`}`
`372`		`- elsif ($atttype eq 'oid[]')`
	`372`	`+ elsif ($atttype eq '_oid')`
`373`	`373`	`{`
`374`	`374`	`if ($bki_values{$attname} ne '_null_')`
`375`	`375`	`{`
`@@ -598,10 +598,6 @@ sub morph_row_for_pgattr`
`598`	`598`
`599`	`599`	`$row->{attname} = $attname;`
`600`	`600`
`601`		`- # Adjust type name for arrays: foo[] becomes _foo, so we can look it up in`
`602`		`- # pg_type`
`603`		`- $atttype = '_' . $1 if $atttype =~ /(.+)\[\]$/;`
`604`		`-`
`605`	`601`	`# Copy the type data from pg_type, and add some type-dependent items`
`606`	`602`	`my $type = $types{$atttype};`
`607`	`603`