def clear(self):
"""Remove all entries from the database. This operation can be undone
using the :meth:`undo` method.
"""
cmds = CompositeOperation()
for entry in self:
for tag in entry.tags:
cmds.add(commands.RemoveTag(self.session, entry, tag))
# TODO: also remove all FITS header entries and all FITS header
# comments from each entry before removing the entry itself!
# remove all entries from all helper tables
database_tables = [
tables.JSONDump, tables.Tag, tables.FitsHeaderEntry,
tables.FitsKeyComment
]
for table in database_tables:
for entry in self.session.query(table):
cmds.add(commands.RemoveEntry(self.session, entry))
for entry in self:
cmds.add(commands.RemoveEntry(self.session, entry))
del self._cache[entry.id]
if self._enable_history:
self._command_manager.do(cmds)
else:
cmds()
def set_cache_size(self, cache_size):
"""Set a new value for the maximum number of database entries in the
cache. Use the value ``float('inf')`` to disable caching. If the new
cache is smaller than the previous one and cannot contain all the
entries anymore, entries are removed from the cache until the number of
entries equals the cache size. Which entries are removed depends on the
implementation of the cache (e.g.
:class:`sunpy.database.caching.LRUCache`,
:class:`sunpy.database.caching.LFUCache`).
"""
cmds = CompositeOperation()
# remove items from the cache if the given argument is lower than the
# current cache size
while cache_size < self.cache_size:
# remove items from the cache until cache_size == maxsize of the
# cache
entry_id, entry = self._cache.to_be_removed
cmd = commands.RemoveEntry(self.session, entry)
if self._enable_history:
cmds.add(cmd)
else:
cmd()
del self._cache[entry_id]
self._cache.maxsize = cache_size
if cmds:
self._command_manager.do(cmds)
def remove(self, database_entry):
"""Remove the given database entry from the database table."""
remove_entry_cmd = commands.RemoveEntry(self.session, database_entry)
if self._enable_history:
self._command_manager.do(remove_entry_cmd)
else:
remove_entry_cmd()
try:
del self._cache[database_entry.id]
except KeyError:
# entry cannot be removed because it was already removed or never
# existed in the database. This can be safely ignored, the user
# doesn't even know there's a cache here
pass
def remove_many(self, database_entries):
"""Remove a row of database entries "at once". If this method is used,
only one entry is saved in the undo history.
Parameters
----------
database_entries : iterable of sunpy.database.tables.DatabaseEntry
The database entries that will be removed from the database.
"""
cmds = CompositeOperation()
for database_entry in database_entries:
cmd = commands.RemoveEntry(self.session, database_entry)
if self._enable_history:
cmds.add(cmd)
else:
cmd()
try:
del self._cache[database_entry.id]
except KeyError:
pass
if cmds:
self._command_manager.do(cmds)
def remove_tag(self, database_entry, tag_name):
"""Remove the given tag from the database entry. If the tag is not
connected to any entry after this operation, the tag itself is removed
from the database as well.
Raises
------
sunpy.database.NoSuchTagError
If the tag is not connected to the given entry.
"""
tag = self.get_tag(tag_name)
cmds = CompositeOperation()
remove_tag_cmd = commands.RemoveTag(self.session, database_entry, tag)
remove_tag_cmd()
if self._enable_history:
cmds.add(remove_tag_cmd)
if not tag.data:
remove_entry_cmd = commands.RemoveEntry(self.session, tag)
remove_entry_cmd()
if self._enable_history:
cmds.add(remove_entry_cmd)
if self._enable_history:
self._command_manager.push_undo_command(cmds)
