/*

   $Id: types.c 10871 2008-03-03 16:50:04Z turnstep $

   Copyright (c) 2003-2008 Greg Sabino Mullane and others: see the Changes file
   
   You may distribute under the terms of either the GNU General Public
   License or the Artistic License, as specified in the Perl README file.

*/

/*
	 Please do not edit the C portions of this file directly. 
	 It is automatically generated by the enclosed Perl script.
*/


#include "Pg.h"

static sql_type_info_t pg_types[] = {
 {PG_ABSTIMEARRAY      ,"_abstime"         ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_ACLITEMARRAY      ,"_aclitem"         ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_BITARRAY          ,"_bit"             ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_BOOLARRAY         ,"_bool"            ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_BOXARRAY          ,"_box"             ,';',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_BPCHARARRAY       ,"_bpchar"          ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_BYTEAARRAY        ,"_bytea"           ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_CHARARRAY         ,"_char"            ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_CIDARRAY          ,"_cid"             ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_CIDRARRAY         ,"_cidr"            ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_CIRCLEARRAY       ,"_circle"          ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_CSTRINGARRAY      ,"_cstring"         ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_DATEARRAY         ,"_date"            ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_FLOAT4ARRAY       ,"_float4"          ,',',"array_out"       ,quote_string,dequote_string,{0},0,2},
 {PG_FLOAT8ARRAY       ,"_float8"          ,',',"array_out"       ,quote_string,dequote_string,{0},0,2},
 {PG_GTSVECTORARRAY    ,"_gtsvector"       ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_INETARRAY         ,"_inet"            ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_INT2ARRAY         ,"_int2"            ,',',"array_out"       ,quote_string,dequote_string,{0},0,1},
 {PG_INT2VECTORARRAY   ,"_int2vector"      ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_INT4ARRAY         ,"_int4"            ,',',"array_out"       ,quote_string,dequote_string,{0},0,1},
 {PG_INT8ARRAY         ,"_int8"            ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_INTERVALARRAY     ,"_interval"        ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_LINEARRAY         ,"_line"            ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_LSEGARRAY         ,"_lseg"            ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_MACADDRARRAY      ,"_macaddr"         ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_MONEYARRAY        ,"_money"           ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_NAMEARRAY         ,"_name"            ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_NUMERICARRAY      ,"_numeric"         ,',',"array_out"       ,quote_string,dequote_string,{0},0,2},
 {PG_OIDARRAY          ,"_oid"             ,',',"array_out"       ,quote_string,dequote_string,{0},0,1},
 {PG_OIDVECTORARRAY    ,"_oidvector"       ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_PATHARRAY         ,"_path"            ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_POINTARRAY        ,"_point"           ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_POLYGONARRAY      ,"_polygon"         ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_REFCURSORARRAY    ,"_refcursor"       ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_REGCLASSARRAY     ,"_regclass"        ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_REGCONFIGARRAY    ,"_regconfig"       ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_REGDICTIONARYARRAY,"_regdictionary"   ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_REGOPERARRAY      ,"_regoper"         ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_REGOPERATORARRAY  ,"_regoperator"     ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_REGPROCARRAY      ,"_regproc"         ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_REGPROCEDUREARRAY ,"_regprocedure"    ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_REGTYPEARRAY      ,"_regtype"         ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_RELTIMEARRAY      ,"_reltime"         ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_TEXTARRAY         ,"_text"            ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_TIDARRAY          ,"_tid"             ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_TIMEARRAY         ,"_time"            ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_TIMESTAMPARRAY    ,"_timestamp"       ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_TIMESTAMPTZARRAY  ,"_timestamptz"     ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_TIMETZARRAY       ,"_timetz"          ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_TINTERVALARRAY    ,"_tinterval"       ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_TSQUERYARRAY      ,"_tsquery"         ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_TSVECTORARRAY     ,"_tsvector"        ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_TXID_SNAPSHOTARRAY,"_txid_snapshot"   ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_UUIDARRAY         ,"_uuid"            ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_VARBITARRAY       ,"_varbit"          ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_VARCHARARRAY      ,"_varchar"         ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_XIDARRAY          ,"_xid"             ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_XMLARRAY          ,"_xml"             ,',',"array_out"       ,quote_string,dequote_string,{0},0,0},
 {PG_ABSTIME           ,"abstime"          ,',',"abstimeout"      ,quote_string,dequote_string,{0},0,0},
 {PG_ACLITEM           ,"aclitem"          ,',',"aclitemout"      ,quote_string,dequote_string,{0},0,0},
 {PG_ANY               ,"any"              ,',',"any_out"         ,quote_string,dequote_string,{0},0,0},
 {PG_ANYARRAY          ,"anyarray"         ,',',"anyarray_out"    ,quote_string,dequote_string,{0},0,0},
 {PG_ANYELEMENT        ,"anyelement"       ,',',"anyelement_out"  ,quote_string,dequote_string,{0},0,0},
 {PG_ANYENUM           ,"anyenum"          ,',',"anyenum_out"     ,quote_string,dequote_string,{0},0,0},
 {PG_ANYNONARRAY       ,"anynonarray"      ,',',"anynonarray_out" ,quote_string,dequote_string,{0},0,0},
 {PG_BIT               ,"bit"              ,',',"bit_out"         ,quote_string,dequote_string,{0},0,0},
 {PG_BOOL              ,"bool"             ,',',"boolout"         ,quote_bool  ,dequote_bool  ,{SQL_BOOLEAN},1,0},
 {PG_BOX               ,"box"              ,';',"box_out"         ,quote_geom  ,dequote_string,{0},0,0},
 {PG_BPCHAR            ,"bpchar"           ,',',"bpcharout"       ,quote_string,dequote_char  ,{SQL_CHAR},1,0},
 {PG_BYTEA             ,"bytea"            ,',',"byteaout"        ,quote_bytea ,dequote_bytea ,{SQL_VARBINARY},1,0},
 {PG_CHAR              ,"char"             ,',',"charout"         ,quote_string,dequote_char  ,{SQL_CHAR},0,0},
 {PG_CID               ,"cid"              ,',',"cidout"          ,quote_string,dequote_string,{0},0,0},
 {PG_CIDR              ,"cidr"             ,',',"cidr_out"        ,quote_string,dequote_string,{0},0,0},
 {PG_CIRCLE            ,"circle"           ,',',"circle_out"      ,quote_circle,dequote_string,{0},0,0},
 {PG_CSTRING           ,"cstring"          ,',',"cstring_out"     ,quote_string,dequote_string,{0},0,0},
 {PG_DATE              ,"date"             ,',',"date_out"        ,quote_string,dequote_string,{SQL_TYPE_DATE},1,0},
 {PG_FLOAT4            ,"float4"           ,',',"float4out"       ,null_quote  ,null_dequote  ,{0},1,2},
 {PG_FLOAT8            ,"float8"           ,',',"float8out"       ,null_quote  ,null_dequote  ,{SQL_FLOAT},1,2},
 {PG_GTSVECTOR         ,"gtsvector"        ,',',"gtsvectorout"    ,quote_string,dequote_string,{0},0,0},
 {PG_INET              ,"inet"             ,',',"inet_out"        ,quote_string,dequote_string,{0},0,0},
 {PG_INT2              ,"int2"             ,',',"int2out"         ,null_quote  ,null_dequote  ,{SQL_SMALLINT},1,1},
 {PG_INT2VECTOR        ,"int2vector"       ,',',"int2vectorout"   ,quote_string,dequote_string,{0},0,0},
 {PG_INT4              ,"int4"             ,',',"int4out"         ,null_quote  ,null_dequote  ,{SQL_INTEGER},1,1},
 {PG_INT8              ,"int8"             ,',',"int8out"         ,null_quote  ,null_dequote  ,{SQL_BIGINT},1,0},
 {PG_INTERNAL          ,"internal"         ,',',"internal_out"    ,quote_string,dequote_string,{0},0,0},
 {PG_INTERVAL          ,"interval"         ,',',"interval_out"    ,quote_string,dequote_string,{0},0,0},
 {PG_LANGUAGE_HANDLER  ,"language_handler" ,',',"language_handler_out",quote_string,dequote_string,{0},0,0},
 {PG_LINE              ,"line"             ,',',"line_out"        ,quote_geom  ,dequote_string,{0},0,0},
 {PG_LSEG              ,"lseg"             ,',',"lseg_out"        ,quote_geom  ,dequote_string,{0},0,0},
 {PG_MACADDR           ,"macaddr"          ,',',"macaddr_out"     ,quote_string,dequote_string,{0},0,0},
 {PG_MONEY             ,"money"            ,',',"cash_out"        ,quote_string,dequote_string,{0},0,0},
 {PG_NAME              ,"name"             ,',',"nameout"         ,null_quote  ,null_dequote  ,{SQL_VARCHAR},0,0},
 {PG_NUMERIC           ,"numeric"          ,',',"numeric_out"     ,null_quote  ,null_dequote  ,{SQL_DECIMAL},1,2},
 {PG_OID               ,"oid"              ,',',"oidout"          ,null_quote  ,null_dequote  ,{0},0,1},
 {PG_OIDVECTOR         ,"oidvector"        ,',',"oidvectorout"    ,quote_string,dequote_string,{0},0,0},
 {PG_OPAQUE            ,"opaque"           ,',',"opaque_out"      ,quote_string,dequote_string,{0},0,0},
 {PG_PATH              ,"path"             ,',',"path_out"        ,quote_path  ,dequote_string,{0},0,0},
 {PG_PG_ATTRIBUTE      ,"pg_attribute"     ,',',"record_out"      ,quote_string,dequote_string,{0},0,0},
 {PG_PG_CLASS          ,"pg_class"         ,',',"record_out"      ,quote_string,dequote_string,{0},0,0},
 {PG_PG_PROC           ,"pg_proc"          ,',',"record_out"      ,quote_string,dequote_string,{0},0,0},
 {PG_PG_TYPE           ,"pg_type"          ,',',"record_out"      ,quote_string,dequote_string,{0},0,0},
 {PG_POINT             ,"point"            ,',',"point_out"       ,quote_geom  ,dequote_string,{0},0,0},
 {PG_POLYGON           ,"polygon"          ,',',"poly_out"        ,quote_geom  ,dequote_string,{0},0,0},
 {PG_RECORD            ,"record"           ,',',"record_out"      ,quote_string,dequote_string,{0},0,0},
 {PG_REFCURSOR         ,"refcursor"        ,',',"textout"         ,quote_string,dequote_string,{0},0,0},
 {PG_REGCLASS          ,"regclass"         ,',',"regclassout"     ,quote_string,dequote_string,{0},0,0},
 {PG_REGCONFIG         ,"regconfig"        ,',',"regconfigout"    ,quote_string,dequote_string,{0},0,0},
 {PG_REGDICTIONARY     ,"regdictionary"    ,',',"regdictionaryout",quote_string,dequote_string,{0},0,0},
 {PG_REGOPER           ,"regoper"          ,',',"regoperout"      ,quote_string,dequote_string,{0},0,0},
 {PG_REGOPERATOR       ,"regoperator"      ,',',"regoperatorout"  ,quote_string,dequote_string,{0},0,0},
 {PG_REGPROC           ,"regproc"          ,',',"regprocout"      ,quote_string,dequote_string,{0},0,0},
 {PG_REGPROCEDURE      ,"regprocedure"     ,',',"regprocedureout" ,quote_string,dequote_string,{0},0,0},
 {PG_REGTYPE           ,"regtype"          ,',',"regtypeout"      ,quote_string,dequote_string,{0},0,0},
 {PG_RELTIME           ,"reltime"          ,',',"reltimeout"      ,quote_string,dequote_string,{0},0,0},
 {PG_SMGR              ,"smgr"             ,',',"smgrout"         ,quote_string,dequote_string,{0},0,0},
 {PG_TEXT              ,"text"             ,',',"textout"         ,quote_string,dequote_string,{SQL_LONGVARCHAR},1,0},
 {PG_TID               ,"tid"              ,',',"tidout"          ,quote_geom  ,dequote_string,{0},0,0},
 {PG_TIME              ,"time"             ,',',"time_out"        ,quote_string,dequote_string,{SQL_TYPE_TIME},1,0},
 {PG_TIMESTAMP         ,"timestamp"        ,',',"timestamp_out"   ,quote_string,dequote_string,{SQL_TIMESTAMP},1,0},
 {PG_TIMESTAMPTZ       ,"timestamptz"      ,',',"timestamptz_out" ,quote_string,dequote_string,{SQL_TYPE_TIMESTAMP_WITH_TIMEZONE},1,0},
 {PG_TIMETZ            ,"timetz"           ,',',"timetz_out"      ,quote_string,dequote_string,{0},0,0},
 {PG_TINTERVAL         ,"tinterval"        ,',',"tintervalout"    ,quote_string,dequote_string,{0},0,0},
 {PG_TRIGGER           ,"trigger"          ,',',"trigger_out"     ,quote_string,dequote_string,{0},0,0},
 {PG_TSQUERY           ,"tsquery"          ,',',"tsqueryout"      ,quote_string,dequote_string,{0},0,0},
 {PG_TSVECTOR          ,"tsvector"         ,',',"tsvectorout"     ,quote_string,dequote_string,{0},0,0},
 {PG_TXID_SNAPSHOT     ,"txid_snapshot"    ,',',"txid_snapshot_out",quote_string,dequote_string,{0},0,0},
 {PG_UNKNOWN           ,"unknown"          ,',',"unknownout"      ,quote_string,dequote_string,{0},0,0},
 {PG_UUID              ,"uuid"             ,',',"uuid_out"        ,quote_string,dequote_string,{0},0,0},
 {PG_VARBIT            ,"varbit"           ,',',"varbit_out"      ,quote_string,dequote_string,{0},0,0},
 {PG_VARCHAR           ,"varchar"          ,',',"varcharout"      ,quote_string,dequote_string,{SQL_VARCHAR},1,0},
 {PG_VOID              ,"void"             ,',',"void_out"        ,quote_string,dequote_string,{0},0,0},
 {PG_XID               ,"xid"              ,',',"xidout"          ,quote_string,dequote_string,{0},0,0},
 {PG_XML               ,"xml"              ,',',"xml_out"         ,quote_string,dequote_string,{0},0,0},
};

