mirrors/postgres
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Run pgindent on range type files, per request from Tom.

Browse Source
This commit is contained in:
Bruce Momjian 2011-11-14 12:08:48 -05:00
parent 5b5985e6c0
commit cdaa45fd4b
4 changed files with 669 additions and 604 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
src/backend/catalog/pg_range.c
View File

@ -36,23 +36,23 @@ RangeCreate(Oid rangeTypeOid, Oid rangeSubType, Oid rangeCollation,
Oid rangeSubOpclass, RegProcedure rangeCanonical, Oid rangeSubOpclass, RegProcedure rangeCanonical,
RegProcedure rangeSubDiff) RegProcedure rangeSubDiff)
{ {
Relation pg_range; Relation pg_range;
Datum values[Natts_pg_range]; Datum values[Natts_pg_range];
bool nulls[Natts_pg_range]; bool nulls[Natts_pg_range];
HeapTuple tup; HeapTuple tup;
ObjectAddress myself; ObjectAddress myself;
ObjectAddress referenced; ObjectAddress referenced;
pg_range = heap_open(RangeRelationId, RowExclusiveLock); pg_range = heap_open(RangeRelationId, RowExclusiveLock);
memset(nulls, 0, Natts_pg_range * sizeof(bool)); memset(nulls, 0, Natts_pg_range * sizeof(bool));
values[Anum_pg_range_rngtypid - 1] = ObjectIdGetDatum(rangeTypeOid); values[Anum_pg_range_rngtypid - 1] = ObjectIdGetDatum(rangeTypeOid);
values[Anum_pg_range_rngsubtype - 1] = ObjectIdGetDatum(rangeSubType); values[Anum_pg_range_rngsubtype - 1] = ObjectIdGetDatum(rangeSubType);
values[Anum_pg_range_rngcollation - 1] = ObjectIdGetDatum(rangeCollation); values[Anum_pg_range_rngcollation - 1] = ObjectIdGetDatum(rangeCollation);
values[Anum_pg_range_rngsubopc - 1] = ObjectIdGetDatum(rangeSubOpclass); values[Anum_pg_range_rngsubopc - 1] = ObjectIdGetDatum(rangeSubOpclass);
values[Anum_pg_range_rngcanonical - 1] = ObjectIdGetDatum(rangeCanonical); values[Anum_pg_range_rngcanonical - 1] = ObjectIdGetDatum(rangeCanonical);
values[Anum_pg_range_rngsubdiff - 1] = ObjectIdGetDatum(rangeSubDiff); values[Anum_pg_range_rngsubdiff - 1] = ObjectIdGetDatum(rangeSubDiff);
tup = heap_form_tuple(RelationGetDescr(pg_range), values, nulls); tup = heap_form_tuple(RelationGetDescr(pg_range), values, nulls);
simple_heap_insert(pg_range, tup); simple_heap_insert(pg_range, tup);
@ -61,40 +61,40 @@ RangeCreate(Oid rangeTypeOid, Oid rangeSubType, Oid rangeCollation,
/* record dependencies */ /* record dependencies */
myself.classId = TypeRelationId; myself.classId = TypeRelationId;
myself.objectId = rangeTypeOid; myself.objectId = rangeTypeOid;
myself.objectSubId = 0; myself.objectSubId = 0;
referenced.classId = TypeRelationId; referenced.classId = TypeRelationId;
referenced.objectId = rangeSubType; referenced.objectId = rangeSubType;
referenced.objectSubId = 0; referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL); recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
referenced.classId = OperatorClassRelationId; referenced.classId = OperatorClassRelationId;
referenced.objectId = rangeSubOpclass; referenced.objectId = rangeSubOpclass;
referenced.objectSubId = 0; referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL); recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
if (OidIsValid(rangeCollation)) if (OidIsValid(rangeCollation))
{ {
referenced.classId = CollationRelationId; referenced.classId = CollationRelationId;
referenced.objectId = rangeCollation; referenced.objectId = rangeCollation;
referenced.objectSubId = 0; referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL); recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
} }
if (OidIsValid(rangeCanonical)) if (OidIsValid(rangeCanonical))
{ {
referenced.classId = ProcedureRelationId; referenced.classId = ProcedureRelationId;
referenced.objectId = rangeCanonical; referenced.objectId = rangeCanonical;
referenced.objectSubId = 0; referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL); recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
} }
if (OidIsValid(rangeSubDiff)) if (OidIsValid(rangeSubDiff))
{ {
referenced.classId = ProcedureRelationId; referenced.classId = ProcedureRelationId;
referenced.objectId = rangeSubDiff; referenced.objectId = rangeSubDiff;
referenced.objectSubId = 0; referenced.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL); recordDependencyOn(&myself, &referenced, DEPENDENCY_NORMAL);
} }

166
src/backend/commands/typecmds.c
View File

