def get_or_create_tables(session, prefix=None, create=True, **tables):
"""
Load or create canonical ORM KB Core table classes.
Parameters
----------
session : sqlalchemy.orm.Session
prefix : str
Prefix for canonical table names, e.g. 'myaccount.' or 'TA_' (no owner/schema).
Canonical table names are used if no prefix is provided.
create : bool
If True, create tables that don't yet exist.
Canonical table keyword/tablename string pairs, such as site='other.site',
can override prefix. For example, you may want to use a different Lastid
table, so that ids don't start from 1.
Returns
-------
tables : dict
A mapping between canonical table names and SQLA declarative classes
with the correct __tablename__.
e.g. {'origin': Origin, ...}
"""
# The Plan:
# 1. For each core table, build or get the table name
# 2. If it's a vanilla table name, just use a pre-packaged table class
# 3. If not, try to autoload it.
# 4. If it doesn't exist, make it from a prototype and create it in the database.
# TODO: check options for which tables to produce.
if not prefix:
prefix = ''
tabledict = {}
for coretable in CORETABLES.values():
# build the table name
fulltablename = tables.get(coretable.name, prefix + coretable.name)
# put table classes into the tables dictionary
if fulltablename == coretable.name:
# it's a vanilla table name. just use a pre-packaged table class instead of making one.
tabledict[coretable.name] = coretable.table
else:
tabledict[coretable.name] = ps.make_table(fulltablename,
coretable.prototype)
tabledict[coretable.name].__table__.create(session.bind,
checkfirst=True)
session.commit()
return tabledict
def get_or_create_tables(session, prefix=None, create=True, **tables):
"""
Load or create canonical ORM KB Core table classes.
Parameters
----------
session : sqlalchemy.orm.Session
prefix : str
Prefix for canonical table names, e.g. 'myaccount.' or 'TA_' (no owner/schema).
Canonical table names are used if no prefix is provided.
create : bool
If True, create tables that don't yet exist.
Canonical table keyword/tablename string pairs, such as site='other.site',
can override prefix. For example, you may want to use a different Lastid
table, so that ids don't start from 1.
Returns
-------
tables : dict
A mapping between canonical table names and SQLA declarative classes
with the correct __tablename__.
e.g. {'origin': Origin, ...}
"""
# The Plan:
# 1. For each core table, build or get the table name
# 2. If it's a vanilla table name, just use a pre-packaged table class
# 3. If not, try to autoload it.
# 4. If it doesn't exist, make it from a prototype and create it in the database.
# TODO: check options for which tables to produce.
if not prefix:
prefix = ''
tabledict = {}
for coretable in CORETABLES.values():
# build the table name
fulltablename = tables.get(coretable.name, prefix + coretable.name)
# put table classes into the tables dictionary
if fulltablename == coretable.name:
# it's a vanilla table name. just use a pre-packaged table class instead of making one.
tabledict[coretable.name] = coretable.table
else:
tabledict[coretable.name] = ps.make_table(fulltablename, coretable.prototype)
tabledict[coretable.name].__table__.create(session.bind, checkfirst=True)
session.commit()
return tabledict
def get_or_create_tables(options, session, create=True):
"""
Load or create canonical ORM KB Core table classes.
Parameters
----------
options : argparse.ArgumentParser
session : sqlalchemy.orm.Session
Returns
-------
tables : dict
Mapping between canonical table names and SQLA ORM classes.
e.g. {'origin': MyOrigin, ...}
"""
# The Plan:
# 1. For each core table, build or get the table name
# 2. If it's a vanilla table name, just use a pre-packaged table class
# 3. If not, try to autoload it.
# 4. If it doesn't exist, make it from a prototype and create it in the database.
# TODO: check options for which tables to produce.
dbout = options.prefix
tables = {}
for coretable in CORETABLES:
# build the table name
if getattr(options, coretable.name, None):
fulltablename = getattr(options, coretable.name)
else:
fulltablename = dbout + coretable.name
# fulltablename is either an arbitrary string or dbout + core name, but not None
# put table classes into the tables dictionary
if fulltablename == coretable.name:
# it's a vanilla table name. just use a pre-packaged table class instead of making one.
tables[coretable.name] = coretable.table
else:
tables[coretable.name] = ps.make_table(fulltablename,
coretable.prototype)
tables[coretable.name].__table__.create(session.bind, checkfirst=True)
session.commit()
return tables
def get_or_create_tables(options, session, create=True):
"""
Load or create canonical ORM KB Core table classes.
Parameters
----------
options : argparse.ArgumentParser
session : sqlalchemy.orm.Session
Returns
-------
tables : dict
Mapping between canonical table names and SQLA ORM classes.
e.g. {'origin': MyOrigin, ...}
"""
# The Plan:
# 1. For each core table, build or get the table name
# 2. If it's a vanilla table name, just use a pre-packaged table class
# 3. If not, try to autoload it.
# 4. If it doesn't exist, make it from a prototype and create it in the database.
# TODO: check options for which tables to produce.
dbout = options.prefix
tables = {}
for coretable in CORETABLES:
# build the table name
if getattr(options, coretable.name, None):
fulltablename = getattr(options, coretable.name)
else:
fulltablename = dbout + coretable.name
# fulltablename is either an arbitrary string or dbout + core name, but not None
# put table classes into the tables dictionary
if fulltablename == coretable.name:
# it's a vanilla table name. just use a pre-packaged table class instead of making one.
tables[coretable.name] = coretable.table
else:
tables[coretable.name] = ps.make_table(fulltablename, coretable.prototype)
tables[coretable.name].__table__.create(session.bind, checkfirst=True)
session.commit()
return tables
def reflect_or_create_tables(options):
"""
returns a dict of classes
make 'em if they don't exist
"tables" is {'wfdisc': mapped table class, ...}
"""
tables = {}
# this list should mirror the command line table options
for table in mapfns.keys() + ['lastid']:
#if options.all_tables:
fulltabnm = getattr(options, table, None)
if fulltabnm:
try:
tables[table] = ps.get_tables(session.bind, [fulltabnm])[0]
except NoSuchTableError:
print "{0} doesn't exist. Adding it.".format(fulltabnm)
tables[table] = ps.make_table(fulltabnm, PROTOTYPES[table])
tables[table].__table__.create(session.bind, checkfirst=True)
return tables
def reflect_or_create_tables(options):
"""
returns a dict of classes
make 'em if they don't exist
"tables" is {'wfdisc': mapped table class, ...}
"""
tables = {}
# this list should mirror the command line table options
for table in mapfns.keys() + ['lastid']:
#if options.all_tables:
fulltabnm = getattr(options, table, None)
if fulltabnm:
try:
tables[table] = ps.get_tables(session.bind, [fulltabnm])[0]
except NoSuchTableError:
print "{0} doesn't exist. Adding it.".format(fulltabnm)
tables[table] = ps.make_table(fulltabnm, PROTOTYPES[table])
tables[table].__table__.create(session.bind, checkfirst=True)
return tables