sql_type_info_t* pg_type_data(int sql_type)
{
	dTHX;

	switch(sql_type) {

		case PG_ABSTIMEARRAY:       return &pg_types[0];
		case PG_ACLITEMARRAY:       return &pg_types[1];
		case PG_BITARRAY:           return &pg_types[2];
		case PG_BOOLARRAY:          return &pg_types[3];
		case PG_BOXARRAY:           return &pg_types[4];
		case PG_BPCHARARRAY:        return &pg_types[5];
		case PG_BYTEAARRAY:         return &pg_types[6];
		case PG_CHARARRAY:          return &pg_types[7];
		case PG_CIDARRAY:           return &pg_types[8];
		case PG_CIDRARRAY:          return &pg_types[9];
		case PG_CIRCLEARRAY:        return &pg_types[10];
		case PG_CSTRINGARRAY:       return &pg_types[11];
		case PG_DATEARRAY:          return &pg_types[12];
		case PG_FLOAT4ARRAY:        return &pg_types[13];
		case PG_FLOAT8ARRAY:        return &pg_types[14];
		case PG_GTSVECTORARRAY:     return &pg_types[15];
		case PG_INETARRAY:          return &pg_types[16];
		case PG_INT2ARRAY:          return &pg_types[17];
		case PG_INT2VECTORARRAY:    return &pg_types[18];
		case PG_INT4ARRAY:          return &pg_types[19];
		case PG_INT8ARRAY:          return &pg_types[20];
		case PG_INTERVALARRAY:      return &pg_types[21];
		case PG_LINEARRAY:          return &pg_types[22];
		case PG_LSEGARRAY:          return &pg_types[23];
		case PG_MACADDRARRAY:       return &pg_types[24];
		case PG_MONEYARRAY:         return &pg_types[25];
		case PG_NAMEARRAY:          return &pg_types[26];
		case PG_NUMERICARRAY:       return &pg_types[27];
		case PG_OIDARRAY:           return &pg_types[28];
		case PG_OIDVECTORARRAY:     return &pg_types[29];
		case PG_PATHARRAY:          return &pg_types[30];
		case PG_POINTARRAY:         return &pg_types[31];
		case PG_POLYGONARRAY:       return &pg_types[32];
		case PG_REFCURSORARRAY:     return &pg_types[33];
		case PG_REGCLASSARRAY:      return &pg_types[34];
		case PG_REGCONFIGARRAY:     return &pg_types[35];
		case PG_REGDICTIONARYARRAY: return &pg_types[36];
		case PG_REGOPERARRAY:       return &pg_types[37];
		case PG_REGOPERATORARRAY:   return &pg_types[38];
		case PG_REGPROCARRAY:       return &pg_types[39];
		case PG_REGPROCEDUREARRAY:  return &pg_types[40];
		case PG_REGTYPEARRAY:       return &pg_types[41];
		case PG_RELTIMEARRAY:       return &pg_types[42];
		case PG_TEXTARRAY:          return &pg_types[43];
		case PG_TIDARRAY:           return &pg_types[44];
		case PG_TIMEARRAY:          return &pg_types[45];
		case PG_TIMESTAMPARRAY:     return &pg_types[46];
		case PG_TIMESTAMPTZARRAY:   return &pg_types[47];
		case PG_TIMETZARRAY:        return &pg_types[48];
		case PG_TINTERVALARRAY:     return &pg_types[49];
		case PG_TSQUERYARRAY:       return &pg_types[50];
		case PG_TSVECTORARRAY:      return &pg_types[51];
		case PG_TXID_SNAPSHOTARRAY: return &pg_types[52];
		case PG_UUIDARRAY:          return &pg_types[53];
		case PG_VARBITARRAY:        return &pg_types[54];
		case PG_VARCHARARRAY:       return &pg_types[55];
		case PG_XIDARRAY:           return &pg_types[56];
		case PG_XMLARRAY:           return &pg_types[57];
		case PG_ABSTIME:            return &pg_types[58];
		case PG_ACLITEM:            return &pg_types[59];
		case PG_ANY:                return &pg_types[60];
		case PG_ANYARRAY:           return &pg_types[61];
		case PG_ANYELEMENT:         return &pg_types[62];
		case PG_ANYENUM:            return &pg_types[63];
		case PG_ANYNONARRAY:        return &pg_types[64];
		case PG_BIT:                return &pg_types[65];
		case PG_BOOL:               return &pg_types[66];
		case PG_BOX:                return &pg_types[67];
		case PG_BPCHAR:             return &pg_types[68];
		case PG_BYTEA:              return &pg_types[69];
		case PG_CHAR:               return &pg_types[70];
		case PG_CID:                return &pg_types[71];
		case PG_CIDR:               return &pg_types[72];
		case PG_CIRCLE:             return &pg_types[73];
		case PG_CSTRING:            return &pg_types[74];
		case PG_DATE:               return &pg_types[75];
		case PG_FLOAT4:             return &pg_types[76];
		case PG_FLOAT8:             return &pg_types[77];
		case PG_GTSVECTOR:          return &pg_types[78];
		case PG_INET:               return &pg_types[79];
		case PG_INT2:               return &pg_types[80];
		case PG_INT2VECTOR:         return &pg_types[81];
		case PG_INT4:               return &pg_types[82];
		case PG_INT8:               return &pg_types[83];
		case PG_INTERNAL:           return &pg_types[84];
		case PG_INTERVAL:           return &pg_types[85];
		case PG_LANGUAGE_HANDLER:   return &pg_types[86];
		case PG_LINE:               return &pg_types[87];
		case PG_LSEG:               return &pg_types[88];
		case PG_MACADDR:            return &pg_types[89];
		case PG_MONEY:              return &pg_types[90];
		case PG_NAME:               return &pg_types[91];
		case PG_NUMERIC:            return &pg_types[92];
		case PG_OID:                return &pg_types[93];
		case PG_OIDVECTOR:          return &pg_types[94];
		case PG_OPAQUE:             return &pg_types[95];
		case PG_PATH:               return &pg_types[96];
		case PG_PG_ATTRIBUTE:       return &pg_types[97];
		case PG_PG_CLASS:           return &pg_types[98];
		case PG_PG_PROC:            return &pg_types[99];
		case PG_PG_TYPE:            return &pg_types[100];
		case PG_POINT:              return &pg_types[101];
		case PG_POLYGON:            return &pg_types[102];
		case PG_RECORD:             return &pg_types[103];
		case PG_REFCURSOR:          return &pg_types[104];
		case PG_REGCLASS:           return &pg_types[105];
		case PG_REGCONFIG:          return &pg_types[106];
		case PG_REGDICTIONARY:      return &pg_types[107];
		case PG_REGOPER:            return &pg_types[108];
		case PG_REGOPERATOR:        return &pg_types[109];
		case PG_REGPROC:            return &pg_types[110];
		case PG_REGPROCEDURE:       return &pg_types[111];
		case PG_REGTYPE:            return &pg_types[112];
		case PG_RELTIME:            return &pg_types[113];
		case PG_SMGR:               return &pg_types[114];
		case PG_TEXT:               return &pg_types[115];
		case PG_TID:                return &pg_types[116];
		case PG_TIME:               return &pg_types[117];
		case PG_TIMESTAMP:          return &pg_types[118];
		case PG_TIMESTAMPTZ:        return &pg_types[119];
		case PG_TIMETZ:             return &pg_types[120];
		case PG_TINTERVAL:          return &pg_types[121];
		case PG_TRIGGER:            return &pg_types[122];
		case PG_TSQUERY:            return &pg_types[123];
		case PG_TSVECTOR:           return &pg_types[124];
		case PG_TXID_SNAPSHOT:      return &pg_types[125];
		case PG_UNKNOWN:            return &pg_types[126];
		case PG_UUID:               return &pg_types[127];
		case PG_VARBIT:             return &pg_types[128];
		case PG_VARCHAR:            return &pg_types[129];
		case PG_VOID:               return &pg_types[130];
		case PG_XID:                return &pg_types[131];
		case PG_XML:                return &pg_types[132];
		default: return NULL;
	}
}

