def from_map(self, table, incols):
"""Initialize the dictionary of columns by converting the input list
:param table: table or type owning the columns/attributes
:param incols: YAML list defining the columns
"""
if not incols:
raise ValueError("Table '%s' has no columns" % table.name)
cols = self[(table.schema, table.name)] = []
for incol in incols:
for key in incol:
if isinstance(incol[key], dict):
arg = incol[key]
else:
arg = {'type': incol[key]}
col = Column(schema=table.schema, table=table.name, name=key,
**arg)
if len(col.privileges) > 0:
if table.owner is None:
raise ValueError("Column '%s.%s' has privileges but "
"no owner information" % (
table.name, key))
col.privileges = privileges_from_map(
col.privileges, col.allprivs, table.owner)
cols.append(col)
def from_map(self, schema, inobjs, newdb):
"""Initalize the dictionary of tables by converting the input map
:param schema: schema owning the tables
:param inobjs: YAML map defining the schema objects
:param newdb: collection of dictionaries defining the database
"""
for key in inobjs:
if not key.startswith('foreign table '):
raise KeyError("Unrecognized object type: %s" % key)
ftb = key[14:]
self[(schema.name, ftb)] = ftable = ForeignTable(
schema=schema.name, name=ftb)
inftable = inobjs[key]
if not inftable:
raise ValueError("Foreign table '%s' has no specification" %
ftb)
try:
newdb.columns.from_map(ftable, inftable['columns'])
except KeyError as exc:
exc.args = ("Foreign table '%s' has no columns" % ftb, )
raise
for attr in ['server', 'options', 'owner', 'description']:
if attr in inftable:
setattr(ftable, attr, inftable[attr])
if 'privileges' in inftable:
ftable.privileges = privileges_from_map(
inftable['privileges'], ftable.allprivs, ftable.owner)
def from_map(self, schema, inobjs, newdb):
"""Initalize the dictionary of tables by converting the input map
:param schema: schema owning the tables
:param inobjs: YAML map defining the schema objects
:param newdb: collection of dictionaries defining the database
"""
for key in inobjs:
if not key.startswith('foreign table '):
raise KeyError("Unrecognized object type: %s" % key)
ftb = key[14:]
self[(schema.name,
ftb)] = ftable = ForeignTable(schema=schema.name, name=ftb)
inftable = inobjs[key]
if not inftable:
raise ValueError("Foreign table '%s' has no specification" %
ftb)
try:
newdb.columns.from_map(ftable, inftable['columns'])
except KeyError as exc:
exc.args = ("Foreign table '%s' has no columns" % ftb, )
raise
for attr in ['server', 'options', 'owner', 'description']:
if attr in inftable:
setattr(ftable, attr, inftable[attr])
if 'privileges' in inftable:
ftable.privileges = privileges_from_map(
inftable['privileges'], ftable.allprivs, ftable.owner)
def from_map(self, inwrappers, newdb):
"""Initialize the dictionary of wrappers by examining the input map
:param inwrappers: input YAML map defining the data wrappers
:param newdb: collection of dictionaries defining the database
"""
for key in inwrappers:
if not key.startswith('foreign data wrapper '):
raise KeyError("Unrecognized object type: %s" % key)
fdw = key[21:]
self[fdw] = wrapper = ForeignDataWrapper(name=fdw)
inwrapper = inwrappers[key]
inservs = {}
for key in inwrapper:
if key.startswith('server '):
inservs.update({key: inwrapper[key]})
elif key in [
'handler', 'validator', 'options', 'owner', 'oldname',
'description'
]:
setattr(wrapper, key, inwrapper[key])
elif key == 'privileges':
wrapper.privileges = privileges_from_map(
inwrapper[key], wrapper.allprivs, inwrapper['owner'])
else:
raise KeyError("Expected typed object, found '%s'" % key)
newdb.servers.from_map(wrapper, inservs, newdb)
def from_map(self, inwrappers, newdb):
"""Initialize the dictionary of wrappers by examining the input map
:param inwrappers: input YAML map defining the data wrappers
:param newdb: collection of dictionaries defining the database
"""
for key in inwrappers:
if not key.startswith('foreign data wrapper '):
raise KeyError("Unrecognized object type: %s" % key)
fdw = key[21:]
self[fdw] = wrapper = ForeignDataWrapper(name=fdw)
inwrapper = inwrappers[key]
inservs = {}
for key in inwrapper:
if key.startswith('server '):
inservs.update({key: inwrapper[key]})
elif key in ['handler', 'validator', 'options', 'owner',
'oldname', 'description']:
setattr(wrapper, key, inwrapper[key])
elif key == 'privileges':
wrapper.privileges = privileges_from_map(
inwrapper[key], wrapper.allprivs, inwrapper['owner'])
else:
raise KeyError("Expected typed object, found '%s'" % key)
newdb.servers.from_map(wrapper, inservs, newdb)
def from_map(self, table, incols):
"""Initialize the dictionary of columns by converting the input list
:param table: table or type owning the columns/attributes
:param incols: YAML list defining the columns
"""
if not incols:
raise ValueError("Table '%s' has no columns" % table.name)
cols = self[(table.schema, table.name)] = []
for incol in incols:
for key in incol:
if isinstance(incol[key], dict):
arg = incol[key]
else:
arg = {'type': incol[key]}
col = Column(schema=table.schema, table=table.name, name=key,
**arg)
if len(col.privileges) > 0:
if table.owner is None:
raise ValueError("Column '%s.%s' has privileges but "
"no owner information" % (
table.name, key))
col.privileges = privileges_from_map(
col.privileges, col.allprivs, table.owner)
cols.append(col)
def from_map(self, inmap, newdb):
"""Initialize the dictionary of schemas by converting the input map
:param inmap: the input YAML map defining the schemas
:param newdb: collection of dictionaries defining the database
Starts the recursive analysis of the input map and
construction of the internal collection of dictionaries
describing the database objects.
"""
for key in inmap:
(objtype, spc, sch) = key.partition(' ')
if spc != ' ' or objtype != 'schema':
raise KeyError("Unrecognized object type: %s" % key)
inschema = inmap[key]
schema = self[sch] = Schema(sch, inschema.pop('description', None),
inschema.pop('owner', None),
inschema.pop('privileges', []))
schema.privileges = privileges_from_map(schema.privileges,
schema.allprivs,
schema.owner)
objdict = {}
for key in sorted(inschema.keys()):
mapped = False
for prefix in PREFIXES:
if key.startswith(prefix):
otype = PREFIXES[prefix]
if otype not in objdict:
objdict[otype] = {}
objdict[otype].update({key: inschema[key]})
mapped = True
break
# Needs separate processing because it overlaps
# operator classes and operator families
if not mapped and key.startswith('operator '):
otype = 'operators'
if otype not in objdict:
objdict[otype] = {}
objdict[otype].update({key: inschema[key]})
mapped = True
elif key == 'oldname':
setattr(schema, key, inschema[key])
mapped = True
if not mapped and key != 'schema':
raise KeyError("Expected typed object, found '%s'" % key)
for objtype in SCHOBJS1:
if objtype in objdict:
subobjs = getattr(newdb, objtype)
subobjs.from_map(schema, objdict[objtype], newdb)
for objtype in SCHOBJS2:
if objtype in objdict:
subobjs = getattr(newdb, objtype)
subobjs.from_map(schema, objdict[objtype])
def from_map(self, inmap, newdb):
"""Initialize the dictionary of schemas by converting the input map
:param inmap: the input YAML map defining the schemas
:param newdb: collection of dictionaries defining the database
Starts the recursive analysis of the input map and
construction of the internal collection of dictionaries
describing the database objects.
"""
for key in inmap:
(objtype, spc, sch) = key.partition(' ')
if spc != ' ' or objtype != 'schema':
raise KeyError("Unrecognized object type: %s" % key)
schema = self[sch] = Schema(name=sch)
inschema = inmap[key]
objdict = {}
for key in sorted(inschema.keys()):
mapped = False
for prefix in PREFIXES:
if key.startswith(prefix):
otype = PREFIXES[prefix]
if otype not in objdict:
objdict[otype] = {}
objdict[otype].update({key: inschema[key]})
mapped = True
break
# Needs separate processing because it overlaps
# operator classes and operator families
if not mapped and key.startswith('operator '):
otype = 'operators'
if otype not in objdict:
objdict[otype] = {}
objdict[otype].update({key: inschema[key]})
mapped = True
elif key in ['oldname', 'owner', 'description']:
setattr(schema, key, inschema[key])
mapped = True
elif key == 'privileges':
schema.privileges = privileges_from_map(
inschema[key], schema.allprivs, schema.owner)
mapped = True
if not mapped and key != 'schema':
raise KeyError("Expected typed object, found '%s'" % key)
for objtype in SCHOBJS1:
if objtype in objdict:
subobjs = getattr(newdb, objtype)
subobjs.from_map(schema, objdict[objtype], newdb)
for objtype in SCHOBJS2:
if objtype in objdict:
subobjs = getattr(newdb, objtype)
subobjs.from_map(schema, objdict[objtype])
def from_map(self, schema, infuncs):
"""Initalize the dictionary of functions by converting the input map
:param schema: schema owning the functions
:param infuncs: YAML map defining the functions
"""
for key in infuncs:
(objtype, spc, fnc) = key.partition(' ')
if spc != ' ' or objtype not in ['function', 'aggregate']:
raise KeyError("Unrecognized object type: %s" % key)
paren = fnc.find('(')
if paren == -1 or fnc[-1:] != ')':
raise KeyError("Invalid function signature: %s" % fnc)
arguments = fnc[paren + 1:-1]
infunc = infuncs[key]
fnc = fnc[:paren]
if objtype == 'function':
self[(schema.name, fnc,
arguments)] = func = Function(schema=schema.name,
name=fnc,
arguments=arguments)
else:
self[(schema.name, fnc,
arguments)] = func = Aggregate(schema=schema.name,
name=fnc,
arguments=arguments)
func.language = 'internal'
if not infunc:
raise ValueError("Function '%s' has no specification" % fnc)
for attr in infunc:
setattr(func, attr, infunc[attr])
if hasattr(func, 'volatility'):
func.volatility = func.volatility[:1].lower()
if isinstance(func, Function):
src = hasattr(func, 'source')
obj = hasattr(func, 'obj_file')
if (src and obj) or not (src or obj):
raise ValueError("Function '%s': either source or "
"obj_file must be specified" % fnc)
if 'privileges' in infunc:
func.privileges = privileges_from_map(infunc['privileges'],
func.allprivs,
func.owner)
def from_map(self, schema, infuncs):
"""Initalize the dictionary of functions by converting the input map
:param schema: schema owning the functions
:param infuncs: YAML map defining the functions
"""
for key in infuncs:
(objtype, spc, fnc) = key.partition(' ')
if spc != ' ' or objtype not in ['function', 'aggregate']:
raise KeyError("Unrecognized object type: %s" % key)
paren = fnc.find('(')
if paren == -1 or fnc[-1:] != ')':
raise KeyError("Invalid function signature: %s" % fnc)
arguments = fnc[paren + 1:-1]
infunc = infuncs[key]
fnc = fnc[:paren]
if objtype == 'function':
self[(schema.name, fnc, arguments)] = func = Function(
schema=schema.name, name=fnc, arguments=arguments)
else:
self[(schema.name, fnc, arguments)] = func = Aggregate(
schema=schema.name, name=fnc, arguments=arguments)
func.language = 'internal'
if not infunc:
raise ValueError("Function '%s' has no specification" % fnc)
for attr in infunc:
setattr(func, attr, infunc[attr])
if hasattr(func, 'volatility'):
func.volatility = func.volatility[:1].lower()
if isinstance(func, Function):
src = hasattr(func, 'source')
obj = hasattr(func, 'obj_file')
if (src and obj) or not (src or obj):
raise ValueError("Function '%s': either source or "
"obj_file must be specified" % fnc)
if 'privileges' in infunc:
func.privileges = privileges_from_map(
infunc['privileges'], func.allprivs, func.owner)
def from_map(self, wrapper, inservers, newdb):
"""Initialize the dictionary of servers by examining the input map
:param wrapper: associated foreign data wrapper
:param inservers: input YAML map defining the foreign servers
:param newdb: collection of dictionaries defining the database
"""
for key in inservers:
if not key.startswith('server '):
raise KeyError("Unrecognized object type: %s" % key)
srv = key[7:]
self[(wrapper.name,
srv)] = serv = ForeignServer(wrapper=wrapper.name, name=srv)
inserv = inservers[key]
if inserv:
for attr, val in list(inserv.items()):
setattr(serv, attr, val)
if 'user mappings' in inserv:
newdb.usermaps.from_map(serv, inserv['user mappings'])
if 'oldname' in inserv:
del inserv['oldname']
if 'privileges' in inserv:
serv.privileges = privileges_from_map(
inserv['privileges'], serv.allprivs, serv.owner)
def from_map(self, wrapper, inservers, newdb):
"""Initialize the dictionary of servers by examining the input map
:param wrapper: associated foreign data wrapper
:param inservers: input YAML map defining the foreign servers
:param newdb: collection of dictionaries defining the database
"""
for key in inservers:
if not key.startswith('server '):
raise KeyError("Unrecognized object type: %s" % key)
srv = key[7:]
self[(wrapper.name, srv)] = serv = ForeignServer(
wrapper=wrapper.name, name=srv)
inserv = inservers[key]
if inserv:
for attr, val in list(inserv.items()):
setattr(serv, attr, val)
if 'user mappings' in inserv:
newdb.usermaps.from_map(serv, inserv['user mappings'])
if 'oldname' in inserv:
del inserv['oldname']
if 'privileges' in inserv:
serv.privileges = privileges_from_map(
inserv['privileges'], serv.allprivs, serv.owner)
def from_map(self, schema, inobjs, newdb):
"""Initalize the dictionary of tables by converting the input map
:param schema: schema owning the tables
:param inobjs: YAML map defining the schema objects
:param newdb: collection of dictionaries defining the database
"""
for k in inobjs:
inobj = inobjs[k]
objtype = None
for typ in OBJTYPES:
if k.startswith(typ):
objtype = typ
key = k[len(typ) + 1:]
if objtype is None:
raise KeyError("Unrecognized object type: %s" % k)
if objtype == 'table':
self[(schema.name, key)] = table = Table(
schema=schema.name, name=key)
intable = inobj
if not intable:
raise ValueError("Table '%s' has no specification" % k)
for attr in ['inherits', 'owner', 'tablespace', 'oldname',
'description', 'options', 'unlogged']:
if attr in intable:
setattr(table, attr, intable[attr])
try:
newdb.columns.from_map(table, intable['columns'])
except KeyError as exc:
exc.args = ("Table '%s' has no columns" % key, )
raise
newdb.constraints.from_map(table, intable)
if 'indexes' in intable:
newdb.indexes.from_map(table, intable['indexes'])
if 'rules' in intable:
newdb.rules.from_map(table, intable['rules'])
if 'triggers' in intable:
newdb.triggers.from_map(table, intable['triggers'])
elif objtype == 'sequence':
self[(schema.name, key)] = seq = Sequence(
schema=schema.name, name=key)
inseq = inobj
if not inseq:
raise ValueError("Sequence '%s' has no specification" % k)
for attr, val in list(inseq.items()):
setattr(seq, attr, val)
elif objtype == 'view':
self[(schema.name, key)] = view = View(
schema=schema.name, name=key)
inview = inobj
if not inview:
raise ValueError("View '%s' has no specification" % k)
for attr, val in list(inview.items()):
setattr(view, attr, val)
if 'triggers' in inview:
newdb.triggers.from_map(view, inview['triggers'])
elif objtype == 'materialized view':
self[(schema.name, key)] = mview = MaterializedView(
schema=schema.name, name=key)
inmview = inobj
if not inmview:
raise ValueError("View '%s' has no specification" % k)
for attr, val in list(inmview.items()):
setattr(mview, attr, val)
else:
raise KeyError("Unrecognized object type: %s" % k)
obj = self[(schema.name, key)]
if 'privileges' in inobj:
if not hasattr(obj, 'owner'):
raise ValueError("%s '%s' has privileges but no "
"owner information" %
obj.objtype.capital(), table.name)
obj.privileges = privileges_from_map(
inobj['privileges'], obj.allprivs, obj.owner)
def from_map(self, schema, inobjs, newdb):
"""Initalize the dictionary of tables by converting the input map
:param schema: schema owning the tables
:param inobjs: YAML map defining the schema objects
:param newdb: collection of dictionaries defining the database
"""
for k in inobjs:
inobj = inobjs[k]
objtype = None
for typ in OBJTYPES:
if k.startswith(typ):
objtype = typ
key = k[len(typ) + 1:]
if objtype is None:
raise KeyError("Unrecognized object type: %s" % k)
if objtype == 'table':
self[(schema.name, key)] = table = Table(schema=schema.name,
name=key)
intable = inobj
if not intable:
raise ValueError("Table '%s' has no specification" % k)
for attr in [
'inherits', 'owner', 'tablespace', 'oldname',
'description', 'options', 'unlogged'
]:
if attr in intable:
setattr(table, attr, intable[attr])
try:
newdb.columns.from_map(table, intable['columns'])
except KeyError as exc:
exc.args = ("Table '%s' has no columns" % key, )
raise
newdb.constraints.from_map(table, intable, rtables=inobjs)
if 'indexes' in intable:
newdb.indexes.from_map(table, intable['indexes'])
if 'rules' in intable:
newdb.rules.from_map(table, intable['rules'])
if 'triggers' in intable:
newdb.triggers.from_map(table, intable['triggers'])
elif objtype == 'sequence':
self[(schema.name, key)] = seq = Sequence(schema=schema.name,
name=key)
inseq = inobj
if not inseq:
raise ValueError("Sequence '%s' has no specification" % k)
for attr, val in list(inseq.items()):
setattr(seq, attr, val)
elif objtype == 'view':
self[(schema.name, key)] = view = View(schema=schema.name,
name=key)
inview = inobj
if not inview:
raise ValueError("View '%s' has no specification" % k)
for attr, val in list(inview.items()):
setattr(view, attr, val)
if 'triggers' in inview:
newdb.triggers.from_map(view, inview['triggers'])
elif objtype == 'materialized view':
self[(schema.name,
key)] = mview = MaterializedView(schema=schema.name,
name=key)
inmview = inobj
if not inmview:
raise ValueError("View '%s' has no specification" % k)
if 'indexes' in inmview:
newdb.indexes.from_map(mview, inmview['indexes'])
for attr, val in list(inmview.items()):
setattr(mview, attr, val)
else:
raise KeyError("Unrecognized object type: %s" % k)
obj = self[(schema.name, key)]
if 'privileges' in inobj:
if obj.owner is None:
raise ValueError(
"%s '%s' has privileges but no "
"owner information" % obj.objtype.capital(),
table.name)
obj.privileges = privileges_from_map(inobj['privileges'],
obj.allprivs, obj.owner)
if 'depends_on' in inobj:
obj.depends_on.extend(inobj['depends_on'])
