typcache.c File Reference

#include "postgres.h"
#include <limits.h>
#include "access/hash.h"
#include "access/htup_details.h"
#include "access/nbtree.h"
#include "access/parallel.h"
#include "access/relation.h"
#include "access/session.h"
#include "access/table.h"
#include "catalog/pg_am.h"
#include "catalog/pg_constraint.h"
#include "catalog/pg_enum.h"
#include "catalog/pg_operator.h"
#include "catalog/pg_range.h"
#include "catalog/pg_type.h"
#include "commands/defrem.h"
#include "common/int.h"
#include "executor/executor.h"
#include "lib/dshash.h"
#include "optimizer/optimizer.h"
#include "port/pg_bitutils.h"
#include "storage/lwlock.h"
#include "utils/builtins.h"
#include "utils/catcache.h"
#include "utils/fmgroids.h"
#include "utils/inval.h"
#include "utils/lsyscache.h"
#include "utils/memutils.h"
#include "utils/rel.h"
#include "utils/syscache.h"
#include "utils/typcache.h"

Include dependency graph for typcache.c:

Go to the source code of this file.

Data Structures
struct	DomainConstraintCache
struct	EnumItem
struct	TypeCacheEnumData
struct	RecordCacheEntry
struct	SharedRecordTypmodRegistry
struct	SharedRecordTableKey
struct	SharedRecordTableEntry
struct	SharedTypmodTableEntry
struct	RecordCacheArrayEntry

Macros
#define	TCFLAGS_HAVE_PG_TYPE_DATA   0x000001
#define	TCFLAGS_CHECKED_BTREE_OPCLASS   0x000002
#define	TCFLAGS_CHECKED_HASH_OPCLASS   0x000004
#define	TCFLAGS_CHECKED_EQ_OPR   0x000008
#define	TCFLAGS_CHECKED_LT_OPR   0x000010
#define	TCFLAGS_CHECKED_GT_OPR   0x000020
#define	TCFLAGS_CHECKED_CMP_PROC   0x000040
#define	TCFLAGS_CHECKED_HASH_PROC   0x000080
#define	TCFLAGS_CHECKED_HASH_EXTENDED_PROC   0x000100
#define	TCFLAGS_CHECKED_ELEM_PROPERTIES   0x000200
#define	TCFLAGS_HAVE_ELEM_EQUALITY   0x000400
#define	TCFLAGS_HAVE_ELEM_COMPARE   0x000800
#define	TCFLAGS_HAVE_ELEM_HASHING   0x001000
#define	TCFLAGS_HAVE_ELEM_EXTENDED_HASHING   0x002000
#define	TCFLAGS_CHECKED_FIELD_PROPERTIES   0x004000
#define	TCFLAGS_HAVE_FIELD_EQUALITY   0x008000
#define	TCFLAGS_HAVE_FIELD_COMPARE   0x010000
#define	TCFLAGS_HAVE_FIELD_HASHING   0x020000
#define	TCFLAGS_HAVE_FIELD_EXTENDED_HASHING   0x040000
#define	TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS   0x080000
#define	TCFLAGS_DOMAIN_BASE_IS_COMPOSITE   0x100000
#define	TCFLAGS_OPERATOR_FLAGS

Typedefs
typedef struct TypeCacheEnumData	TypeCacheEnumData
typedef struct RecordCacheEntry	RecordCacheEntry
typedef struct SharedRecordTableKey	SharedRecordTableKey
typedef struct SharedRecordTableEntry	SharedRecordTableEntry
typedef struct SharedTypmodTableEntry	SharedTypmodTableEntry
typedef struct RecordCacheArrayEntry	RecordCacheArrayEntry

Functions
static int	shared_record_table_compare (const void *a, const void *b, size_t size, void *arg)
static uint32	shared_record_table_hash (const void *a, size_t size, void *arg)
static void	load_typcache_tupdesc (TypeCacheEntry *typentry)
static void	load_rangetype_info (TypeCacheEntry *typentry)
static void	load_multirangetype_info (TypeCacheEntry *typentry)
static void	load_domaintype_info (TypeCacheEntry *typentry)
static int	dcs_cmp (const void *a, const void *b)
static void	decr_dcc_refcount (DomainConstraintCache *dcc)
static void	dccref_deletion_callback (void *arg)
static List *	prep_domain_constraints (List *constraints, MemoryContext execctx)
static bool	array_element_has_equality (TypeCacheEntry *typentry)
static bool	array_element_has_compare (TypeCacheEntry *typentry)
static bool	array_element_has_hashing (TypeCacheEntry *typentry)
static bool	array_element_has_extended_hashing (TypeCacheEntry *typentry)
static void	cache_array_element_properties (TypeCacheEntry *typentry)
static bool	record_fields_have_equality (TypeCacheEntry *typentry)
static bool	record_fields_have_compare (TypeCacheEntry *typentry)
static bool	record_fields_have_hashing (TypeCacheEntry *typentry)
static bool	record_fields_have_extended_hashing (TypeCacheEntry *typentry)
static void	cache_record_field_properties (TypeCacheEntry *typentry)
static bool	range_element_has_hashing (TypeCacheEntry *typentry)
static bool	range_element_has_extended_hashing (TypeCacheEntry *typentry)
static void	cache_range_element_properties (TypeCacheEntry *typentry)
static bool	multirange_element_has_hashing (TypeCacheEntry *typentry)
static bool	multirange_element_has_extended_hashing (TypeCacheEntry *typentry)
static void	cache_multirange_element_properties (TypeCacheEntry *typentry)
static void	TypeCacheRelCallback (Datum arg, Oid relid)
static void	TypeCacheTypCallback (Datum arg, int cacheid, uint32 hashvalue)
static void	TypeCacheOpcCallback (Datum arg, int cacheid, uint32 hashvalue)
static void	TypeCacheConstrCallback (Datum arg, int cacheid, uint32 hashvalue)
static void	load_enum_cache_data (TypeCacheEntry *tcache)
static EnumItem *	find_enumitem (TypeCacheEnumData *enumdata, Oid arg)
static int	enum_oid_cmp (const void *left, const void *right)
static void	shared_record_typmod_registry_detach (dsm_segment *segment, Datum datum)
static TupleDesc	find_or_make_matching_shared_tupledesc (TupleDesc tupdesc)
static dsa_pointer	share_tupledesc (dsa_area *area, TupleDesc tupdesc, uint32 typmod)
static uint32	type_cache_syshash (const void *key, Size keysize)
TypeCacheEntry *	lookup_type_cache (Oid type_id, int flags)
void	InitDomainConstraintRef (Oid type_id, DomainConstraintRef *ref, MemoryContext refctx, bool need_exprstate)
void	UpdateDomainConstraintRef (DomainConstraintRef *ref)
bool	DomainHasConstraints (Oid type_id)
static void	ensure_record_cache_typmod_slot_exists (int32 typmod)
static TupleDesc	lookup_rowtype_tupdesc_internal (Oid type_id, int32 typmod, bool noError)
TupleDesc	lookup_rowtype_tupdesc (Oid type_id, int32 typmod)
TupleDesc	lookup_rowtype_tupdesc_noerror (Oid type_id, int32 typmod, bool noError)
TupleDesc	lookup_rowtype_tupdesc_copy (Oid type_id, int32 typmod)
TupleDesc	lookup_rowtype_tupdesc_domain (Oid type_id, int32 typmod, bool noError)
static uint32	record_type_typmod_hash (const void *data, size_t size)
static int	record_type_typmod_compare (const void *a, const void *b, size_t size)
void	assign_record_type_typmod (TupleDesc tupDesc)
uint64	assign_record_type_identifier (Oid type_id, int32 typmod)
size_t	SharedRecordTypmodRegistryEstimate (void)
void	SharedRecordTypmodRegistryInit (SharedRecordTypmodRegistry *registry, dsm_segment *segment, dsa_area *area)
void	SharedRecordTypmodRegistryAttach (SharedRecordTypmodRegistry *registry)
static bool	enum_known_sorted (TypeCacheEnumData *enumdata, Oid arg)
int	compare_values_of_enum (TypeCacheEntry *tcache, Oid arg1, Oid arg2)

Variables
static HTAB *	TypeCacheHash = NULL
static TypeCacheEntry *	firstDomainTypeEntry = NULL
static const dshash_parameters	srtr_record_table_params
static const dshash_parameters	srtr_typmod_table_params
static HTAB *	RecordCacheHash = NULL
static RecordCacheArrayEntry *	RecordCacheArray = NULL
static int32	RecordCacheArrayLen = 0
static int32	NextRecordTypmod = 0
static uint64	tupledesc_id_counter = INVALID_TUPLEDESC_IDENTIFIER

Macro Definition Documentation

TCFLAGS_CHECKED_BTREE_OPCLASS

#define TCFLAGS_CHECKED_BTREE_OPCLASS   0x000002

Definition at line 85 of file typcache.c.

TCFLAGS_CHECKED_CMP_PROC

#define TCFLAGS_CHECKED_CMP_PROC   0x000040

Definition at line 90 of file typcache.c.

TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS

#define TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS   0x080000

Definition at line 103 of file typcache.c.

TCFLAGS_CHECKED_ELEM_PROPERTIES

#define TCFLAGS_CHECKED_ELEM_PROPERTIES   0x000200

Definition at line 93 of file typcache.c.

TCFLAGS_CHECKED_EQ_OPR

#define TCFLAGS_CHECKED_EQ_OPR   0x000008

Definition at line 87 of file typcache.c.

TCFLAGS_CHECKED_FIELD_PROPERTIES

#define TCFLAGS_CHECKED_FIELD_PROPERTIES   0x004000

Definition at line 98 of file typcache.c.

TCFLAGS_CHECKED_GT_OPR

#define TCFLAGS_CHECKED_GT_OPR   0x000020

Definition at line 89 of file typcache.c.

TCFLAGS_CHECKED_HASH_EXTENDED_PROC

#define TCFLAGS_CHECKED_HASH_EXTENDED_PROC   0x000100

Definition at line 92 of file typcache.c.

TCFLAGS_CHECKED_HASH_OPCLASS

#define TCFLAGS_CHECKED_HASH_OPCLASS   0x000004

Definition at line 86 of file typcache.c.

TCFLAGS_CHECKED_HASH_PROC

#define TCFLAGS_CHECKED_HASH_PROC   0x000080

Definition at line 91 of file typcache.c.

TCFLAGS_CHECKED_LT_OPR

#define TCFLAGS_CHECKED_LT_OPR   0x000010

Definition at line 88 of file typcache.c.

TCFLAGS_DOMAIN_BASE_IS_COMPOSITE

#define TCFLAGS_DOMAIN_BASE_IS_COMPOSITE   0x100000

Definition at line 104 of file typcache.c.

TCFLAGS_HAVE_ELEM_COMPARE

#define TCFLAGS_HAVE_ELEM_COMPARE   0x000800

Definition at line 95 of file typcache.c.

TCFLAGS_HAVE_ELEM_EQUALITY

#define TCFLAGS_HAVE_ELEM_EQUALITY   0x000400

Definition at line 94 of file typcache.c.

TCFLAGS_HAVE_ELEM_EXTENDED_HASHING

#define TCFLAGS_HAVE_ELEM_EXTENDED_HASHING   0x002000

Definition at line 97 of file typcache.c.

TCFLAGS_HAVE_ELEM_HASHING

#define TCFLAGS_HAVE_ELEM_HASHING   0x001000

Definition at line 96 of file typcache.c.

TCFLAGS_HAVE_FIELD_COMPARE

#define TCFLAGS_HAVE_FIELD_COMPARE   0x010000

Definition at line 100 of file typcache.c.

TCFLAGS_HAVE_FIELD_EQUALITY

#define TCFLAGS_HAVE_FIELD_EQUALITY   0x008000

Definition at line 99 of file typcache.c.

TCFLAGS_HAVE_FIELD_EXTENDED_HASHING

#define TCFLAGS_HAVE_FIELD_EXTENDED_HASHING   0x040000

Definition at line 102 of file typcache.c.

TCFLAGS_HAVE_FIELD_HASHING

#define TCFLAGS_HAVE_FIELD_HASHING   0x020000

Definition at line 101 of file typcache.c.

TCFLAGS_HAVE_PG_TYPE_DATA

#define TCFLAGS_HAVE_PG_TYPE_DATA   0x000001

Definition at line 84 of file typcache.c.

TCFLAGS_OPERATOR_FLAGS

#define TCFLAGS_OPERATOR_FLAGS

Value:

    (~(TCFLAGS_HAVE_PG_TYPE_DATA | \
       TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS | \
       TCFLAGS_DOMAIN_BASE_IS_COMPOSITE))

Definition at line 107 of file typcache.c.

Typedef Documentation

RecordCacheArrayEntry

typedef struct RecordCacheArrayEntry RecordCacheArrayEntry

RecordCacheEntry

typedef struct RecordCacheEntry RecordCacheEntry

SharedRecordTableEntry

typedef struct SharedRecordTableEntry SharedRecordTableEntry

SharedRecordTableKey

typedef struct SharedRecordTableKey SharedRecordTableKey

SharedTypmodTableEntry

typedef struct SharedTypmodTableEntry SharedTypmodTableEntry

TypeCacheEnumData

typedef struct TypeCacheEnumData TypeCacheEnumData

Function Documentation

array_element_has_compare()

static bool array_element_has_compare ( TypeCacheEntry *  typentry )

static

Definition at line 1452 of file typcache.c.

{
    if (!(typentry->flags & TCFLAGS_CHECKED_ELEM_PROPERTIES))
        cache_array_element_properties(typentry);
    return (typentry->flags & TCFLAGS_HAVE_ELEM_COMPARE) != 0;
}

References cache_array_element_properties(), TypeCacheEntry::flags, TCFLAGS_CHECKED_ELEM_PROPERTIES, and TCFLAGS_HAVE_ELEM_COMPARE.

Referenced by lookup_type_cache().

array_element_has_equality()

static bool array_element_has_equality ( TypeCacheEntry *  typentry )

static

Definition at line 1444 of file typcache.c.

{
    if (!(typentry->flags & TCFLAGS_CHECKED_ELEM_PROPERTIES))
        cache_array_element_properties(typentry);
    return (typentry->flags & TCFLAGS_HAVE_ELEM_EQUALITY) != 0;
}

References cache_array_element_properties(), TypeCacheEntry::flags, TCFLAGS_CHECKED_ELEM_PROPERTIES, and TCFLAGS_HAVE_ELEM_EQUALITY.

Referenced by lookup_type_cache().

array_element_has_extended_hashing()

static bool array_element_has_extended_hashing ( TypeCacheEntry *  typentry )

static

Definition at line 1468 of file typcache.c.

{
    if (!(typentry->flags & TCFLAGS_CHECKED_ELEM_PROPERTIES))
        cache_array_element_properties(typentry);
    return (typentry->flags & TCFLAGS_HAVE_ELEM_EXTENDED_HASHING) != 0;
}

References cache_array_element_properties(), TypeCacheEntry::flags, TCFLAGS_CHECKED_ELEM_PROPERTIES, and TCFLAGS_HAVE_ELEM_EXTENDED_HASHING.

Referenced by lookup_type_cache().

array_element_has_hashing()

static bool array_element_has_hashing ( TypeCacheEntry *  typentry )

static

Definition at line 1460 of file typcache.c.

{
    if (!(typentry->flags & TCFLAGS_CHECKED_ELEM_PROPERTIES))
        cache_array_element_properties(typentry);
    return (typentry->flags & TCFLAGS_HAVE_ELEM_HASHING) != 0;
}

References cache_array_element_properties(), TypeCacheEntry::flags, TCFLAGS_CHECKED_ELEM_PROPERTIES, and TCFLAGS_HAVE_ELEM_HASHING.

Referenced by lookup_type_cache().

assign_record_type_identifier()

uint64 assign_record_type_identifier	(	Oid	type_id,
		int32	typmod
	)

Definition at line 2062 of file typcache.c.

{
    if (type_id != RECORDOID)
    {
        /*
         * It's a named composite type, so use the regular typcache.
         */
        TypeCacheEntry *typentry;
 
        typentry = lookup_type_cache(type_id, TYPECACHE_TUPDESC);
        if (typentry->tupDesc == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("type %s is not composite",
                            format_type_be(type_id))));
        Assert(typentry->tupDesc_identifier != 0);
        return typentry->tupDesc_identifier;
    }
    else
    {
        /*
         * It's a transient record type, so look in our record-type table.
         */
        if (typmod >= 0 && typmod < RecordCacheArrayLen &&
            RecordCacheArray[typmod].tupdesc != NULL)
        {
            Assert(RecordCacheArray[typmod].id != 0);
            return RecordCacheArray[typmod].id;
        }
 
        /* For anonymous or unrecognized record type, generate a new ID */
        return ++tupledesc_id_counter;
    }
}