static sql_type_info_t sql_types[] = {
 {SQL_BOOLEAN,"SQL_BOOLEAN",',', "none", quote_bool, dequote_bool, {PG_BOOL}, 1, 0},
 {SQL_CHAR,"SQL_CHAR",',', "none", quote_string, dequote_char, {PG_BPCHAR}, 1, 0},
 {SQL_VARBINARY,"SQL_VARBINARY",',', "none", quote_bytea, dequote_bytea, {PG_BYTEA}, 1, 0},
 {SQL_CHAR,"SQL_CHAR",',', "none", quote_string, dequote_char, {PG_CHAR}, 1, 0},
 {SQL_TYPE_DATE,"SQL_TYPE_DATE",',', "none", quote_string, dequote_string, {PG_DATE}, 1, 0},
 {SQL_FLOAT,"SQL_FLOAT",',', "none", null_quote, null_dequote, {PG_FLOAT8}, 1, 2},
 {SQL_DOUBLE,"SQL_DOUBLE",',', "none", null_quote, null_dequote, {PG_FLOAT8}, 1, 2},
 {SQL_NUMERIC,"SQL_NUMERIC",',', "none", null_quote, null_dequote, {PG_FLOAT8}, 1, 2},
 {SQL_REAL,"SQL_REAL",',', "none", null_quote, null_dequote, {PG_FLOAT8}, 1, 2},
 {SQL_SMALLINT,"SQL_SMALLINT",',', "none", null_quote, null_dequote, {PG_INT2}, 1, 1},
 {SQL_TINYINT,"SQL_TINYINT",',', "none", null_quote, null_dequote, {PG_INT2}, 1, 1},
 {SQL_INTEGER,"SQL_INTEGER",',', "none", null_quote, null_dequote, {PG_INT4}, 1, 1},
 {SQL_BIGINT,"SQL_BIGINT",',', "none", null_quote, null_dequote, {PG_INT8}, 1, 0},
 {SQL_VARCHAR,"SQL_VARCHAR",',', "none", null_quote, null_dequote, {PG_NAME}, 1, 0},
 {SQL_DECIMAL,"SQL_DECIMAL",',', "none", null_quote, null_dequote, {PG_NUMERIC}, 1, 2},
 {SQL_LONGVARCHAR,"SQL_LONGVARCHAR",',', "none", quote_string, dequote_string, {PG_TEXT}, 1, 0},
 {SQL_TYPE_TIME,"SQL_TYPE_TIME",',', "none", quote_string, dequote_string, {PG_TIME}, 1, 0},
 {SQL_TIMESTAMP,"SQL_TIMESTAMP",',', "none", quote_string, dequote_string, {PG_TIMESTAMP}, 1, 0},
 {SQL_TYPE_TIMESTAMP,"SQL_TYPE_TIMESTAMP",',', "none", quote_string, dequote_string, {PG_TIMESTAMP}, 1, 0},
 {SQL_TYPE_TIMESTAMP_WITH_TIMEZONE,"SQL_TYPE_TIMESTAMP_WITH_TIMEZONE",',', "none", quote_string, dequote_string, {PG_TIMESTAMPTZ}, 1, 0},
 {SQL_TYPE_TIME_WITH_TIMEZONE,"SQL_TYPE_TIME_WITH_TIMEZONE",',', "none", quote_string, dequote_string, {PG_TIMESTAMPTZ}, 1, 0},
 {SQL_VARCHAR,"SQL_VARCHAR",',', "none", quote_string, dequote_string, {PG_VARCHAR}, 1, 0},
};

