async def read_indexes(self, schema, only_modules, exclude_modules):
pg_index_data = await introspection.tables.fetch_indexes(
self.connection, schema_pattern='edgedb%', index_pattern='%_index')
pg_indexes = set()
for row in pg_index_data:
table_name = tuple(row['table_name'])
for pg_index in self.interpret_indexes(table_name, row['indexes']):
pg_indexes.add(
(table_name, pg_index.get_metadata('schemaname')))
ds = datasources.schema.indexes
indexes = await ds.fetch(self.connection,
modules=only_modules,
exclude_modules=exclude_modules)
basemap = {}
for index_data in indexes:
subj = schema.get(index_data['subject_name'])
subj_table_name = common.get_backend_name(schema,
subj,
catenate=False)
index_name = sn.Name(index_data['name'])
if index_data['is_local']:
try:
pg_indexes.remove((subj_table_name, index_name))
except KeyError:
raise errors.SchemaError(
'internal metadata inconsistency',
details=(
f'Index {index_name} is defined in schema, but '
f'the corresponding PostgreSQL index is missing.'
)) from None
schema, index = s_indexes.Index.create_in_schema(
schema,
id=index_data['id'],
name=index_name,
subject=subj,
is_local=index_data['is_local'],
inherited_fields=self._unpack_inherited_fields(
index_data['inherited_fields']),
expr=self.unpack_expr(index_data['expr'], schema))
schema = subj.add_index(schema, index)
basemap[index] = (index_data['bases'], index_data['ancestors'])
for scls, (basenames, ancestors) in basemap.items():
schema = self._set_reflist(schema, scls, 'bases', basenames)
schema = self._set_reflist(schema, scls, 'ancestors', ancestors)
if pg_indexes and not only_modules and not exclude_modules:
details = f'Extraneous PostgreSQL indexes found: {pg_indexes!r}'
raise errors.SchemaError('internal metadata inconsistency',
details=details)
return schema
async def read_indexes(self, schema, only_modules, exclude_modules):
pg_index_data = await introspection.tables.fetch_indexes(
self.connection,
schema_pattern='edgedb%', index_pattern='%_index')
pg_indexes = set()
for row in pg_index_data:
table_name = tuple(row['table_name'])
for pg_index in self.interpret_indexes(table_name, row['indexes']):
pg_indexes.add(
(table_name, pg_index.get_metadata('schemaname'))
)
ds = datasources.schema.indexes
indexes = await ds.fetch(
self.connection, modules=only_modules,
exclude_modules=exclude_modules)
for index_data in indexes:
subj = schema.get(index_data['subject_name'])
subj_table_name = common.get_backend_name(
schema, subj, catenate=False)
index_name = sn.Name(index_data['name'])
try:
pg_indexes.remove((subj_table_name, index_name))
except KeyError:
raise errors.SchemaError(
'internal metadata inconsistency',
details=f'Index {index_name} is defined in schema, but'
f'the corresponding PostgreSQL index is missing.'
) from None
schema, index = s_indexes.Index.create_in_schema(
schema,
id=index_data['id'],
name=index_name,
subject=subj,
expr=s_expr.Expression(**index_data['expr']))
schema = subj.add_index(schema, index)
if pg_indexes and not only_modules and not exclude_modules:
details = f'Extraneous PostgreSQL indexes found: {pg_indexes!r}'
raise errors.SchemaError(
'internal metadata inconsistency',
details=details)
return schema
async def read_modules(self, schema, only_modules, exclude_modules):
schemas = await introspection.schemas.fetch(self.connection,
schema_pattern='edgedb_%')
schemas = {
s['name']
for s in schemas if not s['name'].startswith('edgedb_aux_')
}
modules = await datasources.schema.modules.fetch(
self.connection,
modules=only_modules,
exclude_modules=exclude_modules)
modules = [{
'id': m['id'],
'name': m['name'],
'builtin': m['builtin']
} for m in modules]
recorded_schemas = set()
for module in modules:
schema, mod = s_mod.Module.create_in_schema(
schema,
id=module['id'],
name=module['name'],
builtin=module['builtin'])
recorded_schemas.add(common.get_backend_name(schema, mod))
# Sanity checks
extra_schemas = schemas - recorded_schemas - {'edgedb', 'edgedbss'}
missing_schemas = recorded_schemas - schemas
if extra_schemas and not only_modules and not exclude_modules:
msg = 'internal metadata incosistency'
details = 'Extraneous data schemas exist: {}'.format(', '.join(
'"%s"' % s for s in extra_schemas))
raise errors.SchemaError(msg, details=details)
if missing_schemas:
msg = 'internal metadata incosistency'
details = 'Missing schemas for modules: {}'.format(', '.join(
'{!r}'.format(s) for s in missing_schemas))
raise errors.SchemaError(msg, details=details)
return schema
def get_trigger_procname(self):
return common.get_backend_name(self._schema,
self._constraint,
catenate=False,
aspect='trigproc')
async def read_scalars(self, schema, only_modules, exclude_modules):
seqs = await introspection.sequences.fetch(
self.connection,
schema_pattern='edgedb%',
sequence_pattern='%_sequence')
seqs = {(s['schema'], s['name']): s for s in seqs}
seen_seqs = set()
scalar_list = await datasources.schema.scalars.fetch(
self.connection,
modules=only_modules,
exclude_modules=exclude_modules)
basemap = {}
for row in scalar_list:
name = sn.Name(row['name'])
scalar_data = {
'id':
row['id'],
'inherited_fields':
self._unpack_inherited_fields(row['inherited_fields']),
'name':
name,
'is_abstract':
row['is_abstract'],
'is_final':
row['is_final'],
'view_type': (s_types.ViewType(row['view_type'])
if row['view_type'] else None),
'view_is_persistent':
row['view_is_persistent'],
'default': (self.unpack_expr(row['default'], schema)
if row['default'] else None),
'expr': (self.unpack_expr(row['expr'], schema)
if row['expr'] else None),
'enum_values':
row['enum_values'],
}
schema, scalar = s_scalars.ScalarType.create_in_schema(
schema, **scalar_data)
basemap[scalar] = (row['bases'], row['ancestors'])
for scls, (basenames, ancestors) in basemap.items():
schema = self._set_reflist(schema, scls, 'bases', basenames)
schema = self._set_reflist(schema, scls, 'ancestors', ancestors)
sequence = schema.get('std::sequence', None)
for scalar in schema.get_objects(type=s_scalars.ScalarType):
if (sequence is not None and scalar.issubclass(schema, sequence)
and not scalar.get_is_abstract(schema)):
seq_name = common.get_backend_name(schema,
scalar,
catenate=False,
aspect='sequence')
if seq_name not in seqs:
msg = 'internal metadata incosistency'
details = (f'Missing sequence for sequence '
f'scalar {scalar.get_name(schema)}')
raise errors.SchemaError(msg, details=details)
seen_seqs.add(seq_name)
extra_seqs = set(seqs) - seen_seqs
if extra_seqs and not only_modules and not exclude_modules:
msg = 'internal metadata incosistency'
details = 'Extraneous sequences exist: {}'.format(', '.join(
common.qname(*t) for t in extra_seqs))
raise errors.SchemaError(msg, details=details)
return schema
