/*
   $Id: types.c 10780 2008-02-18 02:18:58Z 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(sql_type)
        int sql_type;
{
        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(sql_type)
        int sql_type;
{       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{/
#ifndef DBDPGTYEPSH
#define DBDPGTYEPSH
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 += 4;
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#endif\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 10780 2008-02-18 02:18:58Z 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!\t{%s, "%s", '%s', "%s", %s, %s, \{%s\}, %d, %d\},\n!,
                $t->{define}, $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(sql_type)
\tint sql_type;
{
\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{\t\{$sql, "$sql", ',', "none", $pgtype{$name}{quote}, $pgtype{$name}{dequote}, \{$pgtype{$name}{define}\}, 1, $pgtype{$name}{svtype}\},\n};
                $maxlen = length $sql if length $sql > $maxlen;
                $pos{$sql} = $item++;
        }
}
print $newfh "\};\n\n";
print $newfh "sql_type_info_t* sql_type_data(sql_type)\n\tint sql_type;\n\{\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__
*/