2002-07-19 01:11:32 +02:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
*
|
2002-09-01 02:58:07 +02:00
|
|
|
* pg_cast.h
|
|
|
|
* definition of the system "type casts" relation (pg_cast)
|
|
|
|
* along with the relation's initial contents.
|
|
|
|
*
|
2002-07-19 01:11:32 +02:00
|
|
|
*
|
2003-08-05 01:59:41 +02:00
|
|
|
* Copyright (c) 2002-2003, PostgreSQL Global Development Group
|
2002-07-19 01:11:32 +02:00
|
|
|
*
|
2003-11-29 23:41:33 +01:00
|
|
|
* $PostgreSQL: pgsql/src/include/catalog/pg_cast.h,v 1.10 2003/11/29 22:40:58 pgsql Exp $
|
2002-09-01 02:58:07 +02:00
|
|
|
*
|
|
|
|
* NOTES
|
|
|
|
* the genbki.sh script reads this file and generates .bki
|
|
|
|
* information from the DATA() statements.
|
|
|
|
*
|
2002-07-19 01:11:32 +02:00
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
*/
|
|
|
|
#ifndef PG_CAST_H
|
|
|
|
#define PG_CAST_H
|
|
|
|
|
|
|
|
CATALOG(pg_cast)
|
|
|
|
{
|
2002-09-01 02:58:07 +02:00
|
|
|
Oid castsource; /* source datatype for cast */
|
|
|
|
Oid casttarget; /* destination datatype for cast */
|
Extend pg_cast castimplicit column to a three-way value; this allows us
to be flexible about assignment casts without introducing ambiguity in
operator/function resolution. Introduce a well-defined promotion hierarchy
for numeric datatypes (int2->int4->int8->numeric->float4->float8).
Change make_const to initially label numeric literals as int4, int8, or
numeric (never float8 anymore).
Explicitly mark Func and RelabelType nodes to indicate whether they came
from a function call, explicit cast, or implicit cast; use this to do
reverse-listing more accurately and without so many heuristics.
Explicit casts to char, varchar, bit, varbit will truncate or pad without
raising an error (the pre-7.2 behavior), while assigning to a column without
any explicit cast will still raise an error for wrong-length data like 7.3.
This more nearly follows the SQL spec than 7.2 behavior (we should be
reporting a 'completion condition' in the explicit-cast cases, but we have
no mechanism for that, so just do silent truncation).
Fix some problems with enforcement of typmod for array elements;
it didn't work at all in 'UPDATE ... SET array[n] = foo', for example.
Provide a generalized array_length_coerce() function to replace the
specialized per-array-type functions that used to be needed (and were
missing for NUMERIC as well as all the datetime types).
Add missing conversions int8<->float4, text<->numeric, oid<->int8.
initdb forced.
2002-09-18 23:35:25 +02:00
|
|
|
Oid castfunc; /* cast function; 0 = binary coercible */
|
|
|
|
char castcontext; /* contexts in which cast can be used */
|
2002-07-19 01:11:32 +02:00
|
|
|
} FormData_pg_cast;
|
|
|
|
|
|
|
|
typedef FormData_pg_cast *Form_pg_cast;
|
|
|
|
|
Extend pg_cast castimplicit column to a three-way value; this allows us
to be flexible about assignment casts without introducing ambiguity in
operator/function resolution. Introduce a well-defined promotion hierarchy
for numeric datatypes (int2->int4->int8->numeric->float4->float8).
Change make_const to initially label numeric literals as int4, int8, or
numeric (never float8 anymore).
Explicitly mark Func and RelabelType nodes to indicate whether they came
from a function call, explicit cast, or implicit cast; use this to do
reverse-listing more accurately and without so many heuristics.
Explicit casts to char, varchar, bit, varbit will truncate or pad without
raising an error (the pre-7.2 behavior), while assigning to a column without
any explicit cast will still raise an error for wrong-length data like 7.3.
This more nearly follows the SQL spec than 7.2 behavior (we should be
reporting a 'completion condition' in the explicit-cast cases, but we have
no mechanism for that, so just do silent truncation).
Fix some problems with enforcement of typmod for array elements;
it didn't work at all in 'UPDATE ... SET array[n] = foo', for example.
Provide a generalized array_length_coerce() function to replace the
specialized per-array-type functions that used to be needed (and were
missing for NUMERIC as well as all the datetime types).
Add missing conversions int8<->float4, text<->numeric, oid<->int8.
initdb forced.
2002-09-18 23:35:25 +02:00
|
|
|
/*
|
|
|
|
* The allowable values for pg_cast.castcontext are specified by this enum.
|
|
|
|
* Since castcontext is stored as a "char", we use ASCII codes for human
|
|
|
|
* convenience in reading the table. Note that internally to the backend,
|
|
|
|
* these values are converted to the CoercionContext enum (see primnodes.h),
|
|
|
|
* which is defined to sort in a convenient order; the ASCII codes don't
|
|
|
|
* have to sort in any special order.
|
|
|
|
*/
|
|
|
|
|
|
|
|
typedef enum CoercionCodes
|
|
|
|
{
|
2003-08-04 02:43:34 +02:00
|
|
|
COERCION_CODE_IMPLICIT = 'i', /* coercion in context of
|
|
|
|
* expression */
|
|
|
|
COERCION_CODE_ASSIGNMENT = 'a', /* coercion in context of
|
|
|
|
* assignment */
|
Extend pg_cast castimplicit column to a three-way value; this allows us
to be flexible about assignment casts without introducing ambiguity in
operator/function resolution. Introduce a well-defined promotion hierarchy
for numeric datatypes (int2->int4->int8->numeric->float4->float8).
Change make_const to initially label numeric literals as int4, int8, or
numeric (never float8 anymore).
Explicitly mark Func and RelabelType nodes to indicate whether they came
from a function call, explicit cast, or implicit cast; use this to do
reverse-listing more accurately and without so many heuristics.
Explicit casts to char, varchar, bit, varbit will truncate or pad without
raising an error (the pre-7.2 behavior), while assigning to a column without
any explicit cast will still raise an error for wrong-length data like 7.3.
This more nearly follows the SQL spec than 7.2 behavior (we should be
reporting a 'completion condition' in the explicit-cast cases, but we have
no mechanism for that, so just do silent truncation).
Fix some problems with enforcement of typmod for array elements;
it didn't work at all in 'UPDATE ... SET array[n] = foo', for example.
Provide a generalized array_length_coerce() function to replace the
specialized per-array-type functions that used to be needed (and were
missing for NUMERIC as well as all the datetime types).
Add missing conversions int8<->float4, text<->numeric, oid<->int8.
initdb forced.
2002-09-18 23:35:25 +02:00
|
|
|
COERCION_CODE_EXPLICIT = 'e' /* explicit cast operation */
|
|
|
|
} CoercionCodes;
|
|
|
|
|
|
|
|
|
|
|
|
/* ----------------
|
|
|
|
* compiler constants for pg_cast
|
|
|
|
* ----------------
|
|
|
|
*/
|
2002-07-19 01:11:32 +02:00
|
|
|
#define Natts_pg_cast 4
|
|
|
|
#define Anum_pg_cast_castsource 1
|
|
|
|
#define Anum_pg_cast_casttarget 2
|
|
|
|
#define Anum_pg_cast_castfunc 3
|
Extend pg_cast castimplicit column to a three-way value; this allows us
to be flexible about assignment casts without introducing ambiguity in
operator/function resolution. Introduce a well-defined promotion hierarchy
for numeric datatypes (int2->int4->int8->numeric->float4->float8).
Change make_const to initially label numeric literals as int4, int8, or
numeric (never float8 anymore).
Explicitly mark Func and RelabelType nodes to indicate whether they came
from a function call, explicit cast, or implicit cast; use this to do
reverse-listing more accurately and without so many heuristics.
Explicit casts to char, varchar, bit, varbit will truncate or pad without
raising an error (the pre-7.2 behavior), while assigning to a column without
any explicit cast will still raise an error for wrong-length data like 7.3.
This more nearly follows the SQL spec than 7.2 behavior (we should be
reporting a 'completion condition' in the explicit-cast cases, but we have
no mechanism for that, so just do silent truncation).
Fix some problems with enforcement of typmod for array elements;
it didn't work at all in 'UPDATE ... SET array[n] = foo', for example.
Provide a generalized array_length_coerce() function to replace the
specialized per-array-type functions that used to be needed (and were
missing for NUMERIC as well as all the datetime types).
Add missing conversions int8<->float4, text<->numeric, oid<->int8.
initdb forced.
2002-09-18 23:35:25 +02:00
|
|
|
#define Anum_pg_cast_castcontext 4
|
2002-07-19 01:11:32 +02:00
|
|
|
|
|
|
|
/* ----------------
|
|
|
|
* initial contents of pg_cast
|
|
|
|
* ----------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
Extend pg_cast castimplicit column to a three-way value; this allows us
to be flexible about assignment casts without introducing ambiguity in
operator/function resolution. Introduce a well-defined promotion hierarchy
for numeric datatypes (int2->int4->int8->numeric->float4->float8).
Change make_const to initially label numeric literals as int4, int8, or
numeric (never float8 anymore).
Explicitly mark Func and RelabelType nodes to indicate whether they came
from a function call, explicit cast, or implicit cast; use this to do
reverse-listing more accurately and without so many heuristics.
Explicit casts to char, varchar, bit, varbit will truncate or pad without
raising an error (the pre-7.2 behavior), while assigning to a column without
any explicit cast will still raise an error for wrong-length data like 7.3.
This more nearly follows the SQL spec than 7.2 behavior (we should be
reporting a 'completion condition' in the explicit-cast cases, but we have
no mechanism for that, so just do silent truncation).
Fix some problems with enforcement of typmod for array elements;
it didn't work at all in 'UPDATE ... SET array[n] = foo', for example.
Provide a generalized array_length_coerce() function to replace the
specialized per-array-type functions that used to be needed (and were
missing for NUMERIC as well as all the datetime types).
Add missing conversions int8<->float4, text<->numeric, oid<->int8.
initdb forced.
2002-09-18 23:35:25 +02:00
|
|
|
* Numeric category: implicit casts are allowed in the direction
|
|
|
|
* int2->int4->int8->numeric->float4->float8, while casts in the
|
|
|
|
* reverse direction are assignment-only.
|
2002-07-19 01:11:32 +02:00
|
|
|
*/
|
Extend pg_cast castimplicit column to a three-way value; this allows us
to be flexible about assignment casts without introducing ambiguity in
operator/function resolution. Introduce a well-defined promotion hierarchy
for numeric datatypes (int2->int4->int8->numeric->float4->float8).
Change make_const to initially label numeric literals as int4, int8, or
numeric (never float8 anymore).
Explicitly mark Func and RelabelType nodes to indicate whether they came
from a function call, explicit cast, or implicit cast; use this to do
reverse-listing more accurately and without so many heuristics.
Explicit casts to char, varchar, bit, varbit will truncate or pad without
raising an error (the pre-7.2 behavior), while assigning to a column without
any explicit cast will still raise an error for wrong-length data like 7.3.
This more nearly follows the SQL spec than 7.2 behavior (we should be
reporting a 'completion condition' in the explicit-cast cases, but we have
no mechanism for that, so just do silent truncation).
Fix some problems with enforcement of typmod for array elements;
it didn't work at all in 'UPDATE ... SET array[n] = foo', for example.
Provide a generalized array_length_coerce() function to replace the
specialized per-array-type functions that used to be needed (and were
missing for NUMERIC as well as all the datetime types).
Add missing conversions int8<->float4, text<->numeric, oid<->int8.
initdb forced.
2002-09-18 23:35:25 +02:00
|
|
|
DATA(insert ( 20 21 714 a ));
|
|
|
|
DATA(insert ( 20 23 480 a ));
|
2003-08-04 02:43:34 +02:00
|
|
|
DATA(insert ( 20 700 652 i ));
|
Extend pg_cast castimplicit column to a three-way value; this allows us
to be flexible about assignment casts without introducing ambiguity in
operator/function resolution. Introduce a well-defined promotion hierarchy
for numeric datatypes (int2->int4->int8->numeric->float4->float8).
Change make_const to initially label numeric literals as int4, int8, or
numeric (never float8 anymore).
Explicitly mark Func and RelabelType nodes to indicate whether they came
from a function call, explicit cast, or implicit cast; use this to do
reverse-listing more accurately and without so many heuristics.
Explicit casts to char, varchar, bit, varbit will truncate or pad without
raising an error (the pre-7.2 behavior), while assigning to a column without
any explicit cast will still raise an error for wrong-length data like 7.3.
This more nearly follows the SQL spec than 7.2 behavior (we should be
reporting a 'completion condition' in the explicit-cast cases, but we have
no mechanism for that, so just do silent truncation).
Fix some problems with enforcement of typmod for array elements;
it didn't work at all in 'UPDATE ... SET array[n] = foo', for example.
Provide a generalized array_length_coerce() function to replace the
specialized per-array-type functions that used to be needed (and were
missing for NUMERIC as well as all the datetime types).
Add missing conversions int8<->float4, text<->numeric, oid<->int8.
initdb forced.
2002-09-18 23:35:25 +02:00
|
|
|
DATA(insert ( 20 701 482 i ));
|
|
|
|
DATA(insert ( 20 1700 1781 i ));
|
|
|
|
DATA(insert ( 21 20 754 i ));
|
|
|
|
DATA(insert ( 21 23 313 i ));
|
|
|
|
DATA(insert ( 21 700 236 i ));
|
|
|
|
DATA(insert ( 21 701 235 i ));
|
|
|
|
DATA(insert ( 21 1700 1782 i ));
|
|
|
|
DATA(insert ( 23 20 481 i ));
|
|
|
|
DATA(insert ( 23 21 314 a ));
|
|
|
|
DATA(insert ( 23 700 318 i ));
|
|
|
|
DATA(insert ( 23 701 316 i ));
|
|
|
|
DATA(insert ( 23 1700 1740 i ));
|
|
|
|
DATA(insert ( 700 20 653 a ));
|
|
|
|
DATA(insert ( 700 21 238 a ));
|
|
|
|
DATA(insert ( 700 23 319 a ));
|
|
|
|
DATA(insert ( 700 701 311 i ));
|
|
|
|
DATA(insert ( 700 1700 1742 a ));
|
|
|
|
DATA(insert ( 701 20 483 a ));
|
|
|
|
DATA(insert ( 701 21 237 a ));
|
|
|
|
DATA(insert ( 701 23 317 a ));
|
|
|
|
DATA(insert ( 701 700 312 a ));
|
|
|
|
DATA(insert ( 701 1700 1743 a ));
|
|
|
|
DATA(insert ( 1700 20 1779 a ));
|
|
|
|
DATA(insert ( 1700 21 1783 a ));
|
|
|
|
DATA(insert ( 1700 23 1744 a ));
|
|
|
|
DATA(insert ( 1700 700 1745 i ));
|
|
|
|
DATA(insert ( 1700 701 1746 i ));
|
2002-07-19 01:11:32 +02:00
|
|
|
|
|
|
|
/*
|
Extend pg_cast castimplicit column to a three-way value; this allows us
to be flexible about assignment casts without introducing ambiguity in
operator/function resolution. Introduce a well-defined promotion hierarchy
for numeric datatypes (int2->int4->int8->numeric->float4->float8).
Change make_const to initially label numeric literals as int4, int8, or
numeric (never float8 anymore).
Explicitly mark Func and RelabelType nodes to indicate whether they came
from a function call, explicit cast, or implicit cast; use this to do
reverse-listing more accurately and without so many heuristics.
Explicit casts to char, varchar, bit, varbit will truncate or pad without
raising an error (the pre-7.2 behavior), while assigning to a column without
any explicit cast will still raise an error for wrong-length data like 7.3.
This more nearly follows the SQL spec than 7.2 behavior (we should be
reporting a 'completion condition' in the explicit-cast cases, but we have
no mechanism for that, so just do silent truncation).
Fix some problems with enforcement of typmod for array elements;
it didn't work at all in 'UPDATE ... SET array[n] = foo', for example.
Provide a generalized array_length_coerce() function to replace the
specialized per-array-type functions that used to be needed (and were
missing for NUMERIC as well as all the datetime types).
Add missing conversions int8<->float4, text<->numeric, oid<->int8.
initdb forced.
2002-09-18 23:35:25 +02:00
|
|
|
* OID category: allow implicit conversion from any integral type (including
|
|
|
|
* int8, to support OID literals > 2G) to OID, as well as assignment coercion
|
|
|
|
* from OID to int4 or int8. Similarly for each OID-alias type. Also allow
|
|
|
|
* implicit coercions between OID and each OID-alias type, as well as
|
|
|
|
* regproc<->regprocedure and regoper<->regoperator. (Other coercions
|
|
|
|
* between alias types must pass through OID.)
|
|
|
|
*/
|
|
|
|
DATA(insert ( 20 26 1287 i ));
|
|
|
|
DATA(insert ( 21 26 313 i ));
|
|
|
|
DATA(insert ( 23 26 0 i ));
|
|
|
|
DATA(insert ( 26 20 1288 a ));
|
|
|
|
DATA(insert ( 26 23 0 a ));
|
|
|
|
DATA(insert ( 26 24 0 i ));
|
|
|
|
DATA(insert ( 24 26 0 i ));
|
|
|
|
DATA(insert ( 20 24 1287 i ));
|
|
|
|
DATA(insert ( 21 24 313 i ));
|
|
|
|
DATA(insert ( 23 24 0 i ));
|
|
|
|
DATA(insert ( 24 20 1288 a ));
|
|
|
|
DATA(insert ( 24 23 0 a ));
|
|
|
|
DATA(insert ( 24 2202 0 i ));
|
|
|
|
DATA(insert ( 2202 24 0 i ));
|
|
|
|
DATA(insert ( 26 2202 0 i ));
|
|
|
|
DATA(insert ( 2202 26 0 i ));
|
|
|
|
DATA(insert ( 20 2202 1287 i ));
|
|
|
|
DATA(insert ( 21 2202 313 i ));
|
|
|
|
DATA(insert ( 23 2202 0 i ));
|
|
|
|
DATA(insert ( 2202 20 1288 a ));
|
|
|
|
DATA(insert ( 2202 23 0 a ));
|
|
|
|
DATA(insert ( 26 2203 0 i ));
|
|
|
|
DATA(insert ( 2203 26 0 i ));
|
|
|
|
DATA(insert ( 20 2203 1287 i ));
|
|
|
|
DATA(insert ( 21 2203 313 i ));
|
|
|
|
DATA(insert ( 23 2203 0 i ));
|
|
|
|
DATA(insert ( 2203 20 1288 a ));
|
|
|
|
DATA(insert ( 2203 23 0 a ));
|
|
|
|
DATA(insert ( 2203 2204 0 i ));
|
|
|
|
DATA(insert ( 2204 2203 0 i ));
|
|
|
|
DATA(insert ( 26 2204 0 i ));
|
|
|
|
DATA(insert ( 2204 26 0 i ));
|
|
|
|
DATA(insert ( 20 2204 1287 i ));
|
|
|
|
DATA(insert ( 21 2204 313 i ));
|
|
|
|
DATA(insert ( 23 2204 0 i ));
|
|
|
|
DATA(insert ( 2204 20 1288 a ));
|
|
|
|
DATA(insert ( 2204 23 0 a ));
|
|
|
|
DATA(insert ( 26 2205 0 i ));
|
|
|
|
DATA(insert ( 2205 26 0 i ));
|
|
|
|
DATA(insert ( 20 2205 1287 i ));
|
|
|
|
DATA(insert ( 21 2205 313 i ));
|
|
|
|
DATA(insert ( 23 2205 0 i ));
|
|
|
|
DATA(insert ( 2205 20 1288 a ));
|
|
|
|
DATA(insert ( 2205 23 0 a ));
|
|
|
|
DATA(insert ( 26 2206 0 i ));
|
|
|
|
DATA(insert ( 2206 26 0 i ));
|
|
|
|
DATA(insert ( 20 2206 1287 i ));
|
|
|
|
DATA(insert ( 21 2206 313 i ));
|
|
|
|
DATA(insert ( 23 2206 0 i ));
|
|
|
|
DATA(insert ( 2206 20 1288 a ));
|
|
|
|
DATA(insert ( 2206 23 0 a ));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* String category: this needs to be tightened up
|
|
|
|
*/
|
|
|
|
DATA(insert ( 25 1042 0 i ));
|
|
|
|
DATA(insert ( 25 1043 0 i ));
|
2003-05-26 02:11:29 +02:00
|
|
|
DATA(insert ( 1042 25 401 i ));
|
|
|
|
DATA(insert ( 1042 1043 401 i ));
|
Extend pg_cast castimplicit column to a three-way value; this allows us
to be flexible about assignment casts without introducing ambiguity in
operator/function resolution. Introduce a well-defined promotion hierarchy
for numeric datatypes (int2->int4->int8->numeric->float4->float8).
Change make_const to initially label numeric literals as int4, int8, or
numeric (never float8 anymore).
Explicitly mark Func and RelabelType nodes to indicate whether they came
from a function call, explicit cast, or implicit cast; use this to do
reverse-listing more accurately and without so many heuristics.
Explicit casts to char, varchar, bit, varbit will truncate or pad without
raising an error (the pre-7.2 behavior), while assigning to a column without
any explicit cast will still raise an error for wrong-length data like 7.3.
This more nearly follows the SQL spec than 7.2 behavior (we should be
reporting a 'completion condition' in the explicit-cast cases, but we have
no mechanism for that, so just do silent truncation).
Fix some problems with enforcement of typmod for array elements;
it didn't work at all in 'UPDATE ... SET array[n] = foo', for example.
Provide a generalized array_length_coerce() function to replace the
specialized per-array-type functions that used to be needed (and were
missing for NUMERIC as well as all the datetime types).
Add missing conversions int8<->float4, text<->numeric, oid<->int8.
initdb forced.
2002-09-18 23:35:25 +02:00
|
|
|
DATA(insert ( 1043 25 0 i ));
|
|
|
|
DATA(insert ( 1043 1042 0 i ));
|
|
|
|
DATA(insert ( 18 25 946 i ));
|
|
|
|
DATA(insert ( 18 1042 860 i ));
|
|
|
|
DATA(insert ( 19 25 406 i ));
|
|
|
|
DATA(insert ( 19 1042 408 i ));
|
|
|
|
DATA(insert ( 19 1043 1401 i ));
|
|
|
|
DATA(insert ( 25 18 944 a ));
|
|
|
|
DATA(insert ( 25 19 407 i ));
|
|
|
|
DATA(insert ( 1042 19 409 i ));
|
|
|
|
DATA(insert ( 1043 19 1400 i ));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Datetime category
|
|
|
|
*/
|
|
|
|
DATA(insert ( 702 1082 1179 a ));
|
|
|
|
DATA(insert ( 702 1083 1364 a ));
|
|
|
|
DATA(insert ( 702 1114 2023 i ));
|
|
|
|
DATA(insert ( 702 1184 1173 i ));
|
|
|
|
DATA(insert ( 703 1186 1177 i ));
|
|
|
|
DATA(insert ( 1082 1114 2024 i ));
|
|
|
|
DATA(insert ( 1082 1184 1174 i ));
|
|
|
|
DATA(insert ( 1083 1186 1370 i ));
|
|
|
|
DATA(insert ( 1083 1266 2047 i ));
|
|
|
|
DATA(insert ( 1114 702 2030 a ));
|
|
|
|
DATA(insert ( 1114 1082 2029 a ));
|
|
|
|
DATA(insert ( 1114 1083 1316 a ));
|
|
|
|
DATA(insert ( 1114 1184 2028 i ));
|
|
|
|
DATA(insert ( 1184 702 1180 a ));
|
|
|
|
DATA(insert ( 1184 1082 1178 a ));
|
|
|
|
DATA(insert ( 1184 1083 2019 a ));
|
|
|
|
DATA(insert ( 1184 1114 2027 a ));
|
|
|
|
DATA(insert ( 1184 1266 1388 a ));
|
|
|
|
DATA(insert ( 1186 703 1194 a ));
|
|
|
|
DATA(insert ( 1186 1083 1419 a ));
|
|
|
|
DATA(insert ( 1266 1083 2046 a ));
|
|
|
|
/* Cross-category casts between int4 and abstime, reltime */
|
|
|
|
DATA(insert ( 23 702 0 e ));
|
|
|
|
DATA(insert ( 702 23 0 e ));
|
|
|
|
DATA(insert ( 23 703 0 e ));
|
|
|
|
DATA(insert ( 703 23 0 e ));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Geometric category
|
|
|
|
*/
|
|
|
|
DATA(insert ( 601 600 1532 e ));
|
|
|
|
DATA(insert ( 602 600 1533 e ));
|
|
|
|
DATA(insert ( 602 604 1449 a ));
|
|
|
|
DATA(insert ( 603 600 1534 e ));
|
|
|
|
DATA(insert ( 603 601 1541 e ));
|
|
|
|
DATA(insert ( 603 604 1448 a ));
|
|
|
|
DATA(insert ( 603 718 1479 e ));
|
|
|
|
DATA(insert ( 604 600 1540 e ));
|
|
|
|
DATA(insert ( 604 602 1447 a ));
|
|
|
|
DATA(insert ( 604 603 1446 e ));
|
|
|
|
DATA(insert ( 604 718 1474 e ));
|
|
|
|
DATA(insert ( 718 600 1416 e ));
|
|
|
|
DATA(insert ( 718 603 1480 e ));
|
|
|
|
DATA(insert ( 718 604 1544 e ));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* INET category
|
|
|
|
*/
|
|
|
|
DATA(insert ( 650 869 0 i ));
|
|
|
|
DATA(insert ( 869 650 0 i ));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* BitString category
|
|
|
|
*/
|
|
|
|
DATA(insert ( 1560 1562 0 i ));
|
|
|
|
DATA(insert ( 1562 1560 0 i ));
|
2002-10-15 00:12:49 +02:00
|
|
|
/* Cross-category casts between bit and int4, int8 */
|
2003-08-04 02:43:34 +02:00
|
|
|
DATA(insert ( 20 1560 2075 e ));
|
|
|
|
DATA(insert ( 23 1560 1683 e ));
|
|
|
|
DATA(insert ( 1560 20 2076 e ));
|
|
|
|
DATA(insert ( 1560 23 1684 e ));
|
Extend pg_cast castimplicit column to a three-way value; this allows us
to be flexible about assignment casts without introducing ambiguity in
operator/function resolution. Introduce a well-defined promotion hierarchy
for numeric datatypes (int2->int4->int8->numeric->float4->float8).
Change make_const to initially label numeric literals as int4, int8, or
numeric (never float8 anymore).
Explicitly mark Func and RelabelType nodes to indicate whether they came
from a function call, explicit cast, or implicit cast; use this to do
reverse-listing more accurately and without so many heuristics.
Explicit casts to char, varchar, bit, varbit will truncate or pad without
raising an error (the pre-7.2 behavior), while assigning to a column without
any explicit cast will still raise an error for wrong-length data like 7.3.
This more nearly follows the SQL spec than 7.2 behavior (we should be
reporting a 'completion condition' in the explicit-cast cases, but we have
no mechanism for that, so just do silent truncation).
Fix some problems with enforcement of typmod for array elements;
it didn't work at all in 'UPDATE ... SET array[n] = foo', for example.
Provide a generalized array_length_coerce() function to replace the
specialized per-array-type functions that used to be needed (and were
missing for NUMERIC as well as all the datetime types).
Add missing conversions int8<->float4, text<->numeric, oid<->int8.
initdb forced.
2002-09-18 23:35:25 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Cross-category casts to and from TEXT
|
2002-07-19 01:11:32 +02:00
|
|
|
*
|
Extend pg_cast castimplicit column to a three-way value; this allows us
to be flexible about assignment casts without introducing ambiguity in
operator/function resolution. Introduce a well-defined promotion hierarchy
for numeric datatypes (int2->int4->int8->numeric->float4->float8).
Change make_const to initially label numeric literals as int4, int8, or
numeric (never float8 anymore).
Explicitly mark Func and RelabelType nodes to indicate whether they came
from a function call, explicit cast, or implicit cast; use this to do
reverse-listing more accurately and without so many heuristics.
Explicit casts to char, varchar, bit, varbit will truncate or pad without
raising an error (the pre-7.2 behavior), while assigning to a column without
any explicit cast will still raise an error for wrong-length data like 7.3.
This more nearly follows the SQL spec than 7.2 behavior (we should be
reporting a 'completion condition' in the explicit-cast cases, but we have
no mechanism for that, so just do silent truncation).
Fix some problems with enforcement of typmod for array elements;
it didn't work at all in 'UPDATE ... SET array[n] = foo', for example.
Provide a generalized array_length_coerce() function to replace the
specialized per-array-type functions that used to be needed (and were
missing for NUMERIC as well as all the datetime types).
Add missing conversions int8<->float4, text<->numeric, oid<->int8.
initdb forced.
2002-09-18 23:35:25 +02:00
|
|
|
* For historical reasons, most casts to TEXT are implicit. This is BAD
|
|
|
|
* and should be reined in.
|
2002-07-19 01:11:32 +02:00
|
|
|
*/
|
Extend pg_cast castimplicit column to a three-way value; this allows us
to be flexible about assignment casts without introducing ambiguity in
operator/function resolution. Introduce a well-defined promotion hierarchy
for numeric datatypes (int2->int4->int8->numeric->float4->float8).
Change make_const to initially label numeric literals as int4, int8, or
numeric (never float8 anymore).
Explicitly mark Func and RelabelType nodes to indicate whether they came
from a function call, explicit cast, or implicit cast; use this to do
reverse-listing more accurately and without so many heuristics.
Explicit casts to char, varchar, bit, varbit will truncate or pad without
raising an error (the pre-7.2 behavior), while assigning to a column without
any explicit cast will still raise an error for wrong-length data like 7.3.
This more nearly follows the SQL spec than 7.2 behavior (we should be
reporting a 'completion condition' in the explicit-cast cases, but we have
no mechanism for that, so just do silent truncation).
Fix some problems with enforcement of typmod for array elements;
it didn't work at all in 'UPDATE ... SET array[n] = foo', for example.
Provide a generalized array_length_coerce() function to replace the
specialized per-array-type functions that used to be needed (and were
missing for NUMERIC as well as all the datetime types).
Add missing conversions int8<->float4, text<->numeric, oid<->int8.
initdb forced.
2002-09-18 23:35:25 +02:00
|
|
|
DATA(insert ( 20 25 1289 i ));
|
|
|
|
DATA(insert ( 25 20 1290 e ));
|
|
|
|
DATA(insert ( 21 25 113 i ));
|
|
|
|
DATA(insert ( 25 21 818 e ));
|
|
|
|
DATA(insert ( 23 25 112 i ));
|
|
|
|
DATA(insert ( 25 23 819 e ));
|
|
|
|
DATA(insert ( 26 25 114 i ));
|
|
|
|
DATA(insert ( 25 26 817 e ));
|
|
|
|
DATA(insert ( 25 650 1714 e ));
|
|
|
|
DATA(insert ( 700 25 841 i ));
|
|
|
|
DATA(insert ( 25 700 839 e ));
|
|
|
|
DATA(insert ( 701 25 840 i ));
|
|
|
|
DATA(insert ( 25 701 838 e ));
|
|
|
|
DATA(insert ( 829 25 752 e ));
|
|
|
|
DATA(insert ( 25 829 767 e ));
|
2003-05-14 20:08:15 +02:00
|
|
|
DATA(insert ( 650 25 730 e ));
|
Extend pg_cast castimplicit column to a three-way value; this allows us
to be flexible about assignment casts without introducing ambiguity in
operator/function resolution. Introduce a well-defined promotion hierarchy
for numeric datatypes (int2->int4->int8->numeric->float4->float8).
Change make_const to initially label numeric literals as int4, int8, or
numeric (never float8 anymore).
Explicitly mark Func and RelabelType nodes to indicate whether they came
from a function call, explicit cast, or implicit cast; use this to do
reverse-listing more accurately and without so many heuristics.
Explicit casts to char, varchar, bit, varbit will truncate or pad without
raising an error (the pre-7.2 behavior), while assigning to a column without
any explicit cast will still raise an error for wrong-length data like 7.3.
This more nearly follows the SQL spec than 7.2 behavior (we should be
reporting a 'completion condition' in the explicit-cast cases, but we have
no mechanism for that, so just do silent truncation).
Fix some problems with enforcement of typmod for array elements;
it didn't work at all in 'UPDATE ... SET array[n] = foo', for example.
Provide a generalized array_length_coerce() function to replace the
specialized per-array-type functions that used to be needed (and were
missing for NUMERIC as well as all the datetime types).
Add missing conversions int8<->float4, text<->numeric, oid<->int8.
initdb forced.
2002-09-18 23:35:25 +02:00
|
|
|
DATA(insert ( 869 25 730 e ));
|
|
|
|
DATA(insert ( 25 869 1713 e ));
|
|
|
|
DATA(insert ( 1082 25 749 i ));
|
|
|
|
DATA(insert ( 25 1082 748 e ));
|
|
|
|
DATA(insert ( 1083 25 948 i ));
|
|
|
|
DATA(insert ( 25 1083 837 e ));
|
|
|
|
DATA(insert ( 1114 25 2034 i ));
|
|
|
|
DATA(insert ( 25 1114 2022 e ));
|
|
|
|
DATA(insert ( 1184 25 1192 i ));
|
|
|
|
DATA(insert ( 25 1184 1191 e ));
|
|
|
|
DATA(insert ( 1186 25 1193 i ));
|
|
|
|
DATA(insert ( 25 1186 1263 e ));
|
|
|
|
DATA(insert ( 1266 25 939 i ));
|
|
|
|
DATA(insert ( 25 1266 938 e ));
|
|
|
|
DATA(insert ( 1700 25 1688 i ));
|
|
|
|
DATA(insert ( 25 1700 1686 e ));
|
2002-07-19 01:11:32 +02:00
|
|
|
|
|
|
|
#endif /* PG_CAST_H */
|