def initialSetup():
    print "Setting up database..."
    dbs = rethinkdb.db_list().run()

    if not con.general.databases["rethink"]["db"] in dbs:
        print "Creating database in rethink"
        rethinkdb.db_create(con.general.databases["rethink"]["db"]).run()

    dbt = list(rethinkdb.table_list().run())
    for db in c.general.flush["rethink"]:
        if c.general.flush["rethink"][db]:
            print "Flushing rethink "+db+" table..."
            if db in dbt:
                rethinkdb.table_drop(db).run()
                dbt.pop(dbt.index(db))

    print "Creating new rethink tables..."
    for table in c.general.tables:
        if not table in dbt:
            print "Creating table {}".format(table)
            rethinkdb.table_create(table).run()

    for key in c.general.flush["redis"]:
        if c.general.flush["redis"][key]:
            print "Flushing redis "+key+" keys..."
            keys = con.redis.keys(key+":*")
            for key in keys: con.redis.delete(key)

    def __init__(self, database='apscheduler', table='jobs', client=None,
                 pickle_protocol=pickle.HIGHEST_PROTOCOL, **connect_args):
        super(RethinkDBJobStore, self).__init__()
        self.pickle_protocol = pickle_protocol

        if not database:
            raise ValueError('The "database" parameter must not be empty')
        if not table:
            raise ValueError('The "table" parameter must not be empty')

        if client:
            self.conn = maybe_ref(client)
        else:
            self.conn = r.connect(db=database, **connect_args)

        if database not in r.db_list().run(self.conn):
            r.db_create(database).run(self.conn)

        if table not in r.table_list().run(self.conn):
            r.table_create(table).run(self.conn)

        if 'next_run_time' not in r.table(table).index_list().run(self.conn):
            r.table(table).index_create('next_run_time').run(self.conn)

        self.table = r.db(database).table(table)

def create_tables(tables):
	"""
	"""
	existing_tables = r.table_list().run(conn)
	for table in tables:
		if table not in existing_tables:
			r.table_create(table).run(conn)

def init_database():
    try:
        connection = r.connect(host=RDB_HOST, port=RDB_PORT, db=RDB_DB)
    except RqlDriverError:
        debug("Could not connect to the database %s:%d, exiting..." % (RDB_HOST, RDB_PORT), True)
        exit(1)

    try:
        r.db_create("tomatoesfridge").run( connection )
    except r.errors.RqlRuntimeError as e:
        # We could parse the error... later...
        debug("Database `tomatoesfridge` not created. Reason:")
        debug(str(e))
    else:
        debug("Database `tomatoesfridge` created")

    try:
        r.table_create("movie").run( connection )
    except r.errors.RqlRuntimeError as e:
        # We could parse the error... later...
        debug("Table `movie` in `tomatoesfridge` not created. Reason")
        debug(str(e))
    else:
        debug("Table `movie` in `tomatoesfridge` created")

    try:
        connection.close()
    except AttributeError:
        debug("Could not close a connection", True)
        pass

def rethinkdb():
    """Prepare database and table in RethinkDB"""
    from rethinkdb.errors import ReqlOpFailedError, ReqlRuntimeError
    conn = r.connect(host=conf.RethinkDBConf.HOST)

    # Create database
    try:
        r.db_create(conf.RethinkDBConf.DB).run(conn)
        click.secho('Created database {}'.format(conf.RethinkDBConf.DB),
                    fg='yellow')
    except ReqlOpFailedError:
        click.secho('Database {} already exists'.format(conf.RethinkDBConf.DB),
                    fg='green')

    # Create table 'domains'
    conn = r.connect(host=conf.RethinkDBConf.HOST,
                     db=conf.RethinkDBConf.DB)
    try:
        r.table_create('domains', durability=conf.RethinkDBConf.DURABILITY).\
            run(conn)
        click.secho('Created table domains', fg='yellow')
    except ReqlOpFailedError:
        click.secho('Table domains already exists', fg='green')
    
    # Create index on domains.name
    try:
        r.table('domains').index_create('name').run(conn)
        click.secho('Created index domains.name', fg='yellow')
    except ReqlRuntimeError:
        click.secho('Index domains.name already exists', fg='green')

