src/backend/utils/adt/format_type.c - hawq - Git at Google

 /*-------------------------------------------------------------------------
  *
  * format_type.c
  *	  Display type names "nicely".
  *
  *
  * Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
  *	  $PostgreSQL: pgsql/src/backend/utils/adt/format_type.c,v 1.44 2006/07/14 14:52:24 momjian Exp $
  *
  *-------------------------------------------------------------------------
  */

 #include "postgres.h"

 #include <ctype.h>

 #include "catalog/catquery.h"
 #include "catalog/namespace.h"
 #include "catalog/pg_type.h"
 #include "utils/builtins.h"
 #include "utils/datetime.h"
 #include "utils/fmgroids.h"
 #include "utils/lsyscache.h"
 #include "utils/numeric.h"
 #include "utils/syscache.h"
 #include "mb/pg_wchar.h"

 #define MAX_INT32_LEN 11
 #define _textin(str) DirectFunctionCall1(textin, CStringGetDatum(str))

 static char *format_type_internal(Oid type_oid, int32 typemod,
 					 bool typemod_given, bool allow_invalid);
 static char *
 psnprintf(size_t len, const char *fmt,...)
 /* This lets gcc check the format string for consistency. */
 __attribute__((format(printf, 2, 3)));


 /*
  * SQL function: format_type(type_oid, typemod)
  *
  * `type_oid' is from pg_type.oid, `typemod' is from
  * pg_attribute.atttypmod. This function will get the type name and
  * format it and the modifier to canonical SQL format, if the type is
  * a standard type. Otherwise you just get pg_type.typname back,
  * double quoted if it contains funny characters or matches a keyword.
  *
  * If typemod is NULL then we are formatting a type name in a context where
  * no typemod is available, eg a function argument or result type.	This
  * yields a slightly different result from specifying typemod = -1 in some
  * cases.  Given typemod = -1 we feel compelled to produce an output that
  * the parser will interpret as having typemod -1, so that pg_dump will
  * produce CREATE TABLE commands that recreate the original state.	But
  * given NULL typemod, we assume that the parser's interpretation of
  * typemod doesn't matter, and so we are willing to output a slightly
  * "prettier" representation of the same type.	For example, type = bpchar
  * and typemod = NULL gets you "character", whereas typemod = -1 gets you
  * "bpchar" --- the former will be interpreted as character(1) by the
  * parser, which does not yield typemod -1.
  *
  * XXX encoding a meaning in typemod = NULL is ugly; it'd have been
  * cleaner to make two functions of one and two arguments respectively.
  * Not worth changing it now, however.
  */
 Datum
 format_type(PG_FUNCTION_ARGS)
 {
 	Oid			type_oid;
 	int32		typemod;
 	char	   *result;

 	/* Since this function is not strict, we must test for null args */
 	if (PG_ARGISNULL(0))
 		PG_RETURN_NULL();

 	type_oid = PG_GETARG_OID(0);

 	if (PG_ARGISNULL(1))
 		result = format_type_internal(type_oid, -1, false, true);
 	else
 	{
 		typemod = PG_GETARG_INT32(1);
 		result = format_type_internal(type_oid, typemod, true, true);
 	}

 	PG_RETURN_DATUM(_textin(result));
 }

 /*
  * This version is for use within the backend in error messages, etc.
  * One difference is that it will fail for an invalid type.
  *
  * The result is always a palloc'd string.
  */
 char *
 format_type_be(Oid type_oid)
 {
 	return format_type_internal(type_oid, -1, false, false);
 }

 /*
  * This version allows a nondefault typemod to be specified.
  */
 char *
 format_type_with_typemod(Oid type_oid, int32 typemod)
 {
 	return format_type_internal(type_oid, typemod, true, false);
 }


 static char *
 format_type_internal(Oid type_oid, int32 typemod,
 					 bool typemod_given, bool allow_invalid)
 {
 	bool		with_typemod = typemod_given && (typemod >= 0);
 	HeapTuple	tuple;
 	Form_pg_type typeform;
 	Oid			array_base_type;
 	bool		is_array;
 	char	   *buf;
 	cqContext  *typcqCtx;
 	cqContext  *basecqCtx;

 	if (type_oid == InvalidOid && allow_invalid)
 		return pstrdup("-");

 	typcqCtx = caql_beginscan(
 			NULL,
 			cql("SELECT * FROM pg_type "
 				" WHERE oid = :1 ",
 				ObjectIdGetDatum(type_oid)));

 	tuple = caql_getnext(typcqCtx);

 	if (!HeapTupleIsValid(tuple))
 	{
 		caql_endscan(typcqCtx);

 		if (allow_invalid)
 			return pstrdup("???");
 		else
 			elog(ERROR, "cache lookup failed for type %u", type_oid);
 	}
 	typeform = (Form_pg_type) GETSTRUCT(tuple);

 	/*
 	 * Check if it's an array (and not a domain --- we don't want to show the
 	 * substructure of a domain type).	Fixed-length array types such as
 	 * "name" shouldn't get deconstructed either.  As of Postgres 8.1, rather
 	 * than checking typlen we check the toast property, and don't deconstruct
 	 * "plain storage" array types --- this is because we don't want to show
 	 * oidvector as oid[].
 	 *
 	 * *** MPP-5137 patch ***
 	 * The intent of this routine is to replace an array type reference with
 	 * an array of the underlying base type if, and only if, the array
 	 * reference is to the system-defined array type over a base type.
 	 *
 	 * Checking only typstorage = 'p' causes format_type failures when
 	 * processing user-defined array types having typstorage != 'p'.
 	 *
 	 * To avoid this, at least until 8.3, different checking is in order.
 	 * Until 8.3, all system-defined array types have names beginning with an
 	 * underscore ('_') with the remainder of the name the same as the base
 	 * element type name and have a typinput value of array_in.  Base type
 	 * array replacement will occur only if both conditions are met.  All
 	 * other references are left intact.
 	 *
 	 * User-defined and system-defined fixed-length types (like "name" and
 	 * "oidvector") can not use array_in; all of the system-defined
 	 * fixed-length types use specialized typinput routines, not array_in, so
 	 * checking for array_in clears the system types. (See comments in array.h
 	 * about fixed-length arrays.)
 	 */
 	array_base_type = typeform->typelem;

 	if (OidIsValid(array_base_type) &&
 		typeform->typtype != TYPTYPE_DOMAIN &&
 		/* TODO: Change test to use pg_type.typarray when introducing 8.3 updates */
 		NameStr(typeform->typname)[0] == '_' &&
 		typeform->typinput == F_ARRAY_IN)
 	{
 		HeapTuple base_tuple;
 		Form_pg_type base_typeform;

 		/* Switch our attention to the array element type */
 		basecqCtx = caql_beginscan(
 				NULL,
 				cql("SELECT * FROM pg_type "
 					" WHERE oid = :1 ",
 					ObjectIdGetDatum(array_base_type)));

 		base_tuple = caql_getnext(basecqCtx);

 		if (!HeapTupleIsValid(base_tuple))
 		{
 			if (allow_invalid)
 			{
 				caql_endscan(basecqCtx);
 				caql_endscan(typcqCtx);
 				return pstrdup("???[]");
 			}
 			else
 			{
 				elog(ERROR, "cache lookup failed for type %u", type_oid);
 			}
 		}
 		base_typeform = (Form_pg_type) GETSTRUCT(base_tuple);

 		/*
 		 * Now make final checks for system-defined array type before
 		 * substituting the array form of a base type for an array type
 		 * reference.
 		 *
 		 * TODO: Eliminate the name check when merging 8.3 updates and typarray checked
 		 */
 		if (strcmp(NameStr(base_typeform->typname), NameStr(typeform->typname)+1) == 0)
 		{
 			/* NOTE: a little grotesque, but since we are switching
 			 * the base tuple for the type tuple, free the typcqctx,
 			 * then switch the caql context for the base tuple as well
 			 * so it gets freed at the end
 			 */

 			caql_endscan(typcqCtx);

 			tuple = base_tuple;

 			typcqCtx = basecqCtx; /* NOTE: switch the caql ctx */

 			typeform = base_typeform;
 			type_oid = array_base_type;
 			is_array = true;
 		}
 		else
 		{
 			caql_endscan(basecqCtx);
 			is_array = false;
 		}
 	}
 	else
 	{
 		is_array = false;
 	}

 	/*
 	 * See if we want to special-case the output for certain built-in types.
 	 * Note that these special cases should all correspond to special
 	 * productions in gram.y, to ensure that the type name will be taken as a
 	 * system type, not a user type of the same name.
 	 *
 	 * If we do not provide a special-case output here, the type name will be
 	 * handled the same way as a user type name --- in particular, it will be
 	 * double-quoted if it matches any lexer keyword.  This behavior is
 	 * essential for some cases, such as types "bit" and "char".
 	 */
 	buf = NULL;					/* flag for no special case */

 	switch (type_oid)
 	{
 		case BITOID:
 			if (with_typemod)
 				buf = psnprintf(5 + MAX_INT32_LEN + 1, "bit(%d)",
 								(int) typemod);
 			else if (typemod_given)
 			{
 				/*
 				 * bit with typmod -1 is not the same as BIT, which means
 				 * BIT(1) per SQL spec.  Report it as the quoted typename so
 				 * that parser will not assign a bogus typmod.
 				 */
 			}
 			else
 				buf = pstrdup("bit");
 			break;

 		case BOOLOID:
 			buf = pstrdup("boolean");
 			break;

 		case BPCHAROID:
 			if (with_typemod)
 				buf = psnprintf(11 + MAX_INT32_LEN + 1, "character(%d)",
 								(int) (typemod - VARHDRSZ));
 			else if (typemod_given)
 			{
 				/*
 				 * bpchar with typmod -1 is not the same as CHARACTER, which
 				 * means CHARACTER(1) per SQL spec.  Report it as bpchar so
 				 * that parser will not assign a bogus typmod.
 				 */
 			}
 			else
 				buf = pstrdup("character");
 			break;

 		case FLOAT4OID:
 			buf = pstrdup("real");
 			break;

 		case FLOAT8OID:
 			buf = pstrdup("double precision");
 			break;

 		case INT2OID:
 			buf = pstrdup("smallint");
 			break;

 		case INT4OID:
 			buf = pstrdup("integer");
 			break;

 		case INT8OID:
 			buf = pstrdup("bigint");
 			break;

 		case NUMERICOID:
 			if (with_typemod)
 				buf = psnprintf(10 + 2 * MAX_INT32_LEN + 1, "numeric(%d,%d)",
 								((typemod - VARHDRSZ) >> 16) & 0xffff,
 								(typemod - VARHDRSZ) & 0xffff);
 			else
 				buf = pstrdup("numeric");
 			break;

 		case INTERVALOID:
 			if (with_typemod)
 			{
 				int			fields = INTERVAL_RANGE(typemod);
 				int			precision = INTERVAL_PRECISION(typemod);
 				const char *fieldstr;

 				switch (fields)
 				{
 					case INTERVAL_MASK(YEAR):
 						fieldstr = " year";
 						break;
 					case INTERVAL_MASK(MONTH):
 						fieldstr = " month";
 						break;
 					case INTERVAL_MASK(DAY):
 						fieldstr = " day";
 						break;
 					case INTERVAL_MASK(HOUR):
 						fieldstr = " hour";
 						break;
 					case INTERVAL_MASK(MINUTE):
 						fieldstr = " minute";
 						break;
 					case INTERVAL_MASK(SECOND):
 						fieldstr = " second";
 						break;
 						case INTERVAL_MASK(YEAR)
 					| INTERVAL_MASK(MONTH):
 						fieldstr = " year to month";
 						break;
 						case INTERVAL_MASK(DAY)
 					| INTERVAL_MASK(HOUR):
 						fieldstr = " day to hour";
 						break;
 						case INTERVAL_MASK(DAY)
 							| INTERVAL_MASK(HOUR)
 					| INTERVAL_MASK(MINUTE):
 						fieldstr = " day to minute";
 						break;
 						case INTERVAL_MASK(DAY)
 							| INTERVAL_MASK(HOUR)
 							| INTERVAL_MASK(MINUTE)
 					| INTERVAL_MASK(SECOND):
 						fieldstr = " day to second";
 						break;
 						case INTERVAL_MASK(HOUR)
 					| INTERVAL_MASK(MINUTE):
 						fieldstr = " hour to minute";
 						break;
 						case INTERVAL_MASK(HOUR)
 							| INTERVAL_MASK(MINUTE)
 					| INTERVAL_MASK(SECOND):
 						fieldstr = " hour to second";
 						break;
 						case INTERVAL_MASK(MINUTE)
 					| INTERVAL_MASK(SECOND):
 						fieldstr = " minute to second";
 						break;
 					case INTERVAL_FULL_RANGE:
 						fieldstr = "";
 						break;
 					default:
 						elog(ERROR, "invalid INTERVAL typmod: 0x%x", typemod);
 						fieldstr = "";
 						break;
 				}
 				if (precision != INTERVAL_FULL_PRECISION)
 					buf = psnprintf(100, "interval(%d)%s",
 									precision, fieldstr);
 				else
 					buf = psnprintf(100, "interval%s",
 									fieldstr);
 			}
 			else
 				buf = pstrdup("interval");
 			break;

 		case TIMEOID:
 			if (with_typemod)
 				buf = psnprintf(50, "time(%d) without time zone",
 								typemod);
 			else
 				buf = pstrdup("time without time zone");
 			break;

 		case TIMETZOID:
 			if (with_typemod)
 				buf = psnprintf(50, "time(%d) with time zone",
 								typemod);
 			else
 				buf = pstrdup("time with time zone");
 			break;

 		case TIMESTAMPOID:
 			if (with_typemod)
 				buf = psnprintf(50, "timestamp(%d) without time zone",
 								typemod);
 			else
 				buf = pstrdup("timestamp without time zone");
 			break;

 		case TIMESTAMPTZOID:
 			if (with_typemod)
 				buf = psnprintf(50, "timestamp(%d) with time zone",
 								typemod);
 			else
 				buf = pstrdup("timestamp with time zone");
 			break;

 		case VARBITOID:
 			if (with_typemod)
 				buf = psnprintf(13 + MAX_INT32_LEN + 1, "bit varying(%d)",
 								(int) typemod);
 			else
 				buf = pstrdup("bit varying");
 			break;

 		case VARCHAROID:
 			if (with_typemod)
 				buf = psnprintf(19 + MAX_INT32_LEN + 1,
 								"character varying(%d)",
 								(int) (typemod - VARHDRSZ));
 			else
 				buf = pstrdup("character varying");
 			break;
 	}

 	if (buf == NULL)
 	{
 		/*
 		 * Default handling: report the name as it appears in the catalog.
 		 * Here, we must qualify the name if it is not visible in the search
 		 * path, and we must double-quote it if it's not a standard identifier
 		 * or if it matches any keyword.
 		 */
 		char	   *nspname;
 		char	   *typname;

 		if (TypeIsVisible(type_oid))
 			nspname = NULL;
 		else
 			nspname = get_namespace_name(typeform->typnamespace);

 		typname = NameStr(typeform->typname);

 		buf = quote_qualified_identifier(nspname, typname);
 	}

 	if (is_array)
 		buf = psnprintf(strlen(buf) + 3, "%s[]", buf);

 	caql_endscan(typcqCtx); /* NOTE: this could be the base tuple ctx
 							 * if it was an array
 							 */

 	return buf;
 }


 /*
  * type_maximum_size --- determine maximum width of a variable-width column
  *
  * If the max width is indeterminate, return -1.  In particular, we return
  * -1 for any type not known to this routine.  We assume the caller has
  * already determined that the type is a variable-width type, so it's not
  * necessary to look up the type's pg_type tuple here.
  *
  * This may appear unrelated to format_type(), but in fact the two routines
  * share knowledge of the encoding of typmod for different types, so it's
  * convenient to keep them together.
  */
 int32
 type_maximum_size(Oid type_oid, int32 typemod)
 {
 	if (typemod < 0)
 		return -1;

 	switch (type_oid)
 	{
 		case BPCHAROID:
 		case VARCHAROID:
 			/* typemod includes varlena header */

 			/* typemod is in characters not bytes */
 			return (typemod - VARHDRSZ) *
 				pg_encoding_max_length(GetDatabaseEncoding())
 				+ VARHDRSZ;

 		case NUMERICOID:
 			/* precision (ie, max # of digits) is in upper bits of typmod */
 			if (typemod > VARHDRSZ)
 			{
 				int			precision = ((typemod - VARHDRSZ) >> 16) & 0xffff;

 				/* Numeric stores 2 decimal digits/byte, plus header */
 				return (precision + 1) / 2 + NUMERIC_HDRSZ;
 			}
 			break;

 		case VARBITOID:
 		case BITOID:
 			/* typemod is the (max) number of bits */
 			return (typemod + (BITS_PER_BYTE - 1)) / BITS_PER_BYTE
 				+ 2 * sizeof(int32);
 	}

 	/* Unknown type, or unlimited-width type such as 'text' */
 	return -1;
 }


 /*
  * oidvectortypes			- converts a vector of type OIDs to "typname" list
  */
 Datum
 oidvectortypes(PG_FUNCTION_ARGS)
 {
 	oidvector  *oidArray = (oidvector *) PG_GETARG_POINTER(0);
 	char	   *result;
 	int			numargs = oidArray->dim1;
 	int			num;
 	size_t		total;
 	size_t		left;

 	total = 20 * numargs + 1;
 	result = palloc(total);
 	result[0] = '\0';
 	left = total - 1;

 	for (num = 0; num < numargs; num++)
 	{
 		char	   *typename = format_type_internal(oidArray->values[num], -1,
 													false, true);
 		size_t		slen = strlen(typename);

 		if (left < (slen + 2))
 		{
 			total += slen + 2;
 			result = repalloc(result, total);
 			left += slen + 2;
 		}

 		if (num > 0)
 		{
 			strcat(result, ", ");
 			left -= 2;
 		}
 		strcat(result, typename);
 		left -= slen;
 	}

 	PG_RETURN_DATUM(_textin(result));
 }


 /* snprintf into a palloc'd string */
 static char *
 psnprintf(size_t len, const char *fmt,...)
 {
 	va_list		ap;
 	char	   *buf;

 	buf = palloc(len);

 	va_start(ap, fmt);
 	vsnprintf(buf, len, fmt, ap);
 	va_end(ap);

 	return buf;
 }
	/*-------------------------------------------------------------------------
	*
	* format_type.c
	* Display type names "nicely".
	*
	*
	* Portions Copyright (c) 1996-2008, PostgreSQL Global Development Group
	* Portions Copyright (c) 1994, Regents of the University of California
	*
	* IDENTIFICATION
	* $PostgreSQL: pgsql/src/backend/utils/adt/format_type.c,v 1.44 2006/07/14 14:52:24 momjian Exp $
	*
	*-------------------------------------------------------------------------
	*/

	#include "postgres.h"

	#include <ctype.h>

	#include "catalog/catquery.h"
	#include "catalog/namespace.h"
	#include "catalog/pg_type.h"
	#include "utils/builtins.h"
	#include "utils/datetime.h"
	#include "utils/fmgroids.h"
	#include "utils/lsyscache.h"
	#include "utils/numeric.h"
	#include "utils/syscache.h"
	#include "mb/pg_wchar.h"

	#define MAX_INT32_LEN 11
	#define _textin(str) DirectFunctionCall1(textin, CStringGetDatum(str))

	static char *format_type_internal(Oid type_oid, int32 typemod,
	bool typemod_given, bool allow_invalid);
	static char *
	psnprintf(size_t len, const char *fmt,...)
	/* This lets gcc check the format string for consistency. */
	__attribute__((format(printf, 2, 3)));


	/*
	* SQL function: format_type(type_oid, typemod)
	*
	* `type_oid' is from pg_type.oid, `typemod' is from
	* pg_attribute.atttypmod. This function will get the type name and
	* format it and the modifier to canonical SQL format, if the type is
	* a standard type. Otherwise you just get pg_type.typname back,
	* double quoted if it contains funny characters or matches a keyword.
	*
	* If typemod is NULL then we are formatting a type name in a context where
	* no typemod is available, eg a function argument or result type. This
	* yields a slightly different result from specifying typemod = -1 in some
	* cases. Given typemod = -1 we feel compelled to produce an output that
	* the parser will interpret as having typemod -1, so that pg_dump will
	* produce CREATE TABLE commands that recreate the original state. But
	* given NULL typemod, we assume that the parser's interpretation of
	* typemod doesn't matter, and so we are willing to output a slightly
	* "prettier" representation of the same type. For example, type = bpchar
	* and typemod = NULL gets you "character", whereas typemod = -1 gets you
	* "bpchar" --- the former will be interpreted as character(1) by the
	* parser, which does not yield typemod -1.
	*
	* XXX encoding a meaning in typemod = NULL is ugly; it'd have been
	* cleaner to make two functions of one and two arguments respectively.
	* Not worth changing it now, however.
	*/
	Datum
	format_type(PG_FUNCTION_ARGS)
	{
	Oid type_oid;
	int32 typemod;
	char *result;

	/* Since this function is not strict, we must test for null args */
	if (PG_ARGISNULL(0))
	PG_RETURN_NULL();

	type_oid = PG_GETARG_OID(0);

	if (PG_ARGISNULL(1))
	result = format_type_internal(type_oid, -1, false, true);
	else
	{
	typemod = PG_GETARG_INT32(1);
	result = format_type_internal(type_oid, typemod, true, true);
	}

	PG_RETURN_DATUM(_textin(result));
	}

	/*
	* This version is for use within the backend in error messages, etc.
	* One difference is that it will fail for an invalid type.
	*
	* The result is always a palloc'd string.
	*/
	char *
	format_type_be(Oid type_oid)
	{
	return format_type_internal(type_oid, -1, false, false);
	}

	/*
	* This version allows a nondefault typemod to be specified.
	*/
	char *
	format_type_with_typemod(Oid type_oid, int32 typemod)
	{
	return format_type_internal(type_oid, typemod, true, false);
	}



	static char *
	format_type_internal(Oid type_oid, int32 typemod,
	bool typemod_given, bool allow_invalid)
	{
	bool with_typemod = typemod_given && (typemod >= 0);
	HeapTuple tuple;
	Form_pg_type typeform;
	Oid array_base_type;
	bool is_array;
	char *buf;
	cqContext *typcqCtx;
	cqContext *basecqCtx;

	if (type_oid == InvalidOid && allow_invalid)
	return pstrdup("-");

	typcqCtx = caql_beginscan(
	NULL,
	cql("SELECT * FROM pg_type "
	" WHERE oid = :1 ",
	ObjectIdGetDatum(type_oid)));

	tuple = caql_getnext(typcqCtx);

	if (!HeapTupleIsValid(tuple))
	{
	caql_endscan(typcqCtx);

	if (allow_invalid)
	return pstrdup("???");
	else
	elog(ERROR, "cache lookup failed for type %u", type_oid);
	}
	typeform = (Form_pg_type) GETSTRUCT(tuple);

	/*
	* Check if it's an array (and not a domain --- we don't want to show the
	* substructure of a domain type). Fixed-length array types such as
	* "name" shouldn't get deconstructed either. As of Postgres 8.1, rather
	* than checking typlen we check the toast property, and don't deconstruct
	* "plain storage" array types --- this is because we don't want to show
	* oidvector as oid[].
	*
	* * MPP-5137 patch *
	* The intent of this routine is to replace an array type reference with
	* an array of the underlying base type if, and only if, the array
	* reference is to the system-defined array type over a base type.
	*
	* Checking only typstorage = 'p' causes format_type failures when
	* processing user-defined array types having typstorage != 'p'.
	*
	* To avoid this, at least until 8.3, different checking is in order.
	* Until 8.3, all system-defined array types have names beginning with an
	* underscore ('_') with the remainder of the name the same as the base
	* element type name and have a typinput value of array_in. Base type
	* array replacement will occur only if both conditions are met. All
	* other references are left intact.
	*
	* User-defined and system-defined fixed-length types (like "name" and
	* "oidvector") can not use array_in; all of the system-defined
	* fixed-length types use specialized typinput routines, not array_in, so
	* checking for array_in clears the system types. (See comments in array.h
	* about fixed-length arrays.)
	*/
	array_base_type = typeform->typelem;

	if (OidIsValid(array_base_type) &&
	typeform->typtype != TYPTYPE_DOMAIN &&
	/* TODO: Change test to use pg_type.typarray when introducing 8.3 updates */
	NameStr(typeform->typname)[0] == '_' &&
	typeform->typinput == F_ARRAY_IN)
	{
	HeapTuple base_tuple;
	Form_pg_type base_typeform;

	/* Switch our attention to the array element type */
	basecqCtx = caql_beginscan(
	NULL,
	cql("SELECT * FROM pg_type "
	" WHERE oid = :1 ",
	ObjectIdGetDatum(array_base_type)));

	base_tuple = caql_getnext(basecqCtx);

	if (!HeapTupleIsValid(base_tuple))
	{
	if (allow_invalid)
	{
	caql_endscan(basecqCtx);
	caql_endscan(typcqCtx);
	return pstrdup("???[]");
	}
	else
	{
	elog(ERROR, "cache lookup failed for type %u", type_oid);
	}
	}
	base_typeform = (Form_pg_type) GETSTRUCT(base_tuple);

	/*
	* Now make final checks for system-defined array type before
	* substituting the array form of a base type for an array type
	* reference.
	*
	* TODO: Eliminate the name check when merging 8.3 updates and typarray checked
	*/
	if (strcmp(NameStr(base_typeform->typname), NameStr(typeform->typname)+1) == 0)
	{
	/* NOTE: a little grotesque, but since we are switching
	* the base tuple for the type tuple, free the typcqctx,
	* then switch the caql context for the base tuple as well
	* so it gets freed at the end
	*/

	caql_endscan(typcqCtx);

	tuple = base_tuple;

	typcqCtx = basecqCtx; /* NOTE: switch the caql ctx */

	typeform = base_typeform;
	type_oid = array_base_type;
	is_array = true;
	}
	else
	{
	caql_endscan(basecqCtx);
	is_array = false;
	}
	}
	else
	{
	is_array = false;
	}

	/*
	* See if we want to special-case the output for certain built-in types.
	* Note that these special cases should all correspond to special
	* productions in gram.y, to ensure that the type name will be taken as a
	* system type, not a user type of the same name.
	*
	* If we do not provide a special-case output here, the type name will be
	* handled the same way as a user type name --- in particular, it will be
	* double-quoted if it matches any lexer keyword. This behavior is
	* essential for some cases, such as types "bit" and "char".
	*/
	buf = NULL; /* flag for no special case */

	switch (type_oid)
	{
	case BITOID:
	if (with_typemod)
	buf = psnprintf(5 + MAX_INT32_LEN + 1, "bit(%d)",
	(int) typemod);
	else if (typemod_given)
	{
	/*
	* bit with typmod -1 is not the same as BIT, which means
	* BIT(1) per SQL spec. Report it as the quoted typename so
	* that parser will not assign a bogus typmod.
	*/
	}
	else
	buf = pstrdup("bit");
	break;

	case BOOLOID:
	buf = pstrdup("boolean");
	break;

	case BPCHAROID:
	if (with_typemod)
	buf = psnprintf(11 + MAX_INT32_LEN + 1, "character(%d)",
	(int) (typemod - VARHDRSZ));
	else if (typemod_given)
	{
	/*
	* bpchar with typmod -1 is not the same as CHARACTER, which
	* means CHARACTER(1) per SQL spec. Report it as bpchar so
	* that parser will not assign a bogus typmod.
	*/
	}
	else
	buf = pstrdup("character");
	break;

	case FLOAT4OID:
	buf = pstrdup("real");
	break;

	case FLOAT8OID:
	buf = pstrdup("double precision");
	break;

	case INT2OID:
	buf = pstrdup("smallint");
	break;

	case INT4OID:
	buf = pstrdup("integer");
	break;

	case INT8OID:
	buf = pstrdup("bigint");
	break;

	case NUMERICOID:
	if (with_typemod)
	buf = psnprintf(10 + 2 * MAX_INT32_LEN + 1, "numeric(%d,%d)",
	((typemod - VARHDRSZ) >> 16) & 0xffff,
	(typemod - VARHDRSZ) & 0xffff);
	else
	buf = pstrdup("numeric");
	break;

	case INTERVALOID:
	if (with_typemod)
	{
	int fields = INTERVAL_RANGE(typemod);
	int precision = INTERVAL_PRECISION(typemod);
	const char *fieldstr;

	switch (fields)
	{
	case INTERVAL_MASK(YEAR):
	fieldstr = " year";
	break;
	case INTERVAL_MASK(MONTH):
	fieldstr = " month";
	break;
	case INTERVAL_MASK(DAY):
	fieldstr = " day";
	break;
	case INTERVAL_MASK(HOUR):
	fieldstr = " hour";
	break;
	case INTERVAL_MASK(MINUTE):
	fieldstr = " minute";
	break;
	case INTERVAL_MASK(SECOND):
	fieldstr = " second";
	break;
	case INTERVAL_MASK(YEAR)
	\| INTERVAL_MASK(MONTH):
	fieldstr = " year to month";
	break;
	case INTERVAL_MASK(DAY)
	\| INTERVAL_MASK(HOUR):
	fieldstr = " day to hour";
	break;
	case INTERVAL_MASK(DAY)
	\| INTERVAL_MASK(HOUR)
	\| INTERVAL_MASK(MINUTE):
	fieldstr = " day to minute";
	break;
	case INTERVAL_MASK(DAY)
	\| INTERVAL_MASK(HOUR)
	\| INTERVAL_MASK(MINUTE)
	\| INTERVAL_MASK(SECOND):
	fieldstr = " day to second";
	break;
	case INTERVAL_MASK(HOUR)
	\| INTERVAL_MASK(MINUTE):
	fieldstr = " hour to minute";
	break;
	case INTERVAL_MASK(HOUR)
	\| INTERVAL_MASK(MINUTE)
	\| INTERVAL_MASK(SECOND):
	fieldstr = " hour to second";
	break;
	case INTERVAL_MASK(MINUTE)
	\| INTERVAL_MASK(SECOND):
	fieldstr = " minute to second";
	break;
	case INTERVAL_FULL_RANGE:
	fieldstr = "";
	break;
	default:
	elog(ERROR, "invalid INTERVAL typmod: 0x%x", typemod);
	fieldstr = "";
	break;
	}
	if (precision != INTERVAL_FULL_PRECISION)
	buf = psnprintf(100, "interval(%d)%s",
	precision, fieldstr);
	else
	buf = psnprintf(100, "interval%s",
	fieldstr);
	}
	else
	buf = pstrdup("interval");
	break;

	case TIMEOID:
	if (with_typemod)
	buf = psnprintf(50, "time(%d) without time zone",
	typemod);
	else
	buf = pstrdup("time without time zone");
	break;

	case TIMETZOID:
	if (with_typemod)
	buf = psnprintf(50, "time(%d) with time zone",
	typemod);
	else
	buf = pstrdup("time with time zone");
	break;

	case TIMESTAMPOID:
	if (with_typemod)
	buf = psnprintf(50, "timestamp(%d) without time zone",
	typemod);
	else
	buf = pstrdup("timestamp without time zone");
	break;

	case TIMESTAMPTZOID:
	if (with_typemod)
	buf = psnprintf(50, "timestamp(%d) with time zone",
	typemod);
	else
	buf = pstrdup("timestamp with time zone");
	break;

	case VARBITOID:
	if (with_typemod)
	buf = psnprintf(13 + MAX_INT32_LEN + 1, "bit varying(%d)",
	(int) typemod);
	else
	buf = pstrdup("bit varying");
	break;

	case VARCHAROID:
	if (with_typemod)
	buf = psnprintf(19 + MAX_INT32_LEN + 1,
	"character varying(%d)",
	(int) (typemod - VARHDRSZ));
	else
	buf = pstrdup("character varying");
	break;
	}

	if (buf == NULL)
	{
	/*
	* Default handling: report the name as it appears in the catalog.
	* Here, we must qualify the name if it is not visible in the search
	* path, and we must double-quote it if it's not a standard identifier
	* or if it matches any keyword.
	*/
	char *nspname;
	char *typname;

	if (TypeIsVisible(type_oid))
	nspname = NULL;
	else
	nspname = get_namespace_name(typeform->typnamespace);

	typname = NameStr(typeform->typname);

	buf = quote_qualified_identifier(nspname, typname);
	}

	if (is_array)
	buf = psnprintf(strlen(buf) + 3, "%s[]", buf);

	caql_endscan(typcqCtx); /* NOTE: this could be the base tuple ctx
	* if it was an array
	*/

	return buf;
	}


	/*
	* type_maximum_size --- determine maximum width of a variable-width column
	*
	* If the max width is indeterminate, return -1. In particular, we return
	* -1 for any type not known to this routine. We assume the caller has
	* already determined that the type is a variable-width type, so it's not
	* necessary to look up the type's pg_type tuple here.
	*
	* This may appear unrelated to format_type(), but in fact the two routines
	* share knowledge of the encoding of typmod for different types, so it's
	* convenient to keep them together.
	*/
	int32
	type_maximum_size(Oid type_oid, int32 typemod)
	{
	if (typemod < 0)
	return -1;

	switch (type_oid)
	{
	case BPCHAROID:
	case VARCHAROID:
	/* typemod includes varlena header */

	/* typemod is in characters not bytes */
	return (typemod - VARHDRSZ) *
	pg_encoding_max_length(GetDatabaseEncoding())
	+ VARHDRSZ;

	case NUMERICOID:
	/* precision (ie, max # of digits) is in upper bits of typmod */
	if (typemod > VARHDRSZ)
	{
	int precision = ((typemod - VARHDRSZ) >> 16) & 0xffff;

	/* Numeric stores 2 decimal digits/byte, plus header */
	return (precision + 1) / 2 + NUMERIC_HDRSZ;
	}
	break;

	case VARBITOID:
	case BITOID:
	/* typemod is the (max) number of bits */
	return (typemod + (BITS_PER_BYTE - 1)) / BITS_PER_BYTE
	+ 2 * sizeof(int32);
	}

	/* Unknown type, or unlimited-width type such as 'text' */
	return -1;
	}


	/*
	* oidvectortypes - converts a vector of type OIDs to "typname" list
	*/
	Datum
	oidvectortypes(PG_FUNCTION_ARGS)
	{
	oidvector oidArray = (oidvector ) PG_GETARG_POINTER(0);
	char *result;
	int numargs = oidArray->dim1;
	int num;
	size_t total;
	size_t left;

	total = 20 * numargs + 1;
	result = palloc(total);
	result[0] = '\0';
	left = total - 1;

	for (num = 0; num < numargs; num++)
	{
	char *typename = format_type_internal(oidArray->values[num], -1,
	false, true);
	size_t slen = strlen(typename);

	if (left < (slen + 2))
	{
	total += slen + 2;
	result = repalloc(result, total);
	left += slen + 2;
	}

	if (num > 0)
	{
	strcat(result, ", ");
	left -= 2;
	}
	strcat(result, typename);
	left -= slen;
	}

	PG_RETURN_DATUM(_textin(result));
	}


	/* snprintf into a palloc'd string */
	static char *
	psnprintf(size_t len, const char *fmt,...)
	{
	va_list ap;
	char *buf;

	buf = palloc(len);

	va_start(ap, fmt);
	vsnprintf(buf, len, fmt, ap);
	va_end(ap);

	return buf;
	}