References Assert, ereport, errcode(), errmsg(), ERROR, format_type_be(), RecordCacheArrayEntry::id, lookup_type_cache(), RecordCacheArray, RecordCacheArrayLen, TypeCacheEntry::tupDesc, TypeCacheEntry::tupDesc_identifier, tupledesc_id_counter, and TYPECACHE_TUPDESC.

Referenced by expanded_record_fetch_tupdesc(), make_expanded_record_from_tupdesc(), and make_expanded_record_from_typeid().

assign_record_type_typmod()

void assign_record_type_typmod

(

TupleDesc

tupDesc

)

Definition at line 1970 of file typcache.c.

{
    RecordCacheEntry *recentry;
    TupleDesc   entDesc;
    bool        found;
    MemoryContext oldcxt;
 
    Assert(tupDesc->tdtypeid == RECORDOID);
 
    if (RecordCacheHash == NULL)
    {
        /* First time through: initialize the hash table */
        HASHCTL     ctl;
 
        ctl.keysize = sizeof(TupleDesc);    /* just the pointer */
        ctl.entrysize = sizeof(RecordCacheEntry);
        ctl.hash = record_type_typmod_hash;
        ctl.match = record_type_typmod_compare;
        RecordCacheHash = hash_create("Record information cache", 64,
                                      &ctl,
                                      HASH_ELEM | HASH_FUNCTION | HASH_COMPARE);
 
        /* Also make sure CacheMemoryContext exists */
        if (!CacheMemoryContext)
            CreateCacheMemoryContext();
    }
 
    /*
     * Find a hashtable entry for this tuple descriptor. We don't use
     * HASH_ENTER yet, because if it's missing, we need to make sure that all
     * the allocations succeed before we create the new entry.
     */
    recentry = (RecordCacheEntry *) hash_search(RecordCacheHash,
                                                &tupDesc,
                                                HASH_FIND, &found);
    if (found && recentry->tupdesc != NULL)
    {
        tupDesc->tdtypmod = recentry->tupdesc->tdtypmod;
        return;
    }
 
    /* Not present, so need to manufacture an entry */
    oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
 
    /* Look in the SharedRecordTypmodRegistry, if attached */
    entDesc = find_or_make_matching_shared_tupledesc(tupDesc);
    if (entDesc == NULL)
    {
        /*
         * Make sure we have room before we CreateTupleDescCopy() or advance
         * NextRecordTypmod.
         */
        ensure_record_cache_typmod_slot_exists(NextRecordTypmod);
 
        /* Reference-counted local cache only. */
        entDesc = CreateTupleDescCopy(tupDesc);
        entDesc->tdrefcount = 1;
        entDesc->tdtypmod = NextRecordTypmod++;
    }
    else
    {
        ensure_record_cache_typmod_slot_exists(entDesc->tdtypmod);
    }
 
    RecordCacheArray[entDesc->tdtypmod].tupdesc = entDesc;
 
    /* Assign a unique tupdesc identifier, too. */
    RecordCacheArray[entDesc->tdtypmod].id = ++tupledesc_id_counter;
 
    /* Fully initialized; create the hash table entry */
    recentry = (RecordCacheEntry *) hash_search(RecordCacheHash,
                                                &tupDesc,
                                                HASH_ENTER, NULL);
    recentry->tupdesc = entDesc;
 
    /* Update the caller's tuple descriptor. */
    tupDesc->tdtypmod = entDesc->tdtypmod;
 
    MemoryContextSwitchTo(oldcxt);
}

References Assert, CacheMemoryContext, CreateCacheMemoryContext(), CreateTupleDescCopy(), ctl, ensure_record_cache_typmod_slot_exists(), find_or_make_matching_shared_tupledesc(), HASH_COMPARE, hash_create(), HASH_ELEM, HASH_ENTER, HASH_FIND, HASH_FUNCTION, hash_search(), RecordCacheArrayEntry::id, MemoryContextSwitchTo(), NextRecordTypmod, record_type_typmod_compare(), record_type_typmod_hash(), RecordCacheArray, RecordCacheHash, TupleDescData::tdrefcount, TupleDescData::tdtypeid, TupleDescData::tdtypmod, RecordCacheEntry::tupdesc, RecordCacheArrayEntry::tupdesc, and tupledesc_id_counter.

Referenced by BlessTupleDesc(), ER_get_flat_size(), internal_get_result_type(), and SPI_returntuple().

cache_array_element_properties()

static void cache_array_element_properties ( TypeCacheEntry *  typentry )

static

Definition at line 1476 of file typcache.c.

{
    Oid         elem_type = get_base_element_type(typentry->type_id);
 
    if (OidIsValid(elem_type))
    {
        TypeCacheEntry *elementry;
 
        elementry = lookup_type_cache(elem_type,
                                      TYPECACHE_EQ_OPR |
                                      TYPECACHE_CMP_PROC |
                                      TYPECACHE_HASH_PROC |
                                      TYPECACHE_HASH_EXTENDED_PROC);
        if (OidIsValid(elementry->eq_opr))
            typentry->flags |= TCFLAGS_HAVE_ELEM_EQUALITY;
        if (OidIsValid(elementry->cmp_proc))
            typentry->flags |= TCFLAGS_HAVE_ELEM_COMPARE;
        if (OidIsValid(elementry->hash_proc))
            typentry->flags |= TCFLAGS_HAVE_ELEM_HASHING;
        if (OidIsValid(elementry->hash_extended_proc))
            typentry->flags |= TCFLAGS_HAVE_ELEM_EXTENDED_HASHING;
    }
    typentry->flags |= TCFLAGS_CHECKED_ELEM_PROPERTIES;
}

References TypeCacheEntry::cmp_proc, TypeCacheEntry::eq_opr, TypeCacheEntry::flags, get_base_element_type(), TypeCacheEntry::hash_extended_proc, TypeCacheEntry::hash_proc, lookup_type_cache(), OidIsValid, TCFLAGS_CHECKED_ELEM_PROPERTIES, TCFLAGS_HAVE_ELEM_COMPARE, TCFLAGS_HAVE_ELEM_EQUALITY, TCFLAGS_HAVE_ELEM_EXTENDED_HASHING, TCFLAGS_HAVE_ELEM_HASHING, TypeCacheEntry::type_id, TYPECACHE_CMP_PROC, TYPECACHE_EQ_OPR, TYPECACHE_HASH_EXTENDED_PROC, and TYPECACHE_HASH_PROC.

Referenced by array_element_has_compare(), array_element_has_equality(), array_element_has_extended_hashing(), and array_element_has_hashing().

cache_multirange_element_properties()

static void cache_multirange_element_properties ( TypeCacheEntry *  typentry )

static

Definition at line 1699 of file typcache.c.

{
    /* load up range link if we didn't already */
    if (typentry->rngtype == NULL &&
        typentry->typtype == TYPTYPE_MULTIRANGE)
        load_multirangetype_info(typentry);
 
    if (typentry->rngtype != NULL && typentry->rngtype->rngelemtype != NULL)
    {
        TypeCacheEntry *elementry;
 
        /* might need to calculate subtype's hash function properties */
        elementry = lookup_type_cache(typentry->rngtype->rngelemtype->type_id,
                                      TYPECACHE_HASH_PROC |
                                      TYPECACHE_HASH_EXTENDED_PROC);
        if (OidIsValid(elementry->hash_proc))
            typentry->flags |= TCFLAGS_HAVE_ELEM_HASHING;
        if (OidIsValid(elementry->hash_extended_proc))
            typentry->flags |= TCFLAGS_HAVE_ELEM_EXTENDED_HASHING;
    }
    typentry->flags |= TCFLAGS_CHECKED_ELEM_PROPERTIES;
}

References TypeCacheEntry::flags, TypeCacheEntry::hash_extended_proc, TypeCacheEntry::hash_proc, load_multirangetype_info(), lookup_type_cache(), OidIsValid, TypeCacheEntry::rngelemtype, TypeCacheEntry::rngtype, TCFLAGS_CHECKED_ELEM_PROPERTIES, TCFLAGS_HAVE_ELEM_EXTENDED_HASHING, TCFLAGS_HAVE_ELEM_HASHING, TypeCacheEntry::type_id, TYPECACHE_HASH_EXTENDED_PROC, TYPECACHE_HASH_PROC, and TypeCacheEntry::typtype.

Referenced by multirange_element_has_extended_hashing(), and multirange_element_has_hashing().

cache_range_element_properties()

static void cache_range_element_properties ( TypeCacheEntry *  typentry )

static

Definition at line 1659 of file typcache.c.

{
    /* load up subtype link if we didn't already */
    if (typentry->rngelemtype == NULL &&
        typentry->typtype == TYPTYPE_RANGE)
        load_rangetype_info(typentry);
 
    if (typentry->rngelemtype != NULL)
    {
        TypeCacheEntry *elementry;
 
        /* might need to calculate subtype's hash function properties */
        elementry = lookup_type_cache(typentry->rngelemtype->type_id,
                                      TYPECACHE_HASH_PROC |
                                      TYPECACHE_HASH_EXTENDED_PROC);
        if (OidIsValid(elementry->hash_proc))
            typentry->flags |= TCFLAGS_HAVE_ELEM_HASHING;
        if (OidIsValid(elementry->hash_extended_proc))
            typentry->flags |= TCFLAGS_HAVE_ELEM_EXTENDED_HASHING;
    }
    typentry->flags |= TCFLAGS_CHECKED_ELEM_PROPERTIES;
}

References TypeCacheEntry::flags, TypeCacheEntry::hash_extended_proc, TypeCacheEntry::hash_proc, load_rangetype_info(), lookup_type_cache(), OidIsValid, TypeCacheEntry::rngelemtype, TCFLAGS_CHECKED_ELEM_PROPERTIES, TCFLAGS_HAVE_ELEM_EXTENDED_HASHING, TCFLAGS_HAVE_ELEM_HASHING, TypeCacheEntry::type_id, TYPECACHE_HASH_EXTENDED_PROC, TYPECACHE_HASH_PROC, and TypeCacheEntry::typtype.

Referenced by range_element_has_extended_hashing(), and range_element_has_hashing().

cache_record_field_properties()

static void cache_record_field_properties ( TypeCacheEntry *  typentry )

static

Definition at line 1538 of file typcache.c.

{
    /*
     * For type RECORD, we can't really tell what will work, since we don't
     * have access here to the specific anonymous type.  Just assume that
     * equality and comparison will (we may get a failure at runtime).  We
     * could also claim that hashing works, but then if code that has the
     * option between a comparison-based (sort-based) and a hash-based plan
     * chooses hashing, stuff could fail that would otherwise work if it chose
     * a comparison-based plan.  In practice more types support comparison
     * than hashing.
     */
    if (typentry->type_id == RECORDOID)
    {
        typentry->flags |= (TCFLAGS_HAVE_FIELD_EQUALITY |
                            TCFLAGS_HAVE_FIELD_COMPARE);
    }
    else if (typentry->typtype == TYPTYPE_COMPOSITE)
    {
        TupleDesc   tupdesc;
        int         newflags;
        int         i;
 
        /* Fetch composite type's tupdesc if we don't have it already */
        if (typentry->tupDesc == NULL)
            load_typcache_tupdesc(typentry);
        tupdesc = typentry->tupDesc;
 
        /* Must bump the refcount while we do additional catalog lookups */
        IncrTupleDescRefCount(tupdesc);
 
        /* Have each property if all non-dropped fields have the property */
        newflags = (TCFLAGS_HAVE_FIELD_EQUALITY |
                    TCFLAGS_HAVE_FIELD_COMPARE |
                    TCFLAGS_HAVE_FIELD_HASHING |
                    TCFLAGS_HAVE_FIELD_EXTENDED_HASHING);
        for (i = 0; i < tupdesc->natts; i++)
        {
            TypeCacheEntry *fieldentry;
            Form_pg_attribute attr = TupleDescAttr(tupdesc, i);
 
            if (attr->attisdropped)
                continue;
 
            fieldentry = lookup_type_cache(attr->atttypid,
                                           TYPECACHE_EQ_OPR |
                                           TYPECACHE_CMP_PROC |
                                           TYPECACHE_HASH_PROC |
                                           TYPECACHE_HASH_EXTENDED_PROC);
            if (!OidIsValid(fieldentry->eq_opr))
                newflags &= ~TCFLAGS_HAVE_FIELD_EQUALITY;
            if (!OidIsValid(fieldentry->cmp_proc))
                newflags &= ~TCFLAGS_HAVE_FIELD_COMPARE;
            if (!OidIsValid(fieldentry->hash_proc))
                newflags &= ~TCFLAGS_HAVE_FIELD_HASHING;
            if (!OidIsValid(fieldentry->hash_extended_proc))
                newflags &= ~TCFLAGS_HAVE_FIELD_EXTENDED_HASHING;
 
            /* We can drop out of the loop once we disprove all bits */
            if (newflags == 0)
                break;
        }
        typentry->flags |= newflags;
 
        DecrTupleDescRefCount(tupdesc);
    }
    else if (typentry->typtype == TYPTYPE_DOMAIN)
    {
        /* If it's domain over composite, copy base type's properties */
        TypeCacheEntry *baseentry;
 
        /* load up basetype info if we didn't already */
        if (typentry->domainBaseType == InvalidOid)
        {
            typentry->domainBaseTypmod = -1;
            typentry->domainBaseType =
                getBaseTypeAndTypmod(typentry->type_id,
                                     &typentry->domainBaseTypmod);
        }
        baseentry = lookup_type_cache(typentry->domainBaseType,
                                      TYPECACHE_EQ_OPR |
                                      TYPECACHE_CMP_PROC |
                                      TYPECACHE_HASH_PROC |
                                      TYPECACHE_HASH_EXTENDED_PROC);
        if (baseentry->typtype == TYPTYPE_COMPOSITE)
        {
            typentry->flags |= TCFLAGS_DOMAIN_BASE_IS_COMPOSITE;
            typentry->flags |= baseentry->flags & (TCFLAGS_HAVE_FIELD_EQUALITY |
                                                   TCFLAGS_HAVE_FIELD_COMPARE |
                                                   TCFLAGS_HAVE_FIELD_HASHING |
                                                   TCFLAGS_HAVE_FIELD_EXTENDED_HASHING);
        }
    }
    typentry->flags |= TCFLAGS_CHECKED_FIELD_PROPERTIES;
}

References TypeCacheEntry::cmp_proc, DecrTupleDescRefCount(), TypeCacheEntry::domainBaseType, TypeCacheEntry::domainBaseTypmod, TypeCacheEntry::eq_opr, TypeCacheEntry::flags, getBaseTypeAndTypmod(), TypeCacheEntry::hash_extended_proc, TypeCacheEntry::hash_proc, i, IncrTupleDescRefCount(), InvalidOid, load_typcache_tupdesc(), lookup_type_cache(), TupleDescData::natts, OidIsValid, TCFLAGS_CHECKED_FIELD_PROPERTIES, TCFLAGS_DOMAIN_BASE_IS_COMPOSITE, TCFLAGS_HAVE_FIELD_COMPARE, TCFLAGS_HAVE_FIELD_EQUALITY, TCFLAGS_HAVE_FIELD_EXTENDED_HASHING, TCFLAGS_HAVE_FIELD_HASHING, TypeCacheEntry::tupDesc, TupleDescAttr, TypeCacheEntry::type_id, TYPECACHE_CMP_PROC, TYPECACHE_EQ_OPR, TYPECACHE_HASH_EXTENDED_PROC, TYPECACHE_HASH_PROC, and TypeCacheEntry::typtype.

Referenced by record_fields_have_compare(), record_fields_have_equality(), record_fields_have_extended_hashing(), and record_fields_have_hashing().

compare_values_of_enum()

int compare_values_of_enum	(	TypeCacheEntry *	tcache,
		Oid	arg1,
		Oid	arg2
	)

Definition at line 2502 of file typcache.c.

