Exemplo n.º 1
0
class QueryBuilderBus(plugins.SimplePlugin):
    """
    A WSPBus plugin that controls
      1. a SQLAlchemy engine/connection pool.
      2. a QueryBuilder
    """
    def __init__(self, bus, url=None, map_file=None):
        plugins.SimplePlugin.__init__(self, bus)
        self.url = url
        self.dbm = DBManager()
        self.qbs = QueryBuilder()
        self.qbs.set_mapper(map_file)
        self.db_result = Results()
        self.con = None

    def start(self):
        """get db connection"""
        print 'Connecting to database '
        self.con = self.dbm.connect(self.url)
        self.qbs.set_from_tables(self.dbm.load_tables( \
                 self.dbm.get_alias(self.url)))
        if self.dbm.db_type[self.dbm.get_alias(self.url)] == 'mysql':
            self.qbs.mapper.set_sens(True)
        self.qbs.recognize_schema(self.dbm, \
                self.dbm.get_alias(self.url))

    def stop(self):
        """close db connection"""
        self.con.close()
        self.con = None
Exemplo n.º 2
0
 def __init__(self, bus, url=None, map_file=None):
     plugins.SimplePlugin.__init__(self, bus)
     self.url = url
     self.dbm = DBManager()
     self.qbs = QueryBuilder()
     self.qbs.set_mapper(map_file)
     self.db_result = Results()
     self.con = None
Exemplo n.º 3
0
 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'
Exemplo n.º 4
0
 def setUp(self):
     """default"""
     self.manager = DBManager()
     self.o_url = \
         'oracle://*****:*****@localhost.localdomain:1522/orcl:liangd'
Exemplo n.º 5
0
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')
Exemplo n.º 6
0
 def setUp(self):
     """default"""
     self.manager = DBManager()
Exemplo n.º 7
0
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')
Exemplo n.º 8
0
def main():
    """
    main
        view original schema graph
        view simulate schema graph
        specify indirect map, such as dataset.parent
        view basic cycles in simulate schema graph
        view core ambiguous graph generate from simulate schema graph
        specify split file
        view the splition result based on the split file
    """
    usage = "usage: %prog -u <database link> -m <mapfile> \n"
    usage += "      --view_origin \n"
    usage += "      --view_simulate \n"
    usage += "      --alias_mapfile=<mapfile with alias tables> \n"
    usage += "      --view_basic_cycles \n"
    usage += "      --view_core_graph \n"
    usage += "      --divide_by=<file specify the splition of core graph> \n"
    usage += "      --view_splition \n"
    parser = OptionParser(usage=usage, version="%prog 1.0")
    parser.add_option("-u", "--url", action="store", type="string",
          dest="url", help="input database connect url")
    parser.add_option("-m", "--mapfile", action="store", type="string",
          dest="mapfile", help="input registration yaml map file")
    parser.add_option("-o", "--view_origin", action="store_true",
          dest="view_origin", help="view origin schema graph")
    parser.add_option("-s", "--view_simulate", action="store_true",
          dest="view_simulate", help="view simulate schema graph")
    parser.add_option("-a", "--alias_mapfile", action="store", type="string",
          dest="alias_mapfile", help="input mapfile based on aliased table")
    parser.add_option("-b", "--view_basic_cycles", action="store_true",
          dest="view_basics", help="view basic cycles on simulate schema graph")
    parser.add_option("-c", "--view_core_graph", action="store_true",
          dest="view_core", help="view core ambiguous graph on simulate graph")
    parser.add_option("-d", "--divide_by", action="store", type="string",
          dest="split_file", help="input split file and do dividing")
    parser.add_option("-r", "--view_splition", action="store_true",
          dest="view_splition", help="view splition graph")

    url = ""
    mapper = Mapper()
#    mapfile = os.path.join(os.path.dirname(sys.argv[0]), 'map.yaml')
    mapfile = ""
    splition_file = None

    (options, _) = parser.parse_args()

    if not options.url:
        parser.error("database url is needed to do schema review")
    url = options.url
    dbmanager = DBManager()
    dbmanager.connect(url)
    dbalias = dbmanager.get_alias(url)
    tables = dbmanager.load_tables(dbalias)
    originschema = None
    simschema = None
    originschema = OriginSchema(dbmanager.db_tables[dbalias])

    if not originschema.check_connective():
        print "schema graph is not connective"
