~ubuntu-branches/debian/sid/calibre/sid

 

class SchemaUpgrade(object):

 

        self.library_path = library_path

        self.field_metadata = field_metadata

        # Upgrade database

        try:

            while True:

                meth = getattr(self, 'upgrade_version_%d'%uv, None)

                if meth is None:

                    break

                else:

                    prints('Upgrading database to version %d...'%(uv+1))

                    meth()

        except:

            raise

        else:

        finally:

 

    def upgrade_version_1(self):

        '''

        Normalize indices.

        '''

        DROP INDEX IF EXISTS authors_idx;

        CREATE INDEX authors_idx ON books (author_sort COLLATE NOCASE, sort COLLATE NOCASE);

        DROP INDEX IF EXISTS series_idx;

        END;

        DELETE FROM %(table)s WHERE (SELECT COUNT(id) FROM books_%(ltable)s_link WHERE %(ltable_col)s=%(table)s.id) < 1;

        '''

 

    def upgrade_version_3(self):

        ' Add path to result cache '

        DROP VIEW IF EXISTS meta;

        CREATE VIEW meta AS

        SELECT id, title,

 

    def upgrade_version_4(self):

        'Rationalize books table'

        CREATE TEMPORARY TABLE

        books_backup(id,title,sort,timestamp,series_index,author_sort,isbn,path);

        INSERT INTO books_backup SELECT id,title,sort,timestamp,series_index,author_sort,isbn,path FROM books;

 

    def upgrade_version_5(self):

        'Update indexes/triggers for new books table'

        CREATE INDEX authors_idx ON books (author_sort COLLATE NOCASE);

        CREATE INDEX books_idx ON books (sort COLLATE NOCASE);

        CREATE TRIGGER books_delete_trg

 

    def upgrade_version_6(self):

        'Show authors in order'

        DROP VIEW IF EXISTS meta;

        CREATE VIEW meta AS

        SELECT id, title,

 

    def upgrade_version_7(self):

        'Add uuid column'

        ALTER TABLE books ADD COLUMN uuid TEXT;

        DROP TRIGGER IF EXISTS books_insert_trg;

        DROP TRIGGER IF EXISTS books_update_trg;

    def upgrade_version_8(self):

        'Add Tag Browser views'

        def create_tag_browser_view(table_name, column_name):

                DROP VIEW IF EXISTS tag_browser_{tn};

                CREATE VIEW tag_browser_{tn} AS SELECT

                    id,

 

    def upgrade_version_9(self):

        'Add custom columns'

                CREATE TABLE custom_columns (

                    id       INTEGER PRIMARY KEY AUTOINCREMENT,

                    label    TEXT NOT NULL,

                        {cn}={tn}.id AND books_list_filter(book)) count

                FROM {tn};

                '''.format(tn=table_name, cn=column_name, vcn=view_column_name))

 

        for field in self.field_metadata.itervalues():

            if field['is_category'] and not field['is_custom'] and 'link_column' in field:

                    'SELECT name FROM sqlite_master WHERE type="table" AND name=?',

                    ('books_%s_link'%field['table'],), all=False)

                if table is not None:

 

                '''.format(tn=table_name, cn=column_name,

                           vcn=view_column_name, scn=sort_column_name))

 

        def create_cust_tag_browser_view(table_name, link_table_name):

            script = '''

                     value AS sort

                FROM {table};

                '''.format(lt=link_table_name, table=table_name)

 

        for field in self.field_metadata.itervalues():

            if field['is_category'] and not field['is_custom'] and 'link_column' in field:

                    'SELECT name FROM sqlite_master WHERE type="table" AND name=?',

                    ('books_%s_link'%field['table'],), all=False)

                if table is not None:

                    create_std_tag_browser_view(field['table'], field['link_column'],

                                            field['column'], field['category_sort'])

 

                                     WHERE type='table'

                                     ORDER BY name''')

        tables = []

            if table.startswith('custom_column_') and link_table in tables:

                create_cust_tag_browser_view(table, link_table)

 

 

    def upgrade_version_12(self):

        'DB based preference store'

                                 val TEXT NON NULL,

                                 UNIQUE(key));

        '''

 

    def upgrade_version_13(self):

        'Dirtied table for OPF metadata backups'

                             UNIQUE(book));

        INSERT INTO metadata_dirtied (book) SELECT id FROM books;

        '''

 

    def upgrade_version_14(self):

        'Cache has_cover'

        def has_cover(path):

            if path:

                path = os.path.join(self.library_path, path.replace('/', os.sep),

            return False

 

        ids = [(x[0],) for x in data if has_cover(x[1])]

 

    def upgrade_version_15(self):

        'Remove commas from tags'

 

    def upgrade_version_16(self):

        DROP TRIGGER IF EXISTS books_update_trg;

        CREATE TRIGGER books_update_trg

            AFTER UPDATE ON books

                DELETE FROM books_plugin_data WHERE book=OLD.id;

        END;

        '''

 

    def upgrade_version_18(self):

        '''

        '''%isoformat(DEFAULT_DATE, sep=' ')

        # Sqlite does not support non constant default values in alter

        # statements

 

    def upgrade_version_19(self):

        if recipes:

            from calibre.web.feeds.recipes import (custom_recipes,

                    custom_recipe_filename)

        script = '''

        ALTER TABLE authors ADD COLUMN link TEXT NOT NULL DEFAULT "";

        '''