{
    TypeCacheEnumData *enumdata;
    EnumItem   *item1;
    EnumItem   *item2;
 
    /*
     * Equal OIDs are certainly equal --- this case was probably handled by
     * our caller, but we may as well check.
     */
    if (arg1 == arg2)
        return 0;
 
    /* Load up the cache if first time through */
    if (tcache->enumData == NULL)
        load_enum_cache_data(tcache);
    enumdata = tcache->enumData;
 
    /*
     * If both OIDs are known-sorted, we can just compare them directly.
     */
    if (enum_known_sorted(enumdata, arg1) &&
        enum_known_sorted(enumdata, arg2))
    {
        if (arg1 < arg2)
            return -1;
        else
            return 1;
    }
 
    /*
     * Slow path: we have to identify their actual sort-order positions.
     */
    item1 = find_enumitem(enumdata, arg1);
    item2 = find_enumitem(enumdata, arg2);
 
    if (item1 == NULL || item2 == NULL)
    {
        /*
         * We couldn't find one or both values.  That means the enum has
         * changed under us, so re-initialize the cache and try again. We
         * don't bother retrying the known-sorted case in this path.
         */
        load_enum_cache_data(tcache);
        enumdata = tcache->enumData;
 
        item1 = find_enumitem(enumdata, arg1);
        item2 = find_enumitem(enumdata, arg2);
 
        /*
         * If we still can't find the values, complain: we must have corrupt
         * data.
         */
        if (item1 == NULL)
            elog(ERROR, "enum value %u not found in cache for enum %s",
                 arg1, format_type_be(tcache->type_id));
        if (item2 == NULL)
            elog(ERROR, "enum value %u not found in cache for enum %s",
                 arg2, format_type_be(tcache->type_id));
    }
 
    if (item1->sort_order < item2->sort_order)
        return -1;
    else if (item1->sort_order > item2->sort_order)
        return 1;
    else
        return 0;
}

References elog, enum_known_sorted(), TypeCacheEntry::enumData, ERROR, find_enumitem(), format_type_be(), load_enum_cache_data(), EnumItem::sort_order, and TypeCacheEntry::type_id.

Referenced by enum_cmp_internal().

dccref_deletion_callback()

static void dccref_deletion_callback ( void *  arg )

static

Definition at line 1271 of file typcache.c.

{
    DomainConstraintRef *ref = (DomainConstraintRef *) arg;
    DomainConstraintCache *dcc = ref->dcc;
 
    /* Paranoia --- be sure link is nulled before trying to release */
    if (dcc)
    {
        ref->constraints = NIL;
        ref->dcc = NULL;
        decr_dcc_refcount(dcc);
    }
}

References arg, DomainConstraintRef::constraints, DomainConstraintRef::dcc, decr_dcc_refcount(), and NIL.

Referenced by InitDomainConstraintRef().

dcs_cmp()

static int dcs_cmp ( const void *  a, const void *  b  )

static

Definition at line 1247 of file typcache.c.

{
    const DomainConstraintState *const *ca = (const DomainConstraintState *const *) a;
    const DomainConstraintState *const *cb = (const DomainConstraintState *const *) b;
 
    return strcmp((*ca)->name, (*cb)->name);
}

References a, and b.

Referenced by load_domaintype_info().

decr_dcc_refcount()

static void decr_dcc_refcount ( DomainConstraintCache *  dcc )

static

Definition at line 1260 of file typcache.c.

{
    Assert(dcc->dccRefCount > 0);
    if (--(dcc->dccRefCount) <= 0)
        MemoryContextDelete(dcc->dccContext);
}

References Assert, DomainConstraintCache::dccContext, DomainConstraintCache::dccRefCount, and MemoryContextDelete().

Referenced by dccref_deletion_callback(), load_domaintype_info(), and UpdateDomainConstraintRef().

DomainHasConstraints()

bool DomainHasConstraints

(

Oid

type_id

)

Definition at line 1417 of file typcache.c.

{
    TypeCacheEntry *typentry;
 
    /*
     * Note: a side effect is to cause the typcache's domain data to become
     * valid.  This is fine since we'll likely need it soon if there is any.
     */
    typentry = lookup_type_cache(type_id, TYPECACHE_DOMAIN_CONSTR_INFO);
 
    return (typentry->domainData != NULL);
}

References TypeCacheEntry::domainData, lookup_type_cache(), and TYPECACHE_DOMAIN_CONSTR_INFO.

Referenced by ATColumnChangeRequiresRewrite(), ATExecAddColumn(), eval_const_expressions_mutator(), ExecInitJsonCoercion(), and transformJsonFuncExpr().

ensure_record_cache_typmod_slot_exists()

static void ensure_record_cache_typmod_slot_exists ( int32  typmod )

static

Definition at line 1727 of file typcache.c.

{
    if (RecordCacheArray == NULL)
    {
        RecordCacheArray = (RecordCacheArrayEntry *)
            MemoryContextAllocZero(CacheMemoryContext,
                                   64 * sizeof(RecordCacheArrayEntry));
        RecordCacheArrayLen = 64;
    }
 
    if (typmod >= RecordCacheArrayLen)
    {
        int32       newlen = pg_nextpower2_32(typmod + 1);
 
        RecordCacheArray = repalloc0_array(RecordCacheArray,
                                           RecordCacheArrayEntry,
                                           RecordCacheArrayLen,
                                           newlen);
        RecordCacheArrayLen = newlen;
    }
}

References CacheMemoryContext, MemoryContextAllocZero(), pg_nextpower2_32(), RecordCacheArray, RecordCacheArrayLen, and repalloc0_array.

Referenced by assign_record_type_typmod(), and lookup_rowtype_tupdesc_internal().

enum_known_sorted()

static bool enum_known_sorted ( TypeCacheEnumData *  enumdata, Oid  arg  )

inlinestatic

Definition at line 2473 of file typcache.c.

{
    Oid         offset;
 
    if (arg < enumdata->bitmap_base)
        return false;
    offset = arg - enumdata->bitmap_base;
    if (offset > (Oid) INT_MAX)
        return false;
    return bms_is_member((int) offset, enumdata->sorted_values);
}

References arg, TypeCacheEnumData::bitmap_base, bms_is_member(), and TypeCacheEnumData::sorted_values.

Referenced by compare_values_of_enum().

enum_oid_cmp()

static int enum_oid_cmp ( const void *  left, const void *  right  )

static

Definition at line 2747 of file typcache.c.

{
    const EnumItem *l = (const EnumItem *) left;
    const EnumItem *r = (const EnumItem *) right;
 
    return pg_cmp_u32(l->enum_oid, r->enum_oid);
}

References EnumItem::enum_oid, and pg_cmp_u32().

Referenced by find_enumitem(), and load_enum_cache_data().

find_enumitem()

static EnumItem * find_enumitem ( TypeCacheEnumData *  enumdata, Oid  arg  )

static

Definition at line 2730 of file typcache.c.

{
    EnumItem    srch;
 
    /* On some versions of Solaris, bsearch of zero items dumps core */
    if (enumdata->num_values <= 0)
        return NULL;
 
    srch.enum_oid = arg;
    return bsearch(&srch, enumdata->enum_values, enumdata->num_values,
                   sizeof(EnumItem), enum_oid_cmp);
}

References arg, EnumItem::enum_oid, enum_oid_cmp(), TypeCacheEnumData::enum_values, and TypeCacheEnumData::num_values.

Referenced by compare_values_of_enum().

find_or_make_matching_shared_tupledesc()

static TupleDesc find_or_make_matching_shared_tupledesc ( TupleDesc  tupdesc )

static

Definition at line 2781 of file typcache.c.

{
    TupleDesc   result;
    SharedRecordTableKey key;
    SharedRecordTableEntry *record_table_entry;
    SharedTypmodTableEntry *typmod_table_entry;
    dsa_pointer shared_dp;
    bool        found;
    uint32      typmod;
 
    /* If not even attached, nothing to do. */
    if (CurrentSession->shared_typmod_registry == NULL)
        return NULL;
 
    /* Try to find a matching tuple descriptor in the record table. */
    key.shared = false;
    key.u.local_tupdesc = tupdesc;
    record_table_entry = (SharedRecordTableEntry *)
        dshash_find(CurrentSession->shared_record_table, &key, false);
    if (record_table_entry)
    {
        Assert(record_table_entry->key.shared);
        dshash_release_lock(CurrentSession->shared_record_table,
                            record_table_entry);
        result = (TupleDesc)
            dsa_get_address(CurrentSession->area,
                            record_table_entry->key.u.shared_tupdesc);
        Assert(result->tdrefcount == -1);
 
        return result;
    }
 
    /* Allocate a new typmod number.  This will be wasted if we error out. */
    typmod = (int)
        pg_atomic_fetch_add_u32(&CurrentSession->shared_typmod_registry->next_typmod,
                                1);
 
    /* Copy the TupleDesc into shared memory. */
    shared_dp = share_tupledesc(CurrentSession->area, tupdesc, typmod);
 
    /*
     * Create an entry in the typmod table so that others will understand this
     * typmod number.
     */
    PG_TRY();
    {
        typmod_table_entry = (SharedTypmodTableEntry *)
            dshash_find_or_insert(CurrentSession->shared_typmod_table,
                                  &typmod, &found);
        if (found)
            elog(ERROR, "cannot create duplicate shared record typmod");
    }
    PG_CATCH();
    {
        dsa_free(CurrentSession->area, shared_dp);
        PG_RE_THROW();
    }
    PG_END_TRY();
    typmod_table_entry->typmod = typmod;
    typmod_table_entry->shared_tupdesc = shared_dp;
    dshash_release_lock(CurrentSession->shared_typmod_table,
                        typmod_table_entry);
 
    /*
     * Finally create an entry in the record table so others with matching
     * tuple descriptors can reuse the typmod.
     */
    record_table_entry = (SharedRecordTableEntry *)
        dshash_find_or_insert(CurrentSession->shared_record_table, &key,
                              &found);
    if (found)
    {
        /*
         * Someone concurrently inserted a matching tuple descriptor since the
         * first time we checked.  Use that one instead.
         */
        dshash_release_lock(CurrentSession->shared_record_table,
                            record_table_entry);
 
        /* Might as well free up the space used by the one we created. */
        found = dshash_delete_key(CurrentSession->shared_typmod_table,
                                  &typmod);
        Assert(found);
        dsa_free(CurrentSession->area, shared_dp);
 
        /* Return the one we found. */
        Assert(record_table_entry->key.shared);
        result = (TupleDesc)
            dsa_get_address(CurrentSession->area,
                            record_table_entry->key.u.shared_tupdesc);
        Assert(result->tdrefcount == -1);
 
        return result;
    }
 
    /* Store it and return it. */
    record_table_entry->key.shared = true;
    record_table_entry->key.u.shared_tupdesc = shared_dp;
    dshash_release_lock(CurrentSession->shared_record_table,
                        record_table_entry);
    result = (TupleDesc)
        dsa_get_address(CurrentSession->area, shared_dp);
    Assert(result->tdrefcount == -1);
 
    return result;
}

References Session::area, Assert, CurrentSession, dsa_free(), dsa_get_address(), dshash_delete_key(), dshash_find(), dshash_find_or_insert(), dshash_release_lock(), elog, ERROR, SharedRecordTableEntry::key, sort-test::key, SharedRecordTypmodRegistry::next_typmod, pg_atomic_fetch_add_u32(), PG_CATCH, PG_END_TRY, PG_RE_THROW, PG_TRY, share_tupledesc(), SharedRecordTableKey::shared, Session::shared_record_table, SharedRecordTableKey::shared_tupdesc, SharedTypmodTableEntry::shared_tupdesc, Session::shared_typmod_registry, Session::shared_typmod_table, TupleDescData::tdrefcount, SharedTypmodTableEntry::typmod, and SharedRecordTableKey::u.

Referenced by assign_record_type_typmod().

InitDomainConstraintRef()

void InitDomainConstraintRef	(	Oid	type_id,
		DomainConstraintRef *	ref,
		MemoryContext	refctx,
		bool	need_exprstate
	)

Definition at line 1330 of file typcache.c.

{
    /* Look up the typcache entry --- we assume it survives indefinitely */
    ref->tcache = lookup_type_cache(type_id, TYPECACHE_DOMAIN_CONSTR_INFO);
    ref->need_exprstate = need_exprstate;
    /* For safety, establish the callback before acquiring a refcount */
    ref->refctx = refctx;
    ref->dcc = NULL;
    ref->callback.func = dccref_deletion_callback;
    ref->callback.arg = (void *) ref;
    MemoryContextRegisterResetCallback(refctx, &ref->callback);
    /* Acquire refcount if there are constraints, and set up exported list */
    if (ref->tcache->domainData)
    {
        ref->dcc = ref->tcache->domainData;
        ref->dcc->dccRefCount++;
        if (ref->need_exprstate)
            ref->constraints = prep_domain_constraints(ref->dcc->constraints,
                                                       ref->refctx);
        else
            ref->constraints = ref->dcc->constraints;
    }
    else
        ref->constraints = NIL;
}

References MemoryContextCallback::arg, DomainConstraintRef::callback, DomainConstraintCache::constraints, DomainConstraintRef::constraints, DomainConstraintRef::dcc, dccref_deletion_callback(), DomainConstraintCache::dccRefCount, TypeCacheEntry::domainData, MemoryContextCallback::func, lookup_type_cache(), MemoryContextRegisterResetCallback(), DomainConstraintRef::need_exprstate, NIL, prep_domain_constraints(), DomainConstraintRef::refctx, DomainConstraintRef::tcache, and TYPECACHE_DOMAIN_CONSTR_INFO.

Referenced by domain_state_setup(), and ExecInitCoerceToDomain().

load_domaintype_info()

static void load_domaintype_info ( TypeCacheEntry *  typentry )

static

Definition at line 1011 of file typcache.c.