@ -92,10 +92,10 @@ static Oid findTypeSendFunction(List *procname, Oid typeOid);
static Oid findTypeTypmodinFunction(List *procname); static Oid findTypeTypmodinFunction(List *procname);
static Oid findTypeTypmodoutFunction(List *procname); static Oid findTypeTypmodoutFunction(List *procname);
static Oid findTypeAnalyzeFunction(List *procname, Oid typeOid); static Oid findTypeAnalyzeFunction(List *procname, Oid typeOid);
static Oid findRangeCanonicalFunction(List *procname, Oid typeOid); static Oid findRangeCanonicalFunction(List *procname, Oid typeOid);
static Oid findRangeSubOpclass(List *procname, Oid typeOid); static Oid findRangeSubOpclass(List *procname, Oid typeOid);
static Oid findRangeSubtypeDiffFunction(List *procname, Oid typeOid); static Oid findRangeSubtypeDiffFunction(List *procname, Oid typeOid);
static void validateDomainConstraint(Oid domainoid, char *ccbin); static void validateDomainConstraint(Oid domainoid, char *ccbin);
static List *get_rels_with_domain(Oid domainOid, LOCKMODE lockmode); static List *get_rels_with_domain(Oid domainOid, LOCKMODE lockmode);
static void checkDomainOwner(HeapTuple tup); static void checkDomainOwner(HeapTuple tup);
static void checkEnumOwner(HeapTuple tup); static void checkEnumOwner(HeapTuple tup);
@ -104,7 +104,7 @@ static char *domainAddConstraint(Oid domainOid, Oid domainNamespace,
int typMod, Constraint *constr, int typMod, Constraint *constr,
char *domainName); char *domainName);
static void makeRangeConstructor(char *name, Oid namespace, Oid rettype, static void makeRangeConstructor(char *name, Oid namespace, Oid rettype,
Oid subtype); Oid subtype);
/* /*
@ -654,9 +654,9 @@ RemoveTypeById(Oid typeOid)
EnumValuesDelete(typeOid); EnumValuesDelete(typeOid);
/* /*
* If it is a range type, delete the pg_range entries too; we * If it is a range type, delete the pg_range entries too; we don't bother
* don't bother with making dependency entries for those, so it * with making dependency entries for those, so it has to be done "by
* has to be done "by hand" here. * hand" here.
*/ */
if (((Form_pg_type) GETSTRUCT(tup))->typtype == TYPTYPE_RANGE) if (((Form_pg_type) GETSTRUCT(tup))->typtype == TYPTYPE_RANGE)
RangeDelete(typeOid); RangeDelete(typeOid);
@ -744,7 +744,8 @@ DefineDomain(CreateDomainStmt *stmt)
/* /*
* Base type must be a plain base type, another domain, an enum or a range * Base type must be a plain base type, another domain, an enum or a range
* type. Domains over pseudotypes would create a security hole. Domains * type. Domains over pseudotypes would create a security hole. Domains
* over composite types might be made to work in the future, but not today. * over composite types might be made to work in the future, but not
* today.
*/ */
typtype = baseType->typtype; typtype = baseType->typtype;
if (typtype != TYPTYPE_BASE && if (typtype != TYPTYPE_BASE &&
@ -1158,27 +1159,27 @@ DefineEnum(CreateEnumStmt *stmt)
* Registers a new range type. * Registers a new range type.
*/ */
void void
DefineRange(CreateRangeStmt *stmt) DefineRange(CreateRangeStmt * stmt)
{ {
char *typeName; char *typeName;
char *rangeArrayName; char *rangeArrayName;
Oid typeNamespace; Oid typeNamespace;
Oid typoid; Oid typoid;
Oid rangeArrayOid; Oid rangeArrayOid;
List *parameters = stmt->params; List *parameters = stmt->params;
ListCell *lc; ListCell *lc;
List *rangeSubOpclassName = NIL; List *rangeSubOpclassName = NIL;
List *rangeSubtypeDiffName = NIL; List *rangeSubtypeDiffName = NIL;
List *rangeCollationName = NIL; List *rangeCollationName = NIL;
Oid rangeCollation = InvalidOid; Oid rangeCollation = InvalidOid;
regproc rangeAnalyze = InvalidOid; regproc rangeAnalyze = InvalidOid;
Oid rangeSubtype = InvalidOid; Oid rangeSubtype = InvalidOid;
regproc rangeSubOpclass = InvalidOid; regproc rangeSubOpclass = InvalidOid;
regproc rangeCanonical = InvalidOid; regproc rangeCanonical = InvalidOid;
regproc rangeSubtypeDiff = InvalidOid; regproc rangeSubtypeDiff = InvalidOid;
AclResult aclresult; AclResult aclresult;
/* Convert list of names to a name and namespace */ /* Convert list of names to a name and namespace */
typeNamespace = QualifiedNameGetCreationNamespace(stmt->typeName, typeNamespace = QualifiedNameGetCreationNamespace(stmt->typeName,
@ -1236,7 +1237,7 @@ DefineRange(CreateRangeStmt *stmt)
foreach(lc, stmt->params) foreach(lc, stmt->params)
{ {
DefElem *defel = lfirst(lc); DefElem *defel = lfirst(lc);
if (pg_strcasecmp(defel->defname, "subtype") == 0) if (pg_strcasecmp(defel->defname, "subtype") == 0)
{ {
@ -1253,7 +1254,7 @@ DefineRange(CreateRangeStmt *stmt)
(errcode(ERRCODE_SYNTAX_ERROR), (errcode(ERRCODE_SYNTAX_ERROR),
errmsg("conflicting or redundant options"))); errmsg("conflicting or redundant options")));
rangeCanonical = findRangeCanonicalFunction( rangeCanonical = findRangeCanonicalFunction(
defGetQualifiedName(defel), typoid); defGetQualifiedName(defel), typoid);
} }
else if (pg_strcasecmp(defel->defname, "collation") == 0) else if (pg_strcasecmp(defel->defname, "collation") == 0)
{ {
@ -1299,9 +1300,9 @@ DefineRange(CreateRangeStmt *stmt)
} }
if (!OidIsValid(rangeSubtype)) if (!OidIsValid(rangeSubtype))
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_SYNTAX_ERROR), (errcode(ERRCODE_SYNTAX_ERROR),
errmsg("type attribute \"subtype\" is required"))); errmsg("type attribute \"subtype\" is required")));
if (type_is_collatable(rangeSubtype)) if (type_is_collatable(rangeSubtype))
{ {
@ -1319,7 +1320,7 @@ DefineRange(CreateRangeStmt *stmt)
if (rangeSubtypeDiffName != NIL) if (rangeSubtypeDiffName != NIL)
rangeSubtypeDiff = findRangeSubtypeDiffFunction( rangeSubtypeDiff = findRangeSubtypeDiffFunction(
rangeSubtypeDiffName, rangeSubtype); rangeSubtypeDiffName, rangeSubtype);
rangeArrayOid = AssignTypeArrayOid(); rangeArrayOid = AssignTypeArrayOid();
@ -1332,20 +1333,20 @@ DefineRange(CreateRangeStmt *stmt)
0, /* relation kind (ditto) */ 0, /* relation kind (ditto) */
GetUserId(), /* owner's ID */ GetUserId(), /* owner's ID */
-1, /* internal size */ -1, /* internal size */
TYPTYPE_RANGE, /* type-type (range type) */ TYPTYPE_RANGE, /* type-type (range type) */
TYPCATEGORY_RANGE, /* type-category (range type) */ TYPCATEGORY_RANGE, /* type-category (range type) */
false, /* range types are never preferred */ false, /* range types are never preferred */
DEFAULT_TYPDELIM, /* array element delimiter */ DEFAULT_TYPDELIM, /* array element delimiter */
F_RANGE_IN, /* input procedure */ F_RANGE_IN, /* input procedure */
F_RANGE_OUT, /* output procedure */ F_RANGE_OUT, /* output procedure */
F_RANGE_RECV, /* receive procedure */ F_RANGE_RECV, /* receive procedure */
F_RANGE_SEND, /* send procedure */ F_RANGE_SEND, /* send procedure */
InvalidOid, /* typmodin procedure - none */ InvalidOid, /* typmodin procedure - none */
InvalidOid, /* typmodout procedure - none */ InvalidOid, /* typmodout procedure - none */
rangeAnalyze, /* analyze procedure - default */ rangeAnalyze, /* analyze procedure - default */
InvalidOid, /* element type ID */ InvalidOid, /* element type ID */
false, /* this is not an array type */ false, /* this is not an array type */
rangeArrayOid, /* array type we are about to create */ rangeArrayOid, /* array type we are about to create */
InvalidOid, /* base type ID (only for domains) */ InvalidOid, /* base type ID (only for domains) */
NULL, /* never a default type value */ NULL, /* never a default type value */
NULL, /* binary default isn't sent either */ NULL, /* binary default isn't sent either */
@ -1355,7 +1356,7 @@ DefineRange(CreateRangeStmt *stmt)
-1, /* typMod (Domains only) */ -1, /* typMod (Domains only) */
0, /* Array dimensions of typbasetype */ 0, /* Array dimensions of typbasetype */
false, /* Type NOT NULL */ false, /* Type NOT NULL */
InvalidOid); /* typcollation */ InvalidOid); /* typcollation */
/* create the entry in pg_range */ /* create the entry in pg_range */
RangeCreate(typoid, rangeSubtype, rangeCollation, rangeSubOpclass, RangeCreate(typoid, rangeSubtype, rangeCollation, rangeSubOpclass,
@ -1384,7 +1385,7 @@ DefineRange(CreateRangeStmt *stmt)
InvalidOid, /* typmodin procedure - none */ InvalidOid, /* typmodin procedure - none */
InvalidOid, /* typmodout procedure - none */ InvalidOid, /* typmodout procedure - none */
InvalidOid, /* analyze procedure - default */ InvalidOid, /* analyze procedure - default */
typoid, /* element type ID */ typoid, /* element type ID */
true, /* yes this is an array type */ true, /* yes this is an array type */
InvalidOid, /* no further array type */ InvalidOid, /* no further array type */
InvalidOid, /* base type ID */ InvalidOid, /* base type ID */
@ -1415,12 +1416,12 @@ DefineRange(CreateRangeStmt *stmt)
static void static void
makeRangeConstructor(char *name, Oid namespace, Oid rangeOid, Oid subtype) makeRangeConstructor(char *name, Oid namespace, Oid rangeOid, Oid subtype)
{ {
ObjectAddress referenced; ObjectAddress referenced;
Oid constructorArgTypes[3]; Oid constructorArgTypes[3];
int i; int i;
referenced.classId = TypeRelationId; referenced.classId = TypeRelationId;
referenced.objectId = rangeOid; referenced.objectId = rangeOid;
referenced.objectSubId = 0; referenced.objectSubId = 0;
constructorArgTypes[0] = subtype; constructorArgTypes[0] = subtype;
@ -1429,46 +1430,46 @@ makeRangeConstructor(char *name, Oid namespace, Oid rangeOid, Oid subtype)
for (i = 0; i < 4; i++) for (i = 0; i < 4; i++)
{ {
oidvector *constructorArgTypesVector; oidvector *constructorArgTypesVector;
ObjectAddress myself; ObjectAddress myself;
Oid procOid; Oid procOid;
char *prosrc[4] = { "range_constructor0", char *prosrc[4] = {"range_constructor0",
"range_constructor1", "range_constructor1",
"range_constructor2", "range_constructor2",
"range_constructor3"}; "range_constructor3"};
constructorArgTypesVector = buildoidvector(constructorArgTypes, i); constructorArgTypesVector = buildoidvector(constructorArgTypes, i);
procOid = ProcedureCreate( procOid = ProcedureCreate(
name, /* name */ name, /* name */
namespace, /* namespace */ namespace, /* namespace */
false, /* replace */ false, /* replace */
false, /* return set */ false, /* return set */
rangeOid, /* return type */ rangeOid, /* return type */
INTERNALlanguageId, /* language */ INTERNALlanguageId, /* language */
F_FMGR_INTERNAL_VALIDATOR, /* language validator */ F_FMGR_INTERNAL_VALIDATOR, /* language validator */
prosrc[i], /* prosrc */ prosrc[i], /* prosrc */
NULL, /* probin */ NULL, /* probin */
false, /* agg */ false, /* agg */
false, /* window */ false, /* window */
false, /* security definer */ false, /* security definer */
false, /* strict */ false, /* strict */
PROVOLATILE_IMMUTABLE, /* volatility */ PROVOLATILE_IMMUTABLE, /* volatility */
constructorArgTypesVector, /* param types */ constructorArgTypesVector, /* param types */
PointerGetDatum(NULL), /* allParameterTypes */ PointerGetDatum(NULL), /* allParameterTypes */
PointerGetDatum(NULL), /* parameterModes */ PointerGetDatum(NULL), /* parameterModes */
PointerGetDatum(NULL), /* parameterNames */ PointerGetDatum(NULL), /* parameterNames */
NIL, /* parameterDefaults */ NIL, /* parameterDefaults */
PointerGetDatum(NULL), /* proconfig */ PointerGetDatum(NULL), /* proconfig */
1.0, /* procost */ 1.0, /* procost */
0.0); /* prorows */ 0.0); /* prorows */
/* /*
* Make the constructor internally-dependent on the range type so that * Make the constructor internally-dependent on the range type so that
* the user doesn't have to treat them as separate objects. * the user doesn't have to treat them as separate objects.
*/ */
myself.classId = ProcedureRelationId; myself.classId = ProcedureRelationId;
myself.objectId = procOid; myself.objectId = procOid;
myself.objectSubId = 0; myself.objectSubId = 0;
recordDependencyOn(&myself, &referenced, DEPENDENCY_INTERNAL); recordDependencyOn(&myself, &referenced, DEPENDENCY_INTERNAL);
} }
@ -1840,8 +1841,8 @@ findRangeSubtypeDiffFunction(List *procname, Oid typeOid)
if (get_func_rettype(procOid) != FLOAT8OID) if (get_func_rettype(procOid) != FLOAT8OID)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_INVALID_OBJECT_DEFINITION), (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
errmsg("range subtype diff function %s must return type \"float8\"", errmsg("range subtype diff function %s must return type \"float8\"",
func_signature_string(procname, 2, NIL, argList)))); func_signature_string(procname, 2, NIL, argList))));
if (func_volatile(procOid) != PROVOLATILE_IMMUTABLE) if (func_volatile(procOid) != PROVOLATILE_IMMUTABLE)
ereport(ERROR, ereport(ERROR,
@ -2395,13 +2396,13 @@ AlterDomainValidateConstraint(List *names, char *constrName)
Form_pg_constraint con = NULL; Form_pg_constraint con = NULL;
Form_pg_constraint copy_con; Form_pg_constraint copy_con;
char *conbin; char *conbin;
SysScanDesc scan; SysScanDesc scan;
Datum val; Datum val;
bool found = false; bool found = false;
bool isnull; bool isnull;
HeapTuple tuple; HeapTuple tuple;
HeapTuple copyTuple; HeapTuple copyTuple;
ScanKeyData key; ScanKeyData key;
/* Make a TypeName so we can use standard type lookup machinery */ /* Make a TypeName so we can use standard type lookup machinery */
typename = makeTypeNameFromNameList(names); typename = makeTypeNameFromNameList(names);
@ -2447,8 +2448,8 @@ AlterDomainValidateConstraint(List *names, char *constrName)
if (con->contype != CONSTRAINT_CHECK) if (con->contype != CONSTRAINT_CHECK)
ereport(ERROR, ereport(ERROR,
(errcode(ERRCODE_WRONG_OBJECT_TYPE), (errcode(ERRCODE_WRONG_OBJECT_TYPE),
errmsg("constraint \"%s\" of domain \"%s\" is not a check constraint", errmsg("constraint \"%s\" of domain \"%s\" is not a check constraint",
constrName, TypeNameToString(typename)))); constrName, TypeNameToString(typename))));
val = SysCacheGetAttr(CONSTROID, tuple, val = SysCacheGetAttr(CONSTROID, tuple,
Anum_pg_constraint_conbin, Anum_pg_constraint_conbin,
@ -2549,6 +2550,7 @@ validateDomainConstraint(Oid domainoid, char *ccbin)
FreeExecutorState(estate); FreeExecutorState(estate);
} }
/* /*
* get_rels_with_domain * get_rels_with_domain
* *
@ -2868,7 +2870,7 @@ domainAddConstraint(Oid domainOid, Oid domainNamespace, Oid baseTypeOid,
CONSTRAINT_CHECK, /* Constraint Type */ CONSTRAINT_CHECK, /* Constraint Type */
false, /* Is Deferrable */ false, /* Is Deferrable */
false, /* Is Deferred */ false, /* Is Deferred */
!constr->skip_validation, /* Is Validated */ !constr->skip_validation, /* Is Validated */
InvalidOid, /* not a relation constraint */ InvalidOid, /* not a relation constraint */
NULL, NULL,
0, 0,

819
src/backend/utils/adt/rangetypes.c
View File

File diff suppressed because it is too large Load Diff

244
src/backend/utils/adt/rangetypes_gist.c
View File

@ -33,37 +33,38 @@
#define RANGESTRAT_OVERRIGHT 11 #define RANGESTRAT_OVERRIGHT 11
#define RANGESTRAT_ADJACENT 12 #define RANGESTRAT_ADJACENT 12
static RangeType *range_super_union(FunctionCallInfo fcinfo, RangeType *r1, static RangeType *range_super_union(FunctionCallInfo fcinfo, RangeType * r1,
RangeType *r2); RangeType * r2);
static bool range_gist_consistent_int(FunctionCallInfo fcinfo, static bool range_gist_consistent_int(FunctionCallInfo fcinfo,
StrategyNumber strategy, RangeType *key, StrategyNumber strategy, RangeType * key,
RangeType *query); RangeType * query);
static bool range_gist_consistent_leaf(FunctionCallInfo fcinfo, static bool range_gist_consistent_leaf(FunctionCallInfo fcinfo,
StrategyNumber strategy, RangeType *key, StrategyNumber strategy, RangeType * key,
RangeType *query); RangeType * query);
static int sort_item_cmp(const void *a, const void *b); static int sort_item_cmp(const void *a, const void *b);
/* /*
* Auxiliary structure for picksplit method. * Auxiliary structure for picksplit method.
*/ */
typedef struct typedef struct
{ {
int index; int index;
RangeType *data; RangeType *data;
FunctionCallInfo fcinfo; FunctionCallInfo fcinfo;
} PickSplitSortItem; } PickSplitSortItem;
Datum Datum
range_gist_consistent(PG_FUNCTION_ARGS) range_gist_consistent(PG_FUNCTION_ARGS)
{ {
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
Datum dquery = PG_GETARG_DATUM(1); Datum dquery = PG_GETARG_DATUM(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2); StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
/* Oid subtype = PG_GETARG_OID(3); */ /* Oid subtype = PG_GETARG_OID(3); */
bool *recheck = (bool *) PG_GETARG_POINTER(4); bool *recheck = (bool *) PG_GETARG_POINTER(4);
RangeType *key = DatumGetRangeType(entry->key); RangeType *key = DatumGetRangeType(entry->key);
RangeType *query; RangeType *query;
RangeBound lower; RangeBound lower;
RangeBound upper; RangeBound upper;
@ -76,50 +77,50 @@ range_gist_consistent(PG_FUNCTION_ARGS)
switch (strategy) switch (strategy)
{ {
RangeBound lower; RangeBound lower;
RangeBound upper; RangeBound upper;
/* /*
* For contains and contained by operators, the other operand is a * For contains and contained by operators, the other operand is a
* "point" of the subtype. Construct a singleton range containing just * "point" of the subtype. Construct a singleton range containing
* that value. * just that value.
*/ */
case RANGESTRAT_CONTAINS_ELEM: case RANGESTRAT_CONTAINS_ELEM:
case RANGESTRAT_ELEM_CONTAINED_BY: case RANGESTRAT_ELEM_CONTAINED_BY:
lower.rngtypid = rngtypid; lower.rngtypid = rngtypid;
lower.inclusive = true; lower.inclusive = true;
lower.val = dquery; lower.val = dquery;
lower.lower = true; lower.lower = true;
lower.infinite = false; lower.infinite = false;
upper.rngtypid = rngtypid; upper.rngtypid = rngtypid;
upper.inclusive = true; upper.inclusive = true;
upper.val = dquery; upper.val = dquery;
upper.lower = false; upper.lower = false;
upper.infinite = false; upper.infinite = false;
query = DatumGetRangeType( query = DatumGetRangeType(
make_range(fcinfo, &lower, &upper, false)); make_range(fcinfo, &lower, &upper, false));
break; break;
default: default:
query = DatumGetRangeType(dquery); query = DatumGetRangeType(dquery);
break; break;
} }
if (GIST_LEAF(entry)) if (GIST_LEAF(entry))
PG_RETURN_BOOL(range_gist_consistent_leaf( PG_RETURN_BOOL(range_gist_consistent_leaf(
fcinfo, strategy, key, query)); fcinfo, strategy, key, query));
else else
PG_RETURN_BOOL(range_gist_consistent_int( PG_RETURN_BOOL(range_gist_consistent_int(
fcinfo, strategy, key, query)); fcinfo, strategy, key, query));
} }
Datum Datum
range_gist_union(PG_FUNCTION_ARGS) range_gist_union(PG_FUNCTION_ARGS)
{ {
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
GISTENTRY *ent = entryvec->vector; GISTENTRY *ent = entryvec->vector;
RangeType *result_range; RangeType *result_range;
int i; int i;
result_range = DatumGetRangeType(ent[0].key); result_range = DatumGetRangeType(ent[0].key);
@ -136,6 +137,7 @@ Datum
range_gist_compress(PG_FUNCTION_ARGS) range_gist_compress(PG_FUNCTION_ARGS)
{ {
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
PG_RETURN_POINTER(entry); PG_RETURN_POINTER(entry);
} }
@ -143,26 +145,31 @@ Datum
range_gist_decompress(PG_FUNCTION_ARGS) range_gist_decompress(PG_FUNCTION_ARGS)
{ {
GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0); GISTENTRY *entry = (GISTENTRY *) PG_GETARG_POINTER(0);
PG_RETURN_POINTER(entry); PG_RETURN_POINTER(entry);
} }
Datum Datum
range_gist_penalty(PG_FUNCTION_ARGS) range_gist_penalty(PG_FUNCTION_ARGS)
{ {
GISTENTRY *origentry = (GISTENTRY *) PG_GETARG_POINTER(0); GISTENTRY *origentry = (GISTENTRY *) PG_GETARG_POINTER(0);
GISTENTRY *newentry = (GISTENTRY *) PG_GETARG_POINTER(1); GISTENTRY *newentry = (GISTENTRY *) PG_GETARG_POINTER(1);
float *penalty = (float *) PG_GETARG_POINTER(2); float *penalty = (float *) PG_GETARG_POINTER(2);
RangeType *orig = DatumGetRangeType(origentry->key); RangeType *orig = DatumGetRangeType(origentry->key);
RangeType *new = DatumGetRangeType(newentry->key); RangeType *new = DatumGetRangeType(newentry->key);
RangeType *s_union = range_super_union(fcinfo, orig, new); RangeType *s_union = range_super_union(fcinfo, orig, new);
FmgrInfo *subtype_diff; FmgrInfo *subtype_diff;
RangeBound lower1, lower2; RangeBound lower1,
RangeBound upper1, upper2; lower2;
bool empty1, empty2; RangeBound upper1,
upper2;
bool empty1,
empty2;
float lower_diff, upper_diff; float lower_diff,
upper_diff;
RangeTypeInfo rngtypinfo; RangeTypeInfo rngtypinfo;
@ -203,7 +210,7 @@ range_gist_penalty(PG_FUNCTION_ARGS)
if (lower_diff < 0) if (lower_diff < 0)
lower_diff = 0; /* subtype_diff is broken */ lower_diff = 0; /* subtype_diff is broken */
} }
else /* only know whether there is a difference or not */ else /* only know whether there is a difference or not */
lower_diff = (float) range_cmp_bounds(fcinfo, &lower1, &lower2); lower_diff = (float) range_cmp_bounds(fcinfo, &lower1, &lower2);
Assert(upper2.infinite || !upper1.infinite); Assert(upper2.infinite || !upper1.infinite);
@ -219,7 +226,7 @@ range_gist_penalty(PG_FUNCTION_ARGS)
if (upper_diff < 0) if (upper_diff < 0)
upper_diff = 0; /* subtype_diff is broken */ upper_diff = 0; /* subtype_diff is broken */
} }
else /* only know whether there is a difference or not */ else /* only know whether there is a difference or not */
upper_diff = (float) range_cmp_bounds(fcinfo, &upper2, &upper1); upper_diff = (float) range_cmp_bounds(fcinfo, &upper2, &upper1);
Assert(lower_diff >= 0 && upper_diff >= 0); Assert(lower_diff >= 0 && upper_diff >= 0);
@ -238,22 +245,22 @@ range_gist_penalty(PG_FUNCTION_ARGS)
Datum Datum
range_gist_picksplit(PG_FUNCTION_ARGS) range_gist_picksplit(PG_FUNCTION_ARGS)
{ {
GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0); GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1); GIST_SPLITVEC *v = (GIST_SPLITVEC *) PG_GETARG_POINTER(1);
OffsetNumber i; OffsetNumber i;
RangeType *pred_left; RangeType *pred_left;
RangeType *pred_right; RangeType *pred_right;
PickSplitSortItem *sortItems; PickSplitSortItem *sortItems;
int nbytes; int nbytes;
OffsetNumber split_idx; OffsetNumber split_idx;
OffsetNumber *left; OffsetNumber *left;
OffsetNumber *right; OffsetNumber *right;
OffsetNumber maxoff; OffsetNumber maxoff;
maxoff = entryvec->n - 1; maxoff = entryvec->n - 1;
nbytes = (maxoff + 1) * sizeof(OffsetNumber); nbytes = (maxoff + 1) * sizeof(OffsetNumber);
sortItems = (PickSplitSortItem *) palloc( sortItems = (PickSplitSortItem *) palloc(
maxoff * sizeof(PickSplitSortItem)); maxoff * sizeof(PickSplitSortItem));
v->spl_left = (OffsetNumber *) palloc(nbytes); v->spl_left = (OffsetNumber *) palloc(nbytes);
v->spl_right = (OffsetNumber *) palloc(nbytes); v->spl_right = (OffsetNumber *) palloc(nbytes);
@ -262,8 +269,8 @@ range_gist_picksplit(PG_FUNCTION_ARGS)
*/ */
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i)) for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{ {
sortItems[i - 1].index = i; sortItems[i - 1].index = i;
sortItems[i - 1].data = DatumGetRangeType(entryvec->vector[i].key); sortItems[i - 1].data = DatumGetRangeType(entryvec->vector[i].key);
sortItems[i - 1].fcinfo = fcinfo; sortItems[i - 1].fcinfo = fcinfo;
} }
qsort(sortItems, maxoff, sizeof(PickSplitSortItem), sort_item_cmp); qsort(sortItems, maxoff, sizeof(PickSplitSortItem), sort_item_cmp);
@ -313,9 +320,9 @@ range_gist_picksplit(PG_FUNCTION_ARGS)
Datum Datum
range_gist_same(PG_FUNCTION_ARGS) range_gist_same(PG_FUNCTION_ARGS)
{ {
Datum r1 = PG_GETARG_DATUM(0); Datum r1 = PG_GETARG_DATUM(0);
Datum r2 = PG_GETARG_DATUM(1); Datum r2 = PG_GETARG_DATUM(1);
bool *result = (bool *) PG_GETARG_POINTER(2); bool *result = (bool *) PG_GETARG_POINTER(2);
*result = DatumGetBool(OidFunctionCall2(F_RANGE_EQ, r1, r2)); *result = DatumGetBool(OidFunctionCall2(F_RANGE_EQ, r1, r2));
PG_RETURN_POINTER(result); PG_RETURN_POINTER(result);
@ -329,13 +336,16 @@ range_gist_same(PG_FUNCTION_ARGS)
/* return the smallest range that contains r1 and r2 */ /* return the smallest range that contains r1 and r2 */
static RangeType * static RangeType *
range_super_union(FunctionCallInfo fcinfo, RangeType *r1, RangeType *r2) range_super_union(FunctionCallInfo fcinfo, RangeType * r1, RangeType * r2)
{ {
RangeBound lower1, lower2; RangeBound lower1,
RangeBound upper1, upper2; lower2;
bool empty1, empty2; RangeBound upper1,
RangeBound *result_lower; upper2;
RangeBound *result_upper; bool empty1,
empty2;
RangeBound *result_lower;
RangeBound *result_upper;
range_deserialize(fcinfo, r1, &lower1, &upper1, &empty1); range_deserialize(fcinfo, r1, &lower1, &upper1, &empty1);
range_deserialize(fcinfo, r2, &lower2, &upper2, &empty2); range_deserialize(fcinfo, r2, &lower2, &upper2, &empty2);
@ -362,21 +372,24 @@ range_super_union(FunctionCallInfo fcinfo, RangeType *r1, RangeType *r2)
return r2; return r2;
return DatumGetRangeType( return DatumGetRangeType(
make_range(fcinfo, result_lower, result_upper, false)); make_range(fcinfo, result_lower, result_upper, false));
} }
static bool static bool
range_gist_consistent_int(FunctionCallInfo fcinfo, StrategyNumber strategy, range_gist_consistent_int(FunctionCallInfo fcinfo, StrategyNumber strategy,
RangeType *key, RangeType *query) RangeType * key, RangeType * query)
{ {
Oid proc = InvalidOid; Oid proc = InvalidOid;
RangeBound lower1, lower2; RangeBound lower1,
RangeBound upper1, upper2; lower2;
bool empty1, empty2; RangeBound upper1,
upper2;
bool empty1,
empty2;
bool retval; bool retval;
bool negate = false; bool negate = false;
range_deserialize(fcinfo, key, &lower1, &upper1, &empty1); range_deserialize(fcinfo, key, &lower1, &upper1, &empty1);
range_deserialize(fcinfo, query, &lower2, &upper2, &empty2); range_deserialize(fcinfo, query, &lower2, &upper2, &empty2);
@ -384,17 +397,17 @@ range_gist_consistent_int(FunctionCallInfo fcinfo, StrategyNumber strategy,
switch (strategy) switch (strategy)
{ {
case RANGESTRAT_EQ: case RANGESTRAT_EQ:
proc = F_RANGE_CONTAINS; proc = F_RANGE_CONTAINS;
break; break;
case RANGESTRAT_NE: case RANGESTRAT_NE:
return true; return true;
break; break;
case RANGESTRAT_OVERLAPS: case RANGESTRAT_OVERLAPS:
proc = F_RANGE_OVERLAPS; proc = F_RANGE_OVERLAPS;
break; break;
case RANGESTRAT_CONTAINS_ELEM: case RANGESTRAT_CONTAINS_ELEM:
case RANGESTRAT_CONTAINS: case RANGESTRAT_CONTAINS:
proc = F_RANGE_CONTAINS; proc = F_RANGE_CONTAINS;
break; break;
case RANGESTRAT_ELEM_CONTAINED_BY: case RANGESTRAT_ELEM_CONTAINED_BY:
case RANGESTRAT_CONTAINED_BY: case RANGESTRAT_CONTAINED_BY:
@ -403,19 +416,19 @@ range_gist_consistent_int(FunctionCallInfo fcinfo, StrategyNumber strategy,
case RANGESTRAT_BEFORE: case RANGESTRAT_BEFORE:
if (empty1) if (empty1)
return false; return false;
proc = F_RANGE_OVERRIGHT; proc = F_RANGE_OVERRIGHT;
negate = true; negate = true;
break; break;
case RANGESTRAT_AFTER: case RANGESTRAT_AFTER:
if (empty1) if (empty1)
return false; return false;
proc = F_RANGE_OVERLEFT; proc = F_RANGE_OVERLEFT;
negate = true; negate = true;
break; break;
case RANGESTRAT_OVERLEFT: case RANGESTRAT_OVERLEFT:
if (empty1) if (empty1)
return false; return false;
proc = F_RANGE_AFTER; proc = F_RANGE_AFTER;
negate = true; negate = true;
break; break;
case RANGESTRAT_OVERRIGHT: case RANGESTRAT_OVERRIGHT:
@ -428,9 +441,9 @@ range_gist_consistent_int(FunctionCallInfo fcinfo, StrategyNumber strategy,
if (empty1 || empty2) if (empty1 || empty2)
return false; return false;
if (DatumGetBool( if (DatumGetBool(
OidFunctionCall2(F_RANGE_ADJACENT, OidFunctionCall2(F_RANGE_ADJACENT,
RangeTypeGetDatum(key), RangeTypeGetDatum(key),
RangeTypeGetDatum(query)))) RangeTypeGetDatum(query))))
return true; return true;
proc = F_RANGE_OVERLAPS; proc = F_RANGE_OVERLAPS;
break; break;
@ -447,13 +460,16 @@ range_gist_consistent_int(FunctionCallInfo fcinfo, StrategyNumber strategy,
static bool static bool
range_gist_consistent_leaf(FunctionCallInfo fcinfo, StrategyNumber strategy, range_gist_consistent_leaf(FunctionCallInfo fcinfo, StrategyNumber strategy,
RangeType *key, RangeType *query) RangeType * key, RangeType * query)
{ {
Oid proc = InvalidOid; Oid proc = InvalidOid;
RangeBound lower1, lower2; RangeBound lower1,
RangeBound upper1, upper2; lower2;
bool empty1, empty2; RangeBound upper1,
upper2;
bool empty1,
empty2;
range_deserialize(fcinfo, key, &lower1, &upper1, &empty1); range_deserialize(fcinfo, key, &lower1, &upper1, &empty1);
range_deserialize(fcinfo, query, &lower2, &upper2, &empty2); range_deserialize(fcinfo, query, &lower2, &upper2, &empty2);
@ -525,18 +541,21 @@ range_gist_consistent_leaf(FunctionCallInfo fcinfo, StrategyNumber strategy,
static int static int
sort_item_cmp(const void *a, const void *b) sort_item_cmp(const void *a, const void *b)
{ {
PickSplitSortItem *i1 = (PickSplitSortItem *)a; PickSplitSortItem *i1 = (PickSplitSortItem *) a;
PickSplitSortItem *i2 = (PickSplitSortItem *)b; PickSplitSortItem *i2 = (PickSplitSortItem *) b;
RangeType *r1 = i1->data; RangeType *r1 = i1->data;
RangeType *r2 = i2->data; RangeType *r2 = i2->data;
RangeBound lower1, lower2; RangeBound lower1,
RangeBound upper1, upper2; lower2;
bool empty1, empty2; RangeBound upper1,
upper2;
bool empty1,
empty2;
FunctionCallInfo fcinfo = i1->fcinfo; FunctionCallInfo fcinfo = i1->fcinfo;
int cmp; int cmp;
range_deserialize(fcinfo, r1, &lower1, &upper1, &empty1); range_deserialize(fcinfo, r1, &lower1, &upper1, &empty1);
range_deserialize(fcinfo, r2, &lower2, &upper2, &empty2); range_deserialize(fcinfo, r2, &lower2, &upper2, &empty2);
@ -554,12 +573,11 @@ sort_item_cmp(const void *a, const void *b)
} }
/* /*
* If both lower or both upper bounds are infinite, we sort by * If both lower or both upper bounds are infinite, we sort by ascending
* ascending range size. That means that if both upper bounds are * range size. That means that if both upper bounds are infinite, we sort
* infinite, we sort by the lower bound _descending_. That creates * by the lower bound _descending_. That creates a slightly odd total
* a slightly odd total order, but keeps the pages with very * order, but keeps the pages with very unselective predicates grouped
* unselective predicates grouped more closely together on the * more closely together on the right.
* right.
*/ */
if (lower1.infinite || upper1.infinite || if (lower1.infinite || upper1.infinite ||
lower2.infinite || upper2.infinite) lower2.infinite || upper2.infinite)