def __init__(self, dbconn=None):
"""Initialize the various DbObjectDict-derived dictionaries
:param dbconn: a DbConnection object
"""
self.schemas = SchemaDict(dbconn)
self.extensions = ExtensionDict(dbconn)
self.languages = LanguageDict(dbconn)
self.casts = CastDict(dbconn)
self.types = TypeDict(dbconn)
self.tables = ClassDict(dbconn)
self.columns = ColumnDict(dbconn)
self.constraints = ConstraintDict(dbconn)
self.indexes = IndexDict(dbconn)
self.functions = ProcDict(dbconn)
self.operators = OperatorDict(dbconn)
self.operclasses = OperatorClassDict(dbconn)
self.operfams = OperatorFamilyDict(dbconn)
self.rules = RuleDict(dbconn)
self.triggers = TriggerDict(dbconn)
self.conversions = ConversionDict(dbconn)
self.tstempls = TSTemplateDict(dbconn)
self.tsdicts = TSDictionaryDict(dbconn)
self.tsparsers = TSParserDict(dbconn)
self.tsconfigs = TSConfigurationDict(dbconn)
self.fdwrappers = ForeignDataWrapperDict(dbconn)
self.servers = ForeignServerDict(dbconn)
self.usermaps = UserMappingDict(dbconn)
self.ftables = ForeignTableDict(dbconn)
self.collations = CollationDict(dbconn)
self.eventtrigs = EventTriggerDict(dbconn)
def __init__(self, dbconn=None, single_db=False):
"""Initialize the various DbObjectDict-derived dictionaries
:param dbconn: a DbConnection object
"""
self.schemas = SchemaDict(dbconn)
self.extensions = ExtensionDict(dbconn)
self.languages = LanguageDict(dbconn)
self.casts = CastDict(dbconn)
self.types = TypeDict(dbconn)
self.tables = ClassDict(dbconn)
self.columns = ColumnDict(dbconn)
self.constraints = ConstraintDict(dbconn)
self.indexes = IndexDict(dbconn)
self.functions = ProcDict(dbconn)
self.operators = OperatorDict(dbconn)
self.operclasses = OperatorClassDict(dbconn)
self.operfams = OperatorFamilyDict(dbconn)
self.rules = RuleDict(dbconn)
self.triggers = TriggerDict(dbconn)
self.conversions = ConversionDict(dbconn)
self.tstempls = TSTemplateDict(dbconn)
self.tsdicts = TSDictionaryDict(dbconn)
self.tsparsers = TSParserDict(dbconn)
self.tsconfigs = TSConfigurationDict(dbconn)
self.fdwrappers = ForeignDataWrapperDict(dbconn)
self.servers = ForeignServerDict(dbconn)
self.usermaps = UserMappingDict(dbconn)
self.ftables = ForeignTableDict(dbconn)
self.collations = CollationDict(dbconn)
self.eventtrigs = EventTriggerDict(dbconn)
# Populate a map from system catalog to the respective dict
self._catalog_map = {}
for _, d in self.all_dicts(single_db):
if d.cls.catalog is not None:
self._catalog_map[d.cls.catalog] = d
# Map from objects extkey to their (dict name, key)
self._extkey_map = {}
def __init__(self, dbconn=None, single_db=False):
"""Initialize the various DbObjectDict-derived dictionaries
:param dbconn: a DbConnection object
"""
self.schemas = SchemaDict(dbconn)
self.extensions = ExtensionDict(dbconn)
self.languages = LanguageDict(dbconn)
self.casts = CastDict(dbconn)
self.types = TypeDict(dbconn)
self.tables = ClassDict(dbconn)
self.columns = ColumnDict(dbconn)
self.constraints = ConstraintDict(dbconn)
self.indexes = IndexDict(dbconn)
self.functions = ProcDict(dbconn)
self.operators = OperatorDict(dbconn)
self.operclasses = OperatorClassDict(dbconn)
self.operfams = OperatorFamilyDict(dbconn)
self.rules = RuleDict(dbconn)
self.triggers = TriggerDict(dbconn)
self.conversions = ConversionDict(dbconn)
self.tstempls = TSTemplateDict(dbconn)
self.tsdicts = TSDictionaryDict(dbconn)
self.tsparsers = TSParserDict(dbconn)
self.tsconfigs = TSConfigurationDict(dbconn)
self.fdwrappers = ForeignDataWrapperDict(dbconn)
self.servers = ForeignServerDict(dbconn)
self.usermaps = UserMappingDict(dbconn)
self.ftables = ForeignTableDict(dbconn)
self.collations = CollationDict(dbconn)
self.eventtrigs = EventTriggerDict(dbconn)
# Populate a map from system catalog to the respective dict
self._catalog_map = {}
for _, d in self.all_dicts(single_db):
if d.cls.catalog is not None:
self._catalog_map[d.cls.catalog] = d
# Map from objects extkey to their (dict name, key)
self._extkey_map = {}
class Dicts(object):
"""A holder for dictionaries (maps) describing a database"""
def __init__(self, dbconn=None, single_db=False):
"""Initialize the various DbObjectDict-derived dictionaries
:param dbconn: a DbConnection object
"""
self.schemas = SchemaDict(dbconn)
self.extensions = ExtensionDict(dbconn)
self.languages = LanguageDict(dbconn)
self.casts = CastDict(dbconn)
self.types = TypeDict(dbconn)
self.tables = ClassDict(dbconn)
self.columns = ColumnDict(dbconn)
self.constraints = ConstraintDict(dbconn)
self.indexes = IndexDict(dbconn)
self.functions = ProcDict(dbconn)
self.operators = OperatorDict(dbconn)
self.operclasses = OperatorClassDict(dbconn)
self.operfams = OperatorFamilyDict(dbconn)
self.rules = RuleDict(dbconn)
self.triggers = TriggerDict(dbconn)
self.conversions = ConversionDict(dbconn)
self.tstempls = TSTemplateDict(dbconn)
self.tsdicts = TSDictionaryDict(dbconn)
self.tsparsers = TSParserDict(dbconn)
self.tsconfigs = TSConfigurationDict(dbconn)
self.fdwrappers = ForeignDataWrapperDict(dbconn)
self.servers = ForeignServerDict(dbconn)
self.usermaps = UserMappingDict(dbconn)
self.ftables = ForeignTableDict(dbconn)
self.collations = CollationDict(dbconn)
self.eventtrigs = EventTriggerDict(dbconn)
# Populate a map from system catalog to the respective dict
self._catalog_map = {}
for _, d in self.all_dicts(single_db):
if d.cls.catalog is not None:
self._catalog_map[d.cls.catalog] = d
# Map from objects extkey to their (dict name, key)
self._extkey_map = {}
def _get_by_extkey(self, extkey):
"""Return any database item from its extkey
Note: probably doesn't work for all the objects, e.g. constraints
may clash because two in different tables have different extkeys.
However this shouldn't matter as such objects are generated as part
of the containing one and they should be returned by the
`get_implied_deps()` implementation of specific classes (which
would look for the object in by key in the right dict instead,
(e.g. check `Domain.get_implied_deps()` implementation.
"""
try:
return self._extkey_map[extkey]
except KeyError:
# TODO: Likely it's the first time we call this function so
# let's warm up the cache. But we should really define the life
# cycle of this object as trying and catching KeyError on it is
# *very* expensive!
for _, d in self.all_dicts():
for obj in list(d.values()):
self._extkey_map[obj.extern_key()] = obj
return self._extkey_map[extkey]
def all_dicts(self, non_empty=False):
"""Iterate over the DbObjectDict-derived dictionaries returning
an ordered list of tuples (dict name, DbObjectDict object).
:param non_empty: do not include empty dicts
:return: list of tuples
"""
rv = []
for attr in self.__dict__:
d = getattr(self, attr)
if non_empty and len(d) == 0:
continue
if isinstance(d, DbObjectDict):
# skip ColumnDict as not needed for dependency tracking
# and internally has lists, not objects
if not isinstance(d, ColumnDict):
rv.append((attr, d))
# first return the dicts for non-schema objects, then the
# others, each group sorted alphabetically.
rv.sort(key=lambda pair: (issubclass(pair[1].cls, DbSchemaObject),
pair[1].cls.__name__))
return rv
def dbobjdict_from_catalog(self, catalog):
"""Given a catalog name, return corresponding DbObjectDict
:param catalog: full name of a pg_ catalog
:return: DbObjectDict object
"""
return self._catalog_map.get(catalog)
def find_type(self, name):
"""Return a db type given a qualname
Note that tables and views are types too.
"""
rv = self.types.find(name)
if rv is not None:
return rv
rv = self.tables.find(name)
return rv
class Dicts(object):
"""A holder for dictionaries (maps) describing a database"""
def __init__(self, dbconn=None, single_db=False):
"""Initialize the various DbObjectDict-derived dictionaries
:param dbconn: a DbConnection object
"""
self.schemas = SchemaDict(dbconn)
self.extensions = ExtensionDict(dbconn)
self.languages = LanguageDict(dbconn)
self.casts = CastDict(dbconn)
self.types = TypeDict(dbconn)
self.tables = ClassDict(dbconn)
self.columns = ColumnDict(dbconn)
self.constraints = ConstraintDict(dbconn)
self.indexes = IndexDict(dbconn)
self.functions = ProcDict(dbconn)
self.operators = OperatorDict(dbconn)
self.operclasses = OperatorClassDict(dbconn)
self.operfams = OperatorFamilyDict(dbconn)
self.rules = RuleDict(dbconn)
self.triggers = TriggerDict(dbconn)
self.conversions = ConversionDict(dbconn)
self.tstempls = TSTemplateDict(dbconn)
self.tsdicts = TSDictionaryDict(dbconn)
self.tsparsers = TSParserDict(dbconn)
self.tsconfigs = TSConfigurationDict(dbconn)
self.fdwrappers = ForeignDataWrapperDict(dbconn)
self.servers = ForeignServerDict(dbconn)
self.usermaps = UserMappingDict(dbconn)
self.ftables = ForeignTableDict(dbconn)
self.collations = CollationDict(dbconn)
self.eventtrigs = EventTriggerDict(dbconn)
# Populate a map from system catalog to the respective dict
self._catalog_map = {}
for _, d in self.all_dicts(single_db):
if d.cls.catalog is not None:
self._catalog_map[d.cls.catalog] = d
# Map from objects extkey to their (dict name, key)
self._extkey_map = {}
def _get_by_extkey(self, extkey):
"""Return any database item from its extkey
Note: probably doesn't work for all the objects, e.g. constraints
may clash because two in different tables have different extkeys.
However this shouldn't matter as such objects are generated as part
of the containing one and they should be returned by the
`get_implied_deps()` implementation of specific classes (which
would look for the object in by key in the right dict instead,
(e.g. check `Domain.get_implied_deps()` implementation.
"""
try:
return self._extkey_map[extkey]
except KeyError:
# TODO: Likely it's the first time we call this function so
# let's warm up the cache. But we should really define the life
# cycle of this object as trying and catching KeyError on it is
# *very* expensive!
for _, d in self.all_dicts():
for obj in list(d.values()):
self._extkey_map[obj.extern_key()] = obj
return self._extkey_map[extkey]
def all_dicts(self, non_empty=False):
"""Iterate over the DbObjectDict-derived dictionaries returning
an ordered list of tuples (dict name, DbObjectDict object).
:param non_empty: do not include empty dicts
:return: list of tuples
"""
rv = []
for attr in self.__dict__:
d = getattr(self, attr)
if non_empty and len(d) == 0:
continue
if isinstance(d, DbObjectDict):
# skip ColumnDict as not needed for dependency tracking
# and internally has lists, not objects
if not isinstance(d, ColumnDict):
rv.append((attr, d))
# first return the dicts for non-schema objects, then the
# others, each group sorted alphabetically.
rv.sort(key=lambda pair: (issubclass(pair[1].cls, DbSchemaObject),
pair[1].cls.__name__))
return rv
def dbobjdict_from_catalog(self, catalog):
"""Given a catalog name, return corresponding DbObjectDict
:param catalog: full name of a pg_ catalog
:return: DbObjectDict object
"""
return self._catalog_map.get(catalog)
def find_type(self, name):
"""Return a db type given a qualname
Note that tables and views are types too.
"""
rv = self.types.find(name)
if rv is not None:
return rv
rv = self.tables.find(name)
return rv