/*
* Transfer octet length.
*/
Int4
pgtype_transfer_octet_length(StatementClass *stmt, OID type, int column_size)
{
ConnectionClass *conn = SC_get_conn(stmt);
int coef = 1;
Int4 maxvarc;
switch (type)
{
case PG_TYPE_VARCHAR:
case PG_TYPE_BPCHAR:
case PG_TYPE_TEXT:
if (SQL_NO_TOTAL == column_size)
return column_size;
#ifdef UNICODE_SUPPORT
if (CC_is_in_unicode_driver(conn))
return column_size * WCLEN;
#endif /* UNICODE_SUPPORT */
/* after 7.2 */
if (PG_VERSION_GE(conn, 7.2))
coef = conn->mb_maxbyte_per_char;
if (coef < 2 && (conn->connInfo).lf_conversion)
/* CR -> CR/LF */
coef = 2;
if (coef == 1)
return column_size;
maxvarc = conn->connInfo.drivers.max_varchar_size;
if (column_size <= maxvarc && column_size * coef > maxvarc)
return maxvarc;
return coef * column_size;
case PG_TYPE_BYTEA:
return column_size;
default:
if (type == conn->lobj_type)
return column_size;
}
return -1;
}
Int4
pgtype_attr_transfer_octet_length(const ConnectionClass *conn, OID type, int atttypmod, int handle_unknown_size_as)
{
int coef = 1;
Int4 maxvarc, column_size;
switch (type)
{
case PG_TYPE_VARCHAR:
case PG_TYPE_BPCHAR:
case PG_TYPE_TEXT:
case PG_TYPE_UNKNOWN:
column_size = pgtype_attr_column_size(conn, type, atttypmod, PG_ADT_UNSET, handle_unknown_size_as);
if (SQL_NO_TOTAL == column_size)
return column_size;
#ifdef UNICODE_SUPPORT
if (CC_is_in_unicode_driver(conn))
return column_size * WCLEN;
#endif /* UNICODE_SUPPORT */
coef = conn->mb_maxbyte_per_char;
if (coef < 2 && (conn->connInfo).lf_conversion)
/* CR -> CR/LF */
coef = 2;
if (coef == 1)
return column_size;
maxvarc = conn->connInfo.drivers.max_varchar_size;
if (column_size <= maxvarc && column_size * coef > maxvarc)
return maxvarc;
return coef * column_size;
case PG_TYPE_BYTEA:
return pgtype_attr_column_size(conn, type, atttypmod, PG_ADT_UNSET, handle_unknown_size_as);
default:
if (type == conn->lobj_type)
return pgtype_attr_column_size(conn, type, atttypmod, PG_ADT_UNSET, handle_unknown_size_as);
}
return -1;
}
/*
* This function works under Windows or Unicode case only.
* Simply returns NULL under other OSs.
*/
const char * get_environment_encoding(const ConnectionClass *conn, const char *setenc, const char *currenc, BOOL bStartup)
{
const char *wenc = NULL;
#ifdef WIN32
int acp;
#endif /* WIN32 */
#ifdef UNICODE_SUPPORT
if (CC_is_in_unicode_driver(conn))
return "UTF8";
#endif /* UNICODE_SUPPORT */
if (setenc && stricmp(setenc, OTHER_STRING))
return setenc;
#ifdef WIN32
acp = GetACP();
if (acp >= 1251 && acp <= 1258)
{
if (bStartup ||
stricmp(currenc, "SQL_ASCII") == 0)
return wenc;
}
switch (acp)
{
case 932:
wenc = "SJIS";
break;
case 936:
if (!bStartup && PG_VERSION_GT(conn, 7.2))
wenc = "GBK";
break;
case 949:
if (!bStartup && PG_VERSION_GT(conn, 7.2))
wenc = "UHC";
break;
case 950:
wenc = "BIG5";
break;
case 1250:
wenc = "WIN1250";
break;
case 1251:
wenc = "WIN1251";
break;
case 1256:
if (PG_VERSION_GE(conn, 7.3))
wenc = "WIN1256";
break;
case 1252:
if (strnicmp(currenc, "LATIN", 5) == 0)
break;
if (PG_VERSION_GE(conn, 8.1))
wenc = "WIN1252";
else
wenc = "LATIN1";
break;
case 1258:
if (PG_VERSION_GE(conn, 8.1))
wenc = "WIN1258";
break;
case 1253:
if (PG_VERSION_GE(conn, 8.2))
wenc = "WIN1253";
break;
case 1254:
if (PG_VERSION_GE(conn, 8.2))
wenc = "WIN1254";
break;
case 1255:
if (PG_VERSION_GE(conn, 8.2))
wenc = "WIN1255";
break;
case 1257:
if (PG_VERSION_GE(conn, 8.2))
wenc = "WIN1257";
break;
}
#endif /* WIN32 */
return wenc;
}
Int4
getCharColumnSize(StatementClass *stmt, OID type, int col, int handle_unknown_size_as)
{
CSTR func = "getCharColumnSize";
int p = -1, attlen = -1, adtsize = -1, maxsize;
QResultClass *result;
ConnectionClass *conn = SC_get_conn(stmt);
ConnInfo *ci = &(conn->connInfo);
mylog("%s: type=%d, col=%d, unknown = %d\n", func, type, col, handle_unknown_size_as);
/* Assign Maximum size based on parameters */
switch (type)
{
case PG_TYPE_TEXT:
if (ci->drivers.text_as_longvarchar)
maxsize = ci->drivers.max_longvarchar_size;
else
maxsize = ci->drivers.max_varchar_size;
break;
case PG_TYPE_VARCHAR:
case PG_TYPE_BPCHAR:
maxsize = ci->drivers.max_varchar_size;
break;
default:
if (ci->drivers.unknowns_as_longvarchar)
maxsize = ci->drivers.max_longvarchar_size;
else
maxsize = ci->drivers.max_varchar_size;
break;
}
#ifdef UNICODE_SUPPORT
if (CC_is_in_unicode_driver(conn) &&
isSqlServr() &&
maxsize > 4000)
maxsize = 4000;
#endif /* UNICODE_SUPPORT */
if (maxsize == TEXT_FIELD_SIZE + 1) /* magic length for testing */
{
if (PG_VERSION_GE(SC_get_conn(stmt), 7.1))
maxsize = 0;
else
maxsize = TEXT_FIELD_SIZE;
}
/*
* Static ColumnSize (i.e., the Maximum ColumnSize of the datatype) This
* has nothing to do with a result set.
*/
if (col < 0)
return maxsize;
if (result = SC_get_Curres(stmt), NULL == result)
return maxsize;
/*
* Catalog Result Sets -- use assigned column width (i.e., from
* set_tuplefield_string)
*/
adtsize = QR_get_fieldsize(result, col);
if (stmt->catalog_result)
{
if (adtsize > 0)
return adtsize;
return maxsize;
}
p = QR_get_display_size(result, col); /* longest */
attlen = QR_get_atttypmod(result, col);
/* Size is unknown -- handle according to parameter */
if (attlen > 0) /* maybe the length is known */
{
if (attlen >= p)
return attlen;
switch (type)
{
case PG_TYPE_VARCHAR:
case PG_TYPE_BPCHAR:
#if (ODBCVER >= 0x0300)
return attlen;
#else
if (CC_is_in_unicode_driver(conn) || conn->ms_jet)
return attlen;
return p;
#endif /* ODBCVER */
}
}
/* The type is really unknown */
switch (handle_unknown_size_as)
{
case UNKNOWNS_AS_DONTKNOW:
return -1;
case UNKNOWNS_AS_LONGEST:
mylog("%s: LONGEST: p = %d\n", func, p);
if (p > 0)
return p;
break;
case UNKNOWNS_AS_MAX:
break;
default:
return -1;
}
if (maxsize <= 0)
return maxsize;
switch (type)
{
case PG_TYPE_BPCHAR:
case PG_TYPE_VARCHAR:
case PG_TYPE_TEXT:
return maxsize;
}
if (p > maxsize)
maxsize = p;
return maxsize;
}
SQLSMALLINT
pgtype_to_ctype(StatementClass *stmt, OID type)
{
ConnectionClass *conn = SC_get_conn(stmt);
ConnInfo *ci = &(conn->connInfo);
#if (ODBCVER >= 0x0300)
EnvironmentClass *env = (EnvironmentClass *) CC_get_env(conn);
#endif /* ODBCVER */
switch (type)
{
case PG_TYPE_INT8:
#if (ODBCVER >= 0x0300)
if (!conn->ms_jet)
return ALLOWED_C_BIGINT;
#endif /* ODBCVER */
return SQL_C_CHAR;
case PG_TYPE_NUMERIC:
return SQL_C_CHAR;
case PG_TYPE_INT2:
return SQL_C_SSHORT;
case PG_TYPE_OID:
case PG_TYPE_XID:
return SQL_C_ULONG;
case PG_TYPE_INT4:
return SQL_C_SLONG;
case PG_TYPE_FLOAT4:
return SQL_C_FLOAT;
case PG_TYPE_FLOAT8:
return SQL_C_DOUBLE;
case PG_TYPE_DATE:
#if (ODBCVER >= 0x0300)
if (EN_is_odbc3(env))
return SQL_C_TYPE_DATE;
#endif /* ODBCVER */
return SQL_C_DATE;
case PG_TYPE_TIME:
#if (ODBCVER >= 0x0300)
if (EN_is_odbc3(env))
return SQL_C_TYPE_TIME;
#endif /* ODBCVER */
return SQL_C_TIME;
case PG_TYPE_ABSTIME:
case PG_TYPE_DATETIME:
case PG_TYPE_TIMESTAMP_NO_TMZONE:
case PG_TYPE_TIMESTAMP:
#if (ODBCVER >= 0x0300)
if (EN_is_odbc3(env))
return SQL_C_TYPE_TIMESTAMP;
#endif /* ODBCVER */
return SQL_C_TIMESTAMP;
case PG_TYPE_MONEY:
return SQL_C_FLOAT;
case PG_TYPE_BOOL:
return ci->drivers.bools_as_char ? SQL_C_CHAR : SQL_C_BIT;
case PG_TYPE_BYTEA:
return SQL_C_BINARY;
case PG_TYPE_LO_UNDEFINED:
return SQL_C_BINARY;
#ifdef UNICODE_SUPPORT
case PG_TYPE_BPCHAR:
case PG_TYPE_VARCHAR:
case PG_TYPE_TEXT:
if (CC_is_in_unicode_driver(conn)
#ifdef NOT_USED
&& ! stmt->catalog_result
#endif /* NOT USED */
)
return SQL_C_WCHAR;
return SQL_C_CHAR;
#endif /* UNICODE_SUPPORT */
case PG_TYPE_UUID:
#if (ODBCVER >= 0x0350)
if (!conn->ms_jet)
return SQL_C_GUID;
#endif /* ODBCVER */
return SQL_C_CHAR;
default:
/* hack until permanent type is available */
if (type == stmt->hdbc->lobj_type)
return SQL_C_BINARY;
/* Experimental, Does this work ? */
#ifdef EXPERIMENTAL_CURRENTLY
if (ALLOW_WCHAR(conn))
return SQL_C_WCHAR;
#endif /* EXPERIMENTAL_CURRENTLY */
return SQL_C_CHAR;
}
}
/*
* There are two ways of calling this function:
*
* 1. When going through the supported PG types (SQLGetTypeInfo)
*
* 2. When taking any type id (SQLColumns, SQLGetData)
*
* The first type will always work because all the types defined are returned here.
* The second type will return a default based on global parameter when it does not
* know. This allows for supporting
* types that are unknown. All other pg routines in here return a suitable default.
*/
SQLSMALLINT
pgtype_to_concise_type(StatementClass *stmt, OID type, int col)
{
ConnectionClass *conn = SC_get_conn(stmt);
ConnInfo *ci = &(conn->connInfo);
#if (ODBCVER >= 0x0300)
EnvironmentClass *env = (EnvironmentClass *) CC_get_env(conn);
#endif /* ODBCVER */
switch (type)
{
case PG_TYPE_CHAR:
case PG_TYPE_CHAR2:
case PG_TYPE_CHAR4:
case PG_TYPE_CHAR8:
return ALLOW_WCHAR(conn) ? SQL_WCHAR : SQL_CHAR;
case PG_TYPE_NAME:
return ALLOW_WCHAR(conn) ? SQL_WVARCHAR : SQL_VARCHAR;
#ifdef UNICODE_SUPPORT
case PG_TYPE_BPCHAR:
if (col >= 0 &&
getCharColumnSize(stmt, type, col, UNKNOWNS_AS_MAX) > ci->drivers.max_varchar_size)
return ALLOW_WCHAR(conn) ? SQL_WLONGVARCHAR : SQL_LONGVARCHAR;
return ALLOW_WCHAR(conn) ? SQL_WCHAR : SQL_CHAR;
case PG_TYPE_VARCHAR:
if (col >= 0 &&
getCharColumnSize(stmt, type, col, UNKNOWNS_AS_MAX) > ci->drivers.max_varchar_size)
return ALLOW_WCHAR(conn) ? SQL_WLONGVARCHAR : SQL_LONGVARCHAR;
return ALLOW_WCHAR(conn) ? SQL_WVARCHAR : SQL_VARCHAR;
case PG_TYPE_TEXT:
return ci->drivers.text_as_longvarchar ?
(ALLOW_WCHAR(conn) ? SQL_WLONGVARCHAR : SQL_LONGVARCHAR) :
(ALLOW_WCHAR(conn) ? SQL_WVARCHAR : SQL_VARCHAR);
#else
case PG_TYPE_BPCHAR:
if (col >= 0 &&
getCharColumnSize(stmt, type, col, UNKNOWNS_AS_MAX) > ci->drivers.max_varchar_size)
return SQL_LONGVARCHAR;
return SQL_CHAR;
case PG_TYPE_VARCHAR:
if (col >= 0 &&
getCharColumnSize(stmt, type, col, UNKNOWNS_AS_MAX) > ci->drivers.max_varchar_size)
return SQL_LONGVARCHAR;
return SQL_VARCHAR;
case PG_TYPE_TEXT:
return ci->drivers.text_as_longvarchar ? SQL_LONGVARCHAR : SQL_VARCHAR;
#endif /* UNICODE_SUPPORT */
case PG_TYPE_BYTEA:
if (ci->bytea_as_longvarbinary)
return SQL_LONGVARBINARY;
else
return SQL_VARBINARY;
case PG_TYPE_LO_UNDEFINED:
return SQL_LONGVARBINARY;
case PG_TYPE_INT2:
return SQL_SMALLINT;
case PG_TYPE_OID:
case PG_TYPE_XID:
case PG_TYPE_INT4:
return SQL_INTEGER;
/* Change this to SQL_BIGINT for ODBC v3 bjm 2001-01-23 */
case PG_TYPE_INT8:
if (ci->int8_as != 0)
return ci->int8_as;
if (conn->ms_jet)
return SQL_NUMERIC; /* maybe a little better than SQL_VARCHAR */
#if (ODBCVER >= 0x0300)
return SQL_BIGINT;
#else
return SQL_VARCHAR;
#endif /* ODBCVER */
case PG_TYPE_NUMERIC:
return SQL_NUMERIC;
case PG_TYPE_FLOAT4:
return SQL_REAL;
case PG_TYPE_FLOAT8:
return SQL_FLOAT;
case PG_TYPE_DATE:
#if (ODBCVER >= 0x0300)
if (EN_is_odbc3(env))
return SQL_TYPE_DATE;
#endif /* ODBCVER */
return SQL_DATE;
case PG_TYPE_TIME:
#if (ODBCVER >= 0x0300)
if (EN_is_odbc3(env))
return SQL_TYPE_TIME;
#endif /* ODBCVER */
return SQL_TIME;
case PG_TYPE_ABSTIME:
case PG_TYPE_DATETIME:
case PG_TYPE_TIMESTAMP_NO_TMZONE:
case PG_TYPE_TIMESTAMP:
#if (ODBCVER >= 0x0300)
if (EN_is_odbc3(env))
return SQL_TYPE_TIMESTAMP;
#endif /* ODBCVER */
return SQL_TIMESTAMP;
case PG_TYPE_MONEY:
return SQL_FLOAT;
case PG_TYPE_BOOL:
return ci->drivers.bools_as_char ? SQL_CHAR : SQL_BIT;
case PG_TYPE_XML:
return CC_is_in_unicode_driver(conn) ? SQL_WLONGVARCHAR : SQL_LONGVARCHAR;
case PG_TYPE_INET:
case PG_TYPE_CIDR:
case PG_TYPE_MACADDR:
return CC_is_in_unicode_driver(conn) ? SQL_WVARCHAR : SQL_VARCHAR;
case PG_TYPE_UUID:
#if (ODBCVER >= 0x0350)
return SQL_GUID;
#endif /* ODBCVER */
return CC_is_in_unicode_driver(conn) ? SQL_WVARCHAR : SQL_VARCHAR;
default:
/*
* first, check to see if 'type' is in list. If not, look up
* with query. Add oid, name to list. If it's already in
* list, just return.
*/
/* hack until permanent type is available */
if (type == stmt->hdbc->lobj_type)
return SQL_LONGVARBINARY;
#ifdef EXPERIMENTAL_CURRENTLY
if (ALLOW_WCHAR(conn))
return ci->drivers.unknowns_as_longvarchar ? SQL_WLONGVARCHAR : SQL_WVARCHAR;
#endif /* EXPERIMENTAL_CURRENTLY */
return ci->drivers.unknowns_as_longvarchar ? SQL_LONGVARCHAR : SQL_VARCHAR;
}
}
/*
* The length in bytes of data transferred on an SQLGetData, SQLFetch,
* or SQLFetchScroll operation if SQL_C_DEFAULT is specified.
*/
Int4
pgtype_buffer_length(StatementClass *stmt, OID type, int col, int handle_unknown_size_as)
{
ConnectionClass *conn = SC_get_conn(stmt);
switch (type)
{
case PG_TYPE_INT2:
return 2; /* sizeof(SQLSMALLINT) */
case PG_TYPE_OID:
case PG_TYPE_XID:
case PG_TYPE_INT4:
return 4; /* sizeof(SQLINTEGER) */
case PG_TYPE_INT8:
if (SQL_C_CHAR == pgtype_to_ctype(stmt, type))
return 20; /* signed: 19 digits + sign */
return 8; /* sizeof(SQLSBININT) */
case PG_TYPE_NUMERIC:
return getNumericColumnSize(stmt, type, col) + 2;
case PG_TYPE_FLOAT4:
case PG_TYPE_MONEY:
return 4; /* sizeof(SQLREAL) */
case PG_TYPE_FLOAT8:
return 8; /* sizeof(SQLFLOAT) */
case PG_TYPE_DATE:
case PG_TYPE_TIME:
return 6; /* sizeof(DATE(TIME)_STRUCT) */
case PG_TYPE_ABSTIME:
case PG_TYPE_DATETIME:
case PG_TYPE_TIMESTAMP:
case PG_TYPE_TIMESTAMP_NO_TMZONE:
return 16; /* sizeof(TIMESTAMP_STRUCT) */
case PG_TYPE_UUID:
return 16; /* sizeof(SQLGUID) */
/* Character types use the default precision */
case PG_TYPE_VARCHAR:
case PG_TYPE_BPCHAR:
{
int coef = 1;
Int4 prec = pgtype_column_size(stmt, type, col, handle_unknown_size_as), maxvarc;
if (SQL_NO_TOTAL == prec)
return prec;
#ifdef UNICODE_SUPPORT
if (CC_is_in_unicode_driver(conn))
return prec * WCLEN;
#endif /* UNICODE_SUPPORT */
/* after 7.2 */
if (PG_VERSION_GE(conn, 7.2))
coef = conn->mb_maxbyte_per_char;
if (coef < 2 && (conn->connInfo).lf_conversion)
/* CR -> CR/LF */
coef = 2;
if (coef == 1)
return prec;
maxvarc = conn->connInfo.drivers.max_varchar_size;
if (prec <= maxvarc && prec * coef > maxvarc)
return maxvarc;
return coef * prec;
}
default:
return pgtype_column_size(stmt, type, col, handle_unknown_size_as);
}
}
static Int4
getCharColumnSizeX(const ConnectionClass *conn, OID type, int atttypmod, int adtsize_or_longestlen, int handle_unknown_size_as)
{
int p = -1, maxsize;
const ConnInfo *ci = &(conn->connInfo);
mylog("%s: type=%d, atttypmod=%d, adtsize_or=%d, unknown = %d\n", __FUNCTION__, type, atttypmod, adtsize_or_longestlen, handle_unknown_size_as);
/* Assign Maximum size based on parameters */
switch (type)
{
case PG_TYPE_TEXT:
if (ci->drivers.text_as_longvarchar)
maxsize = ci->drivers.max_longvarchar_size;
else
maxsize = ci->drivers.max_varchar_size;
break;
case PG_TYPE_VARCHAR:
case PG_TYPE_BPCHAR:
maxsize = ci->drivers.max_varchar_size;
break;
default:
if (ci->drivers.unknowns_as_longvarchar)
maxsize = ci->drivers.max_longvarchar_size;
else
maxsize = ci->drivers.max_varchar_size;
break;
}
#ifdef UNICODE_SUPPORT
if (CC_is_in_unicode_driver(conn) &&
isSqlServr() &&
maxsize > 4000)
maxsize = 4000;
#endif /* UNICODE_SUPPORT */
if (maxsize == TEXT_FIELD_SIZE + 1) /* magic length for testing */
maxsize = 0;
/*
* Static ColumnSize (i.e., the Maximum ColumnSize of the datatype) This
* has nothing to do with a result set.
*/
inolog("!!! atttypmod < 0 ?\n");
if (atttypmod < 0 && adtsize_or_longestlen < 0)
return maxsize;
inolog("!!! adtsize_or_logngest=%d\n", adtsize_or_longestlen);
p = adtsize_or_longestlen; /* longest */
/*
* Catalog Result Sets -- use assigned column width (i.e., from
* set_tuplefield_string)
*/
inolog("!!! catalog_result=%d\n", handle_unknown_size_as);
if (UNKNOWNS_AS_LONGEST == handle_unknown_size_as)
{
mylog("%s: LONGEST: p = %d\n", __FUNCTION__, p);
if (p > 0 &&
(atttypmod < 0 || atttypmod > p))
return p;
}
if (TYPE_MAY_BE_ARRAY(type))
{
if (p > 0)
return p;
return maxsize;
}
/* Size is unknown -- handle according to parameter */
if (atttypmod > 0) /* maybe the length is known */
{
return atttypmod;
}
/* The type is really unknown */
switch (handle_unknown_size_as)
{
case UNKNOWNS_AS_DONTKNOW:
return -1;
case UNKNOWNS_AS_LONGEST:
case UNKNOWNS_AS_MAX:
break;
default:
return -1;
}
if (maxsize <= 0)
return maxsize;
switch (type)
{
case PG_TYPE_BPCHAR:
case PG_TYPE_VARCHAR:
case PG_TYPE_TEXT:
return maxsize;
}
if (p > maxsize)
maxsize = p;
return maxsize;
}
Int4
pgtype_attr_buffer_length(const ConnectionClass *conn, OID type, int atttypmod, int adtsize_or_longestlen, int handle_unknown_size_as)
{
int dsize;
switch (type)
{
case PG_TYPE_INT2:
return 2; /* sizeof(SQLSMALLINT) */
case PG_TYPE_OID:
case PG_TYPE_XID:
case PG_TYPE_INT4:
return 4; /* sizeof(SQLINTEGER) */
case PG_TYPE_INT8:
if (SQL_C_CHAR == pgtype_attr_to_ctype(conn, type, atttypmod))
return 20; /* signed: 19 digits + sign */
return 8; /* sizeof(SQLSBININT) */
case PG_TYPE_NUMERIC:
dsize = getNumericColumnSizeX(conn, type, atttypmod, adtsize_or_longestlen, handle_unknown_size_as);
return dsize <= 0 ? dsize : dsize + 2;
case PG_TYPE_FLOAT4:
case PG_TYPE_MONEY:
return 4; /* sizeof(SQLREAL) */
case PG_TYPE_FLOAT8:
return 8; /* sizeof(SQLFLOAT) */
case PG_TYPE_DATE:
case PG_TYPE_TIME:
return 6; /* sizeof(DATE(TIME)_STRUCT) */
case PG_TYPE_ABSTIME:
case PG_TYPE_DATETIME:
case PG_TYPE_TIMESTAMP:
case PG_TYPE_TIMESTAMP_NO_TMZONE:
return 16; /* sizeof(TIMESTAMP_STRUCT) */
case PG_TYPE_MACADDR:
return 17;
case PG_TYPE_INET:
case PG_TYPE_CIDR:
return sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255/128");
case PG_TYPE_UUID:
return 16; /* sizeof(SQLGUID) */
/* Character types use the default precision */
case PG_TYPE_VARCHAR:
case PG_TYPE_BPCHAR:
{
int coef = 1;
Int4 prec = pgtype_attr_column_size(conn, type, atttypmod, adtsize_or_longestlen, handle_unknown_size_as), maxvarc;
if (SQL_NO_TOTAL == prec)
return prec;
#ifdef UNICODE_SUPPORT
if (CC_is_in_unicode_driver(conn))
return prec * WCLEN;
#endif /* UNICODE_SUPPORT */
coef = conn->mb_maxbyte_per_char;
if (coef < 2 && (conn->connInfo).lf_conversion)
/* CR -> CR/LF */
coef = 2;
if (coef == 1)
return prec;
maxvarc = conn->connInfo.drivers.max_varchar_size;
if (prec <= maxvarc && prec * coef > maxvarc)
return maxvarc;
return coef * prec;
}
#ifdef PG_INTERVAL_AS_SQL_INTERVAL
case PG_TYPE_INTERVAL:
return sizeof(SQL_INTERVAL_STRUCT);
#endif /* PG_INTERVAL_AS_SQL_INTERVAL */
default:
return pgtype_attr_column_size(conn, type, atttypmod, adtsize_or_longestlen, handle_unknown_size_as);
}
}
