1berry/postgres
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
postgres/src/backend/utils/cache/relcache.c

2962 lines
80 KiB
C
Raw Normal View History

Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
/*-------------------------------------------------------------------------
*
Change my-function-name-- to my_function_name, and optimizer renames.
1999-02-13 23:22:53 +00:00
* relcache.c
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* POSTGRES relation descriptor cache code
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Change Copyright from PostgreSQL, Inc to PostgreSQL Global Development Group.
2001-01-24 19:43:33 +00:00
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
Add: * Portions Copyright (c) 1996-2000, PostgreSQL, Inc to all files copyright Regents of Berkeley. Man, that's a lot of files.
2000-01-26 05:58:53 +00:00
* Portions Copyright (c) 1994, Regents of the University of California
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
*
* IDENTIFICATION
Fix init_irels to close the pg_internal.init file before returning. This saves one open file descriptor per backend, and avoids an annoying NOTICE on Cygwin (which has trouble deleting open files). Bug appears to date back to original coding of init_irels, circa 1992.
2002-01-16 17:34:42 +00:00
* $Header: /cvsroot/pgsql/src/backend/utils/cache/relcache.c,v 1.151 2002/01/16 17:34:42 tgl Exp $
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
*-------------------------------------------------------------------------
*/
/*
* INTERFACE ROUTINES
Toast all the system-table columns that seem to need it. It turns out that giving pg_proc a toast table required solving the same problems we'd have to solve for pg_class --- pg_proc is one of the relations that gets bootstrapped in relcache.c. Solution is to go back at the end of initialization and read in the *real* pg_class row to replace the phony entry created by formrdesc(). This should work as long as there's no need to touch any toasted values during initialization, which seems a reasonable assumption. Although I did not add a toast-table for every single system table with a varlena attribute, I believe that it would work to just do ALTER TABLE pg_class CREATE TOAST TABLE. So anyone who's really intent on having several thousand ACL entries for a rel could do it. NOTE: I didn't force initdb, but you must do one to see the effects of this patch.
2000-08-06 04:40:08 +00:00
* RelationCacheInitialize - initialize relcache
* RelationCacheInitializePhase2 - finish initializing relcache
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* RelationIdCacheGetRelation - get a reldesc from the cache (id)
* RelationNameCacheGetRelation - get a reldesc from the cache (name)
* RelationIdGetRelation - get a reldesc by relation id
* RelationNameGetRelation - get a reldesc by relation name
* RelationClose - close an open relation
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
* NOTES
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* The following code contains many undocumented hacks. Please be
* careful....
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
Clean up syscache so that recursive invocation is safe, and remove error message about recursive use of a syscache. Also remove most of the specialized indexscan routines in indexing.c --- it turns out that catcache.c is perfectly able to perform the indexscan for itself, in fact has already looked up all the information needed to do so! This should be faster as well as needing far less boilerplate code.
2000-11-10 00:33:12 +00:00
#include "postgres.h"
Added SCO support, from Daniel Harris.
1997-07-28 00:57:08 +00:00
#include <sys/types.h>
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
#include <errno.h>
#include <sys/file.h>
More stuff to make it compile on various ports.
1996-11-27 08:16:44 +00:00
#include <fcntl.h>
Fix low-probability bug in relcache startup: write_irels wrote the pg_internal.init file in-place, which meant that if another backend started at about the same time, it might read the incomplete file. init_irels tries to guard against that, but I have now seen a crash due to reading bad data from a partly-written file. (This may indicate a kernel bug on my platform? Not sure.) Anyway, clearly the safest course is to write the new pg_internal.init file under a unique temporary filename, and rename it into place only after it's all written.
2000-03-31 19:39:22 +00:00
#include <unistd.h>
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
#include "access/genam.h"
#include "access/heapam.h"
#include "access/istrat.h"
#include "catalog/catalog.h"
This patch... 1. Removes the unnecessary "#define AbcRegProcedure 123"'s from pg_proc.h. 2. Changes those #defines to use the names already defined in fmgr.h. 3. Forces the make of fmgr.h in backend/Makefile instead of having it made as a dependency in access/common/Makefile *hack*hack*hack* 4. Rearranged the #includes to a less helter-skelter arrangement, also changing <file.h> to "file.h" to signify a non-system header. 5. Removed "pg_proc.h" from files where its only purpose was for the #defines removed in item #1. 6. Added "fmgr.h" to each file changed for completeness sake. Turns out that #6 was not necessary for some files because fmgr.h was being included in a roundabout way SIX levels deep by the first include. "access/genam.h" ->"access/relscan.h" ->"utils/rel.h" ->"access/strat.h" ->"access/skey.h" ->"fmgr.h" So adding fmgr.h really didn't add anything to the compile, hopefully just made it clearer to the programmer. S Darren.
1998-04-27 04:08:07 +00:00
#include "catalog/catname.h"
#include "catalog/index.h"
#include "catalog/indexing.h"
#include "catalog/pg_attrdef.h"
Fix performance problems with pg_index lookups (see, for example, discussion of 5/19/00). pg_index is now searched for indexes of a relation using an indexscan. Moreover, this is done once and cached in the relcache entry for the relation, in the form of a list of OIDs for the indexes. This list is used by the parser and executor to drive lookups in the pg_index syscache when they want to know the properties of the indexes. Net result: index information will be fully cached for repetitive operations such as inserts.
2000-06-17 21:49:04 +00:00
#include "catalog/pg_index.h"
Final cleanup
1999-07-16 05:23:30 +00:00
#include "catalog/pg_proc.h"
This patch... 1. Removes the unnecessary "#define AbcRegProcedure 123"'s from pg_proc.h. 2. Changes those #defines to use the names already defined in fmgr.h. 3. Forces the make of fmgr.h in backend/Makefile instead of having it made as a dependency in access/common/Makefile *hack*hack*hack* 4. Rearranged the #includes to a less helter-skelter arrangement, also changing <file.h> to "file.h" to signify a non-system header. 5. Removed "pg_proc.h" from files where its only purpose was for the #defines removed in item #1. 6. Added "fmgr.h" to each file changed for completeness sake. Turns out that #6 was not necessary for some files because fmgr.h was being included in a roundabout way SIX levels deep by the first include. "access/genam.h" ->"access/relscan.h" ->"utils/rel.h" ->"access/strat.h" ->"access/skey.h" ->"fmgr.h" So adding fmgr.h really didn't add anything to the compile, hopefully just made it clearer to the programmer. S Darren.
1998-04-27 04:08:07 +00:00
#include "catalog/pg_relcheck.h"
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
#include "catalog/pg_rewrite.h"
#include "catalog/pg_type.h"
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
#include "commands/trigger.h"
This patch... 1. Removes the unnecessary "#define AbcRegProcedure 123"'s from pg_proc.h. 2. Changes those #defines to use the names already defined in fmgr.h. 3. Forces the make of fmgr.h in backend/Makefile instead of having it made as a dependency in access/common/Makefile *hack*hack*hack* 4. Rearranged the #includes to a less helter-skelter arrangement, also changing <file.h> to "file.h" to signify a non-system header. 5. Removed "pg_proc.h" from files where its only purpose was for the #defines removed in item #1. 6. Added "fmgr.h" to each file changed for completeness sake. Turns out that #6 was not necessary for some files because fmgr.h was being included in a roundabout way SIX levels deep by the first include. "access/genam.h" ->"access/relscan.h" ->"utils/rel.h" ->"access/strat.h" ->"access/skey.h" ->"fmgr.h" So adding fmgr.h really didn't add anything to the compile, hopefully just made it clearer to the programmer. S Darren.
1998-04-27 04:08:07 +00:00
#include "miscadmin.h"
#include "storage/smgr.h"
Clean up syscache so that recursive invocation is safe, and remove error message about recursive use of a syscache. Also remove most of the specialized indexscan routines in indexing.c --- it turns out that catcache.c is perfectly able to perform the indexscan for itself, in fact has already looked up all the information needed to do so! This should be faster as well as needing far less boilerplate code.
2000-11-10 00:33:12 +00:00
#include "utils/builtins.h"
This patch... 1. Removes the unnecessary "#define AbcRegProcedure 123"'s from pg_proc.h. 2. Changes those #defines to use the names already defined in fmgr.h. 3. Forces the make of fmgr.h in backend/Makefile instead of having it made as a dependency in access/common/Makefile *hack*hack*hack* 4. Rearranged the #includes to a less helter-skelter arrangement, also changing <file.h> to "file.h" to signify a non-system header. 5. Removed "pg_proc.h" from files where its only purpose was for the #defines removed in item #1. 6. Added "fmgr.h" to each file changed for completeness sake. Turns out that #6 was not necessary for some files because fmgr.h was being included in a roundabout way SIX levels deep by the first include. "access/genam.h" ->"access/relscan.h" ->"utils/rel.h" ->"access/strat.h" ->"access/skey.h" ->"fmgr.h" So adding fmgr.h really didn't add anything to the compile, hopefully just made it clearer to the programmer. S Darren.
1998-04-27 04:08:07 +00:00
#include "utils/catcache.h"
First round of changes for new fmgr interface. fmgr itself and the key call sites are changed, but most called functions are still oldstyle. An exception is that the PL managers are updated (so, for example, NULL handling now behaves as expected in plperl and plpgsql functions). NOTE initdb is forced due to added column in pg_proc.
2000-05-28 17:56:29 +00:00
#include "utils/fmgroids.h"
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
#include "utils/hsearch.h"
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
#include "utils/memutils.h"
This patch... 1. Removes the unnecessary "#define AbcRegProcedure 123"'s from pg_proc.h. 2. Changes those #defines to use the names already defined in fmgr.h. 3. Forces the make of fmgr.h in backend/Makefile instead of having it made as a dependency in access/common/Makefile *hack*hack*hack* 4. Rearranged the #includes to a less helter-skelter arrangement, also changing <file.h> to "file.h" to signify a non-system header. 5. Removed "pg_proc.h" from files where its only purpose was for the #defines removed in item #1. 6. Added "fmgr.h" to each file changed for completeness sake. Turns out that #6 was not necessary for some files because fmgr.h was being included in a roundabout way SIX levels deep by the first include. "access/genam.h" ->"access/relscan.h" ->"utils/rel.h" ->"access/strat.h" ->"access/skey.h" ->"fmgr.h" So adding fmgr.h really didn't add anything to the compile, hopefully just made it clearer to the programmer. S Darren.
1998-04-27 04:08:07 +00:00
#include "utils/relcache.h"
In RelationNameGetRelation(), replace temp table name by real name before doing lookup. We only want to index temp tables by their real names in the relcache, to ensure there's not more than one relcache entry for them.
1999-09-04 21:47:23 +00:00
#include "utils/temprel.h"
This patch... 1. Removes the unnecessary "#define AbcRegProcedure 123"'s from pg_proc.h. 2. Changes those #defines to use the names already defined in fmgr.h. 3. Forces the make of fmgr.h in backend/Makefile instead of having it made as a dependency in access/common/Makefile *hack*hack*hack* 4. Rearranged the #includes to a less helter-skelter arrangement, also changing <file.h> to "file.h" to signify a non-system header. 5. Removed "pg_proc.h" from files where its only purpose was for the #defines removed in item #1. 6. Added "fmgr.h" to each file changed for completeness sake. Turns out that #6 was not necessary for some files because fmgr.h was being included in a roundabout way SIX levels deep by the first include. "access/genam.h" ->"access/relscan.h" ->"utils/rel.h" ->"access/strat.h" ->"access/skey.h" ->"fmgr.h" So adding fmgr.h really didn't add anything to the compile, hopefully just made it clearer to the programmer. S Darren.
1998-04-27 04:08:07 +00:00
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* hardcoded tuple descriptors. see lib/backend/catalog/pg_attribute.h
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
static FormData_pg_attribute Desc_pg_class[Natts_pg_class] = {Schema_pg_class};
static FormData_pg_attribute Desc_pg_attribute[Natts_pg_attribute] = {Schema_pg_attribute};
static FormData_pg_attribute Desc_pg_proc[Natts_pg_proc] = {Schema_pg_proc};
static FormData_pg_attribute Desc_pg_type[Natts_pg_type] = {Schema_pg_type};
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
* Hash tables that index the relation cache
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
* Relations are looked up two ways, by name and by id,
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* thus there are two hash tables for referencing them.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
static HTAB *RelationNameCache;
static HTAB *RelationIdCache;
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
/*
* Bufmgr uses RelFileNode for lookup. Actually, I would like to do
* not pass Relation to bufmgr & beyond at all and keep some cache
* in smgr, but no time to do it right way now. -- vadim 10/22/2000
*/
static HTAB *RelationNodeCache;
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
/*
* newlyCreatedRelns -
* relations created during this transaction. We need to keep track of
* these.
*/
static List *newlyCreatedRelns = NULL;
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
/*
* This flag is false until we have prepared the critical relcache entries
* that are needed to do indexscans on the tables read by relcache building.
*/
static bool criticalRelcachesBuilt = false;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* RelationBuildDescInfo exists so code can be shared
* between RelationIdGetRelation() and RelationNameGetRelation()
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
typedef struct RelationBuildDescInfo
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
int infotype; /* lookup by id or by name */
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
#define INFO_RELID 1
#define INFO_RELNAME 2
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
union
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
Oid info_id; /* relation object id */
char *info_name; /* relation name */
} i;
Used modified version of indent that understands over 100 typedefs.
1997-09-08 21:56:23 +00:00
} RelationBuildDescInfo;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
typedef struct relnamecacheent
{
NameData relname;
Relation reldesc;
} RelNameCacheEnt;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
typedef struct relidcacheent
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
Oid reloid;
Relation reldesc;
Used modified version of indent that understands over 100 typedefs.
1997-09-08 21:56:23 +00:00
} RelIdCacheEnt;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
typedef struct relnodecacheent
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
{
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
RelFileNode relnode;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
Relation reldesc;
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
} RelNodeCacheEnt;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Another round of cleanups for dynahash.c (maybe it's finally clean of portability issues). Caller-visible data structures are now allocated on MAXALIGN boundaries, allowing safe use of datatypes wider than 'long'. Rejigger hash_create API so that caller specifies size of key and total size of entry, not size of key and size of rest of entry. This simplifies life considerably since each number is just a sizeof(), and padding issues etc. are taken care of automatically.
2001-10-01 05:36:17 +00:00
* macros to manipulate the lookup hashtables
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
#define RelationCacheInsert(RELATION) \
Fix macros that were not properly surrounded by parens or braces.
1998-06-15 18:40:05 +00:00
do { \
RelIdCacheEnt *idhentry; RelNameCacheEnt *namehentry; \
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
char *relname; RelNodeCacheEnt *nodentry; bool found; \
Fix problem with temp tables shown in regression test by Jan.
1999-11-17 23:51:21 +00:00
relname = RelationGetPhysicalRelationName(RELATION); \
Fix macros that were not properly surrounded by parens or braces.
1998-06-15 18:40:05 +00:00
namehentry = (RelNameCacheEnt*)hash_search(RelationNameCache, \
relname, \
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
HASH_ENTER, \
&found); \
Fix macros that were not properly surrounded by parens or braces.
1998-06-15 18:40:05 +00:00
if (namehentry == NULL) \
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
elog(ERROR, "out of memory for relation descriptor cache"); \
/* used to give notice if found -- now just keep quiet */ ; \
Fix macros that were not properly surrounded by parens or braces.
1998-06-15 18:40:05 +00:00
namehentry->reldesc = RELATION; \
idhentry = (RelIdCacheEnt*)hash_search(RelationIdCache, \
Another round of cleanups for dynahash.c (maybe it's finally clean of portability issues). Caller-visible data structures are now allocated on MAXALIGN boundaries, allowing safe use of datatypes wider than 'long'. Rejigger hash_create API so that caller specifies size of key and total size of entry, not size of key and size of rest of entry. This simplifies life considerably since each number is just a sizeof(), and padding issues etc. are taken care of automatically.
2001-10-01 05:36:17 +00:00
(void *) &(RELATION->rd_id), \
Fix macros that were not properly surrounded by parens or braces.
1998-06-15 18:40:05 +00:00
HASH_ENTER, \
&found); \
if (idhentry == NULL) \
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
elog(ERROR, "out of memory for relation descriptor cache"); \
/* used to give notice if found -- now just keep quiet */ ; \
Fix macros that were not properly surrounded by parens or braces.
1998-06-15 18:40:05 +00:00
idhentry->reldesc = RELATION; \
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
nodentry = (RelNodeCacheEnt*)hash_search(RelationNodeCache, \
Another round of cleanups for dynahash.c (maybe it's finally clean of portability issues). Caller-visible data structures are now allocated on MAXALIGN boundaries, allowing safe use of datatypes wider than 'long'. Rejigger hash_create API so that caller specifies size of key and total size of entry, not size of key and size of rest of entry. This simplifies life considerably since each number is just a sizeof(), and padding issues etc. are taken care of automatically.
2001-10-01 05:36:17 +00:00
(void *) &(RELATION->rd_node), \
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
HASH_ENTER, \
&found); \
if (nodentry == NULL) \
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
elog(ERROR, "out of memory for relation descriptor cache"); \
/* used to give notice if found -- now just keep quiet */ ; \
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
nodentry->reldesc = RELATION; \
Fix macros that were not properly surrounded by parens or braces.
1998-06-15 18:40:05 +00:00
} while(0)
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
#define RelationNameCacheLookup(NAME, RELATION) \
Fix macros that were not properly surrounded by parens or braces.
1998-06-15 18:40:05 +00:00
do { \
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
RelNameCacheEnt *hentry; \
Fix macros that were not properly surrounded by parens or braces.
1998-06-15 18:40:05 +00:00
hentry = (RelNameCacheEnt*)hash_search(RelationNameCache, \
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
(void *) (NAME), HASH_FIND,NULL); \
if (hentry) \
Fix macros that were not properly surrounded by parens or braces.
1998-06-15 18:40:05 +00:00
RELATION = hentry->reldesc; \
else \
RELATION = NULL; \
} while(0)
OK, folks, here is the pgindent output.
1998-09-01 04:40:42 +00:00
#define RelationIdCacheLookup(ID, RELATION) \
Fix macros that were not properly surrounded by parens or braces.
1998-06-15 18:40:05 +00:00
do { \
RelIdCacheEnt *hentry; \
hentry = (RelIdCacheEnt*)hash_search(RelationIdCache, \
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
(void *)&(ID), HASH_FIND,NULL); \
if (hentry) \
Fix macros that were not properly surrounded by parens or braces.
1998-06-15 18:40:05 +00:00
RELATION = hentry->reldesc; \
else \
RELATION = NULL; \
} while(0)
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
#define RelationNodeCacheLookup(NODE, RELATION) \
do { \
RelNodeCacheEnt *hentry; \
hentry = (RelNodeCacheEnt*)hash_search(RelationNodeCache, \
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
(void *)&(NODE), HASH_FIND,NULL); \
if (hentry) \
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
RELATION = hentry->reldesc; \
else \
RELATION = NULL; \
} while(0)
Fix macros that were not properly surrounded by parens or braces.
1998-06-15 18:40:05 +00:00
#define RelationCacheDelete(RELATION) \
do { \
RelNameCacheEnt *namehentry; RelIdCacheEnt *idhentry; \
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
char *relname; RelNodeCacheEnt *nodentry; \
Fix problem with temp tables shown in regression test by Jan.
1999-11-17 23:51:21 +00:00
relname = RelationGetPhysicalRelationName(RELATION); \
Fix macros that were not properly surrounded by parens or braces.
1998-06-15 18:40:05 +00:00
namehentry = (RelNameCacheEnt*)hash_search(RelationNameCache, \
relname, \
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
HASH_REMOVE, NULL); \
Fix macros that were not properly surrounded by parens or braces.
1998-06-15 18:40:05 +00:00
if (namehentry == NULL) \
elog(NOTICE, "trying to delete a reldesc that does not exist."); \
idhentry = (RelIdCacheEnt*)hash_search(RelationIdCache, \
Another round of cleanups for dynahash.c (maybe it's finally clean of portability issues). Caller-visible data structures are now allocated on MAXALIGN boundaries, allowing safe use of datatypes wider than 'long'. Rejigger hash_create API so that caller specifies size of key and total size of entry, not size of key and size of rest of entry. This simplifies life considerably since each number is just a sizeof(), and padding issues etc. are taken care of automatically.
2001-10-01 05:36:17 +00:00
(void *)&(RELATION->rd_id), \
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
HASH_REMOVE, NULL); \
Fix macros that were not properly surrounded by parens or braces.
1998-06-15 18:40:05 +00:00
if (idhentry == NULL) \
elog(NOTICE, "trying to delete a reldesc that does not exist."); \
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
nodentry = (RelNodeCacheEnt*)hash_search(RelationNodeCache, \
Another round of cleanups for dynahash.c (maybe it's finally clean of portability issues). Caller-visible data structures are now allocated on MAXALIGN boundaries, allowing safe use of datatypes wider than 'long'. Rejigger hash_create API so that caller specifies size of key and total size of entry, not size of key and size of rest of entry. This simplifies life considerably since each number is just a sizeof(), and padding issues etc. are taken care of automatically.
2001-10-01 05:36:17 +00:00
(void *)&(RELATION->rd_node), \
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
HASH_REMOVE, NULL); \
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
if (nodentry == NULL) \
elog(NOTICE, "trying to delete a reldesc that does not exist."); \
Fix macros that were not properly surrounded by parens or braces.
1998-06-15 18:40:05 +00:00
} while(0)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
Read info for DEFAULT from pg_attrdef.
1997-08-21 01:36:09 +00:00
/* non-export function prototypes */
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
static void RelationClearRelation(Relation relation, bool rebuildIt);
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
REINDEX under WAL.
2000-12-08 06:17:58 +00:00
#ifdef ENABLE_REINDEX_NAILED_RELATIONS
static void RelationReloadClassinfo(Relation relation);
New pgindent run with fixes suggested by Tom. Patch manually reviewed, initdb/regression tests pass.
2001-11-05 17:46:40 +00:00
#endif /* ENABLE_REINDEX_NAILED_RELATIONS */
Clean up non-reentrant interface for hash_seq/HashTableWalk, so that starting a new hashtable search no longer clobbers any other search active anywhere in the system. Fix RelationCacheInvalidate() so that it will not crash or go into an infinite loop if invoked recursively, as for example by a second SI Reset message arriving while we are still processing a prior one.
2001-01-02 04:33:24 +00:00
static void RelationFlushRelation(Relation relation);
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
static Relation RelationNameCacheGetRelation(const char *relationName);
static void init_irels(void);
static void write_irels(void);
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
static void formrdesc(char *relationName, int natts,
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
FormData_pg_attribute *att);
Toast all the system-table columns that seem to need it. It turns out that giving pg_proc a toast table required solving the same problems we'd have to solve for pg_class --- pg_proc is one of the relations that gets bootstrapped in relcache.c. Solution is to go back at the end of initialization and read in the *real* pg_class row to replace the phony entry created by formrdesc(). This should work as long as there's no need to touch any toasted values during initialization, which seems a reasonable assumption. Although I did not add a toast-table for every single system table with a varlena attribute, I believe that it would work to just do ALTER TABLE pg_class CREATE TOAST TABLE. So anyone who's really intent on having several thousand ACL entries for a rel could do it. NOTE: I didn't force initdb, but you must do one to see the effects of this patch.
2000-08-06 04:40:08 +00:00
static void fixrdesc(char *relationName);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Read info for DEFAULT from pg_attrdef.
1997-08-21 01:36:09 +00:00
static HeapTuple ScanPgRelation(RelationBuildDescInfo buildinfo);
static HeapTuple scan_pg_rel_seq(RelationBuildDescInfo buildinfo);
static HeapTuple scan_pg_rel_ind(RelationBuildDescInfo buildinfo);
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
static Relation AllocateRelationDesc(Relation relation, Form_pg_class relp);
OK, folks, here is the pgindent output.
1998-09-01 04:40:42 +00:00
static void RelationBuildTupleDesc(RelationBuildDescInfo buildinfo,
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
Relation relation);
OK, folks, here is the pgindent output.
1998-09-01 04:40:42 +00:00
static void build_tupdesc_seq(RelationBuildDescInfo buildinfo,
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
Relation relation);
OK, folks, here is the pgindent output.
1998-09-01 04:40:42 +00:00
static void build_tupdesc_ind(RelationBuildDescInfo buildinfo,
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
Relation relation);
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
static Relation RelationBuildDesc(RelationBuildDescInfo buildinfo,
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
Relation oldrelation);
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
static void AttrDefaultFetch(Relation relation);
static void RelCheckFetch(Relation relation);
Modify index-opening code to guarantee that the indexes of a relation are opened in a consistent order by different backends (I ordered them by index OID because that's easy, but any other consistent order would do as well). This avoids potential deadlock for index types that we acquire exclusive locks on ... ie, rtree.
2000-06-19 23:40:48 +00:00
static List *insert_ordered_oid(List *list, Oid datum);
Read info for DEFAULT from pg_attrdef.
1997-08-21 01:36:09 +00:00
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* RelationIdGetRelation() and RelationNameGetRelation()
* support functions
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* ScanPgRelation
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* this is used by RelationBuildDesc to find a pg_class
* tuple matching either a relation name or a relation id
* as specified in buildinfo.
Repair memory leaks that caused CacheCxt to grow without bound. We really ought to fix relcache entry construction so that it does not do so much with CurrentMemoryContext = CacheCxt. As is, relatively harmless leaks in either sequential or index scanning translate to permanent leaks if they occur when called from relcache build. For the moment, however, the path of least resistance is to repair all such leaks...
2000-05-21 02:28:55 +00:00
*
* NB: the returned tuple has been copied into palloc'd storage
* and must eventually be freed with heap_freetuple.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
static HeapTuple
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
ScanPgRelation(RelationBuildDescInfo buildinfo)
{
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
/*
* If this is bootstrap time (initdb), then we can't use the system
* catalog indices, because they may not exist yet. Otherwise, we
* can, and do.
*/
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
if (IsIgnoringSystemIndexes() || !criticalRelcachesBuilt)
Renaming cleanup, no pgindent yet.
1998-09-01 03:29:17 +00:00
return scan_pg_rel_seq(buildinfo);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
else
Renaming cleanup, no pgindent yet.
1998-09-01 03:29:17 +00:00
return scan_pg_rel_ind(buildinfo);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
static HeapTuple
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
scan_pg_rel_seq(RelationBuildDescInfo buildinfo)
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
HeapTuple pg_class_tuple;
HeapTuple return_tuple;
Relation pg_class_desc;
HeapScanDesc pg_class_scan;
ScanKeyData key;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* form a scan key
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
switch (buildinfo.infotype)
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
case INFO_RELID:
ScanKeyEntryInitialize(&key, 0,
ObjectIdAttributeNumber,
This patch... 1. Removes the unnecessary "#define AbcRegProcedure 123"'s from pg_proc.h. 2. Changes those #defines to use the names already defined in fmgr.h. 3. Forces the make of fmgr.h in backend/Makefile instead of having it made as a dependency in access/common/Makefile *hack*hack*hack* 4. Rearranged the #includes to a less helter-skelter arrangement, also changing <file.h> to "file.h" to signify a non-system header. 5. Removed "pg_proc.h" from files where its only purpose was for the #defines removed in item #1. 6. Added "fmgr.h" to each file changed for completeness sake. Turns out that #6 was not necessary for some files because fmgr.h was being included in a roundabout way SIX levels deep by the first include. "access/genam.h" ->"access/relscan.h" ->"utils/rel.h" ->"access/strat.h" ->"access/skey.h" ->"fmgr.h" So adding fmgr.h really didn't add anything to the compile, hopefully just made it clearer to the programmer. S Darren.
1998-04-27 04:08:07 +00:00
F_OIDEQ,
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
ObjectIdGetDatum(buildinfo.i.info_id));
break;
case INFO_RELNAME:
ScanKeyEntryInitialize(&key, 0,
Anum_pg_class_relname,
This patch... 1. Removes the unnecessary "#define AbcRegProcedure 123"'s from pg_proc.h. 2. Changes those #defines to use the names already defined in fmgr.h. 3. Forces the make of fmgr.h in backend/Makefile instead of having it made as a dependency in access/common/Makefile *hack*hack*hack* 4. Rearranged the #includes to a less helter-skelter arrangement, also changing <file.h> to "file.h" to signify a non-system header. 5. Removed "pg_proc.h" from files where its only purpose was for the #defines removed in item #1. 6. Added "fmgr.h" to each file changed for completeness sake. Turns out that #6 was not necessary for some files because fmgr.h was being included in a roundabout way SIX levels deep by the first include. "access/genam.h" ->"access/relscan.h" ->"utils/rel.h" ->"access/strat.h" ->"access/skey.h" ->"fmgr.h" So adding fmgr.h really didn't add anything to the compile, hopefully just made it clearer to the programmer. S Darren.
1998-04-27 04:08:07 +00:00
F_NAMEEQ,
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
NameGetDatum(buildinfo.i.info_name));
break;
default:
Goodbye ABORT. Hello ERROR for all errors.
1998-01-07 21:07:04 +00:00
elog(ERROR, "ScanPgRelation: bad buildinfo");
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
return NULL;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
}
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* open pg_class and fetch a tuple
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
pg_class_desc = heap_openr(RelationRelationName, AccessShareLock);
heap_fetch requires buffer pointer, must be released; heap_getnext no longer returns buffer pointer, can be gotten from scan; descriptor; bootstrap can create multi-key indexes; pg_procname index now is multi-key index; oidint2, oidint4, oidname are gone (must be removed from regression tests); use System Cache rather than sequential scan in many places; heap_modifytuple no longer takes buffer parameter; remove unused buffer parameter in a few other functions; oid8 is not index-able; remove some use of single-character variable names; cleanup Buffer variables usage and scan descriptor looping; cleaned up allocation and freeing of tuples; 18k lines of diff;
1998-08-19 02:04:17 +00:00
pg_class_scan = heap_beginscan(pg_class_desc, 0, SnapshotNow, 1, &key);
pg_class_tuple = heap_getnext(pg_class_scan, 0);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* get set to return tuple
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
if (!HeapTupleIsValid(pg_class_tuple))
return_tuple = pg_class_tuple;
else
{
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* a satanic bug used to live here: pg_class_tuple used to be
* returned here without having the corresponding buffer pinned.
* so when the buffer gets replaced, all hell breaks loose. this
* bug is discovered and killed by wei on 9/27/91.
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
New HeapTuple structure/interface.
1998-11-27 19:52:36 +00:00
return_tuple = heap_copytuple(pg_class_tuple);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
}
/* all done */
heap_endscan(pg_class_scan);
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
heap_close(pg_class_desc, AccessShareLock);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
return return_tuple;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
static HeapTuple
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
scan_pg_rel_ind(RelationBuildDescInfo buildinfo)
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
Relation pg_class_desc;
HeapTuple return_tuple;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
pg_class_desc = heap_openr(RelationRelationName, AccessShareLock);
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
REINDEX under WAL.
2000-12-08 06:17:58 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* If the indexes of pg_class are deactivated we have to call
* scan_pg_rel_seq() instead.
REINDEX under WAL.
2000-12-08 06:17:58 +00:00
*/
if (!pg_class_desc->rd_rel->relhasindex)
{
heap_close(pg_class_desc, AccessShareLock);
return scan_pg_rel_seq(buildinfo);
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
switch (buildinfo.infotype)
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
case INFO_RELID:
Clean out another pocket of functions called via nonspecific function pointers, namely the catcache tuple fetch routines. Also get rid of the unused and possibly confusing 'size' field in struct cachedesc. Since it doesn't allow for variable-length fields, anyone who actually trusted it would likely be making a mistake...
2000-06-17 04:56:39 +00:00
return_tuple = ClassOidIndexScan(pg_class_desc,
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
ObjectIdGetDatum(buildinfo.i.info_id));
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
break;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
case INFO_RELNAME:
return_tuple = ClassNameIndexScan(pg_class_desc,
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
PointerGetDatum(buildinfo.i.info_name));
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
break;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
default:
Goodbye ABORT. Hello ERROR for all errors.
1998-01-07 21:07:04 +00:00
elog(ERROR, "ScanPgRelation: bad buildinfo");
Another pgindent run. Fixes enum indenting, and improves #endif spacing. Also adds space for one-line comments.
2001-10-28 06:26:15 +00:00
return_tuple = NULL; /* keep compiler quiet */
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
}
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
heap_close(pg_class_desc, AccessShareLock);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Repair memory leaks that caused CacheCxt to grow without bound. We really ought to fix relcache entry construction so that it does not do so much with CurrentMemoryContext = CacheCxt. As is, relatively harmless leaks in either sequential or index scanning translate to permanent leaks if they occur when called from relcache build. For the moment, however, the path of least resistance is to repair all such leaks...
2000-05-21 02:28:55 +00:00
/* The xxxIndexScan routines will have returned a palloc'd tuple. */
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
return return_tuple;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* AllocateRelationDesc
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* This is used to allocate memory for a new relation descriptor
* and initialize the rd_rel field.
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
*
* If 'relation' is NULL, allocate a new RelationData object.
* If not, reuse the given object (that path is taken only when
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
* we have to rebuild a relcache entry during RelationClearRelation).
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
static Relation
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
AllocateRelationDesc(Relation relation, Form_pg_class relp)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
{
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
MemoryContext oldcxt;
Renaming cleanup, no pgindent yet.
1998-09-01 03:29:17 +00:00
Form_pg_class relationForm;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
/* Relcache entries must live in CacheMemoryContext */
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* allocate space for new relation descriptor, if needed
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
if (relation == NULL)
Repair bugs discussed in pghackers thread of 15 May 1999: creation of a relcache entry no longer leaks a small amount of memory. index_endscan now releases all the memory acquired by index_beginscan, so callers of it should NOT pfree the scan descriptor anymore.
1999-12-30 05:05:13 +00:00
relation = (Relation) palloc(sizeof(RelationData));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* clear all fields of reldesc
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Repair bugs discussed in pghackers thread of 15 May 1999: creation of a relcache entry no longer leaks a small amount of memory. index_endscan now releases all the memory acquired by index_beginscan, so callers of it should NOT pfree the scan descriptor anymore.
1999-12-30 05:05:13 +00:00
MemSet((char *) relation, 0, sizeof(RelationData));
Install infrastructure for shared-memory free space map. Doesn't actually do anything yet, but it has the necessary connections to initialization and so forth. Make some gestures towards allowing number of blocks in a relation to be BlockNumber, ie, unsigned int, rather than signed int. (I doubt I got all the places that are sloppy about it, yet.) On the way, replace the hardwired NLOCKS_PER_XACT fudge factor with a GUC variable.
2001-06-27 23:31:40 +00:00
relation->rd_targblock = InvalidBlockNumber;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
/* make sure relation is marked as having no open file yet */
relation->rd_fd = -1;
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* Copy the relation tuple form
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* We only allocate space for the fixed fields, ie, CLASS_TUPLE_SIZE.
* relacl is NOT stored in the relcache --- there'd be little point in
* it, since we don't copy the tuple's nullvalues bitmap and hence
* wouldn't know if the value is valid ... bottom line is that relacl
* *cannot* be retrieved from the relcache. Get it from the syscache
* if you need it.
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
*/
relationForm = (Form_pg_class) palloc(CLASS_TUPLE_SIZE);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
memcpy((char *) relationForm, (char *) relp, CLASS_TUPLE_SIZE);
/* initialize relation tuple form */
Renaming cleanup, no pgindent yet.
1998-09-01 03:29:17 +00:00
relation->rd_rel = relationForm;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
/* and allocate attribute tuple form storage */
relation->rd_att = CreateTemplateTupleDesc(relationForm->relnatts);
MemoryContextSwitchTo(oldcxt);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
return relation;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* RelationBuildTupleDesc
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* Form the relation's tuple descriptor from information in
* the pg_attribute, pg_attrdef & pg_relcheck system cataloges.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
static void
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
RelationBuildTupleDesc(RelationBuildDescInfo buildinfo,
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
Relation relation)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
{
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
/*
* If this is bootstrap time (initdb), then we can't use the system
* catalog indices, because they may not exist yet. Otherwise, we
* can, and do.
*/
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
if (IsIgnoringSystemIndexes() || !criticalRelcachesBuilt)
build_tupdesc_seq(buildinfo, relation);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
else
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
build_tupdesc_ind(buildinfo, relation);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Implement reindex command
2000-02-18 09:30:20 +00:00
static void
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
SetConstrOfRelation(Relation relation,
TupleConstr *constr,
int ndef,
AttrDefault *attrdef)
Implement reindex command
2000-02-18 09:30:20 +00:00
{
if (constr->has_not_null || ndef > 0 || relation->rd_rel->relchecks)
{
relation->rd_att->constr = constr;
if (ndef > 0) /* DEFAULTs */
{
if (ndef < relation->rd_rel->relnatts)
constr->defval = (AttrDefault *)
repalloc(attrdef, ndef * sizeof(AttrDefault));
else
constr->defval = attrdef;
constr->num_defval = ndef;
AttrDefaultFetch(relation);
}
else
constr->num_defval = 0;
if (relation->rd_rel->relchecks > 0) /* CHECKs */
{
constr->num_check = relation->rd_rel->relchecks;
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
constr->check = (ConstrCheck *)
MemoryContextAlloc(CacheMemoryContext,
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
constr->num_check * sizeof(ConstrCheck));
Implement reindex command
2000-02-18 09:30:20 +00:00
MemSet(constr->check, 0, constr->num_check * sizeof(ConstrCheck));
RelCheckFetch(relation);
}
else
constr->num_check = 0;
}
else
{
pfree(constr);
relation->rd_att->constr = NULL;
}
}
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
static void
build_tupdesc_seq(RelationBuildDescInfo buildinfo,
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
Relation relation)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
HeapTuple pg_attribute_tuple;
Relation pg_attribute_desc;
HeapScanDesc pg_attribute_scan;
Renaming cleanup, no pgindent yet.
1998-09-01 03:29:17 +00:00
Form_pg_attribute attp;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
ScanKeyData key;
int need;
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
TupleConstr *constr;
Implement reindex command
2000-02-18 09:30:20 +00:00
AttrDefault *attrdef = NULL;
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
int ndef = 0;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
constr = (TupleConstr *) MemoryContextAlloc(CacheMemoryContext,
sizeof(TupleConstr));
Implement reindex command
2000-02-18 09:30:20 +00:00
constr->has_not_null = false;
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* form a scan key
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
ScanKeyEntryInitialize(&key, 0,
Anum_pg_attribute_attrelid,
This patch... 1. Removes the unnecessary "#define AbcRegProcedure 123"'s from pg_proc.h. 2. Changes those #defines to use the names already defined in fmgr.h. 3. Forces the make of fmgr.h in backend/Makefile instead of having it made as a dependency in access/common/Makefile *hack*hack*hack* 4. Rearranged the #includes to a less helter-skelter arrangement, also changing <file.h> to "file.h" to signify a non-system header. 5. Removed "pg_proc.h" from files where its only purpose was for the #defines removed in item #1. 6. Added "fmgr.h" to each file changed for completeness sake. Turns out that #6 was not necessary for some files because fmgr.h was being included in a roundabout way SIX levels deep by the first include. "access/genam.h" ->"access/relscan.h" ->"utils/rel.h" ->"access/strat.h" ->"access/skey.h" ->"fmgr.h" So adding fmgr.h really didn't add anything to the compile, hopefully just made it clearer to the programmer. S Darren.
1998-04-27 04:08:07 +00:00
F_OIDEQ,
heap_fetch requires buffer pointer, must be released; heap_getnext no longer returns buffer pointer, can be gotten from scan; descriptor; bootstrap can create multi-key indexes; pg_procname index now is multi-key index; oidint2, oidint4, oidname are gone (must be removed from regression tests); use System Cache rather than sequential scan in many places; heap_modifytuple no longer takes buffer parameter; remove unused buffer parameter in a few other functions; oid8 is not index-able; remove some use of single-character variable names; cleanup Buffer variables usage and scan descriptor looping; cleaned up allocation and freeing of tuples; 18k lines of diff;
1998-08-19 02:04:17 +00:00
ObjectIdGetDatum(RelationGetRelid(relation)));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* open pg_attribute and begin a scan
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
pg_attribute_desc = heap_openr(AttributeRelationName, AccessShareLock);
heap_fetch requires buffer pointer, must be released; heap_getnext no longer returns buffer pointer, can be gotten from scan; descriptor; bootstrap can create multi-key indexes; pg_procname index now is multi-key index; oidint2, oidint4, oidname are gone (must be removed from regression tests); use System Cache rather than sequential scan in many places; heap_modifytuple no longer takes buffer parameter; remove unused buffer parameter in a few other functions; oid8 is not index-able; remove some use of single-character variable names; cleanup Buffer variables usage and scan descriptor looping; cleaned up allocation and freeing of tuples; 18k lines of diff;
1998-08-19 02:04:17 +00:00
pg_attribute_scan = heap_beginscan(pg_attribute_desc, 0, SnapshotNow, 1, &key);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* add attribute data to relation->rd_att
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
need = relation->rd_rel->relnatts;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
heap_fetch requires buffer pointer, must be released; heap_getnext no longer returns buffer pointer, can be gotten from scan; descriptor; bootstrap can create multi-key indexes; pg_procname index now is multi-key index; oidint2, oidint4, oidname are gone (must be removed from regression tests); use System Cache rather than sequential scan in many places; heap_modifytuple no longer takes buffer parameter; remove unused buffer parameter in a few other functions; oid8 is not index-able; remove some use of single-character variable names; cleanup Buffer variables usage and scan descriptor looping; cleaned up allocation and freeing of tuples; 18k lines of diff;
1998-08-19 02:04:17 +00:00
pg_attribute_tuple = heap_getnext(pg_attribute_scan, 0);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
while (HeapTupleIsValid(pg_attribute_tuple) && need > 0)
{
Renaming cleanup, no pgindent yet.
1998-09-01 03:29:17 +00:00
attp = (Form_pg_attribute) GETSTRUCT(pg_attribute_tuple);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
if (attp->attnum > 0)
{
relation->rd_att->attrs[attp->attnum - 1] =
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
(Form_pg_attribute) MemoryContextAlloc(CacheMemoryContext,
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
ATTRIBUTE_TUPLE_SIZE);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Repair memory leaks that caused CacheCxt to grow without bound. We really ought to fix relcache entry construction so that it does not do so much with CurrentMemoryContext = CacheCxt. As is, relatively harmless leaks in either sequential or index scanning translate to permanent leaks if they occur when called from relcache build. For the moment, however, the path of least resistance is to repair all such leaks...
2000-05-21 02:28:55 +00:00
memcpy((char *) (relation->rd_att->attrs[attp->attnum - 1]),
(char *) attp,
ATTRIBUTE_TUPLE_SIZE);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
need--;
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
Implement reindex command
2000-02-18 09:30:20 +00:00
/* Update if this attribute have a constraint */
if (attp->attnotnull)
constr->has_not_null = true;
if (attp->atthasdef)
{
if (attrdef == NULL)
{
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
attrdef = (AttrDefault *)
MemoryContextAlloc(CacheMemoryContext,
relation->rd_rel->relnatts *
sizeof(AttrDefault));
Implement reindex command
2000-02-18 09:30:20 +00:00
MemSet(attrdef, 0,
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
relation->rd_rel->relnatts * sizeof(AttrDefault));
Implement reindex command
2000-02-18 09:30:20 +00:00
}
attrdef[ndef].adnum = attp->attnum;
attrdef[ndef].adbin = NULL;
ndef++;
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
}
heap_fetch requires buffer pointer, must be released; heap_getnext no longer returns buffer pointer, can be gotten from scan; descriptor; bootstrap can create multi-key indexes; pg_procname index now is multi-key index; oidint2, oidint4, oidname are gone (must be removed from regression tests); use System Cache rather than sequential scan in many places; heap_modifytuple no longer takes buffer parameter; remove unused buffer parameter in a few other functions; oid8 is not index-able; remove some use of single-character variable names; cleanup Buffer variables usage and scan descriptor looping; cleaned up allocation and freeing of tuples; 18k lines of diff;
1998-08-19 02:04:17 +00:00
pg_attribute_tuple = heap_getnext(pg_attribute_scan, 0);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
if (need > 0)
Change error messages to oids come out as %u and not %d. Change has no real affect now.
1999-05-10 00:46:32 +00:00
elog(ERROR, "catalog is missing %d attribute%s for relid %u",
heap_fetch requires buffer pointer, must be released; heap_getnext no longer returns buffer pointer, can be gotten from scan; descriptor; bootstrap can create multi-key indexes; pg_procname index now is multi-key index; oidint2, oidint4, oidname are gone (must be removed from regression tests); use System Cache rather than sequential scan in many places; heap_modifytuple no longer takes buffer parameter; remove unused buffer parameter in a few other functions; oid8 is not index-able; remove some use of single-character variable names; cleanup Buffer variables usage and scan descriptor looping; cleaned up allocation and freeing of tuples; 18k lines of diff;
1998-08-19 02:04:17 +00:00
need, (need == 1 ? "" : "s"), RelationGetRelid(relation));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* end the scan and close the attribute relation
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
heap_endscan(pg_attribute_scan);
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
heap_close(pg_attribute_desc, AccessShareLock);
Implement reindex command
2000-02-18 09:30:20 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* The attcacheoff values we read from pg_attribute should all be -1
* ("unknown"). Verify this if assert checking is on. They will be
* computed when and if needed during tuple access.
Remove VARLENA_FIXED_SIZE hack, which is irreversibly broken now that both MULTIBYTE and TOAST prevent char(n) from being truly fixed-size. Simplify and speed up fastgetattr() and index_getattr() macros by eliminating special cases for attnum=1. It's just as fast to handle the first attribute by presetting its attcacheoff to zero; so do that instead when loading the tupledesc in relcache.c.
2000-11-30 18:38:47 +00:00
*/
#ifdef USE_ASSERT_CHECKING
{
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
int i;
Remove VARLENA_FIXED_SIZE hack, which is irreversibly broken now that both MULTIBYTE and TOAST prevent char(n) from being truly fixed-size. Simplify and speed up fastgetattr() and index_getattr() macros by eliminating special cases for attnum=1. It's just as fast to handle the first attribute by presetting its attcacheoff to zero; so do that instead when loading the tupledesc in relcache.c.
2000-11-30 18:38:47 +00:00
for (i = 0; i < relation->rd_rel->relnatts; i++)
Assert(relation->rd_att->attrs[i]->attcacheoff == -1);
}
#endif
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* However, we can easily set the attcacheoff value for the first
* attribute: it must be zero. This eliminates the need for special
* cases for attnum=1 that used to exist in fastgetattr() and
* index_getattr().
Remove VARLENA_FIXED_SIZE hack, which is irreversibly broken now that both MULTIBYTE and TOAST prevent char(n) from being truly fixed-size. Simplify and speed up fastgetattr() and index_getattr() macros by eliminating special cases for attnum=1. It's just as fast to handle the first attribute by presetting its attcacheoff to zero; so do that instead when loading the tupledesc in relcache.c.
2000-11-30 18:38:47 +00:00
*/
relation->rd_att->attrs[0]->attcacheoff = 0;
Implement reindex command
2000-02-18 09:30:20 +00:00
SetConstrOfRelation(relation, constr, ndef, attrdef);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
static void
build_tupdesc_ind(RelationBuildDescInfo buildinfo,
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
Relation relation)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
Relation attrel;
HeapTuple atttup;
Renaming cleanup, no pgindent yet.
1998-09-01 03:29:17 +00:00
Form_pg_attribute attp;
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
TupleConstr *constr;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
AttrDefault *attrdef = NULL;
int ndef = 0;
int i;
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
constr = (TupleConstr *) MemoryContextAlloc(CacheMemoryContext,
sizeof(TupleConstr));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
constr->has_not_null = false;
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
attrel = heap_openr(AttributeRelationName, AccessShareLock);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
for (i = 1; i <= relation->rd_rel->relnatts; i++)
Read info for DEFAULT from pg_attrdef.
1997-08-21 01:36:09 +00:00
{
Trial implementation of ALTER DROP COLUMN. They are #ifdef'd. Add -D_DROP_COLUMN_HACK__ compile option to evaluate it.
2000-03-09 05:00:26 +00:00
#ifdef _DROP_COLUMN_HACK__
Repair memory leaks that caused CacheCxt to grow without bound. We really ought to fix relcache entry construction so that it does not do so much with CurrentMemoryContext = CacheCxt. As is, relatively harmless leaks in either sequential or index scanning translate to permanent leaks if they occur when called from relcache build. For the moment, however, the path of least resistance is to repair all such leaks...
2000-05-21 02:28:55 +00:00
bool columnDropped = false;
New pgindent run with fixes suggested by Tom. Patch manually reviewed, initdb/regression tests pass.
2001-11-05 17:46:40 +00:00
#endif /* _DROP_COLUMN_HACK__ */
Repair memory leaks that caused CacheCxt to grow without bound. We really ought to fix relcache entry construction so that it does not do so much with CurrentMemoryContext = CacheCxt. As is, relatively harmless leaks in either sequential or index scanning translate to permanent leaks if they occur when called from relcache build. For the moment, however, the path of least resistance is to repair all such leaks...
2000-05-21 02:28:55 +00:00
Clean out another pocket of functions called via nonspecific function pointers, namely the catcache tuple fetch routines. Also get rid of the unused and possibly confusing 'size' field in struct cachedesc. Since it doesn't allow for variable-length fields, anyone who actually trusted it would likely be making a mistake...
2000-06-17 04:56:39 +00:00
atttup = AttributeRelidNumIndexScan(attrel,
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
ObjectIdGetDatum(RelationGetRelid(relation)),
Clean out another pocket of functions called via nonspecific function pointers, namely the catcache tuple fetch routines. Also get rid of the unused and possibly confusing 'size' field in struct cachedesc. Since it doesn't allow for variable-length fields, anyone who actually trusted it would likely be making a mistake...
2000-06-17 04:56:39 +00:00
Int32GetDatum(i));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
if (!HeapTupleIsValid(atttup))
Trial implementation of ALTER DROP COLUMN. They are #ifdef'd. Add -D_DROP_COLUMN_HACK__ compile option to evaluate it.
2000-03-09 05:00:26 +00:00
{
Repair memory leaks that caused CacheCxt to grow without bound. We really ought to fix relcache entry construction so that it does not do so much with CurrentMemoryContext = CacheCxt. As is, relatively harmless leaks in either sequential or index scanning translate to permanent leaks if they occur when called from relcache build. For the moment, however, the path of least resistance is to repair all such leaks...
2000-05-21 02:28:55 +00:00
#ifdef _DROP_COLUMN_HACK__
Clean out another pocket of functions called via nonspecific function pointers, namely the catcache tuple fetch routines. Also get rid of the unused and possibly confusing 'size' field in struct cachedesc. Since it doesn't allow for variable-length fields, anyone who actually trusted it would likely be making a mistake...
2000-06-17 04:56:39 +00:00
atttup = AttributeRelidNumIndexScan(attrel,
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
ObjectIdGetDatum(RelationGetRelid(relation)),
Int32GetDatum(DROPPED_COLUMN_INDEX(i)));
Trial implementation of ALTER DROP COLUMN. They are #ifdef'd. Add -D_DROP_COLUMN_HACK__ compile option to evaluate it.
2000-03-09 05:00:26 +00:00
if (!HeapTupleIsValid(atttup))
New pgindent run with fixes suggested by Tom. Patch manually reviewed, initdb/regression tests pass.
2001-11-05 17:46:40 +00:00
#endif /* _DROP_COLUMN_HACK__ */
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
elog(ERROR, "cannot find attribute %d of relation %s", i,
RelationGetRelationName(relation));
Trial implementation of ALTER DROP COLUMN. They are #ifdef'd. Add -D_DROP_COLUMN_HACK__ compile option to evaluate it.
2000-03-09 05:00:26 +00:00
#ifdef _DROP_COLUMN_HACK__
columnDropped = true;
New pgindent run with fixes suggested by Tom. Patch manually reviewed, initdb/regression tests pass.
2001-11-05 17:46:40 +00:00
#endif /* _DROP_COLUMN_HACK__ */
Repair memory leaks that caused CacheCxt to grow without bound. We really ought to fix relcache entry construction so that it does not do so much with CurrentMemoryContext = CacheCxt. As is, relatively harmless leaks in either sequential or index scanning translate to permanent leaks if they occur when called from relcache build. For the moment, however, the path of least resistance is to repair all such leaks...
2000-05-21 02:28:55 +00:00
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Repair memory leaks that caused CacheCxt to grow without bound. We really ought to fix relcache entry construction so that it does not do so much with CurrentMemoryContext = CacheCxt. As is, relatively harmless leaks in either sequential or index scanning translate to permanent leaks if they occur when called from relcache build. For the moment, however, the path of least resistance is to repair all such leaks...
2000-05-21 02:28:55 +00:00
relation->rd_att->attrs[i - 1] = attp =
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
(Form_pg_attribute) MemoryContextAlloc(CacheMemoryContext,
ATTRIBUTE_TUPLE_SIZE);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Repair memory leaks that caused CacheCxt to grow without bound. We really ought to fix relcache entry construction so that it does not do so much with CurrentMemoryContext = CacheCxt. As is, relatively harmless leaks in either sequential or index scanning translate to permanent leaks if they occur when called from relcache build. For the moment, however, the path of least resistance is to repair all such leaks...
2000-05-21 02:28:55 +00:00
memcpy((char *) attp,
(char *) (Form_pg_attribute) GETSTRUCT(atttup),
ATTRIBUTE_TUPLE_SIZE);
/* don't forget to free the tuple returned from xxxIndexScan */
heap_freetuple(atttup);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Trial implementation of ALTER DROP COLUMN. They are #ifdef'd. Add -D_DROP_COLUMN_HACK__ compile option to evaluate it.
2000-03-09 05:00:26 +00:00
#ifdef _DROP_COLUMN_HACK__
if (columnDropped)
continue;
New pgindent run with fixes suggested by Tom. Patch manually reviewed, initdb/regression tests pass.
2001-11-05 17:46:40 +00:00
#endif /* _DROP_COLUMN_HACK__ */
Repair memory leaks that caused CacheCxt to grow without bound. We really ought to fix relcache entry construction so that it does not do so much with CurrentMemoryContext = CacheCxt. As is, relatively harmless leaks in either sequential or index scanning translate to permanent leaks if they occur when called from relcache build. For the moment, however, the path of least resistance is to repair all such leaks...
2000-05-21 02:28:55 +00:00
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
/* Update if this attribute have a constraint */
if (attp->attnotnull)
constr->has_not_null = true;
if (attp->atthasdef)
{
if (attrdef == NULL)
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
{
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
attrdef = (AttrDefault *)
MemoryContextAlloc(CacheMemoryContext,
relation->rd_rel->relnatts *
sizeof(AttrDefault));
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
MemSet(attrdef, 0,
relation->rd_rel->relnatts * sizeof(AttrDefault));
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
attrdef[ndef].adnum = i;
attrdef[ndef].adbin = NULL;
ndef++;
}
Read info for DEFAULT from pg_attrdef.
1997-08-21 01:36:09 +00:00
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
heap_close(attrel, AccessShareLock);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* The attcacheoff values we read from pg_attribute should all be -1
* ("unknown"). Verify this if assert checking is on. They will be
* computed when and if needed during tuple access.
Remove VARLENA_FIXED_SIZE hack, which is irreversibly broken now that both MULTIBYTE and TOAST prevent char(n) from being truly fixed-size. Simplify and speed up fastgetattr() and index_getattr() macros by eliminating special cases for attnum=1. It's just as fast to handle the first attribute by presetting its attcacheoff to zero; so do that instead when loading the tupledesc in relcache.c.
2000-11-30 18:38:47 +00:00
*/
#ifdef USE_ASSERT_CHECKING
for (i = 0; i < relation->rd_rel->relnatts; i++)
Assert(relation->rd_att->attrs[i]->attcacheoff == -1);
#endif
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* However, we can easily set the attcacheoff value for the first
* attribute: it must be zero. This eliminates the need for special
* cases for attnum=1 that used to exist in fastgetattr() and
* index_getattr().
Remove VARLENA_FIXED_SIZE hack, which is irreversibly broken now that both MULTIBYTE and TOAST prevent char(n) from being truly fixed-size. Simplify and speed up fastgetattr() and index_getattr() macros by eliminating special cases for attnum=1. It's just as fast to handle the first attribute by presetting its attcacheoff to zero; so do that instead when loading the tupledesc in relcache.c.
2000-11-30 18:38:47 +00:00
*/
relation->rd_att->attrs[0]->attcacheoff = 0;
Implement reindex command
2000-02-18 09:30:20 +00:00
SetConstrOfRelation(relation, constr, ndef, attrdef);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* RelationBuildRuleLock
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* Form the relation's rewrite rules from information in
* the pg_rewrite system catalog.
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
*
* Note: The rule parsetrees are potentially very complex node structures.
* To allow these trees to be freed when the relcache entry is flushed,
* we make a private memory context to hold the RuleLock information for
* each relcache entry that has associated rules. The context is used
* just for rule info, not for any other subsidiary data of the relcache
* entry, because that keeps the update logic in RelationClearRelation()
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* manageable. The other subsidiary data structures are simple enough
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
* to be easy to free explicitly, anyway.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
static void
RelationBuildRuleLock(Relation relation)
{
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
MemoryContext rulescxt;
MemoryContext oldcxt;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
HeapTuple pg_rewrite_tuple;
Relation pg_rewrite_desc;
TupleDesc pg_rewrite_tupdesc;
HeapScanDesc pg_rewrite_scan;
ScanKeyData key;
RuleLock *rulelock;
int numlocks;
RewriteRule **rules;
int maxlocks;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
/*
* Make the private context. Parameters are set on the assumption
* that it'll probably not contain much data.
*/
rulescxt = AllocSetContextCreate(CacheMemoryContext,
RelationGetRelationName(relation),
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 05:50:21 +00:00
0, /* minsize */
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
1024, /* initsize */
1024); /* maxsize */
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
relation->rd_rulescxt = rulescxt;
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* form an array to hold the rewrite rules (the array is extended if
* necessary)
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
maxlocks = 4;
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
rules = (RewriteRule **)
MemoryContextAlloc(rulescxt, sizeof(RewriteRule *) * maxlocks);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
numlocks = 0;
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* form a scan key
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
ScanKeyEntryInitialize(&key, 0,
Anum_pg_rewrite_ev_class,
This patch... 1. Removes the unnecessary "#define AbcRegProcedure 123"'s from pg_proc.h. 2. Changes those #defines to use the names already defined in fmgr.h. 3. Forces the make of fmgr.h in backend/Makefile instead of having it made as a dependency in access/common/Makefile *hack*hack*hack* 4. Rearranged the #includes to a less helter-skelter arrangement, also changing <file.h> to "file.h" to signify a non-system header. 5. Removed "pg_proc.h" from files where its only purpose was for the #defines removed in item #1. 6. Added "fmgr.h" to each file changed for completeness sake. Turns out that #6 was not necessary for some files because fmgr.h was being included in a roundabout way SIX levels deep by the first include. "access/genam.h" ->"access/relscan.h" ->"utils/rel.h" ->"access/strat.h" ->"access/skey.h" ->"fmgr.h" So adding fmgr.h really didn't add anything to the compile, hopefully just made it clearer to the programmer. S Darren.
1998-04-27 04:08:07 +00:00
F_OIDEQ,
heap_fetch requires buffer pointer, must be released; heap_getnext no longer returns buffer pointer, can be gotten from scan; descriptor; bootstrap can create multi-key indexes; pg_procname index now is multi-key index; oidint2, oidint4, oidname are gone (must be removed from regression tests); use System Cache rather than sequential scan in many places; heap_modifytuple no longer takes buffer parameter; remove unused buffer parameter in a few other functions; oid8 is not index-able; remove some use of single-character variable names; cleanup Buffer variables usage and scan descriptor looping; cleaned up allocation and freeing of tuples; 18k lines of diff;
1998-08-19 02:04:17 +00:00
ObjectIdGetDatum(RelationGetRelid(relation)));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* open pg_rewrite and begin a scan
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
pg_rewrite_desc = heap_openr(RewriteRelationName, AccessShareLock);
heap_fetch requires buffer pointer, must be released; heap_getnext no longer returns buffer pointer, can be gotten from scan; descriptor; bootstrap can create multi-key indexes; pg_procname index now is multi-key index; oidint2, oidint4, oidname are gone (must be removed from regression tests); use System Cache rather than sequential scan in many places; heap_modifytuple no longer takes buffer parameter; remove unused buffer parameter in a few other functions; oid8 is not index-able; remove some use of single-character variable names; cleanup Buffer variables usage and scan descriptor looping; cleaned up allocation and freeing of tuples; 18k lines of diff;
1998-08-19 02:04:17 +00:00
pg_rewrite_scan = heap_beginscan(pg_rewrite_desc, 0, SnapshotNow, 1, &key);
Renaming cleanup, no pgindent yet.
1998-09-01 03:29:17 +00:00
pg_rewrite_tupdesc = RelationGetDescr(pg_rewrite_desc);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
OK, folks, here is the pgindent output.
1998-09-01 04:40:42 +00:00
while (HeapTupleIsValid(pg_rewrite_tuple = heap_getnext(pg_rewrite_scan, 0)))
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
bool isnull;
RelationBuildRuleLock(): char* --> Datum for ruleaction and rule_evqual_string.
1997-09-12 06:57:04 +00:00
Datum ruleaction;
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
Datum rule_evqual;
char *ruleaction_str;
char *rule_evqual_str;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
RewriteRule *rule;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
rule = (RewriteRule *) MemoryContextAlloc(rulescxt,
sizeof(RewriteRule));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
New HeapTuple structure/interface.
1998-11-27 19:52:36 +00:00
rule->ruleId = pg_rewrite_tuple->t_data->t_oid;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
rule->event = DatumGetInt32(heap_getattr(pg_rewrite_tuple,
Anum_pg_rewrite_ev_type,
pg_rewrite_tupdesc,
&isnull)) - 48;
rule->attrno = DatumGetInt16(heap_getattr(pg_rewrite_tuple,
Anum_pg_rewrite_ev_attr,
pg_rewrite_tupdesc,
&isnull));
rule->isInstead = DatumGetBool(heap_getattr(pg_rewrite_tuple,
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
Anum_pg_rewrite_is_instead,
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
pg_rewrite_tupdesc,
&isnull));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Cleanup of source files where 'return' or 'var =' is alone on a line.
1999-02-03 21:18:02 +00:00
ruleaction = heap_getattr(pg_rewrite_tuple,
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
Anum_pg_rewrite_ev_action,
pg_rewrite_tupdesc,
pgindent run over code.
1999-05-25 16:15:34 +00:00
&isnull);
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
Assert(!isnull);
Type lztext is toast. (Sorry, couldn't help it...) Removed type filename as well, since it's unused and probably useless. INITDB FORCED, because pg_rewrite columns are now plain text again.
2000-07-30 22:14:09 +00:00
ruleaction_str = DatumGetCString(DirectFunctionCall1(textout,
ruleaction));
Fix memory leak in relcache handling of rules: allocate rule parsetrees in per-entry sub-memory-context, where they were supposed to go, rather than in CacheMemoryContext where the code was putting them. Must've suffered a severe brain fade when I wrote this :-(
2001-01-06 21:53:18 +00:00
oldcxt = MemoryContextSwitchTo(rulescxt);
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
rule->actions = (List *) stringToNode(ruleaction_str);
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
MemoryContextSwitchTo(oldcxt);
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
pfree(ruleaction_str);
rule_evqual = heap_getattr(pg_rewrite_tuple,
Anum_pg_rewrite_ev_qual,
pg_rewrite_tupdesc,
&isnull);
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
Assert(!isnull);
Type lztext is toast. (Sorry, couldn't help it...) Removed type filename as well, since it's unused and probably useless. INITDB FORCED, because pg_rewrite columns are now plain text again.
2000-07-30 22:14:09 +00:00
rule_evqual_str = DatumGetCString(DirectFunctionCall1(textout,
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
rule_evqual));
Fix memory leak in relcache handling of rules: allocate rule parsetrees in per-entry sub-memory-context, where they were supposed to go, rather than in CacheMemoryContext where the code was putting them. Must've suffered a severe brain fade when I wrote this :-(
2001-01-06 21:53:18 +00:00
oldcxt = MemoryContextSwitchTo(rulescxt);
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
rule->qual = (Node *) stringToNode(rule_evqual_str);
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
MemoryContextSwitchTo(oldcxt);
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
pfree(rule_evqual_str);
if (numlocks >= maxlocks)
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
{
maxlocks *= 2;
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
rules = (RewriteRule **)
repalloc(rules, sizeof(RewriteRule *) * maxlocks);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
}
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
rules[numlocks++] = rule;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* end the scan and close the attribute relation
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
heap_endscan(pg_rewrite_scan);
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
heap_close(pg_rewrite_desc, AccessShareLock);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* form a RuleLock and insert into relation
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
rulelock = (RuleLock *) MemoryContextAlloc(rulescxt, sizeof(RuleLock));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
rulelock->numLocks = numlocks;
rulelock->rules = rules;
relation->rd_rules = rulelock;
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
}
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
* equalRuleLocks
*
* Determine whether two RuleLocks are equivalent
*
* Probably this should be in the rules code someplace...
*/
static bool
equalRuleLocks(RuleLock *rlock1, RuleLock *rlock2)
{
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
int i,
j;
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
if (rlock1 != NULL)
{
if (rlock2 == NULL)
return false;
if (rlock1->numLocks != rlock2->numLocks)
return false;
for (i = 0; i < rlock1->numLocks; i++)
{
RewriteRule *rule1 = rlock1->rules[i];
RewriteRule *rule2 = NULL;
/*
* We can't assume that the rules are always read from
* pg_rewrite in the same order; so use the rule OIDs to
* identify the rules to compare. (We assume here that the
* same OID won't appear twice in either ruleset.)
*/
for (j = 0; j < rlock2->numLocks; j++)
{
rule2 = rlock2->rules[j];
if (rule1->ruleId == rule2->ruleId)
break;
}
if (j >= rlock2->numLocks)
return false;
if (rule1->event != rule2->event)
return false;
if (rule1->attrno != rule2->attrno)
return false;
if (rule1->isInstead != rule2->isInstead)
return false;
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
if (!equal(rule1->qual, rule2->qual))
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
return false;
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
if (!equal(rule1->actions, rule2->actions))
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
return false;
}
}
else if (rlock2 != NULL)
return false;
return true;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/* ----------------------------------
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* RelationBuildDesc
*
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
* Build a relation descriptor --- either a new one, or by
* recycling the given old relation object. The latter case
* supports rebuilding a relcache entry without invalidating
* pointers to it.
*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* To build a relation descriptor, we have to allocate space,
* open the underlying unix file and initialize the following
* fields:
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* File rd_fd; open file descriptor
Install infrastructure for shared-memory free space map. Doesn't actually do anything yet, but it has the necessary connections to initialization and so forth. Make some gestures towards allowing number of blocks in a relation to be BlockNumber, ie, unsigned int, rather than signed int. (I doubt I got all the places that are sloppy about it, yet.) On the way, replace the hardwired NLOCKS_PER_XACT fudge factor with a GUC variable.
2001-06-27 23:31:40 +00:00
* BlockNumber rd_nblocks; number of blocks in rel
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* it will be set in ambeginscan()
Install infrastructure for shared-memory free space map. Doesn't actually do anything yet, but it has the necessary connections to initialization and so forth. Make some gestures towards allowing number of blocks in a relation to be BlockNumber, ie, unsigned int, rather than signed int. (I doubt I got all the places that are sloppy about it, yet.) On the way, replace the hardwired NLOCKS_PER_XACT fudge factor with a GUC variable.
2001-06-27 23:31:40 +00:00
* int rd_refcnt; reference count
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* Form_pg_am rd_am; AM tuple
* Form_pg_class rd_rel; RELATION tuple
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
* Oid rd_id; relation's object id
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
* LockInfoData rd_lockInfo; lock manager's info
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
* TupleDesc rd_att; tuple descriptor
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* Note: rd_ismem (rel is in-memory only) is currently unused
* by any part of the system. someday this will indicate that
* the relation lives only in the main-memory buffer pool
* -cim 2/4/91
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
* --------------------------------
*/
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
static Relation
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
RelationBuildDesc(RelationBuildDescInfo buildinfo,
Relation oldrelation)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
Relation relation;
Oid relid;
Oid relam;
Repair bugs discussed in pghackers thread of 15 May 1999: creation of a relcache entry no longer leaks a small amount of memory. index_endscan now releases all the memory acquired by index_beginscan, so callers of it should NOT pfree the scan descriptor anymore.
1999-12-30 05:05:13 +00:00
HeapTuple pg_class_tuple;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
Form_pg_class relp;
MemoryContext oldcxt;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* find the tuple in pg_class corresponding to the given relation id
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
pg_class_tuple = ScanPgRelation(buildinfo);
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* if no such tuple exists, return NULL
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
if (!HeapTupleIsValid(pg_class_tuple))
return NULL;
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* get information from the pg_class_tuple
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
New HeapTuple structure/interface.
1998-11-27 19:52:36 +00:00
relid = pg_class_tuple->t_data->t_oid;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
relp = (Form_pg_class) GETSTRUCT(pg_class_tuple);
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* allocate storage for the relation descriptor, and copy
* pg_class_tuple to relation->rd_rel.
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
relation = AllocateRelationDesc(oldrelation, relp);
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* now we can free the memory allocated for pg_class_tuple
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
*/
heap_freetuple(pg_class_tuple);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* initialize the relation's relation id (relation->rd_id)
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
heap_fetch requires buffer pointer, must be released; heap_getnext no longer returns buffer pointer, can be gotten from scan; descriptor; bootstrap can create multi-key indexes; pg_procname index now is multi-key index; oidint2, oidint4, oidname are gone (must be removed from regression tests); use System Cache rather than sequential scan in many places; heap_modifytuple no longer takes buffer parameter; remove unused buffer parameter in a few other functions; oid8 is not index-able; remove some use of single-character variable names; cleanup Buffer variables usage and scan descriptor looping; cleaned up allocation and freeing of tuples; 18k lines of diff;
1998-08-19 02:04:17 +00:00
RelationGetRelid(relation) = relid;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* initialize relation->rd_refcnt
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
RelationSetReferenceCount(relation, 1);
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* normal relations are not nailed into the cache
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
relation->rd_isnailed = false;
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* initialize the access method information (relation->rd_am)
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
relam = relation->rd_rel->relam;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
if (OidIsValid(relam))
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
relation->rd_am = AccessMethodObjectIdGetForm(relam,
CacheMemoryContext);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* initialize the tuple descriptor (relation->rd_att).
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
RelationBuildTupleDesc(buildinfo, relation);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* Fetch rules and triggers that affect this relation
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
if (relation->rd_rel->relhasrules)
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
RelationBuildRuleLock(relation);
else
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
{
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
relation->rd_rules = NULL;
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
relation->rd_rulescxt = NULL;
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
if (relation->rd_rel->reltriggers > 0)
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
RelationBuildTriggers(relation);
else
relation->trigdesc = NULL;
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* initialize index strategy and support information for this relation
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
if (OidIsValid(relam))
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
RelationInitIndexAccessInfo(relation);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* initialize the relation lock manager information
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
RelationInitLockInfo(relation); /* see lmgr.c */
Clean up various to-do items associated with system indexes: pg_database now has unique indexes on oid and on datname. pg_shadow now has unique indexes on usename and on usesysid. pg_am now has unique index on oid. pg_opclass now has unique index on oid. pg_amproc now has unique index on amid+amopclaid+amprocnum. Remove pg_rewrite's unnecessary index on oid, delete unused RULEOID syscache. Remove index on pg_listener and associated syscache for performance reasons (caching rows that are certain to change before you need 'em again is rather pointless). Change pg_attrdef's nonunique index on adrelid into a unique index on adrelid+adnum. Fix various incorrect settings of pg_class.relisshared, make that the primary reference point for whether a relation is shared or not. IsSharedSystemRelationName() is now only consulted to initialize relisshared during initial creation of tables and indexes. In theory we might now support shared user relations, though it's not clear how one would get entries for them into pg_class &etc of multiple databases. Fix recently reported bug that pg_attribute rows created for an index all have the same OID. (Proof that non-unique OID doesn't matter unless it's actually used to do lookups ;-)) There's no need to treat pg_trigger, pg_attrdef, pg_relcheck as bootstrap relations. Convert them into plain system catalogs without hardwired entries in pg_class and friends. Unify global.bki and template1.bki into a single init script postgres.bki, since the alleged distinction between them was misleading and pointless. Not to mention that it didn't work for setting up indexes on shared system relations. Rationalize locking of pg_shadow, pg_group, pg_attrdef (no need to use AccessExclusiveLock where ExclusiveLock or even RowExclusiveLock will do). Also, hold locks until transaction commit where necessary.
2001-06-12 05:55:50 +00:00
if (relation->rd_rel->relisshared)
New file naming. Database OID is used as "tablespace" id and relation OID is used as file node on creation but may be changed later if required. Regression Tests Approved (c) -:)))
2000-10-16 14:52:28 +00:00
relation->rd_node.tblNode = InvalidOid;
else
relation->rd_node.tblNode = MyDatabaseId;
relation->rd_node.relNode = relation->rd_rel->relfilenode;
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Restore pre-7.1 behavior of allowing DROP of a table whose underlying physical file has disappeared. There is no really good reason why relcache should be opening the underlying file at all, AFAICS. In any case we needn't raise a hard error here.
2001-04-02 23:30:04 +00:00
* Open the relation and assign the file descriptor returned by the
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* storage manager code to rd_fd.
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
*
Restore pre-7.1 behavior of allowing DROP of a table whose underlying physical file has disappeared. There is no really good reason why relcache should be opening the underlying file at all, AFAICS. In any case we needn't raise a hard error here.
2001-04-02 23:30:04 +00:00
* We do not raise a hard error if we fail to open the relation at this
* point. If we did, it would be impossible to drop a relation whose
* underlying physical file had disappeared.
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Make DROP TABLE rollback-able: postpone physical file delete until commit. (WAL logging for this is not done yet, however.) Clean up a number of really crufty things that are no longer needed now that DROP behaves nicely. Make temp table mapper do the right things when drop or rename affecting a temp table is rolled back. Also, remove "relation modified while in use" error check, in favor of locking tables at first reference and holding that lock throughout the statement.
2000-11-08 22:10:03 +00:00
if (relation->rd_rel->relkind != RELKIND_VIEW)
Restore pre-7.1 behavior of allowing DROP of a table whose underlying physical file has disappeared. There is no really good reason why relcache should be opening the underlying file at all, AFAICS. In any case we needn't raise a hard error here.
2001-04-02 23:30:04 +00:00
{
relation->rd_fd = smgropen(DEFAULT_SMGR, relation, true);
Assert(relation->rd_fd >= -1);
if (relation->rd_fd == -1)
elog(NOTICE, "RelationBuildDesc: can't open %s: %m",
RelationGetRelationName(relation));
}
Make DROP TABLE rollback-able: postpone physical file delete until commit. (WAL logging for this is not done yet, however.) Clean up a number of really crufty things that are no longer needed now that DROP behaves nicely. Make temp table mapper do the right things when drop or rename affecting a temp table is rolled back. Also, remove "relation modified while in use" error check, in favor of locking tables at first reference and holding that lock throughout the statement.
2000-11-08 22:10:03 +00:00
else
This patch implements a different "relkind" for views. Views are now have a "relkind" of RELKIND_VIEW instead of RELKIND_RELATION. Also, views no longer have actual heap storage files. The following changes were made 1. CREATE VIEW sets the new relkind 2. The executor complains if a DELETE or INSERT references a view. 3. DROP RULE complains if an attempt is made to delete a view SELECT rule. 4. CREATE RULE "_RETmytable" AS ON SELECT TO mytable DO INSTEAD ... 1. checks to make sure mytable is empty. 2. sets the relkind to RELKIND_VIEW. 3. deletes the heap storage files. 5. LOCK myview is not allowed. :) 6. the regression test type_sanity was changed to account for the new relkind value. 7. CREATE INDEX ON myview ... is not allowed. 8. VACUUM myview is not allowed. VACUUM automatically skips views when do the entire database. 9. TRUNCATE myview is not allowed. THINGS LEFT TO THINK ABOUT o pg_views o pg_dump o pgsql (\d \dv) o Do we really want to be able to inherit from views? o Is 'DROP TABLE myview' OK? -- Mark Hollomon
2000-09-12 04:49:17 +00:00
relation->rd_fd = -1;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* insert newly created relation into proper relcaches, restore memory
* context and return the new reldesc.
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
RelationCacheInsert(relation);
Repair bugs discussed in pghackers thread of 15 May 1999: creation of a relcache entry no longer leaks a small amount of memory. index_endscan now releases all the memory acquired by index_beginscan, so callers of it should NOT pfree the scan descriptor anymore.
1999-12-30 05:05:13 +00:00
MemoryContextSwitchTo(oldcxt);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
return relation;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
/*
* Initialize index-access-method support data for an index relation
*/
void
RelationInitIndexAccessInfo(Relation relation)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
{
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
MemoryContext indexcxt;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
IndexStrategy strategy;
RegProcedure *support;
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
FmgrInfo *supportinfo;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
int natts;
Clean up some minor problems exposed by further thought about Panon's bug report on old-style functions invoked by RI triggers. We had a number of other places that were being sloppy about which memory context FmgrInfo subsidiary data will be allocated in. Turns out none of them actually cause a problem in 7.1, but this is for arcane reasons such as the fact that old-style triggers aren't supported anyway. To avoid getting burnt later, I've restructured the trigger support so that we don't keep trigger FmgrInfo structs in relcache memory. Some other related cleanups too: it's not really necessary to call fmgr_info at all while setting up the index support info in relcache entries, because those ScanKeyEntry structs are never used to invoke the functions. This should speed up relcache initialization a tiny bit.
2001-06-01 02:41:36 +00:00
uint16 amstrategies;
uint16 amsupport;
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
Size stratSize;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
natts = relation->rd_rel->relnatts;
Clean up some minor problems exposed by further thought about Panon's bug report on old-style functions invoked by RI triggers. We had a number of other places that were being sloppy about which memory context FmgrInfo subsidiary data will be allocated in. Turns out none of them actually cause a problem in 7.1, but this is for arcane reasons such as the fact that old-style triggers aren't supported anyway. To avoid getting burnt later, I've restructured the trigger support so that we don't keep trigger FmgrInfo structs in relcache memory. Some other related cleanups too: it's not really necessary to call fmgr_info at all while setting up the index support info in relcache entries, because those ScanKeyEntry structs are never used to invoke the functions. This should speed up relcache initialization a tiny bit.
2001-06-01 02:41:36 +00:00
amstrategies = relation->rd_am->amstrategies;
amsupport = relation->rd_am->amsupport;
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
/*
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 05:50:21 +00:00
* Make the private context to hold index access info. The reason we
* need a context, and not just a couple of pallocs, is so that we
* won't leak any subsidiary info attached to fmgr lookup records.
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
*
* Context parameters are set on the assumption that it'll probably not
* contain much data.
*/
indexcxt = AllocSetContextCreate(CacheMemoryContext,
RelationGetRelationName(relation),
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 05:50:21 +00:00
0, /* minsize */
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
512, /* initsize */
1024); /* maxsize */
relation->rd_indexcxt = indexcxt;
/*
* Allocate arrays to hold data
*/
Clean up some minor problems exposed by further thought about Panon's bug report on old-style functions invoked by RI triggers. We had a number of other places that were being sloppy about which memory context FmgrInfo subsidiary data will be allocated in. Turns out none of them actually cause a problem in 7.1, but this is for arcane reasons such as the fact that old-style triggers aren't supported anyway. To avoid getting burnt later, I've restructured the trigger support so that we don't keep trigger FmgrInfo structs in relcache memory. Some other related cleanups too: it's not really necessary to call fmgr_info at all while setting up the index support info in relcache entries, because those ScanKeyEntry structs are never used to invoke the functions. This should speed up relcache initialization a tiny bit.
2001-06-01 02:41:36 +00:00
stratSize = AttributeNumberGetIndexStrategySize(natts, amstrategies);
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
strategy = (IndexStrategy) MemoryContextAlloc(indexcxt, stratSize);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Clean up some minor problems exposed by further thought about Panon's bug report on old-style functions invoked by RI triggers. We had a number of other places that were being sloppy about which memory context FmgrInfo subsidiary data will be allocated in. Turns out none of them actually cause a problem in 7.1, but this is for arcane reasons such as the fact that old-style triggers aren't supported anyway. To avoid getting burnt later, I've restructured the trigger support so that we don't keep trigger FmgrInfo structs in relcache memory. Some other related cleanups too: it's not really necessary to call fmgr_info at all while setting up the index support info in relcache entries, because those ScanKeyEntry structs are never used to invoke the functions. This should speed up relcache initialization a tiny bit.
2001-06-01 02:41:36 +00:00
if (amsupport > 0)
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
{
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 05:50:21 +00:00
int nsupport = natts * amsupport;
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
support = (RegProcedure *)
MemoryContextAlloc(indexcxt, nsupport * sizeof(RegProcedure));
supportinfo = (FmgrInfo *)
MemoryContextAlloc(indexcxt, nsupport * sizeof(FmgrInfo));
MemSet(supportinfo, 0, nsupport * sizeof(FmgrInfo));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
}
else
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
{
support = NULL;
supportinfo = NULL;
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
/*
* Fill the strategy map and the support RegProcedure arrays.
* (supportinfo is left as zeroes, and is filled on-the-fly when used)
*/
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
IndexSupportInitialize(strategy, support,
Cleanup of code for creating index entries. Functional indexes with pass-by-ref data types --- eg, an index on lower(textfield) --- no longer leak memory during index creation or update. Clean up a lot of redundant code ... did you know that copy, vacuum, truncate, reindex, extend index, and bootstrap each basically duplicated the main executor's logic for extracting information about an index and preparing index entries? Functional indexes should be a little faster now too, due to removal of repeated function lookups. CREATE INDEX 'opt_type' clause is deimplemented by these changes, but I haven't removed it from the parser yet (need to merge with Thomas' latest change set first).
2000-07-14 22:18:02 +00:00
&relation->rd_uniqueindex,
Clean up some minor problems exposed by further thought about Panon's bug report on old-style functions invoked by RI triggers. We had a number of other places that were being sloppy about which memory context FmgrInfo subsidiary data will be allocated in. Turns out none of them actually cause a problem in 7.1, but this is for arcane reasons such as the fact that old-style triggers aren't supported anyway. To avoid getting burnt later, I've restructured the trigger support so that we don't keep trigger FmgrInfo structs in relcache memory. Some other related cleanups too: it's not really necessary to call fmgr_info at all while setting up the index support info in relcache entries, because those ScanKeyEntry structs are never used to invoke the functions. This should speed up relcache initialization a tiny bit.
2001-06-01 02:41:36 +00:00
RelationGetRelid(relation),
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
relation->rd_rel->relam,
Clean up some minor problems exposed by further thought about Panon's bug report on old-style functions invoked by RI triggers. We had a number of other places that were being sloppy about which memory context FmgrInfo subsidiary data will be allocated in. Turns out none of them actually cause a problem in 7.1, but this is for arcane reasons such as the fact that old-style triggers aren't supported anyway. To avoid getting burnt later, I've restructured the trigger support so that we don't keep trigger FmgrInfo structs in relcache memory. Some other related cleanups too: it's not really necessary to call fmgr_info at all while setting up the index support info in relcache entries, because those ScanKeyEntry structs are never used to invoke the functions. This should speed up relcache initialization a tiny bit.
2001-06-01 02:41:36 +00:00
amstrategies, amsupport, natts);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
relation->rd_istrat = strategy;
relation->rd_support = support;
relation->rd_supportinfo = supportinfo;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* formrdesc
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
* This is a special cut-down version of RelationBuildDesc()
Toast all the system-table columns that seem to need it. It turns out that giving pg_proc a toast table required solving the same problems we'd have to solve for pg_class --- pg_proc is one of the relations that gets bootstrapped in relcache.c. Solution is to go back at the end of initialization and read in the *real* pg_class row to replace the phony entry created by formrdesc(). This should work as long as there's no need to touch any toasted values during initialization, which seems a reasonable assumption. Although I did not add a toast-table for every single system table with a varlena attribute, I believe that it would work to just do ALTER TABLE pg_class CREATE TOAST TABLE. So anyone who's really intent on having several thousand ACL entries for a rel could do it. NOTE: I didn't force initdb, but you must do one to see the effects of this patch.
2000-08-06 04:40:08 +00:00
* used by RelationCacheInitialize() in initializing the relcache.
* The relation descriptor is built just from the supplied parameters,
Clean up syscache so that recursive invocation is safe, and remove error message about recursive use of a syscache. Also remove most of the specialized indexscan routines in indexing.c --- it turns out that catcache.c is perfectly able to perform the indexscan for itself, in fact has already looked up all the information needed to do so! This should be faster as well as needing far less boilerplate code.
2000-11-10 00:33:12 +00:00
* without actually looking at any system table entries. We cheat
* quite a lot since we only need to work for a few basic system
* catalogs...
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
*
* NOTE: we assume we are already switched into CacheMemoryContext.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
static void
formrdesc(char *relationName,
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
int natts,
Renaming cleanup, no pgindent yet.
1998-09-01 03:29:17 +00:00
FormData_pg_attribute *att)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
Relation relation;
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
int i;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* allocate new relation desc
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Fix performance problems with pg_index lookups (see, for example, discussion of 5/19/00). pg_index is now searched for indexes of a relation using an indexscan. Moreover, this is done once and cached in the relcache entry for the relation, in the form of a list of OIDs for the indexes. This list is used by the parser and executor to drive lookups in the pg_index syscache when they want to know the properties of the indexes. Net result: index information will be fully cached for repetitive operations such as inserts.
2000-06-17 21:49:04 +00:00
relation = (Relation) palloc(sizeof(RelationData));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Install infrastructure for shared-memory free space map. Doesn't actually do anything yet, but it has the necessary connections to initialization and so forth. Make some gestures towards allowing number of blocks in a relation to be BlockNumber, ie, unsigned int, rather than signed int. (I doubt I got all the places that are sloppy about it, yet.) On the way, replace the hardwired NLOCKS_PER_XACT fudge factor with a GUC variable.
2001-06-27 23:31:40 +00:00
* clear all fields of reldesc
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Install infrastructure for shared-memory free space map. Doesn't actually do anything yet, but it has the necessary connections to initialization and so forth. Make some gestures towards allowing number of blocks in a relation to be BlockNumber, ie, unsigned int, rather than signed int. (I doubt I got all the places that are sloppy about it, yet.) On the way, replace the hardwired NLOCKS_PER_XACT fudge factor with a GUC variable.
2001-06-27 23:31:40 +00:00
MemSet((char *) relation, 0, sizeof(RelationData));
relation->rd_targblock = InvalidBlockNumber;
/* make sure relation is marked as having no open file yet */
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
relation->rd_fd = -1;
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* initialize reference count
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
RelationSetReferenceCount(relation, 1);
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* all entries built with this routine are nailed-in-cache
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Toast all the system-table columns that seem to need it. It turns out that giving pg_proc a toast table required solving the same problems we'd have to solve for pg_class --- pg_proc is one of the relations that gets bootstrapped in relcache.c. Solution is to go back at the end of initialization and read in the *real* pg_class row to replace the phony entry created by formrdesc(). This should work as long as there's no need to touch any toasted values during initialization, which seems a reasonable assumption. Although I did not add a toast-table for every single system table with a varlena attribute, I believe that it would work to just do ALTER TABLE pg_class CREATE TOAST TABLE. So anyone who's really intent on having several thousand ACL entries for a rel could do it. NOTE: I didn't force initdb, but you must do one to see the effects of this patch.
2000-08-06 04:40:08 +00:00
relation->rd_isnailed = true;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* initialize relation tuple form
Toast all the system-table columns that seem to need it. It turns out that giving pg_proc a toast table required solving the same problems we'd have to solve for pg_class --- pg_proc is one of the relations that gets bootstrapped in relcache.c. Solution is to go back at the end of initialization and read in the *real* pg_class row to replace the phony entry created by formrdesc(). This should work as long as there's no need to touch any toasted values during initialization, which seems a reasonable assumption. Although I did not add a toast-table for every single system table with a varlena attribute, I believe that it would work to just do ALTER TABLE pg_class CREATE TOAST TABLE. So anyone who's really intent on having several thousand ACL entries for a rel could do it. NOTE: I didn't force initdb, but you must do one to see the effects of this patch.
2000-08-06 04:40:08 +00:00
*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* The data we insert here is pretty incomplete/bogus, but it'll serve to
* get us launched. RelationCacheInitializePhase2() will read the
* real data from pg_class and replace what we've done here.
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
*/
Toast all the system-table columns that seem to need it. It turns out that giving pg_proc a toast table required solving the same problems we'd have to solve for pg_class --- pg_proc is one of the relations that gets bootstrapped in relcache.c. Solution is to go back at the end of initialization and read in the *real* pg_class row to replace the phony entry created by formrdesc(). This should work as long as there's no need to touch any toasted values during initialization, which seems a reasonable assumption. Although I did not add a toast-table for every single system table with a varlena attribute, I believe that it would work to just do ALTER TABLE pg_class CREATE TOAST TABLE. So anyone who's really intent on having several thousand ACL entries for a rel could do it. NOTE: I didn't force initdb, but you must do one to see the effects of this patch.
2000-08-06 04:40:08 +00:00
relation->rd_rel = (Form_pg_class) palloc(CLASS_TUPLE_SIZE);
MemSet(relation->rd_rel, 0, CLASS_TUPLE_SIZE);
strcpy(RelationGetPhysicalRelationName(relation), relationName);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
/*
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 05:50:21 +00:00
* It's important to distinguish between shared and non-shared
* relations, even at bootstrap time, to make sure we know where they
* are stored.
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Clean up various to-do items associated with system indexes: pg_database now has unique indexes on oid and on datname. pg_shadow now has unique indexes on usename and on usesysid. pg_am now has unique index on oid. pg_opclass now has unique index on oid. pg_amproc now has unique index on amid+amopclaid+amprocnum. Remove pg_rewrite's unnecessary index on oid, delete unused RULEOID syscache. Remove index on pg_listener and associated syscache for performance reasons (caching rows that are certain to change before you need 'em again is rather pointless). Change pg_attrdef's nonunique index on adrelid into a unique index on adrelid+adnum. Fix various incorrect settings of pg_class.relisshared, make that the primary reference point for whether a relation is shared or not. IsSharedSystemRelationName() is now only consulted to initialize relisshared during initial creation of tables and indexes. In theory we might now support shared user relations, though it's not clear how one would get entries for them into pg_class &etc of multiple databases. Fix recently reported bug that pg_attribute rows created for an index all have the same OID. (Proof that non-unique OID doesn't matter unless it's actually used to do lookups ;-)) There's no need to treat pg_trigger, pg_attrdef, pg_relcheck as bootstrap relations. Convert them into plain system catalogs without hardwired entries in pg_class and friends. Unify global.bki and template1.bki into a single init script postgres.bki, since the alleged distinction between them was misleading and pointless. Not to mention that it didn't work for setting up indexes on shared system relations. Rationalize locking of pg_shadow, pg_group, pg_attrdef (no need to use AccessExclusiveLock where ExclusiveLock or even RowExclusiveLock will do). Also, hold locks until transaction commit where necessary.
2001-06-12 05:55:50 +00:00
relation->rd_rel->relisshared = IsSharedSystemRelationName(relationName);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Toast all the system-table columns that seem to need it. It turns out that giving pg_proc a toast table required solving the same problems we'd have to solve for pg_class --- pg_proc is one of the relations that gets bootstrapped in relcache.c. Solution is to go back at the end of initialization and read in the *real* pg_class row to replace the phony entry created by formrdesc(). This should work as long as there's no need to touch any toasted values during initialization, which seems a reasonable assumption. Although I did not add a toast-table for every single system table with a varlena attribute, I believe that it would work to just do ALTER TABLE pg_class CREATE TOAST TABLE. So anyone who's really intent on having several thousand ACL entries for a rel could do it. NOTE: I didn't force initdb, but you must do one to see the effects of this patch.
2000-08-06 04:40:08 +00:00
relation->rd_rel->relpages = 1;
relation->rd_rel->reltuples = 1;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
relation->rd_rel->relkind = RELKIND_RELATION;
Make OIDs optional, per discussions in pghackers. WITH OIDS is still the default, but OIDS are removed from many system catalogs that don't need them. Some interesting side effects: TOAST pointers are 20 bytes not 32 now; pg_description has a three-column key instead of one. Bugs fixed in passing: BINARY cursors work again; pg_class.relhaspkey has some usefulness; pg_dump dumps comments on indexes, rules, and triggers in a valid order. initdb forced.
2001-08-10 18:57:42 +00:00
relation->rd_rel->relhasoids = true;
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
relation->rd_rel->relnatts = (int16) natts;
Toast all the system-table columns that seem to need it. It turns out that giving pg_proc a toast table required solving the same problems we'd have to solve for pg_class --- pg_proc is one of the relations that gets bootstrapped in relcache.c. Solution is to go back at the end of initialization and read in the *real* pg_class row to replace the phony entry created by formrdesc(). This should work as long as there's no need to touch any toasted values during initialization, which seems a reasonable assumption. Although I did not add a toast-table for every single system table with a varlena attribute, I believe that it would work to just do ALTER TABLE pg_class CREATE TOAST TABLE. So anyone who's really intent on having several thousand ACL entries for a rel could do it. NOTE: I didn't force initdb, but you must do one to see the effects of this patch.
2000-08-06 04:40:08 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* initialize attribute tuple form
Toast all the system-table columns that seem to need it. It turns out that giving pg_proc a toast table required solving the same problems we'd have to solve for pg_class --- pg_proc is one of the relations that gets bootstrapped in relcache.c. Solution is to go back at the end of initialization and read in the *real* pg_class row to replace the phony entry created by formrdesc(). This should work as long as there's no need to touch any toasted values during initialization, which seems a reasonable assumption. Although I did not add a toast-table for every single system table with a varlena attribute, I believe that it would work to just do ALTER TABLE pg_class CREATE TOAST TABLE. So anyone who's really intent on having several thousand ACL entries for a rel could do it. NOTE: I didn't force initdb, but you must do one to see the effects of this patch.
2000-08-06 04:40:08 +00:00
*/
relation->rd_att = CreateTemplateTupleDesc(natts);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* initialize tuple desc info
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
for (i = 0; i < natts; i++)
{
Cleanup of source files where 'return' or 'var =' is alone on a line.
1999-02-03 21:18:02 +00:00
relation->rd_att->attrs[i] = (Form_pg_attribute) palloc(ATTRIBUTE_TUPLE_SIZE);
Repair memory leaks that caused CacheCxt to grow without bound. We really ought to fix relcache entry construction so that it does not do so much with CurrentMemoryContext = CacheCxt. As is, relatively harmless leaks in either sequential or index scanning translate to permanent leaks if they occur when called from relcache build. For the moment, however, the path of least resistance is to repair all such leaks...
2000-05-21 02:28:55 +00:00
memcpy((char *) relation->rd_att->attrs[i],
(char *) &att[i],
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
ATTRIBUTE_TUPLE_SIZE);
}
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Clean up some minor problems exposed by further thought about Panon's bug report on old-style functions invoked by RI triggers. We had a number of other places that were being sloppy about which memory context FmgrInfo subsidiary data will be allocated in. Turns out none of them actually cause a problem in 7.1, but this is for arcane reasons such as the fact that old-style triggers aren't supported anyway. To avoid getting burnt later, I've restructured the trigger support so that we don't keep trigger FmgrInfo structs in relcache memory. Some other related cleanups too: it's not really necessary to call fmgr_info at all while setting up the index support info in relcache entries, because those ScanKeyEntry structs are never used to invoke the functions. This should speed up relcache initialization a tiny bit.
2001-06-01 02:41:36 +00:00
* initialize relation id from info in att array (my, this is ugly)
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
heap_fetch requires buffer pointer, must be released; heap_getnext no longer returns buffer pointer, can be gotten from scan; descriptor; bootstrap can create multi-key indexes; pg_procname index now is multi-key index; oidint2, oidint4, oidname are gone (must be removed from regression tests); use System Cache rather than sequential scan in many places; heap_modifytuple no longer takes buffer parameter; remove unused buffer parameter in a few other functions; oid8 is not index-able; remove some use of single-character variable names; cleanup Buffer variables usage and scan descriptor looping; cleaned up allocation and freeing of tuples; 18k lines of diff;
1998-08-19 02:04:17 +00:00
RelationGetRelid(relation) = relation->rd_att->attrs[0]->attrelid;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* initialize the relation's lock manager and RelFileNode information
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
*/
RelationInitLockInfo(relation); /* see lmgr.c */
Clean up various to-do items associated with system indexes: pg_database now has unique indexes on oid and on datname. pg_shadow now has unique indexes on usename and on usesysid. pg_am now has unique index on oid. pg_opclass now has unique index on oid. pg_amproc now has unique index on amid+amopclaid+amprocnum. Remove pg_rewrite's unnecessary index on oid, delete unused RULEOID syscache. Remove index on pg_listener and associated syscache for performance reasons (caching rows that are certain to change before you need 'em again is rather pointless). Change pg_attrdef's nonunique index on adrelid into a unique index on adrelid+adnum. Fix various incorrect settings of pg_class.relisshared, make that the primary reference point for whether a relation is shared or not. IsSharedSystemRelationName() is now only consulted to initialize relisshared during initial creation of tables and indexes. In theory we might now support shared user relations, though it's not clear how one would get entries for them into pg_class &etc of multiple databases. Fix recently reported bug that pg_attribute rows created for an index all have the same OID. (Proof that non-unique OID doesn't matter unless it's actually used to do lookups ;-)) There's no need to treat pg_trigger, pg_attrdef, pg_relcheck as bootstrap relations. Convert them into plain system catalogs without hardwired entries in pg_class and friends. Unify global.bki and template1.bki into a single init script postgres.bki, since the alleged distinction between them was misleading and pointless. Not to mention that it didn't work for setting up indexes on shared system relations. Rationalize locking of pg_shadow, pg_group, pg_attrdef (no need to use AccessExclusiveLock where ExclusiveLock or even RowExclusiveLock will do). Also, hold locks until transaction commit where necessary.
2001-06-12 05:55:50 +00:00
if (relation->rd_rel->relisshared)
New file naming. Database OID is used as "tablespace" id and relation OID is used as file node on creation but may be changed later if required. Regression Tests Approved (c) -:)))
2000-10-16 14:52:28 +00:00
relation->rd_node.tblNode = InvalidOid;
else
relation->rd_node.tblNode = MyDatabaseId;
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
relation->rd_node.relNode =
New file naming. Database OID is used as "tablespace" id and relation OID is used as file node on creation but may be changed later if required. Regression Tests Approved (c) -:)))
2000-10-16 14:52:28 +00:00
relation->rd_rel->relfilenode = RelationGetRelid(relation);
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* initialize the rel-has-index flag, using hardwired knowledge
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
*/
Clean up syscache so that recursive invocation is safe, and remove error message about recursive use of a syscache. Also remove most of the specialized indexscan routines in indexing.c --- it turns out that catcache.c is perfectly able to perform the indexscan for itself, in fact has already looked up all the information needed to do so! This should be faster as well as needing far less boilerplate code.
2000-11-10 00:33:12 +00:00
relation->rd_rel->relhasindex = false;
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
Clean up syscache so that recursive invocation is safe, and remove error message about recursive use of a syscache. Also remove most of the specialized indexscan routines in indexing.c --- it turns out that catcache.c is perfectly able to perform the indexscan for itself, in fact has already looked up all the information needed to do so! This should be faster as well as needing far less boilerplate code.
2000-11-10 00:33:12 +00:00
/* In bootstrap mode, we have no indexes */
if (!IsBootstrapProcessingMode())
{
Clean up various to-do items associated with system indexes: pg_database now has unique indexes on oid and on datname. pg_shadow now has unique indexes on usename and on usesysid. pg_am now has unique index on oid. pg_opclass now has unique index on oid. pg_amproc now has unique index on amid+amopclaid+amprocnum. Remove pg_rewrite's unnecessary index on oid, delete unused RULEOID syscache. Remove index on pg_listener and associated syscache for performance reasons (caching rows that are certain to change before you need 'em again is rather pointless). Change pg_attrdef's nonunique index on adrelid into a unique index on adrelid+adnum. Fix various incorrect settings of pg_class.relisshared, make that the primary reference point for whether a relation is shared or not. IsSharedSystemRelationName() is now only consulted to initialize relisshared during initial creation of tables and indexes. In theory we might now support shared user relations, though it's not clear how one would get entries for them into pg_class &etc of multiple databases. Fix recently reported bug that pg_attribute rows created for an index all have the same OID. (Proof that non-unique OID doesn't matter unless it's actually used to do lookups ;-)) There's no need to treat pg_trigger, pg_attrdef, pg_relcheck as bootstrap relations. Convert them into plain system catalogs without hardwired entries in pg_class and friends. Unify global.bki and template1.bki into a single init script postgres.bki, since the alleged distinction between them was misleading and pointless. Not to mention that it didn't work for setting up indexes on shared system relations. Rationalize locking of pg_shadow, pg_group, pg_attrdef (no need to use AccessExclusiveLock where ExclusiveLock or even RowExclusiveLock will do). Also, hold locks until transaction commit where necessary.
2001-06-12 05:55:50 +00:00
/*
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 05:50:21 +00:00
* This list is incomplete, but it only has to work for the set of
* rels that formrdesc is used for ...
Clean up various to-do items associated with system indexes: pg_database now has unique indexes on oid and on datname. pg_shadow now has unique indexes on usename and on usesysid. pg_am now has unique index on oid. pg_opclass now has unique index on oid. pg_amproc now has unique index on amid+amopclaid+amprocnum. Remove pg_rewrite's unnecessary index on oid, delete unused RULEOID syscache. Remove index on pg_listener and associated syscache for performance reasons (caching rows that are certain to change before you need 'em again is rather pointless). Change pg_attrdef's nonunique index on adrelid into a unique index on adrelid+adnum. Fix various incorrect settings of pg_class.relisshared, make that the primary reference point for whether a relation is shared or not. IsSharedSystemRelationName() is now only consulted to initialize relisshared during initial creation of tables and indexes. In theory we might now support shared user relations, though it's not clear how one would get entries for them into pg_class &etc of multiple databases. Fix recently reported bug that pg_attribute rows created for an index all have the same OID. (Proof that non-unique OID doesn't matter unless it's actually used to do lookups ;-)) There's no need to treat pg_trigger, pg_attrdef, pg_relcheck as bootstrap relations. Convert them into plain system catalogs without hardwired entries in pg_class and friends. Unify global.bki and template1.bki into a single init script postgres.bki, since the alleged distinction between them was misleading and pointless. Not to mention that it didn't work for setting up indexes on shared system relations. Rationalize locking of pg_shadow, pg_group, pg_attrdef (no need to use AccessExclusiveLock where ExclusiveLock or even RowExclusiveLock will do). Also, hold locks until transaction commit where necessary.
2001-06-12 05:55:50 +00:00
*/
if (strcmp(relationName, RelationRelationName) == 0 ||
strcmp(relationName, AttributeRelationName) == 0 ||
strcmp(relationName, ProcedureRelationName) == 0 ||
strcmp(relationName, TypeRelationName) == 0)
relation->rd_rel->relhasindex = true;
Clean up syscache so that recursive invocation is safe, and remove error message about recursive use of a syscache. Also remove most of the specialized indexscan routines in indexing.c --- it turns out that catcache.c is perfectly able to perform the indexscan for itself, in fact has already looked up all the information needed to do so! This should be faster as well as needing far less boilerplate code.
2000-11-10 00:33:12 +00:00
}
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* add new reldesc to relcache
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Clean up syscache so that recursive invocation is safe, and remove error message about recursive use of a syscache. Also remove most of the specialized indexscan routines in indexing.c --- it turns out that catcache.c is perfectly able to perform the indexscan for itself, in fact has already looked up all the information needed to do so! This should be faster as well as needing far less boilerplate code.
2000-11-10 00:33:12 +00:00
RelationCacheInsert(relation);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Toast all the system-table columns that seem to need it. It turns out that giving pg_proc a toast table required solving the same problems we'd have to solve for pg_class --- pg_proc is one of the relations that gets bootstrapped in relcache.c. Solution is to go back at the end of initialization and read in the *real* pg_class row to replace the phony entry created by formrdesc(). This should work as long as there's no need to touch any toasted values during initialization, which seems a reasonable assumption. Although I did not add a toast-table for every single system table with a varlena attribute, I believe that it would work to just do ALTER TABLE pg_class CREATE TOAST TABLE. So anyone who's really intent on having several thousand ACL entries for a rel could do it. NOTE: I didn't force initdb, but you must do one to see the effects of this patch.
2000-08-06 04:40:08 +00:00
* fixrdesc
*
* Update the phony data inserted by formrdesc() with real info
* from pg_class.
*/
static void
fixrdesc(char *relationName)
{
RelationBuildDescInfo buildinfo;
HeapTuple pg_class_tuple;
Form_pg_class relp;
Relation relation;
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* find the tuple in pg_class corresponding to the given relation name
Toast all the system-table columns that seem to need it. It turns out that giving pg_proc a toast table required solving the same problems we'd have to solve for pg_class --- pg_proc is one of the relations that gets bootstrapped in relcache.c. Solution is to go back at the end of initialization and read in the *real* pg_class row to replace the phony entry created by formrdesc(). This should work as long as there's no need to touch any toasted values during initialization, which seems a reasonable assumption. Although I did not add a toast-table for every single system table with a varlena attribute, I believe that it would work to just do ALTER TABLE pg_class CREATE TOAST TABLE. So anyone who's really intent on having several thousand ACL entries for a rel could do it. NOTE: I didn't force initdb, but you must do one to see the effects of this patch.
2000-08-06 04:40:08 +00:00
*/
buildinfo.infotype = INFO_RELNAME;
buildinfo.i.info_name = relationName;
pg_class_tuple = ScanPgRelation(buildinfo);
if (!HeapTupleIsValid(pg_class_tuple))
elog(FATAL, "fixrdesc: no pg_class entry for %s",
relationName);
relp = (Form_pg_class) GETSTRUCT(pg_class_tuple);
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* find the pre-made relcache entry (better be there!)
Toast all the system-table columns that seem to need it. It turns out that giving pg_proc a toast table required solving the same problems we'd have to solve for pg_class --- pg_proc is one of the relations that gets bootstrapped in relcache.c. Solution is to go back at the end of initialization and read in the *real* pg_class row to replace the phony entry created by formrdesc(). This should work as long as there's no need to touch any toasted values during initialization, which seems a reasonable assumption. Although I did not add a toast-table for every single system table with a varlena attribute, I believe that it would work to just do ALTER TABLE pg_class CREATE TOAST TABLE. So anyone who's really intent on having several thousand ACL entries for a rel could do it. NOTE: I didn't force initdb, but you must do one to see the effects of this patch.
2000-08-06 04:40:08 +00:00
*/
relation = RelationNameCacheGetRelation(relationName);
if (!RelationIsValid(relation))
elog(FATAL, "fixrdesc: no existing relcache entry for %s",
relationName);
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* and copy pg_class_tuple to relation->rd_rel. (See notes in
* AllocateRelationDesc())
Toast all the system-table columns that seem to need it. It turns out that giving pg_proc a toast table required solving the same problems we'd have to solve for pg_class --- pg_proc is one of the relations that gets bootstrapped in relcache.c. Solution is to go back at the end of initialization and read in the *real* pg_class row to replace the phony entry created by formrdesc(). This should work as long as there's no need to touch any toasted values during initialization, which seems a reasonable assumption. Although I did not add a toast-table for every single system table with a varlena attribute, I believe that it would work to just do ALTER TABLE pg_class CREATE TOAST TABLE. So anyone who's really intent on having several thousand ACL entries for a rel could do it. NOTE: I didn't force initdb, but you must do one to see the effects of this patch.
2000-08-06 04:40:08 +00:00
*/
Assert(relation->rd_rel != NULL);
memcpy((char *) relation->rd_rel, (char *) relp, CLASS_TUPLE_SIZE);
heap_freetuple(pg_class_tuple);
}
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
/* ----------------------------------------------------------------
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* Relation Descriptor Lookup Interface
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
* ----------------------------------------------------------------
*/
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* RelationIdCacheGetRelation
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
* Lookup an existing reldesc by OID.
*
* Only try to get the reldesc by looking in the cache,
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
* do not go to the disk.
*
* NB: relation ref count is incremented if successful.
* Caller should eventually decrement count. (Usually,
* that happens by calling RelationClose().)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
Relation
RelationIdCacheGetRelation(Oid relationId)
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
Relation rd;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
RelationIdCacheLookup(relationId, rd);
if (RelationIsValid(rd))
{
Make DROP TABLE rollback-able: postpone physical file delete until commit. (WAL logging for this is not done yet, however.) Clean up a number of really crufty things that are no longer needed now that DROP behaves nicely. Make temp table mapper do the right things when drop or rename affecting a temp table is rolled back. Also, remove "relation modified while in use" error check, in favor of locking tables at first reference and holding that lock throughout the statement.
2000-11-08 22:10:03 +00:00
/* re-open files if necessary */
This patch implements a different "relkind" for views. Views are now have a "relkind" of RELKIND_VIEW instead of RELKIND_RELATION. Also, views no longer have actual heap storage files. The following changes were made 1. CREATE VIEW sets the new relkind 2. The executor complains if a DELETE or INSERT references a view. 3. DROP RULE complains if an attempt is made to delete a view SELECT rule. 4. CREATE RULE "_RETmytable" AS ON SELECT TO mytable DO INSTEAD ... 1. checks to make sure mytable is empty. 2. sets the relkind to RELKIND_VIEW. 3. deletes the heap storage files. 5. LOCK myview is not allowed. :) 6. the regression test type_sanity was changed to account for the new relkind value. 7. CREATE INDEX ON myview ... is not allowed. 8. VACUUM myview is not allowed. VACUUM automatically skips views when do the entire database. 9. TRUNCATE myview is not allowed. THINGS LEFT TO THINK ABOUT o pg_views o pg_dump o pgsql (\d \dv) o Do we really want to be able to inherit from views? o Is 'DROP TABLE myview' OK? -- Mark Hollomon
2000-09-12 04:49:17 +00:00
if (rd->rd_fd == -1 && rd->rd_rel->relkind != RELKIND_VIEW)
Make DROP TABLE rollback-able: postpone physical file delete until commit. (WAL logging for this is not done yet, however.) Clean up a number of really crufty things that are no longer needed now that DROP behaves nicely. Make temp table mapper do the right things when drop or rename affecting a temp table is rolled back. Also, remove "relation modified while in use" error check, in favor of locking tables at first reference and holding that lock throughout the statement.
2000-11-08 22:10:03 +00:00
rd->rd_fd = smgropen(DEFAULT_SMGR, rd, false);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
RelationIncrementReferenceCount(rd);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Renaming cleanup, no pgindent yet.
1998-09-01 03:29:17 +00:00
return rd;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* RelationNameCacheGetRelation
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
*
* As above, but lookup by name.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
static Relation
added ALTER TABLE DROP COLUMN, early version
2000-01-22 14:20:56 +00:00
RelationNameCacheGetRelation(const char *relationName)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
Relation rd;
NameData name;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
/*
* make sure that the name key used for hash lookup is properly
* null-padded
*/
namestrcpy(&name, relationName);
New NameStr macro to convert Name to Str. No need for var.data anymore. Fewer calls to nameout. Better use of RelationGetRelationName.
1999-11-07 23:08:36 +00:00
RelationNameCacheLookup(NameStr(name), rd);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
if (RelationIsValid(rd))
{
Make DROP TABLE rollback-able: postpone physical file delete until commit. (WAL logging for this is not done yet, however.) Clean up a number of really crufty things that are no longer needed now that DROP behaves nicely. Make temp table mapper do the right things when drop or rename affecting a temp table is rolled back. Also, remove "relation modified while in use" error check, in favor of locking tables at first reference and holding that lock throughout the statement.
2000-11-08 22:10:03 +00:00
/* re-open files if necessary */
This patch implements a different "relkind" for views. Views are now have a "relkind" of RELKIND_VIEW instead of RELKIND_RELATION. Also, views no longer have actual heap storage files. The following changes were made 1. CREATE VIEW sets the new relkind 2. The executor complains if a DELETE or INSERT references a view. 3. DROP RULE complains if an attempt is made to delete a view SELECT rule. 4. CREATE RULE "_RETmytable" AS ON SELECT TO mytable DO INSTEAD ... 1. checks to make sure mytable is empty. 2. sets the relkind to RELKIND_VIEW. 3. deletes the heap storage files. 5. LOCK myview is not allowed. :) 6. the regression test type_sanity was changed to account for the new relkind value. 7. CREATE INDEX ON myview ... is not allowed. 8. VACUUM myview is not allowed. VACUUM automatically skips views when do the entire database. 9. TRUNCATE myview is not allowed. THINGS LEFT TO THINK ABOUT o pg_views o pg_dump o pgsql (\d \dv) o Do we really want to be able to inherit from views? o Is 'DROP TABLE myview' OK? -- Mark Hollomon
2000-09-12 04:49:17 +00:00
if (rd->rd_fd == -1 && rd->rd_rel->relkind != RELKIND_VIEW)
Make DROP TABLE rollback-able: postpone physical file delete until commit. (WAL logging for this is not done yet, however.) Clean up a number of really crufty things that are no longer needed now that DROP behaves nicely. Make temp table mapper do the right things when drop or rename affecting a temp table is rolled back. Also, remove "relation modified while in use" error check, in favor of locking tables at first reference and holding that lock throughout the statement.
2000-11-08 22:10:03 +00:00
rd->rd_fd = smgropen(DEFAULT_SMGR, rd, false);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
RelationIncrementReferenceCount(rd);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Renaming cleanup, no pgindent yet.
1998-09-01 03:29:17 +00:00
return rd;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
Relation
RelationNodeCacheGetRelation(RelFileNode rnode)
{
Relation rd;
RelationNodeCacheLookup(rnode, rd);
if (RelationIsValid(rd))
{
Make DROP TABLE rollback-able: postpone physical file delete until commit. (WAL logging for this is not done yet, however.) Clean up a number of really crufty things that are no longer needed now that DROP behaves nicely. Make temp table mapper do the right things when drop or rename affecting a temp table is rolled back. Also, remove "relation modified while in use" error check, in favor of locking tables at first reference and holding that lock throughout the statement.
2000-11-08 22:10:03 +00:00
/* re-open files if necessary */
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
if (rd->rd_fd == -1 && rd->rd_rel->relkind != RELKIND_VIEW)
Make DROP TABLE rollback-able: postpone physical file delete until commit. (WAL logging for this is not done yet, however.) Clean up a number of really crufty things that are no longer needed now that DROP behaves nicely. Make temp table mapper do the right things when drop or rename affecting a temp table is rolled back. Also, remove "relation modified while in use" error check, in favor of locking tables at first reference and holding that lock throughout the statement.
2000-11-08 22:10:03 +00:00
rd->rd_fd = smgropen(DEFAULT_SMGR, rd, false);
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
RelationIncrementReferenceCount(rd);
}
return rd;
}
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* RelationIdGetRelation
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
* Lookup a reldesc by OID; make one if not already in cache.
*
* NB: relation ref count is incremented, or set to 1 if new entry.
* Caller should eventually decrement count. (Usually,
* that happens by calling RelationClose().)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
Relation
RelationIdGetRelation(Oid relationId)
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
Relation rd;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
RelationBuildDescInfo buildinfo;
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* increment access statistics
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
IncrHeapAccessStat(local_RelationIdGetRelation);
IncrHeapAccessStat(global_RelationIdGetRelation);
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* first try and get a reldesc from the cache
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
rd = RelationIdCacheGetRelation(relationId);
if (RelationIsValid(rd))
return rd;
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* no reldesc in the cache, so have RelationBuildDesc() build one and
* add it.
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
buildinfo.infotype = INFO_RELID;
buildinfo.i.info_id = relationId;
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
rd = RelationBuildDesc(buildinfo, NULL);
Add TEMP tables/indexes. Add COPY pfree(). Other cleanups.
1999-02-02 03:45:56 +00:00
return rd;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* RelationNameGetRelation
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
* As above, but lookup by name.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
Relation
added ALTER TABLE DROP COLUMN, early version
2000-01-22 14:20:56 +00:00
RelationNameGetRelation(const char *relationName)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
{
In RelationNameGetRelation(), replace temp table name by real name before doing lookup. We only want to index temp tables by their real names in the relcache, to ensure there's not more than one relcache entry for them.
1999-09-04 21:47:23 +00:00
char *temprelname;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
Relation rd;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
RelationBuildDescInfo buildinfo;
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* increment access statistics
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
IncrHeapAccessStat(local_RelationNameGetRelation);
IncrHeapAccessStat(global_RelationNameGetRelation);
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* if caller is looking for a temp relation, substitute its real name;
* we only index temp rels by their real names.
In RelationNameGetRelation(), replace temp table name by real name before doing lookup. We only want to index temp tables by their real names in the relcache, to ensure there's not more than one relcache entry for them.
1999-09-04 21:47:23 +00:00
*/
Commit to make clearer distinction for temp names and real names. Thanks to Tom Lane for ideas.
1999-11-16 04:14:03 +00:00
temprelname = get_temp_rel_by_username(relationName);
Small cleanup of temp-table handling. Disallow creation of a non-temp table that inherits from a temp table. Make sure the right things happen if one creates a temp table, creates another temp that inherits from it, then renames the first one. (Previously, system would end up trying to delete the temp tables in the wrong order.)
2000-12-22 23:12:07 +00:00
if (temprelname != NULL)
In RelationNameGetRelation(), replace temp table name by real name before doing lookup. We only want to index temp tables by their real names in the relcache, to ensure there's not more than one relcache entry for them.
1999-09-04 21:47:23 +00:00
relationName = temprelname;
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* first try and get a reldesc from the cache
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
rd = RelationNameCacheGetRelation(relationName);
if (RelationIsValid(rd))
return rd;
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* no reldesc in the cache, so have RelationBuildDesc() build one and
* add it.
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
buildinfo.infotype = INFO_RELNAME;
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
buildinfo.i.info_name = (char *) relationName;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
rd = RelationBuildDesc(buildinfo, NULL);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
return rd;
}
/* ----------------------------------------------------------------
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* cache invalidation support routines
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
* ----------------------------------------------------------------
*/
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
* RelationClose - close an open relation
*
Add some debugging support code (ifdef'd out in normal use).
2001-01-08 18:34:44 +00:00
* Actually, we just decrement the refcount.
*
* NOTE: if compiled with -DRELCACHE_FORCE_RELEASE then relcache entries
* will be freed as soon as their refcount goes to zero. In combination
* with aset.c's CLOBBER_FREED_MEMORY option, this provides a good test
* to catch references to already-released relcache entries. It slows
* things down quite a bit, however.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
void
RelationClose(Relation relation)
{
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
/* Note: no locking manipulations needed */
RelationDecrementReferenceCount(relation);
Add some debugging support code (ifdef'd out in normal use).
2001-01-08 18:34:44 +00:00
#ifdef RELCACHE_FORCE_RELEASE
if (RelationHasReferenceCountZero(relation) && !relation->rd_myxactonly)
RelationClearRelation(relation, false);
#endif
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
REINDEX under WAL.
2000-12-08 06:17:58 +00:00
#ifdef ENABLE_REINDEX_NAILED_RELATIONS
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
REINDEX under WAL.
2000-12-08 06:17:58 +00:00
* RelationReloadClassinfo
*
* This function is especially for nailed relations.
* relhasindex/relfilenode could be changed even for
* nailed relations.
*/
static void
RelationReloadClassinfo(Relation relation)
{
RelationBuildDescInfo buildinfo;
HeapTuple pg_class_tuple;
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
Form_pg_class relp;
REINDEX under WAL.
2000-12-08 06:17:58 +00:00
if (!relation->rd_rel)
return;
buildinfo.infotype = INFO_RELID;
buildinfo.i.info_id = relation->rd_id;
pg_class_tuple = ScanPgRelation(buildinfo);
if (!HeapTupleIsValid(pg_class_tuple))
{
elog(ERROR, "RelationReloadClassinfo system relation id=%d doesn't exist", relation->rd_id);
return;
}
RelationCacheDelete(relation);
relp = (Form_pg_class) GETSTRUCT(pg_class_tuple);
memcpy((char *) relation->rd_rel, (char *) relp, CLASS_TUPLE_SIZE);
relation->rd_node.relNode = relp->relfilenode;
RelationCacheInsert(relation);
heap_freetuple(pg_class_tuple);
return;
}
New pgindent run with fixes suggested by Tom. Patch manually reviewed, initdb/regression tests pass.
2001-11-05 17:46:40 +00:00
#endif /* ENABLE_REINDEX_NAILED_RELATIONS */
Add some debugging support code (ifdef'd out in normal use).
2001-01-08 18:34:44 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
* RelationClearRelation
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
* Physically blow away a relation cache entry, or reset it and rebuild
* it from scratch (that is, from catalog entries). The latter path is
* usually used when we are notified of a change to an open relation
* (one with refcount > 0). However, this routine just does whichever
* it's told to do; callers must determine which they want.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
Make functions static where possible, enclose unused functions in #ifdef NOT_USED.
1997-08-19 21:40:56 +00:00
static void
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
RelationClearRelation(Relation relation, bool rebuildIt)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
{
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
MemoryContext oldcxt;
/*
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
* Make sure smgr and lower levels close the relation's files, if they
Make DROP TABLE rollback-able: postpone physical file delete until commit. (WAL logging for this is not done yet, however.) Clean up a number of really crufty things that are no longer needed now that DROP behaves nicely. Make temp table mapper do the right things when drop or rename affecting a temp table is rolled back. Also, remove "relation modified while in use" error check, in favor of locking tables at first reference and holding that lock throughout the statement.
2000-11-08 22:10:03 +00:00
* weren't closed already. If the relation is not getting deleted,
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* the next smgr access should reopen the files automatically. This
Make DROP TABLE rollback-able: postpone physical file delete until commit. (WAL logging for this is not done yet, however.) Clean up a number of really crufty things that are no longer needed now that DROP behaves nicely. Make temp table mapper do the right things when drop or rename affecting a temp table is rolled back. Also, remove "relation modified while in use" error check, in favor of locking tables at first reference and holding that lock throughout the statement.
2000-11-08 22:10:03 +00:00
* ensures that the low-level file access state is updated after, say,
* a vacuum truncation.
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
*/
Make DROP TABLE rollback-able: postpone physical file delete until commit. (WAL logging for this is not done yet, however.) Clean up a number of really crufty things that are no longer needed now that DROP behaves nicely. Make temp table mapper do the right things when drop or rename affecting a temp table is rolled back. Also, remove "relation modified while in use" error check, in favor of locking tables at first reference and holding that lock throughout the statement.
2000-11-08 22:10:03 +00:00
if (relation->rd_fd >= 0)
Install infrastructure for shared-memory free space map. Doesn't actually do anything yet, but it has the necessary connections to initialization and so forth. Make some gestures towards allowing number of blocks in a relation to be BlockNumber, ie, unsigned int, rather than signed int. (I doubt I got all the places that are sloppy about it, yet.) On the way, replace the hardwired NLOCKS_PER_XACT fudge factor with a GUC variable.
2001-06-27 23:31:40 +00:00
{
Make DROP TABLE rollback-able: postpone physical file delete until commit. (WAL logging for this is not done yet, however.) Clean up a number of really crufty things that are no longer needed now that DROP behaves nicely. Make temp table mapper do the right things when drop or rename affecting a temp table is rolled back. Also, remove "relation modified while in use" error check, in favor of locking tables at first reference and holding that lock throughout the statement.
2000-11-08 22:10:03 +00:00
smgrclose(DEFAULT_SMGR, relation);
Install infrastructure for shared-memory free space map. Doesn't actually do anything yet, but it has the necessary connections to initialization and so forth. Make some gestures towards allowing number of blocks in a relation to be BlockNumber, ie, unsigned int, rather than signed int. (I doubt I got all the places that are sloppy about it, yet.) On the way, replace the hardwired NLOCKS_PER_XACT fudge factor with a GUC variable.
2001-06-27 23:31:40 +00:00
relation->rd_fd = -1;
}
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
/*
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
* Never, never ever blow away a nailed-in system relation, because
* we'd be unable to recover.
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
*/
if (relation->rd_isnailed)
REINDEX under WAL.
2000-12-08 06:17:58 +00:00
{
Clean up non-reentrant interface for hash_seq/HashTableWalk, so that starting a new hashtable search no longer clobbers any other search active anywhere in the system. Fix RelationCacheInvalidate() so that it will not crash or go into an infinite loop if invoked recursively, as for example by a second SI Reset message arriving while we are still processing a prior one.
2001-01-02 04:33:24 +00:00
#ifdef ENABLE_REINDEX_NAILED_RELATIONS
REINDEX under WAL.
2000-12-08 06:17:58 +00:00
RelationReloadClassinfo(relation);
New pgindent run with fixes suggested by Tom. Patch manually reviewed, initdb/regression tests pass.
2001-11-05 17:46:40 +00:00
#endif /* ENABLE_REINDEX_NAILED_RELATIONS */
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
return;
REINDEX under WAL.
2000-12-08 06:17:58 +00:00
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
/*
* Remove relation from hash tables
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
*
* Note: we might be reinserting it momentarily, but we must not have it
* visible in the hash tables until it's valid again, so don't try to
* optimize this away...
*/
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
RelationCacheDelete(relation);
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
MemoryContextSwitchTo(oldcxt);
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
/* Clear out catcache's entries for this relation */
Do some restructuring to improve performance of the catcaches. Teach CatalogCacheFlushRelation (formerly called SystemCacheRelationFlushed) how to distinguish tuples it should flush from those it needn't; this means a relcache flush event now only removes the catcache entries it ought to, rather than zapping the caches completely as it used to. Testing with the regression tests indicates that this considerably improves the lifespan of catcache entries. Also, rearrange catcache data structures so that the limit on number of cached tuples applies globally across all the catcaches, rather than being per-catcache. It was a little silly to have the same size limit on both, say, pg_attribute caches and pg_am caches (there being only four possible rows in the latter...). Doing LRU removal across all the caches instead of locally in each one should reduce cache reload traffic in the more heavily used caches and improve the efficiency of cache memory use.
2001-06-18 03:35:07 +00:00
CatalogCacheFlushRelation(RelationGetRelid(relation));
Repair a bunch of problems in md.c. This builds on Hiroshi's insight that RelationFlushRelation ought to invoke smgrclose, and that the way to make that work is to ensure that mdclose doesn't fail if the relation is already closed (or unlinked, if we are looking at a DROP TABLE). While I was testing that, I was able to identify several problems that we had with multiple-segment relations. The system is now able to do initdb and pass the regression tests with a very small segment size (I had it set to 64Kb per segment for testing). I don't believe that ever worked before. File descriptor leaks seem to be gone too. I have partially addressed the concerns we had about mdtruncate(), too. On a Win32 or NFS filesystem it is not possible to unlink a file that another backend is holding open, so what md.c now does is to truncate unwanted files to zero length before trying to unlink them. The other backends will be forced to close their open files by relation cache invalidation --- but I think it would take considerable work to make that happen before vacuum truncates the relation rather than after. Leaving zero-length files lying around seems a usable compromise.
1999-09-02 02:57:50 +00:00
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
/*
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
* Free all the subsidiary data structures of the relcache entry. We
* cannot free rd_att if we are trying to rebuild the entry, however,
* because pointers to it may be cached in various places. The trigger
* manager might also have pointers into the trigdesc, and the rule
* manager might have pointers into the rewrite rules. So to begin
* with, we can only get rid of these fields:
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
*/
if (relation->rd_am)
pfree(relation->rd_am);
if (relation->rd_rel)
pfree(relation->rd_rel);
Fix performance problems with pg_index lookups (see, for example, discussion of 5/19/00). pg_index is now searched for indexes of a relation using an indexscan. Moreover, this is done once and cached in the relcache entry for the relation, in the form of a list of OIDs for the indexes. This list is used by the parser and executor to drive lookups in the pg_index syscache when they want to know the properties of the indexes. Net result: index information will be fully cached for repetitive operations such as inserts.
2000-06-17 21:49:04 +00:00
freeList(relation->rd_indexlist);
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
if (relation->rd_indexcxt)
MemoryContextDelete(relation->rd_indexcxt);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
/*
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
* If we're really done with the relcache entry, blow it away. But if
* someone is still using it, reconstruct the whole deal without
* moving the physical RelationData record (so that the someone's
* pointer is still valid).
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
*/
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
if (!rebuildIt)
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
{
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
/* ok to zap remaining substructure */
FreeTupleDesc(relation->rd_att);
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
if (relation->rd_rulescxt)
MemoryContextDelete(relation->rd_rulescxt);
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
FreeTriggerDesc(relation->trigdesc);
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
pfree(relation);
}
else
{
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
/*
* When rebuilding an open relcache entry, must preserve ref count
* and myxactonly flag. Also attempt to preserve the tupledesc,
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
* rewrite rules, and trigger substructures in place. Furthermore
* we save/restore rd_nblocks (in case it is a local relation)
* *and* call RelationGetNumberOfBlocks (in case it isn't).
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
*/
Install infrastructure for shared-memory free space map. Doesn't actually do anything yet, but it has the necessary connections to initialization and so forth. Make some gestures towards allowing number of blocks in a relation to be BlockNumber, ie, unsigned int, rather than signed int. (I doubt I got all the places that are sloppy about it, yet.) On the way, replace the hardwired NLOCKS_PER_XACT fudge factor with a GUC variable.
2001-06-27 23:31:40 +00:00
int old_refcnt = relation->rd_refcnt;
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
bool old_myxactonly = relation->rd_myxactonly;
TupleDesc old_att = relation->rd_att;
RuleLock *old_rules = relation->rd_rules;
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
MemoryContext old_rulescxt = relation->rd_rulescxt;
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
TriggerDesc *old_trigdesc = relation->trigdesc;
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 05:50:21 +00:00
BlockNumber old_nblocks = relation->rd_nblocks;
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
RelationBuildDescInfo buildinfo;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
buildinfo.infotype = INFO_RELID;
buildinfo.i.info_id = RelationGetRelid(relation);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
if (RelationBuildDesc(buildinfo, relation) != relation)
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
{
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
/* Should only get here if relation was deleted */
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
FreeTupleDesc(old_att);
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
if (old_rulescxt)
MemoryContextDelete(old_rulescxt);
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
FreeTriggerDesc(old_trigdesc);
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
pfree(relation);
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
elog(ERROR, "RelationClearRelation: relation %u deleted while still in use",
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
buildinfo.i.info_id);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
}
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
RelationSetReferenceCount(relation, old_refcnt);
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
relation->rd_myxactonly = old_myxactonly;
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
if (equalTupleDescs(old_att, relation->rd_att))
{
FreeTupleDesc(relation->rd_att);
relation->rd_att = old_att;
}
else
FreeTupleDesc(old_att);
if (equalRuleLocks(old_rules, relation->rd_rules))
{
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
if (relation->rd_rulescxt)
MemoryContextDelete(relation->rd_rulescxt);
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
relation->rd_rules = old_rules;
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
relation->rd_rulescxt = old_rulescxt;
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
}
else
{
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
if (old_rulescxt)
MemoryContextDelete(old_rulescxt);
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
}
if (equalTriggerDescs(old_trigdesc, relation->trigdesc))
{
FreeTriggerDesc(relation->trigdesc);
relation->trigdesc = old_trigdesc;
}
else
FreeTriggerDesc(old_trigdesc);
relation->rd_nblocks = old_nblocks;
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
/*
* this is kind of expensive, but I think we must do it in case
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
* relation has been truncated...
*/
Make DROP TABLE rollback-able: postpone physical file delete until commit. (WAL logging for this is not done yet, however.) Clean up a number of really crufty things that are no longer needed now that DROP behaves nicely. Make temp table mapper do the right things when drop or rename affecting a temp table is rolled back. Also, remove "relation modified while in use" error check, in favor of locking tables at first reference and holding that lock throughout the statement.
2000-11-08 22:10:03 +00:00
relation->rd_nblocks = RelationGetNumberOfBlocks(relation);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
}
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
* RelationFlushRelation
*
* Rebuild the relation if it is open (refcount > 0), else blow it away.
*/
static void
Clean up non-reentrant interface for hash_seq/HashTableWalk, so that starting a new hashtable search no longer clobbers any other search active anywhere in the system. Fix RelationCacheInvalidate() so that it will not crash or go into an infinite loop if invoked recursively, as for example by a second SI Reset message arriving while we are still processing a prior one.
2001-01-02 04:33:24 +00:00
RelationFlushRelation(Relation relation)
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
{
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
bool rebuildIt;
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
if (relation->rd_myxactonly)
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
{
/*
* Local rels should always be rebuilt, not flushed; the relcache
* entry must live until RelationPurgeLocalRelation().
*/
rebuildIt = true;
}
else
{
/*
* Nonlocal rels can be dropped from the relcache if not open.
*/
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
rebuildIt = !RelationHasReferenceCountZero(relation);
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
}
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
RelationClearRelation(relation, rebuildIt);
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
}
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
* RelationForgetRelation -
*
* RelationClearRelation + if the relation is myxactonly then
* remove the relation descriptor from the newly created
Add TEMP tables/indexes. Add COPY pfree(). Other cleanups.
1999-02-02 03:45:56 +00:00
* relation list.
New func RelationForgetRelation(); * RelationFlushRelation + if the relation is local then get rid of * the relation descriptor from the newly created relation list.
1997-06-04 08:56:51 +00:00
*/
void
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
RelationForgetRelation(Oid rid)
New func RelationForgetRelation(); * RelationFlushRelation + if the relation is local then get rid of * the relation descriptor from the newly created relation list.
1997-06-04 08:56:51 +00:00
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
Relation relation;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
RelationIdCacheLookup(rid, relation);
Add TEMP tables/indexes. Add COPY pfree(). Other cleanups.
1999-02-02 03:45:56 +00:00
if (PointerIsValid(relation))
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
{
Add TEMP tables/indexes. Add COPY pfree(). Other cleanups.
1999-02-02 03:45:56 +00:00
if (relation->rd_myxactonly)
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
{
Add TEMP tables/indexes. Add COPY pfree(). Other cleanups.
1999-02-02 03:45:56 +00:00
List *curr;
List *prev = NIL;
pgindent run over code.
1999-05-25 16:15:34 +00:00
Add TEMP tables/indexes. Add COPY pfree(). Other cleanups.
1999-02-02 03:45:56 +00:00
foreach(curr, newlyCreatedRelns)
{
Relation reln = lfirst(curr);
pgindent run over code.
1999-05-25 16:15:34 +00:00
Add TEMP tables/indexes. Add COPY pfree(). Other cleanups.
1999-02-02 03:45:56 +00:00
Assert(reln != NULL && reln->rd_myxactonly);
if (RelationGetRelid(reln) == rid)
break;
prev = curr;
}
if (curr == NIL)
elog(FATAL, "Local relation %s not found in list",
New NameStr macro to convert Name to Str. No need for var.data anymore. Fewer calls to nameout. Better use of RelationGetRelationName.
1999-11-07 23:08:36 +00:00
RelationGetRelationName(relation));
Add TEMP tables/indexes. Add COPY pfree(). Other cleanups.
1999-02-02 03:45:56 +00:00
if (prev == NIL)
newlyCreatedRelns = lnext(newlyCreatedRelns);
else
lnext(prev) = lnext(curr);
pfree(curr);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
}
pgindent run over code.
1999-05-25 16:15:34 +00:00
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
/* Unconditionally destroy the relcache entry */
RelationClearRelation(relation, false);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
}
New func RelationForgetRelation(); * RelationFlushRelation + if the relation is local then get rid of * the relation descriptor from the newly created relation list.
1997-06-04 08:56:51 +00:00
}
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* RelationIdInvalidateRelationCacheByRelationId
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
*
* This routine is invoked for SI cache flush messages.
*
* We used to skip local relations, on the grounds that they could
* not be targets of cross-backend SI update messages; but it seems
* safer to process them, so that our *own* SI update messages will
* have the same effects during CommandCounterIncrement for both
* local and nonlocal relations.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
void
RelationIdInvalidateRelationCacheByRelationId(Oid relationId)
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
Relation relation;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
RelationIdCacheLookup(relationId, relation);
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
if (PointerIsValid(relation))
Clean up non-reentrant interface for hash_seq/HashTableWalk, so that starting a new hashtable search no longer clobbers any other search active anywhere in the system. Fix RelationCacheInvalidate() so that it will not crash or go into an infinite loop if invoked recursively, as for example by a second SI Reset message arriving while we are still processing a prior one.
2001-01-02 04:33:24 +00:00
RelationFlushRelation(relation);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Repair problem exposed by Jan's new parallel-regression-test scaffold: inval.c thought it could safely use the catcache to look up the OIDs of system relations. Not good, considering that inval.c could be called during catcache loading, if a shared-inval message arrives. Rip out the lookup logic and instead use the known OIDs from pg_class.h.
1999-11-21 01:58:22 +00:00
#if NOT_USED
/* only used by RelationIdInvalidateRelationCacheByAccessMethodId,
* which is dead code.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
static void
Used modified version of indent that understands over 100 typedefs.
1997-09-08 21:56:23 +00:00
RelationFlushIndexes(Relation *r,
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Oid accessMethodId)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
Relation relation = *r;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
if (!RelationIsValid(relation))
{
elog(NOTICE, "inval call to RFI");
return;
}
if (relation->rd_rel->relkind == RELKIND_INDEX && /* XXX style */
(!OidIsValid(accessMethodId) ||
relation->rd_rel->relam == accessMethodId))
Clean up non-reentrant interface for hash_seq/HashTableWalk, so that starting a new hashtable search no longer clobbers any other search active anywhere in the system. Fix RelationCacheInvalidate() so that it will not crash or go into an infinite loop if invoked recursively, as for example by a second SI Reset message arriving while we are still processing a prior one.
2001-01-02 04:33:24 +00:00
RelationFlushRelation(relation);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Major code cleanups from D'arcy (-Wall -Werror)
1996-10-23 07:42:13 +00:00
#endif
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
/*
* RelationCacheInvalidate
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
* Blow away cached relation descriptors that have zero reference counts,
* and rebuild those with positive reference counts.
Modify uses of RelationFlushRelation and RelationCacheInvalidate so that we *always* rebuild, rather than deleting, an invalidated relcache entry that has positive refcount. Otherwise an SI cache overrun leads to dangling Relation pointers all over the place!
2000-01-29 19:51:59 +00:00
*
Fix relcache.c so that local relations (those created during current transaction) are not flushed by shared-cache-inval reset message. SI reset actually works now, for probably the first time in a long time. I was able to run initdb and regression tests with a 16-element SI message array, with a lot of NOTICE: cache state reset messages but no crashes.
1999-09-06 19:33:16 +00:00
* This is currently used only to recover from SI message buffer overflow,
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
* so we do not touch transaction-local relations; they cannot be targets
* of cross-backend SI updates (and our own updates now go through a
* separate linked list that isn't limited by the SI message buffer size).
Clean up non-reentrant interface for hash_seq/HashTableWalk, so that starting a new hashtable search no longer clobbers any other search active anywhere in the system. Fix RelationCacheInvalidate() so that it will not crash or go into an infinite loop if invoked recursively, as for example by a second SI Reset message arriving while we are still processing a prior one.
2001-01-02 04:33:24 +00:00
*
* We do this in two phases: the first pass deletes deletable items, and
* the second one rebuilds the rebuildable items. This is essential for
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
* safety, because hash_seq_search only copes with concurrent deletion of
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* the element it is currently visiting. If a second SI overflow were to
Clean up non-reentrant interface for hash_seq/HashTableWalk, so that starting a new hashtable search no longer clobbers any other search active anywhere in the system. Fix RelationCacheInvalidate() so that it will not crash or go into an infinite loop if invoked recursively, as for example by a second SI Reset message arriving while we are still processing a prior one.
2001-01-02 04:33:24 +00:00
* occur while we are walking the table, resulting in recursive entry to
* this routine, we could crash because the inner invocation blows away
* the entry next to be visited by the outer scan. But this way is OK,
* because (a) during the first pass we won't process any more SI messages,
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
* so hash_seq_search will complete safely; (b) during the second pass we
Clean up non-reentrant interface for hash_seq/HashTableWalk, so that starting a new hashtable search no longer clobbers any other search active anywhere in the system. Fix RelationCacheInvalidate() so that it will not crash or go into an infinite loop if invoked recursively, as for example by a second SI Reset message arriving while we are still processing a prior one.
2001-01-02 04:33:24 +00:00
* only hold onto pointers to nondeletable entries.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
void
Fix problems seen in parallel regress tests when SI buffer overruns (causing syscache and relcache flushes). Relcache entry rebuild now preserves original tupledesc, rewrite rules, and triggers if possible, so that pointers to these things remain valid --- if these things change while relcache entry has positive refcount, we elog(ERROR) to avoid later crash. Arrange for xact-local rels to be rebuilt when an SI inval message is seen for them, so that they are updated by CommandCounterIncrement the same as regular rels. (This is useful because of Hiroshi's recent changes to process our own SI messages at CommandCounterIncrement time.) This allows simplification of some routines that previously hacked around the lack of an automatic update. catcache now keeps its own copy of tupledesc for its relation, rather than depending on the relcache's copy; this avoids needing to reinitialize catcache during a cache flush, which saves some cycles and eliminates nasty circularity problems that occur if a cache flush happens while trying to initialize a catcache. Eliminate a number of permanent memory leaks that used to happen during catcache or relcache flush; not least of which was that catcache never freed any cached tuples! (Rule parsetree storage is still leaked, however; will fix that separately.) Nothing done yet about code that uses tuples retrieved by SearchSysCache for longer than is safe.
2000-01-31 04:35:57 +00:00
RelationCacheInvalidate(void)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
{
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
HASH_SEQ_STATUS status;
RelNameCacheEnt *namehentry;
Relation relation;
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
List *rebuildList = NIL;
List *l;
Clean up non-reentrant interface for hash_seq/HashTableWalk, so that starting a new hashtable search no longer clobbers any other search active anywhere in the system. Fix RelationCacheInvalidate() so that it will not crash or go into an infinite loop if invoked recursively, as for example by a second SI Reset message arriving while we are still processing a prior one.
2001-01-02 04:33:24 +00:00
/* Phase 1 */
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
hash_seq_init(&status, RelationNameCache);
Clean up non-reentrant interface for hash_seq/HashTableWalk, so that starting a new hashtable search no longer clobbers any other search active anywhere in the system. Fix RelationCacheInvalidate() so that it will not crash or go into an infinite loop if invoked recursively, as for example by a second SI Reset message arriving while we are still processing a prior one.
2001-01-02 04:33:24 +00:00
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
while ((namehentry = (RelNameCacheEnt *) hash_seq_search(&status)) != NULL)
Clean up non-reentrant interface for hash_seq/HashTableWalk, so that starting a new hashtable search no longer clobbers any other search active anywhere in the system. Fix RelationCacheInvalidate() so that it will not crash or go into an infinite loop if invoked recursively, as for example by a second SI Reset message arriving while we are still processing a prior one.
2001-01-02 04:33:24 +00:00
{
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
relation = namehentry->reldesc;
Clean up non-reentrant interface for hash_seq/HashTableWalk, so that starting a new hashtable search no longer clobbers any other search active anywhere in the system. Fix RelationCacheInvalidate() so that it will not crash or go into an infinite loop if invoked recursively, as for example by a second SI Reset message arriving while we are still processing a prior one.
2001-01-02 04:33:24 +00:00
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
/* Ignore xact-local relations, since they are never SI targets */
if (relation->rd_myxactonly)
continue;
Clean up non-reentrant interface for hash_seq/HashTableWalk, so that starting a new hashtable search no longer clobbers any other search active anywhere in the system. Fix RelationCacheInvalidate() so that it will not crash or go into an infinite loop if invoked recursively, as for example by a second SI Reset message arriving while we are still processing a prior one.
2001-01-02 04:33:24 +00:00
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
if (RelationHasReferenceCountZero(relation))
{
/* Delete this entry immediately */
RelationClearRelation(relation, false);
}
else
{
/* Add entry to list of stuff to rebuild in second pass */
rebuildList = lcons(relation, rebuildList);
}
Clean up non-reentrant interface for hash_seq/HashTableWalk, so that starting a new hashtable search no longer clobbers any other search active anywhere in the system. Fix RelationCacheInvalidate() so that it will not crash or go into an infinite loop if invoked recursively, as for example by a second SI Reset message arriving while we are still processing a prior one.
2001-01-02 04:33:24 +00:00
}
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
/* Phase 2: rebuild the items found to need rebuild in phase 1 */
foreach(l, rebuildList)
Clean up non-reentrant interface for hash_seq/HashTableWalk, so that starting a new hashtable search no longer clobbers any other search active anywhere in the system. Fix RelationCacheInvalidate() so that it will not crash or go into an infinite loop if invoked recursively, as for example by a second SI Reset message arriving while we are still processing a prior one.
2001-01-02 04:33:24 +00:00
{
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
relation = (Relation) lfirst(l);
RelationClearRelation(relation, true);
Clean up non-reentrant interface for hash_seq/HashTableWalk, so that starting a new hashtable search no longer clobbers any other search active anywhere in the system. Fix RelationCacheInvalidate() so that it will not crash or go into an infinite loop if invoked recursively, as for example by a second SI Reset message arriving while we are still processing a prior one.
2001-01-02 04:33:24 +00:00
}
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
freeList(rebuildList);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
/*
* RelationCacheAbort
*
* Clean up the relcache at transaction abort.
*
* What we need to do here is reset relcache entry ref counts to
* their normal not-in-a-transaction state. A ref count may be
* too high because some routine was exited by elog() between
* incrementing and decrementing the count.
*
* XXX Maybe we should do this at transaction commit, too, in case
* someone forgets to decrement a refcount in a non-error path?
*/
void
RelationCacheAbort(void)
{
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
HASH_SEQ_STATUS status;
RelNameCacheEnt *namehentry;
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
hash_seq_init(&status, RelationNameCache);
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
while ((namehentry = (RelNameCacheEnt *) hash_seq_search(&status)) != NULL)
{
Relation relation = namehentry->reldesc;
if (relation->rd_isnailed)
RelationSetReferenceCount(relation, 1);
else
RelationSetReferenceCount(relation, 0);
}
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
}
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Further work on connecting the free space map (which is still just a stub) into the rest of the system. Adopt a cleaner approach to preventing deadlock in concurrent heap_updates: allow RelationGetBufferForTuple to select any page of the rel, and put the onus on it to lock both buffers in a consistent order. Remove no-longer-needed isExtend hack from API of ReleaseAndReadBuffer.
2001-06-29 21:08:25 +00:00
* RelationBuildLocalRelation
* Build a relcache entry for an about-to-be-created relation,
* and enter it into the relcache.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
Further work on connecting the free space map (which is still just a stub) into the rest of the system. Adopt a cleaner approach to preventing deadlock in concurrent heap_updates: allow RelationGetBufferForTuple to select any page of the rel, and put the onus on it to lock both buffers in a consistent order. Remove no-longer-needed isExtend hack from API of ReleaseAndReadBuffer.
2001-06-29 21:08:25 +00:00
Relation
RelationBuildLocalRelation(const char *relname,
TupleDesc tupDesc,
Oid relid, Oid dbid,
bool nailit)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
{
Further work on connecting the free space map (which is still just a stub) into the rest of the system. Adopt a cleaner approach to preventing deadlock in concurrent heap_updates: allow RelationGetBufferForTuple to select any page of the rel, and put the onus on it to lock both buffers in a consistent order. Remove no-longer-needed isExtend hack from API of ReleaseAndReadBuffer.
2001-06-29 21:08:25 +00:00
Relation rel;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
MemoryContext oldcxt;
Further work on connecting the free space map (which is still just a stub) into the rest of the system. Adopt a cleaner approach to preventing deadlock in concurrent heap_updates: allow RelationGetBufferForTuple to select any page of the rel, and put the onus on it to lock both buffers in a consistent order. Remove no-longer-needed isExtend hack from API of ReleaseAndReadBuffer.
2001-06-29 21:08:25 +00:00
int natts = tupDesc->natts;
int i;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Further work on connecting the free space map (which is still just a stub) into the rest of the system. Adopt a cleaner approach to preventing deadlock in concurrent heap_updates: allow RelationGetBufferForTuple to select any page of the rel, and put the onus on it to lock both buffers in a consistent order. Remove no-longer-needed isExtend hack from API of ReleaseAndReadBuffer.
2001-06-29 21:08:25 +00:00
AssertArg(natts > 0);
/*
* switch to the cache context to create the relcache entry.
*/
if (!CacheMemoryContext)
CreateCacheMemoryContext();
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
Further work on connecting the free space map (which is still just a stub) into the rest of the system. Adopt a cleaner approach to preventing deadlock in concurrent heap_updates: allow RelationGetBufferForTuple to select any page of the rel, and put the onus on it to lock both buffers in a consistent order. Remove no-longer-needed isExtend hack from API of ReleaseAndReadBuffer.
2001-06-29 21:08:25 +00:00
/*
* allocate a new relation descriptor.
*/
rel = (Relation) palloc(sizeof(RelationData));
MemSet((char *) rel, 0, sizeof(RelationData));
rel->rd_targblock = InvalidBlockNumber;
/* make sure relation is marked as having no open file yet */
rel->rd_fd = -1;
RelationSetReferenceCount(rel, 1);
/*
* nail the reldesc if this is a bootstrap create reln and we may need
* it in the cache later on in the bootstrap process so we don't ever
* want it kicked out. e.g. pg_attribute!!!
*/
if (nailit)
rel->rd_isnailed = true;
/*
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 05:50:21 +00:00
* create a new tuple descriptor from the one passed in (we do this to
* copy it into the cache context)
Further work on connecting the free space map (which is still just a stub) into the rest of the system. Adopt a cleaner approach to preventing deadlock in concurrent heap_updates: allow RelationGetBufferForTuple to select any page of the rel, and put the onus on it to lock both buffers in a consistent order. Remove no-longer-needed isExtend hack from API of ReleaseAndReadBuffer.
2001-06-29 21:08:25 +00:00
*/
rel->rd_att = CreateTupleDescCopyConstr(tupDesc);
/*
* initialize relation tuple form (caller may add/override data later)
*/
rel->rd_rel = (Form_pg_class) palloc(CLASS_TUPLE_SIZE);
MemSet((char *) rel->rd_rel, 0, CLASS_TUPLE_SIZE);
strcpy(RelationGetPhysicalRelationName(rel), relname);
rel->rd_rel->relkind = RELKIND_UNCATALOGED;
Make OIDs optional, per discussions in pghackers. WITH OIDS is still the default, but OIDS are removed from many system catalogs that don't need them. Some interesting side effects: TOAST pointers are 20 bytes not 32 now; pg_description has a three-column key instead of one. Bugs fixed in passing: BINARY cursors work again; pg_class.relhaspkey has some usefulness; pg_dump dumps comments on indexes, rules, and triggers in a valid order. initdb forced.
2001-08-10 18:57:42 +00:00
rel->rd_rel->relhasoids = true;
Further work on connecting the free space map (which is still just a stub) into the rest of the system. Adopt a cleaner approach to preventing deadlock in concurrent heap_updates: allow RelationGetBufferForTuple to select any page of the rel, and put the onus on it to lock both buffers in a consistent order. Remove no-longer-needed isExtend hack from API of ReleaseAndReadBuffer.
2001-06-29 21:08:25 +00:00
rel->rd_rel->relnatts = natts;
rel->rd_rel->reltype = InvalidOid;
if (tupDesc->constr)
rel->rd_rel->relchecks = tupDesc->constr->num_check;
/*
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 05:50:21 +00:00
* Insert relation OID and database/tablespace ID into the right
* places. XXX currently we assume physical tblspace/relnode are same
* as logical dbid/reloid. Probably should pass an extra pair of
* parameters.
Further work on connecting the free space map (which is still just a stub) into the rest of the system. Adopt a cleaner approach to preventing deadlock in concurrent heap_updates: allow RelationGetBufferForTuple to select any page of the rel, and put the onus on it to lock both buffers in a consistent order. Remove no-longer-needed isExtend hack from API of ReleaseAndReadBuffer.
2001-06-29 21:08:25 +00:00
*/
rel->rd_rel->relisshared = (dbid == InvalidOid);
RelationGetRelid(rel) = relid;
for (i = 0; i < natts; i++)
rel->rd_att->attrs[i]->attrelid = relid;
RelationInitLockInfo(rel); /* see lmgr.c */
rel->rd_node.tblNode = dbid;
rel->rd_node.relNode = relid;
rel->rd_rel->relfilenode = relid;
/*
* Okay to insert into the relcache hash tables.
*/
RelationCacheInsert(rel);
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
/*
* we've just created the relation. It is invisible to anyone else
pgindent run over code.
1999-05-25 16:15:34 +00:00
* before the transaction is committed. Setting rd_myxactonly allows
* us to use the local buffer manager for select/insert/etc before the
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* end of transaction. (We also need to keep track of relations
Further work on connecting the free space map (which is still just a stub) into the rest of the system. Adopt a cleaner approach to preventing deadlock in concurrent heap_updates: allow RelationGetBufferForTuple to select any page of the rel, and put the onus on it to lock both buffers in a consistent order. Remove no-longer-needed isExtend hack from API of ReleaseAndReadBuffer.
2001-06-29 21:08:25 +00:00
* created during a transaction and do the necessary clean up at the
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* end of the transaction.) - ay 3/95
*/
Further work on connecting the free space map (which is still just a stub) into the rest of the system. Adopt a cleaner approach to preventing deadlock in concurrent heap_updates: allow RelationGetBufferForTuple to select any page of the rel, and put the onus on it to lock both buffers in a consistent order. Remove no-longer-needed isExtend hack from API of ReleaseAndReadBuffer.
2001-06-29 21:08:25 +00:00
rel->rd_myxactonly = true;
newlyCreatedRelns = lcons(rel, newlyCreatedRelns);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Further work on connecting the free space map (which is still just a stub) into the rest of the system. Adopt a cleaner approach to preventing deadlock in concurrent heap_updates: allow RelationGetBufferForTuple to select any page of the rel, and put the onus on it to lock both buffers in a consistent order. Remove no-longer-needed isExtend hack from API of ReleaseAndReadBuffer.
2001-06-29 21:08:25 +00:00
/*
* done building relcache entry.
*/
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
MemoryContextSwitchTo(oldcxt);
Further work on connecting the free space map (which is still just a stub) into the rest of the system. Adopt a cleaner approach to preventing deadlock in concurrent heap_updates: allow RelationGetBufferForTuple to select any page of the rel, and put the onus on it to lock both buffers in a consistent order. Remove no-longer-needed isExtend hack from API of ReleaseAndReadBuffer.
2001-06-29 21:08:25 +00:00
return rel;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
/*
* RelationPurgeLocalRelation -
Add TEMP tables/indexes. Add COPY pfree(). Other cleanups.
1999-02-02 03:45:56 +00:00
* find all the Relation descriptors marked rd_myxactonly and reset them.
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* This should be called at the end of a transaction (commit/abort) when
* the "local" relations will become visible to others and the multi-user
* buffer pool should be used.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
void
RelationPurgeLocalRelation(bool xactCommitted)
{
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
while (newlyCreatedRelns)
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
List *l = newlyCreatedRelns;
Relation reln = lfirst(l);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Further work on connecting the free space map (which is still just a stub) into the rest of the system. Adopt a cleaner approach to preventing deadlock in concurrent heap_updates: allow RelationGetBufferForTuple to select any page of the rel, and put the onus on it to lock both buffers in a consistent order. Remove no-longer-needed isExtend hack from API of ReleaseAndReadBuffer.
2001-06-29 21:08:25 +00:00
newlyCreatedRelns = lnext(newlyCreatedRelns);
pfree(l);
Add TEMP tables/indexes. Add COPY pfree(). Other cleanups.
1999-02-02 03:45:56 +00:00
Assert(reln != NULL && reln->rd_myxactonly);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
reln->rd_myxactonly = false; /* mark it not on list anymore */
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
Further work on connecting the free space map (which is still just a stub) into the rest of the system. Adopt a cleaner approach to preventing deadlock in concurrent heap_updates: allow RelationGetBufferForTuple to select any page of the rel, and put the onus on it to lock both buffers in a consistent order. Remove no-longer-needed isExtend hack from API of ReleaseAndReadBuffer.
2001-06-29 21:08:25 +00:00
/*
* XXX while we clearly must throw out new Relation entries at
* xact abort, it's not clear why we need to do it at commit.
* Could this be improved?
*/
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
if (!IsBootstrapProcessingMode())
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
RelationClearRelation(reln, false);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
}
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Toast all the system-table columns that seem to need it. It turns out that giving pg_proc a toast table required solving the same problems we'd have to solve for pg_class --- pg_proc is one of the relations that gets bootstrapped in relcache.c. Solution is to go back at the end of initialization and read in the *real* pg_class row to replace the phony entry created by formrdesc(). This should work as long as there's no need to touch any toasted values during initialization, which seems a reasonable assumption. Although I did not add a toast-table for every single system table with a varlena attribute, I believe that it would work to just do ALTER TABLE pg_class CREATE TOAST TABLE. So anyone who's really intent on having several thousand ACL entries for a rel could do it. NOTE: I didn't force initdb, but you must do one to see the effects of this patch.
2000-08-06 04:40:08 +00:00
* RelationCacheInitialize
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* This initializes the relation descriptor cache.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
#define INITRELCACHESIZE 400
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
void
Toast all the system-table columns that seem to need it. It turns out that giving pg_proc a toast table required solving the same problems we'd have to solve for pg_class --- pg_proc is one of the relations that gets bootstrapped in relcache.c. Solution is to go back at the end of initialization and read in the *real* pg_class row to replace the phony entry created by formrdesc(). This should work as long as there's no need to touch any toasted values during initialization, which seems a reasonable assumption. Although I did not add a toast-table for every single system table with a varlena attribute, I believe that it would work to just do ALTER TABLE pg_class CREATE TOAST TABLE. So anyone who's really intent on having several thousand ACL entries for a rel could do it. NOTE: I didn't force initdb, but you must do one to see the effects of this patch.
2000-08-06 04:40:08 +00:00
RelationCacheInitialize(void)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
MemoryContext oldcxt;
HASHCTL ctl;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* switch to cache memory context
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
First phase of memory management rewrite (see backend/utils/mmgr/README for details). It doesn't really do that much yet, since there are no short-term memory contexts in the executor, but the infrastructure is in place and long-term contexts are handled reasonably. A few long- standing bugs have been fixed, such as 'VACUUM; anything' in a single query string crashing. Also, out-of-memory is now considered a recoverable ERROR, not FATAL. Eliminate a large amount of crufty, now-dead code in and around memory management. Fix problem with holding off SIGTRAP, SIGSEGV, etc in postmaster and backend startup.
2000-06-28 03:33:33 +00:00
if (!CacheMemoryContext)
CreateCacheMemoryContext();
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
First phase of memory management rewrite (see backend/utils/mmgr/README for details). It doesn't really do that much yet, since there are no short-term memory contexts in the executor, but the infrastructure is in place and long-term contexts are handled reasonably. A few long- standing bugs have been fixed, such as 'VACUUM; anything' in a single query string crashing. Also, out-of-memory is now considered a recoverable ERROR, not FATAL. Eliminate a large amount of crufty, now-dead code in and around memory management. Fix problem with holding off SIGTRAP, SIGSEGV, etc in postmaster and backend startup.
2000-06-28 03:33:33 +00:00
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* create global caches
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Another round of cleanups for dynahash.c (maybe it's finally clean of portability issues). Caller-visible data structures are now allocated on MAXALIGN boundaries, allowing safe use of datatypes wider than 'long'. Rejigger hash_create API so that caller specifies size of key and total size of entry, not size of key and size of rest of entry. This simplifies life considerably since each number is just a sizeof(), and padding issues etc. are taken care of automatically.
2001-10-01 05:36:17 +00:00
MemSet(&ctl, 0, sizeof(ctl));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
ctl.keysize = sizeof(NameData);
Another round of cleanups for dynahash.c (maybe it's finally clean of portability issues). Caller-visible data structures are now allocated on MAXALIGN boundaries, allowing safe use of datatypes wider than 'long'. Rejigger hash_create API so that caller specifies size of key and total size of entry, not size of key and size of rest of entry. This simplifies life considerably since each number is just a sizeof(), and padding issues etc. are taken care of automatically.
2001-10-01 05:36:17 +00:00
ctl.entrysize = sizeof(RelNameCacheEnt);
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
RelationNameCache = hash_create("Relcache by name", INITRELCACHESIZE,
&ctl, HASH_ELEM);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
ctl.keysize = sizeof(Oid);
Another round of cleanups for dynahash.c (maybe it's finally clean of portability issues). Caller-visible data structures are now allocated on MAXALIGN boundaries, allowing safe use of datatypes wider than 'long'. Rejigger hash_create API so that caller specifies size of key and total size of entry, not size of key and size of rest of entry. This simplifies life considerably since each number is just a sizeof(), and padding issues etc. are taken care of automatically.
2001-10-01 05:36:17 +00:00
ctl.entrysize = sizeof(RelIdCacheEnt);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
ctl.hash = tag_hash;
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
RelationIdCache = hash_create("Relcache by OID", INITRELCACHESIZE,
&ctl, HASH_ELEM | HASH_FUNCTION);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
ctl.keysize = sizeof(RelFileNode);
Another round of cleanups for dynahash.c (maybe it's finally clean of portability issues). Caller-visible data structures are now allocated on MAXALIGN boundaries, allowing safe use of datatypes wider than 'long'. Rejigger hash_create API so that caller specifies size of key and total size of entry, not size of key and size of rest of entry. This simplifies life considerably since each number is just a sizeof(), and padding issues etc. are taken care of automatically.
2001-10-01 05:36:17 +00:00
ctl.entrysize = sizeof(RelNodeCacheEnt);
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
ctl.hash = tag_hash;
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
RelationNodeCache = hash_create("Relcache by rnode", INITRELCACHESIZE,
&ctl, HASH_ELEM | HASH_FUNCTION);
New relcache hash table with RelFileNode as key to be used from bufmgr - it would be nice to have separate hash in smgr for node <--> fd mappings, but for the moment it's easy to add new hash to relcache. Fixed small bug in xlog.c:ReadRecord.
2000-10-23 04:10:24 +00:00
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* initialize the cache with pre-made relation descriptors for some of
* the more important system relations. These relations should always
* be in the cache.
Toast all the system-table columns that seem to need it. It turns out that giving pg_proc a toast table required solving the same problems we'd have to solve for pg_class --- pg_proc is one of the relations that gets bootstrapped in relcache.c. Solution is to go back at the end of initialization and read in the *real* pg_class row to replace the phony entry created by formrdesc(). This should work as long as there's no need to touch any toasted values during initialization, which seems a reasonable assumption. Although I did not add a toast-table for every single system table with a varlena attribute, I believe that it would work to just do ALTER TABLE pg_class CREATE TOAST TABLE. So anyone who's really intent on having several thousand ACL entries for a rel could do it. NOTE: I didn't force initdb, but you must do one to see the effects of this patch.
2000-08-06 04:40:08 +00:00
*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* NB: see also the list in RelationCacheInitializePhase2().
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
formrdesc(RelationRelationName, Natts_pg_class, Desc_pg_class);
formrdesc(AttributeRelationName, Natts_pg_attribute, Desc_pg_attribute);
formrdesc(ProcedureRelationName, Natts_pg_proc, Desc_pg_proc);
formrdesc(TypeRelationName, Natts_pg_type, Desc_pg_type);
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* init_irels() used to be called here. It is changed to be called in
* RelationCacheInitializePhase2() now so that transactional control
* could guarantee the consistency.
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
MemoryContextSwitchTo(oldcxt);
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Change /*---- commants to /* where appropriate. pgindent will tighten up the comments later.
2001-02-22 18:39:20 +00:00
/*
Toast all the system-table columns that seem to need it. It turns out that giving pg_proc a toast table required solving the same problems we'd have to solve for pg_class --- pg_proc is one of the relations that gets bootstrapped in relcache.c. Solution is to go back at the end of initialization and read in the *real* pg_class row to replace the phony entry created by formrdesc(). This should work as long as there's no need to touch any toasted values during initialization, which seems a reasonable assumption. Although I did not add a toast-table for every single system table with a varlena attribute, I believe that it would work to just do ALTER TABLE pg_class CREATE TOAST TABLE. So anyone who's really intent on having several thousand ACL entries for a rel could do it. NOTE: I didn't force initdb, but you must do one to see the effects of this patch.
2000-08-06 04:40:08 +00:00
* RelationCacheInitializePhase2
*
* This completes initialization of the relcache after catcache
* is functional and we are able to actually load data from pg_class.
*/
void
RelationCacheInitializePhase2(void)
{
/*
* Get the real pg_class tuple for each nailed-in-cache relcache entry
* that was made by RelationCacheInitialize(), and replace the phony
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* rd_rel entry made by formrdesc(). This is necessary so that we
* have, for example, the correct toast-table info for tables that
* have such.
Toast all the system-table columns that seem to need it. It turns out that giving pg_proc a toast table required solving the same problems we'd have to solve for pg_class --- pg_proc is one of the relations that gets bootstrapped in relcache.c. Solution is to go back at the end of initialization and read in the *real* pg_class row to replace the phony entry created by formrdesc(). This should work as long as there's no need to touch any toasted values during initialization, which seems a reasonable assumption. Although I did not add a toast-table for every single system table with a varlena attribute, I believe that it would work to just do ALTER TABLE pg_class CREATE TOAST TABLE. So anyone who's really intent on having several thousand ACL entries for a rel could do it. NOTE: I didn't force initdb, but you must do one to see the effects of this patch.
2000-08-06 04:40:08 +00:00
*/
if (!IsBootstrapProcessingMode())
{
init_irels() is changed to be called in RelationCacheInitializePhase2() so that transactional control could guarantee the consistency.
2001-01-06 01:48:59 +00:00
/*
* Initialize critical system index relation descriptors, first.
* They are to make building relation descriptors fast.
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* init_irels() used to be called in RelationCacheInitialize(). It
* is changed to be called here to be transaction safe.
init_irels() is changed to be called in RelationCacheInitializePhase2() so that transactional control could guarantee the consistency.
2001-01-06 01:48:59 +00:00
*/
MemoryContext oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
init_irels() is changed to be called in RelationCacheInitializePhase2() so that transactional control could guarantee the consistency.
2001-01-06 01:48:59 +00:00
init_irels();
MemoryContextSwitchTo(oldcxt);
/* fix nailed-in-cache relations */
Toast all the system-table columns that seem to need it. It turns out that giving pg_proc a toast table required solving the same problems we'd have to solve for pg_class --- pg_proc is one of the relations that gets bootstrapped in relcache.c. Solution is to go back at the end of initialization and read in the *real* pg_class row to replace the phony entry created by formrdesc(). This should work as long as there's no need to touch any toasted values during initialization, which seems a reasonable assumption. Although I did not add a toast-table for every single system table with a varlena attribute, I believe that it would work to just do ALTER TABLE pg_class CREATE TOAST TABLE. So anyone who's really intent on having several thousand ACL entries for a rel could do it. NOTE: I didn't force initdb, but you must do one to see the effects of this patch.
2000-08-06 04:40:08 +00:00
fixrdesc(RelationRelationName);
fixrdesc(AttributeRelationName);
fixrdesc(ProcedureRelationName);
fixrdesc(TypeRelationName);
}
}
No more #ifdef XLOG.
2000-11-30 08:46:26 +00:00
/* used by XLogInitCache */
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
void CreateDummyCaches(void);
void DestroyDummyCaches(void);
WAL
2000-10-28 16:21:00 +00:00
void
CreateDummyCaches(void)
{
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
MemoryContext oldcxt;
HASHCTL ctl;
WAL
2000-10-28 16:21:00 +00:00
if (!CacheMemoryContext)
CreateCacheMemoryContext();
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
Another round of cleanups for dynahash.c (maybe it's finally clean of portability issues). Caller-visible data structures are now allocated on MAXALIGN boundaries, allowing safe use of datatypes wider than 'long'. Rejigger hash_create API so that caller specifies size of key and total size of entry, not size of key and size of rest of entry. This simplifies life considerably since each number is just a sizeof(), and padding issues etc. are taken care of automatically.
2001-10-01 05:36:17 +00:00
MemSet(&ctl, 0, sizeof(ctl));
WAL
2000-10-28 16:21:00 +00:00
ctl.keysize = sizeof(NameData);
Another round of cleanups for dynahash.c (maybe it's finally clean of portability issues). Caller-visible data structures are now allocated on MAXALIGN boundaries, allowing safe use of datatypes wider than 'long'. Rejigger hash_create API so that caller specifies size of key and total size of entry, not size of key and size of rest of entry. This simplifies life considerably since each number is just a sizeof(), and padding issues etc. are taken care of automatically.
2001-10-01 05:36:17 +00:00
ctl.entrysize = sizeof(RelNameCacheEnt);
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
RelationNameCache = hash_create("Relcache by name", INITRELCACHESIZE,
&ctl, HASH_ELEM);
WAL
2000-10-28 16:21:00 +00:00
ctl.keysize = sizeof(Oid);
Another round of cleanups for dynahash.c (maybe it's finally clean of portability issues). Caller-visible data structures are now allocated on MAXALIGN boundaries, allowing safe use of datatypes wider than 'long'. Rejigger hash_create API so that caller specifies size of key and total size of entry, not size of key and size of rest of entry. This simplifies life considerably since each number is just a sizeof(), and padding issues etc. are taken care of automatically.
2001-10-01 05:36:17 +00:00
ctl.entrysize = sizeof(RelIdCacheEnt);
WAL
2000-10-28 16:21:00 +00:00
ctl.hash = tag_hash;
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
RelationIdCache = hash_create("Relcache by OID", INITRELCACHESIZE,
&ctl, HASH_ELEM | HASH_FUNCTION);
WAL
2000-10-28 16:21:00 +00:00
ctl.keysize = sizeof(RelFileNode);
Another round of cleanups for dynahash.c (maybe it's finally clean of portability issues). Caller-visible data structures are now allocated on MAXALIGN boundaries, allowing safe use of datatypes wider than 'long'. Rejigger hash_create API so that caller specifies size of key and total size of entry, not size of key and size of rest of entry. This simplifies life considerably since each number is just a sizeof(), and padding issues etc. are taken care of automatically.
2001-10-01 05:36:17 +00:00
ctl.entrysize = sizeof(RelNodeCacheEnt);
WAL
2000-10-28 16:21:00 +00:00
ctl.hash = tag_hash;
Further cleanup of dynahash.c API, in pursuit of portability and readability. Bizarre '(long *) TRUE' return convention is gone, in favor of just raising an error internally in dynahash.c when we detect hashtable corruption. HashTableWalk is gone, in favor of using hash_seq_search directly, since it had no hope of working with non-LONGALIGNable datatypes. Simplify some other code that was made undesirably grotty by promixity to HashTableWalk.
2001-10-05 17:28:13 +00:00
RelationNodeCache = hash_create("Relcache by rnode", INITRELCACHESIZE,
&ctl, HASH_ELEM | HASH_FUNCTION);
WAL
2000-10-28 16:21:00 +00:00
MemoryContextSwitchTo(oldcxt);
}
void
DestroyDummyCaches(void)
{
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
MemoryContext oldcxt;
WAL
2000-10-28 16:21:00 +00:00
if (!CacheMemoryContext)
return;
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
if (RelationNameCache)
hash_destroy(RelationNameCache);
if (RelationIdCache)
hash_destroy(RelationIdCache);
if (RelationNodeCache)
hash_destroy(RelationNodeCache);
RelationNameCache = RelationIdCache = RelationNodeCache = NULL;
MemoryContextSwitchTo(oldcxt);
}
Read info for DEFAULT from pg_attrdef.
1997-08-21 01:36:09 +00:00
static void
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
AttrDefaultFetch(Relation relation)
Read info for DEFAULT from pg_attrdef.
1997-08-21 01:36:09 +00:00
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
AttrDefault *attrdef = relation->rd_att->constr->defval;
int ndef = relation->rd_att->constr->num_defval;
Relation adrel;
Implement reindex command
2000-02-18 09:30:20 +00:00
Relation irel = (Relation) NULL;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
ScanKeyData skey;
pgindent run over code.
1999-05-25 16:15:34 +00:00
HeapTupleData tuple;
Implement reindex command
2000-02-18 09:30:20 +00:00
HeapTuple htup;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Form_pg_attrdef adform;
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
IndexScanDesc sd = (IndexScanDesc) NULL;
HeapScanDesc adscan = (HeapScanDesc) NULL;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
RetrieveIndexResult indexRes;
Update textin() and textout() to new fmgr style. This is just phase one of updating the whole text datatype, but there are so dang many calls of these two routines that it seems worth a separate commit.
2000-07-05 23:12:09 +00:00
Datum val;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
bool isnull;
int found;
int i;
Implement reindex command
2000-02-18 09:30:20 +00:00
bool hasindex;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
ScanKeyEntryInitialize(&skey,
(bits16) 0x0,
(AttrNumber) 1,
This patch... 1. Removes the unnecessary "#define AbcRegProcedure 123"'s from pg_proc.h. 2. Changes those #defines to use the names already defined in fmgr.h. 3. Forces the make of fmgr.h in backend/Makefile instead of having it made as a dependency in access/common/Makefile *hack*hack*hack* 4. Rearranged the #includes to a less helter-skelter arrangement, also changing <file.h> to "file.h" to signify a non-system header. 5. Removed "pg_proc.h" from files where its only purpose was for the #defines removed in item #1. 6. Added "fmgr.h" to each file changed for completeness sake. Turns out that #6 was not necessary for some files because fmgr.h was being included in a roundabout way SIX levels deep by the first include. "access/genam.h" ->"access/relscan.h" ->"utils/rel.h" ->"access/strat.h" ->"access/skey.h" ->"fmgr.h" So adding fmgr.h really didn't add anything to the compile, hopefully just made it clearer to the programmer. S Darren.
1998-04-27 04:08:07 +00:00
(RegProcedure) F_OIDEQ,
heap_fetch requires buffer pointer, must be released; heap_getnext no longer returns buffer pointer, can be gotten from scan; descriptor; bootstrap can create multi-key indexes; pg_procname index now is multi-key index; oidint2, oidint4, oidname are gone (must be removed from regression tests); use System Cache rather than sequential scan in many places; heap_modifytuple no longer takes buffer parameter; remove unused buffer parameter in a few other functions; oid8 is not index-able; remove some use of single-character variable names; cleanup Buffer variables usage and scan descriptor looping; cleaned up allocation and freeing of tuples; 18k lines of diff;
1998-08-19 02:04:17 +00:00
ObjectIdGetDatum(RelationGetRelid(relation)));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
adrel = heap_openr(AttrDefaultRelationName, AccessShareLock);
Implement reindex command
2000-02-18 09:30:20 +00:00
hasindex = (adrel->rd_rel->relhasindex && !IsIgnoringSystemIndexes());
if (hasindex)
{
irel = index_openr(AttrDefaultIndex);
sd = index_beginscan(irel, false, 1, &skey);
}
else
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
adscan = heap_beginscan(adrel, false, SnapshotNow, 1, &skey);
Some changes to prepare for LONG attributes. Jan
1999-12-16 22:20:03 +00:00
tuple.t_datamcxt = NULL;
New HeapTuple structure/interface.
1998-11-27 19:52:36 +00:00
tuple.t_data = NULL;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
for (found = 0;;)
{
OK, folks, here is the pgindent output.
1998-09-01 04:40:42 +00:00
Buffer buffer;
Implement reindex command
2000-02-18 09:30:20 +00:00
if (hasindex)
{
indexRes = index_getnext(sd, ForwardScanDirection);
if (!indexRes)
break;
tuple.t_self = indexRes->heap_iptr;
Statistical system views (yet without the config stuff, but it's hard to keep such massive changes in sync with the tree so I need to get it in and work from there now). Jan
2001-06-22 19:16:24 +00:00
heap_fetch(adrel, SnapshotNow, &tuple, &buffer, sd);
Implement reindex command
2000-02-18 09:30:20 +00:00
pfree(indexRes);
if (tuple.t_data == NULL)
continue;
htup = &tuple;
}
else
{
htup = heap_getnext(adscan, 0);
if (!HeapTupleIsValid(htup))
break;
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
found++;
Implement reindex command
2000-02-18 09:30:20 +00:00
adform = (Form_pg_attrdef) GETSTRUCT(htup);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
for (i = 0; i < ndef; i++)
{
if (adform->adnum != attrdef[i].adnum)
continue;
Reimplement parsing and storage of default expressions and constraint expressions in CREATE TABLE. There is no longer an emasculated expression syntax for these things; it's full a_expr for constraints, and b_expr for defaults (unfortunately the fact that NOT NULL is a part of the column constraint syntax causes a shift/reduce conflict if you try a_expr. Oh well --- at least parenthesized boolean expressions work now). Also, stored expression for a column default is not pre-coerced to the column type; we rely on transformInsertStatement to do that when the default is actually used. This means "f1 datetime default 'now'" behaves the way people usually expect it to. BTW, all the support code is now there to implement ALTER TABLE ADD CONSTRAINT and ALTER TABLE ADD COLUMN with a default value. I didn't actually teach ALTER TABLE to call it, but it wouldn't be much work.
1999-10-03 23:55:40 +00:00
if (attrdef[i].adbin != NULL)
added ALTER TABLE DROP COLUMN, early version
2000-01-22 14:20:56 +00:00
elog(NOTICE, "AttrDefaultFetch: second record found for attr %s in rel %s",
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
NameStr(relation->rd_att->attrs[adform->adnum - 1]->attname),
New NameStr macro to convert Name to Str. No need for var.data anymore. Fewer calls to nameout. Better use of RelationGetRelationName.
1999-11-07 23:08:36 +00:00
RelationGetRelationName(relation));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Update textin() and textout() to new fmgr style. This is just phase one of updating the whole text datatype, but there are so dang many calls of these two routines that it seems worth a separate commit.
2000-07-05 23:12:09 +00:00
val = fastgetattr(htup,
Anum_pg_attrdef_adbin,
adrel->rd_att, &isnull);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
if (isnull)
added ALTER TABLE DROP COLUMN, early version
2000-01-22 14:20:56 +00:00
elog(NOTICE, "AttrDefaultFetch: adbin IS NULL for attr %s in rel %s",
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
NameStr(relation->rd_att->attrs[adform->adnum - 1]->attname),
New NameStr macro to convert Name to Str. No need for var.data anymore. Fewer calls to nameout. Better use of RelationGetRelationName.
1999-11-07 23:08:36 +00:00
RelationGetRelationName(relation));
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
else
attrdef[i].adbin = MemoryContextStrdup(CacheMemoryContext,
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
DatumGetCString(DirectFunctionCall1(textout,
val)));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
break;
}
Implement reindex command
2000-02-18 09:30:20 +00:00
if (hasindex)
ReleaseBuffer(buffer);
OK, folks, here is the pgindent output.
1998-09-01 04:40:42 +00:00
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
if (i >= ndef)
added ALTER TABLE DROP COLUMN, early version
2000-01-22 14:20:56 +00:00
elog(NOTICE, "AttrDefaultFetch: unexpected record found for attr %d in rel %s",
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
adform->adnum,
New NameStr macro to convert Name to Str. No need for var.data anymore. Fewer calls to nameout. Better use of RelationGetRelationName.
1999-11-07 23:08:36 +00:00
RelationGetRelationName(relation));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
}
if (found < ndef)
added ALTER TABLE DROP COLUMN, early version
2000-01-22 14:20:56 +00:00
elog(NOTICE, "AttrDefaultFetch: %d record not found for rel %s",
New NameStr macro to convert Name to Str. No need for var.data anymore. Fewer calls to nameout. Better use of RelationGetRelationName.
1999-11-07 23:08:36 +00:00
ndef - found, RelationGetRelationName(relation));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Implement reindex command
2000-02-18 09:30:20 +00:00
if (hasindex)
{
index_endscan(sd);
index_close(irel);
}
else
heap_endscan(adscan);
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
heap_close(adrel, AccessShareLock);
Read info for DEFAULT from pg_attrdef.
1997-08-21 01:36:09 +00:00
}
Fetch information about DEFAULT/CHECK while openning a relation.
1997-08-22 03:35:44 +00:00
static void
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
RelCheckFetch(Relation relation)
Fetch information about DEFAULT/CHECK while openning a relation.
1997-08-22 03:35:44 +00:00
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
ConstrCheck *check = relation->rd_att->constr->check;
int ncheck = relation->rd_att->constr->num_check;
Relation rcrel;
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
Relation irel = (Relation) NULL;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
ScanKeyData skey;
pgindent run over code.
1999-05-25 16:15:34 +00:00
HeapTupleData tuple;
Implement reindex command
2000-02-18 09:30:20 +00:00
HeapTuple htup;
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
IndexScanDesc sd = (IndexScanDesc) NULL;
HeapScanDesc rcscan = (HeapScanDesc) NULL;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
RetrieveIndexResult indexRes;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
Name rcname;
Update textin() and textout() to new fmgr style. This is just phase one of updating the whole text datatype, but there are so dang many calls of these two routines that it seems worth a separate commit.
2000-07-05 23:12:09 +00:00
Datum val;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
bool isnull;
int found;
Implement reindex command
2000-02-18 09:30:20 +00:00
bool hasindex;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
ScanKeyEntryInitialize(&skey,
(bits16) 0x0,
(AttrNumber) 1,
This patch... 1. Removes the unnecessary "#define AbcRegProcedure 123"'s from pg_proc.h. 2. Changes those #defines to use the names already defined in fmgr.h. 3. Forces the make of fmgr.h in backend/Makefile instead of having it made as a dependency in access/common/Makefile *hack*hack*hack* 4. Rearranged the #includes to a less helter-skelter arrangement, also changing <file.h> to "file.h" to signify a non-system header. 5. Removed "pg_proc.h" from files where its only purpose was for the #defines removed in item #1. 6. Added "fmgr.h" to each file changed for completeness sake. Turns out that #6 was not necessary for some files because fmgr.h was being included in a roundabout way SIX levels deep by the first include. "access/genam.h" ->"access/relscan.h" ->"utils/rel.h" ->"access/strat.h" ->"access/skey.h" ->"fmgr.h" So adding fmgr.h really didn't add anything to the compile, hopefully just made it clearer to the programmer. S Darren.
1998-04-27 04:08:07 +00:00
(RegProcedure) F_OIDEQ,
heap_fetch requires buffer pointer, must be released; heap_getnext no longer returns buffer pointer, can be gotten from scan; descriptor; bootstrap can create multi-key indexes; pg_procname index now is multi-key index; oidint2, oidint4, oidname are gone (must be removed from regression tests); use System Cache rather than sequential scan in many places; heap_modifytuple no longer takes buffer parameter; remove unused buffer parameter in a few other functions; oid8 is not index-able; remove some use of single-character variable names; cleanup Buffer variables usage and scan descriptor looping; cleaned up allocation and freeing of tuples; 18k lines of diff;
1998-08-19 02:04:17 +00:00
ObjectIdGetDatum(RelationGetRelid(relation)));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
rcrel = heap_openr(RelCheckRelationName, AccessShareLock);
Implement reindex command
2000-02-18 09:30:20 +00:00
hasindex = (rcrel->rd_rel->relhasindex && !IsIgnoringSystemIndexes());
if (hasindex)
{
irel = index_openr(RelCheckIndex);
sd = index_beginscan(irel, false, 1, &skey);
}
else
rcscan = heap_beginscan(rcrel, false, SnapshotNow, 1, &skey);
Some changes to prepare for LONG attributes. Jan
1999-12-16 22:20:03 +00:00
tuple.t_datamcxt = NULL;
New HeapTuple structure/interface.
1998-11-27 19:52:36 +00:00
tuple.t_data = NULL;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
for (found = 0;;)
{
OK, folks, here is the pgindent output.
1998-09-01 04:40:42 +00:00
Buffer buffer;
Implement reindex command
2000-02-18 09:30:20 +00:00
if (hasindex)
{
indexRes = index_getnext(sd, ForwardScanDirection);
if (!indexRes)
break;
tuple.t_self = indexRes->heap_iptr;
Statistical system views (yet without the config stuff, but it's hard to keep such massive changes in sync with the tree so I need to get it in and work from there now). Jan
2001-06-22 19:16:24 +00:00
heap_fetch(rcrel, SnapshotNow, &tuple, &buffer, sd);
Implement reindex command
2000-02-18 09:30:20 +00:00
pfree(indexRes);
if (tuple.t_data == NULL)
continue;
htup = &tuple;
}
else
{
htup = heap_getnext(rcscan, 0);
if (!HeapTupleIsValid(htup))
break;
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
if (found == ncheck)
Cleanup Name usage.
1998-07-20 16:14:18 +00:00
elog(ERROR, "RelCheckFetch: unexpected record found for rel %s",
New NameStr macro to convert Name to Str. No need for var.data anymore. Fewer calls to nameout. Better use of RelationGetRelationName.
1999-11-07 23:08:36 +00:00
RelationGetRelationName(relation));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Implement reindex command
2000-02-18 09:30:20 +00:00
rcname = (Name) fastgetattr(htup,
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Anum_pg_relcheck_rcname,
rcrel->rd_att, &isnull);
if (isnull)
Cleanup Name usage.
1998-07-20 16:14:18 +00:00
elog(ERROR, "RelCheckFetch: rcname IS NULL for rel %s",
New NameStr macro to convert Name to Str. No need for var.data anymore. Fewer calls to nameout. Better use of RelationGetRelationName.
1999-11-07 23:08:36 +00:00
RelationGetRelationName(relation));
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
check[found].ccname = MemoryContextStrdup(CacheMemoryContext,
NameStr(*rcname));
Update textin() and textout() to new fmgr style. This is just phase one of updating the whole text datatype, but there are so dang many calls of these two routines that it seems worth a separate commit.
2000-07-05 23:12:09 +00:00
val = fastgetattr(htup,
Anum_pg_relcheck_rcbin,
rcrel->rd_att, &isnull);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
if (isnull)
Cleanup Name usage.
1998-07-20 16:14:18 +00:00
elog(ERROR, "RelCheckFetch: rcbin IS NULL for rel %s",
New NameStr macro to convert Name to Str. No need for var.data anymore. Fewer calls to nameout. Better use of RelationGetRelationName.
1999-11-07 23:08:36 +00:00
RelationGetRelationName(relation));
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
check[found].ccbin = MemoryContextStrdup(CacheMemoryContext,
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
DatumGetCString(DirectFunctionCall1(textout,
val)));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
found++;
Implement reindex command
2000-02-18 09:30:20 +00:00
if (hasindex)
ReleaseBuffer(buffer);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
}
if (found < ncheck)
Cleanup Name usage.
1998-07-20 16:14:18 +00:00
elog(ERROR, "RelCheckFetch: %d record not found for rel %s",
Fix problem with temp tables shown in regression test by Jan.
1999-11-17 23:51:21 +00:00
ncheck - found, RelationGetRelationName(relation));
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Implement reindex command
2000-02-18 09:30:20 +00:00
if (hasindex)
{
index_endscan(sd);
index_close(irel);
}
else
heap_endscan(rcscan);
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
heap_close(rcrel, AccessShareLock);
Fetch information about DEFAULT/CHECK while openning a relation.
1997-08-22 03:35:44 +00:00
}
Fix performance problems with pg_index lookups (see, for example, discussion of 5/19/00). pg_index is now searched for indexes of a relation using an indexscan. Moreover, this is done once and cached in the relcache entry for the relation, in the form of a list of OIDs for the indexes. This list is used by the parser and executor to drive lookups in the pg_index syscache when they want to know the properties of the indexes. Net result: index information will be fully cached for repetitive operations such as inserts.
2000-06-17 21:49:04 +00:00
/*
* RelationGetIndexList -- get a list of OIDs of indexes on this relation
*
* The index list is created only if someone requests it. We scan pg_index
* to find relevant indexes, and add the list to the relcache entry so that
* we won't have to compute it again. Note that shared cache inval of a
* relcache entry will delete the old list and set rd_indexfound to false,
* so that we must recompute the index list on next request. This handles
* creation or deletion of an index.
*
Modify index-opening code to guarantee that the indexes of a relation are opened in a consistent order by different backends (I ordered them by index OID because that's easy, but any other consistent order would do as well). This avoids potential deadlock for index types that we acquire exclusive locks on ... ie, rtree.
2000-06-19 23:40:48 +00:00
* The returned list is guaranteed to be sorted in order by OID. This is
* needed by the executor, since for index types that we obtain exclusive
* locks on when updating the index, all backends must lock the indexes in
* the same order or we will get deadlocks (see ExecOpenIndices()). Any
* consistent ordering would do, but ordering by OID is easy.
*
Fix performance problems with pg_index lookups (see, for example, discussion of 5/19/00). pg_index is now searched for indexes of a relation using an indexscan. Moreover, this is done once and cached in the relcache entry for the relation, in the form of a list of OIDs for the indexes. This list is used by the parser and executor to drive lookups in the pg_index syscache when they want to know the properties of the indexes. Net result: index information will be fully cached for repetitive operations such as inserts.
2000-06-17 21:49:04 +00:00
* Since shared cache inval causes the relcache's copy of the list to go away,
* we return a copy of the list palloc'd in the caller's context. The caller
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* may freeList() the returned list after scanning it. This is necessary
Fix performance problems with pg_index lookups (see, for example, discussion of 5/19/00). pg_index is now searched for indexes of a relation using an indexscan. Moreover, this is done once and cached in the relcache entry for the relation, in the form of a list of OIDs for the indexes. This list is used by the parser and executor to drive lookups in the pg_index syscache when they want to know the properties of the indexes. Net result: index information will be fully cached for repetitive operations such as inserts.
2000-06-17 21:49:04 +00:00
* since the caller will typically be doing syscache lookups on the relevant
* indexes, and syscache lookup could cause SI messages to be processed!
*/
List *
RelationGetIndexList(Relation relation)
{
Relation indrel;
Relation irel = (Relation) NULL;
ScanKeyData skey;
IndexScanDesc sd = (IndexScanDesc) NULL;
HeapScanDesc hscan = (HeapScanDesc) NULL;
bool hasindex;
List *result;
MemoryContext oldcxt;
/* Quick exit if we already computed the list. */
if (relation->rd_indexfound)
return listCopy(relation->rd_indexlist);
/* Prepare to scan pg_index for entries having indrelid = this rel. */
indrel = heap_openr(IndexRelationName, AccessShareLock);
hasindex = (indrel->rd_rel->relhasindex && !IsIgnoringSystemIndexes());
if (hasindex)
{
irel = index_openr(IndexIndrelidIndex);
ScanKeyEntryInitialize(&skey,
(bits16) 0x0,
(AttrNumber) 1,
(RegProcedure) F_OIDEQ,
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
ObjectIdGetDatum(RelationGetRelid(relation)));
Fix performance problems with pg_index lookups (see, for example, discussion of 5/19/00). pg_index is now searched for indexes of a relation using an indexscan. Moreover, this is done once and cached in the relcache entry for the relation, in the form of a list of OIDs for the indexes. This list is used by the parser and executor to drive lookups in the pg_index syscache when they want to know the properties of the indexes. Net result: index information will be fully cached for repetitive operations such as inserts.
2000-06-17 21:49:04 +00:00
sd = index_beginscan(irel, false, 1, &skey);
}
else
{
ScanKeyEntryInitialize(&skey,
(bits16) 0x0,
(AttrNumber) Anum_pg_index_indrelid,
(RegProcedure) F_OIDEQ,
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
ObjectIdGetDatum(RelationGetRelid(relation)));
Fix performance problems with pg_index lookups (see, for example, discussion of 5/19/00). pg_index is now searched for indexes of a relation using an indexscan. Moreover, this is done once and cached in the relcache entry for the relation, in the form of a list of OIDs for the indexes. This list is used by the parser and executor to drive lookups in the pg_index syscache when they want to know the properties of the indexes. Net result: index information will be fully cached for repetitive operations such as inserts.
2000-06-17 21:49:04 +00:00
hscan = heap_beginscan(indrel, false, SnapshotNow, 1, &skey);
}
/*
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
* We build the list we intend to return (in the caller's context)
* while doing the scan. After successfully completing the scan, we
* copy that list into the relcache entry. This avoids cache-context
* memory leakage if we get some sort of error partway through.
Fix performance problems with pg_index lookups (see, for example, discussion of 5/19/00). pg_index is now searched for indexes of a relation using an indexscan. Moreover, this is done once and cached in the relcache entry for the relation, in the form of a list of OIDs for the indexes. This list is used by the parser and executor to drive lookups in the pg_index syscache when they want to know the properties of the indexes. Net result: index information will be fully cached for repetitive operations such as inserts.
2000-06-17 21:49:04 +00:00
*/
result = NIL;
pgindent run. Make it all clean.
2001-03-22 04:01:46 +00:00
Fix performance problems with pg_index lookups (see, for example, discussion of 5/19/00). pg_index is now searched for indexes of a relation using an indexscan. Moreover, this is done once and cached in the relcache entry for the relation, in the form of a list of OIDs for the indexes. This list is used by the parser and executor to drive lookups in the pg_index syscache when they want to know the properties of the indexes. Net result: index information will be fully cached for repetitive operations such as inserts.
2000-06-17 21:49:04 +00:00
for (;;)
{
HeapTupleData tuple;
HeapTuple htup;
Buffer buffer;
Form_pg_index index;
if (hasindex)
{
RetrieveIndexResult indexRes;
indexRes = index_getnext(sd, ForwardScanDirection);
if (!indexRes)
break;
tuple.t_self = indexRes->heap_iptr;
tuple.t_datamcxt = NULL;
tuple.t_data = NULL;
Statistical system views (yet without the config stuff, but it's hard to keep such massive changes in sync with the tree so I need to get it in and work from there now). Jan
2001-06-22 19:16:24 +00:00
heap_fetch(indrel, SnapshotNow, &tuple, &buffer, sd);
Fix performance problems with pg_index lookups (see, for example, discussion of 5/19/00). pg_index is now searched for indexes of a relation using an indexscan. Moreover, this is done once and cached in the relcache entry for the relation, in the form of a list of OIDs for the indexes. This list is used by the parser and executor to drive lookups in the pg_index syscache when they want to know the properties of the indexes. Net result: index information will be fully cached for repetitive operations such as inserts.
2000-06-17 21:49:04 +00:00
pfree(indexRes);
if (tuple.t_data == NULL)
continue;
htup = &tuple;
}
else
{
htup = heap_getnext(hscan, 0);
if (!HeapTupleIsValid(htup))
break;
}
index = (Form_pg_index) GETSTRUCT(htup);
Modify index-opening code to guarantee that the indexes of a relation are opened in a consistent order by different backends (I ordered them by index OID because that's easy, but any other consistent order would do as well). This avoids potential deadlock for index types that we acquire exclusive locks on ... ie, rtree.
2000-06-19 23:40:48 +00:00
result = insert_ordered_oid(result, index->indexrelid);
Fix performance problems with pg_index lookups (see, for example, discussion of 5/19/00). pg_index is now searched for indexes of a relation using an indexscan. Moreover, this is done once and cached in the relcache entry for the relation, in the form of a list of OIDs for the indexes. This list is used by the parser and executor to drive lookups in the pg_index syscache when they want to know the properties of the indexes. Net result: index information will be fully cached for repetitive operations such as inserts.
2000-06-17 21:49:04 +00:00
if (hasindex)
ReleaseBuffer(buffer);
}
if (hasindex)
{
index_endscan(sd);
index_close(irel);
}
else
heap_endscan(hscan);
heap_close(indrel, AccessShareLock);
Modify index-opening code to guarantee that the indexes of a relation are opened in a consistent order by different backends (I ordered them by index OID because that's easy, but any other consistent order would do as well). This avoids potential deadlock for index types that we acquire exclusive locks on ... ie, rtree.
2000-06-19 23:40:48 +00:00
/* Now save a copy of the completed list in the relcache entry. */
First phase of memory management rewrite (see backend/utils/mmgr/README for details). It doesn't really do that much yet, since there are no short-term memory contexts in the executor, but the infrastructure is in place and long-term contexts are handled reasonably. A few long- standing bugs have been fixed, such as 'VACUUM; anything' in a single query string crashing. Also, out-of-memory is now considered a recoverable ERROR, not FATAL. Eliminate a large amount of crufty, now-dead code in and around memory management. Fix problem with holding off SIGTRAP, SIGSEGV, etc in postmaster and backend startup.
2000-06-28 03:33:33 +00:00
oldcxt = MemoryContextSwitchTo(CacheMemoryContext);
Fix performance problems with pg_index lookups (see, for example, discussion of 5/19/00). pg_index is now searched for indexes of a relation using an indexscan. Moreover, this is done once and cached in the relcache entry for the relation, in the form of a list of OIDs for the indexes. This list is used by the parser and executor to drive lookups in the pg_index syscache when they want to know the properties of the indexes. Net result: index information will be fully cached for repetitive operations such as inserts.
2000-06-17 21:49:04 +00:00
relation->rd_indexlist = listCopy(result);
relation->rd_indexfound = true;
MemoryContextSwitchTo(oldcxt);
return result;
}
Modify index-opening code to guarantee that the indexes of a relation are opened in a consistent order by different backends (I ordered them by index OID because that's easy, but any other consistent order would do as well). This avoids potential deadlock for index types that we acquire exclusive locks on ... ie, rtree.
2000-06-19 23:40:48 +00:00
/*
* insert_ordered_oid
* Insert a new Oid into a sorted list of Oids, preserving ordering
*
* Building the ordered list this way is O(N^2), but with a pretty small
* constant, so for the number of entries we expect it will probably be
* faster than trying to apply qsort(). Most tables don't have very many
* indexes...
*/
static List *
insert_ordered_oid(List *list, Oid datum)
{
List *l;
/* Does the datum belong at the front? */
if (list == NIL || datum < (Oid) lfirsti(list))
return lconsi(datum, list);
/* No, so find the entry it belongs after */
l = list;
for (;;)
{
List *n = lnext(l);
if (n == NIL || datum < (Oid) lfirsti(n))
break; /* it belongs before n */
l = n;
}
/* Insert datum into list after item l */
lnext(l) = lconsi(datum, lnext(l));
return list;
}
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
/*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* init_irels(), write_irels() -- handle special-case initialization of
* index relation descriptors.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* In late 1992, we started regularly having databases with more than
* a thousand classes in them. With this number of classes, it became
* critical to do indexed lookups on the system catalogs.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* Bootstrapping these lookups is very hard. We want to be able to
* use an index on pg_attribute, for example, but in order to do so,
* we must have read pg_attribute for the attributes in the index,
* which implies that we need to use the index.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* In order to get around the problem, we do the following:
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* + When the database system is initialized (at initdb time), we
* don't use indices on pg_attribute. We do sequential scans.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* + When the backend is started up in normal mode, we load an image
* of the appropriate relation descriptors, in internal format,
* from an initialization file in the data/base/... directory.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* + If the initialization file isn't there, then we create the
Arrange for VACUUM to delete the init file that relcache.c uses to save a little bit of backend startup time. This way, the first backend started after a VACUUM will rebuild the init file with up-to-date statistics for the critical system indexes.
1999-05-01 19:09:46 +00:00
* relation descriptors using sequential scans and write 'em to
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
* the initialization file for use by subsequent backends.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*
Arrange for VACUUM to delete the init file that relcache.c uses to save a little bit of backend startup time. This way, the first backend started after a VACUUM will rebuild the init file with up-to-date statistics for the critical system indexes.
1999-05-01 19:09:46 +00:00
* We could dispense with the initialization file and just build the
* critical reldescs the hard way on every backend startup, but that
* slows down backend startup noticeably if pg_class is large.
*
* As of v6.5, vacuum.c deletes the initialization file at completion
* of a VACUUM, so that it will be rebuilt at the next backend startup.
* This ensures that vacuum-collected stats for the system indexes
* will eventually get used by the optimizer --- otherwise the relcache
* entries for these indexes will show zero sizes forever, since the
* relcache entries are pinned in memory and will never be reloaded
* from pg_class.
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
*/
/* pg_attnumind, pg_classnameind, pg_classoidind */
#define Num_indices_bootstrap 3
Make functions static where possible, enclose unused functions in #ifdef NOT_USED.
1997-08-19 21:40:56 +00:00
static void
All external function definitions now have prototypes that are checked.
1996-11-10 03:06:38 +00:00
init_irels(void)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
{
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
Size len;
int nread;
File fd;
Relation irel[Num_indices_bootstrap];
Relation ird;
Form_pg_am am;
Form_pg_class relform;
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
MemoryContext indexcxt;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
IndexStrategy strat;
RegProcedure *support;
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
int nstrategies,
nsupport;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
int i;
int relno;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Remove NT-specific file open defines by defining our own open macros for "rb" and "wb".
2000-06-02 15:57:44 +00:00
if ((fd = FileNameOpenFile(RELCACHE_INIT_FILENAME, O_RDONLY | PG_BINARY, 0600)) < 0)
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
{
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
write_irels();
return;
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
for (relno = 0; relno < Num_indices_bootstrap; relno++)
{
/* first read the relation descriptor length */
Fix for Size sizeof in cache code.
1999-01-22 16:49:25 +00:00
if ((nread = FileRead(fd, (char *) &len, sizeof(len))) != sizeof(len))
Fix init_irels to close the pg_internal.init file before returning. This saves one open file descriptor per backend, and avoids an annoying NOTICE on Cygwin (which has trouble deleting open files). Bug appears to date back to original coding of init_irels, circa 1992.
2002-01-16 17:34:42 +00:00
goto read_failed;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
/* safety check for incompatible relcache layout */
if (len != sizeof(RelationData))
Fix init_irels to close the pg_internal.init file before returning. This saves one open file descriptor per backend, and avoids an annoying NOTICE on Cygwin (which has trouble deleting open files). Bug appears to date back to original coding of init_irels, circa 1992.
2002-01-16 17:34:42 +00:00
goto read_failed;
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
ird = irel[relno] = (Relation) palloc(len);
Inline memset() as MemSet().
1997-09-18 20:22:58 +00:00
MemSet(ird, 0, len);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
/* then, read the Relation structure */
if ((nread = FileRead(fd, (char *) ird, len)) != len)
Fix init_irels to close the pg_internal.init file before returning. This saves one open file descriptor per backend, and avoids an annoying NOTICE on Cygwin (which has trouble deleting open files). Bug appears to date back to original coding of init_irels, circa 1992.
2002-01-16 17:34:42 +00:00
goto read_failed;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Install infrastructure for shared-memory free space map. Doesn't actually do anything yet, but it has the necessary connections to initialization and so forth. Make some gestures towards allowing number of blocks in a relation to be BlockNumber, ie, unsigned int, rather than signed int. (I doubt I got all the places that are sloppy about it, yet.) On the way, replace the hardwired NLOCKS_PER_XACT fudge factor with a GUC variable.
2001-06-27 23:31:40 +00:00
/* reset transient fields */
ird->rd_targblock = InvalidBlockNumber;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
ird->rd_fd = -1;
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
ird->rd_refcnt = 0;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
New file naming. Database OID is used as "tablespace" id and relation OID is used as file node on creation but may be changed later if required. Regression Tests Approved (c) -:)))
2000-10-16 14:52:28 +00:00
ird->rd_node.tblNode = MyDatabaseId;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
/* next, read the access method tuple form */
Fix for Size sizeof in cache code.
1999-01-22 16:49:25 +00:00
if ((nread = FileRead(fd, (char *) &len, sizeof(len))) != sizeof(len))
Fix init_irels to close the pg_internal.init file before returning. This saves one open file descriptor per backend, and avoids an annoying NOTICE on Cygwin (which has trouble deleting open files). Bug appears to date back to original coding of init_irels, circa 1992.
2002-01-16 17:34:42 +00:00
goto read_failed;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
am = (Form_pg_am) palloc(len);
if ((nread = FileRead(fd, (char *) am, len)) != len)
Fix init_irels to close the pg_internal.init file before returning. This saves one open file descriptor per backend, and avoids an annoying NOTICE on Cygwin (which has trouble deleting open files). Bug appears to date back to original coding of init_irels, circa 1992.
2002-01-16 17:34:42 +00:00
goto read_failed;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
ird->rd_am = am;
/* next read the relation tuple form */
Fix for Size sizeof in cache code.
1999-01-22 16:49:25 +00:00
if ((nread = FileRead(fd, (char *) &len, sizeof(len))) != sizeof(len))
Fix init_irels to close the pg_internal.init file before returning. This saves one open file descriptor per backend, and avoids an annoying NOTICE on Cygwin (which has trouble deleting open files). Bug appears to date back to original coding of init_irels, circa 1992.
2002-01-16 17:34:42 +00:00
goto read_failed;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
relform = (Form_pg_class) palloc(len);
if ((nread = FileRead(fd, (char *) relform, len)) != len)
Fix init_irels to close the pg_internal.init file before returning. This saves one open file descriptor per backend, and avoids an annoying NOTICE on Cygwin (which has trouble deleting open files). Bug appears to date back to original coding of init_irels, circa 1992.
2002-01-16 17:34:42 +00:00
goto read_failed;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
ird->rd_rel = relform;
/* initialize attribute tuple forms */
ird->rd_att = CreateTemplateTupleDesc(relform->relnatts);
/* next read all the attribute tuple form data entries */
len = ATTRIBUTE_TUPLE_SIZE;
for (i = 0; i < relform->relnatts; i++)
{
Fix for Size sizeof in cache code.
1999-01-22 16:49:25 +00:00
if ((nread = FileRead(fd, (char *) &len, sizeof(len))) != sizeof(len))
Fix init_irels to close the pg_internal.init file before returning. This saves one open file descriptor per backend, and avoids an annoying NOTICE on Cygwin (which has trouble deleting open files). Bug appears to date back to original coding of init_irels, circa 1992.
2002-01-16 17:34:42 +00:00
goto read_failed;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Renaming cleanup, no pgindent yet.
1998-09-01 03:29:17 +00:00
ird->rd_att->attrs[i] = (Form_pg_attribute) palloc(len);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
if ((nread = FileRead(fd, (char *) ird->rd_att->attrs[i], len)) != len)
Fix init_irels to close the pg_internal.init file before returning. This saves one open file descriptor per backend, and avoids an annoying NOTICE on Cygwin (which has trouble deleting open files). Bug appears to date back to original coding of init_irels, circa 1992.
2002-01-16 17:34:42 +00:00
goto read_failed;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
}
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
/*
* prepare index info context --- parameters should match
* RelationInitIndexAccessInfo
*/
indexcxt = AllocSetContextCreate(CacheMemoryContext,
RelationGetRelationName(ird),
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 05:50:21 +00:00
0, /* minsize */
512, /* initsize */
1024); /* maxsize */
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
ird->rd_indexcxt = indexcxt;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
/* next, read the index strategy map */
Fix for Size sizeof in cache code.
1999-01-22 16:49:25 +00:00
if ((nread = FileRead(fd, (char *) &len, sizeof(len))) != sizeof(len))
Fix init_irels to close the pg_internal.init file before returning. This saves one open file descriptor per backend, and avoids an annoying NOTICE on Cygwin (which has trouble deleting open files). Bug appears to date back to original coding of init_irels, circa 1992.
2002-01-16 17:34:42 +00:00
goto read_failed;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
strat = (IndexStrategy) MemoryContextAlloc(indexcxt, len);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
if ((nread = FileRead(fd, (char *) strat, len)) != len)
Fix init_irels to close the pg_internal.init file before returning. This saves one open file descriptor per backend, and avoids an annoying NOTICE on Cygwin (which has trouble deleting open files). Bug appears to date back to original coding of init_irels, circa 1992.
2002-01-16 17:34:42 +00:00
goto read_failed;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
/* have to invalidate any FmgrInfo data in the strategy maps */
nstrategies = am->amstrategies * relform->relnatts;
for (i = 0; i < nstrategies; i++)
strat->strategyMapData[i].entry[0].sk_func.fn_oid = InvalidOid;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
ird->rd_istrat = strat;
/* finally, read the vector of support procedures */
Fix for Size sizeof in cache code.
1999-01-22 16:49:25 +00:00
if ((nread = FileRead(fd, (char *) &len, sizeof(len))) != sizeof(len))
Fix init_irels to close the pg_internal.init file before returning. This saves one open file descriptor per backend, and avoids an annoying NOTICE on Cygwin (which has trouble deleting open files). Bug appears to date back to original coding of init_irels, circa 1992.
2002-01-16 17:34:42 +00:00
goto read_failed;
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
support = (RegProcedure *) MemoryContextAlloc(indexcxt, len);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
if ((nread = FileRead(fd, (char *) support, len)) != len)
Fix init_irels to close the pg_internal.init file before returning. This saves one open file descriptor per backend, and avoids an annoying NOTICE on Cygwin (which has trouble deleting open files). Bug appears to date back to original coding of init_irels, circa 1992.
2002-01-16 17:34:42 +00:00
goto read_failed;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
ird->rd_support = support;
Rearrange fmgr.c and relcache so that it's possible to keep FmgrInfo lookup info in the relcache for index access method support functions. This makes a huge difference for dynamically loaded support functions, and should save a few cycles even for built-in ones. Also tweak dfmgr.c so that load_external_function is called only once, not twice, when doing fmgr_info for a dynamically loaded function. All per performance gripe from Teodor Sigaev, 5-Oct-01.
2001-10-06 23:21:45 +00:00
nsupport = relform->relnatts * am->amsupport;
ird->rd_supportinfo = (FmgrInfo *)
MemoryContextAlloc(indexcxt, nsupport * sizeof(FmgrInfo));
MemSet(ird->rd_supportinfo, 0, nsupport * sizeof(FmgrInfo));
Lmgr cleanup, new locking modes for LLL.
1998-08-01 15:26:38 +00:00
RelationInitLockInfo(ird);
Mega-commit to make heap_open/heap_openr/heap_close take an additional argument specifying the kind of lock to acquire/release (or 'NoLock' to do no lock processing). Ensure that all relations are locked with some appropriate lock level before being examined --- this ensures that relevant shared-inval messages have been processed and should prevent problems caused by concurrent VACUUM. Fix several bugs having to do with mismatched increment/decrement of relation ref count and mismatched heap_open/close (which amounts to the same thing). A bogus ref count on a relation doesn't matter much *unless* a SI Inval message happens to arrive at the wrong time, which is probably why we got away with this sloppiness for so long. Repair missing grab of AccessExclusiveLock in DROP TABLE, ALTER/RENAME TABLE, etc, as noted by Hiroshi. Recommend 'make clean all' after pulling this update; I modified the Relation struct layout slightly. Will post further discussion to pghackers list shortly.
1999-09-18 19:08:25 +00:00
RelationCacheInsert(ird);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
}
Fix init_irels to close the pg_internal.init file before returning. This saves one open file descriptor per backend, and avoids an annoying NOTICE on Cygwin (which has trouble deleting open files). Bug appears to date back to original coding of init_irels, circa 1992.
2002-01-16 17:34:42 +00:00
/* successfully read the init file */
FileClose(fd);
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
criticalRelcachesBuilt = true;
Fix init_irels to close the pg_internal.init file before returning. This saves one open file descriptor per backend, and avoids an annoying NOTICE on Cygwin (which has trouble deleting open files). Bug appears to date back to original coding of init_irels, circa 1992.
2002-01-16 17:34:42 +00:00
return;
/* init file is broken, so do it the hard way */
read_failed:
FileClose(fd);
write_irels();
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Make functions static where possible, enclose unused functions in #ifdef NOT_USED.
1997-08-19 21:40:56 +00:00
static void
All external function definitions now have prototypes that are checked.
1996-11-10 03:06:38 +00:00
write_irels(void)
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
{
Relcache Size fix.
1999-01-22 18:47:37 +00:00
Size len;
Another PGINDENT run that changes variable indenting and case label indenting. Also static variable indenting.
1997-09-08 02:41:22 +00:00
int nwritten;
File fd;
Relation irel[Num_indices_bootstrap];
Relation ird;
Form_pg_am am;
Form_pg_class relform;
IndexStrategy strat;
RegProcedure *support;
int i;
int relno;
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
RelationBuildDescInfo bi;
Fix low-probability bug in relcache startup: write_irels wrote the pg_internal.init file in-place, which meant that if another backend started at about the same time, it might read the incomplete file. init_irels tries to guard against that, but I have now seen a crash due to reading bad data from a partly-written file. (This may indicate a kernel bug on my platform? Not sure.) Anyway, clearly the safest course is to write the new pg_internal.init file under a unique temporary filename, and rename it into place only after it's all written.
2000-03-31 19:39:22 +00:00
char tempfilename[MAXPGPATH];
char finalfilename[MAXPGPATH];
/*
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
* We must write a temporary file and rename it into place. Otherwise,
* another backend starting at about the same time might crash trying
* to read the partially-complete file.
Fix low-probability bug in relcache startup: write_irels wrote the pg_internal.init file in-place, which meant that if another backend started at about the same time, it might read the incomplete file. init_irels tries to guard against that, but I have now seen a crash due to reading bad data from a partly-written file. (This may indicate a kernel bug on my platform? Not sure.) Anyway, clearly the safest course is to write the new pg_internal.init file under a unique temporary filename, and rename it into place only after it's all written.
2000-03-31 19:39:22 +00:00
*/
Remove SEP_CHAR, replace with / or '/' as appropriate.
2001-05-30 14:15:27 +00:00
snprintf(tempfilename, sizeof(tempfilename), "%s/%s.%d",
DatabasePath, RELCACHE_INIT_FILENAME, MyProcPid);
snprintf(finalfilename, sizeof(finalfilename), "%s/%s",
DatabasePath, RELCACHE_INIT_FILENAME);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
Remove NT-specific file open defines by defining our own open macros for "rb" and "wb".
2000-06-02 15:57:44 +00:00
fd = PathNameOpenFile(tempfilename, O_WRONLY | O_CREAT | O_TRUNC | PG_BINARY, 0600);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
if (fd < 0)
Modify index-opening code to guarantee that the indexes of a relation are opened in a consistent order by different backends (I ordered them by index OID because that's easy, but any other consistent order would do as well). This avoids potential deadlock for index types that we acquire exclusive locks on ... ie, rtree.
2000-06-19 23:40:48 +00:00
{
/*
* We used to consider this a fatal error, but we might as well
* continue with backend startup ...
*/
elog(NOTICE, "Cannot create init file %s: %m\n\tContinuing anyway, but there's something wrong.", tempfilename);
return;
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
FileSeek(fd, 0L, SEEK_SET);
/*
RelationCacheInvalidate thought there were 7 nailed-in-cache system tables, but actually there are only 6 --- see RelationInitialize. Kinda makes you wonder how long ago this code was last executed...
1999-09-06 18:13:02 +00:00
* Build relation descriptors for the critical system indexes without
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
* resort to the descriptor cache. In order to do this, we set
* ProcessingMode to Bootstrap. The effect of this is to disable
* indexed relation searches -- a necessary step, since we're trying
* to instantiate the index relation descriptors here. Once we have
* the descriptors, nail them into cache so we never lose them.
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
*/
Fix comments that were mis-wrapped, for Tom Lane.
2001-03-23 04:49:58 +00:00
/*---------
* Removed the following ProcessingMode change -- inoue
* At this point
* 1) Catalog Cache isn't initialized
* 2) Relation Cache for the following critical indexes aren't built
* oldmode = GetProcessingMode();
* SetProcessingMode(BootstrapProcessing);
*---------
Implement reindex command
2000-02-18 09:30:20 +00:00
*/
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
bi.infotype = INFO_RELNAME;
Add system indexes to match all caches. Make all system indexes unique. Make all cache loads use system indexes. Rename *rel to *relid in inheritance tables. Rename cache names to be clearer.
1999-11-22 17:56:41 +00:00
bi.i.info_name = AttributeRelidNumIndex;
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
irel[0] = RelationBuildDesc(bi, NULL);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
irel[0]->rd_isnailed = true;
bi.i.info_name = ClassNameIndex;
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
irel[1] = RelationBuildDesc(bi, NULL);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
irel[1]->rd_isnailed = true;
bi.i.info_name = ClassOidIndex;
Modify RelationFlushRelation so that if the relcache entry has positive refcount, it is rebuilt from pg_class data. This ensures that relcache entries will track changes made by other backends. Formerly, a shared inval report would just be ignored if it happened to arrive while the relcache entry was in use. Also, fix relcache to reset ref counts to zero during transaction abort. Finally, change LockRelation() so that it checks for shared inval reports after obtaining the lock. In this way, once any kind of lock has been obtained on a rel, we can trust the relcache entry to be up-to-date.
1999-09-04 18:42:15 +00:00
irel[2] = RelationBuildDesc(bi, NULL);
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
irel[2]->rd_isnailed = true;
Use a private memory context to store rule information in each relcache entry that has rules. This allows us to release the rule parsetrees on relcache flush without needing a working freeObject() routine. Formerly, the rule trees were leaked permanently at relcache flush. Also, clean up handling of rule creation and deletion --- there was not sufficient locking of the relation being modified, and there was no reliable notification of other backends that a relcache reload was needed. Also, clean up relcache.c code so that scans of system tables needed to load a relcache entry are done in the caller's memory context, not in CacheMemoryContext. This prevents any un-pfreed memory from those scans from becoming a permanent memory leak.
2000-06-30 07:04:23 +00:00
criticalRelcachesBuilt = true;
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
/*
* Removed the following ProcessingMode -- inoue
* SetProcessingMode(oldmode);
Implement reindex command
2000-02-18 09:30:20 +00:00
*/
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
RelationCacheInvalidate thought there were 7 nailed-in-cache system tables, but actually there are only 6 --- see RelationInitialize. Kinda makes you wonder how long ago this code was last executed...
1999-09-06 18:13:02 +00:00
/*
* Write out the index reldescs to the special cache file.
*/
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
for (relno = 0; relno < Num_indices_bootstrap; relno++)
{
ird = irel[relno];
/* save the volatile fields in the relation descriptor */
am = ird->rd_am;
ird->rd_am = (Form_pg_am) NULL;
relform = ird->rd_rel;
ird->rd_rel = (Form_pg_class) NULL;
strat = ird->rd_istrat;
support = ird->rd_support;
/*
* first write the relation descriptor , excluding strategy and
* support
*/
len = sizeof(RelationData);
/* first, write the relation descriptor length */
Fix for Size sizeof in cache code.
1999-01-22 16:49:25 +00:00
if ((nwritten = FileWrite(fd, (char *) &len, sizeof(len)))
!= sizeof(len))
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
elog(FATAL, "cannot write init file -- descriptor length");
/* next, write out the Relation structure */
if ((nwritten = FileWrite(fd, (char *) ird, len)) != len)
elog(FATAL, "cannot write init file -- reldesc");
/* next, write the access method tuple form */
len = sizeof(FormData_pg_am);
Fix for Size sizeof in cache code.
1999-01-22 16:49:25 +00:00
if ((nwritten = FileWrite(fd, (char *) &len, sizeof(len)))
!= sizeof(len))
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
elog(FATAL, "cannot write init file -- am tuple form length");
if ((nwritten = FileWrite(fd, (char *) am, len)) != len)
elog(FATAL, "cannot write init file -- am tuple form");
/* next write the relation tuple form */
len = sizeof(FormData_pg_class);
Fix for Size sizeof in cache code.
1999-01-22 16:49:25 +00:00
if ((nwritten = FileWrite(fd, (char *) &len, sizeof(len)))
!= sizeof(len))
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
elog(FATAL, "cannot write init file -- relation tuple form length");
if ((nwritten = FileWrite(fd, (char *) relform, len)) != len)
elog(FATAL, "cannot write init file -- relation tuple form");
/* next, do all the attribute tuple form data entries */
len = ATTRIBUTE_TUPLE_SIZE;
for (i = 0; i < relform->relnatts; i++)
{
Fix for Size sizeof in cache code.
1999-01-22 16:49:25 +00:00
if ((nwritten = FileWrite(fd, (char *) &len, sizeof(len)))
!= sizeof(len))
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
elog(FATAL, "cannot write init file -- length of attdesc %d", i);
if ((nwritten = FileWrite(fd, (char *) ird->rd_att->attrs[i], len))
!= len)
elog(FATAL, "cannot write init file -- attdesc %d", i);
}
/* next, write the index strategy map */
len = AttributeNumberGetIndexStrategySize(relform->relnatts,
am->amstrategies);
Fix for Size sizeof in cache code.
1999-01-22 16:49:25 +00:00
if ((nwritten = FileWrite(fd, (char *) &len, sizeof(len)))
!= sizeof(len))
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
elog(FATAL, "cannot write init file -- strategy map length");
if ((nwritten = FileWrite(fd, (char *) strat, len)) != len)
elog(FATAL, "cannot write init file -- strategy map");
/* finally, write the vector of support procedures */
len = relform->relnatts * (am->amsupport * sizeof(RegProcedure));
Fix for Size sizeof in cache code.
1999-01-22 16:49:25 +00:00
if ((nwritten = FileWrite(fd, (char *) &len, sizeof(len)))
!= sizeof(len))
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
elog(FATAL, "cannot write init file -- support vector length");
if ((nwritten = FileWrite(fd, (char *) support, len)) != len)
elog(FATAL, "cannot write init file -- support vector");
/* restore volatile fields */
ird->rd_am = am;
ird->rd_rel = relform;
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Massive commit to run PGINDENT on all *.c and *.h files.
1997-09-07 05:04:48 +00:00
FileClose(fd);
Fix low-probability bug in relcache startup: write_irels wrote the pg_internal.init file in-place, which meant that if another backend started at about the same time, it might read the incomplete file. init_irels tries to guard against that, but I have now seen a crash due to reading bad data from a partly-written file. (This may indicate a kernel bug on my platform? Not sure.) Anyway, clearly the safest course is to write the new pg_internal.init file under a unique temporary filename, and rename it into place only after it's all written.
2000-03-31 19:39:22 +00:00
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
/*
* And rename the temp file to its final name, deleting any
Modify index-opening code to guarantee that the indexes of a relation are opened in a consistent order by different backends (I ordered them by index OID because that's easy, but any other consistent order would do as well). This avoids potential deadlock for index types that we acquire exclusive locks on ... ie, rtree.
2000-06-19 23:40:48 +00:00
* previously-existing init file.
Fix init_irels to close the pg_internal.init file before returning. This saves one open file descriptor per backend, and avoids an annoying NOTICE on Cygwin (which has trouble deleting open files). Bug appears to date back to original coding of init_irels, circa 1992.
2002-01-16 17:34:42 +00:00
*
* Note: a failure here is possible under Cygwin, if some other
* backend is holding open an unlinked-but-not-yet-gone init file.
* So treat this as a noncritical failure.
Ye-old pgindent run. Same 4-space tabs.
2000-04-12 17:17:23 +00:00
*/
Modify index-opening code to guarantee that the indexes of a relation are opened in a consistent order by different backends (I ordered them by index OID because that's easy, but any other consistent order would do as well). This avoids potential deadlock for index types that we acquire exclusive locks on ... ie, rtree.
2000-06-19 23:40:48 +00:00
if (rename(tempfilename, finalfilename) < 0)
If we fail to rename pg_internal.init into place, delete the useless temporary file. This seems to be a known failure mode under Cygwin, so we might as well expend the extra line of code to be tidy.
2002-01-15 22:33:20 +00:00
{
Modify index-opening code to guarantee that the indexes of a relation are opened in a consistent order by different backends (I ordered them by index OID because that's easy, but any other consistent order would do as well). This avoids potential deadlock for index types that we acquire exclusive locks on ... ie, rtree.
2000-06-19 23:40:48 +00:00
elog(NOTICE, "Cannot rename init file %s to %s: %m\n\tContinuing anyway, but there's something wrong.", tempfilename, finalfilename);
If we fail to rename pg_internal.init into place, delete the useless temporary file. This seems to be a known failure mode under Cygwin, so we might as well expend the extra line of code to be tidy.
2002-01-15 22:33:20 +00:00
/*
* If we fail, try to clean up the useless temp file; don't bother
* to complain if this fails too.
*/
unlink(tempfilename);
}
Postgres95 1.01 Distribution - Virgin Sources
1996-07-09 06:22:35 +00:00
}
Reference in New Issue Copy Permalink