Cutlery/calibre
1
0
Fork 0
mirror of https://github.com/kovidgoyal/calibre.git synced 2025-07-08 02:34:06 -04:00
Code Issues Packages Projects Releases Wiki Activity

Back the virtual library column stuff out of this branch.

Browse Source
This commit is contained in:
Charles Haley 2013-07-13 12:52:47 +02:00
parent 37520e3ba8
commit 1c75418d20
7 changed files with 48 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/calibre/gui2/search_restriction_mixin.py
View File

@ -332,7 +332,6 @@ class SearchRestrictionMixin(object):
virt_libs = db.prefs.get('virtual_libraries', {})
virt_libs[name] = search
db.prefs.set('virtual_libraries', virt_libs)
db.data.invalidate_virtual_libraries_caches()
def do_create_edit(self, name=None):
db = self.library_view.model().db
@ -342,11 +341,8 @@ class SearchRestrictionMixin(object):
if name:
self._remove_vl(name, reapply=False)
self.add_virtual_library(db, cd.library_name, cd.library_search)
db.data.invalidate_virtual_libraries_caches()
if not name or name == db.data.get_base_restriction_name():
self.apply_virtual_library(cd.library_name)
else:
self.tags_view.recount()
def virtual_library_clicked(self):
m = self.virtual_library_menu
@ -466,9 +462,6 @@ class SearchRestrictionMixin(object):
default_yes=False):
return
self._remove_vl(name, reapply=True)
db = self.library_view.model().db
db.data.invalidate_virtual_libraries_caches()
self.tags_view.recount()
def _remove_vl(self, name, reapply=True):
db = self.library_view.model().db

65
src/calibre/library/caches.py
View File

