class TestDBManager(unittest.TestCase):
"""test DBManager"""
def setUp(self):
"""default"""
self.manager = DBManager()
self.o_url = \
'oracle://*****:*****@localhost.localdomain:1522/orcl:liangd'
def test_get_dbname(self):
"""test execute query on sqlite DB"""
# oracle
arg = self.o_url
db_name = self.manager.dbname(arg)
print "db_name: %s" % db_name
oracle_name = 'oracle-orcl-liangd |\#> '
self.assertEqual(db_name, oracle_name)
def test_connection(self):
"""test get connection with diff DB"""
# oracle
arg = self.o_url
self.manager.connect(arg)
self.manager.show_table('orcl-liangd')
results = self.manager.execute("select count(*) from t1")
rows = results.fetchall()
self.manager.close('orcl-liangd')
self.assertEqual(3, rows[0][0])
def test_desc(self):
"""test describe database"""
# oracle
arg = self.o_url
self.manager.connect(arg)
length = self.manager.desc('orcl-liangd', 't1')
self.assertEqual(4, length)
length = self.manager.desc('orcl-liangd', 't2')
self.assertEqual(4, length)
self.manager.close('orcl-liangd')
def test_dump(self):
"""test dump database in file"""
# oracle
arg = self.o_url
self.manager.connect(arg)
self.manager.dump('orcl-liangd')
self.manager.close('orcl-liangd')
def test_migrate_drop(self):
"""test migrate database"""
# oracle
arg = self.o_url
self.manager.connect(arg)
arg = 'oracle://*****:*****@localhost.localdomain:1522/orcl:scott'
self.manager.migrate('orcl-liangd', arg)
self.manager.close('orcl-liangd')
self.manager.connect(arg)
results = self.manager.execute("select count(*) from t1")
rows = results.fetchall()
self.assertEqual(3, rows[0][0])
self.manager.drop_table('orcl-scott', 't2')
self.manager.drop_table('orcl-scott', 't1')
self.manager.close('orcl-scott')
def test_reconnect(self):
"""test reconnect to database"""
# oracle
arg = self.o_url
self.manager.connect(arg)
self.manager.reconnect('orcl-liangd')
self.manager.close('orcl-liangd')
class TestDBManager(unittest.TestCase):
"""test DBManager"""
def setUp(self):
"""default"""
self.manager = DBManager()
def test_get_dbname(self):
"""test execute query on sqlite DB"""
# sqlite
db_name = self.manager.dbname('sqlite://test.db')
# print "db_name: %s" % db_name
sqlite_name = 'sqlite-test.db |\#> '
self.assertEqual(db_name, sqlite_name)
def test_connection(self):
"""test get connection with diff DB"""
# sqlite
self.manager.connect('sqlite://test.db')
self.manager.show_table('test.db-sqlite')
results = self.manager.execute("select count(*) from t1")
rows = results.fetchall()
self.manager.close('test.db-sqlite')
self.assertEqual(3, rows[0][0])
rows = []
def test_desc(self):
"""test describe database"""
# sqlite
self.manager.connect('sqlite://test.db')
length = self.manager.desc('test.db-sqlite', 't1')
self.assertEqual(4, length)
length = self.manager.desc('test.db-sqlite', 't2')
self.assertEqual(4, length)
self.manager.close('test.db-sqlite')
def test_dump(self):
"""test dump database in file"""
# sqlite
self.manager.connect('sqlite://test.db')
self.manager.dump('test.db-sqlite')
self.manager.close('test.db-sqlite')
def test_migrate_drop(self):
"""test migrate database"""
# sqlite
self.manager.connect('sqlite://migrate.db')
self.manager.drop_db('migrate.db-sqlite')
self.manager.close('migrate.db-sqlite')
self.manager.connect('sqlite://test.db')
self.manager.migrate('test.db-sqlite', 'sqlite://migrate.db')
self.manager.close('test.db-sqlite')
self.manager.connect('sqlite://migrate.db')
results = self.manager.execute("select count(*) from t1")
rows = results.fetchall()
self.assertEqual(3, rows[0][0])
rows = []
self.manager.drop_table('migrate.db-sqlite', 't2')
self.manager.drop_db('migrate.db-sqlite')
self.manager.close('migrate.db-sqlite')
def test_reconnect(self):
"""test reconnect to database"""
# sqlite
self.manager.connect('sqlite://test.db')
self.manager.reconnect('test.db-sqlite')
self.manager.close('test.db-sqlite')
class TestDBManager(unittest.TestCase):
"""test DBManager"""
def setUp(self):
"""default"""
self.manager = DBManager()
self.p_url = 'postgresql://*****:*****@localhost:5432/test'
def test_get_dbname(self):
"""test execute query on sqlite DB"""
# postgresql
arg = self.p_url
db_name = self.manager.dbname(arg)
print "db_name: %s" % db_name
postgresql_name = 'postgresql-test-localhost |\#> '
self.assertEqual(db_name, postgresql_name)
def test_connection(self):
"""test get connection with diff DB"""
# postgresql
arg = self.p_url
self.manager.connect(arg)
self.manager.show_table('test-postgresql')
results = self.manager.execute("select count(*) from t1")
rows = results.fetchall()
self.manager.close('test-postgresql')
self.assertEqual(3, rows[0][0])
def test_desc(self):
"""test describe database"""
# postgresql
arg = self.p_url
self.manager.connect(arg)
length = self.manager.desc('test-postgresql', 't1')
self.assertEqual(4, length)
length = self.manager.desc('test-postgresql', 't2')
self.assertEqual(4, length)
self.manager.close('test-postgresql')
def test_dump(self):
"""test dump database in file"""
# postgresql
arg = self.p_url
self.manager.connect(arg)
self.manager.dump('test-postgresql')
self.manager.close('test-postgresql')
def test_migrate_drop(self):
"""test migrate database"""
# postgresql
self.manager.connect(self.p_url)
arg = 'postgresql://*****:*****@localhost:5432/migrate'
self.manager.migrate('test-postgresql', arg)
self.manager.close('test-postgresql')
print "finished migrated and closed test-postgresql DB"
self.manager.connect(arg)
results = self.manager.execute("select count(*) from t1")
rows = results.fetchall()
self.assertEqual(3, rows[0][0])
rows = []
self.manager.close('migrate-postgresql')
self.manager.connect(arg)
# if _DEBUG == True:
# import pdb
# pdb.set_trace()
# try:
# self.manager.drop_table('migrate-postgresql', 't2')
# self.manager.drop_table('migrate-postgresql', 't1')
# except:
# traceback.print_exc()
self.manager.drop_table('migrate-postgresql', 't2')
print "droped table t2"
self.manager.drop_db('migrate-postgresql')
self.manager.close('migrate-postgresql')
def test_reconnect(self):
"""test reconnect to database"""
# postgresql
self.manager.connect(self.p_url)
self.manager.reconnect('test-postgresql')
self.manager.close('test-postgresql')
class App():
"""Application demo"""
def __init__(self, verbose = 0):
"""initialize"""
class MySchema(object):
"""class encapsulate tables structure"""
def __init__(self, tables=None):
"""initialize """
self.tables = tables
def set_tables(self, tables):
"""set tables"""
self.tables = tables
self.schema = MySchema()
self.manager = None
self.db_name = None
self.querybuilder = None
self.url = None
self.mapper = None
def set_manager(self, url, alias):
"""set manager"""
self.manager = DBManager()
self.url = url
self.db_name = alias
def get_db_connection(self):
"""get db connection"""
return self.manager.connect(self.url)
def close_db_connection(self):
"""close db connection"""
return self.manager.close(self.db_name)
def set_mapper(self, mapfile='map.yaml'):
"""set mapper"""
self.mapper = Mapper()
self.mapper.load_mapfile(mapfile)
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 parse_input(self, in_puts):
"""parse input"""
return test_query_parser(self.mapper, in_puts)
def generate_sqlalchemy_query(self, query):
"""generate sqlalcemy query"""
# print type(process_dataset.c.Name)
# print type(process_dataset.columns['Name'])
return generate_query(self.schema, query)
def build_query(self, query):
"""build query"""
# print "query._raw_columns is ", select_test._raw_columns
# print "query.inner_columns is ", [col for col in select_test.inner_columns]
# print "query.froms is ", select_test.froms
# print dir(select_test)
return self.querybuilder.build_query(query)
def execute_query(self, query):
"""execute query"""
try:
result = self.manager.execute(query)
return result
except Error:
print Error
return None
class TestDBManager(unittest.TestCase):
"""test DBManager"""
def setUp(self):
"""default"""
self.manager = DBManager()
self.url = 'sqlite:///test.db'
self.murl = 'sqlite:///migrate.db'
self.pname = 'sqlite-test.db |\#> '
self.name = 'sqlite-test.db'
self.mname = 'sqlite-migrate.db'
def test_get_dbname(self):
"""test execute query on sqlite DB"""
db_name = self.manager.dbname(self.url)
# print "db_name: %s" % db_name
self.assertEqual(db_name, self.pname)
def test_connection(self):
"""test get connection with diff DB"""
self.manager.connect(self.url)
self.manager.show_table(self.name)
results = self.manager.execute("select count(*) from block")
rows = results.fetchall()
self.manager.close(self.name)
self.assertEqual(10, rows[0][0])
rows = []
def test_desc(self):
"""test describe database"""
self.manager.connect(self.url)
length = self.manager.desc(self.name, 'block')
self.assertEqual(7, length)
length = self.manager.desc(self.name, 'processeddataset')
self.assertEqual(6, length)
self.manager.close(self.name)
def test_dump(self):
"""test dump database in file"""
self.manager.connect(self.url)
self.manager.dump(self.name)
self.manager.close(self.name)
def test_migrate_drop(self):
"""test migrate database"""
if self.murl.startswith('oracle'):
return
self.manager.connect(self.url)
self.manager.migrate(self.name, \
self.murl)
self.manager.close(self.name)
self.manager.connect(self.murl)
results = self.manager.execute("select count(*) from block")
rows = results.fetchall()
self.assertEqual(10, rows[0][0])
self.manager.close(self.mname)
self.manager.connect(self.murl)
self.manager.drop_table(self.mname, 'primarydataset')
self.manager.drop_db(self.mname)
self.manager.close(self.mname)
def test_reconnect(self):
"""test reconnect to database"""
self.manager.connect(self.url)
self.manager.reconnect(self.name)
self.manager.close(self.name)
