def test_views(self):
"""test views """
metadata = load_from_file("complex_db.yaml")
person_name = find_table_name(metadata, 'Person')
(view, _) = make_view_without_table(metadata,
person_name, 'FullName')
# process_dataset = find_table(view, 'ProcessedDatasetView')
# data_tier = find_table(view, 'DataTierView')
# process_dataset = find_table(view, 'PrimaryDatasetView')
# files = find_table(view, 'FilesView')
# This shows what happens to the foreign keys
# when you make a select statement.
for table_name in view.tables:
table = view.tables[table_name]
for f_key in table.foreign_keys:
vals = {}
vals['table'] = table_name
vals['column'] = f_key.parent.name
if f_key.parent.table.__dict__.has_key('name'):
vals['from'] = f_key.parent.table.name
else:
vals['from'] = "none"
if f_key.column.table.__dict__.has_key('name'):
vals['to'] = f_key.column.table
else:
vals['to'] = "none"
_LOGGER.debug(
"test_views %(table)s.%(column)s %(from)s->%(to)s"
% vals)
def test_yaml_graph(self):
"""test create schema from yaml
make a dotgraph
output via query_builder"""
query_builder = Schema(load_from_file("starting_db.yaml").tables)
dot = DotGraph(file("z.dot","w"))
query_builder.write_graph(dot)
def setUp(self):
"""auto init"""
metadata = load_from_file("starting_db.yaml")
self.oschema = OriginSchema(metadata.tables)
self.mapper = Mapper()
self.mapper.load_mapfile('testmap.yaml')
self.mapper.validate_map(metadata.tables)
self.oschema.check_connective()
def setUp(self):
"""default"""
metadata = load_from_file("starting_db.yaml")
app = QueryBuilder()
app.set_mapper('testmap.yaml')
app.set_from_tables(metadata.tables)
app.recognize_schema() # without loading statistics
self.app = app
def test_operators(self):
"""test operators"""
metadata = load_from_file("starting_db.yaml")
process_dataset = find_table(metadata, 'ProcessedDataset')
data_tier = find_table(metadata, 'DataTier')
process_dataset = find_table(metadata, 'PrimaryDataset')
# files = find_table(metadata,'Files')
select_test = select([process_dataset.c.Name, data_tier.c.Name,
process_dataset.c.Description], process_dataset.c.ID==0)
query_builder = Schema(metadata.tables)
query = query_builder.build_query(select_test)
def set_querybuilder(self, schema_file=None):
"""set querybuilder"""
metadata = MetaData()
tables = None
if schema_file:
metadata = load_from_file(schema_file)
tables = metadata.tables
self.schema = metadata
else:
tables = self.manager.load_tables(self.db_name)
self.schema.set_tables(tables)
self.querybuilder = Schema(tables)
def test_single_query(self):
"""test create schema from yaml
get table by name
create a select query on this table
create a query builder and build this query"""
metadata = load_from_file("starting_db.yaml")
process_dataset = find_table(metadata, 'ProcessedDataset')
select_test = select([process_dataset.c.Name],
process_dataset.c.ID == 0)
query_builder = Schema(metadata.tables)
query = query_builder.build_query(select_test)
print query
def setUp(self):
metadata = load_from_file("starting_db.yaml")
oschema = OriginSchema(metadata.tables)
oschema.check_connective()
self.mapper = Mapper()
self.mapper.load_mapfile('testmap.yaml')
self.mapper.validate_map(metadata.tables)
oschema.recognize_type(self.mapper)
oschema.handle_alias()
attr_path, _ = oschema.gen_attr_links(self.mapper)
self.simschemas = oschema.gen_simschema()
for simschema in self.simschemas:
simschema.update_nodelist()
def test_yaml_query(self):
"""test yaml query, using multiple tables"""
metadata = load_from_file("starting_db.yaml")
process_dataset = find_table(metadata, 'ProcessedDataset')
data_tier = find_table(metadata, 'DataTier')
process_dataset = find_table(metadata, 'PrimaryDataset')
files = find_table(metadata, 'Files')
select_test = select([process_dataset.c.Name, data_tier.c.Name,
process_dataset.c.Description])
query_builder = Schema(metadata.tables)
query = query_builder.build_query(select_test)
# print query
select_test1 = select([process_dataset.c.Name, data_tier.c.Name,
files.c.LogicalFileName])
query = query_builder.build_query(select_test1)
def setUp(self):
"""default"""
metadata = load_from_file("starting_db.yaml")
self.handler = SchemaHandler(metadata.tables)
self.mapper = Mapper()
self.mapper.load_mapfile('testmap.yaml')
self.mapper.validate_map(metadata.tables)
self.handler._schema.recognize_type(self.mapper)
self.handler._schema.handle_alias()
self.handler._schema.gen_attr_links(self.mapper)
simschemas = self.handler._schema.gen_simschema()
for simschema in simschemas:
simschema.update_nodelist()
graph = simschema.get_wgraph_from_schema()
self.handler.subconstructors.append([ConstructQuery(graph, \
weighted=True)])
nodes = set(range(len(simschema.ordered)))
self.handler.subnodes.append([nodes])
self.handler._simschemas = simschemas
def test_view_build(self):
"""test view build """
_LOGGER.debug("test_view_build start")
metadata = load_from_file("complex_db.yaml")
person_name = find_table_name(metadata, 'Person')
(view, foreign_keys) = make_view_without_table(metadata,
person_name, 'FullName')
# for table_name in view.tables:
# print table_name, list(view.tables[table_name].c)
# files = find_table(view, 'FilesView')
process_dataset = find_table(view, 'ProcessedDatasetView')
data_tier = find_table(view, 'DataTierView')
process_dataset = find_table(view, 'PrimaryDatasetView')
query_builder = Schema(view.tables, foreign_keys)
select_test = select([process_dataset.c.Name, data_tier.c.Name,
process_dataset.c.Description],
process_dataset.c.ID==0)
query = query_builder.build_query(select_test)
_LOGGER.debug("test_view_build query: " + str(query))
_LOGGER.debug("test_view_build finish")
def test_from_yaml(self):
"""test from yaml"""
metadata = load_from_file('starting_db.yaml')
udb = UnittestDB()
c_count = udb.column_count(metadata)
self.assertEqual(c_count, 51)
def test_dotgraph(self):
"""test DotGraph"""
query_builder = Schema(load_from_file("starting_db.yaml").tables)
output = StringIO()
dot = DotGraph(output)
query_builder.write_graph(dot)
