def test_oracle_query(self):
"""test oracle query
create test oracle db
get meta data
create select query on multiple table
create query builder and build querys
output in graph"""
_LOGGER.debug("test_oracle_query start")
test_db = UnittestDB()
metadata = test_db.read_from_oracle('oracle.sql')
process_dataset = find_table(metadata, 'ProcessedDataset')
app_exec = find_table(metadata, 'AppExecutable')
select_test = select([process_dataset.c.Name,
app_exec.c.ExecutableName])
query_builder = Schema(metadata.tables)
query = query_builder.build_query(select_test)
# print query
person = find_table(metadata, 'Person')
select_test = select([process_dataset.c.Name,
app_exec.c.ExecutableName, person.c.Name])
query_builder = Schema(metadata.tables)
query = query_builder.build_query(select_test)
dot = DotGraph(file("testOracleQuery.dot", "w"))
write_query_alchemy_graph(dot, query)
# print query
_LOGGER.debug("test_oracle_query finish")
def setUp(self):
"""initialize test sqlite db then metadata"""
if os.path.exists('unittest.db'):
os.unlink('unittest.db')
test_db = UnittestDB()
self.metadata = test_db.load_with_fake_data('oracle.sql',
'sqlite:///unittest.db')
def setUp(self):
""" auto init"""
self.mapper = Mapper()
self.mapfile = 'testmap.yaml'
udb = UnittestDB()
metadata = udb.load_from_file('starting_db.yaml')
self.mapper.load_mapfile(self.mapfile)
self.mapper.validate_map(metadata)
self.assertEqual(12, len(self.mapper.dict))
def setUp(self):
"""initialize test sqlite db then metadata"""
if os.path.exists('unittest.db'):
os.unlink('unittest.db')
test_db = UnittestDB()
metadata = test_db.load_with_fake_data('oracle.sql',
'sqlite:///unittest.db')
self.metadata = metadata
app = QueryBuilder()
app.set_mapper('map.yaml')
app.set_from_tables(metadata.tables)
app.recognize_schema() # without loading statistics
self.app = app
def test_sample_query(self):
"""test sample query"""
db_test = UnittestDB()
# class zCol(object):
# """z col"""
# def __init__(self, prim, fkey):
# """initialize"""
# self.primarykey = prim
# self.foreignkey = fkey
connection = self.engine.connect()
metadata = db_test.create_from(self.inputs)
metadata.create_all(bind=connection)
c_count = db_test.column_count(metadata)
metadata.drop_all(bind=connection)
self.assertEqual(c_count, 4)
connection.close()
def test_oracle_simple(self):
"""test oracle simple query"""
_LOGGER.debug("test_oracle_simple start")
test_db = UnittestDB()
metadata = test_db.read_from_oracle('oracle.sql')
process_dataset = find_table(metadata, 'ProcessedDataset')
# app_exec = find_table(metadata, 'AppExecutable')
person = find_table(metadata, 'Person')
select_test = select([person.c.Name])
query_builder = Schema(metadata.tables)
query = query_builder.build_query(select_test)
# print query
select_test = select([process_dataset.c.Name])
query_builder = Schema(metadata.tables)
query = query_builder.build_query(select_test)
# print query
_LOGGER.debug("test_oracle_simple finish")
def test_fill(self):
"""test fill"""
# if path.exists('unittest2.db'):
# unlink('unittest2.db')
udb = UnittestDB()
metadata = udb.load_from_file('starting_db.yaml')
# for table in metadata.sorted_tables:
# print table.name
# for col in table.columns:
# print col
connection = self.engine.connect()
metadata.bind = connection
metadata.drop_all()
for table in metadata.sorted_tables:
for col in table.columns:
col.autoincrement = False
metadata.create_all()
udb.fill_tables(metadata, 10)
connection.close()
def setUp(self):
"""initialize test sqlite db then metadata"""
if os.path.exists('unittest.db'):
os.unlink('unittest.db')
test_db = UnittestDB()
self.metadata = test_db.load_with_fake_data('oracle.sql',
'sqlite:///unittest.db')
self.handler = SchemaHandler(self.metadata.tables)
self.mapper = Mapper()
self.mapper.load_mapfile('map.yaml')
self.mapper.validate_map(self.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_by_sql_file(self):
"""test by sql file"""
udb = UnittestDB()
metadata = udb.load_from_file('starting_db.yaml')
connection = self.engine.connect()
metadata.bind = connection
metadata.drop_all()
connection.close()
udb = UnittestDB()
metadata = udb.read_from_oracle('oracle.sql')
# for table in metadata.sorted_tables:
# print table.name
# for col in table.columns:
# print col
metadata.bind = self.engine
metadata.create_all()
udb.fill_tables(metadata, 10)
metadata.drop_all()
prog_name = os.path.basename(sys.argv[0])
print "Usage:"
print "python %s --validate_map=<map> --mapfile=<mapfile> " % prog_name
print " --find_key=<table|table.column> --find_column=<key> "
print " --list_key --list_column"
print " "
if __name__ == '__main__':
MAPPER = Mapper()
MAPFILE = 'testmap.yaml'
COLUMN = None
KEY = None
LIST_KEY = False
LIST_COLUMN = False
VMAP = None
UDB = UnittestDB()
for ARG in sys.argv[1:]:
ARG = str.split(ARG, "=")
if ARG[0] == "--mapfile":
MAPFILE = ARG[1]
elif ARG[0] == "--find_key":
COLUMN = ARG[1]
elif ARG[0] == "--find_column":
KEY = ARG[1]
elif ARG[0] == "--list_key":
LIST_KEY = True
elif ARG[0] == "--list_column":
LIST_COLUMN = True
elif ARG[0] == "--validate_map":
VMAP = ARG[1]
def test_oracle_write(self):
"""test oracle write"""
udb = UnittestDB()
metadata = udb.read_from_oracle('oracle.sql')
dot = DotGraph(file("oracle.dot", "w"))
write_sql_alchemy_graph(dot, metadata, set(['Person']))
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)
