def ClearDeleteRecord(self, service_id, hash_ids):

        deleted_files_table_name = GenerateFilesTableName(
            service_id, HC.CONTENT_STATUS_DELETED)

        self._c.executemany(
            'DELETE FROM {} WHERE hash_id = ?;'.format(
                deleted_files_table_name),
            ((hash_id, ) for hash_id in hash_ids))

        num_deleted = HydrusDB.GetRowCount(self._c)

        return num_deleted
    def RecordDeleteFiles(self, service_id, insert_rows):

        deleted_files_table_name = GenerateFilesTableName(
            service_id, HC.CONTENT_STATUS_DELETED)

        now = HydrusData.GetNow()

        self._c.executemany(
            'INSERT OR IGNORE INTO {} ( hash_id, timestamp, original_timestamp ) VALUES ( ?, ?, ? );'
            .format(deleted_files_table_name),
            ((hash_id, now, original_timestamp)
             for (hash_id, original_timestamp) in insert_rows))

        num_new_deleted_files = HydrusDB.GetRowCount(self._c)

        return num_new_deleted_files
    def RemoveFiles(self, service_id, hash_ids):

        (current_files_table_name, deleted_files_table_name,
         pending_files_table_name,
         petitioned_files_table_name) = GenerateFilesTableNames(service_id)

        self._c.executemany(
            'DELETE FROM {} WHERE hash_id = ?;'.format(
                current_files_table_name),
            ((hash_id, ) for hash_id in hash_ids))

        self._c.executemany(
            'DELETE FROM {} WHERE hash_id = ?;'.format(
                petitioned_files_table_name),
            ((hash_id, ) for hash_id in hash_ids))

        pending_changed = HydrusDB.GetRowCount(self._c) > 0

        return pending_changed
    def AddFiles(self, service_id, insert_rows):

        (current_files_table_name, deleted_files_table_name,
         pending_files_table_name,
         petitioned_files_table_name) = GenerateFilesTableNames(service_id)

        self._c.executemany(
            'INSERT OR IGNORE INTO {} VALUES ( ?, ? );'.format(
                current_files_table_name),
            ((hash_id, timestamp) for (hash_id, timestamp) in insert_rows))

        self._c.executemany(
            'DELETE FROM {} WHERE hash_id = ?;'.format(
                pending_files_table_name),
            ((hash_id, ) for (hash_id, timestamp) in insert_rows))

        pending_changed = HydrusDB.GetRowCount(self._c) > 0

        return pending_changed
Пример #5
0
 def AssociatePHashes( self, hash_id, phashes ):
     
     phash_ids = set()
     
     for phash in phashes:
         
         phash_id = self._GetPHashId( phash )
         
         phash_ids.add( phash_id )
         
     
     self._c.executemany( 'INSERT OR IGNORE INTO shape_perceptual_hash_map ( phash_id, hash_id ) VALUES ( ?, ? );', ( ( phash_id, hash_id ) for phash_id in phash_ids ) )
     
     if HydrusDB.GetRowCount( self._c ) > 0:
         
         self._c.execute( 'REPLACE INTO shape_search_cache ( hash_id, searched_distance ) VALUES ( ?, ? );', ( hash_id, None ) )
         
     
     return phash_ids
    def ClearLocalDeleteRecord(self, hash_ids=None):

        # we delete from everywhere, but not for files currently in the trash

        service_ids_to_nums_cleared = {}

        local_non_trash_service_ids = self.modules_services.GetServiceIds(
            (HC.COMBINED_LOCAL_FILE, HC.LOCAL_FILE_DOMAIN))

        if hash_ids is None:

            trash_current_files_table_name = GenerateFilesTableName(
                self.modules_services.trash_service_id,
                HC.CONTENT_STATUS_CURRENT)

            for service_id in local_non_trash_service_ids:

                deleted_files_table_name = GenerateFilesTableName(
                    service_id, HC.CONTENT_STATUS_DELETED)

                self._c.execute(
                    'DELETE FROM {} WHERE hash_id NOT IN ( SELECT hash_id FROM {} );'
                    .format(deleted_files_table_name,
                            trash_current_files_table_name))

                num_cleared = HydrusDB.GetRowCount(self._c)

                service_ids_to_nums_cleared[service_id] = num_cleared

            self._c.execute(
                'DELETE FROM local_file_deletion_reasons WHERE hash_id NOT IN ( SELECT hash_id FROM {} );'
                .format(trash_current_files_table_name))

        else:

            trashed_hash_ids = self.FilterCurrentHashIds(
                self.modules_services.trash_service_id, hash_ids)

            ok_to_clear_hash_ids = set(hash_ids).difference(trashed_hash_ids)

            if len(ok_to_clear_hash_ids) > 0:

                for service_id in local_non_trash_service_ids:

                    deleted_files_table_name = GenerateFilesTableName(
                        service_id, HC.CONTENT_STATUS_DELETED)

                    self._c.executemany(
                        'DELETE FROM {} WHERE hash_id = ?;'.format(
                            deleted_files_table_name),
                        ((hash_id, ) for hash_id in ok_to_clear_hash_ids))

                    num_cleared = HydrusDB.GetRowCount(self._c)

                    service_ids_to_nums_cleared[service_id] = num_cleared

                self._c.executemany(
                    'DELETE FROM local_file_deletion_reasons WHERE hash_id = ?;',
                    ((hash_id, ) for hash_id in ok_to_clear_hash_ids))

        return service_ids_to_nums_cleared