{
    Oid         typeOid = typentry->type_id;
    DomainConstraintCache *dcc;
    bool        notNull = false;
    DomainConstraintState **ccons;
    int         cconslen;
    Relation    conRel;
    MemoryContext oldcxt;
 
    /*
     * If we're here, any existing constraint info is stale, so release it.
     * For safety, be sure to null the link before trying to delete the data.
     */
    if (typentry->domainData)
    {
        dcc = typentry->domainData;
        typentry->domainData = NULL;
        decr_dcc_refcount(dcc);
    }
 
    /*
     * We try to optimize the common case of no domain constraints, so don't
     * create the dcc object and context until we find a constraint.  Likewise
     * for the temp sorting array.
     */
    dcc = NULL;
    ccons = NULL;
    cconslen = 0;
 
    /*
     * Scan pg_constraint for relevant constraints.  We want to find
     * constraints for not just this domain, but any ancestor domains, so the
     * outer loop crawls up the domain stack.
     */
    conRel = table_open(ConstraintRelationId, AccessShareLock);
 
    for (;;)
    {
        HeapTuple   tup;
        HeapTuple   conTup;
        Form_pg_type typTup;
        int         nccons = 0;
        ScanKeyData key[1];
        SysScanDesc scan;
 
        tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typeOid));
        if (!HeapTupleIsValid(tup))
            elog(ERROR, "cache lookup failed for type %u", typeOid);
        typTup = (Form_pg_type) GETSTRUCT(tup);
 
        if (typTup->typtype != TYPTYPE_DOMAIN)
        {
            /* Not a domain, so done */
            ReleaseSysCache(tup);
            break;
        }
 
        /* Test for NOT NULL Constraint */
        if (typTup->typnotnull)
            notNull = true;
 
        /* Look for CHECK Constraints on this domain */
        ScanKeyInit(&key[0],
                    Anum_pg_constraint_contypid,
                    BTEqualStrategyNumber, F_OIDEQ,
                    ObjectIdGetDatum(typeOid));
 
        scan = systable_beginscan(conRel, ConstraintTypidIndexId, true,
                                  NULL, 1, key);
 
        while (HeapTupleIsValid(conTup = systable_getnext(scan)))
        {
            Form_pg_constraint c = (Form_pg_constraint) GETSTRUCT(conTup);
            Datum       val;
            bool        isNull;
            char       *constring;
            Expr       *check_expr;
            DomainConstraintState *r;
 
            /* Ignore non-CHECK constraints */
            if (c->contype != CONSTRAINT_CHECK)
                continue;
 
            /* Not expecting conbin to be NULL, but we'll test for it anyway */
            val = fastgetattr(conTup, Anum_pg_constraint_conbin,
                              conRel->rd_att, &isNull);
            if (isNull)
                elog(ERROR, "domain \"%s\" constraint \"%s\" has NULL conbin",
                     NameStr(typTup->typname), NameStr(c->conname));
 
            /* Convert conbin to C string in caller context */
            constring = TextDatumGetCString(val);
 
            /* Create the DomainConstraintCache object and context if needed */
            if (dcc == NULL)
            {
                MemoryContext cxt;
 
                cxt = AllocSetContextCreate(CurrentMemoryContext,
                                            "Domain constraints",
                                            ALLOCSET_SMALL_SIZES);
                dcc = (DomainConstraintCache *)
                    MemoryContextAlloc(cxt, sizeof(DomainConstraintCache));
                dcc->constraints = NIL;
                dcc->dccContext = cxt;
                dcc->dccRefCount = 0;
            }
 
            /* Create node trees in DomainConstraintCache's context */
            oldcxt = MemoryContextSwitchTo(dcc->dccContext);
 
            check_expr = (Expr *) stringToNode(constring);
 
            /*
             * Plan the expression, since ExecInitExpr will expect that.
             *
             * Note: caching the result of expression_planner() is not very
             * good practice.  Ideally we'd use a CachedExpression here so
             * that we would react promptly to, eg, changes in inlined
             * functions.  However, because we don't support mutable domain
             * CHECK constraints, it's not really clear that it's worth the
             * extra overhead to do that.
             */
            check_expr = expression_planner(check_expr);
 
            r = makeNode(DomainConstraintState);
            r->constrainttype = DOM_CONSTRAINT_CHECK;
            r->name = pstrdup(NameStr(c->conname));
            r->check_expr = check_expr;
            r->check_exprstate = NULL;
 
            MemoryContextSwitchTo(oldcxt);
 
            /* Accumulate constraints in an array, for sorting below */
            if (ccons == NULL)
            {
                cconslen = 8;
                ccons = (DomainConstraintState **)
                    palloc(cconslen * sizeof(DomainConstraintState *));
            }
            else if (nccons >= cconslen)
            {
                cconslen *= 2;
                ccons = (DomainConstraintState **)
                    repalloc(ccons, cconslen * sizeof(DomainConstraintState *));
            }
            ccons[nccons++] = r;
        }
 
        systable_endscan(scan);
 
        if (nccons > 0)
        {
            /*
             * Sort the items for this domain, so that CHECKs are applied in a
             * deterministic order.
             */
            if (nccons > 1)
                qsort(ccons, nccons, sizeof(DomainConstraintState *), dcs_cmp);
 
            /*
             * Now attach them to the overall list.  Use lcons() here because
             * constraints of parent domains should be applied earlier.
             */
            oldcxt = MemoryContextSwitchTo(dcc->dccContext);
            while (nccons > 0)
                dcc->constraints = lcons(ccons[--nccons], dcc->constraints);
            MemoryContextSwitchTo(oldcxt);
        }
 
        /* loop to next domain in stack */
        typeOid = typTup->typbasetype;
        ReleaseSysCache(tup);
    }
 
    table_close(conRel, AccessShareLock);
 
    /*
     * Only need to add one NOT NULL check regardless of how many domains in
     * the stack request it.
     */
    if (notNull)
    {
        DomainConstraintState *r;
 
        /* Create the DomainConstraintCache object and context if needed */
        if (dcc == NULL)
        {
            MemoryContext cxt;
 
            cxt = AllocSetContextCreate(CurrentMemoryContext,
                                        "Domain constraints",
                                        ALLOCSET_SMALL_SIZES);
            dcc = (DomainConstraintCache *)
                MemoryContextAlloc(cxt, sizeof(DomainConstraintCache));
            dcc->constraints = NIL;
            dcc->dccContext = cxt;
            dcc->dccRefCount = 0;
        }
 
        /* Create node trees in DomainConstraintCache's context */
        oldcxt = MemoryContextSwitchTo(dcc->dccContext);
 
        r = makeNode(DomainConstraintState);
 
        r->constrainttype = DOM_CONSTRAINT_NOTNULL;
        r->name = pstrdup("NOT NULL");
        r->check_expr = NULL;
        r->check_exprstate = NULL;
 
        /* lcons to apply the nullness check FIRST */
        dcc->constraints = lcons(r, dcc->constraints);
 
        MemoryContextSwitchTo(oldcxt);
    }
 
    /*
     * If we made a constraint object, move it into CacheMemoryContext and
     * attach it to the typcache entry.
     */
    if (dcc)
    {
        MemoryContextSetParent(dcc->dccContext, CacheMemoryContext);
        typentry->domainData = dcc;
        dcc->dccRefCount++;     /* count the typcache's reference */
    }
 
    /* Either way, the typcache entry's domain data is now valid. */
    typentry->flags |= TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS;
}

References AccessShareLock, ALLOCSET_SMALL_SIZES, AllocSetContextCreate, BTEqualStrategyNumber, CacheMemoryContext, DomainConstraintState::check_expr, DomainConstraintState::check_exprstate, DomainConstraintCache::constraints, DomainConstraintState::constrainttype, CurrentMemoryContext, DomainConstraintCache::dccContext, DomainConstraintCache::dccRefCount, dcs_cmp(), decr_dcc_refcount(), DOM_CONSTRAINT_CHECK, DOM_CONSTRAINT_NOTNULL, TypeCacheEntry::domainData, elog, ERROR, expression_planner(), fastgetattr(), TypeCacheEntry::flags, GETSTRUCT, HeapTupleIsValid, sort-test::key, lcons(), makeNode, MemoryContextAlloc(), MemoryContextSetParent(), MemoryContextSwitchTo(), DomainConstraintState::name, NameStr, NIL, ObjectIdGetDatum(), palloc(), pstrdup(), qsort, RelationData::rd_att, ReleaseSysCache(), repalloc(), ScanKeyInit(), SearchSysCache1(), stringToNode(), systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS, TextDatumGetCString, TypeCacheEntry::type_id, and val.

Referenced by lookup_type_cache(), and UpdateDomainConstraintRef().

load_enum_cache_data()

static void load_enum_cache_data ( TypeCacheEntry *  tcache )

static

Definition at line 2575 of file typcache.c.

{
    TypeCacheEnumData *enumdata;
    Relation    enum_rel;
    SysScanDesc enum_scan;
    HeapTuple   enum_tuple;
    ScanKeyData skey;
    EnumItem   *items;
    int         numitems;
    int         maxitems;
    Oid         bitmap_base;
    Bitmapset  *bitmap;
    MemoryContext oldcxt;
    int         bm_size,
                start_pos;
 
    /* Check that this is actually an enum */
    if (tcache->typtype != TYPTYPE_ENUM)
        ereport(ERROR,
                (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                 errmsg("%s is not an enum",
                        format_type_be(tcache->type_id))));
 
    /*
     * Read all the information for members of the enum type.  We collect the
     * info in working memory in the caller's context, and then transfer it to
     * permanent memory in CacheMemoryContext.  This minimizes the risk of
     * leaking memory from CacheMemoryContext in the event of an error partway
     * through.
     */
    maxitems = 64;
    items = (EnumItem *) palloc(sizeof(EnumItem) * maxitems);
    numitems = 0;
 
    /* Scan pg_enum for the members of the target enum type. */
    ScanKeyInit(&skey,
                Anum_pg_enum_enumtypid,
                BTEqualStrategyNumber, F_OIDEQ,
                ObjectIdGetDatum(tcache->type_id));
 
    enum_rel = table_open(EnumRelationId, AccessShareLock);
    enum_scan = systable_beginscan(enum_rel,
                                   EnumTypIdLabelIndexId,
                                   true, NULL,
                                   1, &skey);
 
    while (HeapTupleIsValid(enum_tuple = systable_getnext(enum_scan)))
    {
        Form_pg_enum en = (Form_pg_enum) GETSTRUCT(enum_tuple);
 
        if (numitems >= maxitems)
        {
            maxitems *= 2;
            items = (EnumItem *) repalloc(items, sizeof(EnumItem) * maxitems);
        }
        items[numitems].enum_oid = en->oid;
        items[numitems].sort_order = en->enumsortorder;
        numitems++;
    }
 
    systable_endscan(enum_scan);
    table_close(enum_rel, AccessShareLock);
 
    /* Sort the items into OID order */
    qsort(items, numitems, sizeof(EnumItem), enum_oid_cmp);
 
    /*
     * Here, we create a bitmap listing a subset of the enum's OIDs that are
     * known to be in order and can thus be compared with just OID comparison.
     *
     * The point of this is that the enum's initial OIDs were certainly in
     * order, so there is some subset that can be compared via OID comparison;
     * and we'd rather not do binary searches unnecessarily.
     *
     * This is somewhat heuristic, and might identify a subset of OIDs that
     * isn't exactly what the type started with.  That's okay as long as the
     * subset is correctly sorted.
     */
    bitmap_base = InvalidOid;
    bitmap = NULL;
    bm_size = 1;                /* only save sets of at least 2 OIDs */
 
    for (start_pos = 0; start_pos < numitems - 1; start_pos++)
    {
        /*
         * Identify longest sorted subsequence starting at start_pos
         */
        Bitmapset  *this_bitmap = bms_make_singleton(0);
        int         this_bm_size = 1;
        Oid         start_oid = items[start_pos].enum_oid;
        float4      prev_order = items[start_pos].sort_order;
        int         i;
 
        for (i = start_pos + 1; i < numitems; i++)
        {
            Oid         offset;
 
            offset = items[i].enum_oid - start_oid;
            /* quit if bitmap would be too large; cutoff is arbitrary */
            if (offset >= 8192)
                break;
            /* include the item if it's in-order */
            if (items[i].sort_order > prev_order)
            {
                prev_order = items[i].sort_order;
                this_bitmap = bms_add_member(this_bitmap, (int) offset);
                this_bm_size++;
            }
        }
 
        /* Remember it if larger than previous best */
        if (this_bm_size > bm_size)
        {
            bms_free(bitmap);
            bitmap_base = start_oid;
            bitmap = this_bitmap;
            bm_size = this_bm_size;
        }
        else
            bms_free(this_bitmap);
 
        /*
         * Done if it's not possible to find a longer sequence in the rest of
         * the list.  In typical cases this will happen on the first
         * iteration, which is why we create the bitmaps on the fly instead of
         * doing a second pass over the list.
         */
        if (bm_size >= (numitems - start_pos - 1))
            break;
    }
 
    /* OK, copy the data into CacheMemoryContext */
    oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
    enumdata = (TypeCacheEnumData *)
        palloc(offsetof(TypeCacheEnumData, enum_values) +
               numitems * sizeof(EnumItem));
    enumdata->bitmap_base = bitmap_base;
    enumdata->sorted_values = bms_copy(bitmap);
    enumdata->num_values = numitems;
    memcpy(enumdata->enum_values, items, numitems * sizeof(EnumItem));
    MemoryContextSwitchTo(oldcxt);
 
    pfree(items);
    bms_free(bitmap);
 
    /* And link the finished cache struct into the typcache */
    if (tcache->enumData != NULL)
        pfree(tcache->enumData);
    tcache->enumData = enumdata;
}

References AccessShareLock, TypeCacheEnumData::bitmap_base, bms_add_member(), bms_copy(), bms_free(), bms_make_singleton(), BTEqualStrategyNumber, CacheMemoryContext, enum_oid_cmp(), TypeCacheEnumData::enum_values, TypeCacheEntry::enumData, ereport, errcode(), errmsg(), ERROR, format_type_be(), GETSTRUCT, HeapTupleIsValid, i, InvalidOid, items, MemoryContextSwitchTo(), TypeCacheEnumData::num_values, ObjectIdGetDatum(), palloc(), pfree(), qsort, repalloc(), ScanKeyInit(), TypeCacheEnumData::sorted_values, systable_beginscan(), systable_endscan(), systable_getnext(), table_close(), table_open(), TypeCacheEntry::type_id, and TypeCacheEntry::typtype.

Referenced by compare_values_of_enum().

load_multirangetype_info()

static void load_multirangetype_info ( TypeCacheEntry *  typentry )

static

Definition at line 989 of file typcache.c.

{
    Oid         rangetypeOid;
 
    rangetypeOid = get_multirange_range(typentry->type_id);
    if (!OidIsValid(rangetypeOid))
        elog(ERROR, "cache lookup failed for multirange type %u",
             typentry->type_id);
 
    typentry->rngtype = lookup_type_cache(rangetypeOid, TYPECACHE_RANGE_INFO);
}

References elog, ERROR, get_multirange_range(), lookup_type_cache(), OidIsValid, TypeCacheEntry::rngtype, TypeCacheEntry::type_id, and TYPECACHE_RANGE_INFO.

Referenced by cache_multirange_element_properties(), and lookup_type_cache().

load_rangetype_info()

static void load_rangetype_info ( TypeCacheEntry *  typentry )

static

Definition at line 931 of file typcache.c.

{
    Form_pg_range pg_range;
    HeapTuple   tup;
    Oid         subtypeOid;
    Oid         opclassOid;
    Oid         canonicalOid;
    Oid         subdiffOid;
    Oid         opfamilyOid;
    Oid         opcintype;
    Oid         cmpFnOid;
 
    /* get information from pg_range */
    tup = SearchSysCache1(RANGETYPE, ObjectIdGetDatum(typentry->type_id));
    /* should not fail, since we already checked typtype ... */
    if (!HeapTupleIsValid(tup))
        elog(ERROR, "cache lookup failed for range type %u",
             typentry->type_id);
    pg_range = (Form_pg_range) GETSTRUCT(tup);
 
    subtypeOid = pg_range->rngsubtype;
    typentry->rng_collation = pg_range->rngcollation;
    opclassOid = pg_range->rngsubopc;
    canonicalOid = pg_range->rngcanonical;
    subdiffOid = pg_range->rngsubdiff;
 
    ReleaseSysCache(tup);
 
    /* get opclass properties and look up the comparison function */
    opfamilyOid = get_opclass_family(opclassOid);
    opcintype = get_opclass_input_type(opclassOid);
    typentry->rng_opfamily = opfamilyOid;
 
    cmpFnOid = get_opfamily_proc(opfamilyOid, opcintype, opcintype,
                                 BTORDER_PROC);
    if (!RegProcedureIsValid(cmpFnOid))
        elog(ERROR, "missing support function %d(%u,%u) in opfamily %u",
             BTORDER_PROC, opcintype, opcintype, opfamilyOid);
 
    /* set up cached fmgrinfo structs */
    fmgr_info_cxt(cmpFnOid, &typentry->rng_cmp_proc_finfo,
                  CacheMemoryContext);
    if (OidIsValid(canonicalOid))
        fmgr_info_cxt(canonicalOid, &typentry->rng_canonical_finfo,
                      CacheMemoryContext);
    if (OidIsValid(subdiffOid))
        fmgr_info_cxt(subdiffOid, &typentry->rng_subdiff_finfo,
                      CacheMemoryContext);
 
    /* Lastly, set up link to the element type --- this marks data valid */
    typentry->rngelemtype = lookup_type_cache(subtypeOid, 0);
}

References BTORDER_PROC, CacheMemoryContext, elog, ERROR, fmgr_info_cxt(), get_opclass_family(), get_opclass_input_type(), get_opfamily_proc(), GETSTRUCT, HeapTupleIsValid, lookup_type_cache(), ObjectIdGetDatum(), OidIsValid, RegProcedureIsValid, ReleaseSysCache(), TypeCacheEntry::rng_canonical_finfo, TypeCacheEntry::rng_cmp_proc_finfo, TypeCacheEntry::rng_collation, TypeCacheEntry::rng_opfamily, TypeCacheEntry::rng_subdiff_finfo, TypeCacheEntry::rngelemtype, SearchSysCache1(), and TypeCacheEntry::type_id.

Referenced by cache_range_element_properties(), and lookup_type_cache().

load_typcache_tupdesc()

static void load_typcache_tupdesc ( TypeCacheEntry *  typentry )

static

Definition at line 897 of file typcache.c.

{
    Relation    rel;
 
    if (!OidIsValid(typentry->typrelid))    /* should not happen */
        elog(ERROR, "invalid typrelid for composite type %u",
             typentry->type_id);
    rel = relation_open(typentry->typrelid, AccessShareLock);
    Assert(rel->rd_rel->reltype == typentry->type_id);
 
    /*
     * Link to the tupdesc and increment its refcount (we assert it's a
     * refcounted descriptor).  We don't use IncrTupleDescRefCount() for this,
     * because the reference mustn't be entered in the current resource owner;
     * it can outlive the current query.
     */
    typentry->tupDesc = RelationGetDescr(rel);
 
    Assert(typentry->tupDesc->tdrefcount > 0);
    typentry->tupDesc->tdrefcount++;
 
    /*
     * In future, we could take some pains to not change tupDesc_identifier if
     * the tupdesc didn't really change; but for now it's not worth it.
     */
    typentry->tupDesc_identifier = ++tupledesc_id_counter;
 
    relation_close(rel, AccessShareLock);
}

