def delete(session: Session, sensor_type: str):
try:
sensor = session.query(SensorTypes).filter_by(
sensor_type=sensor_type).first()
session.delete(sensor)
except NoResultFound as ex:
"""Sensor type does not exists. No need to nothing"""
def handle_user_audio_tracks(
session: Session,
user_id: int,
music_choices: Optional[List[str]],
sfx_choice: Optional[str],
):
"""[summary]
Args:
session (Session): the database.
user_id (int): current users' id.
music_choices (Optional[List[str]]):
a list of music tracks if music is enabled, None otherwise.
sfx_choice (Optional[str]): choice for sound effect.
"""
user_audio_tracks = session.query(UserAudioTracks).filter_by(
user_id=user_id, )
if user_audio_tracks:
for record in user_audio_tracks:
session.delete(record)
session.commit()
if music_choices:
for track in music_choices:
create_new_user_audio_record(session, track, user_id)
if sfx_choice:
create_new_user_audio_record(session, sfx_choice, user_id)
def deleteParameter(self, session: Session, name: str) -> None:
"""
Delete parameter from the db.
Returns:
None
Throws:
ParameterNotFound
DbError
"""
try:
p = self._globalParametersDbHandler.getParameter(session, name)
self._logger.debug('Deleting parameter [%s]' % (name))
session.delete(p)
session.commit()
self._logger.info('Deleted parameter [%s]' % name)
except TortugaException:
session.rollback()
raise
except Exception as ex:
session.rollback()
self._logger.exception(str(ex))
raise
def delete_items(session: Session, url_hashes: List[str]) -> List[str]:
deleted_items = []
for obj in (session.query(ScraperItemModel).filter(
ScraperItemModel.url_hash.in_(url_hashes)).all()):
deleted_items.append(obj.url_hash)
session.delete(obj)
return deleted_items
def update_sources(remote_sources: List[SDKSource],
local_sources: List[Source], session: Session,
data_dir: str) -> None:
"""
Given collections of remote sources, the current local sources and a
session to the local database, ensure the state of the local database
matches that of the remote sources:
* Existing items are updated in the local database.
* New items are created in the local database.
* Local items not returned in the remote sources are deleted from the
local database.
"""
local_sources_by_uuid = {s.uuid: s for s in local_sources}
for source in remote_sources:
if source.uuid in local_sources_by_uuid:
# Update an existing record.
local_source = local_sources_by_uuid[source.uuid]
lazy_setattr(local_source, "journalist_designation",
source.journalist_designation)
lazy_setattr(local_source, "is_flagged", source.is_flagged)
lazy_setattr(local_source, "interaction_count",
source.interaction_count)
lazy_setattr(local_source, "document_count",
source.number_of_documents)
lazy_setattr(local_source, "is_starred", source.is_starred)
lazy_setattr(local_source, "last_updated",
parse(source.last_updated))
lazy_setattr(local_source, "public_key", source.key['public'])
# Removing the UUID from local_sources_by_uuid ensures
# this record won't be deleted at the end of this
# function.
del local_sources_by_uuid[source.uuid]
logger.debug('Updated source {}'.format(source.uuid))
else:
# A new source to be added to the database.
ns = Source(
uuid=source.uuid,
journalist_designation=source.journalist_designation,
is_flagged=source.is_flagged,
interaction_count=source.interaction_count,
is_starred=source.is_starred,
last_updated=parse(source.last_updated),
document_count=source.number_of_documents,
public_key=source.key['public'],
fingerprint=source.key['fingerprint'],
)
session.add(ns)
logger.debug('Added new source {}'.format(source.uuid))
# The uuids remaining in local_uuids do not exist on the remote server, so
# delete the related records.
for deleted_source in local_sources_by_uuid.values():
delete_source_collection(deleted_source.journalist_filename, data_dir)
session.delete(deleted_source)
logger.debug('Deleted source {}'.format(deleted_source.uuid))
session.commit()
def clean(cls, model: str, pk: int, *args, session: Session,
base: Type[DBT], **kwargs) -> DBRes:
obj = session.query(base).get(pk)
if isinstance(obj, Connector):
back = obj.as_dict()
source, target = obj.source, obj.target
session.delete(obj)
session.commit()
cls._clean(source, session, Connection)
cls._clean(target, session, Connection)
session.add(Connector(**back))
else:
if isinstance(obj, Connection):
s_names = [
x[0] for x in session.query(Connector.name).join(
Connector.source).filter(Connection.id == pk).all()
]
t_names = [
x[0] for x in session.query(Connector.name).join(
Connector.target).filter(Connection.id == pk).all()
]
msg = "please clean connector source: {} target: {}".format(
','.join(s_names), ','.join(t_names))
if s_names or t_names:
return DBRes.api_error(msg)
cls._clean(obj, session, base)
return DBRes()
def delete(self, session: Session) -> None:
"""
Delete the Statification
:param session: the database session
"""
session.delete(self)
session.commit()
def test_cascade_delete_table(app_context: None, session: Session) -> None:
"""
Test that deleting ``Table`` also deletes its columns.
"""
from superset.columns.models import Column
from superset.models.core import Database
from superset.tables.models import Table
engine = session.get_bind()
Table.metadata.create_all(engine) # pylint: disable=no-member
table = Table(
name="my_table",
schema="my_schema",
catalog="my_catalog",
database=Database(database_name="my_database",
sqlalchemy_uri="sqlite://"),
columns=[
Column(name="longitude", expression="longitude"),
Column(name="latitude", expression="latitude"),
],
)
session.add(table)
session.flush()
columns = session.query(Column).all()
assert len(columns) == 2
session.delete(table)
session.flush()
# test that columns were deleted
columns = session.query(Column).all()
assert len(columns) == 0
def test_delete_sqlatable(app_context: None, session: Session) -> None:
"""
Test that deleting a ``SqlaTable`` also deletes the corresponding ``Dataset``.
"""
from superset.columns.models import Column
from superset.connectors.sqla.models import SqlaTable, TableColumn
from superset.datasets.models import Dataset
from superset.models.core import Database
from superset.tables.models import Table
engine = session.get_bind()
Dataset.metadata.create_all(engine) # pylint: disable=no-member
columns = [
TableColumn(column_name="ds", is_dttm=1, type="TIMESTAMP"),
]
sqla_table = SqlaTable(
table_name="old_dataset",
columns=columns,
metrics=[],
database=Database(database_name="my_database",
sqlalchemy_uri="sqlite://"),
)
session.add(sqla_table)
session.flush()
datasets = session.query(Dataset).all()
assert len(datasets) == 1
session.delete(sqla_table)
session.flush()
# test that dataset was also deleted
datasets = session.query(Dataset).all()
assert len(datasets) == 0
def upgrade():
from sqlalchemy.orm.session import Session
session = Session(bind=op.get_bind())
# Find duplicates
for vcs in session.query(Vcs).group_by(Vcs.repository_id, Vcs.revision).having(func.count(Vcs.id) > 1).all():
print(vcs)
# Find all vcs entries with this duplication
dupes = session.query(Vcs).filter(Vcs.repository_id == vcs.repository_id).filter(Vcs.revision == vcs.revision).all()
# Keep the first and remove the others - thus we need to update references to others to the first
for update in dupes[1:]:
for af in session.query(Artifakt).filter(Artifakt.vcs_id == update.id).all():
print("Updating artifakt {} to point to vcs {}".format(af.sha1, dupes[0].id))
af.vcs_id = dupes[0].id
print("Deleting vcs {}".format(update.id))
session.delete(update)
session.commit()
if session.bind.dialect.name == "sqlite":
session.execute("PRAGMA foreign_keys = OFF")
elif session.bind.dialect.name == "mysql":
session.execute("SET foreign_key_checks = 0")
else:
raise NotImplemented
with op.batch_alter_table('vcs', schema=None) as batch_op:
batch_op.create_unique_constraint('rr', ['repository_id', 'revision'])
if session.bind.dialect.name == "sqlite":
session.execute("PRAGMA foreign_keys = ON")
elif session.bind.dialect.name == "mysql":
session.execute("SET foreign_key_checks = 1")
def delete_cookie(session: Session, token) -> bool:
c = session.query(Cookie).filter(Cookie.token == token).first()
if c is None:
return False
session.delete(c)
session.commit()
return True
def remove_quote_handler(db_session: DbSession, bot: telegram.Bot,
update: telegram.Update):
"""Adds a message as a user quote"""
_, group, group_user = _record_presence(db_session, bot, update)
if not update.message.reply_to_message:
update.message.reply_text(
"Command must be sent as a reply to a message", quote=True)
user_repo = ChatUserRepository(db_session)
group_repo = ChatGroupRepository(db_session)
quote_repo = QuoteRepository(db_session)
reply = update.message.reply_to_message
quoted_user = user_repo.find_or_create_by_id(reply.from_user.id)
quoted_group_user = group_repo.record_membership(group, quoted_user)
quote = quote_repo.find_quote(quoted_group_user, str(reply.message_id))
if not quote:
update.message.reply_text("Message is not a registered quote",
quote=True)
return
if group_user.id != quoted_group_user.id:
update.message.reply_text(
"Only the quoted user can remove his own quote", quote=True)
return
db_session.delete(quote)
update.message.reply_text("Quote removed from database", quote=True)
def __delete_nodes(self, session: Session, kitmgr: KitActionsManager,
nodes: List[NodeModel]) -> None:
"""
:raises DeleteNodeFailed:
"""
hwprofile_nodes = self.__pre_delete_nodes(kitmgr, nodes)
# commit node state changes to database
session.commit()
for hwprofile, node_data_dicts in hwprofile_nodes.items():
# build list of NodeModels
node_objs: List[NodeModel] = [
node_data_dict['node'] for node_data_dict in node_data_dicts
]
# Call resource adapter deleteNode() entry point
self.__get_resource_adapter(session,
hwprofile).deleteNode(node_objs)
# Perform delete node action for each node in hwprofile
for node_data_dict in node_data_dicts:
# get JSON object for node record
node_dict = NodeSchema(
only=('hardwareprofile', 'softwareprofile', 'name',
'state'),
exclude=('softwareprofile.metadata', )).dump(
node_data_dict['node']).data
# Delete the Node
self._logger.debug('Deleting node [%s]', node_dict['name'])
#
# Fire node state change events
#
NodeStateChanged.fire(
node=node_dict,
previous_state=node_data_dict['previous_state'])
session.delete(node_data_dict['node'])
# Commit the actual deletion of this node to the DB. This is required
# as the post_delete hooks may use a different DB session and we have
# already commited some changes for this node.
session.commit()
self.__post_delete(kitmgr, node_dict)
self._logger.info('Node [%s] deleted', node_dict['name'])
# clean up add host session cache
self._addHostManager.delete_sessions(
set([
node.addHostSession for node in node_objs
if node.addHostSession
]))
self.__scheduleUpdate()
def test_delete_none_sceamer_chance_default(self):
session = Session(connection)
webm = session.query(WEBM).get('q')
assert webm
session.delete(webm)
session.commit()
webm = session.query(WEBM).get('q')
assert webm is None
def delete_statification(session: Session, i_id: int) -> None:
"""
Delete the statification that have the given id
:param session: the database session
:param i_id: the id of the statification to be deleted
"""
session.delete(Statification.get_from_statification_id(session, i_id))
session.commit()
def delete(self, synchronize_session='evaluate'):
from rome.core.session.session import Session
temporary_session = Session()
objects = self.matching_objects(filter_deleted=False)
for obj in objects:
temporary_session.delete(obj)
temporary_session.flush()
return len(objects)
def delete(self):
if not self.id:
session = Session()
else:
session = Session.object_session(self)
session.delete(self)
session.commit()
def delete(self, session: Session, primary_key_value) -> dict:
result = session.query(
self.sql_model).filter_by(**{
self.primary_key: primary_key_value
}).one()
session.delete(result)
session.commit()
def delete(cls, model: str, pk: int, *args, session: Session,
base: Type[Base], **kwargs) -> DBRes:
if settings.FSQLFLY_SAVE_MODE_DISABLE:
obj = session.query(base).get(pk)
session.delete(obj)
return DBRes(data=obj.id)
else:
return DBRes.sever_error(
'Not Support Delete when FSQLFLY_SAVE_MODE_DISABLE not set')
def upgrade():
session = Session(bind=op.get_bind())
session.add(Exchange(name=BitkubExchange.name, is_active=True, weight=15))
bx_in_th_name = "[bx.in.th](https://bx.in.th/ref/s9c3HU/)"
bx_in_th = session.query(Exchange).filter_by(name=bx_in_th_name).one()
session.query(Rate).filter_by(exchange_id=bx_in_th.id).delete()
session.delete(bx_in_th)
session.flush()
def __update_submissions(model: Union[Type[File], Type[Message]],
remote_submissions: List[SDKSubmission],
local_submissions: Union[List[Message], List[File]],
session: Session, data_dir: str) -> None:
"""
The logic for updating files and messages is effectively the same, so this function is somewhat
overloaded to allow us to do both in a DRY way.
* Existing submissions are updated in the local database.
* New submissions have an entry created in the local database.
* Local submissions not returned in the remote submissions are deleted
from the local database.
"""
local_uuids = {submission.uuid for submission in local_submissions}
for submission in remote_submissions:
if submission.uuid in local_uuids:
local_submission = [
s for s in local_submissions if s.uuid == submission.uuid
][0]
# Update files on disk to match new filename.
if (local_submission.filename != submission.filename):
rename_file(data_dir, local_submission.filename,
submission.filename)
# Update an existing record.
local_submission.filename = submission.filename
local_submission.size = submission.size
local_submission.is_read = submission.is_read
local_submission.download_url = submission.download_url
# Removing the UUID from local_uuids ensures this record won't be
# deleted at the end of this function.
local_uuids.remove(submission.uuid)
logger.debug('Updated submission {}'.format(submission.uuid))
else:
# A new submission to be added to the database.
_, source_uuid = submission.source_url.rsplit('/', 1)
source = session.query(Source).filter_by(uuid=source_uuid)[0]
ns = model(source_id=source.id,
uuid=submission.uuid,
size=submission.size,
filename=submission.filename,
download_url=submission.download_url)
session.add(ns)
logger.debug('Added new submission {}'.format(submission.uuid))
# The uuids remaining in local_uuids do not exist on the remote server, so
# delete the related records.
for deleted_submission in [
s for s in local_submissions if s.uuid in local_uuids
]:
delete_single_submission_or_reply_on_disk(deleted_submission, data_dir)
session.delete(deleted_submission)
logger.debug('Deleted submission {}'.format(deleted_submission.uuid))
session.commit()
def delete_local_source_by_uuid(session: Session, uuid: str, data_dir: str) -> None:
"""
Delete the source with the referenced UUID.
"""
source = session.query(Source).filter_by(uuid=uuid).one_or_none()
if source:
delete_source_collection(source.journalist_filename, data_dir)
session.delete(source)
session.commit()
logger.info("Deleted source with UUID {} from local database.".format(uuid))
def deleteGene(geneId):
session = Session()
try:
gene = session.query(Gene).filter(Gene.id == geneId).one()
except:
print "gene does not exist in database"
raise
session.delete(gene)
session.commit()
session.close()
def deleteModel(modelId):
session = Session()
try:
model = session.query(Model).filter(Model.id == modelId).one()
except:
print "model does not exist in database"
raise
session.delete(model)
session.commit()
session.close()
def test_get_all_notifications(db: Session) -> None:
provider = utils.create_random_provider(db)
document = utils.create_random_notification(provider)
provider_notifications = crud_notification.get_all_notifications(str(provider.id))
assert provider_notifications
assert provider_notifications[0]['id'] == document.id
assert provider_notifications[0]['recipient_id'] == str(provider.id)
db.delete(provider)
db.commit()
def test_update_notification(db: Session) -> None:
provider = utils.create_random_provider(db)
notification = utils.create_random_notification(provider)
crud_notification.update(notification.id)
update_notification = Notification.objects(id=notification.id).first()
assert update_notification
db.delete(provider)
db.commit()
Notification.delete(notification)
def deleteSoftwareProfile(self, session: Session, name: str) -> None:
"""
Delete softwareProfile from the db.
Returns:
None
Throws:
SoftwareProfileNotFound
DbError
"""
try:
# This role of this lookup is twofold. One, it validates
# the existence of the software profile to be deleted and
# second, gets the id for looking up any associated nodes
dbSwProfile = self._softwareProfilesDbHandler.\
getSoftwareProfile(session, name)
if dbSwProfile.nodes:
# The software profile cannot be removed while
# associated
# nodes exist
raise TortugaException('Unable to delete software profile with'
' associated nodes')
if dbSwProfile.isIdle:
# Ensure this software profile is not associated with
# a hardware profile
if dbSwProfile.hwprofileswithidle:
# This software profile is associated with one
# or more hardware profiles
raise TortugaException(
'Unable to delete software profile.'
' This software profile is associated'
' with one or more hardware profiles: [%s]' %
(' '.join([
hwprofile.name
for hwprofile in dbSwProfile.hwprofileswithidle
])))
# Proceed with software profile deletion
self.getLogger().debug(
'Marking software profile [%s] for deletion' % (name))
session.delete(dbSwProfile)
session.commit()
except TortugaException:
session.rollback()
raise
except Exception as ex:
session.rollback()
self.getLogger().exception('%s' % ex)
raise
def convert_sdb(
env: Environment,
sess: Session,
sdb: StoredDataBlockMetadata,
conversion_path: ConversionPath,
target_storage: Storage,
storages: Optional[List[Storage]] = None,
) -> StoredDataBlockMetadata:
if not conversion_path.conversions:
return sdb
if storages is None:
storages = env.storages
prev_sdb = sdb
next_sdb: Optional[StoredDataBlockMetadata] = None
prev_storage = sdb.storage
next_storage: Optional[Storage] = None
realized_schema = sdb.realized_schema(env, sess)
for conversion_edge in conversion_path.conversions:
conversion = conversion_edge.conversion
target_storage_format = conversion.to_storage_format
next_storage = select_storage(target_storage, storages,
target_storage_format)
logger.debug(
f"CONVERSION: {conversion.from_storage_format} -> {conversion.to_storage_format}"
)
next_sdb = StoredDataBlockMetadata( # type: ignore
id=get_datablock_id(),
data_block_id=prev_sdb.data_block_id,
data_block=prev_sdb.data_block,
data_format=target_storage_format.data_format,
storage_url=next_storage.url,
)
sess.add(next_sdb)
conversion_edge.copier.copy(
from_name=prev_sdb.get_name(),
to_name=next_sdb.get_name(),
conversion=conversion,
from_storage_api=prev_storage.get_api(),
to_storage_api=next_storage.get_api(),
schema=realized_schema,
)
if (prev_sdb.data_format.is_python_format()
and not prev_sdb.data_format.is_storable()):
# If the records obj is in python and not storable, and we just used it, then it can be reused
# TODO: Bit of a hack. Is there a central place we can do this?
# also is reusable a better name than storable?
prev_storage.get_api().remove(prev_sdb.get_name())
prev_sdb.data_block.stored_data_blocks.remove(prev_sdb)
if prev_sdb in sess.new:
sess.expunge(prev_sdb)
else:
sess.delete(prev_sdb)
prev_sdb = next_sdb
prev_storage = next_storage
return next_sdb
class VMDatabase(object):
def __init__(self, path=os.path.expanduser("~/vm.db")):
engine = create_engine('sqlite:///%s' % path, echo=False)
metadata.create_all(engine)
Session = sessionmaker(bind=engine, autoflush=True, autocommit=False)
self.session = Session()
def print_state(self):
for provider in self.getProviders():
print 'Provider:', provider.name
for base_image in provider.base_images:
print ' Base image:', base_image.name
for snapshot_image in base_image.snapshot_images:
print ' Snapshot:', snapshot_image.name, \
snapshot_image.state
for machine in base_image.machines:
print ' Machine:', machine.id, machine.name, \
machine.state, machine.state_time, machine.ip
def abort(self):
self.session.rollback()
def commit(self):
self.session.commit()
def delete(self, obj):
self.session.delete(obj)
def getProviders(self):
return self.session.query(Provider).all()
def getProvider(self, name):
return self.session.query(Provider).filter_by(name=name)[0]
def getResult(self, id):
return self.session.query(Result).filter_by(id=id)[0]
def getMachine(self, id):
return self.session.query(Machine).filter_by(id=id)[0]
def getMachineByJenkinsName(self, name):
return self.session.query(Machine).filter_by(jenkins_name=name)[0]
def getMachineForUse(self, image_name):
"""Atomically find a machine that is ready for use, and update
its state."""
image = None
for machine in self.session.query(Machine).filter(
machine_table.c.state == READY).order_by(
machine_table.c.state_time):
if machine.base_image.name == image_name:
machine.state = USED
self.commit()
return machine
raise Exception("No machine found for image %s" % image_name)
class VMDatabase(object):
def __init__(self, path=os.path.expanduser("~/vm.db")):
engine = create_engine('sqlite:///%s' % path, echo=False)
metadata.create_all(engine)
Session = sessionmaker(bind=engine, autoflush=True, autocommit=False)
self.session = Session()
def print_state(self):
for provider in self.getProviders():
print 'Provider:', provider.name
for base_image in provider.base_images:
print ' Base image:', base_image.name
for snapshot_image in base_image.snapshot_images:
print ' Snapshot:', snapshot_image.name, \
snapshot_image.state
for machine in base_image.machines:
print ' Machine:', machine.id, machine.name, \
machine.state, machine.state_time, machine.ip
def abort(self):
self.session.rollback()
def commit(self):
self.session.commit()
def delete(self, obj):
self.session.delete(obj)
def getProviders(self):
return self.session.query(Provider).all()
def getProvider(self, name):
return self.session.query(Provider).filter_by(name=name)[0]
def getResult(self, id):
return self.session.query(Result).filter_by(id=id)[0]
def getMachine(self, id):
return self.session.query(Machine).filter_by(id=id)[0]
def getMachineByJenkinsName(self, name):
return self.session.query(Machine).filter_by(jenkins_name=name)[0]
def getMachineForUse(self, image_name):
"""Atomically find a machine that is ready for use, and update
its state."""
image = None
for machine in self.session.query(Machine).filter(
machine_table.c.state == READY).order_by(
machine_table.c.state_time):
if machine.base_image.name == image_name:
machine.state = USED
self.commit()
return machine
raise Exception("No machine found for image %s" % image_name)
def process_delete_host_request(session: Session,
transaction_id: str,
nodespec: str,
force: bool = False):
try:
req = NodeRequestsDbHandler().get_by_addHostSession(
session, transaction_id)
if req is None:
# Session was deleted prior to being processed. Nothing to do...
logger.warning(
'Delete host request [%s] not found; nothing to do...',
transaction_id)
return
#
# Save this data so that we have it for firing the event below
#
evt_req_id = req.id
evt_req_request = {'name': nodespec}
ahm.update_session(transaction_id, running=True)
logger.debug('process_delete_host_request(): transaction_id=[{0}],'
' nodespec=[{1}]'.format(transaction_id, nodespec))
try:
NodeApi().deleteNode(session, nodespec, force=force)
ahm.delete_session(transaction_id)
session.delete(req)
DeleteNodeRequestComplete.fire(request_id=evt_req_id,
request=evt_req_request)
except (OperationFailed, NodeNotFound):
ahm.delete_session(transaction_id)
session.delete(req)
raise
except TortugaException as exc:
logger.exception('Exception while deleting nodes')
req.message = str(exc)
req.state = 'error'
req.last_update = datetime.datetime.utcnow()
finally:
ahm.update_session(transaction_id, running=False)
finally:
session.commit()
async def delete_todo(id: int, db: Session, current_user: schemas.User):
todo = db.query(models.TODO).filter(models.TODO.id == id).first()
if not todo:
detail = f"Todo {id} not found in db, thus cannot deleted"
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=detail)
if user_right(todo.owner_id, current_user.id):
detail = "Unauthorized to delete, kindly login into your Account"
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=detail)
db.delete(todo)
db.commit()
return Response(status_code=status.HTTP_204_NO_CONTENT)
def update_sources(remote_sources: List[SDKSource],
local_sources: List[Source], session: Session,
data_dir: str) -> None:
"""
Given collections of remote sources, the current local sources and a
session to the local database, ensure the state of the local database
matches that of the remote sources:
* Existing items are updated in the local database.
* New items are created in the local database.
* Local items not returned in the remote sources are deleted from the
local database.
"""
local_uuids = {source.uuid for source in local_sources}
for source in remote_sources:
if source.uuid in local_uuids:
# Update an existing record.
local_source = [s for s in local_sources
if s.uuid == source.uuid][0]
local_source.journalist_designation = source.journalist_designation
local_source.is_flagged = source.is_flagged
local_source.public_key = source.key['public']
local_source.interaction_count = source.interaction_count
local_source.document_count = source.number_of_documents
local_source.is_starred = source.is_starred
local_source.last_updated = parse(source.last_updated)
# Removing the UUID from local_uuids ensures this record won't be
# deleted at the end of this function.
local_uuids.remove(source.uuid)
logger.debug('Updated source {}'.format(source.uuid))
else:
# A new source to be added to the database.
ns = Source(uuid=source.uuid,
journalist_designation=source.journalist_designation,
is_flagged=source.is_flagged,
public_key=source.key['public'],
interaction_count=source.interaction_count,
is_starred=source.is_starred,
last_updated=parse(source.last_updated),
document_count=source.number_of_documents)
session.add(ns)
logger.debug('Added new source {}'.format(source.uuid))
# The uuids remaining in local_uuids do not exist on the remote server, so
# delete the related records.
for deleted_source in [s for s in local_sources if s.uuid in local_uuids]:
for document in deleted_source.collection:
delete_single_submission_or_reply_on_disk(document, data_dir)
session.delete(deleted_source)
logger.debug('Deleted source {}'.format(deleted_source.uuid))
session.commit()
def delete_video(session: Session, vid_id: int):
vid = session.query(Video).get(vid_id)
if not vid:
print("Video ID not found")
return -1
print("Deleting video %s: %s" % (vid.id, vid.title))
session.delete(vid)
session.commit()
print("Done")
return 0
def test_delete_existing_object(self):
"""
Test the method _delete_object(self, obj) when the object exists
Test scenario:
When the data is in the database, the delete operation should
complete successfully
"""
self.aMox.StubOutWithMock(session, 'query')
session.query(model.PowerVCMapping).AndReturn(query)
self.aMox.StubOutWithMock(query, 'filter_by')
query.filter_by(id=self.powerVCMapping['id']).AndReturn(query)
self.aMox.StubOutWithMock(query, 'one')
query.one().AndReturn(self.powerVCMapping)
self.aMox.StubOutWithMock(session, 'begin')
session.begin(subtransactions=True).AndReturn(transaction(None, None))
self.aMox.StubOutWithMock(session, 'delete')
returnValue = session.delete(self.powerVCMapping).AndReturn(True)
self.aMox.ReplayAll()
self.powervcagentdb._delete_object(self.powerVCMapping)
self.aMox.VerifyAll()
self.assertEqual(returnValue, True)
self.aMox.UnsetStubs()
class InboxSession(object):
""" Inbox custom ORM (with SQLAlchemy compatible API).
Parameters
----------
engine : <sqlalchemy.engine.Engine>
A configured database engine to use for this session
versioned : bool
Do you want to enable the transaction log?
ignore_soft_deletes : bool
Whether or not to ignore soft-deleted objects in query results.
namespace_id : int
Namespace to limit query results with.
"""
def __init__(self, engine, versioned=True, ignore_soft_deletes=True,
namespace_id=None):
# TODO: support limiting on namespaces
assert engine, "Must set the database engine"
args = dict(bind=engine, autoflush=True, autocommit=False)
self.ignore_soft_deletes = ignore_soft_deletes
if ignore_soft_deletes:
args['query_cls'] = InboxQuery
self._session = Session(**args)
if versioned:
from inbox.models.transaction import create_revisions
@event.listens_for(self._session, 'after_flush')
def after_flush(session, flush_context):
"""
Hook to log revision snapshots. Must be post-flush in order to
grab object IDs on new objects.
"""
create_revisions(session)
def query(self, *args, **kwargs):
q = self._session.query(*args, **kwargs)
if self.ignore_soft_deletes:
return q.options(IgnoreSoftDeletesOption())
else:
return q
def add(self, instance):
if not self.ignore_soft_deletes or not instance.is_deleted:
self._session.add(instance)
else:
raise Exception("Why are you adding a deleted object?")
def add_all(self, instances):
if True not in [i.is_deleted for i in instances] or \
not self.ignore_soft_deletes:
self._session.add_all(instances)
else:
raise Exception("Why are you adding a deleted object?")
def delete(self, instance):
if self.ignore_soft_deletes:
instance.mark_deleted()
# just to make sure
self._session.add(instance)
else:
self._session.delete(instance)
def begin(self):
self._session.begin()
def commit(self):
self._session.commit()
def rollback(self):
self._session.rollback()
def flush(self):
self._session.flush()
def close(self):
self._session.close()
def expunge(self, obj):
self._session.expunge(obj)
def merge(self, obj):
return self._session.merge(obj)
@property
def no_autoflush(self):
return self._session.no_autoflush
def __remove(self, entity, path): # pylint: disable=W0613
if len(path) == 0:
SaSession.delete(self, entity)
def remove(self, entity_class, data):
if not IEntity.providedBy(data): # pylint: disable=E1101
self.__run_traversal(entity_class, None, data,
RELATION_OPERATIONS.REMOVE)
else:
SaSession.delete(self, data)
def delete(self, entity):
self.begin()
SaSession.delete(self, entity)
self.commit()
session.expire_all()
################################################################################
# manage relationship
# emit a query and load relationship objects during the first qualification
# if no eager load is applied.
################################################################################
# load ########################################################
# may emit a quer
addresses = user.addresses
# eager load through left join
session.query(User).options('addresses')
# eager load with join. cause the inner join followed by left outer join.
session.query(User).options(joinedload('addresses')).join(User.addresses)
# delete ######################################################
# delete from secondary table automatically
user.addresses.remove(addresses[0])
# whether delete from secondary table depends on the configuration
session.delete(addresses[0])
def delete(cls, id_):
obj = cls.query().get(id_)
Session.delete(obj)
Session.commit()