@ -144,8 +144,7 @@ def force_to_bool(val):
class CacheRow(list): # {{{
def __init__(self, db, composites, val, series_col, series_sort_col,
virtual_library_col):
def __init__(self, db, composites, val, series_col, series_sort_col):
self.db = db
self._composites = composites
list.__init__(self, val)
@ -153,8 +152,6 @@ class CacheRow(list): # {{{
self._series_col = series_col
self._series_sort_col = series_sort_col
self._series_sort = None
self._virt_lib_col = virtual_library_col
self._virt_libs = None
def __getitem__(self, col):
if self._must_do:
@ -182,26 +179,6 @@ class CacheRow(list): # {{{
else:
self._series_sort = ''
self[self._series_sort_col] = ''
if col == self._virt_lib_col and self._virt_libs is None:
try:
if not getattr(self.db.data, '_virt_libs_computed', False):
self.db.data._ids_in_virt_libs = {}
for v,s in self.db.prefs.get('virtual_libraries', {}).iteritems():
self.db.data._ids_in_virt_libs[v] = self.db.data.search_raw(s)
self.db.data._virt_libs_computed = True
r = []
for v in self.db.prefs.get('virtual_libraries', {}).keys():
# optimize the lookup of the ID -- it is always zero
if self[0] in self.db.data._ids_in_virt_libs[v]:
r.append(v)
from calibre.utils.icu import sort_key
self._virt_libs = ", ".join(sorted(r, key=sort_key))
self[self._virt_lib_col] = self._virt_libs
except:
print len(self)
traceback.print_exc()
return list.__getitem__(self, col)
def __getslice__(self, i, j):
@ -212,8 +189,6 @@ class CacheRow(list): # {{{
self[c] = None
self._must_do = True
def refresh_virtual_libraries(self):
self._virt_libs = None
# }}}
class ResultCache(SearchQueryParser): # {{{
@ -231,7 +206,6 @@ class ResultCache(SearchQueryParser): # {{{
self.composites[field_metadata[key]['rec_index']] = key
self.series_col = field_metadata['series']['rec_index']
self.series_sort_col = field_metadata['series_sort']['rec_index']
self.virtual_libraries_col = field_metadata['virtual_libraries']['rec_index']
self._data = []
self._map = self._map_filtered = []
self.first_sort = True
@ -249,8 +223,6 @@ class ResultCache(SearchQueryParser): # {{{
pref_use_primary_find_in_search = prefs['use_primary_find_in_search']
self._uuid_column_index = self.FIELD_MAP['uuid']
self._uuid_map = {}
self._virt_libs_computed = False
self._ids_in_virt_libs = {}
def break_cycles(self):
self._data = self.field_metadata = self.FIELD_MAP = \
@ -844,19 +816,6 @@ class ResultCache(SearchQueryParser): # {{{
current_candidates -= matches
return matches
def invalidate_virtual_libraries_caches(self):
self._virt_libs_computed = False
self._ids_in_virt_libs = {}
for row in self._data:
if row is not None:
row.refresh_virtual_libraries()
row.refresh_composites()
def search_raw(self, query):
matches = self.parse(query)
return matches
def search(self, query, return_matches=False):
ans = self.search_getting_ids(query, self.search_restriction,
set_restriction_count=True)
@ -1014,11 +973,10 @@ class ResultCache(SearchQueryParser): # {{{
try:
self._data[id] = CacheRow(db, self.composites,
db.conn.get('SELECT * from meta2 WHERE id=?', (id,))[0],
self.series_col, self.series_sort_col,
self.virtual_libraries_col)
self.series_col, self.series_sort_col)
self._data[id].append(db.book_on_device_string(id))
self._data[id].extend((self.marked_ids_dict.get(id, None), None, None))
self._virt_libs_computed = False
self._data[id].append(self.marked_ids_dict.get(id, None))
self._data[id].append(None)
self._uuid_map[self._data[id][self._uuid_column_index]] = id
except IndexError:
return None
@ -1035,11 +993,10 @@ class ResultCache(SearchQueryParser): # {{{
for id in ids:
self._data[id] = CacheRow(db, self.composites,
db.conn.get('SELECT * from meta2 WHERE id=?', (id,))[0],
self.series_col, self.series_sort_col,
self.virtual_libraries_col)
self.series_col, self.series_sort_col)
self._data[id].append(db.book_on_device_string(id))
self._data[id].extend((self.marked_ids_dict.get(id, None), None, None))
self._virt_libs_computed = False
self._data[id].append(self.marked_ids_dict.get(id, None))
self._data[id].append(None) # Series sort column
self._uuid_map[self._data[id][self._uuid_column_index]] = id
self._map[0:0] = ids
self._map_filtered[0:0] = ids
@ -1066,17 +1023,15 @@ class ResultCache(SearchQueryParser): # {{{
self._data = list(itertools.repeat(None, temp[-1][0]+2)) if temp else []
for r in temp:
self._data[r[0]] = CacheRow(db, self.composites, r,
self.series_col, self.series_sort_col,
self.virtual_libraries_col)
self.series_col, self.series_sort_col)
self._uuid_map[self._data[r[0]][self._uuid_column_index]] = r[0]
for item in self._data:
if item is not None:
item.append(db.book_on_device_string(item[0]))
# Temp mark, series_sort, virtual_library columns
item.extend((None, None, None))
# Temp mark and series_sort columns
item.extend((None, None))
self._virt_libs_computed = False
marked_col = self.FIELD_MAP['marked']
for id_,val in self.marked_ids_dict.iteritems():
try:

2
src/calibre/library/cli.py
View File

@ -575,7 +575,7 @@ def command_set_metadata(args, dbpath):
for key in sorted(db.field_metadata.all_field_keys()):
m = db.field_metadata[key]
if (key not in {'formats', 'series_sort', 'ondevice', 'path',
'virtual_libraries', 'last_modified'} and m['is_editable'] and m['name']):
'last_modified'} and m['is_editable'] and m['name']):
yield key, m
if m['datatype'] == 'series':
si = m.copy()

6
src/calibre/library/database2.py
View File

