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)