def init(conn, event):
    # try to drop table (may or may not exist)
    rv = ''
    try:
        r.db_drop(TIX).run(conn)
        rv = 'dropped, then created'
    except:
        rv = 'created'
    r.db_create(TIX).run(conn)
    r.db(TIX).table_create(VENU).run(conn)
    r.db(TIX).table(VENU).index_create(TS).run(conn)

    smap = {}
    umap = {}
    for x in range(1, CNT + 1):
        smap[str(x)] = 'free' 
        umap[str(x)] = ''

    rv += str(r.db(TIX).table(VENU).insert({
        ID: 0,
        SMAP: smap,
        UMAP: umap,
        MAX: CNT,
        TS: time.time()
    }).run(conn))

    return rv

def main():
    import rethinkdb as r
    from rethinkdb.errors import RqlRuntimeError

    # Lib para auxilio na insercao de dados de teste
    from faker import Factory
    fake = Factory.create('pt_BR')

    # Conecta ao banco local
    r.connect(HOST, PORT).repl()

    try:
        r.db_drop(DBNAME).run()
    except RqlRuntimeError:
        pass

    # Cria o banco de dados
    r.db_create(DBNAME).run()

    # Cria a tabela
    r.db(DBNAME).table_create(TABLENAME).run()

    # Insere os registros na tabela
    for frase in range(TOTAL_FRASES):
        reg = {
            'id': frase,
            'frase': fake.text(),
            'autor': fake.name()
        }
        r.db(DBNAME).table(TABLENAME).insert(reg).run()

def main():
    # connect rethinkdb
    rethinkdb.connect("localhost", 28015, "mysql")
    try:
        rethinkdb.db_drop("mysql").run()
    except:
        pass
    rethinkdb.db_create("mysql").run()

    tables = ["dept_emp", "dept_manager", "titles",
              "salaries", "employees", "departments"]
    for table in tables:
        rethinkdb.db("mysql").table_create(table).run()

    stream = BinLogStreamReader(
        connection_settings=MYSQL_SETTINGS,
        blocking=True,
        only_events=[DeleteRowsEvent, WriteRowsEvent, UpdateRowsEvent],
    )

    # process Feed
    for binlogevent in stream:
        if not isinstance(binlogevent, WriteRowsEvent):
            continue

        for row in binlogevent.rows:
            if not binlogevent.schema == "employees":
                continue

            vals = {}
            vals = {str(k): str(v) for k, v in row["values"].iteritems()}
            rethinkdb.table(binlogevent.table).insert(vals).run()

    stream.close()

def init_database_with_default_tables(args):
    """
    Create a new RethinkDB database and initialise (default) tables

    :param args: an argparse argument (force)
    """
    # Add additional (default) tables here...
    def_tables = ['determined_variants', 'strains_under_investigation',
                  'references', 'reference_features', 'strain_features']
    with database.make_connection() as connection:
        try:
            r.db_create(connection.db).run(connection)
            for atable in def_tables:
                r.db(connection.db).table_create(atable).run(connection)
        except RqlRuntimeError:
            print ("Database %s already exists. Use '--force' option to "
                   "reinitialise the database." % (connection.db))
            if args.force:
                print "Reinitialising %s" % (connection.db)
                r.db_drop(connection.db).run(connection)
                r.db_create(connection.db).run(connection)
                for atable in def_tables:
                    r.db(connection.db).table_create(atable).run(connection)
            else:
                sys.exit(1)
        print ("Initalised database %s. %s contains the following tables: "
               "%s" % (connection.db, connection.db, ', '.join(def_tables)))

def delete_databases(dbnames=[]):
    b = Bigchain()

    for dbname in dbnames:
        logger.info('Dropping database: {}'.format(dbname))
        try:
            r.db_drop(dbname).run(b.conn)
        except r.ReqlOpFailedError as e:
            logger.info(e.message)

def drop_db():
    logger.info("Dropping RethinkDB database '{}'...".format(RETHINKDB_NAME))
    try:
        with get_connection() as conn:
            r.db_drop(RETHINKDB_NAME).run(conn)
            logger.info("RethinkDB database dropped successfully.")
    except r.RqlRuntimeError:
        logger.info("Database '{}' does not exist on {}:{}".format(
            RETHINKDB_NAME, RETHINKDB_HOST, RETHINKDB_PORT))

 def tearDownClass(self):
     """ Drops the test database after the classes' tests are finished """
     with rethinkdb.connect(host='localhost', port=28015) as conn:
         if 'TEST' in rethinkdb.db_list().run(conn):
             rethinkdb.db_drop('TEST').run(conn)
     try:
         self.rdb.close()
     except AttributeError:
         pass

