← Back to branch summary

~ubuntu-branches/ubuntu/natty/newsbeuter/natty

« back to all changes in this revision

Viewing changes to src/cache.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Nico Golde
  • Date: 2010-03-23 19:09:18 UTC
  • mfrom: (4.1.10 sid)
  • Revision ID: james.westby@ubuntu.com-20100323190918-o3mwdwl3v4li449s
Tags: 2.2-2
http://bugs.debian.org/574665
Do not cleanup deleted items uppon quitting so they will be
reloaded and marked as new next time (Closes: #574665).

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cache.cpp
94
94
 
95
95
static int rssitem_callback(void * myfeed, int argc, char ** argv, char ** /* azColName */) {
96
96
        std::tr1::shared_ptr<rss_feed>* feed = static_cast<std::tr1::shared_ptr<rss_feed>* >(myfeed);
97
 
        assert (argc == 12);
 
97
        assert (argc == 13);
98
98
        std::tr1::shared_ptr<rss_item> item(new rss_item(NULL));
99
99
        item->set_guid(argv[0]);
100
100
        item->set_title(argv[1]);
115
115
        item->set_enclosure_type(argv[9] ? argv[9] : "");
116
116
        item->set_enqueued((std::string("1") == (argv[10] ? argv[10] : "")));
117
117
        item->set_flags(argv[11] ? argv[11] : "");
 
118
        item->set_base(argv[12] ? argv[12] : "");
118
119
 
119
120
        (*feed)->items().push_back(item);
120
121
        return 0;
123
124
static int rssitemvector_callback(void * vector, int argc, char ** argv, char ** /* azColName */) {
124
125
        std::vector<std::tr1::shared_ptr<rss_item> >* items = static_cast<std::vector<std::tr1::shared_ptr<rss_item> > *>(vector);
125
126
 
126
 
        assert (argc == 12);
 
127
        assert (argc == 13);
127
128
        std::tr1::shared_ptr<rss_item> item(new rss_item(NULL));
128
129
        item->set_guid(argv[0]);
129
130
        item->set_title(argv[1]);
144
145
        item->set_enclosure_type(argv[9] ? argv[9] : "");
145
146
        item->set_enqueued((std::string("1") == (argv[10] ? argv[10] : "")));
146
147
        item->set_flags(argv[11] ? argv[11] : "");
 
148
        item->set_base(argv[12] ? argv[12] : "");
147
149
 
148
150
        items->push_back(item);
149
151
        return 0;
151
153
 
152
154
static int search_item_callback(void * myfeed, int argc, char ** argv, char ** /* azColName */) {
153
155
        std::vector<std::tr1::shared_ptr<rss_item> > * items = static_cast<std::vector<std::tr1::shared_ptr<rss_item> > *>(myfeed);
154
 
        assert (argc == 12);
 
156
        assert (argc == 13);
155
157
        std::tr1::shared_ptr<rss_item> item(new rss_item(NULL));
156
158
        item->set_guid(argv[0]);
157
159
        item->set_title(argv[1]);
171
173
        item->set_enclosure_type(argv[9] ? argv[9] : "");
172
174
        item->set_enqueued((std::string("1") == argv[10]));
173
175
        item->set_flags(argv[11] ? argv[11] : "");
 
176
        item->set_base(argv[12] ? argv[12] : "");
174
177
 
175
178
        items->push_back(item);
176
179
        return 0;
292
295
        rc = sqlite3_exec(db, "ALTER TABLE rss_feed ADD etag VARCHAR(128) NOT NULL DEFAULT \"\";", NULL, NULL, NULL);
293
296
        LOG(LOG_DEBUG, "cache::populate_tables: ALTER TABLE rss_feed (9) rc = %d", rc);
294
297
 
 
298
        rc = sqlite3_exec(db, "ALTER TABLE rss_item ADD base VARCHAR(128) NOT NULL DEFAULT \"\";", NULL, NULL, NULL);
 
299
        LOG(LOG_DEBUG, "cache::populate_tables: ALTER TABLE rss_feed(10) rc = %d", rc);
295
300
}
296
301
 
297
302
 
398
403
 
399
404
// this function reads an rss_feed including all of its rss_items.
400
405
// the feed parameter needs to have the rssurl member set.
401
 
void cache::internalize_rssfeed(std::tr1::shared_ptr<rss_feed> feed) {
 
406
void cache::internalize_rssfeed(std::tr1::shared_ptr<rss_feed> feed, rss_ignores * ign) {
402
407
        scope_measure m1("cache::internalize_rssfeed");
403
408
        if (feed->rssurl().substr(0,6) == "query:")
404
409
                return;
432
437
        feed->items().clear();
433
438
 
434
439
        /* ...and then the associated items */
435
 
        query = prepare_query("SELECT guid,title,author,url,pubDate,content,unread,feedurl,enclosure_url,enclosure_type,enqueued,flags FROM rss_item WHERE feedurl = '%q' AND deleted = 0 ORDER BY pubDate DESC, id DESC;",feed->rssurl().c_str());
 
440
        query = prepare_query("SELECT guid,title,author,url,pubDate,content,unread,feedurl,enclosure_url,enclosure_type,enqueued,flags,base FROM rss_item WHERE feedurl = '%q' AND deleted = 0 ORDER BY pubDate DESC, id DESC;",feed->rssurl().c_str());
436
441
        LOG(LOG_DEBUG,"running query: %s",query.c_str());
437
442
        rc = sqlite3_exec(db,query.c_str(),rssitem_callback,&feed,NULL);
438
443
        if (rc != SQLITE_OK) {
441
446
        }
442
447
 
443
448
        unsigned int i=0;
444
 
        for (std::vector<std::tr1::shared_ptr<rss_item> >::iterator it=feed->items().begin(); it != feed->items().end(); ++it, ++i) {
 
449
        for (std::vector<std::tr1::shared_ptr<rss_item> >::iterator it=feed->items().begin(); it != feed->items().end(); ++it,++i) {
 
450
                if (ign && ign->matches(it->get())) {
 
451
                        feed->items().erase(it);
 
452
                        // since we modified the vector, we need to reset the iterator
 
453
                        // to the beginning of the vector, and then fast-forward to
 
454
                        // the next element.
 
455
                        it = feed->items().begin();
 
456
                        for (int j=0;j<int(i)-1;j++) {
 
457
                                it++;
 
458
                        }
 
459
                        continue;
 
460
                }
445
461
                (*it)->set_cache(this);
446
462
                (*it)->set_feedptr(feed);
447
463
                (*it)->set_feedurl(feed->rssurl());
472
488
 
473
489
void cache::get_latest_items(std::vector<std::tr1::shared_ptr<rss_item> >& items, unsigned int limit) {
474
490
        scope_mutex lock(&mtx);
475
 
        std::string query = prepare_query("SELECT guid,title,author,url,pubDate,content,unread,feedurl,enclosure_url,enclosure_type,enqueued,flags "
 
491
        std::string query = prepare_query("SELECT guid,title,author,url,pubDate,content,unread,feedurl,enclosure_url,enclosure_type,enqueued,flags,base "
476
492
                                                                        "FROM rss_item WHERE deleted = 0 ORDER BY pubDate DESC, id DESC LIMIT %d;", limit);
477
493
        LOG(LOG_DEBUG, "running query: %s", query.c_str());
478
494
        int rc = sqlite3_exec(db, query.c_str(), rssitemvector_callback, &items, NULL);
508
524
 
509
525
        scope_mutex lock(&mtx);
510
526
        if (feedurl.length() > 0) {
511
 
                query = prepare_query("SELECT guid,title,author,url,pubDate,content,unread,feedurl,enclosure_url,enclosure_type,enqueued,flags FROM rss_item WHERE (title LIKE '%%%q%%' OR content LIKE '%%%q%%') AND feedurl = '%q' AND deleted = 0 ORDER BY pubDate DESC, id DESC;",querystr.c_str(), querystr.c_str(), feedurl.c_str());
 
527
                query = prepare_query("SELECT guid,title,author,url,pubDate,content,unread,feedurl,enclosure_url,enclosure_type,enqueued,flags,base FROM rss_item WHERE (title LIKE '%%%q%%' OR content LIKE '%%%q%%') AND feedurl = '%q' AND deleted = 0 ORDER BY pubDate DESC, id DESC;",querystr.c_str(), querystr.c_str(), feedurl.c_str());
512
528
        } else {
513
 
                query = prepare_query("SELECT guid,title,author,url,pubDate,content,unread,feedurl,enclosure_url,enclosure_type,enqueued,flags FROM rss_item WHERE (title LIKE '%%%q%%' OR content LIKE '%%%q%%') AND deleted = 0 ORDER BY pubDate DESC, id DESC;",querystr.c_str(), querystr.c_str());
 
529
                query = prepare_query("SELECT guid,title,author,url,pubDate,content,unread,feedurl,enclosure_url,enclosure_type,enqueued,flags,base FROM rss_item WHERE (title LIKE '%%%q%%' OR content LIKE '%%%q%%') AND deleted = 0 ORDER BY pubDate DESC, id DESC;",querystr.c_str(), querystr.c_str());
514
530
        }
515
531
 
516
532
        LOG(LOG_DEBUG,"running query: %s",query.c_str());
636
652
                                }
637
653
                        }
638
654
                }
639
 
                std::string update = prepare_query("UPDATE rss_item SET title = '%q', author = '%q', url = '%q', feedurl = '%q', content = '%q', enclosure_url = '%q', enclosure_type = '%q' WHERE guid = '%q'",
640
 
                        item->title_raw().c_str(), item->author_raw().c_str(), item->link().c_str(), 
641
 
                        feedurl.c_str(), item->description_raw().c_str(), 
642
 
                        item->enclosure_url().c_str(), item->enclosure_type().c_str(),
643
 
                        item->guid().c_str());
 
655
                std::string update;
 
656
                if (item->override_unread()) {
 
657
                        update = prepare_query("UPDATE rss_item SET title = '%q', author = '%q', url = '%q', feedurl = '%q', content = '%q', enclosure_url = '%q', enclosure_type = '%q', base = '%q', unread = '%d' WHERE guid = '%q'",
 
658
                                item->title_raw().c_str(), item->author_raw().c_str(), item->link().c_str(), 
 
659
                                feedurl.c_str(), item->description_raw().c_str(), 
 
660
                                item->enclosure_url().c_str(), item->enclosure_type().c_str(), item->get_base().c_str(),
 
661
                                (item->unread() ? 1 : 0),
 
662
                                item->guid().c_str());
 
663
                } else {
 
664
                        update = prepare_query("UPDATE rss_item SET title = '%q', author = '%q', url = '%q', feedurl = '%q', content = '%q', enclosure_url = '%q', enclosure_type = '%q', base = '%q' WHERE guid = '%q'",
 
665
                                item->title_raw().c_str(), item->author_raw().c_str(), item->link().c_str(), 
 
666
                                feedurl.c_str(), item->description_raw().c_str(), 
 
667
                                item->enclosure_url().c_str(), item->enclosure_type().c_str(), item->get_base().c_str(),
 
668
                                item->guid().c_str());
 
669
                }
644
670
                LOG(LOG_DEBUG,"running query: %s", update.c_str());
645
671
                rc = sqlite3_exec(db,update.c_str(),NULL,NULL,NULL);
646
672
                if (rc != SQLITE_OK) {
648
674
                        throw dbexception(db);
649
675
                }
650
676
        } else {
651
 
                std::string insert = prepare_query("INSERT INTO rss_item (guid,title,author,url,feedurl,pubDate,content,unread,enclosure_url,enclosure_type,enqueued) "
652
 
                                                                "VALUES ('%q','%q','%q','%q','%q','%u','%q',1,'%q','%q',%d)",
 
677
                std::string insert = prepare_query("INSERT INTO rss_item (guid,title,author,url,feedurl,pubDate,content,unread,enclosure_url,enclosure_type,enqueued, base) "
 
678
                                                                "VALUES ('%q','%q','%q','%q','%q','%u','%q','%d','%q','%q',%d, '%q')",
653
679
                                                                item->guid().c_str(), item->title_raw().c_str(), item->author_raw().c_str(), 
654
 
                                                                item->link().c_str(), feedurl.c_str(), item->pubDate_timestamp(), item->description_raw().c_str(),
655
 
                                                                item->enclosure_url().c_str(), item->enclosure_type().c_str(), item->enqueued() ? 1 : 0);
 
680
                                                                item->link().c_str(), feedurl.c_str(), item->pubDate_timestamp(), item->description_raw().c_str(), (item->unread() ? 1 : 0),
 
681
                                                                item->enclosure_url().c_str(), item->enclosure_type().c_str(), item->enqueued() ? 1 : 0, item->get_base().c_str());
656
682
                LOG(LOG_DEBUG,"running query: %s", insert.c_str());
657
683
                rc = sqlite3_exec(db,insert.c_str(),NULL,NULL,NULL);
658
684
                if (rc != SQLITE_OK) {
720
746
                        throw dbexception(db);
721
747
                }
722
748
        } else {
723
 
                std::string insert = prepare_query("INSERT INTO rss_item (guid,title,author,url,feedurl,pubDate,content,unread,enclosure_url,enclosure_type,enqueued,flags) "
724
 
                                                                                "VALUES ('%q','%q','%q','%q','%q','%u','%q',1,'%q','%q',%d, '%q')",
 
749
                std::string insert = prepare_query("INSERT INTO rss_item (guid,title,author,url,feedurl,pubDate,content,unread,enclosure_url,enclosure_type,enqueued,flags,base) "
 
750
                                                                                "VALUES ('%q','%q','%q','%q','%q','%u','%q','%d','%q','%q',%d, '%q', '%q')",
725
751
                                                                                item->guid().c_str(), item->title_raw().c_str(), item->author_raw().c_str(), 
726
 
                                                                                item->link().c_str(), feedurl.c_str(), item->pubDate_timestamp(), item->description_raw().c_str(),
727
 
                                                                                item->enclosure_url().c_str(), item->enclosure_type().c_str(), item->enqueued() ? 1 : 0, item->flags().c_str());
 
752
                                                                                item->link().c_str(), feedurl.c_str(), item->pubDate_timestamp(), item->description_raw().c_str(), item->unread() ? 1 : 0,
 
753
                                                                                item->enclosure_url().c_str(), item->enclosure_type().c_str(), item->enqueued() ? 1 : 0, item->flags().c_str(), 
 
754
                                                                                item->get_base().c_str());
728
755
                LOG(LOG_DEBUG,"running query: %s", insert.c_str());
729
756
                rc = sqlite3_exec(db,insert.c_str(),NULL,NULL,NULL);
730
757
                if (rc != SQLITE_OK) {
757
784
                        throw dbexception(db);
758
785
                }
759
786
        } else {
760
 
                std::string insert = prepare_query("INSERT INTO rss_item (guid,title,author,url,feedurl,pubDate,content,unread,enclosure_url,enclosure_type,enqueued,flags) "
761
 
                                                                                "VALUES ('%q','%q','%q','%q','%q','%u','%q',1,'%q','%q',%d, '%q')",
 
787
                std::string insert = prepare_query("INSERT INTO rss_item (guid,title,author,url,feedurl,pubDate,content,unread,enclosure_url,enclosure_type,enqueued,flags,base) "
 
788
                                                                                "VALUES ('%q','%q','%q','%q','%q','%u','%q','%d','%q','%q',%d, '%q', '%q')",
762
789
                                                                                item->guid().c_str(), item->title_raw().c_str(), item->author_raw().c_str(), 
763
 
                                                                                item->link().c_str(), feedurl.c_str(), item->pubDate_timestamp(), item->description_raw().c_str(),
764
 
                                                                                item->enclosure_url().c_str(), item->enclosure_type().c_str(), item->enqueued() ? 1 : 0, item->flags().c_str());
 
790
                                                                                item->link().c_str(), feedurl.c_str(), item->pubDate_timestamp(), item->description_raw().c_str(), (item->unread() ? 1 : 0),
 
791
                                                                                item->enclosure_url().c_str(), item->enclosure_type().c_str(), item->enqueued() ? 1 : 0, item->flags().c_str(),
 
792
                                                                                item->get_base().c_str());
765
793
                LOG(LOG_DEBUG,"running query: %s", insert.c_str());
766
794
                rc = sqlite3_exec(db,insert.c_str(),NULL,NULL,NULL);
767
795
                if (rc != SQLITE_OK) {