def setUpClass(cls): cls.conn = r.connect() try: r.db_drop('test').run(cls.conn) except errors.ReqlOpFailedError: pass r.db_create('test').run(cls.conn)
def mk_db(): try: r.db_create(db_name).run(rethink_conn) except rethinkdb.errors.ReqlOpFailedError as e: if 'already exists' in str(e).lower(): logger.info("db already exists, won't remake it") else: raise e
def create_db(database, connection): # TODO REFACTOR TO contains.do(r.branch) BLOCK # TODO PyPi package 2.3.0post6 contains error for the mentioned refactor, # wait for new release if r.db_list().contains(database).run(connection): return {"dbs_created": 0} else: r.db_create(database).run(connection) return {"dbs_created": 1}
def setUp(self): super(DbBaseTestCase, self).setUp() # Create new database and switch to it try: with get_conn() as conn: r.db_create('testing').run(conn) conn.use('testing') except RqlDriverError: raise unittest.SkipTest('RethinkDB is unaccessible')
def real_stock_data_load(data, connection): for db in list(r.db_list().run(connection)): if db == "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 dbSetup(): connection = r.connect(host=RDB_HOST, port=RDB_PORT) try: connection.run(r.db_create(TODO_DB)) connection.run(r.db(TODO_DB).table_create('todos')) print 'Database setup completed. Now run the app without --setup.' except Exception: print 'App database already exists. Run the app without --setup.' finally: connection.close()
def __init__(self): self.db_name = "bitfinex" r.connect("localhost", 28015).repl() databases = r.db_list().run() if self.db_name not in databases: r.db_create(self.db_name).run() indexes = ["currency", "timestamp"] database_tables = r.db(self.db_name).table_list().run() tables = ["balance", "orders", "tickers", "trades", "run_exec"] for table in tables: if table not in database_tables: r.db(self.db_name).table_create(table).run() # indexes indexes_tables = r.db(self.db_name).table(table).index_list().run() for index in indexes: if index not in indexes_tables: if r.db(self.db_name).table(table).has_fields(index): r.db(self.db_name).table(table).index_create(index).run()
def dbSetup(): connection = r.connect(host=RDB_HOST, port=RDB_PORT) try: connection.run(r.db_create(DB_NAME)) connection.run(r.db(DB_NAME).table_create('tools')) connection.run(r.db(DB_NAME).table_create('users')) connection.run(r.db(DB_NAME).table_create('categories')) connection.run(r.db(DB_NAME).table_create('toolboxes')) print 'Database setup completed. Now run the app without --setup.' except Exception: print 'App database already exists. Run the app without --setup.' finally: connection.close()
def initialise(self): """ Set up database with tables and indexes """ self.connect_with_retry() try: log.info("rethinkdb initialising") # Create databases db_exists = r.db_list().contains(self.DB).run(self.conn) if not db_exists: log.info(f'creating database {self.DB}') r.db_create(self.DB).run(self.conn) # Create tables table_exists = r.db(self.DB).table_list().contains(self.TABLE).run(self.conn) if not table_exists: log.info(f'adding table {self.TABLE}') r.db(self.DB).table_create(self.TABLE).run(self.conn) # Create indexes rtable = r.db(self.DB).table(self.TABLE) current_indexes = rtable.index_list().run(self.conn) for index in self.INDEXES: if index not in current_indexes: log.info(f'adding index {index}') rtable.index_create(index).run(self.conn) log.info("rethinkdb ready") except ReqlDriverError as err: log.error(f"rethinkdb failed to initialise: {err}") sys.exit(1)
def connect(): conn = r.connect("db") queries = [ r.db_create(DB), db().table_create(REPORTS), db().table_create(TARGETS), t_reports().index_create("target_id"), t_reports().index_create("date"), ] for q in queries: try: q.run(conn) except r.RqlRuntimeError: pass return conn
def setup(self): """ setup must be called before everything """ if self.__is_setup: return self.__is_setup = True conn = r.connect(**self.__connect_kwargs) def safe_run(rsql, show_error=False): try: return rsql.run(conn) except r.RqlRuntimeError as e: if show_error: logger.warning("safe_run rsql:%s, error:%s", rsql, e) return False # init databases here safe_run(r.db_create(self.__dbname)) rdb = r.db(self.__dbname) for tbl in self.__tables.values(): table_name = tbl['name'] primary_key = tbl.get('primary_key', 'id') safe_run(rdb.table_create(table_name, primary_key=primary_key)) # reset database safe_run(rdb.table("users").index_create("token")) safe_run(rdb.table("devices").replace(lambda q: q.without("sources"))) # reload add idle check functions from .views.device import D # must import in here devices = safe_run(rdb.table("devices").filter({ "using": True }).pluck("udid"), show_error=True) if devices: for d in devices: logger.debug("Device: %s is in using state", d['udid']) D(d['udid']).release_until_idle() r.set_loop_type("tornado")
def migrate(): ''' Creates Database ''' try: db_name = app.config['DATABASE_NAME'] conn = r.connect() # Create Tables if db_name not in r.db_list().run(conn): db = r.db_create(db_name).run(conn) print("Created database '{0}'...".format(db_name)) # Create the application tables if they do not exist lib = importlib.import_module('api.models') for cls in inspect.getmembers(lib, inspect.isclass): for base in cls[1].__bases__: if base.__name__ == "RethinkDBModel": table_name = getattr(cls[1], '_table') r.db(db_name).table_create(table_name).run(conn) print("Created table '{0}'...".format(table_name)) print("Running RethinkDB migration command") except Exception as e: cprint("An error occured --> {0}".format(e), 'red', attrs=['bold'])
from rethinkdb import r r.connect('localhost', 28015).repl() r.db_create('cosmic-retro').run() # Table creation r.db('cosmic-retro').table_create('feedbacks').run()
def _create_database(self): if self.db not in r.db_list().run(self.connection): r.db_create(self.db).run(self.connection)
def create_db(db_name): return r.db_create(db_name)
def test_db_create(self, conn): expected = set(['db_one', 'db_two', 'db_three']) r.db_create('db_three').run(conn) result = self.db_list(conn) assertEqual(expected, result)
def main(mmCIFPath, logPath): # Start time start = time.time() # Logging logging.basicConfig( filename=logPath, level=logging.DEBUG ) # Connect to DB try: conn = r.connect() logging.info('Connected to DB') print('Connected to DB') except Exception as e: logging.debug(e) print(e) # Create DB and connect to it try: r.db_create('pdb_compounds').run() conn.use('pdb_compounds') logging.info('Created DB and connected to it') print('Created DB and connected to it') except Exception as e: logging.debug(e) print(e) # Create table try: r.db('pdb_compounds') \ .table_create('compounds', primary_key='_chem_comp.id') \ .run() logging.info('Created Table: compounds') print('Created Table: compounds') except Exception as e: logging.debug(e) print(e) # Iterate through the mmCIF files and write to DB for cifFile in glob.iglob(os.path.join(mmCIFPath, '*.cif')): try: data = MMCIF2Dict(cifFile) dataJSON = json.dumps(data) # Creates JSON string dataDecoded = json.loads(dataJSON) # Needed to create valid JSON # Insert the data into the DB result = r.table('compounds').insert(dataDecoded).run() logging.info( 'Insertion: ID: {id} | Error: {error} | ' \ 'Inserted: {inserted}'.format( id=data['_chem_comp.id'], error=result['errors'], inserted=result['inserted'] ) ) print('Success: ', cifFile) except Exception as e: logging.debug( 'File: {filename} | Error: {error}'.format( filename=cifFile, error=e ) ) print('Error: ', cifFile) # Close DB Connection conn.close() logging.info('Disconnected to DB') print('Disconnected from DB') # End time end = time.time() timeTaken = (end - start) / 60 logging.info('Time Taken: {time} mins'.format(time=timeTaken)) print('Time Taken: {time} mins'.format(time=timeTaken))