def drop_database():
    """
    Deletes the RethinkDB database
    """
    try:
        with get_connection() as conn:
            rethink.db_drop(DEFAULT_DB_NAME).run(conn)
    except (RqlRuntimeError, RqlDriverError) as err:
            print(err.message)

def db_drop():
    connection = r.connect(host=RDB_HOST, port=RDB_PORT)
    try:
        r.db_drop(DB).run(connection)
        print "Database dropped."
    except:
        print "Error in dropping database"
    finally:
        connection.close()

def DropTable(name, conn):
  '''Dropping tables -- for clean-up.'''

  try:
    r.db_drop(name).run(conn)
    return True

  except Exception as e:
    print "Could not drop table `%s`" % name
    return False

    def fin():
        print('Deleting `{}` database'.format(db_name))
        get_conn().repl()
        try:
            r.db_drop(db_name).run()
        except r.ReqlOpFailedError as e:
            if e.message != 'Database `{}` does not exist.'.format(db_name):
                raise

        print('Finished deleting `{}`'.format(db_name))

def init_db():
    """
    Initialize the database.
    """
    with connect() as con:
        try:
            r.db_drop('awe').run(con)
        except r.ReqlOpFailedError:
            pass
        r.db_create('awe').run(con)

	def test_configure(self):
		# r.table_drop(self.table_name).run(self.connection)
		r.db_drop(self.db_name).run(self.connection)
		self.db.configure()
		
		db_exists = r.db_list().contains(self.db_name).run(self.connection)
		self.assertTrue( db_exists )
		
		table_exists = r.db(self.db_name).table_list().contains(self.table_name).run(self.connection)
		self.assertTrue( table_exists )

def rethink_unique_db(rethink_server_sess):
    """ Starts up a session-scoped server, and returns a connection to
        a unique database for the life of a single test, and drops it after
    """
    dbid = uuid.uuid4().hex
    conn = rethink_server_sess.conn
    rethinkdb.db_create(dbid).run(conn)
    conn.use(dbid)
    yield conn
    rethinkdb.db_drop(dbid).run(conn)

def real_stock_data_load(data, connection):
    for db in list(r.db_list().run(connection)):
        if db == u"rethinkdb":
            # This db is special and can't be deleted.
            continue
        r.db_drop(db).run(connection)
    for db_name, db_data in iteritems(data['dbs']):
        r.db_create(db_name).run(connection)
        for table_name, table_data in iteritems(db_data['tables']):
            r.db(db_name).table_create(table_name).run(connection)
            r.db(db_name).table(table_name).insert(table_data).run(connection)

def db_reset():
    if yn_choice("Are you sure you wish to reset the Database?\nAll data will be lost and this cannot be undone.", 'n'):
        connection = r.connect(host=RDB_HOST, port=RDB_PORT, db=CP2020_DB)
        try:
            r.db_drop(CP2020_DB).run(connection)
            print ('Database deleted')
        except RqlRuntimeError:
            print ('Database could not be deleted')
        finally:
            connection.close()
        db_setup()

def init_tables():
    """
    Create the tables we are going to use
    """
    global connection, tables

    print "Creating databases/tables...",
    sys.stdout.flush()
    try:
        r.db_drop("test").run(connection)
    except r.errors.RqlRuntimeError, e:
        pass

 def setUpClass(cls):
     cls.connection = r.connect(host=DB.RDB_HOST, port=DB.RDB_PORT, db=DB_AWS_TEST)
     try:
         # Create the DB tables we need
         DB.Database.create_db_structure(DB_AWS_TEST)
         test_conf = TestingConfig(DB_AWS_TEST)
         cls.app = app.create_app(test_conf).test_client()
         # print 'Set-up DONE. DB-name: {db_name}'.format(db_name=DB_AWS_TEST)
     except RqlRuntimeError:
         # print 'The test-database already exist. Will remove it, and then re-run the test!'
         r.db_drop(DB_AWS_TEST).run(cls.connection)
         cls.setUpClass()

    def drop_database(self):
        """Drop the db for the application.

        If the db exists, log a warning.

        Returns:
            None
        """

        dbs = r.db_list().run(self.connection)
        if self.db in dbs:
            r.db_drop(self.db).run(self.connection)

def db_init(dest_ip):
    # connect
    conn = r.connect(dest_ip, 28015)
    state = ''
    try:
        r.db_drop('authentication').run(conn)
        state = 'deleted, then created'
    except:
        state = 'created'

    r.db_create('authentication').run(conn)
    r.db('authentication').table_create('user', primary_key = 'account').run(conn)