/postgres.bki
/schemapg.h
+/syscache_ids.h
+/syscache_info.h
/system_fk_info.h
/system_constraints.sql
/pg_*_d.h
%+,
};
}
+ elsif (
+ /^MAKE_SYSCACHE\(\s*
+ (?<syscache_name>\w+),\s*
+ (?<index_name>\w+),\s*
+ (?<syscache_nbuckets>\w+)\s*
+ \)/x
+ )
+ {
+ push @{ $catalog{syscaches} }, {%+};
+ }
elsif (
/^DECLARE_OID_DEFINING_MACRO\(\s*
(?<other_name>\w+),\s*
pg_subscription.h \
pg_subscription_rel.h
-GENERATED_HEADERS := $(CATALOG_HEADERS:%.h=%_d.h) schemapg.h system_fk_info.h
+GENERATED_HEADERS := $(CATALOG_HEADERS:%.h=%_d.h) schemapg.h syscache_ids.h syscache_info.h system_fk_info.h
POSTGRES_BKI_SRCS := $(addprefix $(top_srcdir)/src/include/catalog/, $(CATALOG_HEADERS))
my %catalog_data;
my @toast_decls;
my @index_decls;
+my %syscaches;
+my %syscache_catalogs;
my %oidcounts;
my @system_constraints;
}
}
+ # Lookup table to get index info by index name
+ my %indexes;
+
# If the header file contained toast or index info, build BKI
# commands for those, which we'll output later.
foreach my $toast (@{ $catalog->{toasting} })
}
foreach my $index (@{ $catalog->{indexing} })
{
+ $indexes{ $index->{index_name} } = $index;
+
push @index_decls,
sprintf "declare %sindex %s %s on %s using %s\n",
$index->{is_unique} ? 'unique ' : '',
$index->{index_name};
}
}
+
+ # Analyze syscache info
+ foreach my $syscache (@{ $catalog->{syscaches} })
+ {
+ my $index = $indexes{ $syscache->{index_name} };
+ my $tblname = $index->{table_name};
+ my $key = $index->{index_decl};
+ $key =~ s/^\w+\(//;
+ $key =~ s/\)$//;
+ $key =~ s/(\w+)\s+\w+/Anum_${tblname}_$1/g;
+
+ $syscaches{ $syscache->{syscache_name} } = {
+ table_oid_macro => $catalogs{$tblname}->{relation_oid_macro},
+ index_oid_macro => $index->{index_oid_macro},
+ key => $key,
+ nbuckets => $syscache->{syscache_nbuckets},
+ };
+
+ $syscache_catalogs{$catname} = 1;
+ }
}
# Complain and exit if we found any duplicate OIDs.
my $constraints_file = $output_path . 'system_constraints.sql';
open my $constraints, '>', $constraints_file . $tmpext
or die "can't open $constraints_file$tmpext: $!";
+my $syscache_ids_file = $output_path . 'syscache_ids.h';
+open my $syscache_ids_fh, '>', $syscache_ids_file . $tmpext
+ or die "can't open $syscache_ids_file$tmpext: $!";
+my $syscache_info_file = $output_path . 'syscache_info.h';
+open my $syscache_info_fh, '>', $syscache_info_file . $tmpext
+ or die "can't open $syscache_info_file$tmpext: $!";
# Generate postgres.bki and pg_*_d.h headers.
# Closing boilerplate for system_fk_info.h
print $fk_info "};\n\n#endif\t\t\t\t\t\t\t/* SYSTEM_FK_INFO_H */\n";
+# Now generate syscache info
+
+print_boilerplate($syscache_ids_fh, "syscache_ids.h", "SysCache identifiers");
+print $syscache_ids_fh "enum SysCacheIdentifier
+{
+";
+
+print_boilerplate($syscache_info_fh, "syscache_info.h",
+ "SysCache definitions");
+print $syscache_info_fh "\n";
+foreach my $catname (sort keys %syscache_catalogs)
+{
+ print $syscache_info_fh qq{#include "catalog/${catname}_d.h"\n};
+}
+print $syscache_info_fh "\n";
+print $syscache_info_fh "static const struct cachedesc cacheinfo[] = {\n";
+
+my $last_syscache;
+foreach my $syscache (sort keys %syscaches)
+{
+ print $syscache_ids_fh "\t$syscache,\n";
+ $last_syscache = $syscache;
+
+ print $syscache_info_fh "\t[$syscache] = {\n";
+ print $syscache_info_fh "\t\t", $syscaches{$syscache}{table_oid_macro},
+ ",\n";
+ print $syscache_info_fh "\t\t", $syscaches{$syscache}{index_oid_macro},
+ ",\n";
+ print $syscache_info_fh "\t\tKEY(", $syscaches{$syscache}{key}, "),\n";
+ print $syscache_info_fh "\t\t", $syscaches{$syscache}{nbuckets}, "\n";
+ print $syscache_info_fh "\t},\n";
+}
+
+print $syscache_ids_fh "};\n";
+print $syscache_ids_fh "#define SysCacheSize ($last_syscache + 1)\n";
+
+print $syscache_info_fh "};\n";
+
# We're done emitting data
close $bki;
close $schemapg;
close $fk_info;
close $constraints;
+close $syscache_ids_fh;
+close $syscache_info_fh;
# Finally, rename the completed files into place.
Catalog::RenameTempFile($bkifile, $tmpext);
Catalog::RenameTempFile($schemafile, $tmpext);
Catalog::RenameTempFile($fk_info_file, $tmpext);
Catalog::RenameTempFile($constraints_file, $tmpext);
+Catalog::RenameTempFile($syscache_ids_file, $tmpext);
+Catalog::RenameTempFile($syscache_info_file, $tmpext);
exit($num_errors != 0 ? 1 : 0);
#include "access/htup_details.h"
#include "access/sysattr.h"
-#include "catalog/pg_aggregate.h"
-#include "catalog/pg_am.h"
-#include "catalog/pg_amop.h"
-#include "catalog/pg_amproc.h"
-#include "catalog/pg_auth_members.h"
-#include "catalog/pg_authid.h"
-#include "catalog/pg_cast.h"
-#include "catalog/pg_collation.h"
-#include "catalog/pg_constraint.h"
-#include "catalog/pg_conversion.h"
-#include "catalog/pg_database.h"
-#include "catalog/pg_db_role_setting.h"
-#include "catalog/pg_default_acl.h"
-#include "catalog/pg_depend.h"
-#include "catalog/pg_description.h"
-#include "catalog/pg_enum.h"
-#include "catalog/pg_event_trigger.h"
-#include "catalog/pg_foreign_data_wrapper.h"
-#include "catalog/pg_foreign_server.h"
-#include "catalog/pg_foreign_table.h"
-#include "catalog/pg_language.h"
-#include "catalog/pg_namespace.h"
-#include "catalog/pg_opclass.h"
-#include "catalog/pg_operator.h"
-#include "catalog/pg_opfamily.h"
-#include "catalog/pg_parameter_acl.h"
-#include "catalog/pg_partitioned_table.h"
-#include "catalog/pg_proc.h"
-#include "catalog/pg_publication.h"
-#include "catalog/pg_publication_namespace.h"
-#include "catalog/pg_publication_rel.h"
-#include "catalog/pg_range.h"
-#include "catalog/pg_replication_origin.h"
-#include "catalog/pg_rewrite.h"
-#include "catalog/pg_seclabel.h"
-#include "catalog/pg_sequence.h"
-#include "catalog/pg_shdepend.h"
-#include "catalog/pg_shdescription.h"
-#include "catalog/pg_shseclabel.h"
-#include "catalog/pg_statistic.h"
-#include "catalog/pg_statistic_ext.h"
-#include "catalog/pg_statistic_ext_data.h"
-#include "catalog/pg_subscription.h"
-#include "catalog/pg_subscription_rel.h"
-#include "catalog/pg_tablespace.h"
-#include "catalog/pg_transform.h"
-#include "catalog/pg_ts_config.h"
-#include "catalog/pg_ts_config_map.h"
-#include "catalog/pg_ts_dict.h"
-#include "catalog/pg_ts_parser.h"
-#include "catalog/pg_ts_template.h"
-#include "catalog/pg_type.h"
-#include "catalog/pg_user_mapping.h"
+#include "catalog/pg_db_role_setting_d.h"
+#include "catalog/pg_depend_d.h"
+#include "catalog/pg_description_d.h"
+#include "catalog/pg_seclabel_d.h"
+#include "catalog/pg_shdepend_d.h"
+#include "catalog/pg_shdescription_d.h"
+#include "catalog/pg_shseclabel_d.h"
#include "lib/qunique.h"
#include "utils/catcache.h"
#include "utils/lsyscache.h"
Adding system caches:
- Add your new cache to the list in include/utils/syscache.h.
- Keep the list sorted alphabetically.
-
- Add your entry to the cacheinfo[] array below. All cache lists are
- alphabetical, so add it in the proper place. Specify the relation OID,
- index OID, number of keys, key attribute numbers, and initial number of
- hash buckets.
-
- The number of hash buckets must be a power of 2. It's reasonable to
- set this to the number of entries that might be in the particular cache
- in a medium-size database.
-
There must be a unique index underlying each syscache (ie, an index
whose key is the same as that of the cache). If there is not one
already, add the definition for it to include/catalog/pg_*.h using
(Adding an index requires a catversion.h update, while simply
adding/deleting caches only requires a recompile.)
+ Add a MAKE_SYSCACHE call to the same pg_*.h file specifying the name of
+ your cache, the underlying index, and the initial number of hash buckets.
+
+ The number of hash buckets must be a power of 2. It's reasonable to
+ set this to the number of entries that might be in the particular cache
+ in a medium-size database.
+
Finally, any place your relation gets heap_insert() or
heap_update() calls, use CatalogTupleInsert() or CatalogTupleUpdate()
instead, which also update indexes. The heap_* calls do not do that.
/* Macro to provide nkeys and key array with convenient syntax. */
#define KEY(...) VA_ARGS_NARGS(__VA_ARGS__), { __VA_ARGS__ }
-static const struct cachedesc cacheinfo[] = {
- [AGGFNOID] = {
- AggregateRelationId,
- AggregateFnoidIndexId,
- KEY(Anum_pg_aggregate_aggfnoid),
- 16
- },
- [AMNAME] = {
- AccessMethodRelationId,
- AmNameIndexId,
- KEY(Anum_pg_am_amname),
- 4
- },
- [AMOID] = {
- AccessMethodRelationId,
- AmOidIndexId,
- KEY(Anum_pg_am_oid),
- 4
- },
- [AMOPOPID] = {
- AccessMethodOperatorRelationId,
- AccessMethodOperatorIndexId,
- KEY(Anum_pg_amop_amopopr,
- Anum_pg_amop_amoppurpose,
- Anum_pg_amop_amopfamily),
- 64
- },
- [AMOPSTRATEGY] = {
- AccessMethodOperatorRelationId,
- AccessMethodStrategyIndexId,
- KEY(Anum_pg_amop_amopfamily,
- Anum_pg_amop_amoplefttype,
- Anum_pg_amop_amoprighttype,
- Anum_pg_amop_amopstrategy),
- 64
- },
- [AMPROCNUM] = {
- AccessMethodProcedureRelationId,
- AccessMethodProcedureIndexId,
- KEY(Anum_pg_amproc_amprocfamily,
- Anum_pg_amproc_amproclefttype,
- Anum_pg_amproc_amprocrighttype,
- Anum_pg_amproc_amprocnum),
- 16
- },
- [ATTNAME] = {
- AttributeRelationId,
- AttributeRelidNameIndexId,
- KEY(Anum_pg_attribute_attrelid,
- Anum_pg_attribute_attname),
- 32
- },
- [ATTNUM] = {
- AttributeRelationId,
- AttributeRelidNumIndexId,
- KEY(Anum_pg_attribute_attrelid,
- Anum_pg_attribute_attnum),
- 128
- },
- [AUTHMEMMEMROLE] = {
- AuthMemRelationId,
- AuthMemMemRoleIndexId,
- KEY(Anum_pg_auth_members_member,
- Anum_pg_auth_members_roleid,
- Anum_pg_auth_members_grantor),
- 8
- },
- [AUTHMEMROLEMEM] = {
- AuthMemRelationId,
- AuthMemRoleMemIndexId,
- KEY(Anum_pg_auth_members_roleid,
- Anum_pg_auth_members_member,
- Anum_pg_auth_members_grantor),
- 8
- },
- [AUTHNAME] = {
- AuthIdRelationId,
- AuthIdRolnameIndexId,
- KEY(Anum_pg_authid_rolname),
- 8
- },
- [AUTHOID] = {
- AuthIdRelationId,
- AuthIdOidIndexId,
- KEY(Anum_pg_authid_oid),
- 8
- },
- [CASTSOURCETARGET] = {
- CastRelationId,
- CastSourceTargetIndexId,
- KEY(Anum_pg_cast_castsource,
- Anum_pg_cast_casttarget),
- 256
- },
- [CLAAMNAMENSP] = {
- OperatorClassRelationId,
- OpclassAmNameNspIndexId,
- KEY(Anum_pg_opclass_opcmethod,
- Anum_pg_opclass_opcname,
- Anum_pg_opclass_opcnamespace),
- 8
- },
- [CLAOID] = {
- OperatorClassRelationId,
- OpclassOidIndexId,
- KEY(Anum_pg_opclass_oid),
- 8
- },
- [COLLNAMEENCNSP] = {
- CollationRelationId,
- CollationNameEncNspIndexId,
- KEY(Anum_pg_collation_collname,
- Anum_pg_collation_collencoding,
- Anum_pg_collation_collnamespace),
- 8
- },
- [COLLOID] = {
- CollationRelationId,
- CollationOidIndexId,
- KEY(Anum_pg_collation_oid),
- 8
- },
- [CONDEFAULT] = {
- ConversionRelationId,
- ConversionDefaultIndexId,
- KEY(Anum_pg_conversion_connamespace,
- Anum_pg_conversion_conforencoding,
- Anum_pg_conversion_contoencoding,
- Anum_pg_conversion_oid),
- 8
- },
- [CONNAMENSP] = {
- ConversionRelationId,
- ConversionNameNspIndexId,
- KEY(Anum_pg_conversion_conname,
- Anum_pg_conversion_connamespace),
- 8
- },
- [CONSTROID] = {
- ConstraintRelationId,
- ConstraintOidIndexId,
- KEY(Anum_pg_constraint_oid),
- 16
- },
- [CONVOID] = {
- ConversionRelationId,
- ConversionOidIndexId,
- KEY(Anum_pg_conversion_oid),
- 8
- },
- [DATABASEOID] = {
- DatabaseRelationId,
- DatabaseOidIndexId,
- KEY(Anum_pg_database_oid),
- 4
- },
- [DEFACLROLENSPOBJ] = {
- DefaultAclRelationId,
- DefaultAclRoleNspObjIndexId,
- KEY(Anum_pg_default_acl_defaclrole,
- Anum_pg_default_acl_defaclnamespace,
- Anum_pg_default_acl_defaclobjtype),
- 8
- },
- [ENUMOID] = {
- EnumRelationId,
- EnumOidIndexId,
- KEY(Anum_pg_enum_oid),
- 8
- },
- [ENUMTYPOIDNAME] = {
- EnumRelationId,
- EnumTypIdLabelIndexId,
- KEY(Anum_pg_enum_enumtypid,
- Anum_pg_enum_enumlabel),
- 8
- },
- [EVENTTRIGGERNAME] = {
- EventTriggerRelationId,
- EventTriggerNameIndexId,
- KEY(Anum_pg_event_trigger_evtname),
- 8
- },
- [EVENTTRIGGEROID] = {
- EventTriggerRelationId,
- EventTriggerOidIndexId,
- KEY(Anum_pg_event_trigger_oid),
- 8
- },
- [FOREIGNDATAWRAPPERNAME] = {
- ForeignDataWrapperRelationId,
- ForeignDataWrapperNameIndexId,
- KEY(Anum_pg_foreign_data_wrapper_fdwname),
- 2
- },
- [FOREIGNDATAWRAPPEROID] = {
- ForeignDataWrapperRelationId,
- ForeignDataWrapperOidIndexId,
- KEY(Anum_pg_foreign_data_wrapper_oid),
- 2
- },
- [FOREIGNSERVERNAME] = {
- ForeignServerRelationId,
- ForeignServerNameIndexId,
- KEY(Anum_pg_foreign_server_srvname),
- 2
- },
- [FOREIGNSERVEROID] = {
- ForeignServerRelationId,
- ForeignServerOidIndexId,
- KEY(Anum_pg_foreign_server_oid),
- 2
- },
- [FOREIGNTABLEREL] = {
- ForeignTableRelationId,
- ForeignTableRelidIndexId,
- KEY(Anum_pg_foreign_table_ftrelid),
- 4
- },
- [INDEXRELID] = {
- IndexRelationId,
- IndexRelidIndexId,
- KEY(Anum_pg_index_indexrelid),
- 64
- },
- [LANGNAME] = {
- LanguageRelationId,
- LanguageNameIndexId,
- KEY(Anum_pg_language_lanname),
- 4
- },
- [LANGOID] = {
- LanguageRelationId,
- LanguageOidIndexId,
- KEY(Anum_pg_language_oid),
- 4
- },
- [NAMESPACENAME] = {
- NamespaceRelationId,
- NamespaceNameIndexId,
- KEY(Anum_pg_namespace_nspname),
- 4
- },
- [NAMESPACEOID] = {
- NamespaceRelationId,
- NamespaceOidIndexId,
- KEY(Anum_pg_namespace_oid),
- 16
- },
- [OPERNAMENSP] = {
- OperatorRelationId,
- OperatorNameNspIndexId,
- KEY(Anum_pg_operator_oprname,
- Anum_pg_operator_oprleft,
- Anum_pg_operator_oprright,
- Anum_pg_operator_oprnamespace),
- 256
- },
- [OPEROID] = {
- OperatorRelationId,
- OperatorOidIndexId,
- KEY(Anum_pg_operator_oid),
- 32
- },
- [OPFAMILYAMNAMENSP] = {
- OperatorFamilyRelationId,
- OpfamilyAmNameNspIndexId,
- KEY(Anum_pg_opfamily_opfmethod,
- Anum_pg_opfamily_opfname,
- Anum_pg_opfamily_opfnamespace),
- 8
- },
- [OPFAMILYOID] = {
- OperatorFamilyRelationId,
- OpfamilyOidIndexId,
- KEY(Anum_pg_opfamily_oid),
- 8
- },
- [PARAMETERACLNAME] = {
- ParameterAclRelationId,
- ParameterAclParnameIndexId,
- KEY(Anum_pg_parameter_acl_parname),
- 4
- },
- [PARAMETERACLOID] = {
- ParameterAclRelationId,
- ParameterAclOidIndexId,
- KEY(Anum_pg_parameter_acl_oid),
- 4
- },
- [PARTRELID] = {
- PartitionedRelationId,
- PartitionedRelidIndexId,
- KEY(Anum_pg_partitioned_table_partrelid),
- 32
- },
- [PROCNAMEARGSNSP] = {
- ProcedureRelationId,
- ProcedureNameArgsNspIndexId,
- KEY(Anum_pg_proc_proname,
- Anum_pg_proc_proargtypes,
- Anum_pg_proc_pronamespace),
- 128
- },
- [PROCOID] = {
- ProcedureRelationId,
- ProcedureOidIndexId,
- KEY(Anum_pg_proc_oid),
- 128
- },
- [PUBLICATIONNAME] = {
- PublicationRelationId,
- PublicationNameIndexId,
- KEY(Anum_pg_publication_pubname),
- 8
- },
- [PUBLICATIONNAMESPACE] = {
- PublicationNamespaceRelationId,
- PublicationNamespaceObjectIndexId,
- KEY(Anum_pg_publication_namespace_oid),
- 64
- },
- [PUBLICATIONNAMESPACEMAP] = {
- PublicationNamespaceRelationId,
- PublicationNamespacePnnspidPnpubidIndexId,
- KEY(Anum_pg_publication_namespace_pnnspid,
- Anum_pg_publication_namespace_pnpubid),
- 64
- },
- [PUBLICATIONOID] = {
- PublicationRelationId,
- PublicationObjectIndexId,
- KEY(Anum_pg_publication_oid),
- 8
- },
- [PUBLICATIONREL] = {
- PublicationRelRelationId,
- PublicationRelObjectIndexId,
- KEY(Anum_pg_publication_rel_oid),
- 64
- },
- [PUBLICATIONRELMAP] = {
- PublicationRelRelationId,
- PublicationRelPrrelidPrpubidIndexId,
- KEY(Anum_pg_publication_rel_prrelid,
- Anum_pg_publication_rel_prpubid),
- 64
- },
- [RANGEMULTIRANGE] = {
- RangeRelationId,
- RangeMultirangeTypidIndexId,
- KEY(Anum_pg_range_rngmultitypid),
- 4
- },
- [RANGETYPE] = {
- RangeRelationId,
- RangeTypidIndexId,
- KEY(Anum_pg_range_rngtypid),
- 4
- },
- [RELNAMENSP] = {
- RelationRelationId,
- ClassNameNspIndexId,
- KEY(Anum_pg_class_relname,
- Anum_pg_class_relnamespace),
- 128
- },
- [RELOID] = {
- RelationRelationId,
- ClassOidIndexId,
- KEY(Anum_pg_class_oid),
- 128
- },
- [REPLORIGIDENT] = {
- ReplicationOriginRelationId,
- ReplicationOriginIdentIndex,
- KEY(Anum_pg_replication_origin_roident),
- 16
- },
- [REPLORIGNAME] = {
- ReplicationOriginRelationId,
- ReplicationOriginNameIndex,
- KEY(Anum_pg_replication_origin_roname),
- 16
- },
- [RULERELNAME] = {
- RewriteRelationId,
- RewriteRelRulenameIndexId,
- KEY(Anum_pg_rewrite_ev_class,
- Anum_pg_rewrite_rulename),
- 8
- },
- [SEQRELID] = {
- SequenceRelationId,
- SequenceRelidIndexId,
- KEY(Anum_pg_sequence_seqrelid),
- 32
- },
- [STATEXTDATASTXOID] = {
- StatisticExtDataRelationId,
- StatisticExtDataStxoidInhIndexId,
- KEY(Anum_pg_statistic_ext_data_stxoid,
- Anum_pg_statistic_ext_data_stxdinherit),
- 4
- },
- [STATEXTNAMENSP] = {
- StatisticExtRelationId,
- StatisticExtNameIndexId,
- KEY(Anum_pg_statistic_ext_stxname,
- Anum_pg_statistic_ext_stxnamespace),
- 4
- },
- [STATEXTOID] = {
- StatisticExtRelationId,
- StatisticExtOidIndexId,
- KEY(Anum_pg_statistic_ext_oid),
- 4
- },
- [STATRELATTINH] = {
- StatisticRelationId,
- StatisticRelidAttnumInhIndexId,
- KEY(Anum_pg_statistic_starelid,
- Anum_pg_statistic_staattnum,
- Anum_pg_statistic_stainherit),
- 128
- },
- [SUBSCRIPTIONNAME] = {
- SubscriptionRelationId,
- SubscriptionNameIndexId,
- KEY(Anum_pg_subscription_subdbid,
- Anum_pg_subscription_subname),
- 4
- },
- [SUBSCRIPTIONOID] = {
- SubscriptionRelationId,
- SubscriptionObjectIndexId,
- KEY(Anum_pg_subscription_oid),
- 4
- },
- [SUBSCRIPTIONRELMAP] = {
- SubscriptionRelRelationId,
- SubscriptionRelSrrelidSrsubidIndexId,
- KEY(Anum_pg_subscription_rel_srrelid,
- Anum_pg_subscription_rel_srsubid),
- 64
- },
- [TABLESPACEOID] = {
- TableSpaceRelationId,
- TablespaceOidIndexId,
- KEY(Anum_pg_tablespace_oid),
- 4
- },
- [TRFOID] = {
- TransformRelationId,
- TransformOidIndexId,
- KEY(Anum_pg_transform_oid),
- 16
- },
- [TRFTYPELANG] = {
- TransformRelationId,
- TransformTypeLangIndexId,
- KEY(Anum_pg_transform_trftype,
- Anum_pg_transform_trflang),
- 16
- },
- [TSCONFIGMAP] = {
- TSConfigMapRelationId,
- TSConfigMapIndexId,
- KEY(Anum_pg_ts_config_map_mapcfg,
- Anum_pg_ts_config_map_maptokentype,
- Anum_pg_ts_config_map_mapseqno),
- 2
- },
- [TSCONFIGNAMENSP] = {
- TSConfigRelationId,
- TSConfigNameNspIndexId,
- KEY(Anum_pg_ts_config_cfgname,
- Anum_pg_ts_config_cfgnamespace),
- 2
- },
- [TSCONFIGOID] = {
- TSConfigRelationId,
- TSConfigOidIndexId,
- KEY(Anum_pg_ts_config_oid),
- 2
- },
- [TSDICTNAMENSP] = {
- TSDictionaryRelationId,
- TSDictionaryNameNspIndexId,
- KEY(Anum_pg_ts_dict_dictname,
- Anum_pg_ts_dict_dictnamespace),
- 2
- },
- [TSDICTOID] = {
- TSDictionaryRelationId,
- TSDictionaryOidIndexId,
- KEY(Anum_pg_ts_dict_oid),
- 2
- },
- [TSPARSERNAMENSP] = {
- TSParserRelationId,
- TSParserNameNspIndexId,
- KEY(Anum_pg_ts_parser_prsname,
- Anum_pg_ts_parser_prsnamespace),
- 2
- },
- [TSPARSEROID] = {
- TSParserRelationId,
- TSParserOidIndexId,
- KEY(Anum_pg_ts_parser_oid),
- 2
- },
- [TSTEMPLATENAMENSP] = {
- TSTemplateRelationId,
- TSTemplateNameNspIndexId,
- KEY(Anum_pg_ts_template_tmplname,
- Anum_pg_ts_template_tmplnamespace),
- 2
- },
- [TSTEMPLATEOID] = {
- TSTemplateRelationId,
- TSTemplateOidIndexId,
- KEY(Anum_pg_ts_template_oid),
- 2
- },
- [TYPENAMENSP] = {
- TypeRelationId,
- TypeNameNspIndexId,
- KEY(Anum_pg_type_typname,
- Anum_pg_type_typnamespace),
- 64
- },
- [TYPEOID] = {
- TypeRelationId,
- TypeOidIndexId,
- KEY(Anum_pg_type_oid),
- 64
- },
- [USERMAPPINGOID] = {
- UserMappingRelationId,
- UserMappingOidIndexId,
- KEY(Anum_pg_user_mapping_oid),
- 2
- },
- [USERMAPPINGUSERSERVER] = {
- UserMappingRelationId,
- UserMappingUserServerIndexId,
- KEY(Anum_pg_user_mapping_umuser,
- Anum_pg_user_mapping_umserver),
- 2
- }
-};
+#include "catalog/syscache_info.h"
StaticAssertDecl(lengthof(cacheinfo) == SysCacheSize,
"SysCacheSize does not match syscache.c's array");
/schemapg.h
+/syscache_ids.h
+/syscache_info.h
/system_fk_info.h
/pg_*_d.h
/header-stamp
#define DECLARE_ARRAY_FOREIGN_KEY(cols,reftbl,refcols) extern int no_such_variable
#define DECLARE_ARRAY_FOREIGN_KEY_OPT(cols,reftbl,refcols) extern int no_such_variable
+/*
+ * Create a syscache with the given name, index, and bucket size. See
+ * syscache.c.
+ */
+#define MAKE_SYSCACHE(name,idxname,nbuckets) extern int no_such_variable
+
/* The following are never defined; they are here only for documentation. */
/*
input = []
-output_files = ['postgres.bki', 'system_constraints.sql', 'schemapg.h', 'system_fk_info.h']
-output_install = [dir_data, dir_data, dir_include_server / 'catalog', dir_include_server / 'catalog']
+output_files = [
+ 'postgres.bki',
+ 'system_constraints.sql',
+ 'schemapg.h',
+ 'syscache_ids.h',
+ 'syscache_info.h',
+ 'system_fk_info.h',
+]
+output_install = [
+ dir_data,
+ dir_data,
+ dir_include_server / 'catalog',
+ false,
+ dir_include_server / 'catalog',
+ dir_include_server / 'catalog',
+]
foreach h : catalog_headers
fname = h.split('.h')[0] + '_d.h'
DECLARE_UNIQUE_INDEX_PKEY(pg_aggregate_fnoid_index, 2650, AggregateFnoidIndexId, pg_aggregate, btree(aggfnoid oid_ops));
+MAKE_SYSCACHE(AGGFNOID, pg_aggregate_fnoid_index, 16);
+
#ifdef EXPOSE_TO_CLIENT_CODE
/*
DECLARE_UNIQUE_INDEX(pg_am_name_index, 2651, AmNameIndexId, pg_am, btree(amname name_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_am_oid_index, 2652, AmOidIndexId, pg_am, btree(oid oid_ops));
+MAKE_SYSCACHE(AMNAME, pg_am_name_index, 4);
+MAKE_SYSCACHE(AMOID, pg_am_oid_index, 4);
+
#ifdef EXPOSE_TO_CLIENT_CODE
/*
DECLARE_UNIQUE_INDEX(pg_amop_opr_fam_index, 2654, AccessMethodOperatorIndexId, pg_amop, btree(amopopr oid_ops, amoppurpose char_ops, amopfamily oid_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_amop_oid_index, 2756, AccessMethodOperatorOidIndexId, pg_amop, btree(oid oid_ops));
+MAKE_SYSCACHE(AMOPSTRATEGY, pg_amop_fam_strat_index, 64);
+MAKE_SYSCACHE(AMOPOPID, pg_amop_opr_fam_index, 64);
+
#ifdef EXPOSE_TO_CLIENT_CODE
/* allowed values of amoppurpose: */
DECLARE_UNIQUE_INDEX(pg_amproc_fam_proc_index, 2655, AccessMethodProcedureIndexId, pg_amproc, btree(amprocfamily oid_ops, amproclefttype oid_ops, amprocrighttype oid_ops, amprocnum int2_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_amproc_oid_index, 2757, AccessMethodProcedureOidIndexId, pg_amproc, btree(oid oid_ops));
+MAKE_SYSCACHE(AMPROCNUM, pg_amproc_fam_proc_index, 16);
+
#endif /* PG_AMPROC_H */
DECLARE_UNIQUE_INDEX(pg_attribute_relid_attnam_index, 2658, AttributeRelidNameIndexId, pg_attribute, btree(attrelid oid_ops, attname name_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_attribute_relid_attnum_index, 2659, AttributeRelidNumIndexId, pg_attribute, btree(attrelid oid_ops, attnum int2_ops));
+MAKE_SYSCACHE(ATTNAME, pg_attribute_relid_attnam_index, 32);
+MAKE_SYSCACHE(ATTNUM, pg_attribute_relid_attnum_index, 128);
+
#ifdef EXPOSE_TO_CLIENT_CODE
#define ATTRIBUTE_IDENTITY_ALWAYS 'a'
DECLARE_UNIQUE_INDEX(pg_auth_members_member_role_index, 2695, AuthMemMemRoleIndexId, pg_auth_members, btree(member oid_ops, roleid oid_ops, grantor oid_ops));
DECLARE_INDEX(pg_auth_members_grantor_index, 6302, AuthMemGrantorIndexId, pg_auth_members, btree(grantor oid_ops));
+MAKE_SYSCACHE(AUTHMEMROLEMEM, pg_auth_members_role_member_index, 8);
+MAKE_SYSCACHE(AUTHMEMMEMROLE, pg_auth_members_member_role_index, 8);
+
#endif /* PG_AUTH_MEMBERS_H */
DECLARE_UNIQUE_INDEX(pg_authid_rolname_index, 2676, AuthIdRolnameIndexId, pg_authid, btree(rolname name_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_authid_oid_index, 2677, AuthIdOidIndexId, pg_authid, btree(oid oid_ops));
+MAKE_SYSCACHE(AUTHNAME, pg_authid_rolname_index, 8);
+MAKE_SYSCACHE(AUTHOID, pg_authid_oid_index, 8);
+
#endif /* PG_AUTHID_H */
DECLARE_UNIQUE_INDEX_PKEY(pg_cast_oid_index, 2660, CastOidIndexId, pg_cast, btree(oid oid_ops));
DECLARE_UNIQUE_INDEX(pg_cast_source_target_index, 2661, CastSourceTargetIndexId, pg_cast, btree(castsource oid_ops, casttarget oid_ops));
+MAKE_SYSCACHE(CASTSOURCETARGET, pg_cast_source_target_index, 256);
+
#ifdef EXPOSE_TO_CLIENT_CODE
/*
DECLARE_UNIQUE_INDEX(pg_class_relname_nsp_index, 2663, ClassNameNspIndexId, pg_class, btree(relname name_ops, relnamespace oid_ops));
DECLARE_INDEX(pg_class_tblspc_relfilenode_index, 3455, ClassTblspcRelfilenodeIndexId, pg_class, btree(reltablespace oid_ops, relfilenode oid_ops));
+MAKE_SYSCACHE(RELOID, pg_class_oid_index, 128);
+MAKE_SYSCACHE(RELNAMENSP, pg_class_relname_nsp_index, 128);
+
#ifdef EXPOSE_TO_CLIENT_CODE
#define RELKIND_RELATION 'r' /* ordinary table */
DECLARE_UNIQUE_INDEX(pg_collation_name_enc_nsp_index, 3164, CollationNameEncNspIndexId, pg_collation, btree(collname name_ops, collencoding int4_ops, collnamespace oid_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_collation_oid_index, 3085, CollationOidIndexId, pg_collation, btree(oid oid_ops));
+MAKE_SYSCACHE(COLLNAMEENCNSP, pg_collation_name_enc_nsp_index, 8);
+MAKE_SYSCACHE(COLLOID, pg_collation_oid_index, 8);
+
#ifdef EXPOSE_TO_CLIENT_CODE
#define COLLPROVIDER_DEFAULT 'd'
DECLARE_UNIQUE_INDEX_PKEY(pg_constraint_oid_index, 2667, ConstraintOidIndexId, pg_constraint, btree(oid oid_ops));
DECLARE_INDEX(pg_constraint_conparentid_index, 2579, ConstraintParentIndexId, pg_constraint, btree(conparentid oid_ops));
+MAKE_SYSCACHE(CONSTROID, pg_constraint_oid_index, 16);
+
/* conkey can contain zero (InvalidAttrNumber) if a whole-row Var is used */
DECLARE_ARRAY_FOREIGN_KEY_OPT((conrelid, conkey), pg_attribute, (attrelid, attnum));
DECLARE_ARRAY_FOREIGN_KEY((confrelid, confkey), pg_attribute, (attrelid, attnum));
DECLARE_UNIQUE_INDEX(pg_conversion_name_nsp_index, 2669, ConversionNameNspIndexId, pg_conversion, btree(conname name_ops, connamespace oid_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_conversion_oid_index, 2670, ConversionOidIndexId, pg_conversion, btree(oid oid_ops));
+MAKE_SYSCACHE(CONDEFAULT, pg_conversion_default_index, 8);
+MAKE_SYSCACHE(CONNAMENSP, pg_conversion_name_nsp_index, 8);
+MAKE_SYSCACHE(CONVOID, pg_conversion_oid_index, 8);
+
extern ObjectAddress ConversionCreate(const char *conname, Oid connamespace,
Oid conowner,
DECLARE_UNIQUE_INDEX(pg_database_datname_index, 2671, DatabaseNameIndexId, pg_database, btree(datname name_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_database_oid_index, 2672, DatabaseOidIndexId, pg_database, btree(oid oid_ops));
+MAKE_SYSCACHE(DATABASEOID, pg_database_oid_index, 4);
+
/*
* pg_database.dat contains an entry for template1, but not for the template0
* or postgres databases, because those are created later in initdb.
DECLARE_UNIQUE_INDEX(pg_default_acl_role_nsp_obj_index, 827, DefaultAclRoleNspObjIndexId, pg_default_acl, btree(defaclrole oid_ops, defaclnamespace oid_ops, defaclobjtype char_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_default_acl_oid_index, 828, DefaultAclOidIndexId, pg_default_acl, btree(oid oid_ops));
+MAKE_SYSCACHE(DEFACLROLENSPOBJ, pg_default_acl_role_nsp_obj_index, 8);
+
#ifdef EXPOSE_TO_CLIENT_CODE
/*
DECLARE_UNIQUE_INDEX(pg_enum_typid_label_index, 3503, EnumTypIdLabelIndexId, pg_enum, btree(enumtypid oid_ops, enumlabel name_ops));
DECLARE_UNIQUE_INDEX(pg_enum_typid_sortorder_index, 3534, EnumTypIdSortOrderIndexId, pg_enum, btree(enumtypid oid_ops, enumsortorder float4_ops));
+MAKE_SYSCACHE(ENUMOID, pg_enum_oid_index, 8);
+MAKE_SYSCACHE(ENUMTYPOIDNAME, pg_enum_typid_label_index, 8);
+
/*
* prototypes for functions in pg_enum.c
*/
DECLARE_UNIQUE_INDEX(pg_event_trigger_evtname_index, 3467, EventTriggerNameIndexId, pg_event_trigger, btree(evtname name_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_event_trigger_oid_index, 3468, EventTriggerOidIndexId, pg_event_trigger, btree(oid oid_ops));
+MAKE_SYSCACHE(EVENTTRIGGERNAME, pg_event_trigger_evtname_index, 8);
+MAKE_SYSCACHE(EVENTTRIGGEROID, pg_event_trigger_oid_index, 8);
+
#endif /* PG_EVENT_TRIGGER_H */
DECLARE_UNIQUE_INDEX_PKEY(pg_foreign_data_wrapper_oid_index, 112, ForeignDataWrapperOidIndexId, pg_foreign_data_wrapper, btree(oid oid_ops));
DECLARE_UNIQUE_INDEX(pg_foreign_data_wrapper_name_index, 548, ForeignDataWrapperNameIndexId, pg_foreign_data_wrapper, btree(fdwname name_ops));
+MAKE_SYSCACHE(FOREIGNDATAWRAPPEROID, pg_foreign_data_wrapper_oid_index, 2);
+MAKE_SYSCACHE(FOREIGNDATAWRAPPERNAME, pg_foreign_data_wrapper_name_index, 2);
+
#endif /* PG_FOREIGN_DATA_WRAPPER_H */
DECLARE_UNIQUE_INDEX_PKEY(pg_foreign_server_oid_index, 113, ForeignServerOidIndexId, pg_foreign_server, btree(oid oid_ops));
DECLARE_UNIQUE_INDEX(pg_foreign_server_name_index, 549, ForeignServerNameIndexId, pg_foreign_server, btree(srvname name_ops));
+MAKE_SYSCACHE(FOREIGNSERVEROID, pg_foreign_server_oid_index, 2);
+MAKE_SYSCACHE(FOREIGNSERVERNAME, pg_foreign_server_name_index, 2);
+
#endif /* PG_FOREIGN_SERVER_H */
DECLARE_UNIQUE_INDEX_PKEY(pg_foreign_table_relid_index, 3119, ForeignTableRelidIndexId, pg_foreign_table, btree(ftrelid oid_ops));
+MAKE_SYSCACHE(FOREIGNTABLEREL, pg_foreign_table_relid_index, 4);
+
#endif /* PG_FOREIGN_TABLE_H */
DECLARE_INDEX(pg_index_indrelid_index, 2678, IndexIndrelidIndexId, pg_index, btree(indrelid oid_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_index_indexrelid_index, 2679, IndexRelidIndexId, pg_index, btree(indexrelid oid_ops));
+MAKE_SYSCACHE(INDEXRELID, pg_index_indexrelid_index, 64);
+
/* indkey can contain zero (InvalidAttrNumber) to represent expressions */
DECLARE_ARRAY_FOREIGN_KEY_OPT((indrelid, indkey), pg_attribute, (attrelid, attnum));
DECLARE_UNIQUE_INDEX(pg_language_name_index, 2681, LanguageNameIndexId, pg_language, btree(lanname name_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_language_oid_index, 2682, LanguageOidIndexId, pg_language, btree(oid oid_ops));
+MAKE_SYSCACHE(LANGNAME, pg_language_name_index, 4);
+MAKE_SYSCACHE(LANGOID, pg_language_oid_index, 4);
+
#endif /* PG_LANGUAGE_H */
DECLARE_UNIQUE_INDEX(pg_namespace_nspname_index, 2684, NamespaceNameIndexId, pg_namespace, btree(nspname name_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_namespace_oid_index, 2685, NamespaceOidIndexId, pg_namespace, btree(oid oid_ops));
+MAKE_SYSCACHE(NAMESPACENAME, pg_namespace_nspname_index, 4);
+MAKE_SYSCACHE(NAMESPACEOID, pg_namespace_oid_index, 16);
+
/*
* prototypes for functions in pg_namespace.c
*/
DECLARE_UNIQUE_INDEX(pg_opclass_am_name_nsp_index, 2686, OpclassAmNameNspIndexId, pg_opclass, btree(opcmethod oid_ops, opcname name_ops, opcnamespace oid_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_opclass_oid_index, 2687, OpclassOidIndexId, pg_opclass, btree(oid oid_ops));
+MAKE_SYSCACHE(CLAAMNAMENSP, pg_opclass_am_name_nsp_index, 8);
+MAKE_SYSCACHE(CLAOID, pg_opclass_oid_index, 8);
+
#endif /* PG_OPCLASS_H */
DECLARE_UNIQUE_INDEX_PKEY(pg_operator_oid_index, 2688, OperatorOidIndexId, pg_operator, btree(oid oid_ops));
DECLARE_UNIQUE_INDEX(pg_operator_oprname_l_r_n_index, 2689, OperatorNameNspIndexId, pg_operator, btree(oprname name_ops, oprleft oid_ops, oprright oid_ops, oprnamespace oid_ops));
+MAKE_SYSCACHE(OPEROID, pg_operator_oid_index, 32);
+MAKE_SYSCACHE(OPERNAMENSP, pg_operator_oprname_l_r_n_index, 256);
extern Oid OperatorLookup(List *operatorName,
Oid leftObjectId,
DECLARE_UNIQUE_INDEX(pg_opfamily_am_name_nsp_index, 2754, OpfamilyAmNameNspIndexId, pg_opfamily, btree(opfmethod oid_ops, opfname name_ops, opfnamespace oid_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_opfamily_oid_index, 2755, OpfamilyOidIndexId, pg_opfamily, btree(oid oid_ops));
+MAKE_SYSCACHE(OPFAMILYAMNAMENSP, pg_opfamily_am_name_nsp_index, 8);
+MAKE_SYSCACHE(OPFAMILYOID, pg_opfamily_oid_index, 8);
+
#ifdef EXPOSE_TO_CLIENT_CODE
/* This does not account for non-core opfamilies that might accept boolean */
DECLARE_UNIQUE_INDEX(pg_parameter_acl_parname_index, 6246, ParameterAclParnameIndexId, pg_parameter_acl, btree(parname text_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_parameter_acl_oid_index, 6247, ParameterAclOidIndexId, pg_parameter_acl, btree(oid oid_ops));
+MAKE_SYSCACHE(PARAMETERACLNAME, pg_parameter_acl_parname_index, 4);
+MAKE_SYSCACHE(PARAMETERACLOID, pg_parameter_acl_oid_index, 4);
extern Oid ParameterAclLookup(const char *parameter, bool missing_ok);
extern Oid ParameterAclCreate(const char *parameter);
DECLARE_UNIQUE_INDEX_PKEY(pg_partitioned_table_partrelid_index, 3351, PartitionedRelidIndexId, pg_partitioned_table, btree(partrelid oid_ops));
+MAKE_SYSCACHE(PARTRELID, pg_partitioned_table_partrelid_index, 32);
+
/* partattrs can contain zero (InvalidAttrNumber) to represent expressions */
DECLARE_ARRAY_FOREIGN_KEY_OPT((partrelid, partattrs), pg_attribute, (attrelid, attnum));
DECLARE_UNIQUE_INDEX_PKEY(pg_proc_oid_index, 2690, ProcedureOidIndexId, pg_proc, btree(oid oid_ops));
DECLARE_UNIQUE_INDEX(pg_proc_proname_args_nsp_index, 2691, ProcedureNameArgsNspIndexId, pg_proc, btree(proname name_ops, proargtypes oidvector_ops, pronamespace oid_ops));
+MAKE_SYSCACHE(PROCOID, pg_proc_oid_index, 128);
+MAKE_SYSCACHE(PROCNAMEARGSNSP, pg_proc_proname_args_nsp_index, 128);
+
#ifdef EXPOSE_TO_CLIENT_CODE
/*
DECLARE_UNIQUE_INDEX_PKEY(pg_publication_oid_index, 6110, PublicationObjectIndexId, pg_publication, btree(oid oid_ops));
DECLARE_UNIQUE_INDEX(pg_publication_pubname_index, 6111, PublicationNameIndexId, pg_publication, btree(pubname name_ops));
+MAKE_SYSCACHE(PUBLICATIONOID, pg_publication_oid_index, 8);
+MAKE_SYSCACHE(PUBLICATIONNAME, pg_publication_pubname_index, 8);
+
typedef struct PublicationActions
{
bool pubinsert;
DECLARE_UNIQUE_INDEX_PKEY(pg_publication_namespace_oid_index, 6238, PublicationNamespaceObjectIndexId, pg_publication_namespace, btree(oid oid_ops));
DECLARE_UNIQUE_INDEX(pg_publication_namespace_pnnspid_pnpubid_index, 6239, PublicationNamespacePnnspidPnpubidIndexId, pg_publication_namespace, btree(pnnspid oid_ops, pnpubid oid_ops));
+MAKE_SYSCACHE(PUBLICATIONNAMESPACE, pg_publication_namespace_oid_index, 64);
+MAKE_SYSCACHE(PUBLICATIONNAMESPACEMAP, pg_publication_namespace_pnnspid_pnpubid_index, 64);
+
#endif /* PG_PUBLICATION_NAMESPACE_H */
DECLARE_UNIQUE_INDEX(pg_publication_rel_prrelid_prpubid_index, 6113, PublicationRelPrrelidPrpubidIndexId, pg_publication_rel, btree(prrelid oid_ops, prpubid oid_ops));
DECLARE_INDEX(pg_publication_rel_prpubid_index, 6116, PublicationRelPrpubidIndexId, pg_publication_rel, btree(prpubid oid_ops));
+MAKE_SYSCACHE(PUBLICATIONREL, pg_publication_rel_oid_index, 64);
+MAKE_SYSCACHE(PUBLICATIONRELMAP, pg_publication_rel_prrelid_prpubid_index, 64);
+
#endif /* PG_PUBLICATION_REL_H */
DECLARE_UNIQUE_INDEX_PKEY(pg_range_rngtypid_index, 3542, RangeTypidIndexId, pg_range, btree(rngtypid oid_ops));
DECLARE_UNIQUE_INDEX(pg_range_rngmultitypid_index, 2228, RangeMultirangeTypidIndexId, pg_range, btree(rngmultitypid oid_ops));
+MAKE_SYSCACHE(RANGETYPE, pg_range_rngtypid_index, 4);
+MAKE_SYSCACHE(RANGEMULTIRANGE, pg_range_rngmultitypid_index, 4);
+
/*
* prototypes for functions in pg_range.c
*/
DECLARE_UNIQUE_INDEX_PKEY(pg_replication_origin_roiident_index, 6001, ReplicationOriginIdentIndex, pg_replication_origin, btree(roident oid_ops));
DECLARE_UNIQUE_INDEX(pg_replication_origin_roname_index, 6002, ReplicationOriginNameIndex, pg_replication_origin, btree(roname text_ops));
+MAKE_SYSCACHE(REPLORIGIDENT, pg_replication_origin_roiident_index, 16);
+MAKE_SYSCACHE(REPLORIGNAME, pg_replication_origin_roname_index, 16);
+
#endif /* PG_REPLICATION_ORIGIN_H */
DECLARE_UNIQUE_INDEX_PKEY(pg_rewrite_oid_index, 2692, RewriteOidIndexId, pg_rewrite, btree(oid oid_ops));
DECLARE_UNIQUE_INDEX(pg_rewrite_rel_rulename_index, 2693, RewriteRelRulenameIndexId, pg_rewrite, btree(ev_class oid_ops, rulename name_ops));
+MAKE_SYSCACHE(RULERELNAME, pg_rewrite_rel_rulename_index, 8);
+
#endif /* PG_REWRITE_H */
DECLARE_UNIQUE_INDEX_PKEY(pg_sequence_seqrelid_index, 5002, SequenceRelidIndexId, pg_sequence, btree(seqrelid oid_ops));
+MAKE_SYSCACHE(SEQRELID, pg_sequence_seqrelid_index, 32);
+
#endif /* PG_SEQUENCE_H */
DECLARE_UNIQUE_INDEX_PKEY(pg_statistic_relid_att_inh_index, 2696, StatisticRelidAttnumInhIndexId, pg_statistic, btree(starelid oid_ops, staattnum int2_ops, stainherit bool_ops));
+MAKE_SYSCACHE(STATRELATTINH, pg_statistic_relid_att_inh_index, 128);
+
DECLARE_FOREIGN_KEY((starelid, staattnum), pg_attribute, (attrelid, attnum));
#ifdef EXPOSE_TO_CLIENT_CODE
DECLARE_UNIQUE_INDEX(pg_statistic_ext_name_index, 3997, StatisticExtNameIndexId, pg_statistic_ext, btree(stxname name_ops, stxnamespace oid_ops));
DECLARE_INDEX(pg_statistic_ext_relid_index, 3379, StatisticExtRelidIndexId, pg_statistic_ext, btree(stxrelid oid_ops));
+MAKE_SYSCACHE(STATEXTOID, pg_statistic_ext_oid_index, 4);
+MAKE_SYSCACHE(STATEXTNAMENSP, pg_statistic_ext_name_index, 4);
+
DECLARE_ARRAY_FOREIGN_KEY((stxrelid, stxkeys), pg_attribute, (attrelid, attnum));
#ifdef EXPOSE_TO_CLIENT_CODE
DECLARE_UNIQUE_INDEX_PKEY(pg_statistic_ext_data_stxoid_inh_index, 3433, StatisticExtDataStxoidInhIndexId, pg_statistic_ext_data, btree(stxoid oid_ops, stxdinherit bool_ops));
+MAKE_SYSCACHE(STATEXTDATASTXOID, pg_statistic_ext_data_stxoid_inh_index, 4);
#endif /* PG_STATISTIC_EXT_DATA_H */
DECLARE_UNIQUE_INDEX_PKEY(pg_subscription_oid_index, 6114, SubscriptionObjectIndexId, pg_subscription, btree(oid oid_ops));
DECLARE_UNIQUE_INDEX(pg_subscription_subname_index, 6115, SubscriptionNameIndexId, pg_subscription, btree(subdbid oid_ops, subname name_ops));
+MAKE_SYSCACHE(SUBSCRIPTIONOID, pg_subscription_oid_index, 4);
+MAKE_SYSCACHE(SUBSCRIPTIONNAME, pg_subscription_subname_index, 4);
+
typedef struct Subscription
{
Oid oid; /* Oid of the subscription */
DECLARE_UNIQUE_INDEX_PKEY(pg_subscription_rel_srrelid_srsubid_index, 6117, SubscriptionRelSrrelidSrsubidIndexId, pg_subscription_rel, btree(srrelid oid_ops, srsubid oid_ops));
+MAKE_SYSCACHE(SUBSCRIPTIONRELMAP, pg_subscription_rel_srrelid_srsubid_index, 64);
+
#ifdef EXPOSE_TO_CLIENT_CODE
/* ----------------
DECLARE_UNIQUE_INDEX_PKEY(pg_tablespace_oid_index, 2697, TablespaceOidIndexId, pg_tablespace, btree(oid oid_ops));
DECLARE_UNIQUE_INDEX(pg_tablespace_spcname_index, 2698, TablespaceNameIndexId, pg_tablespace, btree(spcname name_ops));
+MAKE_SYSCACHE(TABLESPACEOID, pg_tablespace_oid_index, 4);
+
#endif /* PG_TABLESPACE_H */
DECLARE_UNIQUE_INDEX_PKEY(pg_transform_oid_index, 3574, TransformOidIndexId, pg_transform, btree(oid oid_ops));
DECLARE_UNIQUE_INDEX(pg_transform_type_lang_index, 3575, TransformTypeLangIndexId, pg_transform, btree(trftype oid_ops, trflang oid_ops));
+MAKE_SYSCACHE(TRFOID, pg_transform_oid_index, 16);
+MAKE_SYSCACHE(TRFTYPELANG, pg_transform_type_lang_index, 16);
+
#endif /* PG_TRANSFORM_H */
DECLARE_UNIQUE_INDEX(pg_ts_config_cfgname_index, 3608, TSConfigNameNspIndexId, pg_ts_config, btree(cfgname name_ops, cfgnamespace oid_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_ts_config_oid_index, 3712, TSConfigOidIndexId, pg_ts_config, btree(oid oid_ops));
+MAKE_SYSCACHE(TSCONFIGNAMENSP, pg_ts_config_cfgname_index, 2);
+MAKE_SYSCACHE(TSCONFIGOID, pg_ts_config_oid_index, 2);
+
#endif /* PG_TS_CONFIG_H */
DECLARE_UNIQUE_INDEX_PKEY(pg_ts_config_map_index, 3609, TSConfigMapIndexId, pg_ts_config_map, btree(mapcfg oid_ops, maptokentype int4_ops, mapseqno int4_ops));
+MAKE_SYSCACHE(TSCONFIGMAP, pg_ts_config_map_index, 2);
+
#endif /* PG_TS_CONFIG_MAP_H */
DECLARE_UNIQUE_INDEX(pg_ts_dict_dictname_index, 3604, TSDictionaryNameNspIndexId, pg_ts_dict, btree(dictname name_ops, dictnamespace oid_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_ts_dict_oid_index, 3605, TSDictionaryOidIndexId, pg_ts_dict, btree(oid oid_ops));
+MAKE_SYSCACHE(TSDICTNAMENSP, pg_ts_dict_dictname_index, 2);
+MAKE_SYSCACHE(TSDICTOID, pg_ts_dict_oid_index, 2);
+
#endif /* PG_TS_DICT_H */
DECLARE_UNIQUE_INDEX(pg_ts_parser_prsname_index, 3606, TSParserNameNspIndexId, pg_ts_parser, btree(prsname name_ops, prsnamespace oid_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_ts_parser_oid_index, 3607, TSParserOidIndexId, pg_ts_parser, btree(oid oid_ops));
+MAKE_SYSCACHE(TSPARSERNAMENSP, pg_ts_parser_prsname_index, 2);
+MAKE_SYSCACHE(TSPARSEROID, pg_ts_parser_oid_index, 2);
+
#endif /* PG_TS_PARSER_H */
DECLARE_UNIQUE_INDEX(pg_ts_template_tmplname_index, 3766, TSTemplateNameNspIndexId, pg_ts_template, btree(tmplname name_ops, tmplnamespace oid_ops));
DECLARE_UNIQUE_INDEX_PKEY(pg_ts_template_oid_index, 3767, TSTemplateOidIndexId, pg_ts_template, btree(oid oid_ops));
+MAKE_SYSCACHE(TSTEMPLATENAMENSP, pg_ts_template_tmplname_index, 2);
+MAKE_SYSCACHE(TSTEMPLATEOID, pg_ts_template_oid_index, 2);
+
#endif /* PG_TS_TEMPLATE_H */
DECLARE_UNIQUE_INDEX_PKEY(pg_type_oid_index, 2703, TypeOidIndexId, pg_type, btree(oid oid_ops));
DECLARE_UNIQUE_INDEX(pg_type_typname_nsp_index, 2704, TypeNameNspIndexId, pg_type, btree(typname name_ops, typnamespace oid_ops));
+MAKE_SYSCACHE(TYPEOID, pg_type_oid_index, 64);
+MAKE_SYSCACHE(TYPENAMENSP, pg_type_typname_nsp_index, 64);
+
#ifdef EXPOSE_TO_CLIENT_CODE
/*
DECLARE_UNIQUE_INDEX_PKEY(pg_user_mapping_oid_index, 174, UserMappingOidIndexId, pg_user_mapping, btree(oid oid_ops));
DECLARE_UNIQUE_INDEX(pg_user_mapping_user_server_index, 175, UserMappingUserServerIndexId, pg_user_mapping, btree(umuser oid_ops, umserver oid_ops));
+MAKE_SYSCACHE(USERMAPPINGOID, pg_user_mapping_oid_index, 2);
+MAKE_SYSCACHE(USERMAPPINGUSERSERVER, pg_user_mapping_user_server_index, 2);
+
#endif /* PG_USER_MAPPING_H */
#include "access/htup.h"
/* we intentionally do not include utils/catcache.h here */
-/*
- * SysCache identifiers.
- *
- * The order of these identifiers must match the order
- * of the entries in the array cacheinfo[] in syscache.c.
- * Keep them in alphabetical order (renumbering only costs a
- * backend rebuild).
- */
-
-enum SysCacheIdentifier
-{
- AGGFNOID = 0,
- AMNAME,
- AMOID,
- AMOPOPID,
- AMOPSTRATEGY,
- AMPROCNUM,
- ATTNAME,
- ATTNUM,
- AUTHMEMMEMROLE,
- AUTHMEMROLEMEM,
- AUTHNAME,
- AUTHOID,
- CASTSOURCETARGET,
- CLAAMNAMENSP,
- CLAOID,
- COLLNAMEENCNSP,
- COLLOID,
- CONDEFAULT,
- CONNAMENSP,
- CONSTROID,
- CONVOID,
- DATABASEOID,
- DEFACLROLENSPOBJ,
- ENUMOID,
- ENUMTYPOIDNAME,
- EVENTTRIGGERNAME,
- EVENTTRIGGEROID,
- FOREIGNDATAWRAPPERNAME,
- FOREIGNDATAWRAPPEROID,
- FOREIGNSERVERNAME,
- FOREIGNSERVEROID,
- FOREIGNTABLEREL,
- INDEXRELID,
- LANGNAME,
- LANGOID,
- NAMESPACENAME,
- NAMESPACEOID,
- OPERNAMENSP,
- OPEROID,
- OPFAMILYAMNAMENSP,
- OPFAMILYOID,
- PARAMETERACLNAME,
- PARAMETERACLOID,
- PARTRELID,
- PROCNAMEARGSNSP,
- PROCOID,
- PUBLICATIONNAME,
- PUBLICATIONNAMESPACE,
- PUBLICATIONNAMESPACEMAP,
- PUBLICATIONOID,
- PUBLICATIONREL,
- PUBLICATIONRELMAP,
- RANGEMULTIRANGE,
- RANGETYPE,
- RELNAMENSP,
- RELOID,
- REPLORIGIDENT,
- REPLORIGNAME,
- RULERELNAME,
- SEQRELID,
- STATEXTDATASTXOID,
- STATEXTNAMENSP,
- STATEXTOID,
- STATRELATTINH,
- SUBSCRIPTIONNAME,
- SUBSCRIPTIONOID,
- SUBSCRIPTIONRELMAP,
- TABLESPACEOID,
- TRFOID,
- TRFTYPELANG,
- TSCONFIGMAP,
- TSCONFIGNAMENSP,
- TSCONFIGOID,
- TSDICTNAMENSP,
- TSDICTOID,
- TSPARSERNAMENSP,
- TSPARSEROID,
- TSTEMPLATENAMENSP,
- TSTEMPLATEOID,
- TYPENAMENSP,
- TYPEOID,
- USERMAPPINGOID,
- USERMAPPINGUSERSERVER,
-
-#define SysCacheSize (USERMAPPINGUSERSERVER + 1)
-};
+#include "catalog/syscache_ids.h"
extern void InitCatalogCache(void);
extern void InitCatalogCachePhase2(void);
test "$f" = src/include/common/unicode_nonspacing_table.h && continue
test "$f" = src/include/common/unicode_east_asian_fw_table.h && continue
+ test "$f" = src/backend/catalog/syscache_ids.h && continue
+ test "$f" = src/backend/catalog/syscache_info.h && continue
+ test "$f" = src/include/catalog/syscache_ids.h && continue
+ test "$f" = src/include/catalog/syscache_info.h && continue
+
# We can't make these Bison output files compilable standalone
# without using "%code require", which old Bison versions lack.
# parser/gram.h will be included by parser/gramparse.h anyway.
test "$f" = src/include/common/unicode_nonspacing_table.h && continue
test "$f" = src/include/common/unicode_east_asian_fw_table.h && continue
+ test "$f" = src/backend/catalog/syscache_ids.h && continue
+ test "$f" = src/backend/catalog/syscache_info.h && continue
+ test "$f" = src/include/catalog/syscache_ids.h && continue
+ test "$f" = src/include/catalog/syscache_info.h && continue
+
# We can't make these Bison output files compilable standalone
# without using "%code require", which old Bison versions lack.
# parser/gram.h will be included by parser/gramparse.h anyway.
projects / users / c2main / postgres.git / commitdiff