#        raise Exception('Schema graph is not connective')

    if options.view_origin:
        write_original_schema_graph(originschema, "original_schema")
        check_call(['dot', '-Tpng', 'original_schema.dot', '-o', \
            'original_schema.png'])

    if not options.mapfile:
        print "further review need mapfile"
        return

    mapfile = options.mapfile
    mapper.load_mapfile(mapfile)
    if dbmanager.db_type[dbalias] == 'mysql':# for mysql case sensitive
        mapper.set_sens(True)

    if not mapper.validate_map(tables):
        raise Exception("conflicts between map file and schema")

    originschema.recognize_type(mapper)
    originschema.handle_alias()
    originschema.gen_attr_links(mapper)

    load_statistics(dbmanager, dbalias, originschema)

    if options.alias_mapfile:
        mapper.load_mapfile(options.alias_mapfile)


    simschemas = originschema.gen_simschema()
    for simschema in simschemas:
        simschema.update_nodelist()

    originschema.recognize_shortcut()

    if options.view_simulate:
        write_original_schema_graph(originschema, "simschema0")
        check_call(['dot', '-Tpng', 'simschema0.dot', '-o', \
            'simschema.png'])
        for idx in range(len(simschemas)):
            simschema = simschemas[idx]
            fname = 'simschema%d.png' % idx
            if len(simschema.nodelist) > 1:
                write_simulate_schema_graph(simschema, 'simschema1')
                check_call(['dot', '-Tpng', 'simschema1.dot', '-o', fname])

    if options.view_basics:
        for idx in range(len(simschemas)):
            simschema = simschemas[idx]
            if len(simschema.nodelist) < 2:
                continue
            if not write_basics_cycles(simschema, "basic_cycle%d" % idx):
                continue
            fname = 'basic_cycle%d_pack.png' % idx
            p1 = Popen(["dot"] + glob.glob('basic_cycle%d_*.dot' % idx), \
                stdout=PIPE)
            p2 = Popen(["gvpack"], stdin=p1.stdout, stdout=PIPE)
            p3 = Popen(['dot', '-Tpng', '-o', fname], \
                stdin=p2.stdout, stdout=PIPE)
            p1.stdout.close()  # Allow p1 to receive a SIGPIPE if p2 exits.
            p2.stdout.close()
            output = p3.communicate()[0]

    if options.view_core:
        for idx in range(len(simschemas)):
            simschema = simschemas[idx]
            if len(simschema.nodelist) < 2:
                continue
            write_core_wgraph(simschema)
            fname = 'coreschema%d.png' % idx
            check_call(['dot', '-Tpng', 'coreschema.dot', '-o', fname])

    if options.split_file:
        splition_file = options.split_file

    if options.view_splition:
        for idx in range(len(simschemas)):
            simschema = simschemas[idx]
            if len(simschema.nodelist) < 2:
                continue
            write_splition(simschema, splition_file, "Subgraph%d" % idx)
            fname = 'subgraph%d_pack.png' % idx
            p1 = Popen(["dot"] + glob.glob('Subgraph%d_*.dot' % idx), \
                stdout=PIPE)
            p2 = Popen(["gvpack"], stdin=p1.stdout, stdout=PIPE)
            p3 = Popen(['dot', '-Tpng', '-o', fname], \
                stdin=p2.stdout, stdout=PIPE)
            p1.stdout.close()  # Allow p1 to receive a SIGPIPE if p2 exits.
            p2.stdout.close()
            output = p3.communicate()[0]
Exemplo n.º 9
0
import getopt
import time
from logging import getLogger
from pyquerybuilder.qb.ConfigureLog import configurelog


from pyquerybuilder.db.DBManager import DBManager
from pyquerybuilder.dbsh.dbprint import PrintOutput
from pyquerybuilder.qb.pyqb import QueryBuilder

#RESULTS = Results()
#SCHEMA_FILE = None
FILE_DICT = {'MAP_FILE':None, 'SCHEMA_FILE':None}

try:
    DB = DBManager()
    DBPRINT = PrintOutput()
    QB = QueryBuilder()
#    FILE_DICT['MAP_FILE'] = os.getenv('HOME')+'/.ipython/map.yaml'
#    QB.set_mapper(FILE_DICT['MAP_FILE'])
except:
    traceback.print_exc()
    raise Exception, DBPRINT.msg_red("ERROR: fail to load DBManager")
try:
    configurelog()
except:
    traceback.print_exc()
    raise Exception, DBPRINT.msg_red("ERROR: fail to configure log")

_LOGGER = getLogger("ConstructQuery")
Exemplo n.º 10
0
 def set_manager(self, url, alias):
     """set manager"""
     self.manager = DBManager()
     self.url = url
     self.db_name = alias