References AccessShareLock, Assert, elog, ERROR, OidIsValid, RelationData::rd_rel, relation_close(), relation_open(), RelationGetDescr, TupleDescData::tdrefcount, TypeCacheEntry::tupDesc, TypeCacheEntry::tupDesc_identifier, tupledesc_id_counter, TypeCacheEntry::type_id, and TypeCacheEntry::typrelid.

Referenced by cache_record_field_properties(), and lookup_type_cache().

lookup_rowtype_tupdesc()

TupleDesc lookup_rowtype_tupdesc	(	Oid	type_id,
		int32	typmod
	)

Definition at line 1850 of file typcache.c.

{
    TupleDesc   tupDesc;
 
    tupDesc = lookup_rowtype_tupdesc_internal(type_id, typmod, false);
    PinTupleDesc(tupDesc);
    return tupDesc;
}

References lookup_rowtype_tupdesc_internal(), and PinTupleDesc.

Referenced by ATExecAddOf(), coerce_record_to_complex(), composite_to_json(), composite_to_jsonb(), deconstruct_composite_datum(), exec_move_row_from_datum(), ExecInitExprRec(), ExecuteCallStmt(), expanded_record_fetch_tupdesc(), get_cached_rowtype(), get_rule_expr(), GetAttributeByName(), GetAttributeByNum(), hash_record(), hash_record_extended(), HeapTupleHeaderGetDatum(), make_expanded_record_from_typeid(), make_tuple_indirect(), plperl_hash_from_datum(), pltcl_func_handler(), PLyDict_FromComposite(), PLyObject_ToComposite(), record_cmp(), record_eq(), record_image_cmp(), record_image_eq(), record_in(), record_out(), record_recv(), record_send(), transformOfType(), and update_cached_tupdesc().

lookup_rowtype_tupdesc_copy()

TupleDesc lookup_rowtype_tupdesc_copy	(	Oid	type_id,
		int32	typmod
	)

Definition at line 1884 of file typcache.c.

{
    TupleDesc   tmp;
 
    tmp = lookup_rowtype_tupdesc_internal(type_id, typmod, false);
    return CreateTupleDescCopyConstr(tmp);
}

References CreateTupleDescCopyConstr(), and lookup_rowtype_tupdesc_internal().

Referenced by ExecInitExprRec(), ExecMakeTableFunctionResult(), get_expr_result_type(), internal_get_result_type(), and TypeGetTupleDesc().

lookup_rowtype_tupdesc_domain()

TupleDesc lookup_rowtype_tupdesc_domain	(	Oid	type_id,
		int32	typmod,
		bool	noError
	)

Definition at line 1906 of file typcache.c.

{
    TupleDesc   tupDesc;
 
    if (type_id != RECORDOID)
    {
        /*
         * Check for domain or named composite type.  We might as well load
         * whichever data is needed.
         */
        TypeCacheEntry *typentry;
 
        typentry = lookup_type_cache(type_id,
                                     TYPECACHE_TUPDESC |
                                     TYPECACHE_DOMAIN_BASE_INFO);
        if (typentry->typtype == TYPTYPE_DOMAIN)
            return lookup_rowtype_tupdesc_noerror(typentry->domainBaseType,
                                                  typentry->domainBaseTypmod,
                                                  noError);
        if (typentry->tupDesc == NULL && !noError)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("type %s is not composite",
                            format_type_be(type_id))));
        tupDesc = typentry->tupDesc;
    }
    else
        tupDesc = lookup_rowtype_tupdesc_internal(type_id, typmod, noError);
    if (tupDesc != NULL)
        PinTupleDesc(tupDesc);
    return tupDesc;
}

References TypeCacheEntry::domainBaseType, TypeCacheEntry::domainBaseTypmod, ereport, errcode(), errmsg(), ERROR, format_type_be(), lookup_rowtype_tupdesc_internal(), lookup_rowtype_tupdesc_noerror(), lookup_type_cache(), PinTupleDesc, TypeCacheEntry::tupDesc, TYPECACHE_DOMAIN_BASE_INFO, TYPECACHE_TUPDESC, and TypeCacheEntry::typtype.

Referenced by ExecEvalWholeRowVar(), hstore_from_record(), hstore_populate_record(), plperl_sv_to_datum(), and rowtype_field_matches().

lookup_rowtype_tupdesc_internal()

static TupleDesc lookup_rowtype_tupdesc_internal ( Oid  type_id, int32  typmod, bool  noError  )

static

Definition at line 1756 of file typcache.c.

{
    if (type_id != RECORDOID)
    {
        /*
         * It's a named composite type, so use the regular typcache.
         */
        TypeCacheEntry *typentry;
 
        typentry = lookup_type_cache(type_id, TYPECACHE_TUPDESC);
        if (typentry->tupDesc == NULL && !noError)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("type %s is not composite",
                            format_type_be(type_id))));
        return typentry->tupDesc;
    }
    else
    {
        /*
         * It's a transient record type, so look in our record-type table.
         */
        if (typmod >= 0)
        {
            /* It is already in our local cache? */
            if (typmod < RecordCacheArrayLen &&
                RecordCacheArray[typmod].tupdesc != NULL)
                return RecordCacheArray[typmod].tupdesc;
 
            /* Are we attached to a shared record typmod registry? */
            if (CurrentSession->shared_typmod_registry != NULL)
            {
                SharedTypmodTableEntry *entry;
 
                /* Try to find it in the shared typmod index. */
                entry = dshash_find(CurrentSession->shared_typmod_table,
                                    &typmod, false);
                if (entry != NULL)
                {
                    TupleDesc   tupdesc;
 
                    tupdesc = (TupleDesc)
                        dsa_get_address(CurrentSession->area,
                                        entry->shared_tupdesc);
                    Assert(typmod == tupdesc->tdtypmod);
 
                    /* We may need to extend the local RecordCacheArray. */
                    ensure_record_cache_typmod_slot_exists(typmod);
 
                    /*
                     * Our local array can now point directly to the TupleDesc
                     * in shared memory, which is non-reference-counted.
                     */
                    RecordCacheArray[typmod].tupdesc = tupdesc;
                    Assert(tupdesc->tdrefcount == -1);
 
                    /*
                     * We don't share tupdesc identifiers across processes, so
                     * assign one locally.
                     */
                    RecordCacheArray[typmod].id = ++tupledesc_id_counter;
 
                    dshash_release_lock(CurrentSession->shared_typmod_table,
                                        entry);
 
                    return RecordCacheArray[typmod].tupdesc;
                }
            }
        }
 
        if (!noError)
            ereport(ERROR,
                    (errcode(ERRCODE_WRONG_OBJECT_TYPE),
                     errmsg("record type has not been registered")));
        return NULL;
    }
}

References Session::area, Assert, CurrentSession, dsa_get_address(), dshash_find(), dshash_release_lock(), ensure_record_cache_typmod_slot_exists(), ereport, errcode(), errmsg(), ERROR, format_type_be(), RecordCacheArrayEntry::id, lookup_type_cache(), RecordCacheArray, RecordCacheArrayLen, SharedTypmodTableEntry::shared_tupdesc, Session::shared_typmod_registry, Session::shared_typmod_table, TupleDescData::tdrefcount, TupleDescData::tdtypmod, RecordCacheArrayEntry::tupdesc, TypeCacheEntry::tupDesc, tupledesc_id_counter, and TYPECACHE_TUPDESC.

Referenced by lookup_rowtype_tupdesc(), lookup_rowtype_tupdesc_copy(), lookup_rowtype_tupdesc_domain(), and lookup_rowtype_tupdesc_noerror().

lookup_rowtype_tupdesc_noerror()

TupleDesc lookup_rowtype_tupdesc_noerror	(	Oid	type_id,
		int32	typmod,
		bool	noError
	)

Definition at line 1867 of file typcache.c.

{
    TupleDesc   tupDesc;
 
    tupDesc = lookup_rowtype_tupdesc_internal(type_id, typmod, noError);
    if (tupDesc != NULL)
        PinTupleDesc(tupDesc);
    return tupDesc;
}

References lookup_rowtype_tupdesc_internal(), and PinTupleDesc.

Referenced by lookup_rowtype_tupdesc_domain().

lookup_type_cache()

TypeCacheEntry* lookup_type_cache	(	Oid	type_id,
		int	flags
	)

Definition at line 356 of file typcache.c.

