def diff_map(self, input_map, quote_reserved=True):
"""Generate SQL to transform an existing database
:param input_map: a YAML map defining the new database
:param quote_reserved: fetch reserved words
:return: list of SQL statements
Compares the existing database definition, as fetched from the
catalogs, to the input YAML map and generates SQL statements
to transform the database into the one represented by the
input.
"""
from .dbobject.table import Table
if not self.db:
self.from_catalog()
opts = self.config['options']
if opts.schemas:
schlist = ['schema ' + sch for sch in opts.schemas]
for sch in list(input_map.keys()):
if sch not in schlist and sch.startswith('schema '):
del input_map[sch]
self._trim_objects(opts.schemas)
# quote_reserved is only set to False by most tests
if quote_reserved:
fetch_reserved_words(self.dbconn)
langs = [lang[0] for lang in self.dbconn.fetchall(
"SELECT tmplname FROM pg_pltemplate")]
self.from_map(input_map, langs)
if opts.revert:
(self.db, self.ndb) = (self.ndb, self.db)
del self.ndb.schemas['pg_catalog']
self.db.languages.dbconn = self.dbconn
# First sort the objects in the new db in dependency order
new_objs = []
for _, d in self.ndb.all_dicts():
pairs = list(d.items())
pairs.sort()
new_objs.extend(list(map(itemgetter(1), pairs)))
new_objs = self.dep_sorted(new_objs, self.ndb)
# Then generate the sql for all the objects, walking in dependency
# order over all the db objects
stmts = []
for new in new_objs:
d = self.db.dbobjdict_from_catalog(new.catalog)
old = d.get(new.key())
if old is not None:
stmts.append(old.alter(new))
else:
stmts.append(new.create_sql(self.dbconn.version))
# Check if the object just created was renamed, in which case
# don't try to delete the original one
if getattr(new, 'oldname', None):
try:
origname, new.name = new.name, new.oldname
oldkey = new.key()
finally:
new.name = origname
# Intentionally raising KeyError as tested e.g. in
# test_bad_rename_view -- ok Joe?
old = d[oldkey]
old._nodrop = True
# Order the old database objects in reverse dependency order
old_objs = []
for _, d in self.db.all_dicts():
pairs = list(d.items())
pairs.sort
old_objs.extend(list(map(itemgetter(1), pairs)))
old_objs = self.dep_sorted(old_objs, self.db)
old_objs.reverse()
# Drop the objects that don't appear in the new db
for old in old_objs:
d = self.ndb.dbobjdict_from_catalog(old.catalog)
if isinstance(old, Table):
new = d.get(old.key())
if new is not None:
stmts.extend(old.alter_drop_columns(new))
if not getattr(old, '_nodrop', False) and old.key() not in d:
stmts.extend(old.drop())
if 'datacopy' in self.config:
opts.data_dir = self.config['files']['data_path']
stmts.append(self.ndb.schemas.data_import(opts))
stmts = [s for s in flatten(stmts)]
funcs = False
for s in stmts:
if "LANGUAGE sql" in s and (
s.startswith("CREATE FUNCTION ") or
s.startswith("CREATE OR REPLACE FUNCTION ")):
funcs = True
break
if funcs:
stmts.insert(0, "SET check_function_bodies = false")
return stmts
def diff_map(self, input_map):
"""Generate SQL to transform an existing database
:param input_map: a YAML map defining the new database
:return: list of SQL statements
Compares the existing database definition, as fetched from the
catalogs, to the input YAML map and generates SQL statements
to transform the database into the one represented by the
input.
"""
if not self.db:
self.from_catalog()
opts = self.config['options']
if opts.schemas:
schlist = ['schema ' + sch for sch in opts.schemas]
for sch in input_map.keys():
if sch not in schlist and sch.startswith('schema '):
del input_map[sch]
self._trim_objects(opts.schemas)
if opts.quote_reserved:
fetch_reserved_words(self.dbconn)
langs = None
if self.dbconn.version >= 90100:
langs = [
lang[0] for lang in self.dbconn.fetchall(
"SELECT tmplname FROM pg_pltemplate")
]
self.from_map(input_map, langs)
if opts.revert:
(self.db, self.ndb) = (self.ndb, self.db)
self.db.languages.dbconn = self.dbconn
stmts = self.db.schemas.diff_map(self.ndb.schemas)
stmts.append(self.db.extensions.diff_map(self.ndb.extensions))
stmts.append(self.db.languages.diff_map(self.ndb.languages))
stmts.append(self.db.types.diff_map(self.ndb.types))
stmts.append(self.db.functions.diff_map(self.ndb.functions))
stmts.append(self.db.operators.diff_map(self.ndb.operators))
stmts.append(self.db.operfams.diff_map(self.ndb.operfams))
stmts.append(self.db.operclasses.diff_map(self.ndb.operclasses))
stmts.append(self.db.eventtrigs.diff_map(self.ndb.eventtrigs))
stmts.append(self.db.tables.diff_map(self.ndb.tables))
stmts.append(self.db.constraints.diff_map(self.ndb.constraints))
stmts.append(self.db.indexes.diff_map(self.ndb.indexes))
stmts.append(self.db.columns.diff_map(self.ndb.columns))
stmts.append(self.db.triggers.diff_map(self.ndb.triggers))
stmts.append(self.db.rules.diff_map(self.ndb.rules))
stmts.append(self.db.conversions.diff_map(self.ndb.conversions))
stmts.append(self.db.tsdicts.diff_map(self.ndb.tsdicts))
stmts.append(self.db.tstempls.diff_map(self.ndb.tstempls))
stmts.append(self.db.tsparsers.diff_map(self.ndb.tsparsers))
stmts.append(self.db.tsconfigs.diff_map(self.ndb.tsconfigs))
stmts.append(self.db.casts.diff_map(self.ndb.casts))
stmts.append(self.db.collations.diff_map(self.ndb.collations))
stmts.append(self.db.fdwrappers.diff_map(self.ndb.fdwrappers))
stmts.append(self.db.servers.diff_map(self.ndb.servers))
stmts.append(self.db.usermaps.diff_map(self.ndb.usermaps))
stmts.append(self.db.ftables.diff_map(self.ndb.ftables))
stmts.append(self.db.operators._drop())
stmts.append(self.db.operclasses._drop())
stmts.append(self.db.operfams._drop())
stmts.append(self.db.functions._drop())
stmts.append(self.db.types._drop())
stmts.append(self.db.schemas._drop())
stmts.append(self.db.servers._drop())
stmts.append(self.db.fdwrappers._drop())
stmts.append(self.db.languages._drop())
stmts.append(self.db.extensions._drop())
if 'datacopy' in self.config:
opts.data_dir = self.config['files']['data_path']
stmts.append(self.ndb.schemas.data_import(opts))
return [s for s in flatten(stmts)]
def diff_map(self, input_map):
"""Generate SQL to transform an existing database
:param input_map: a YAML map defining the new database
:return: list of SQL statements
Compares the existing database definition, as fetched from the
catalogs, to the input YAML map and generates SQL statements
to transform the database into the one represented by the
input.
"""
if not self.db:
self.from_catalog()
opts = self.config['options']
if opts.schemas:
schlist = ['schema ' + sch for sch in opts.schemas]
for sch in input_map:
if sch not in schlist and sch.startswith('schema '):
del input_map[sch]
self._trim_objects(opts.schemas)
if opts.quote_reserved:
fetch_reserved_words(self.dbconn)
langs = None
if self.dbconn.version >= 90100:
langs = [lang[0] for lang in self.dbconn.fetchall(
"SELECT tmplname FROM pg_pltemplate")]
self.from_map(input_map, langs)
stmts = self.db.schemas.diff_map(self.ndb.schemas)
stmts.append(self.db.extensions.diff_map(self.ndb.extensions))
stmts.append(self.db.languages.diff_map(self.ndb.languages))
stmts.append(self.db.types.diff_map(self.ndb.types))
stmts.append(self.db.functions.diff_map(self.ndb.functions))
stmts.append(self.db.operators.diff_map(self.ndb.operators))
stmts.append(self.db.operfams.diff_map(self.ndb.operfams))
stmts.append(self.db.operclasses.diff_map(self.ndb.operclasses))
stmts.append(self.db.eventtrigs.diff_map(self.ndb.eventtrigs))
stmts.append(self.db.tables.diff_map(self.ndb.tables))
stmts.append(self.db.constraints.diff_map(self.ndb.constraints))
stmts.append(self.db.indexes.diff_map(self.ndb.indexes))
stmts.append(self.db.columns.diff_map(self.ndb.columns))
stmts.append(self.db.triggers.diff_map(self.ndb.triggers))
stmts.append(self.db.rules.diff_map(self.ndb.rules))
stmts.append(self.db.conversions.diff_map(self.ndb.conversions))
stmts.append(self.db.tsdicts.diff_map(self.ndb.tsdicts))
stmts.append(self.db.tstempls.diff_map(self.ndb.tstempls))
stmts.append(self.db.tsparsers.diff_map(self.ndb.tsparsers))
stmts.append(self.db.tsconfigs.diff_map(self.ndb.tsconfigs))
stmts.append(self.db.casts.diff_map(self.ndb.casts))
stmts.append(self.db.collations.diff_map(self.ndb.collations))
stmts.append(self.db.fdwrappers.diff_map(self.ndb.fdwrappers))
stmts.append(self.db.servers.diff_map(self.ndb.servers))
stmts.append(self.db.usermaps.diff_map(self.ndb.usermaps))
stmts.append(self.db.ftables.diff_map(self.ndb.ftables))
stmts.append(self.db.operators._drop())
stmts.append(self.db.operclasses._drop())
stmts.append(self.db.operfams._drop())
stmts.append(self.db.functions._drop())
stmts.append(self.db.types._drop())
stmts.append(self.db.extensions._drop())
stmts.append(self.db.schemas._drop())
stmts.append(self.db.servers._drop())
stmts.append(self.db.fdwrappers._drop())
stmts.append(self.db.languages._drop())
if 'datacopy' in self.config:
opts.data_dir = self.config['files']['data_path']
stmts.append(self.ndb.schemas.data_import(opts))
return [s for s in flatten(stmts)]
def diff_map(self, input_map, quote_reserved=True):
"""Generate SQL to transform an existing database
:param input_map: a YAML map defining the new database
:param quote_reserved: fetch reserved words
:return: list of SQL statements
Compares the existing database definition, as fetched from the
catalogs, to the input YAML map and generates SQL statements
to transform the database into the one represented by the
input.
"""
from .dbobject.table import Table
if not self.db:
self.from_catalog()
opts = self.config['options']
if opts.schemas:
schlist = ['schema ' + sch for sch in opts.schemas]
for sch in list(input_map.keys()):
if sch not in schlist and sch.startswith('schema '):
del input_map[sch]
self._trim_objects(opts.schemas)
# quote_reserved is only set to False by most tests
if quote_reserved:
fetch_reserved_words(self.dbconn)
langs = [lang[0] for lang in self.dbconn.fetchall(
"SELECT tmplname FROM pg_pltemplate")]
self.from_map(input_map, langs)
if opts.revert:
(self.db, self.ndb) = (self.ndb, self.db)
del self.ndb.schemas['pg_catalog']
self.db.languages.dbconn = self.dbconn
# First sort the objects in the new db in dependency order
new_objs = []
for _, d in self.ndb.all_dicts():
pairs = list(d.items())
pairs.sort()
new_objs.extend(list(map(itemgetter(1), pairs)))
new_objs = self.dep_sorted(new_objs, self.ndb)
# Then generate the sql for all the objects, walking in dependency
# order over all the db objects
stmts = []
for new in new_objs:
d = self.db.dbobjdict_from_catalog(new.catalog)
old = d.get(new.key())
if old is not None:
stmts.append(old.alter(new))
else:
stmts.append(new.create_sql(self.dbconn.version))
# Check if the object just created was renamed, in which case
# don't try to delete the original one
if getattr(new, 'oldname', None):
try:
origname, new.name = new.name, new.oldname
oldkey = new.key()
finally:
new.name = origname
# Intentionally raising KeyError as tested e.g. in
# test_bad_rename_view -- ok Joe?
old = d[oldkey]
old._nodrop = True
# Order the old database objects in reverse dependency order
old_objs = []
for _, d in self.db.all_dicts():
pairs = list(d.items())
pairs.sort
old_objs.extend(list(map(itemgetter(1), pairs)))
old_objs = self.dep_sorted(old_objs, self.db)
old_objs.reverse()
# Drop the objects that don't appear in the new db
for old in old_objs:
d = self.ndb.dbobjdict_from_catalog(old.catalog)
if isinstance(old, Table):
new = d.get(old.key())
if new is not None:
stmts.extend(old.alter_drop_columns(new))
if not getattr(old, '_nodrop', False) and old.key() not in d:
stmts.extend(old.drop())
if 'datacopy' in self.config:
opts.data_dir = self.config['files']['data_path']
stmts.append(self.ndb.schemas.data_import(opts))
stmts = [s for s in flatten(stmts)]
funcs = False
for s in stmts:
if "LANGUAGE sql" in s and (
s.startswith("CREATE FUNCTION ") or
s.startswith("CREATE OR REPLACE FUNCTION ")):
funcs = True
break
if funcs:
stmts.insert(0, "SET check_function_bodies = false")
return stmts