def __setitem__(self, key, value):
if not isinstance(key, str):
raise DBException('Key should be str')
if not isinstance(value, dict):
raise DBException('Value should be dict')
k = key.encode('utf-8')
v = json.dumps(value).encode('utf-8')
self.__db.Put(k, v)
def writebatch(self, values):
batch = leveldb.WriteBatch()
for key, value in values.items():
if not isinstance(key, str):
raise DBException('Key should be str')
if not isinstance(value, dict):
raise DBException('Value should be dict')
batch.Put(key.encode('utf-8'), json.dumps(value).encode('utf-8'))
self.__db.Write(batch)
def set_user_src_city(self, user_id, city):
try:
with self.connection:
self.cursor.execute("INSERT OR REPLACE INTO user_city (user_id, city) VALUES (?, ?)", (user_id, city))
except Exception as ex:
logging.error(ex)
raise DBException(ex)
def update(self):
try:
db.session.commit()
except:
db.session.rollback()
raise DBException(f"Failed to update Volunteer {self.name}")
finally:
db.session.close()
def __init__(self, dbroot=None, create_if_missing=False):
self._dbroot = dbroot
if dbroot is not None and not os.path.exists(self._dbroot):
if create_if_missing:
logger.info('The DB root dir {} is not exists, auto created.'.format(self._dbroot))
os.makedirs(self._dbroot)
else:
raise DBException('The DB folder')
def insert(self):
try:
db.session.add(self)
db.session.commit()
except:
db.session.rollback()
raise DBException(f"Failed to register Volunteer {self.name}")
finally:
db.session.close()
def insert(self):
try:
db.session.add(self)
db.session.commit()
except:
db.session.rollback()
raise DBException(f"Failed to create Classroom {self.description}")
finally:
db.session.close()
def get_user_src_city(self, user_id):
try:
with self.connection:
result = self.cursor.execute('SELECT city FROM user_city WHERE user_id = ?', (user_id,)).fetchall()
if len(result) > 0:
return result[0][0]
except Exception as ex:
logging.error(ex)
raise DBException(ex)
def delete(self):
try:
db.session.delete(self)
db.session.commit()
except:
db.session.rollback()
raise DBException(f"Failed to remove Classroom {self.name}")
finally:
db.session.close()
def __init__(self, database=None):
try:
if database:
self.connection = sqlite3.connect(database, check_same_thread=False)
else:
self.connection = sqlite3.connect(':memory:', check_same_thread=False)
self.cursor = self.connection.cursor()
self.create_user_city_table()
except Exception as ex:
logging.error(ex)
raise DBException(ex)
def __init__(self, name, dbroot=None, data_type=None):
logger.info('Init DB table {}(type={}) at {}'.format(name, data_type, dbroot))
if dbroot is None:
logger.error('Can not create Table: database was not init with root dir')
raise DBException('Can not create Table: database was not init with root dir')
self._path = os.path.join(dbroot, name)
if data_type == 'dict':
self._table = LevelDBJsonDict(self._path)
elif data_type == 'bytes':
self._table = LevelDBDict(self._path)
else:
self._table = LevelDBDict(self._path)
def __cursor_execute(self, query: str, params: tuple,
method: str) -> Union[None, str]:
"""Executes commands for cursor.
:param query: sql query
:param params: parameters of query
:param method: execute method of cursor (execute, mogrify, callproc...)
:return: different methods returns different results
(execute - returns None, mogrify - returns query string ...)
"""
try:
return getattr(self.__cur, method)(query, params)
except Error as e:
raise DBException(e)
def __cursor_retrieve(self) -> None:
"""Retrieves data from database,
used after executing query as a callback,
stores result in self.__result attribute
:return:
"""
try:
if self.__retrieve_method is None:
self.__result = self.__cur.rowcount
else:
self.__result = getattr(self.__cur, self.__retrieve_method)()
self.__event.set()
except Error as e:
raise DBException(e)
def __check(self) -> None:
"""Checks file descriptor state.
:return:
"""
state = self.__conn.poll()
if state == POLL_OK:
self.__connected = True
self.__call()
elif state == POLL_WRITE:
self.__loop.add_writer(self.__conn.fileno(), self.__call)
elif state == POLL_READ:
self.__loop.add_reader(self.__conn.fileno(), self.__call)
else:
raise DBException('poll() returned %s' % state)
def close(self):
try:
self.connection.close()
except Exception as ex:
logging.error(ex)
raise DBException(ex)
def __delitem__(self, key):
if not isinstance(key, str):
raise DBException('Key should be str')
k = key.encode('utf-8')
self.__db.Delete(k)
def __getitem__(self, key):
if not isinstance(key, str):
raise DBException('Key should be str')
k = key.encode('utf-8')
return json.loads(self.__db.Get(k).decode('utf-8'))
def __delitem__(self, key):
if type(key) not in [str, bytes]:
raise DBException('Key should be str or bytes')
k = key if isinstance(key, bytes) else key.encode('utf-8')
self.__db.Delete(k)