{
    TypeCacheEntry *typentry;
    bool        found;
 
    if (TypeCacheHash == NULL)
    {
        /* First time through: initialize the hash table */
        HASHCTL     ctl;
 
        ctl.keysize = sizeof(Oid);
        ctl.entrysize = sizeof(TypeCacheEntry);
 
        /*
         * TypeCacheEntry takes hash value from the system cache. For
         * TypeCacheHash we use the same hash in order to speedup search by
         * hash value. This is used by hash_seq_init_with_hash_value().
         */
        ctl.hash = type_cache_syshash;
 
        TypeCacheHash = hash_create("Type information cache", 64,
                                    &ctl, HASH_ELEM | HASH_FUNCTION);
 
        /* Also set up callbacks for SI invalidations */
        CacheRegisterRelcacheCallback(TypeCacheRelCallback, (Datum) 0);
        CacheRegisterSyscacheCallback(TYPEOID, TypeCacheTypCallback, (Datum) 0);
        CacheRegisterSyscacheCallback(CLAOID, TypeCacheOpcCallback, (Datum) 0);
        CacheRegisterSyscacheCallback(CONSTROID, TypeCacheConstrCallback, (Datum) 0);
 
        /* Also make sure CacheMemoryContext exists */
        if (!CacheMemoryContext)
            CreateCacheMemoryContext();
    }
 
    /* Try to look up an existing entry */
    typentry = (TypeCacheEntry *) hash_search(TypeCacheHash,
                                              &type_id,
                                              HASH_FIND, NULL);
    if (typentry == NULL)
    {
        /*
         * If we didn't find one, we want to make one.  But first look up the
         * pg_type row, just to make sure we don't make a cache entry for an
         * invalid type OID.  If the type OID is not valid, present a
         * user-facing error, since some code paths such as domain_in() allow
         * this function to be reached with a user-supplied OID.
         */
        HeapTuple   tp;
        Form_pg_type typtup;
 
        tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_id));
        if (!HeapTupleIsValid(tp))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("type with OID %u does not exist", type_id)));
        typtup = (Form_pg_type) GETSTRUCT(tp);
        if (!typtup->typisdefined)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("type \"%s\" is only a shell",
                            NameStr(typtup->typname))));
 
        /* Now make the typcache entry */
        typentry = (TypeCacheEntry *) hash_search(TypeCacheHash,
                                                  &type_id,
                                                  HASH_ENTER, &found);
        Assert(!found);         /* it wasn't there a moment ago */
 
        MemSet(typentry, 0, sizeof(TypeCacheEntry));
 
        /* These fields can never change, by definition */
        typentry->type_id = type_id;
        typentry->type_id_hash = get_hash_value(TypeCacheHash, &type_id);
 
        /* Keep this part in sync with the code below */
        typentry->typlen = typtup->typlen;
        typentry->typbyval = typtup->typbyval;
        typentry->typalign = typtup->typalign;
        typentry->typstorage = typtup->typstorage;
        typentry->typtype = typtup->typtype;
        typentry->typrelid = typtup->typrelid;
        typentry->typsubscript = typtup->typsubscript;
        typentry->typelem = typtup->typelem;
        typentry->typcollation = typtup->typcollation;
        typentry->flags |= TCFLAGS_HAVE_PG_TYPE_DATA;
 
        /* If it's a domain, immediately thread it into the domain cache list */
        if (typentry->typtype == TYPTYPE_DOMAIN)
        {
            typentry->nextDomain = firstDomainTypeEntry;
            firstDomainTypeEntry = typentry;
        }
 
        ReleaseSysCache(tp);
    }
    else if (!(typentry->flags & TCFLAGS_HAVE_PG_TYPE_DATA))
    {
        /*
         * We have an entry, but its pg_type row got changed, so reload the
         * data obtained directly from pg_type.
         */
        HeapTuple   tp;
        Form_pg_type typtup;
 
        tp = SearchSysCache1(TYPEOID, ObjectIdGetDatum(type_id));
        if (!HeapTupleIsValid(tp))
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("type with OID %u does not exist", type_id)));
        typtup = (Form_pg_type) GETSTRUCT(tp);
        if (!typtup->typisdefined)
            ereport(ERROR,
                    (errcode(ERRCODE_UNDEFINED_OBJECT),
                     errmsg("type \"%s\" is only a shell",
                            NameStr(typtup->typname))));
 
        /*
         * Keep this part in sync with the code above.  Many of these fields
         * shouldn't ever change, particularly typtype, but copy 'em anyway.
         */
        typentry->typlen = typtup->typlen;
        typentry->typbyval = typtup->typbyval;
        typentry->typalign = typtup->typalign;
        typentry->typstorage = typtup->typstorage;
        typentry->typtype = typtup->typtype;
        typentry->typrelid = typtup->typrelid;
        typentry->typsubscript = typtup->typsubscript;
        typentry->typelem = typtup->typelem;
        typentry->typcollation = typtup->typcollation;
        typentry->flags |= TCFLAGS_HAVE_PG_TYPE_DATA;
 
        ReleaseSysCache(tp);
    }
 
    /*
     * Look up opclasses if we haven't already and any dependent info is
     * requested.
     */
    if ((flags & (TYPECACHE_EQ_OPR | TYPECACHE_LT_OPR | TYPECACHE_GT_OPR |
                  TYPECACHE_CMP_PROC |
                  TYPECACHE_EQ_OPR_FINFO | TYPECACHE_CMP_PROC_FINFO |
                  TYPECACHE_BTREE_OPFAMILY)) &&
        !(typentry->flags & TCFLAGS_CHECKED_BTREE_OPCLASS))
    {
        Oid         opclass;
 
        opclass = GetDefaultOpClass(type_id, BTREE_AM_OID);
        if (OidIsValid(opclass))
        {
            typentry->btree_opf = get_opclass_family(opclass);
            typentry->btree_opintype = get_opclass_input_type(opclass);
        }
        else
        {
            typentry->btree_opf = typentry->btree_opintype = InvalidOid;
        }
 
        /*
         * Reset information derived from btree opclass.  Note in particular
         * that we'll redetermine the eq_opr even if we previously found one;
         * this matters in case a btree opclass has been added to a type that
         * previously had only a hash opclass.
         */
        typentry->flags &= ~(TCFLAGS_CHECKED_EQ_OPR |
                             TCFLAGS_CHECKED_LT_OPR |
                             TCFLAGS_CHECKED_GT_OPR |
                             TCFLAGS_CHECKED_CMP_PROC);
        typentry->flags |= TCFLAGS_CHECKED_BTREE_OPCLASS;
    }
 
    /*
     * If we need to look up equality operator, and there's no btree opclass,
     * force lookup of hash opclass.
     */
    if ((flags & (TYPECACHE_EQ_OPR | TYPECACHE_EQ_OPR_FINFO)) &&
        !(typentry->flags & TCFLAGS_CHECKED_EQ_OPR) &&
        typentry->btree_opf == InvalidOid)
        flags |= TYPECACHE_HASH_OPFAMILY;
 
    if ((flags & (TYPECACHE_HASH_PROC | TYPECACHE_HASH_PROC_FINFO |
                  TYPECACHE_HASH_EXTENDED_PROC |
                  TYPECACHE_HASH_EXTENDED_PROC_FINFO |
                  TYPECACHE_HASH_OPFAMILY)) &&
        !(typentry->flags & TCFLAGS_CHECKED_HASH_OPCLASS))
    {
        Oid         opclass;
 
        opclass = GetDefaultOpClass(type_id, HASH_AM_OID);
        if (OidIsValid(opclass))
        {
            typentry->hash_opf = get_opclass_family(opclass);
            typentry->hash_opintype = get_opclass_input_type(opclass);
        }
        else
        {
            typentry->hash_opf = typentry->hash_opintype = InvalidOid;
        }
 
        /*
         * Reset information derived from hash opclass.  We do *not* reset the
         * eq_opr; if we already found one from the btree opclass, that
         * decision is still good.
         */
        typentry->flags &= ~(TCFLAGS_CHECKED_HASH_PROC |
                             TCFLAGS_CHECKED_HASH_EXTENDED_PROC);
        typentry->flags |= TCFLAGS_CHECKED_HASH_OPCLASS;
    }
 
    /*
     * Look for requested operators and functions, if we haven't already.
     */
    if ((flags & (TYPECACHE_EQ_OPR | TYPECACHE_EQ_OPR_FINFO)) &&
        !(typentry->flags & TCFLAGS_CHECKED_EQ_OPR))
    {
        Oid         eq_opr = InvalidOid;
 
        if (typentry->btree_opf != InvalidOid)
            eq_opr = get_opfamily_member(typentry->btree_opf,
                                         typentry->btree_opintype,
                                         typentry->btree_opintype,
                                         BTEqualStrategyNumber);
        if (eq_opr == InvalidOid &&
            typentry->hash_opf != InvalidOid)
            eq_opr = get_opfamily_member(typentry->hash_opf,
                                         typentry->hash_opintype,
                                         typentry->hash_opintype,
                                         HTEqualStrategyNumber);
 
        /*
         * If the proposed equality operator is array_eq or record_eq, check
         * to see if the element type or column types support equality.  If
         * not, array_eq or record_eq would fail at runtime, so we don't want
         * to report that the type has equality.  (We can omit similar
         * checking for ranges and multiranges because ranges can't be created
         * in the first place unless their subtypes support equality.)
         */
        if (eq_opr == ARRAY_EQ_OP &&
            !array_element_has_equality(typentry))
            eq_opr = InvalidOid;
        else if (eq_opr == RECORD_EQ_OP &&
                 !record_fields_have_equality(typentry))
            eq_opr = InvalidOid;
 
        /* Force update of eq_opr_finfo only if we're changing state */
        if (typentry->eq_opr != eq_opr)
            typentry->eq_opr_finfo.fn_oid = InvalidOid;
 
        typentry->eq_opr = eq_opr;
 
        /*
         * Reset info about hash functions whenever we pick up new info about
         * equality operator.  This is so we can ensure that the hash
         * functions match the operator.
         */
        typentry->flags &= ~(TCFLAGS_CHECKED_HASH_PROC |
                             TCFLAGS_CHECKED_HASH_EXTENDED_PROC);
        typentry->flags |= TCFLAGS_CHECKED_EQ_OPR;
    }
    if ((flags & TYPECACHE_LT_OPR) &&
        !(typentry->flags & TCFLAGS_CHECKED_LT_OPR))
    {
        Oid         lt_opr = InvalidOid;
 
        if (typentry->btree_opf != InvalidOid)
            lt_opr = get_opfamily_member(typentry->btree_opf,
                                         typentry->btree_opintype,
                                         typentry->btree_opintype,
                                         BTLessStrategyNumber);
 
        /*
         * As above, make sure array_cmp or record_cmp will succeed; but again
         * we need no special check for ranges or multiranges.
         */
        if (lt_opr == ARRAY_LT_OP &&
            !array_element_has_compare(typentry))
            lt_opr = InvalidOid;
        else if (lt_opr == RECORD_LT_OP &&
                 !record_fields_have_compare(typentry))
            lt_opr = InvalidOid;
 
        typentry->lt_opr = lt_opr;
        typentry->flags |= TCFLAGS_CHECKED_LT_OPR;
    }
    if ((flags & TYPECACHE_GT_OPR) &&
        !(typentry->flags & TCFLAGS_CHECKED_GT_OPR))
    {
        Oid         gt_opr = InvalidOid;
 
        if (typentry->btree_opf != InvalidOid)
            gt_opr = get_opfamily_member(typentry->btree_opf,
                                         typentry->btree_opintype,
                                         typentry->btree_opintype,
                                         BTGreaterStrategyNumber);
 
        /*
         * As above, make sure array_cmp or record_cmp will succeed; but again
         * we need no special check for ranges or multiranges.
         */
        if (gt_opr == ARRAY_GT_OP &&
            !array_element_has_compare(typentry))
            gt_opr = InvalidOid;
        else if (gt_opr == RECORD_GT_OP &&
                 !record_fields_have_compare(typentry))
            gt_opr = InvalidOid;
 
        typentry->gt_opr = gt_opr;
        typentry->flags |= TCFLAGS_CHECKED_GT_OPR;
    }
    if ((flags & (TYPECACHE_CMP_PROC | TYPECACHE_CMP_PROC_FINFO)) &&
        !(typentry->flags & TCFLAGS_CHECKED_CMP_PROC))
    {
        Oid         cmp_proc = InvalidOid;
 
        if (typentry->btree_opf != InvalidOid)
            cmp_proc = get_opfamily_proc(typentry->btree_opf,
                                         typentry->btree_opintype,
                                         typentry->btree_opintype,
                                         BTORDER_PROC);
 
        /*
         * As above, make sure array_cmp or record_cmp will succeed; but again
         * we need no special check for ranges or multiranges.
         */
        if (cmp_proc == F_BTARRAYCMP &&
            !array_element_has_compare(typentry))
            cmp_proc = InvalidOid;
        else if (cmp_proc == F_BTRECORDCMP &&
                 !record_fields_have_compare(typentry))
            cmp_proc = InvalidOid;
 
        /* Force update of cmp_proc_finfo only if we're changing state */
        if (typentry->cmp_proc != cmp_proc)
            typentry->cmp_proc_finfo.fn_oid = InvalidOid;
 
        typentry->cmp_proc = cmp_proc;
        typentry->flags |= TCFLAGS_CHECKED_CMP_PROC;
    }
    if ((flags & (TYPECACHE_HASH_PROC | TYPECACHE_HASH_PROC_FINFO)) &&
        !(typentry->flags & TCFLAGS_CHECKED_HASH_PROC))
    {
        Oid         hash_proc = InvalidOid;
 
        /*
         * We insist that the eq_opr, if one has been determined, match the
         * hash opclass; else report there is no hash function.
         */
        if (typentry->hash_opf != InvalidOid &&
            (!OidIsValid(typentry->eq_opr) ||
             typentry->eq_opr == get_opfamily_member(typentry->hash_opf,
                                                     typentry->hash_opintype,
                                                     typentry->hash_opintype,
                                                     HTEqualStrategyNumber)))
            hash_proc = get_opfamily_proc(typentry->hash_opf,
                                          typentry->hash_opintype,
                                          typentry->hash_opintype,
                                          HASHSTANDARD_PROC);
 
        /*
         * As above, make sure hash_array, hash_record, or hash_range will
         * succeed.
         */
        if (hash_proc == F_HASH_ARRAY &&
            !array_element_has_hashing(typentry))
            hash_proc = InvalidOid;
        else if (hash_proc == F_HASH_RECORD &&
                 !record_fields_have_hashing(typentry))
            hash_proc = InvalidOid;
        else if (hash_proc == F_HASH_RANGE &&
                 !range_element_has_hashing(typentry))
            hash_proc = InvalidOid;
 
        /*
         * Likewise for hash_multirange.
         */
        if (hash_proc == F_HASH_MULTIRANGE &&
            !multirange_element_has_hashing(typentry))
            hash_proc = InvalidOid;
 
        /* Force update of hash_proc_finfo only if we're changing state */
        if (typentry->hash_proc != hash_proc)
            typentry->hash_proc_finfo.fn_oid = InvalidOid;
 
        typentry->hash_proc = hash_proc;
        typentry->flags |= TCFLAGS_CHECKED_HASH_PROC;
    }
    if ((flags & (TYPECACHE_HASH_EXTENDED_PROC |
                  TYPECACHE_HASH_EXTENDED_PROC_FINFO)) &&
        !(typentry->flags & TCFLAGS_CHECKED_HASH_EXTENDED_PROC))
    {
        Oid         hash_extended_proc = InvalidOid;
 
        /*
         * We insist that the eq_opr, if one has been determined, match the
         * hash opclass; else report there is no hash function.
         */
        if (typentry->hash_opf != InvalidOid &&
            (!OidIsValid(typentry->eq_opr) ||
             typentry->eq_opr == get_opfamily_member(typentry->hash_opf,
                                                     typentry->hash_opintype,
                                                     typentry->hash_opintype,
                                                     HTEqualStrategyNumber)))
            hash_extended_proc = get_opfamily_proc(typentry->hash_opf,
                                                   typentry->hash_opintype,
                                                   typentry->hash_opintype,
                                                   HASHEXTENDED_PROC);
 
        /*
         * As above, make sure hash_array_extended, hash_record_extended, or
         * hash_range_extended will succeed.
         */
        if (hash_extended_proc == F_HASH_ARRAY_EXTENDED &&
            !array_element_has_extended_hashing(typentry))
            hash_extended_proc = InvalidOid;
        else if (hash_extended_proc == F_HASH_RECORD_EXTENDED &&
                 !record_fields_have_extended_hashing(typentry))
            hash_extended_proc = InvalidOid;
        else if (hash_extended_proc == F_HASH_RANGE_EXTENDED &&
                 !range_element_has_extended_hashing(typentry))
            hash_extended_proc = InvalidOid;
 
        /*
         * Likewise for hash_multirange_extended.
         */
        if (hash_extended_proc == F_HASH_MULTIRANGE_EXTENDED &&
            !multirange_element_has_extended_hashing(typentry))
            hash_extended_proc = InvalidOid;
 
        /* Force update of proc finfo only if we're changing state */
        if (typentry->hash_extended_proc != hash_extended_proc)
            typentry->hash_extended_proc_finfo.fn_oid = InvalidOid;
 
        typentry->hash_extended_proc = hash_extended_proc;
        typentry->flags |= TCFLAGS_CHECKED_HASH_EXTENDED_PROC;
    }
 
    /*
     * Set up fmgr lookup info as requested
     *
     * Note: we tell fmgr the finfo structures live in CacheMemoryContext,
     * which is not quite right (they're really in the hash table's private
     * memory context) but this will do for our purposes.
     *
     * Note: the code above avoids invalidating the finfo structs unless the
     * referenced operator/function OID actually changes.  This is to prevent
     * unnecessary leakage of any subsidiary data attached to an finfo, since
     * that would cause session-lifespan memory leaks.
     */
    if ((flags & TYPECACHE_EQ_OPR_FINFO) &&
        typentry->eq_opr_finfo.fn_oid == InvalidOid &&
        typentry->eq_opr != InvalidOid)
    {
        Oid         eq_opr_func;
 
        eq_opr_func = get_opcode(typentry->eq_opr);
        if (eq_opr_func != InvalidOid)
            fmgr_info_cxt(eq_opr_func, &typentry->eq_opr_finfo,
                          CacheMemoryContext);
    }
    if ((flags & TYPECACHE_CMP_PROC_FINFO) &&
        typentry->cmp_proc_finfo.fn_oid == InvalidOid &&
        typentry->cmp_proc != InvalidOid)
    {
        fmgr_info_cxt(typentry->cmp_proc, &typentry->cmp_proc_finfo,
                      CacheMemoryContext);
    }
    if ((flags & TYPECACHE_HASH_PROC_FINFO) &&
        typentry->hash_proc_finfo.fn_oid == InvalidOid &&
        typentry->hash_proc != InvalidOid)
    {
        fmgr_info_cxt(typentry->hash_proc, &typentry->hash_proc_finfo,
                      CacheMemoryContext);
    }
    if ((flags & TYPECACHE_HASH_EXTENDED_PROC_FINFO) &&
        typentry->hash_extended_proc_finfo.fn_oid == InvalidOid &&
        typentry->hash_extended_proc != InvalidOid)
    {
        fmgr_info_cxt(typentry->hash_extended_proc,
                      &typentry->hash_extended_proc_finfo,
                      CacheMemoryContext);
    }
 
    /*
     * If it's a composite type (row type), get tupdesc if requested
     */
    if ((flags & TYPECACHE_TUPDESC) &&
        typentry->tupDesc == NULL &&
        typentry->typtype == TYPTYPE_COMPOSITE)
    {
        load_typcache_tupdesc(typentry);
    }
 
    /*
     * If requested, get information about a range type
     *
     * This includes making sure that the basic info about the range element
     * type is up-to-date.
     */
    if ((flags & TYPECACHE_RANGE_INFO) &&
        typentry->typtype == TYPTYPE_RANGE)
    {
        if (typentry->rngelemtype == NULL)
            load_rangetype_info(typentry);
        else if (!(typentry->rngelemtype->flags & TCFLAGS_HAVE_PG_TYPE_DATA))
            (void) lookup_type_cache(typentry->rngelemtype->type_id, 0);
    }
 
    /*
     * If requested, get information about a multirange type
     */
    if ((flags & TYPECACHE_MULTIRANGE_INFO) &&
        typentry->rngtype == NULL &&
        typentry->typtype == TYPTYPE_MULTIRANGE)
    {
        load_multirangetype_info(typentry);
    }
 
    /*
     * If requested, get information about a domain type
     */
    if ((flags & TYPECACHE_DOMAIN_BASE_INFO) &&
        typentry->domainBaseType == InvalidOid &&
        typentry->typtype == TYPTYPE_DOMAIN)
    {
        typentry->domainBaseTypmod = -1;
        typentry->domainBaseType =
            getBaseTypeAndTypmod(type_id, &typentry->domainBaseTypmod);
    }
    if ((flags & TYPECACHE_DOMAIN_CONSTR_INFO) &&
        (typentry->flags & TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS) == 0 &&
        typentry->typtype == TYPTYPE_DOMAIN)
    {
        load_domaintype_info(typentry);
    }
 
    return typentry;
}

References array_element_has_compare(), array_element_has_equality(), array_element_has_extended_hashing(), array_element_has_hashing(), Assert, BTEqualStrategyNumber, BTGreaterStrategyNumber, BTLessStrategyNumber, BTORDER_PROC, TypeCacheEntry::btree_opf, TypeCacheEntry::btree_opintype, CacheMemoryContext, CacheRegisterRelcacheCallback(), CacheRegisterSyscacheCallback(), TypeCacheEntry::cmp_proc, TypeCacheEntry::cmp_proc_finfo, CreateCacheMemoryContext(), ctl, TypeCacheEntry::domainBaseType, TypeCacheEntry::domainBaseTypmod, TypeCacheEntry::eq_opr, TypeCacheEntry::eq_opr_finfo, ereport, errcode(), errmsg(), ERROR, firstDomainTypeEntry, TypeCacheEntry::flags, fmgr_info_cxt(), FmgrInfo::fn_oid, get_hash_value(), get_opclass_family(), get_opclass_input_type(), get_opcode(), get_opfamily_member(), get_opfamily_proc(), getBaseTypeAndTypmod(), GetDefaultOpClass(), GETSTRUCT, TypeCacheEntry::gt_opr, hash_create(), HASH_ELEM, HASH_ENTER, TypeCacheEntry::hash_extended_proc, TypeCacheEntry::hash_extended_proc_finfo, HASH_FIND, HASH_FUNCTION, TypeCacheEntry::hash_opf, TypeCacheEntry::hash_opintype, TypeCacheEntry::hash_proc, TypeCacheEntry::hash_proc_finfo, hash_search(), HASHEXTENDED_PROC, HASHSTANDARD_PROC, HeapTupleIsValid, HTEqualStrategyNumber, InvalidOid, load_domaintype_info(), load_multirangetype_info(), load_rangetype_info(), load_typcache_tupdesc(), TypeCacheEntry::lt_opr, MemSet, multirange_element_has_extended_hashing(), multirange_element_has_hashing(), NameStr, TypeCacheEntry::nextDomain, ObjectIdGetDatum(), OidIsValid, range_element_has_extended_hashing(), range_element_has_hashing(), record_fields_have_compare(), record_fields_have_equality(), record_fields_have_extended_hashing(), record_fields_have_hashing(), ReleaseSysCache(), TypeCacheEntry::rngelemtype, TypeCacheEntry::rngtype, SearchSysCache1(), TCFLAGS_CHECKED_BTREE_OPCLASS, TCFLAGS_CHECKED_CMP_PROC, TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS, TCFLAGS_CHECKED_EQ_OPR, TCFLAGS_CHECKED_GT_OPR, TCFLAGS_CHECKED_HASH_EXTENDED_PROC, TCFLAGS_CHECKED_HASH_OPCLASS, TCFLAGS_CHECKED_HASH_PROC, TCFLAGS_CHECKED_LT_OPR, TCFLAGS_HAVE_PG_TYPE_DATA, TypeCacheEntry::tupDesc, TypeCacheEntry::typalign, TypeCacheEntry::typbyval, TypeCacheEntry::typcollation, type_cache_syshash(), TypeCacheEntry::type_id, TypeCacheEntry::type_id_hash, TYPECACHE_BTREE_OPFAMILY, TYPECACHE_CMP_PROC, TYPECACHE_CMP_PROC_FINFO, TYPECACHE_DOMAIN_BASE_INFO, TYPECACHE_DOMAIN_CONSTR_INFO, TYPECACHE_EQ_OPR, TYPECACHE_EQ_OPR_FINFO, TYPECACHE_GT_OPR, TYPECACHE_HASH_EXTENDED_PROC, TYPECACHE_HASH_EXTENDED_PROC_FINFO, TYPECACHE_HASH_OPFAMILY, TYPECACHE_HASH_PROC, TYPECACHE_HASH_PROC_FINFO, TYPECACHE_LT_OPR, TYPECACHE_MULTIRANGE_INFO, TYPECACHE_RANGE_INFO, TYPECACHE_TUPDESC, TypeCacheConstrCallback(), TypeCacheHash, TypeCacheOpcCallback(), TypeCacheRelCallback(), TypeCacheTypCallback(), TypeCacheEntry::typelem, TypeCacheEntry::typlen, TypeCacheEntry::typrelid, TypeCacheEntry::typstorage, TypeCacheEntry::typsubscript, and TypeCacheEntry::typtype.