@ -449,8 +449,6 @@ class LibraryDatabase2(LibraryDatabase, SchemaUpgrade, CustomColumns):
self.field_metadata.set_field_record_index('marked', base, prefer_custom=False)
self.FIELD_MAP['series_sort'] = base = base+1
self.field_metadata.set_field_record_index('series_sort', base, prefer_custom=False)
self.FIELD_MAP['virtual_libraries'] = base = base+1
self.field_metadata.set_field_record_index('virtual_libraries', base, prefer_custom=False)
script = '''
DROP VIEW IF EXISTS meta2;
@ -994,10 +992,6 @@ class LibraryDatabase2(LibraryDatabase, SchemaUpgrade, CustomColumns):
mi.book_size = row[fm['size']]
mi.ondevice_col= row[fm['ondevice']]
mi.last_modified = row[fm['last_modified']]
mi._base_db_row = row # So the formatter functions can see the underlying data
mi._virt_lib_column = fm['virtual_libraries']
formats = row[fm['formats']]
mi.format_metadata = {}
if not formats:

10
src/calibre/library/field_metadata.py
View File

@ -387,16 +387,6 @@ class FieldMetadata(dict):
'is_custom':False,
'is_category':False,
'is_csp': False}),
('virtual_libraries', {'table':None,
'column':None,
'datatype':'text',
'is_multiple':{},
'kind':'field',
'name':_('Virtual Libraries'),
'search_terms':['virtual_libraries'],
'is_custom':False,
'is_category':False,
'is_csp': False}),
]
# }}}

12
src/calibre/utils/formatter_functions.py
View File

@ -1209,19 +1209,9 @@ class BuiltinFinishFormatting(BuiltinFormatterFunction):
return val
return prefix + formatter._do_format(val, fmt) + suffix
class BuiltinBookInVirtualLibraries(BuiltinFormatterFunction):
name = 'book_in_virtual_libraries'
arg_count = 0
category = 'Get values from metadata'
__doc__ = doc = _('book_in_virtual_libraries() -- returns a list of '
'virtual libraries that this book is in.')
def evaluate(self, formatter, kwargs, mi, locals_):
return mi._base_db_row[mi._virt_lib_column ]
_formatter_builtins = [
BuiltinAdd(), BuiltinAnd(), BuiltinApproximateFormats(),
BuiltinAssign(), BuiltinBookInVirtualLibraries(), BuiltinBooksize(),
BuiltinAssign(), BuiltinBooksize(),
BuiltinCapitalize(), BuiltinCmp(), BuiltinContains(), BuiltinCount(),
BuiltinCurrentLibraryName(), BuiltinCurrentLibraryPath(),
BuiltinDaysBetween(), BuiltinDivide(), BuiltinEval(), BuiltinFirstNonEmpty(),

7
src/calibre/utils/search_query_parser.py
View File

@ -294,7 +294,6 @@ class SearchQueryParser(object):
def __init__(self, locations, test=False, optimize=False):
self.sqp_initialize(locations, test=test, optimize=optimize)
self.sqp_parsed_search_cache = {}
self.parser = Parser()
def sqp_change_locations(self, locations):
@ -309,7 +308,8 @@ class SearchQueryParser(object):
# empty the list of searches used for recursion testing
self.recurse_level = 0
self.searches_seen = set([])
return self._parse(query)
candidates = self.universal_set()
return self._parse(query, candidates)
# this parse is used internally because it doesn't clear the
# recursive search test list. However, we permit seeing the
@ -317,11 +317,8 @@ class SearchQueryParser(object):
# another search.
def _parse(self, query, candidates=None):
self.recurse_level += 1
res = self.sqp_parsed_search_cache.get(query, None)
if res is None:
try:
res = self.parser.parse(query, self.locations)
self.sqp_parsed_search_cache[query] = res
except RuntimeError:
raise ParseException(_('Failed to parse query, recursion limit reached: %s')%repr(query))
if candidates is None: