def _pg_create_db(cfg, eng, ident):
with eng.connect().execution_options(
isolation_level="AUTOCOMMIT") as conn:
try:
_pg_drop_db(cfg, conn, ident)
except Exception:
pass
currentdb = conn.scalar("select current_database()")
for attempt in range(3):
try:
conn.execute(
"CREATE DATABASE %s TEMPLATE %s" % (ident, currentdb))
except exc.OperationalError as err:
if attempt != 2 and "accessed by other users" in str(err):
time.sleep(.2)
continue
else:
raise
else:
break
python类OperationalError()的实例源码
def _pg_create_db(cfg, eng, ident):
with eng.connect().execution_options(
isolation_level="AUTOCOMMIT") as conn:
try:
_pg_drop_db(cfg, conn, ident)
except Exception:
pass
currentdb = conn.scalar("select current_database()")
for attempt in range(3):
try:
conn.execute(
"CREATE DATABASE %s TEMPLATE %s" % (ident, currentdb))
except exc.OperationalError as err:
if attempt != 2 and "accessed by other users" in str(err):
time.sleep(.2)
continue
else:
raise
else:
break
def _pg_create_db(cfg, eng, ident):
with eng.connect().execution_options(
isolation_level="AUTOCOMMIT") as conn:
try:
_pg_drop_db(cfg, conn, ident)
except Exception:
pass
currentdb = conn.scalar("select current_database()")
for attempt in range(3):
try:
conn.execute(
"CREATE DATABASE %s TEMPLATE %s" % (ident, currentdb))
except exc.OperationalError as err:
if attempt != 2 and "accessed by other users" in str(err):
time.sleep(.2)
continue
else:
raise
else:
break
def _pg_create_db(cfg, eng, ident):
with eng.connect().execution_options(
isolation_level="AUTOCOMMIT") as conn:
try:
_pg_drop_db(cfg, conn, ident)
except Exception:
pass
currentdb = conn.scalar("select current_database()")
for attempt in range(3):
try:
conn.execute(
"CREATE DATABASE %s TEMPLATE %s" % (ident, currentdb))
except exc.OperationalError as err:
if attempt != 2 and "accessed by other users" in str(err):
time.sleep(.2)
continue
else:
raise
else:
break
def patch_resource(self, obj):
if self.has_change_permission(obj) and obj:
obj, errors = self.schema(exclude=self.exclude_related_resource).load(request.json, instance=obj,
partial=True)
if errors:
db.session.rollback()
return {'error': True, 'message': str(errors)}, 400
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
raise SQLIntegrityError(data={}, message='Integrity Error', operation='Adding Resource',
status=400)
except OperationalError:
db.session.rollback()
raise SQlOperationalError(data={}, message='Operational Error', operation='Adding Resource',
status=400)
return {'success': True, 'message': 'obj updated successfully',
'data': self.schema(exclude=tuple(self.obj_exclude), only=tuple(self.obj_only))
.dump(obj).data}, 200
return {'error': True, 'message': 'Forbidden Permission Denied To Change Resource'}, 403
def save_resource(self):
data = request.json if isinstance(request.json, list) else [request.json]
objects, errors = self.schema().load(data, session=db.session, many=True)
if errors:
db.session.rollback()
return {'error': True, 'message': str(errors)}, 400
if self.has_add_permission(objects):
db.session.add_all(objects)
else:
db.session.rollback()
return {'error': True, 'message': 'Forbidden Permission Denied To Add Resource'}, 403
try:
db.session.commit()
except IntegrityError as e:
db.session.rollback()
print(e)
raise SQLIntegrityError(data=data, message='Integrity Error', operation='Adding Resource', status=400)
except OperationalError:
db.session.rollback()
raise SQlOperationalError(data=data, message='Operational Error', operation='Adding Resource', status=400)
return {'success': True, 'message': 'Resource added successfully',
'data': self.schema(exclude=tuple(self.obj_exclude), only=tuple(self.obj_only))
.dump(objects, many=True).data}, 201
def add_relation(self, data):
obj, errors = self.schema().load(data, session=db.session)
if errors:
raise CustomException(data=data, message=str(errors), operation='adding relation')
if self.has_add_permission(obj, data):
db.session.add(obj)
try:
db.session.commit()
except IntegrityError as e:
raise SQLIntegrityError(data=data, message=str(e), operation='adding relation', status=400)
except OperationalError as e:
raise SQLIntegrityError(data=data, message=str(e), operation='adding relation', status=400)
else:
raise RequestNotAllowed(data=data, message='Object not Found', operation='adding relation',
status=401)
def update_relation(self, data):
obj = self.model.query.get(data['id'])
if obj:
obj, errors = self.schema().load(data, instance=obj)
if errors:
raise CustomException(data=data, message=str(errors), operation='updating relation')
if self.has_change_permission(obj, data):
raise CustomException(data=data, message='Permission Denied', operation='adding relation')
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
raise SQLIntegrityError(data=data, message='Integrity Error', operation='Adding Resource', status=400)
except OperationalError:
db.session.rollback()
raise SQlOperationalError(data=data, message='Operational Error', operation='Adding Resource',
status=400)
else:
raise RequestNotAllowed(data=data, message='Object not Found', operation='deleting relation',
status=401)
else:
raise ResourceNotFound(data=data, message='Object not Found', operation='Updating relation', status=404)
def _pg_create_db(cfg, eng, ident):
with eng.connect().execution_options(
isolation_level="AUTOCOMMIT") as conn:
try:
_pg_drop_db(cfg, conn, ident)
except Exception:
pass
currentdb = conn.scalar("select current_database()")
for attempt in range(3):
try:
conn.execute(
"CREATE DATABASE %s TEMPLATE %s" % (ident, currentdb))
except exc.OperationalError as err:
if attempt != 2 and "accessed by other users" in str(err):
time.sleep(.2)
continue
else:
raise
else:
break
def __init__(self, url, **kwargs):
"""Initialises a database connection to a given database url.
Parameters
----------
url : url
A sqlalchemy url to connect to a specified database.
kwargs : dict
Additional keys will be passed at create_engine.
"""
super().__init__()
self.url = url
self.log.info("Creating session to db: {}".format(self.url))
self.engine = create_engine(self.url, **kwargs)
try:
self.session_class = sessionmaker(bind=self.engine)
except OperationalError:
self.log.exception(
"Failed to connect db session: {}".format(self.url)
)
raise
def chianti_ions_table(self):
if self._chianti_ions_table is None:
chianti_ions_table_name = "ChiantiIonList" + str(hash(frozenset(self.chianti_ions)))
try:
chianti_ions_table = Base.metadata.tables[convert_camel2snake(chianti_ions_table_name)]
except KeyError:
chianti_ions_table = type(chianti_ions_table_name, (Base, IonListMixin), dict()).__table__
try:
# To create the temporary table use the session's current transaction-bound connection
chianti_ions_table.create(self.session.connection())
except OperationalError: # Raised if the table already exists
pass
else:
# Insert values from `ions` into the table
if self.chianti_ions:
self.session.execute(chianti_ions_table.insert(),
[{"atomic_number": atomic_number, "ion_charge": ion_charge}
for atomic_number, ion_charge in self.chianti_ions])
self._chianti_ions_table = chianti_ions_table
return self._chianti_ions_table
def _pg_create_db(cfg, eng, ident):
with eng.connect().execution_options(
isolation_level="AUTOCOMMIT") as conn:
try:
_pg_drop_db(cfg, conn, ident)
except Exception:
pass
currentdb = conn.scalar("select current_database()")
for attempt in range(3):
try:
conn.execute(
"CREATE DATABASE %s TEMPLATE %s" % (ident, currentdb))
except exc.OperationalError as err:
if attempt != 2 and "accessed by other users" in str(err):
time.sleep(.2)
continue
else:
raise
else:
break
def initialize(self, parameters):
super(SQLDumper, self).initialize(parameters)
table_to_resource = parameters['tables']
engine = parameters.get('engine', 'env://DPP_DB_ENGINE')
if engine.startswith('env://'):
env_var = engine[6:]
engine = os.environ.get(env_var)
assert engine is not None, \
"Couldn't connect to DB - " \
"Please set your '%s' environment variable" % env_var
self.engine = create_engine(engine)
try:
self.engine.connect()
except OperationalError:
logging.exception('Failed to connect to database %s', engine)
raise
for k, v in table_to_resource.items():
v['table-name'] = k
self.converted_resources = \
dict((v['resource-name'], v) for v in table_to_resource.values())
self.updated_column = parameters.get("updated_column")
self.updated_id_column = parameters.get("updated_id_column")
def _pg_create_db(cfg, eng, ident):
with eng.connect().execution_options(
isolation_level="AUTOCOMMIT") as conn:
try:
_pg_drop_db(cfg, conn, ident)
except Exception:
pass
currentdb = conn.scalar("select current_database()")
for attempt in range(3):
try:
conn.execute(
"CREATE DATABASE %s TEMPLATE %s" % (ident, currentdb))
except exc.OperationalError as err:
if attempt != 2 and "accessed by other users" in str(err):
time.sleep(.2)
continue
else:
raise
else:
break
def _pg_create_db(cfg, eng, ident):
with eng.connect().execution_options(
isolation_level="AUTOCOMMIT") as conn:
try:
_pg_drop_db(cfg, conn, ident)
except Exception:
pass
currentdb = conn.scalar("select current_database()")
for attempt in range(3):
try:
conn.execute(
"CREATE DATABASE %s TEMPLATE %s" % (ident, currentdb))
except exc.OperationalError as err:
if attempt != 2 and "accessed by other users" in str(err):
time.sleep(.2)
continue
else:
raise
else:
break
def _pg_create_db(cfg, eng, ident):
with eng.connect().execution_options(
isolation_level="AUTOCOMMIT") as conn:
try:
_pg_drop_db(cfg, conn, ident)
except Exception:
pass
currentdb = conn.scalar("select current_database()")
for attempt in range(3):
try:
conn.execute(
"CREATE DATABASE %s TEMPLATE %s" % (ident, currentdb))
except exc.OperationalError as err:
if attempt != 2 and "accessed by other users" in str(err):
time.sleep(.2)
continue
else:
raise
else:
break
def _pg_create_db(cfg, eng, ident):
with eng.connect().execution_options(
isolation_level="AUTOCOMMIT") as conn:
try:
_pg_drop_db(cfg, conn, ident)
except Exception:
pass
currentdb = conn.scalar("select current_database()")
for attempt in range(3):
try:
conn.execute(
"CREATE DATABASE %s TEMPLATE %s" % (ident, currentdb))
except exc.OperationalError as err:
if attempt != 2 and "accessed by other users" in str(err):
time.sleep(.2)
continue
else:
raise
else:
break
def _pg_create_db(cfg, eng, ident):
with eng.connect().execution_options(
isolation_level="AUTOCOMMIT") as conn:
try:
_pg_drop_db(cfg, conn, ident)
except Exception:
pass
currentdb = conn.scalar("select current_database()")
for attempt in range(3):
try:
conn.execute(
"CREATE DATABASE %s TEMPLATE %s" % (ident, currentdb))
except exc.OperationalError as err:
if attempt != 2 and "accessed by other users" in str(err):
time.sleep(.2)
continue
else:
raise
else:
break
def _pg_create_db(cfg, eng, ident):
with eng.connect().execution_options(
isolation_level="AUTOCOMMIT") as conn:
try:
_pg_drop_db(cfg, conn, ident)
except Exception:
pass
currentdb = conn.scalar("select current_database()")
for attempt in range(3):
try:
conn.execute(
"CREATE DATABASE %s TEMPLATE %s" % (ident, currentdb))
except exc.OperationalError as err:
if attempt != 2 and "accessed by other users" in str(err):
time.sleep(.2)
continue
else:
raise
else:
break