Referenced by analyzeCTE(), appendOrderBySuffix(), array_cmp(), array_contain_compare(), array_eq(), array_position_common(), array_positions(), array_replace_internal(), array_sample(), array_shuffle(), array_typanalyze(), assign_record_type_identifier(), brin_bloom_opcinfo(), brin_inclusion_opcinfo(), brin_minmax_multi_opcinfo(), brin_minmax_opcinfo(), build_datatype(), build_mss(), cache_array_element_properties(), cache_multirange_element_properties(), cache_range_element_properties(), cache_record_field_properties(), calc_arraycontsel(), check_memoizable(), contain_leaked_vars_walker(), CreateStatistics(), dependency_degree(), domain_state_setup(), DomainHasConstraints(), enum_cmp_internal(), ExecInitExprRec(), find_simplified_clause(), foreign_expr_walker(), get_cached_rowtype(), get_multirange_io_data(), get_range_io_data(), get_rule_orderby(), get_sort_group_operators(), hash_array(), hash_array_extended(), hash_multirange(), hash_multirange_extended(), hash_range(), hash_range_extended(), hash_record(), hash_record_extended(), InitDomainConstraintRef(), initGinState(), load_multirangetype_info(), load_rangetype_info(), lookup_rowtype_tupdesc_domain(), lookup_rowtype_tupdesc_internal(), make_expanded_record_from_tupdesc(), make_expanded_record_from_typeid(), multirange_get_typcache(), multirange_unnest(), ndistinct_for_combination(), op_hashjoinable(), op_mergejoinable(), paraminfo_get_equal_hashops(), PLy_input_setup_func(), PLy_output_setup_func(), range_get_typcache(), record_cmp(), record_eq(), revalidate_rectypeid(), scalararraysel(), scalararraysel_containment(), show_sortorder_options(), statext_mcv_serialize(), tuples_equal(), and width_bucket_array().

multirange_element_has_extended_hashing()

static bool multirange_element_has_extended_hashing ( TypeCacheEntry *  typentry )

static

Definition at line 1691 of file typcache.c.

{
    if (!(typentry->flags & TCFLAGS_CHECKED_ELEM_PROPERTIES))
        cache_multirange_element_properties(typentry);
    return (typentry->flags & TCFLAGS_HAVE_ELEM_EXTENDED_HASHING) != 0;
}

References cache_multirange_element_properties(), TypeCacheEntry::flags, TCFLAGS_CHECKED_ELEM_PROPERTIES, and TCFLAGS_HAVE_ELEM_EXTENDED_HASHING.

Referenced by lookup_type_cache().

multirange_element_has_hashing()

static bool multirange_element_has_hashing ( TypeCacheEntry *  typentry )

static

Definition at line 1683 of file typcache.c.

{
    if (!(typentry->flags & TCFLAGS_CHECKED_ELEM_PROPERTIES))
        cache_multirange_element_properties(typentry);
    return (typentry->flags & TCFLAGS_HAVE_ELEM_HASHING) != 0;
}

References cache_multirange_element_properties(), TypeCacheEntry::flags, TCFLAGS_CHECKED_ELEM_PROPERTIES, and TCFLAGS_HAVE_ELEM_HASHING.

Referenced by lookup_type_cache().

prep_domain_constraints()

static List * prep_domain_constraints ( List *  constraints, MemoryContext  execctx  )

static

Definition at line 1292 of file typcache.c.

{
    List       *result = NIL;
    MemoryContext oldcxt;
    ListCell   *lc;
 
    oldcxt = MemoryContextSwitchTo(execctx);
 
    foreach(lc, constraints)
    {
        DomainConstraintState *r = (DomainConstraintState *) lfirst(lc);
        DomainConstraintState *newr;
 
        newr = makeNode(DomainConstraintState);
        newr->constrainttype = r->constrainttype;
        newr->name = r->name;
        newr->check_expr = r->check_expr;
        newr->check_exprstate = ExecInitExpr(r->check_expr, NULL);
 
        result = lappend(result, newr);
    }
 
    MemoryContextSwitchTo(oldcxt);
 
    return result;
}

References DomainConstraintState::check_expr, DomainConstraintState::check_exprstate, DomainConstraintState::constrainttype, ExecInitExpr(), lappend(), lfirst, makeNode, MemoryContextSwitchTo(), DomainConstraintState::name, and NIL.

Referenced by InitDomainConstraintRef(), and UpdateDomainConstraintRef().

range_element_has_extended_hashing()

static bool range_element_has_extended_hashing ( TypeCacheEntry *  typentry )

static

Definition at line 1651 of file typcache.c.

{
    if (!(typentry->flags & TCFLAGS_CHECKED_ELEM_PROPERTIES))
        cache_range_element_properties(typentry);
    return (typentry->flags & TCFLAGS_HAVE_ELEM_EXTENDED_HASHING) != 0;
}

References cache_range_element_properties(), TypeCacheEntry::flags, TCFLAGS_CHECKED_ELEM_PROPERTIES, and TCFLAGS_HAVE_ELEM_EXTENDED_HASHING.

Referenced by lookup_type_cache().

range_element_has_hashing()

static bool range_element_has_hashing ( TypeCacheEntry *  typentry )

static

Definition at line 1643 of file typcache.c.

{
    if (!(typentry->flags & TCFLAGS_CHECKED_ELEM_PROPERTIES))
        cache_range_element_properties(typentry);
    return (typentry->flags & TCFLAGS_HAVE_ELEM_HASHING) != 0;
}

References cache_range_element_properties(), TypeCacheEntry::flags, TCFLAGS_CHECKED_ELEM_PROPERTIES, and TCFLAGS_HAVE_ELEM_HASHING.

Referenced by lookup_type_cache().

record_fields_have_compare()

static bool record_fields_have_compare ( TypeCacheEntry *  typentry )

static

Definition at line 1514 of file typcache.c.

{
    if (!(typentry->flags & TCFLAGS_CHECKED_FIELD_PROPERTIES))
        cache_record_field_properties(typentry);
    return (typentry->flags & TCFLAGS_HAVE_FIELD_COMPARE) != 0;
}

References cache_record_field_properties(), TypeCacheEntry::flags, TCFLAGS_CHECKED_FIELD_PROPERTIES, and TCFLAGS_HAVE_FIELD_COMPARE.

Referenced by lookup_type_cache().

record_fields_have_equality()

static bool record_fields_have_equality ( TypeCacheEntry *  typentry )

static

Definition at line 1506 of file typcache.c.

{
    if (!(typentry->flags & TCFLAGS_CHECKED_FIELD_PROPERTIES))
        cache_record_field_properties(typentry);
    return (typentry->flags & TCFLAGS_HAVE_FIELD_EQUALITY) != 0;
}

References cache_record_field_properties(), TypeCacheEntry::flags, TCFLAGS_CHECKED_FIELD_PROPERTIES, and TCFLAGS_HAVE_FIELD_EQUALITY.

Referenced by lookup_type_cache().

record_fields_have_extended_hashing()

static bool record_fields_have_extended_hashing ( TypeCacheEntry *  typentry )

static

Definition at line 1530 of file typcache.c.

{
    if (!(typentry->flags & TCFLAGS_CHECKED_FIELD_PROPERTIES))
        cache_record_field_properties(typentry);
    return (typentry->flags & TCFLAGS_HAVE_FIELD_EXTENDED_HASHING) != 0;
}

References cache_record_field_properties(), TypeCacheEntry::flags, TCFLAGS_CHECKED_FIELD_PROPERTIES, and TCFLAGS_HAVE_FIELD_EXTENDED_HASHING.

Referenced by lookup_type_cache().

record_fields_have_hashing()

static bool record_fields_have_hashing ( TypeCacheEntry *  typentry )

static

Definition at line 1522 of file typcache.c.

{
    if (!(typentry->flags & TCFLAGS_CHECKED_FIELD_PROPERTIES))
        cache_record_field_properties(typentry);
    return (typentry->flags & TCFLAGS_HAVE_FIELD_HASHING) != 0;
}

References cache_record_field_properties(), TypeCacheEntry::flags, TCFLAGS_CHECKED_FIELD_PROPERTIES, and TCFLAGS_HAVE_FIELD_HASHING.

Referenced by lookup_type_cache().

record_type_typmod_compare()

static int record_type_typmod_compare ( const void *  a, const void *  b, size_t  size  )

static

Definition at line 1954 of file typcache.c.

{
    RecordCacheEntry *left = (RecordCacheEntry *) a;
    RecordCacheEntry *right = (RecordCacheEntry *) b;
 
    return equalRowTypes(left->tupdesc, right->tupdesc) ? 0 : 1;
}

References a, b, equalRowTypes(), and RecordCacheEntry::tupdesc.

Referenced by assign_record_type_typmod().

record_type_typmod_hash()

static uint32 record_type_typmod_hash ( const void *  data, size_t  size  )

static

Definition at line 1943 of file typcache.c.

{
    RecordCacheEntry *entry = (RecordCacheEntry *) data;
 
    return hashRowType(entry->tupdesc);
}

References data, hashRowType(), and RecordCacheEntry::tupdesc.

Referenced by assign_record_type_typmod().

share_tupledesc()

static dsa_pointer share_tupledesc ( dsa_area *  area, TupleDesc  tupdesc, uint32  typmod  )

static

Definition at line 2760 of file typcache.c.

{
    dsa_pointer shared_dp;
    TupleDesc   shared;
 
    shared_dp = dsa_allocate(area, TupleDescSize(tupdesc));
    shared = (TupleDesc) dsa_get_address(area, shared_dp);
    TupleDescCopy(shared, tupdesc);
    shared->tdtypmod = typmod;
 
    return shared_dp;
}

References dsa_allocate, dsa_get_address(), TupleDescData::tdtypmod, TupleDescCopy(), and TupleDescSize.

Referenced by find_or_make_matching_shared_tupledesc(), and SharedRecordTypmodRegistryInit().

shared_record_table_compare()

static int shared_record_table_compare ( const void *  a, const void *  b, size_t  size, void *  arg  )

static

Definition at line 215 of file typcache.c.

{
    dsa_area   *area = (dsa_area *) arg;
    SharedRecordTableKey *k1 = (SharedRecordTableKey *) a;
    SharedRecordTableKey *k2 = (SharedRecordTableKey *) b;
    TupleDesc   t1;
    TupleDesc   t2;
 
    if (k1->shared)
        t1 = (TupleDesc) dsa_get_address(area, k1->u.shared_tupdesc);
    else
        t1 = k1->u.local_tupdesc;
 
    if (k2->shared)
        t2 = (TupleDesc) dsa_get_address(area, k2->u.shared_tupdesc);
    else
        t2 = k2->u.local_tupdesc;
 
    return equalRowTypes(t1, t2) ? 0 : 1;
}

References a, arg, b, dsa_get_address(), equalRowTypes(), SharedRecordTableKey::local_tupdesc, SharedRecordTableKey::shared, SharedRecordTableKey::shared_tupdesc, and SharedRecordTableKey::u.

shared_record_table_hash()

static uint32 shared_record_table_hash ( const void *  a, size_t  size, void *  arg  )

static

Definition at line 241 of file typcache.c.

{
    dsa_area   *area = (dsa_area *) arg;
    SharedRecordTableKey *k = (SharedRecordTableKey *) a;
    TupleDesc   t;
 
    if (k->shared)
        t = (TupleDesc) dsa_get_address(area, k->u.shared_tupdesc);
    else
        t = k->u.local_tupdesc;
 
    return hashRowType(t);
}

References a, arg, dsa_get_address(), hashRowType(), SharedRecordTableKey::local_tupdesc, SharedRecordTableKey::shared, SharedRecordTableKey::shared_tupdesc, and SharedRecordTableKey::u.

shared_record_typmod_registry_detach()

static void shared_record_typmod_registry_detach ( dsm_segment *  segment, Datum  datum  )

static

Definition at line 2893 of file typcache.c.

{
    /* Be cautious here: maybe we didn't finish initializing. */
    if (CurrentSession->shared_record_table != NULL)
    {
        dshash_detach(CurrentSession->shared_record_table);
        CurrentSession->shared_record_table = NULL;
    }
    if (CurrentSession->shared_typmod_table != NULL)
    {
        dshash_detach(CurrentSession->shared_typmod_table);
        CurrentSession->shared_typmod_table = NULL;
    }
    CurrentSession->shared_typmod_registry = NULL;
}

References CurrentSession, dshash_detach(), Session::shared_record_table, Session::shared_typmod_registry, and Session::shared_typmod_table.

Referenced by SharedRecordTypmodRegistryAttach(), and SharedRecordTypmodRegistryInit().

SharedRecordTypmodRegistryAttach()

void SharedRecordTypmodRegistryAttach

(

SharedRecordTypmodRegistry *

registry

)

Definition at line 2224 of file typcache.c.

{
    MemoryContext old_context;
    dshash_table *record_table;
    dshash_table *typmod_table;
 
    Assert(IsParallelWorker());
 
    /* We can't already be attached to a shared registry. */
    Assert(CurrentSession != NULL);
    Assert(CurrentSession->segment != NULL);
    Assert(CurrentSession->area != NULL);
    Assert(CurrentSession->shared_typmod_registry == NULL);
    Assert(CurrentSession->shared_record_table == NULL);
    Assert(CurrentSession->shared_typmod_table == NULL);
 
    /*
     * We can't already have typmods in our local cache, because they'd clash
     * with those imported by SharedRecordTypmodRegistryInit.  This should be
     * a freshly started parallel worker.  If we ever support worker
     * recycling, a worker would need to zap its local cache in between
     * servicing different queries, in order to be able to call this and
     * synchronize typmods with a new leader; but that's problematic because
     * we can't be very sure that record-typmod-related state hasn't escaped
     * to anywhere else in the process.
     */
    Assert(NextRecordTypmod == 0);
 
    old_context = MemoryContextSwitchTo(TopMemoryContext);
 
    /* Attach to the two hash tables. */
    record_table = dshash_attach(CurrentSession->area,
                                 &srtr_record_table_params,
                                 registry->record_table_handle,
                                 CurrentSession->area);
    typmod_table = dshash_attach(CurrentSession->area,
                                 &srtr_typmod_table_params,
                                 registry->typmod_table_handle,
                                 NULL);
 
    MemoryContextSwitchTo(old_context);
 
    /*
     * Set up detach hook to run at worker exit.  Currently this is the same
     * as the leader's detach hook, but in future they might need to be
     * different.
     */
    on_dsm_detach(CurrentSession->segment,
                  shared_record_typmod_registry_detach,
                  PointerGetDatum(registry));
 
    /*
     * Set up the session state that will tell assign_record_type_typmod and
     * lookup_rowtype_tupdesc_internal about the shared registry.
     */
    CurrentSession->shared_typmod_registry = registry;
    CurrentSession->shared_record_table = record_table;
    CurrentSession->shared_typmod_table = typmod_table;
}