def table_create(connection):
    for table in TABLE_NAMES:
        try:
            r.table_create(table).run(connection)
            print ('Table ' + table + ' created')
        except RqlRuntimeError:
            print ('Table ' + table + ' already exists')

 def _create(self):
     try:
         rdb.table_create(self.Meta.table_name).run()
     except RqlRuntimeError:
         return False
     else:
         return True

	def setUp(self):
		
		self.db_name = 'radiowcs_test'
		assert self.db_name != 'radiowcs'
		self.table_name = 'test'

		self.db = database.Database()
		self.db.database_name = self.db_name
		self.db.table_name = self.table_name

		self.db.connect()

		self.connection = r.connect(
			host='localhost',
			port=28015,
			db=self.db_name,
			auth_key='',
			timeout=30
		)
		try:
			r.db_create(self.db_name).run(self.connection)
			r.table_create(self.table_name).run(self.connection)
		except r.RqlRuntimeError:
			print 'unittest setup: Drop table'
			r.table_drop(self.table_name).run(self.connection)
			r.table_create(self.table_name).run(self.connection)
		r.db(self.db_name).table(self.table_name).index_create( 'title').run(self.connection)
		r.db(self.db_name).table(self.table_name).index_create('artist').run(self.connection)
		r.db(self.db_name).table(self.table_name).index_create(  'date').run(self.connection)
		# 'out of order' insertions
		r.db(self.db_name).table(self.table_name).insert({'title':'foobar',      'artist': 'Selena',   'date': '1430183323'}).run(self.connection)
		r.db(self.db_name).table(self.table_name).insert({'title':'hello world', 'artist': 'John',     'date': '1430082566'}).run(self.connection)
		r.db(self.db_name).table(self.table_name).insert({'title':'zombie apoc', 'artist': 'xxJANExx', 'date': '1430385845'}).run(self.connection)
		r.db(self.db_name).table(self.table_name).insert({'title':'Black',       'artist': 'Kettle',   'date': '1430284300'}).run(self.connection)

def _create_table(table_name):
    logger.info("Creating {} table...".format(table_name))
    with get_connection() as conn:
        try:
            r.table_create(table_name).run(conn)
            logger.info("Created table {} successfully.".format(table_name))
        except:
            logger.info("Failed to create table {}!".format(table_name))

def ensure_table_exists(table_name, *args, **kwargs):
    """Creates a table if it doesn't exist."""
    try:
        r.table_create(table_name, *args, **kwargs).run(r_conn())
        print 'Successfully created table ' + table_name
    except r.RqlRuntimeError:
        print 'Table ' + table_name + ' has already been created.'
        pass  # Ignore table already created

def create_db():
    tables = ['datasets', 'visualizations']
    for table in tables:
        try:
            r.table_create(table).run(db.conn)
        except RqlRuntimeError:
            print 'Table `%s` already exists' % table
    print 'Tables have been created.'

 def make_table(self):
     try:
         if self.async:
             yield r.table_create(self.table).run(self.conn)
         else:
             r.table_create(self.table).run(self.conn)
         log.info("Table %s created successfully." % self.table)
     except r.RqlRuntimeError:
         log.info("Table %s already exists... skipping." % self.table)

def create_table(conn):
    try:
        r.table_create("wallpapers").run(conn)
        created = True
    except r.errors.RqlRuntimeError:
        #Already exists
        created = False 
        pass
    return created

def generate_canary():
	""" Generates new canary string """
	canary = ''.join(random.SystemRandom().choice('abcdef' + string.digits) for _ in range(64))

	if 'canary' not in r.table_list().run(flask.g.rdb_conn):
		r.table_create('canary').run(flask.g.rdb_conn)

	r.table('canary').insert({'date': r.now(), 'canary': canary}).run(flask.g.rdb_conn)
	return flask.jsonify(canary=canary)

  def new_table(self, name):
    try:
      r.table_create(name, primary_key='name').run(self.connection)
      self.table = name
    except RqlRuntimeError:
      print 'Error: Table with name \"' + name + '\" already exists'
      return False

    return True

	def configure(self):
		"""Creates required database and tables/collections"""
		self.connect()
		try:
			r.db_create(self.connection.db).run(self.connection)
			r.table_create(self.table_name).run(self.connection)
			r.table(self.table_name).index_create('date')
			print 'Database setup completed.'
		except r.RqlRuntimeError:
			print 'App database already exists..'

    def post_stat(self, statDict):
        if not self.config['enable_stats']:
            return

        LOG.debug("Posting stat: {0}".format(statDict['type']))
        statTable = self.config['rethink_stat_table_template'].format(type=statDict['type'])
        if statTable not in rethinkdb.table_list().run(self.rethink):
            rethinkdb.table_create(statTable).run(self.rethink)

        rethinkdb.table(statTable).insert(statDict).run(self.rethink)

def init_table(name, **kwargs):
    """
    Initialize a table in the database.
    """
    with connect() as con:
        try:
            r.table_drop(name).run(con)
        except r.ReqlOpFailedError:
            pass
        r.table_create(name, **kwargs).run(con)

    def init(self):
        current_version = self.current_version()

        if current_version is not None:
            raise AlreadyInitializedException()

        rethinkdb.table_create(MARKER_TABLE_NAME).run(self.conn)
        rethinkdb.table(MARKER_TABLE_NAME).insert({
            'version': 0,
            'date_updated': utc_now(),
        }).run(self.conn)

def dbcreate(options):
    """Create pasahero database and tables"""
    conn = r.connect(options.dbhost, options.dbport)
      
    if options.dbname in r.db_list().run(conn):
        return

    r.db_create(options.dbname).run(conn)
    conn.use(options.dbname)

    r.table_create('users').run(conn)   
    r.table_create('migrations', primary_key='name').run(conn)