Exemplo n.º 11
0
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
Exemplo n.º 12
0
def main():
    """main """
    usage = "usage: %prog -m mapfile \n"
    usage += "      -v --validate_mapfile=<mapfile> --source=<database link>\n"
    usage += "      --find_key=<table|table.column> --find_column=<key> \n"
    usage += "      --find_table=<key> --list_key --list_column --list_entity"
    parser = OptionParser(usage=usage, version="%prog 1.0")
    parser.add_option("-m", "--mapfile", action="store", type="string",
          dest="mapfile", help="input registration yaml map file")
    parser.add_option("-v", "--validate", action="store_true",
          dest="validate", help="perform validation for the mapping")
    parser.add_option("-f", "--validate_mapfile", action="store", type="string",
          dest="vmapfile", help="input validate mapfile")
    parser.add_option("-s", "--source", action="store", type="string",
          dest="source", help="input validate database source link")
    parser.add_option("-k", "--find_key", action="store", type="string",
          dest="find_key", help="input table/column to get corresponding key ")
    parser.add_option("-c", "--find_column", action="store", type="string",
          dest="find_column", help="input key to get table[.column] ")
    parser.add_option("-t", "--find_table", action="store", type="string",
          dest="find_table", help="input key to get only table name ")
    parser.add_option("-e", "--list_key", action="store_true",
          dest="list_key", help="list all keys ")
    parser.add_option("-o", "--list_column", action="store_true",
          dest="list_column", help="list all tables/columns")
    parser.add_option("-i", "--list_entity", action="store_true",
          dest="list_entity", help="list all entity ")

    mapper = Mapper()
    mapfile = os.path.join(os.path.dirname(sys.argv[0]), 'map.yaml')
    validate = False
    column = None
    key = None
    list_key = False
    list_column = False
    list_entity = False
    vmap = None
    sloader = SchemaLoader()
    dbmanager = None
    source = None

    (options, args) = parser.parse_args()
    if options.mapfile:
        mapfile = options.mapfile
    if options.validate:
        validate = options.validate
        if options.vmapfile:
            vmap = options.vmapfile
        elif options.source:
            source = options.source
        else:
            parser.error("options -v need either mapfile or source")
    if options.find_key:
        column = options.find_key
    if options.find_column:
        key = options.find_column
    if options.find_table:
        key = options.find_table
    if options.list_key:
        list_key = options.list_key
    if options.list_column:
        list_column = options.list_column
    if options.list_entity:
        list_entity = options.list_entity

    mapper.load_mapfile(mapfile)

    if validate:
        if vmap:
            tables = sloader.load_from_file(vmap).sorted_tables
            if mapper.validate_map(tables):
                print "Validate is OK"
        else:
            dbmanager = DBManager()
            dbmanager.connect(source)
            dbaliase = dbmanager.get_alias(source)
            tables = dbmanager.load_tables(dbaliase)
            if mapper.validate_map(tables):
                print "Validate is OK"
    if column:
        mapper.pprint(mapper.get_key(column))
    if key:
        if options.find_column:
            mapper.pprint(mapper.get_column(key))
        if options.find_table:
            mapper.pprint(mapper.get_table(key))
    if list_key:
        mapper.pprint(mapper.list_key())
    if list_column:
        mapper.pprint(mapper.list_column())
    if list_entity:
        mapper.pprint(mapper.list_entity())
 def setUp(self):
     """default"""
     self.manager = DBManager()
     self.p_url = 'postgresql://*****:*****@localhost:5432/test'
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')
Exemplo n.º 15
0
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)
Exemplo n.º 16
0
def main():
    usage = "usage: %prog -m mapfile \n"
    usage += "      -s databaselink -a alias_mapfile\n"
    parser = OptionParser(usage=usage, version="%prog 1.0")
    parser.add_option("-m", "--mapfile", action="store", type="string",
          dest="mapfile", help="input registration yaml map file")
    parser.add_option("-s", "--source", action="store", type="string",
          dest="source", help="input validate database source link")
    parser.add_option("-a", "--alias_mapfile", action="store", type="string",
          dest="alias_mapfile", help="input mapfile based on aliased table")

    mapper = Mapper()
    mapfile = None
    dbmanager = None
    source = None
    originschema = None
    simschema = None

    (options, args) = parser.parse_args()
    if options.mapfile:
        mapfile = options.mapfile
    if options.source:
        source = options.source


    if mapfile == None or source == None:
        print "mapfile and source is needed"
        return

    mapper.load_mapfile(mapfile)
    dbmanager = DBManager()
    dbmanager.connect(source)
    dbalias = dbmanager.get_alias(source)
    tables = dbmanager.load_tables(dbalias)

    columns = mapper.list_column()
    entities = mapper.list_entity()
    keys = mapper.list_key()
    edict = {}
    edict = gendict(mapper)
   #gen single
    gen_single(edict)
    samples = get_sample(mapper, dbmanager, dbalias)

#    if dbmanager.db_type[dbalias] == 'mysql':# for mysql case sensitive
#        mapper.set_sens(True)
    originschema = OriginSchema(dbmanager.db_tables[dbalias])
    originschema.check_connective()
    originschema.recognize_type(mapper)
    originschema.handle_alias()
#    print originschema.alias_table
    samples = get_sample(mapper, dbmanager, dbalias, originschema.alias_table)
#    print samples

    originschema.gen_attr_links(mapper)
    load_statistics(dbmanager, dbalias, originschema)

    if options.alias_mapfile:
        mapper.load_mapfile(options.alias_mapfile)
    edict = gendict(mapper)
    single = gen_single(edict)
    writedown(single, 'single.txt')
    singlec = gen_single_constraints(edict, single, mapper, samples)
    writedown(singlec, 'singlec.txt')

    double = gen_double(edict)
#    p.pprint (double)
    doublec = gen_double_constraints(edict, double, mapper, samples)
    writedown(doublec, 'doublec.txt')

    multiple = gen_multiple(edict, 3)
    writedown(multiple, 'multiple.txt')
    multiple = gen_multiple(edict, 4)
    writedown(multiple, 'multiple4.txt')