References Session::area, Assert, CurrentSession, dshash_attach(), IsParallelWorker, MemoryContextSwitchTo(), NextRecordTypmod, on_dsm_detach(), PointerGetDatum(), SharedRecordTypmodRegistry::record_table_handle, Session::segment, Session::shared_record_table, shared_record_typmod_registry_detach(), Session::shared_typmod_registry, Session::shared_typmod_table, srtr_record_table_params, srtr_typmod_table_params, TopMemoryContext, and SharedRecordTypmodRegistry::typmod_table_handle.

Referenced by AttachSession().

SharedRecordTypmodRegistryEstimate()

size_t SharedRecordTypmodRegistryEstimate

(

void

)

Definition at line 2103 of file typcache.c.

{
    return sizeof(SharedRecordTypmodRegistry);
}

Referenced by GetSessionDsmHandle().

SharedRecordTypmodRegistryInit()

void SharedRecordTypmodRegistryInit	(	SharedRecordTypmodRegistry *	registry,
		dsm_segment *	segment,
		dsa_area *	area
	)

Definition at line 2125 of file typcache.c.

{
    MemoryContext old_context;
    dshash_table *record_table;
    dshash_table *typmod_table;
    int32       typmod;
 
    Assert(!IsParallelWorker());
 
    /* We can't already be attached to a shared registry. */
    Assert(CurrentSession->shared_typmod_registry == NULL);
    Assert(CurrentSession->shared_record_table == NULL);
    Assert(CurrentSession->shared_typmod_table == NULL);
 
    old_context = MemoryContextSwitchTo(TopMemoryContext);
 
    /* Create the hash table of tuple descriptors indexed by themselves. */
    record_table = dshash_create(area, &srtr_record_table_params, area);
 
    /* Create the hash table of tuple descriptors indexed by typmod. */
    typmod_table = dshash_create(area, &srtr_typmod_table_params, NULL);
 
    MemoryContextSwitchTo(old_context);
 
    /* Initialize the SharedRecordTypmodRegistry. */
    registry->record_table_handle = dshash_get_hash_table_handle(record_table);
    registry->typmod_table_handle = dshash_get_hash_table_handle(typmod_table);
    pg_atomic_init_u32(&registry->next_typmod, NextRecordTypmod);
 
    /*
     * Copy all entries from this backend's private registry into the shared
     * registry.
     */
    for (typmod = 0; typmod < NextRecordTypmod; ++typmod)
    {
        SharedTypmodTableEntry *typmod_table_entry;
        SharedRecordTableEntry *record_table_entry;
        SharedRecordTableKey record_table_key;
        dsa_pointer shared_dp;
        TupleDesc   tupdesc;
        bool        found;
 
        tupdesc = RecordCacheArray[typmod].tupdesc;
        if (tupdesc == NULL)
            continue;
 
        /* Copy the TupleDesc into shared memory. */
        shared_dp = share_tupledesc(area, tupdesc, typmod);
 
        /* Insert into the typmod table. */
        typmod_table_entry = dshash_find_or_insert(typmod_table,
                                                   &tupdesc->tdtypmod,
                                                   &found);
        if (found)
            elog(ERROR, "cannot create duplicate shared record typmod");
        typmod_table_entry->typmod = tupdesc->tdtypmod;
        typmod_table_entry->shared_tupdesc = shared_dp;
        dshash_release_lock(typmod_table, typmod_table_entry);
 
        /* Insert into the record table. */
        record_table_key.shared = false;
        record_table_key.u.local_tupdesc = tupdesc;
        record_table_entry = dshash_find_or_insert(record_table,
                                                   &record_table_key,
                                                   &found);
        if (!found)
        {
            record_table_entry->key.shared = true;
            record_table_entry->key.u.shared_tupdesc = shared_dp;
        }
        dshash_release_lock(record_table, record_table_entry);
    }
 
    /*
     * Set up the global state that will tell assign_record_type_typmod and
     * lookup_rowtype_tupdesc_internal about the shared registry.
     */
    CurrentSession->shared_record_table = record_table;
    CurrentSession->shared_typmod_table = typmod_table;
    CurrentSession->shared_typmod_registry = registry;
 
    /*
     * We install a detach hook in the leader, but only to handle cleanup on
     * failure during GetSessionDsmHandle().  Once GetSessionDsmHandle() pins
     * the memory, the leader process will use a shared registry until it
     * exits.
     */
    on_dsm_detach(segment, shared_record_typmod_registry_detach, (Datum) 0);
}

References Assert, CurrentSession, dshash_create(), dshash_find_or_insert(), dshash_get_hash_table_handle(), dshash_release_lock(), elog, ERROR, IsParallelWorker, SharedRecordTableEntry::key, SharedRecordTableKey::local_tupdesc, MemoryContextSwitchTo(), SharedRecordTypmodRegistry::next_typmod, NextRecordTypmod, on_dsm_detach(), pg_atomic_init_u32(), SharedRecordTypmodRegistry::record_table_handle, RecordCacheArray, share_tupledesc(), SharedRecordTableKey::shared, Session::shared_record_table, shared_record_typmod_registry_detach(), SharedRecordTableKey::shared_tupdesc, SharedTypmodTableEntry::shared_tupdesc, Session::shared_typmod_registry, Session::shared_typmod_table, srtr_record_table_params, srtr_typmod_table_params, TupleDescData::tdtypmod, TopMemoryContext, RecordCacheArrayEntry::tupdesc, SharedTypmodTableEntry::typmod, SharedRecordTypmodRegistry::typmod_table_handle, and SharedRecordTableKey::u.

Referenced by GetSessionDsmHandle().

type_cache_syshash()

static uint32 type_cache_syshash ( const void *  key, Size  keysize  )

static

Definition at line 338 of file typcache.c.

{
    Assert(keysize == sizeof(Oid));
    return GetSysCacheHashValue1(TYPEOID, ObjectIdGetDatum(*(const Oid *) key));
}

References Assert, GetSysCacheHashValue1, sort-test::key, and ObjectIdGetDatum().

Referenced by lookup_type_cache().

TypeCacheConstrCallback()

static void TypeCacheConstrCallback ( Datum  arg, int  cacheid, uint32  hashvalue  )

static

Definition at line 2449 of file typcache.c.

{
    TypeCacheEntry *typentry;
 
    /*
     * Because this is called very frequently, and typically very few of the
     * typcache entries are for domains, we don't use hash_seq_search here.
     * Instead we thread all the domain-type entries together so that we can
     * visit them cheaply.
     */
    for (typentry = firstDomainTypeEntry;
         typentry != NULL;
         typentry = typentry->nextDomain)
    {
        /* Reset domain constraint validity information */
        typentry->flags &= ~TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS;
    }
}

References firstDomainTypeEntry, TypeCacheEntry::flags, TypeCacheEntry::nextDomain, and TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS.

Referenced by lookup_type_cache().

TypeCacheOpcCallback()

static void TypeCacheOpcCallback ( Datum  arg, int  cacheid, uint32  hashvalue  )

static

Definition at line 2420 of file typcache.c.

{
    HASH_SEQ_STATUS status;
    TypeCacheEntry *typentry;
 
    /* TypeCacheHash must exist, else this callback wouldn't be registered */
    hash_seq_init(&status, TypeCacheHash);
    while ((typentry = (TypeCacheEntry *) hash_seq_search(&status)) != NULL)
    {
        /* Reset equality/comparison/hashing validity information */
        typentry->flags &= ~TCFLAGS_OPERATOR_FLAGS;
    }
}

References TypeCacheEntry::flags, hash_seq_init(), hash_seq_search(), TCFLAGS_OPERATOR_FLAGS, and TypeCacheHash.

Referenced by lookup_type_cache().

TypeCacheRelCallback()

static void TypeCacheRelCallback ( Datum  arg, Oid  relid  )

static

Definition at line 2307 of file typcache.c.

{
    HASH_SEQ_STATUS status;
    TypeCacheEntry *typentry;
 
    /* TypeCacheHash must exist, else this callback wouldn't be registered */
    hash_seq_init(&status, TypeCacheHash);
    while ((typentry = (TypeCacheEntry *) hash_seq_search(&status)) != NULL)
    {
        if (typentry->typtype == TYPTYPE_COMPOSITE)
        {
            /* Skip if no match, unless we're zapping all composite types */
            if (relid != typentry->typrelid && relid != InvalidOid)
                continue;
 
            /* Delete tupdesc if we have it */
            if (typentry->tupDesc != NULL)
            {
                /*
                 * Release our refcount, and free the tupdesc if none remain.
                 * (Can't use DecrTupleDescRefCount because this reference is
                 * not logged in current resource owner.)
                 */
                Assert(typentry->tupDesc->tdrefcount > 0);
                if (--typentry->tupDesc->tdrefcount == 0)
                    FreeTupleDesc(typentry->tupDesc);
                typentry->tupDesc = NULL;
 
                /*
                 * Also clear tupDesc_identifier, so that anything watching
                 * that will realize that the tupdesc has possibly changed.
                 * (Alternatively, we could specify that to detect possible
                 * tupdesc change, one must check for tupDesc != NULL as well
                 * as tupDesc_identifier being the same as what was previously
                 * seen.  That seems error-prone.)
                 */
                typentry->tupDesc_identifier = 0;
            }
 
            /* Reset equality/comparison/hashing validity information */
            typentry->flags &= ~TCFLAGS_OPERATOR_FLAGS;
        }
        else if (typentry->typtype == TYPTYPE_DOMAIN)
        {
            /*
             * If it's domain over composite, reset flags.  (We don't bother
             * trying to determine whether the specific base type needs a
             * reset.)  Note that if we haven't determined whether the base
             * type is composite, we don't need to reset anything.
             */
            if (typentry->flags & TCFLAGS_DOMAIN_BASE_IS_COMPOSITE)
                typentry->flags &= ~TCFLAGS_OPERATOR_FLAGS;
        }
    }
}

References Assert, TypeCacheEntry::flags, FreeTupleDesc(), hash_seq_init(), hash_seq_search(), InvalidOid, TCFLAGS_DOMAIN_BASE_IS_COMPOSITE, TCFLAGS_OPERATOR_FLAGS, TupleDescData::tdrefcount, TypeCacheEntry::tupDesc, TypeCacheEntry::tupDesc_identifier, TypeCacheHash, TypeCacheEntry::typrelid, and TypeCacheEntry::typtype.

Referenced by lookup_type_cache().

TypeCacheTypCallback()

static void TypeCacheTypCallback ( Datum  arg, int  cacheid, uint32  hashvalue  )

static

Definition at line 2372 of file typcache.c.

{
    HASH_SEQ_STATUS status;
    TypeCacheEntry *typentry;
 
    /* TypeCacheHash must exist, else this callback wouldn't be registered */
 
    /*
     * By convention, zero hash value is passed to the callback as a sign that
     * it's time to invalidate the whole cache. See sinval.c, inval.c and
     * InvalidateSystemCachesExtended().
     */
    if (hashvalue == 0)
        hash_seq_init(&status, TypeCacheHash);
    else
        hash_seq_init_with_hash_value(&status, TypeCacheHash, hashvalue);
 
    while ((typentry = (TypeCacheEntry *) hash_seq_search(&status)) != NULL)
    {
        Assert(hashvalue == 0 || typentry->type_id_hash == hashvalue);
 
        /*
         * Mark the data obtained directly from pg_type as invalid.  Also, if
         * it's a domain, typnotnull might've changed, so we'll need to
         * recalculate its constraints.
         */
        typentry->flags &= ~(TCFLAGS_HAVE_PG_TYPE_DATA |
                             TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS);
    }
}

References Assert, TypeCacheEntry::flags, hash_seq_init(), hash_seq_init_with_hash_value(), hash_seq_search(), TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS, TCFLAGS_HAVE_PG_TYPE_DATA, TypeCacheEntry::type_id_hash, and TypeCacheHash.

Referenced by lookup_type_cache().

UpdateDomainConstraintRef()

void UpdateDomainConstraintRef

(

DomainConstraintRef *

ref

)

Definition at line 1368 of file typcache.c.

{
    TypeCacheEntry *typentry = ref->tcache;
 
    /* Make sure typcache entry's data is up to date */
    if ((typentry->flags & TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS) == 0 &&
        typentry->typtype == TYPTYPE_DOMAIN)
        load_domaintype_info(typentry);
 
    /* Transfer to ref object if there's new info, adjusting refcounts */
    if (ref->dcc != typentry->domainData)
    {
        /* Paranoia --- be sure link is nulled before trying to release */
        DomainConstraintCache *dcc = ref->dcc;
 
        if (dcc)
        {
            /*
             * Note: we just leak the previous list of executable domain
             * constraints.  Alternatively, we could keep those in a child
             * context of ref->refctx and free that context at this point.
             * However, in practice this code path will be taken so seldom
             * that the extra bookkeeping for a child context doesn't seem
             * worthwhile; we'll just allow a leak for the lifespan of refctx.
             */
            ref->constraints = NIL;
            ref->dcc = NULL;
            decr_dcc_refcount(dcc);
        }
        dcc = typentry->domainData;
        if (dcc)
        {
            ref->dcc = dcc;
            dcc->dccRefCount++;
            if (ref->need_exprstate)
                ref->constraints = prep_domain_constraints(dcc->constraints,
                                                           ref->refctx);
            else
                ref->constraints = dcc->constraints;
        }
    }
}

References DomainConstraintCache::constraints, DomainConstraintRef::constraints, DomainConstraintRef::dcc, DomainConstraintCache::dccRefCount, decr_dcc_refcount(), TypeCacheEntry::domainData, TypeCacheEntry::flags, load_domaintype_info(), DomainConstraintRef::need_exprstate, NIL, prep_domain_constraints(), DomainConstraintRef::refctx, DomainConstraintRef::tcache, TCFLAGS_CHECKED_DOMAIN_CONSTRAINTS, and TypeCacheEntry::typtype.

Referenced by domain_check_input().

Variable Documentation

firstDomainTypeEntry

TypeCacheEntry* firstDomainTypeEntry = NULL

static

Definition at line 81 of file typcache.c.

Referenced by lookup_type_cache(), and TypeCacheConstrCallback().

NextRecordTypmod

int32 NextRecordTypmod = 0

static

Definition at line 287 of file typcache.c.

Referenced by assign_record_type_typmod(), SharedRecordTypmodRegistryAttach(), and SharedRecordTypmodRegistryInit().

RecordCacheArray

RecordCacheArrayEntry* RecordCacheArray = NULL

static

Definition at line 285 of file typcache.c.

Referenced by assign_record_type_identifier(), assign_record_type_typmod(), ensure_record_cache_typmod_slot_exists(), lookup_rowtype_tupdesc_internal(), and SharedRecordTypmodRegistryInit().

RecordCacheArrayLen

int32 RecordCacheArrayLen = 0

static

Definition at line 286 of file typcache.c.

Referenced by assign_record_type_identifier(), ensure_record_cache_typmod_slot_exists(), and lookup_rowtype_tupdesc_internal().

RecordCacheHash

HTAB* RecordCacheHash = NULL

static

Definition at line 276 of file typcache.c.

Referenced by assign_record_type_typmod().

srtr_record_table_params

const dshash_parameters srtr_record_table_params

static

Initial value:

= {
    sizeof(SharedRecordTableKey),   
    sizeof(SharedRecordTableEntry),
    shared_record_table_compare,
    shared_record_table_hash,
    dshash_memcpy,
    LWTRANCHE_PER_SESSION_RECORD_TYPE
}

Definition at line 256 of file typcache.c.

Referenced by SharedRecordTypmodRegistryAttach(), and SharedRecordTypmodRegistryInit().

srtr_typmod_table_params

const dshash_parameters srtr_typmod_table_params

static

Initial value:

= {
    sizeof(uint32),
    sizeof(SharedTypmodTableEntry),
    dshash_memcmp,
    dshash_memhash,
    dshash_memcpy,
    LWTRANCHE_PER_SESSION_RECORD_TYPMOD
}

Definition at line 266 of file typcache.c.

Referenced by SharedRecordTypmodRegistryAttach(), and SharedRecordTypmodRegistryInit().

tupledesc_id_counter

uint64 tupledesc_id_counter = INVALID_TUPLEDESC_IDENTIFIER

static

Definition at line 294 of file typcache.c.

Referenced by assign_record_type_identifier(), assign_record_type_typmod(), load_typcache_tupdesc(), and lookup_rowtype_tupdesc_internal().

TypeCacheHash

HTAB* TypeCacheHash = NULL

static

Definition at line 78 of file typcache.c.

Referenced by lookup_type_cache(), TypeCacheOpcCallback(), TypeCacheRelCallback(), and TypeCacheTypCallback().