sql_type_info_t* sql_type_data(int sql_type)
{
	dTHX;

	switch(sql_type) {
		case SQL_BOOLEAN:                      return &sql_types[0];
		case SQL_VARBINARY:                    return &sql_types[2];
		case SQL_CHAR:                         return &sql_types[3];
		case SQL_TYPE_DATE:                    return &sql_types[4];
		case SQL_FLOAT:                        return &sql_types[5];
		case SQL_DOUBLE:                       return &sql_types[6];
		case SQL_NUMERIC:                      return &sql_types[7];
		case SQL_REAL:                         return &sql_types[8];
		case SQL_SMALLINT:                     return &sql_types[9];
		case SQL_TINYINT:                      return &sql_types[10];
		case SQL_INTEGER:                      return &sql_types[11];
		case SQL_BIGINT:                       return &sql_types[12];
		case SQL_DECIMAL:                      return &sql_types[14];
		case SQL_LONGVARCHAR:                  return &sql_types[15];
		case SQL_TYPE_TIME:                    return &sql_types[16];
		case SQL_TIMESTAMP:                    return &sql_types[17];
		case SQL_TYPE_TIMESTAMP:               return &sql_types[18];
		case SQL_TYPE_TIMESTAMP_WITH_TIMEZONE: return &sql_types[19];
		case SQL_TYPE_TIME_WITH_TIMEZONE:      return &sql_types[20];
		case SQL_VARCHAR:                      return &sql_types[21];
		default: return NULL;
	}
}

