def get_connection(self, dsn: str = None):
"""
Getting the database connection and driver based on parameters
"""
driver = self.Meta.driver if self.Meta.driver else "pg"
if driver:
# logging.debug('Getting data from Database: {}'.format(driver))
# working with app labels
try:
app = self.Meta.app_label if self.Meta.app_label else None
except AttributeError:
app = None
if app:
# TODO: get formula to got app database list
# db = DATABASES[app]
db = {}
try:
params = {
"user": db["USER"],
"password": db["PASSWORD"],
"host": db["HOST"],
"port": db["PORT"],
"database": db["NAME"],
}
if "SCHEMA" in db:
params["schema"] = db["SCHEMA"]
except KeyError:
pass
elif hasattr(self.Meta, "credentials"):
params = self.Meta.credentials
self.Meta.connection = AsyncDB(driver, params=params)
elif dsn is not None:
# print('HERE ', dsn)
self.Meta.connection = AsyncDB(driver, dsn=dsn)
return self.Meta.connection
async def _make_connection():
try:
self.connection = AsyncDB('pg', dsn=default_dsn)
await self.connection.connection()
except Exception as err:
print(err)
raise Exception(err)
async def test_connect(driver, params, event_loop):
db = AsyncDB(driver, params=params, loop=event_loop)
await db.connection()
print('CONNECTED: ', db.is_connected() is True)
result, error = await db.test_connection()
print(result, error)
print(type(result) == list)
db.use('library') # set database to work
# # making a simple query:
# result, error = await db.query('SELECT * from events')
# print(error)
# for row in result:
# print(row)
# creation and insertion:
await db.execute("CREATE TABLE tests (id int, name text, PRIMARY KEY(id))")
ql = "INSERT INTO tests (id, name) VALUES(?, ?)"
# prepare the statement:
prepared, error = await db.prepare(ql)
print(": prepare the statement: ", prepared)
print(": Executing Insert of many entries: ")
result, error = await db.execute(prepared, (2, "def"))
result, error = await db.execute(prepared, (3, "ghi"))
result, error = await db.execute(prepared, (4, "jkl"))
examples = [(5, "mno"), (6, "pqr"), (7, "stu")]
for example in examples:
result, error = await db.execute(prepared, example)
print(result, error)
result, error = await db.query("SELECT * FROM tests")
for row in result:
print(row)
await db.close()
async def test_pool_by_params(driver, event_loop):
db = AsyncDB(driver, params=params, loop=event_loop)
assert db.is_connected() is False
await db.connection()
pytest.assume(db.is_connected() is True)
await db.close()
assert db.is_closed() is True
async def test_connect(driver, event_loop):
db = AsyncDB(driver, params=params, loop=event_loop)
await db.connection()
pytest.assume(db.is_connected() is True)
result, error = await db.test_connection()
pytest.assume(type(result) == list)
await db.close()
async def test_connect(driver, params, event_loop):
db = AsyncDB(driver, params=params, loop=event_loop)
await db.connection()
print('CONNECTED: ', db.is_connected() is True)
result, error = await db.test_connection()
print(result, error)
print(type(result) == list)
await db.close()
def adb():
try:
db = AsyncDB('postgres', dsn=asyncpg_url)
if db:
db.connect()
return asyncORM(db=db)
except Exception as err:
raise Exception(err)
async def test_connect(driver, event_loop):
db = AsyncDB(driver, params=params, loop=event_loop)
await db.connection()
pytest.assume(db.is_connected() is True)
result, error = await db.test_connection('bigtest')
pytest.assume(not error)
assert result == 'bigtest'
await db.close()
async def test_connect(driver, event_loop):
db = AsyncDB(driver, params=PARAMS, loop=event_loop)
await db.connection()
pytest.assume(db.is_connected() is True)
result, error = await db.test_connection()
pytest.assume(type(result) == dict)
pytest.assume(result['version'] == '4.4.2')
await db.close()
pytest.assume(db.is_connected() is False)
def create_problem_data(proid):
db = AsyncDB(config.MOD_DBNAME, config.MOD_DBUSER,
config.MOD_DBPASSWORD)
cur = db.cursor()
sqlstr = ('INSERT INTO "PMOD_TEST_MODE" ("proid", "modeid", '
'"content", "testmodeid") VALUES (%s, %s, %s, %s);')
sqlarr = (proid, 1, '', None)
cur.execute(sqlstr, sqlarr)
async def test_connect(driver, event_loop):
db = AsyncDB(driver, params=PARAMS, loop=event_loop)
await db.connection()
pytest.assume(db.is_connected() is True)
result, error = await db.test_connection()
pytest.assume(type(result) == list)
row = result[0]
pytest.assume(row['release_version'] == '3.11.8')
await db.close()
pytest.assume(db.is_connected() is False)
def __init__(self, pubkey, privkey=None):
super().__init__()
self.set_verifykey(pubkey)
if privkey != None:
self.set_signkey(privkey)
TOJAuth.instance = self
TOJAuth.db = AsyncDB(config.CORE_DBNAME, config.CORE_DBUSER,
config.CORE_DBPASSWORD)
def __init__(self, dsn="", session: AbstractSession = None, loop=None):
if loop:
self._loop = loop
else:
self._loop = asyncio.get_event_loop()
self._result = {}
self._session_key = ""
self._session_id = None
self._loop.set_exception_handler(nav_exception_handler)
# TODO: define other session backend
self._cache = redis = AsyncDB("redis", dsn=dsn)
self._session = session
async def test_huge_query(event_loop):
sql = 'SELECT * FROM trocplaces.stores'
check_conn = None
db = AsyncDB(DRIVER, params=params, loop=event_loop)
async with await db.connection() as conn:
result, error = await conn.execute("SET TIMEZONE TO 'America/New_York'")
pytest.assume(not error)
result, error = await conn.query(sql)
pytest.assume(not error)
pytest.assume(result is not None)
check_conn = conn
pytest.assume(check_conn is not None)
async def test_pool_connect(event_loop):
db = AsyncDB(DRIVER, params=params, loop=event_loop)
pytest.assume(db.is_connected() is False)
await db.connection()
pytest.assume(db.is_connected() == True)
result, error = await db.execute("SELECT 1")
print(result)
pytest.assume(result == 'SELECT 1')
result, error = await db.test_connection()
print(result, error)
row = result[0]
pytest.assume(row[0] == 1)
await db.close()
assert (not db.get_connection())
def __init__(self,mod_idendesc,get_link_fn):
self.DATATYPE_CHALLENGE = 1
self.DATATYPE_STATUS = 2
self.DATASTSTUS_PEND = 1
self.DATASTSTUS_WAIT = 2
self.DATASTSTUS_DONE = 3
self._idendesc = mod_idendesc
self.get_link = get_link_fn
self.db = AsyncDB(config.CORE_DBNAME,config.CORE_DBUSER,
config.CORE_DBPASSWORD)
self.collector_namemap = {}
def __init__(self, mod_idendesc, get_link_fn):
Notice.db = AsyncDB(config.CORE_DBNAME, config.CORE_DBUSER,
config.CORE_DBPASSWORD)
Notice._idendesc = mod_idendesc
self.get_link = get_link_fn
Proxy.instance.register_call('core/notice/', 'list_notice',
self.list_notice)
Proxy.instance.register_call('core/notice/', 'read_notice',
self.read_notice)
Proxy.instance.register_call('core/notice/', 'del_notice',
self.del_notice)
Proxy.instance.register_call('core/notice/', 'get_unseen_count',
self.get_unseen_count)
def __init__(self, mod_idendesc, get_link_fn):
TestdataMg.db = AsyncDB(config.CORE_DBNAME, config.CORE_DBUSER,
config.CORE_DBPASSWORD)
TestdataMg._idendesc = mod_idendesc
self.get_link = get_link_fn
Proxy.instance.register_call('core/testdata/', 'add_testdata',
self.add_testdata)
Proxy.instance.register_call('core/testdata/', 'update_testdata',
self.update_testdata)
Proxy.instance.register_call('core/testdata/', 'get_testdata',
self.get_testdata)
Proxy.instance.register_call('core/testdata/', 'del_testdata',
self.del_testdata)
def __init__(self, mod_idendesc, get_link_fn, proid):
self._proid = proid
self._idendesc = mod_idendesc
self.get_link = get_link_fn
self._proinfo = mod.ProblemMg.get_problem_info_by_proid(self._proid)
self._accessid = mod.ProblemMg.get_accessid_by_proid(self._proid)
self.db = AsyncDB(config.MOD_DBNAME, config.MOD_DBUSER,
config.MOD_DBPASSWORD)
self._reg_path = 'pro/' + str(self._proid) + '/'
Proxy.instance.register_call(
self._reg_path, 'view', self.view)
Proxy.instance.register_call(
self._reg_path, 'add_mode', self.add_mode)
Proxy.instance.register_call(
self._reg_path, 'del_mode', self.del_mode)
Proxy.instance.register_call(
self._reg_path, 'set_mode', self.set_mode)
Proxy.instance.register_call(
self._reg_path, 'get_mode', self.get_mode)
Proxy.instance.register_call(
self._reg_path, 'list_mode', self.list_mode)
Proxy.instance.register_call(
self._reg_path, 'add_testmode', self.add_testmode)
Proxy.instance.register_call(
self._reg_path, 'del_testmode', self.del_testmode)
Proxy.instance.register_call(
self._reg_path, 'set_testmode', self.set_testmode)
Proxy.instance.register_call(
self._reg_path, 'get_testmode', self.get_testmode)
Proxy.instance.register_call(
self._reg_path, 'list_testmode', self.list_testmode)
Proxy.instance.register_call(
self._reg_path, 'create_testdata', self.create_testdata)
Proxy.instance.register_call(
self._reg_path, 'delete_testdata', self.delete_testdata)
Proxy.instance.register_call(
self._reg_path, 'get_testdata', self.get_testdata)
Proxy.instance.register_call(
self._reg_path, 'list_testdata', self.list_testdata)
Proxy.instance.register_call(
self._reg_path, 'set_testdata', self.set_testdata)
Proxy.instance.register_call(
self._reg_path, 'set_testmode_testdata', self.set_testdata)
Proxy.instance.register_call(
self._reg_path, 'get_testmode_testdata', self.get_testdata)
def delete_problem_data(proid):
db = AsyncDB(config.MOD_DBNAME, config.MOD_DBUSER,
config.MOD_DBPASSWORD)
cur = db.cursor()
sqlstr = ('DELETE FROM "PMOD_TEST_MODE" WHERE "proid" = %s;')
sqlarr = (proid, )
cur.execute(sqlstr, sqlarr)
sqlstr = ('DELETE FROM "PMOD_TEST_TESTMODE" WHERE "proid" = %s;')
sqlarr = (proid, )
cur.execute(sqlstr, sqlarr)
sqlstr = ('DELETE FROM "PMOD_TEST_TESTDATA" WHERE "proid" = %s;')
sqlarr = (proid, )
cur.execute(sqlstr, sqlarr)
def __init__(self, mod_idendesc, get_link_fn, sqid):
self._sqid = sqid
self._idendesc = mod_idendesc
self.get_link = get_link_fn
self._accessid = mod.SquareMg.get_accessid_by_sqid(self._sqid)
self.db = AsyncDB(config.MOD_DBNAME, config.MOD_DBUSER,
config.MOD_DBPASSWORD)
self._reg_path = 'sq/' + str(self._sqid) + '/'
Proxy.instance.register_call(self._reg_path, 'list_jurank',
self.list_jurank)
Proxy.instance.register_call(self._reg_path, 'update_result',
self.update_result)
def __init__(self, mod_idendesc, get_link_fn):
Mail.db = AsyncDB(config.CORE_DBNAME, config.CORE_DBUSER,
config.CORE_DBPASSWORD)
Mail._idendesc = mod_idendesc
self.get_link = get_link_fn
Proxy.instance.register_call(
'core/mail/', 'send_mail', self.send_mail)
Proxy.instance.register_call(
'core/mail/', 'recv_mail', self.recv_mail)
Proxy.instance.register_call(
'core/mail/', 'list_mail', self.list_mail)
Proxy.instance.register_call(
'core/mail/', 'del_mail', self.del_mail)
Proxy.instance.register_call(
'core/mail/', 'get_mail_count', self.get_mail_count)
def __init__(self, mod_idendesc, get_link_fn):
UserMg.db = AsyncDB(config.CORE_DBNAME, config.CORE_DBUSER,
config.CORE_DBPASSWORD)
UserMg._idendesc = mod_idendesc
self.get_link = get_link_fn
Proxy.instance.register_call(
'core/user/', 'register', self.register)
Proxy.instance.register_call(
'core/user/', 'login', self.login)
Proxy.instance.register_call(
'core/user/', 'cookie_login', self.cookie_login)
Proxy.instance.register_call(
'core/user/', 'get_user_info', self.get_user_info)
Proxy.instance.register_call(
'core/user/', 'set_user_info', self.set_user_info)
Proxy.instance.register_call(
'core/user/', 'change_user_password', self.change_user_password)
Proxy.instance.register_call(
'core/user/', 'list_auth', self.list_auth)
def __init__(self, mod_idendesc, get_link_fn):
ProblemMg.db = AsyncDB(config.CORE_DBNAME, config.CORE_DBUSER,
config.CORE_DBPASSWORD)
ProblemMg._idendesc = mod_idendesc
self.get_link = get_link_fn
self._pmod_list = {}
Proxy.instance.register_filter('pro/', self.pmod_filter)
Proxy.instance.register_call('core/problem/', 'create_problem',
self.create_problem)
Proxy.instance.register_call('core/problem/', 'delete_problem',
self.delete_problem)
Proxy.instance.register_call('core/problem/', 'set_problem',
self.imc_set_problem)
Proxy.instance.register_call('core/problem/', 'list_problem',
self.list_problem)
Proxy.instance.register_call('core/problem/', 'get_problem_info',
self.get_problem_info)
Proxy.instance.register_call('core/problem/', 'list_pmod',
self.list_pmod)
loop = asyncio.get_event_loop()
asyncio.set_event_loop(loop)
loop.set_debug(True)
import iso8601
logging.basicConfig(level=logging.INFO,
format="%(name)s - %(levelname)s - %(message)s")
logger = logging.getLogger(__name__)
from asyncdb import AsyncDB, AsyncPool
from asyncdb.exceptions import NoDataFound, ProviderError
from asyncdb.providers.rethink import rethink
params = {"host": "localhost", "port": "28015", "db": "troc"}
rt = AsyncDB("rethink", params=params, loop=loop)
data = [{
'inserted_at': iso8601.parse_date('2020-12-09 04:23:52.441312+0000'),
'description': 'TERRE HAUTE-WM - #4235',
'company_id': 1,
'territory_id': 2.0,
'territory_name': '2-Midwest',
'region_name': 'William Pipkin',
'district_id': 235.0,
'district_name': '235-IN/IL Border',
'market_id': 2355.0,
'market_name': 'IN/IL Border-2355',
'store_id': 4235.0,
'store_name': 'TERRE HAUTE-WM - #4235',
'num_stores': 1,
async def conn(event_loop):
db = AsyncDB('pg', dsn=asyncpg_url, loop=event_loop)
await db.connection()
yield db
await db.close()
async def test_pool_by_params(driver, event_loop):
db = AsyncDB(driver, params=params, loop=event_loop)
assert db.is_connected() is False
async def conn(event_loop):
db = AsyncDB(DRIVER, params=params, loop=event_loop)
await db.connection()
yield db
await db.close()
"host": "localhost",
"port": "3306",
"database": "test",
"DEBUG": True,
}
# With mysqlPool
pool = mysqlPool(loop=loop, params=params)
loop.run_until_complete(pool.connect())
db = loop.run_until_complete(pool.acquire())
conn = db.get_connection()
loop.run_until_complete(pool.release())
pool.terminate()
# With AsyncDB
pool = AsyncDB("mysql", loop=loop, params=params)
conn = loop.run_until_complete(pool.connection())
cursor = loop.run_until_complete(pool.cursor())
result, error = loop.run_until_complete(pool.execute("TRUNCATE TABLE color"))
print("-- execute", result)
data = [
("Red", "#ff0000"),
("Green", "#00ff00"),
("Blue", "#0000ff"),
("Cyan", "#00ffff"),
("Magenta", "#ff00ff"),
("Yellow", "#ffff00"),
("Black", "#000000"),
("White", "#ffffff"),
("SVO", "Moscow", "Russia"),
]
airports = "INSERT INTO airports VALUES(?, ?, ?)"
await conn.executemany(airports, data)
a_country = "United States"
a_city = "Moscow"
query = "SELECT * FROM airports WHERE country=? OR city=?"
async with await conn.fetch(query, (a_country, a_city)) as result:
async for row in result:
print(row)
# using prepare
print('Using Cursor Objects: ')
b_country = 'France'
b_city = 'London'
async with conn.cursor(query, (b_country, b_city)) as cursor:
print("using iterator: ")
async for row in cursor:
print(row)
# its an iterable
print("Using Context Manager: ")
async with cursor:
print(await cursor.fetchall())
# this returns a cursor based object
if __name__ == "__main__":
loop = asyncio.get_event_loop()
loop.set_exception_handler(default_exception_handler)
driver = AsyncDB("sqlite", params={"database": ":memory:"}, loop=loop)
asyncio.run(connect(driver))