/*
#!perl

## Autogenerate all type information and populate types.c and types.h

## You should only run this if you are developing DBD::Pg and 
## understand what this script does

## Usage: perl -x $0 "path-to-pgsql-source"

use strict; use warnings; use Data::Dumper;

my $arg = shift || die "Usage: $0 path-to-pgsql-source\n";

-d $arg or die qq{Sorry, but "$arg" is not a directory!\n};

my $file = "$arg/src/include/catalog/pg_type.h";

open(F, $file) or die qq{Could not open file "$file": $!\n};
my $maxlen = 1;
my %pgtype;
my $thisname = 0;
while(<F>) {
	if (/^DATA\(insert OID\s+=\s+(\d+)\s+\(\s+(\S+)\s+\S+ \S+\s+\S+\s+[tf]\s+. ([tf]) \\(\d+) (\d+)\s+(\d+) (\d+) (\S+) (\S+) (\S+) (\S+)/o) {
		my ($oid,$name,$typedef,$delim,$typrelid,$typelem,$typarray,$tin,$tout,$bin,$bout) = 
			($1,$2,$3,chr(oct($4)),$5,$6,$7,$8,$9,$10,$11);
		die "Duplicated OID $oid!: $_\n" if exists $pgtype{$oid};
		$pgtype{$name} = {
			oid     => $oid,
			delim   => $delim,
			textin  => $tin,
			textout => $tout,
			binin   => $bin,
			binout  => $bout,
			quote   => 'quote_string',
            dequote => 'dequote_string',
			define  => 'PG_' . uc($name),
			sql     => 0,
            sqlc    => 0,
			svtype  => 0,
		};
		length($name) > $maxlen and $maxlen = length($name);
		$thisname = $name;
		## Special hack for array types
		if ($tin =~ /^array/ and $name =~ /^_/) {
			$pgtype{$name}{define} = 'PG' . uc $name . 'ARRAY';
		}
	}
	elsif (/^DESCR\("(.+?)"/) {
		$pgtype{$thisname}{description} = $1;
	}
	elsif (/^DATA/) {
		die "Bad line: $_\n";
   }
}
close(F);

my ($oldfh,$newfh);

## Rewrite types.h
$file = "types.h";
open $newfh, '>', "$file.tmp" or die qq{Could not create "$file.tmp": $!\n};

print $newfh '/' . qq{*
	Do not edit this file directly - it is generated by types.c
*} . qq{/

typedef struct sql_type_info {
	int	    type_id;
	char*   type_name;
    char    array_delimeter;
    char*   arrayout;
	char* 	(*quote)();
	void	(*dequote)();
	union	{
			int pg;
			int sql;
	} type;
	bool	bind_ok;
    int     svtype;
} sql_type_info_t;

sql_type_info_t* pg_type_data(int);
sql_type_info_t* sql_type_data(int);

};

$maxlen += 5;
for (sort {
		$pgtype{$a}{define} =~ /ARRAY/ <=> $pgtype{$b}{define} =~ /ARRAY/
		or $pgtype{$a}{define} cmp $pgtype{$b}{define}
	} keys %pgtype) {
	printf $newfh "#define %${maxlen}s  $pgtype{$_}{oid}\n", $pgtype{$_}{define};
}

print $newfh "\n";
close $newfh;
system("mv $file.tmp $file");
print "Wrote $file\n";

## Rewrite Pg.xs
$file = 'Pg.xs';
open $oldfh, '<', $file or die qq{Could not open "$file": $!\n};
open $newfh, '>', "$file.tmp" or die qq{Could not write to "$file.tmp": $!\n};
my $step = 0;
while (<$oldfh>) {
	if (0 == $step) {
		if (/ALIAS:/) {
			print $newfh $_;
			$step = 1;
			for (sort { $pgtype{$a}{define} cmp $pgtype{$b}{define} } keys %pgtype) {
				printf $newfh "\t%-${maxlen}s = $pgtype{$_}{oid}\n", $pgtype{$_}{define};
			}
			printf $newfh "\n\t%-${maxlen}s = 1\n", "PG_ASYNC";
			printf $newfh "\t%-${maxlen}s = 2\n", "PG_OLDQUERY_CANCEL";
			printf $newfh "\t%-${maxlen}s = 4\n\n", "PG_OLDQUERY_WAIT";
			next;
		}
	}
	elsif (1 == $step) {
		next unless /CODE:/;
		$step = 2;
	}
	print $newfh $_;
}
close $newfh;
close $oldfh;
system("mv $file.tmp $file");
print "Wrote $file\n";


## Rewrite Pg.pm
$file = 'Pg.pm';
open $oldfh, '<', $file or die qq{Could not open "$file": $!\n};
open $newfh, '>', "$file.tmp" or die qq{Could not write to "$file.tmp": $!\n};
$step = 0;
while (<$oldfh>) {
	if (0 == $step) {
		if (/pg_types/) {
			chomp;
			print $newfh $_;
			$step = 0;
			for (sort { $pgtype{$a}{define} cmp $pgtype{$b}{define} } keys %pgtype) {
				printf $newfh "%s$pgtype{$_}{define}", !($step++ % 5) ? "\n\t\t\t" : " ";
			}
			print $newfh "\n";
			$step = 1;
			next;
		}
	}
	elsif (1 == $step) {
		next unless /\]/;
		$step = 2;
	}
	elsif (2 == $step) {
		if (/data types exported/) {
			print $newfh $_;
			$step = 0;
			for (sort { $pgtype{$a}{define} cmp $pgtype{$b}{define} } keys %pgtype) {
				printf $newfh "%s$pgtype{$_}{define}", !($step++ % 6) ? "\n" : " ";
			}
			print $newfh "\n\n";			
			$step = 3;
			next;
		  }
	}
	elsif (3 == $step) {
		next unless /sticky/;
		$step = 4;
	}
	print $newfh $_;
}
close $newfh;
close $oldfh;
system("mv $file.tmp $file");
print "Wrote $file\n";

## Rewrite 01constants.t
$file = 't/01constants.t';
open $oldfh, '<', $file or die qq{Could not open "$file": $!\n};
open $newfh, '>', "$file.tmp" or die qq{Could not write to "$file.tmp": $!\n};
$step = 0;
while (<$oldfh>) {
	if (0 == $step) {
		if (/^is/) {
			for (sort { $pgtype{$a}{define} cmp $pgtype{$b}{define} } keys %pgtype) {
				printf $newfh qq{is(%-*s, %5s, '%s returns correct value');\n},
					3+$maxlen, $pgtype{$_}{define}, $pgtype{$_}{oid}, $pgtype{$_}{define};
			}
			print $newfh "\n";
			$step = 1;
			last;
		}
	}
	print $newfh $_;
}
close $newfh;
close $oldfh;
system("mv $file.tmp $file");
print "Wrote $file\n";

## Rewrite 99_pod.t
$file = 't/99_pod.t';
open $oldfh, '<', $file or die qq{Could not open "$file": $!\n};
open $newfh, '>', "$file.tmp" or die qq{Could not write to "$file.tmp": $!\n};
$step = 0;
while (<$oldfh>) {
	if (0 == $step) {
		if (/types.c/) {
			print $newfh $_;
			for (sort { $pgtype{$a}{define} cmp $pgtype{$b}{define} } keys %pgtype) {
				print $newfh "\t\t qr{$pgtype{$_}{define}},\n";
			}
			print $newfh "\n";
			$step = 1;
			next;
		}
	}
	elsif (1 == $step) {
		next unless /;/;
		$step = 2;
	}
	print $newfh $_;
}
close $newfh;
close $oldfh;
system("mv $file.tmp $file");
print "Wrote $file\n";


## Rewrite types.c
$file = "types.c";
open $newfh, '>', "$file.tmp" or die qq{Could not write to "$file.tmp": $!\n};

print $newfh 
'/' . q{*

   $Id: types.c 10871 2008-03-03 16:50:04Z turnstep $

   Copyright (c) 2003-2008 Greg Sabino Mullane and others: see the Changes file
   
   You may distribute under the terms of either the GNU General Public
   License or the Artistic License, as specified in the Perl README file.

*} . "/\n\n/" . qq{*
	 Please do not edit the C portions of this file directly. 
	 It is automatically generated by the enclosed Perl script.
*} . qq{/


#include "Pg.h"

};

## Read in our DATA information to make things more specific
while (<DATA>) {
	last if /^__END__/;
	next unless /^[a-z]/o;
	chomp;
	my ($name,$q,$dq,$sql,$sqlc,$svtype) = split / +/ => $_;
	if (!exists $pgtype{$name}) {
		die qq{Type ($name) was not found in source file!\n};
	}
	$pgtype{$name}{quote}   = $q;
	$pgtype{$name}{dequote} = $dq;
	$pgtype{$name}{sql}     = $sql;
	$pgtype{$name}{sqlc}    = $sqlc;
	$pgtype{$name}{svtype}  = $svtype;
	## For arrays, we want to echo the base svtype
	if ($svtype and exists $pgtype{"_$name"} and $pgtype{"_$name"}{textin} =~ /array/) {
      $pgtype{"_$name"}{svtype} = $svtype;
	}
}


## Map all types into a sql_type_info structure

print $newfh "static sql_type_info_t pg_types[] = {\n";

my %pos;
my $item = 0;
for my $name (sort {$a cmp $b } keys %pgtype) {
	## {BOOLOID, "bool", ",", "boolout", quote_bool, dequote_bool, {SQL_BOOLEAN}, DBDPG_TRUE},
	my $t = $pgtype{$name};
	my ($sqltype,$quote,$dequote) = (0,0,0);
	## INT2OID, int2, null_quote, null_dequote, SQL_SMALLINT|SQL_TINYINT, 1
	(my $sql = $t->{sql}) =~ s#^(\w+).*#$1#;

	printf $newfh qq! {%-*s,%-*s,'%s',%-18s,%-12s,%-14s,\{%s\},%d,%d\},\n!,
		$maxlen, $t->{define}, $maxlen-2, "\"$name\"", $t->{delim}, "\"$t->{textout}\"", $t->{quote}, $t->{dequote}, $sql, $t->{sqlc}, $t->{svtype};
	$pos{$name} = $item++;
}

print $newfh "\};\n\n";

print $newfh 
"sql_type_info_t* pg_type_data(int sql_type)
{
\tdTHX;

\tswitch(sql_type) {
\n";

for my $name (sort { $a cmp $b } keys %pgtype) {
	printf $newfh qq{\t\tcase %-*s return \&pg_types\[%d\];\n}, 1+$maxlen, "$pgtype{$name}{define}:", $pos{$name};
}

print $newfh "\t\tdefault: return NULL;\n\t\}\n\}\n\n";

print $newfh "static sql_type_info_t sql_types[] = \{\n";

undef %pos;
$item=0;
$maxlen = 1;
for my $name (sort { $a cmp $b } keys %pgtype) {
	next unless $pgtype{$name}{sql};
	for my $sql (split /\|/ => $pgtype{$name}{sql}) {
		## {SQL_VARCHAR, "SQL_VARCHAR", quote_string, dequote_string, {VARCHAROID}, DBDPG_TRUE },
		printf $newfh qq! {%s,"%s",',', "none", $pgtype{$name}{quote}, $pgtype{$name}{dequote}, \{$pgtype{$name}{define}\}, 1, $pgtype{$name}{svtype}\},\n!, $sql, $sql;
		$maxlen = length $sql if length $sql > $maxlen;
		$pos{$sql} = $item++;
	}
}
print $newfh "\};\n\n";

print $newfh "sql_type_info_t* sql_type_data(int sql_type)\n\{\n";

print $newfh "\tswitch(sql_type) \{\n";
for (sort { $pos{$a} <=> $pos{$b} } keys %pos) {
	printf $newfh qq{\t\tcase %-*s return \&sql_types\[%d\];\n}, 1+$maxlen, "$_:", $pos{$_};
}
print $newfh "\t\tdefault: return NULL;\n\t\}\n\}\n\n/" ."*\n";

seek(DATA,0,0);
1 while <DATA> !~ /!perl/;
print $newfh "#!perl\n";
while (<DATA>) { print $newfh $_; }
close($newfh);
system("mv $file.tmp $file");
print "Wrote $file\n";

exit;
__DATA__
## Format: for each type, there are 5 items, space separated:
## 1. The given name, from the Postgres source code (pg_type.h)
## 2. The function name we use to do the quoting, or 0 if we do not bind it
## 3. The function name we use for DE-quoting
## 4. The closest SQL_ datatype, or 0 if there is none. May be multiple, separated by |
## 5. Whether this is the one to use for reverse SQL_ type mapping
## 6. What type of SV we can put this in: 1: IV 2: NV

## Simple quoting (e.g. text) - wrap in single quotes, escape backslashes and apostrophes
## This is also the default action for types not specified here
varchar  quote_string  dequote_string  SQL_VARCHAR               1  0
text     quote_string  dequote_string  SQL_LONGVARCHAR           1  0
char     quote_string  dequote_char    SQL_CHAR                  0  0
bpchar   quote_string  dequote_char    SQL_CHAR                  1  0
cid      quote_string  dequote_string  0                         0  0

## Things that get no quoting at all (e.g. numbers)
int2     null_quote    null_dequote    SQL_SMALLINT|SQL_TINYINT  1  1
int4     null_quote    null_dequote    SQL_INTEGER               1  1
int8     null_quote    null_dequote    SQL_BIGINT                1  0
float4   null_quote    null_dequote    0                         1  2
float8   null_quote    null_dequote    SQL_FLOAT|SQL_DOUBLE|SQL_NUMERIC|SQL_REAL 1  2
numeric  null_quote    null_dequote    SQL_DECIMAL               1  2
oid      null_quote    null_dequote    0                         0  1
name     null_quote    null_dequote    SQL_VARCHAR               0  0 ## XXX Wrong

## Boolean
bool     quote_bool    dequote_bool    SQL_BOOLEAN               1  0

## Geometric types
point    quote_geom    dequote_string  0                         0  0
line     quote_geom    dequote_string  0                         0  0
lseg     quote_geom    dequote_string  0                         0  0
box      quote_geom    dequote_string  0                         0  0
path     quote_path    dequote_string  0                         0  0
polygon  quote_geom    dequote_string  0                         0  0
circle   quote_circle  dequote_string  0                         0  0

## Similar enough to geometric types that we use the same quoting rules
tid      quote_geom    dequote_string  0                         0  0

## Binary - very different quoting rules
bytea    quote_bytea   dequote_bytea   SQL_VARBINARY             1  0

## Time and date
date        quote_string  dequote_string  SQL_TYPE_DATE                     1  0
time        quote_string  dequote_string  SQL_TYPE_TIME                     1  0
timestamp   quote_string  dequote_string  SQL_TIMESTAMP|SQL_TYPE_TIMESTAMP  1  0
timestamptz quote_string  dequote_string  SQL_TYPE_TIMESTAMP_WITH_TIMEZONE|SQL_TYPE_TIME_WITH_TIMEZONE       1  0

__END__

*/


