rec10/trunk/src/dbMySQL.py

   1 #!/usr/bin/python
   2 # coding: UTF-8
   3 # Rec10 TS Recording Tools
   4 # Copyright (C) 2009-2010 Yukikaze
   5 import MySQLdb
   6 import recdblist
   7 import warnings
   8
   9 from decimal import Decimal
  10 class DB_MySQL:
  11     dbname = ""
  12     dbhost = ""
  13     dbusr = ""
  14     dbpasswd = ""
  15     dbport = 0
  16     def __init__(self, dbname, user, passwd, host="localhost", port=3306):
  17         warnings.filterwarnings('ignore', "Data truncated for column")
  18         self.dbname = dbname
  19         self.dbhost = host
  20         self.dbusr = user
  21         self.dbpasswd = passwd
  22         self.dbport = port
  23         try:
  24             con = MySQLdb.connect(user=user, passwd=passwd)
  25             cur = con.cursor()
  26             cur.execute('CREATE DATABASE ' + dbname + " DEFAULT CHARACTER SET utf8")
  27             cur.close()
  28             con.close()
  29         except:
  30             ""
  31         db = self.connect_db()
  32         try:
  33             db[1].execute('\
  34             CREATE TABLE timeline \
  35             (\
  36             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
  37             type VARCHAR(40),\
  38             chtxt VARCHAR(40),\
  39             title VARCHAR(100),\
  40             btime DATETIME,\
  41             etime DATETIME,\
  42             deltatime VARCHAR(5),\
  43             deltaday VARCHAR(5),\
  44             opt VARCHAR(20),\
  45             epgtitle VARCHAR(100),\
  46             epgbtime DATETIME,\
  47             epgetime DATETIME,\
  48             epgduplicate TINYINT DEFAULT 0,\
  49             epgchange TINYINT DEFAULT 0\
  50             epgexp VARCHAR(200),\
  51             counter TINYINT DEFAULT -1\
  52             UNIQUE uni (type,chtxt,title,btime,deltaday)\
  53             )')
  54         except:
  55             ""
  56         self.close_db(db)
  57         self.new_epg_timeline("")
  58         self.new_in_timeline_log()
  59         self.new_in_auto_bayes_key()
  60         self.new_in_auto_jbk_key()
  61         self.new_in_status()
  62         self.new_in_settings()
  63         self.new_auto_timeline_bayes()
  64         self.new_auto_timeline_keyword()
  65     def connect_db(self):
  66         """
  67         dbへの接続
  68         """
  69         con = MySQLdb.connect(db=self.dbname, host=self.dbhost, port=self.dbport, user=self.dbusr, passwd=self.dbpasswd, charset="utf8")
  70         cur = con.cursor()
  71         cur.execute('set names utf8;')
  72         return [con, cur]
  73     def close_db(self, db):
  74         db[1].close()
  75         db[0].close()
  76     def new_epg_ch(self):
  77         db = self.connect_db()
  78         try:
  79             db[1].execute('drop table epg_ch')
  80         except:
  81             ""
  82         try:
  83             db[1].execute('\
  84             CREATE TABLE epg_ch \
  85             (\
  86             bctype VARCHAR(15),\
  87             ontv VARCHAR(30) PRIMARY KEY,\
  88             chtxt VARCHAR(20),\
  89             ch VARCHAR(20),\
  90             csch VARCHAR(20),\
  91             chname VARCHAR(100),\
  92             updatetime DATETIME,\
  93             status TINYINT,\
  94             isshow TINYINT\
  95             )')
  96         except:
  97             ""
  98         self.close_db(db)
  99     def add_epg_ch(self, bctype, ontv, chtxt, ch, csch, updatetime):
 100         db = self.connect_db()
 101         db[1].execute('\
 102         INSERT INTO epg_ch \
 103         VALUES (%s,%s,%s,%s,%s,"",%s,%s,%s)', \
 104                       (bctype, ontv, chtxt, ch, csch, updatetime, "1","1"))
 105         self.close_db(db)
 106     def select_by_ontv_epg_ch(self, ontv):
 107         db = self.connect_db()
 108         dbexe = db[1].execute("\
 109         SELECT bctype,ontv,chtxt,ch,csch,updatetime \
 110         FROM epg_ch \
 111         WHERE ontv = %s", \
 112                               (ontv,))
 113         ret = []
 114         dls = []
 115         if dbexe > 0:
 116             dls = db[1].fetchall()
 117         self.close_db(db)
 118         for dl in dls:
 119             r = list(dl)
 120             r[5] = r[5].strftime("%Y-%m-%d %H:%M:%S")
 121             ret.append(r)
 122         return ret
 123     def select_by_chtxt_epg_ch(self, chtxt):
 124         db = self.connect_db()
 125         dbexe = db[1].execute("\
 126         SELECT bctype,ontv,chtxt,ch,csch,updatetime \
 127         FROM epg_ch \
 128         WHERE chtxt = %s", \
 129                               (chtxt,))
 130         ret = []
 131         dls = []
 132         if dbexe > 0:
 133             dls = db[1].fetchall()
 134         self.close_db(db)
 135         for dl in dls:
 136             r = list(dl)
 137             r[5] = r[5].strftime("%Y-%m-%d %H:%M:%S")
 138             ret.append(r)
 139         return ret
 140     def select_by_bctype_epg_ch(self, bctype):
 141         db = self.connect_db()
 142         dbexe = db[1].execute("\
 143         SELECT bctype,ontv,chtxt,ch,csch,updatetime,status \
 144         FROM epg_ch \
 145         WHERE bctype = %s", \
 146                               (bctype,))
 147         ret = []
 148         dls = []
 149         if dbexe > 0:
 150             dls = db[1].fetchall()
 151         self.close_db(db)
 152         for dl in dls:
 153             #recdblist.printutf8(dl)
 154             r = list(dl)
 155             r[5] = r[5].strftime("%Y-%m-%d %H:%M:%S")
 156             r[6] = str(r[6])
 157             ret.append(r)
 158         return ret
 159     def select_by_ch_epg_ch(self, ch):
 160         db = self.connect_db()
 161         dbexe = db[1].execute("\
 162         SELECT \
 163         bctype,ontv,chtxt,ch,csch,updatetime \
 164         FROM epg_ch \
 165         WHERE ch = %s", \
 166                               (ch,))
 167         ret = []
 168         dls = []
 169         if dbexe > 0:
 170             dls = db[1].fetchall()
 171         self.close_db(db)
 172         for dl in dls:
 173             r = list(dl)
 174             r[5] = r[5].strftime("%Y-%m-%d %H:%M:%S")
 175             ret.append(r)
 176         return ret
 177     def select_all_epg_ch(self):
 178         db = self.connect_db()
 179         dbexe = db[1].execute("\
 180         SELECT bctype,ontv,chtxt,ch,csch,updatetime \
 181         FROM epg_ch \
 182         ")
 183         ret = []
 184         dls = []
 185         if dbexe > 0:
 186             dls = db[1].fetchall()
 187         self.close_db(db)
 188         for dl in dls:
 189             r = list(dl)
 190             r[5] = r[5].strftime("%Y-%m-%d %H:%M:%S")
 191             ret.append(r)
 192         return ret
 193     def set_new_status(self,dhour):
 194         db = self.connect_db()
 195         dbexe = db[1].execute("UPDATE epg_ch \
 196         SET status = 1 \
 197         WHERE \
 198         ( \
 199         updatetime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR) \
 200         AND \
 201         status = 0 \
 202         )"\
 203         )
 204     def select_get_update_epg_ch(self, dhour):
 205         db = self.connect_db()
 206         dbexe = db[1].execute("SELECT bctype,chtxt,status FROM epg_ch \
 207         WHERE (\
 208         ( \
 209         updatetime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR) \
 210         AND \
 211         status = 1 \
 212         ) \
 213         OR \
 214         status > 1 )\
 215         ORDER BY status DESC")
 216         ret = []
 217         #recdblist.printutf8(dbexe)
 218         if dbexe > 0:
 219             ret = db[1].fetchall()
 220         self.close_db(db)
 221         return ret
 222     def update_by_bctype_epg_ch(self, bctype):
 223         db = self.connect_db()
 224         db[1].execute("\
 225         UPDATE epg_ch \
 226         SET \
 227         updatetime=now() , \
 228         status = 1 \
 229         WHERE bctype = %s", (bctype,))
 230         self.close_db(db)
 231     def update_by_bctype_and_chtxt_epg_ch(self, bctype, chtxt):
 232         db = self.connect_db()
 233         db[1].execute("\
 234         UPDATE epg_ch \
 235         SET \
 236         updatetime=now() , \
 237         status = 1\
 238         WHERE bctype = %s AND chtxt = %s", (bctype, chtxt))
 239         self.close_db(db)
 240     def update_status_by_bctype_epg_ch(self, bctype, status):
 241         db = self.connect_db()
 242         db[1].execute("\
 243         UPDATE epg_ch \
 244         SET \
 245         status=%s , \
 246         updatetime=now() \
 247         WHERE bctype = %s", \
 248                       (status, bctype)\
 249                       )
 250         self.close_db(db)
 251     def update_chname_by_ontv_epg_ch(self,ontv,chname):
 252         db = self.connect_db()
 253         db[1].execute("\
 254         UPDATE epg_ch \
 255         SET \
 256         chname=%s \
 257         WHERE ontv = %s", \
 258                       (chname, ontv)\
 259                       )
 260         self.close_db(db)
 261     def add_auto_proc_tmp(self,type,title,chtxt):
 262         db = self.connect_db()
 263         db[1].execute('\
 264         INSERT IGNORE into auto_proc_tmp \
 265         (type,title,chtxt) \
 266         values (%s,%s,%s)',(type,title,chtxt))
 267         ##db.commit()
 268         self.close_db(db)
 269     def new_auto_proc_tmp(self):
 270         db = self.connect_db()
 271         try:
 272             db[1].execute('drop table auto_proc_tmp')
 273         except:
 274             ""
 275         try:
 276             db[1].execute('\
 277             CREATE TABLE auto_proc_tmp \
 278             (\
 279             type VARCHAR(20),\
 280             title VARCHAR(100) PRIMARY KEY,\
 281             chtxt VARCHAR(30),\
 282             UNIQUE unibayeskey(title)\
 283             )')
 284         except:
 285             ""
 286         self.close_db(db)
 287     def update_auto_proc(self):
 288         db = self.connect_db()
 289         try:
 290             db[1].execute('INSERT INTO auto_proc SELECT * FROM auto_proc_tmp')
 291         except:
 292             ""
 293         self.close_db(db)
 294     def new_auto_proc(self):
 295         db = self.connect_db()
 296         try:
 297             db[1].execute('drop table auto_proc')
 298         except:
 299             ""
 300         try:
 301             db[1].execute('\
 302             CREATE TABLE auto_proc \
 303             (\
 304             type VARCHAR(20),\
 305             title VARCHAR(100) PRIMARY KEY,\
 306             chtxt VARCHAR(30),\
 307             UNIQUE unibayeskey(title)\
 308             )')
 309         except:
 310             ""
 311         self.close_db(db)
 312     def add_auto_proc(self,type,title,chtxt):
 313         db = self.connect_db()
 314         db[1].execute('\
 315         INSERT IGNORE into auto_proc \
 316         (type,title,chtxt) \
 317         values (%s,%s,%s)',(type,title,chtxt))
 318         ##db.commit()
 319         self.close_db(db)
 320     def drop_in_settings(self):
 321         db = self.connect_db()
 322         try:
 323             db[1].execute('drop table in_settings')
 324         except:
 325             ""
 326         self.close_db(db)
 327     def new_in_settings(self):
 328         db = self.connect_db()
 329         try:
 330             db[1].execute('\
 331             CREATE TABLE in_settings \
 332             (\
 333             auto_jbk TINYINT,\
 334             auto_bayes TINYINT,\
 335             auto_opt VARCHAR(20),\
 336             auto_del_tmp TINYINT\
 337             )')
 338             db[1].execute("INSERT IGNORE into in_settings VALUE (0,0,\"H\",1)")
 339         except:
 340             ""
 341         self.close_db(db)
 342     def select_all_in_settings(self):
 343         db = self.connect_db()
 344         dbexe = db[1].execute("\
 345         SELECT auto_jbk,auto_bayes,auto_del_tmp,auto_opt \
 346         FROM in_settings \
 347         ")
 348         ret = []
 349         dls = []
 350         if dbexe > 0:
 351             dls = db[1].fetchall()
 352         self.close_db(db)
 353         for dl in dls:
 354             r = list(dl)
 355             r[0]=str(r[0])
 356             r[1]=str(r[1])
 357             r[2]=str(r[2])
 358             r[3]=r[3]
 359             ret.append(r)
 360         return ret
 361     def add_in_timeline_log(self , chtxt="", title="", btime="", etime="", opt="", exp="", longexp="", category=""):
 362         db = self.connect_db()
 363         db[1].execute('\
 364         INSERT IGNORE into in_timeline_log \
 365         (chtxt,title,btime,etime,opt,exp,longexp,category) \
 366         values (%s,%s,%s,%s,%s,%s,%s,%s)', \
 367                       ( chtxt, title, btime, etime, opt,exp,longexp,category))
 368         ##db.commit()
 369         self.close_db(db)
 370     def del_in_timeline_log(self, title="", chtxt="", btime=""):
 371         """
 372
 373         """
 374         db = self.connect_db()
 375         db[1].execute("\
 376         DELETE FROM in_timeline_log \
 377         WHERE title = %s AND chtxt = %s AND btime = %s", \
 378                       (title, chtxt, btime))
 379         #db.commit()
 380         self.close_db(db)
 381     def new_in_timeline_log(self):
 382         db = self.connect_db()
 383         try:
 384             db[1].execute('\
 385             CREATE TABLE in_timeline_log \
 386             (\
 387             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
 388             chtxt VARCHAR(20),\
 389             title VARCHAR(100),\
 390             btime DATETIME,\
 391             etime DATETIME,\
 392             opt VARCHAR(20),\
 393             exp VARCHAR(200),\
 394             longexp TEXT,\
 395             category VARCHAR(100),\
 396             UNIQUE uni (chtxt,title,btime,category)\
 397             )')
 398         except:
 399             ""
 400         self.close_db(db)
 401     def select_chtxt_by_title_timeline_log(self,title):
 402         db = self.connect_db()
 403         dbexe = db[1].execute("\
 404         SELECT chtxt \
 405         FROM in_timeline_log \
 406         WHERE title LIKE \"%"+title+"%\"\
 407         GROUP by chtxt\
 408         ORDER by sum(1) DESC limit 1")
 409         retdb=db[1].fetchall()
 410         ret=""
 411         if ret!=None:
 412             if len(retdb)>0:
 413                 ret=retdb[0][0]
 414         self.close_db(db)
 415         return ret
 416     def add_timeline(self, type="", chtxt="", title="", btime="", etime="", deltatime="", deltaday="", opt="" ,counter=-1):
 417         db = self.connect_db()
 418         db[1].execute('\
 419         INSERT IGNORE into timeline \
 420         (type,chtxt,title,btime,etime,deltatime,deltaday,opt,counter) \
 421         values (%s,%s,%s,%s,%s,%s,%s,%s,%s)', \
 422                       (type, chtxt, title, btime, etime, deltatime, deltaday, opt ,counter))
 423         ##db.commit()
 424         self.close_db(db)
 425     def update_epg_timeline(self,type,chtxt,title,btime,epgbtime,epgetime,epgtitle,epgexp):
 426         db = self.connect_db()
 427         db[1].execute('\
 428         UPDATE timeline \
 429         SET epgbtime=%s,epgetime=%s,epgtitle=%s,epgexp=%s \
 430         WHERE type=%s AND chtxt=%s AND title=%s AND btime=%s ', \
 431                       (epgbtime,epgetime,epgtitle,epgexp,type, chtxt, title, btime))
 432         ##db.commit()
 433         self.close_db(db)
 434     def update_status_change_timeline(self,type,chtxt,title,btime,epgchange):
 435         db = self.connect_db()
 436         db[1].execute('\
 437         UPDATE timeline \
 438         SET epgchange =%s \
 439         WHERE type=%s AND chtxt=%s AND title=%s AND btime=%s ', \
 440                       (epgchange , type, chtxt, title, btime))
 441         ##db.commit()
 442         self.close_db(db)
 443     def update_status_dup_timeline(self,type,chtxt,title,btime,epgduplicate):
 444         db = self.connect_db()
 445         db[1].execute('\
 446         UPDATE timeline \
 447         SET epgduplicate =%s \
 448         WHERE type=%s AND chtxt=%s AND title=%s AND btime=%s ', \
 449                       (epgduplicate , type, chtxt, title, btime))
 450         ##db.commit()
 451         self.close_db(db)
 452     def del_timeline(self, type="", title="", chtxt="", btime=""):
 453         """
 454
 455         """
 456         db = self.connect_db()
 457         db[1].execute("\
 458         DELETE FROM timeline \
 459         WHERE type = %s AND title = %s AND chtxt = %s AND btime = %s", \
 460                       (type, title, chtxt, btime))
 461         #db.commit()
 462         self.close_db(db)
 463     def select_all_timeline(self):
 464         db = self.connect_db()
 465         recdata = []
 466         dbr = db[1].execute("\
 467         SELECT type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange ,counter\
 468         FROM timeline")
 469         dbl = db[1].fetchall()
 470         self.close_db(db)
 471         if dbr > 0:
 472             recdata = self.getdic_timeline(dbl)
 473         return recdata
 474     def select_bytime_timeline(self, dminutes):
 475         db = self.connect_db()
 476         recdatum = []
 477         #dbr=db[1].execute("SELECT type, chtxt, title, btime, etime, deltatime ,deltaday ,opt FROM rectime WHERE btime < DATE_SUB(now(),INTERVAL "+dminutes+" MINUTE ) AND btime > DATE_ADD(now(),INTERVAL "+dminutes+" MINUTE )")
 478         dbr = db[1].execute("SELECT \
 479         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange ,counter\
 480         FROM timeline \
 481         WHERE btime BETWEEN DATE_SUB(now(),INTERVAL " + dminutes + " MINUTE ) AND \
 482         DATE_ADD(now(),INTERVAL " + dminutes + " MINUTE )")
 483         dbl = db[1].fetchall()
 484         self.close_db(db)
 485         #recdblist.printutf8(dbl)
 486         if dbr > 0:
 487             recdatum = self.getdic_timeline(dbl)
 488         return recdatum
 489     def select_by_name_time_timeline(self,title,btime,btime2):
 490         db = self.connect_db()
 491         recdatum = []
 492         #dbr=db[1].execute("SELECT type, chtxt, title, btime, etime, deltatime ,deltaday ,opt FROM rectime WHERE btime < DATE_SUB(now(),INTERVAL "+dminutes+" MINUTE ) AND btime > DATE_ADD(now(),INTERVAL "+dminutes+" MINUTE )")
 493         dbr = db[1].execute("SELECT \
 494         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange ,counter\
 495         FROM timeline \
 496         WHERE btime > %s AND \
 497         btime < %s AND title = %s",(btime,btime2,title))
 498         dbl = db[1].fetchall()
 499         self.close_db(db)
 500         #recdblist.printutf8(dbl)
 501         if dbr > 0:
 502             recdatum = self.getdic_timeline(dbl)
 503         return recdatum
 504     def select_bytime_all_timeline(self,btime,etime):
 505         db = self.connect_db()
 506         recdatum = []
 507         #dbr=db[1].execute("SELECT type, chtxt, title, btime, etime, deltatime ,deltaday ,opt FROM rectime WHERE btime < DATE_SUB(now(),INTERVAL "+dminutes+" MINUTE ) AND btime > DATE_ADD(now(),INTERVAL "+dminutes+" MINUTE )")
 508         dbr = db[1].execute("SELECT \
 509         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange ,counter\
 510         FROM timeline \
 511         WHERE btime > %s AND \
 512         etime < %s",(btime,etime))
 513         dbl = db[1].fetchall()
 514         self.close_db(db)
 515         #recdblist.printutf8(dbl)
 516         if dbr > 0:
 517             recdatum = self.getdic_timeline(dbl)
 518         return recdatum
 519     def select_byepgtime_all_timeline(self,epgbtime,epgetime):
 520         db = self.connect_db()
 521         recdatum = []
 522         #dbr=db[1].execute("SELECT type, chtxt, title, btime, etime, deltatime ,deltaday ,opt FROM rectime WHERE btime < DATE_SUB(now(),INTERVAL "+dminutes+" MINUTE ) AND btime > DATE_ADD(now(),INTERVAL "+dminutes+" MINUTE )")
 523         dbr = db[1].execute("SELECT \
 524         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange ,counter\
 525         FROM timeline \
 526         WHERE epgbtime >= %s AND \
 527         epgetime <= %s",(epgbtime,epgetime))
 528         dbl = db[1].fetchall()
 529         self.close_db(db)
 530         #recdblist.printutf8(dbl)
 531         if dbr > 0:
 532             recdatum=self.getdic_timeline(dbl)
 533         return recdatum
 534     def select_byepgtime_over_timeline(self,epgbtime,epgetime):
 535         db = self.connect_db()
 536         recdatum = []
 537         #dbr=db[1].execute("SELECT type, chtxt, title, btime, etime, deltatime ,deltaday ,opt FROM rectime WHERE btime < DATE_SUB(now(),INTERVAL "+dminutes+" MINUTE ) AND btime > DATE_ADD(now(),INTERVAL "+dminutes+" MINUTE )")
 538         dbr = db[1].execute("SELECT \
 539         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange ,counter\
 540         FROM timeline \
 541         WHERE (NOT(( timeline.epgetime <= %s )OR( timeline.epgbtime >= %s )))"\
 542         ,(epgbtime,epgetime))
 543         dbl = db[1].fetchall()
 544         self.close_db(db)
 545         #recdblist.printutf8(dbl)
 546         if dbr > 0:
 547             recdatum=self.getdic_timeline(dbl)
 548         return recdatum
 549     def count_schedule_timeline(self, btime, etime):
 550         """
 551         count rectasknum
 552         return [te num,bs/cs num]
 553         """
 554         db = self.connect_db()
 555         dbexe = "SELECT type,epg_ch.bctype,timeline.chtxt,title FROM timeline INNER JOIN epg_ch ON timeline.chtxt=epg_ch.chtxt"
 556         dbexe = dbexe + " WHERE ((NOT(( timeline.etime <= %s )OR( timeline.btime >= %s ))) OR ((timeline.btime = %s) AND (timeline.etime = %s) ) )"
 557         Srec = 0
 558         Trec = 0
 559         db[1].execute(dbexe, (btime, etime,btime,etime))
 560         dbl=db[1].fetchall()
 561         for typet, bctypet, chtxtt, titlet in dbl:
 562             if (typet == recdblist.REC_RESERVE) or (typet == recdblist.REC_FINAL_RESERVE) or (typet == recdblist.REC_KEYWORD) or (typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS):
 563                 if bctypet.find("cs") > -1:
 564                     Srec = Srec + 1
 565                 elif bctypet.find("bs") > -1:
 566                     Srec = Srec + 1
 567                 elif bctypet.find("te") > -1:
 568                     Trec = Trec + 1
 569         self.close_db(db)
 570         return [Trec, Srec]
 571     def search_schedule_timeline(self,btime,etime):
 572         """
 573         count rectasknum
 574         return [(type,bctype,chtxt,title,btime,etime)]
 575         """
 576         db = self.connect_db()
 577         dbexe = "SELECT type,epg_ch.bctype,timeline.chtxt,title,timeline.btime,timeline.etime FROM timeline INNER JOIN epg_ch ON timeline.chtxt=epg_ch.chtxt"
 578         dbexe = dbexe + " WHERE ((NOT(( timeline.etime <= %s )OR( timeline.btime >= %s ))) OR ((timeline.btime = %s) AND (timeline.etime = %s) ) )"
 579         ret=[]
 580         db[1].execute(dbexe, (btime, etime,btime,etime))
 581         dbl=db[1].fetchall()
 582         for typet, bctypet, chtxtt, titlet , btimet, etimet in dbl:
 583             if (typet == recdblist.REC_RESERVE) or (typet == recdblist.REC_FINAL_RESERVE) or (typet == recdblist.REC_KEYWORD) or (typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS):
 584                 ret.append([typet,bctypet,chtxtt,titlet,btimet,etimet])
 585         self.close_db(db)
 586         return ret
 587     def count_epgschedule_timeline(self, epgbtime, epgetime):
 588         """
 589         count rectasknum
 590         return [te num,bs/cs num]
 591         """
 592         db = self.connect_db()
 593         dbexe = "SELECT type,epg_ch.bctype,timeline.chtxt,title FROM timeline INNER JOIN epg_ch ON timeline.chtxt=epg_ch.chtxt"
 594         dbexe = dbexe + " WHERE (NOT(( timeline.epgetime <= %s )OR( timeline.epgbtime >= %s )))"
 595         Srec = 0
 596         Trec = 0
 597         db[1].execute(dbexe, (epgbtime, epgetime))
 598         dbl=db[1].fetchall()
 599         for typet, bctypet, chtxtt, titlet in dbl:
 600             if (typet == recdblist.REC_RESERVE) or (typet == recdblist.REC_FINAL_RESERVE) or (typet == recdblist.REC_KEYWORD) or (typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS):
 601                 if bctypet.find("cs") > -1:
 602                     Srec = Srec + 1
 603                 elif bctypet.find("bs") > -1:
 604                     Srec = Srec + 1
 605                 elif bctypet.find("te") > -1:
 606                     Trec = Trec + 1
 607         self.close_db(db)
 608         return [Trec, Srec]
 609     def search_epgschedule_timeline(self,epgbtime,epgetime):
 610         """
 611         count rectasknum
 612         return [(type,bctype,chtxt,title,btime,etime)]
 613         """
 614         db = self.connect_db()
 615         dbexe = "SELECT type,epg_ch.bctype,timeline.chtxt,title,timeline.btime,timeline.etime FROM timeline INNER JOIN epg_ch ON timeline.chtxt=epg_ch.chtxt"
 616         dbexe = dbexe + " WHERE ((NOT(( timeline.epgetime <= %s )OR( timeline.epgbtime >= %s ))) OR ((timeline.epgbtime = %s) AND (timeline.epgetime = %s) ) )"
 617         ret=[]
 618         db[1].execute(dbexe, (epgbtime, epgetime,epgbtime,epgetime))
 619         dbl=db[1].fetchall()
 620         for typet, bctypet, chtxtt, titlet , btimet, etimet in dbl:
 621             if (typet == recdblist.REC_RESERVE) or (typet == recdblist.REC_FINAL_RESERVE) or (typet == recdblist.REC_KEYWORD) or (typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS):
 622                 ret.append([typet,bctypet,chtxtt,titlet,btimet,etimet])
 623         self.close_db(db)
 624         return ret
 625     def select_bytime_bychtxt_all_timeline(self,btime,etime,chtxt):
 626         db = self.connect_db()
 627         recdatum = []
 628         #dbr=db[1].execute("SELECT type, chtxt, title, btime, etime, deltatime ,deltaday ,opt FROM rectime WHERE btime < DATE_SUB(now(),INTERVAL "+dminutes+" MINUTE ) AND btime > DATE_ADD(now(),INTERVAL "+dminutes+" MINUTE )")
 629         dbr = db[1].execute("SELECT \
 630         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange ,counter\
 631         FROM timeline \
 632         WHERE btime > %s AND \
 633         etime < %s\
 634         AND chtxt=%s ",(btime,etime,chtxt))
 635         dbl = db[1].fetchall()
 636         self.close_db(db)
 637         #recdblist.printutf8(dbl)
 638         if dbr > 0:
 639             recdatum = self.getdic_timeline(dbl)
 640         return recdatum
 641     def getdic_timeline(self,timelinelists):
 642         recdatum=[]
 643         for typet, chtxt, title, btime, etime, deltatime, deltaday, opt ,epgbtimet , epgetimet ,epgtitlet ,epgduplicatet ,epgchanget ,countert in timelinelists:
 644             ret = {}
 645             ret['type'] = typet
 646             ret['chtxt'] = chtxt
 647             ret['title'] = title
 648             btime = btime.strftime("%Y-%m-%d %H:%M:%S")
 649             etime = etime.strftime("%Y-%m-%d %H:%M:%S")
 650             ret['btime'] = btime
 651             ret['etime'] = etime
 652             ret['opt'] = opt
 653             try:
 654                 ret['epgbtime'] = epgbtimet.strftime("%Y-%m-%d %H:%M:%S")
 655                 ret['epgetime'] = epgetimet.strftime("%Y-%m-%d %H:%M:%S")
 656             except:
 657                 ret['epgbtime'] = "2010-01-01 00:00:00"
 658                 ret['epgetime'] = "2010-01-01 00:00:00"
 659             ret['epgtitle'] = epgtitlet
 660             ret['epgduplicate'] = epgduplicatet
 661             ret['epgchange'] = epgchanget
 662             if deltatime == None or deltatime == "":
 663                 deltatime = "3"
 664             if deltaday == None or deltaday == "":
 665                 deltaday = "7"
 666             if typet == recdblist.REC_KEYWORD:
 667                 ret['deltatime'] = deltatime
 668             elif typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS:
 669                 ret['deltatime'] = deltatime
 670                 ret['deltaday'] = deltaday
 671             try:
 672                 ret['counter'] = int(countert)
 673             except:
 674                 ret['counter']=-1
 675             recdatum.append(ret)
 676         return recdatum
 677     def delete_old_timeline(self, dhour):
 678         db = self.connect_db()
 679         db[1].execute("\
 680         DELETE FROM timeline \
 681         WHERE \
 682         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
 683         #db.commit()
 684         self.close_db(db)
 685     def new_in_auto_jbk_key(self):
 686         db = self.connect_db()
 687         try:
 688             db[1].execute("\
 689             CREATE TABLE in_auto_jbk_key \
 690             (\
 691             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
 692             keyword VARCHAR(200),\
 693             UNIQUE unijbk (keyword)\
 694             )")
 695         except:
 696             ""
 697         self.close_db(db)
 698     def add_in_auto_jbk_key(self,key):
 699         db = self.connect_db()
 700         db[1].execute('\
 701         INSERT IGNORE into in_auto_jbk_key \
 702         (keyword) \
 703         values (%s)', \
 704                       (key,))
 705         ##db.commit()
 706         self.close_db(db)
 707     def select_all_in_auto_jbk_key(self):
 708         db = self.connect_db()
 709         dbexe = db[1].execute("\
 710         SELECT keyword \
 711         FROM in_auto_jbk_key \
 712         ")
 713         ret = []
 714         if dbexe > 0:
 715             ret = db[1].fetchall()
 716         self.close_db(db)
 717         return ret
 718     def drop_in_status(self):
 719         db = self.connect_db()
 720         try:
 721             db[1].execute('drop table in_status')
 722         except:
 723             ""
 724         self.close_db(db)
 725     def new_in_status(self):
 726         db = self.connect_db()
 727         try:
 728             db[1].execute("\
 729             CREATE TABLE in_status \
 730             (\
 731             ts2avi TINYINT DEFAULT 0,\
 732             terec TINYINT DEFAULT 0,\
 733             bscsrec TINYINT DEFAULT 0,\
 734             b252ts TINYINT DEFAULT 0,\
 735             installed TINYINT DEFAULT 0,\
 736             version TINYINT\
 737             )")
 738             db[1].execute("INSERT IGNORE into in_status VALUE (0,0,0,0,0)")
 739         except:
 740             ""
 741         self.close_db(db)
 742     def select_all_in_status(self):
 743         db = self.connect_db()
 744         dbexe = db[1].execute("\
 745         SELECT ts2avi,terec,bscsrec,b252ts \
 746         FROM in_status \
 747         ")
 748         ret = []
 749         dls = []
 750         if dbexe > 0:
 751             dls = db[1].fetchall()
 752         self.close_db(db)
 753         for dl in dls:
 754             r = list(dl)
 755             r[0]=str(r[0])
 756             r[1]=str(r[1])
 757             r[2]=str(r[2])
 758             r[3]=str(r[3])
 759             ret.append(r)
 760         return ret
 761     def select_version_in_status(self):
 762         db = self.connect_db()
 763         version=0
 764         try:
 765             dbexe = db[1].execute("\
 766             SELECT version \
 767             FROM in_status \
 768             ")
 769             if dbexe > 0:
 770                 dls = db[1].fetchall()
 771             self.close_db(db)
 772             for dl in dls:
 773                 r = list(dl)
 774                 version=int(str(r[0]))
 775         except:
 776             ""
 777         return version
 778     def change_version_in_status(self,version):
 779         db = self.connect_db()
 780         db[1].execute("\
 781         UPDATE in_status SET version=%s",str(version))
 782         self.close_db(db)
 783     def change_ts2avi_in_status(self,i):
 784         """
 785         statuをiだけ増減する
 786         iはint
 787         """
 788         db = self.connect_db()
 789         db[1].execute("\
 790         UPDATE in_status SET ts2avi=ts2avi+%s",i)
 791         self.close_db(db)
 792     def change_terec_in_status(self,i):
 793         """
 794         statuをiだけ増減する
 795         iはint
 796         """
 797         db = self.connect_db()
 798         db[1].execute("\
 799         UPDATE in_status SET terec=terec+%s",i)
 800         self.close_db(db)
 801     def change_bscsrec_in_status(self,i):
 802         """
 803         statuをiだけ増減する
 804         iはint
 805         """
 806         db = self.connect_db()
 807         db[1].execute("\
 808         UPDATE in_status SET bscsrec=bscsrec+%s",i)
 809         self.close_db(db)
 810     def change_b252ts_in_status(self,i):
 811         """
 812         statuをiだけ増減する
 813         iはint
 814         """
 815         db = self.connect_db()
 816         db[1].execute("\
 817         UPDATE in_status SET b252ts=b252ts+%s",i)
 818         self.close_db(db)
 819     def select_installed_in_status(self):
 820         db = self.connect_db()
 821         dbexe = db[1].execute("\
 822         SELECT ts2avi,terec,bscsrec,b252ts,installed \
 823         FROM in_status \
 824         ")
 825         ret = 0
 826         dls = []
 827         if dbexe > 0:
 828             dls = db[1].fetchall()
 829         self.close_db(db)
 830         for dl in dls:
 831             r = list(dl)
 832             ret=r[4]
 833         return ret
 834     def change_installed_in_status(self):
 835         """
 836         installedを設定する
 837         """
 838         db = self.connect_db()
 839         db[1].execute("\
 840         UPDATE in_status SET installed=1")
 841         self.close_db(db)
 842     def new_epg_timeline(self, bctype):
 843         db = self.connect_db()
 844         try:
 845             db[1].execute("\
 846             DELETE FROM epg_timeline \
 847             WHERE bctype = %s", \
 848                           (bctype,))
 849         except:
 850             ""
 851         try:
 852             db[1].execute("\
 853             CREATE TABLE epg_timeline \
 854             (\
 855             bctype VARCHAR(20),\
 856             channel VARCHAR(100) NOT NULL,\
 857             start VARCHAR(30),\
 858             stop  VARCHAR(30),\
 859             title VARCHAR(100),\
 860             exp VARCHAR(200),\
 861             longexp TEXT,\
 862             category VARCHAR(100),\
 863             UNIQUE unitv(bctype,channel,start,stop,title)\
 864             )")
 865         except:
 866             ""
 867         #db.commit()
 868         self.close_db(db)
 869     def add_epg_timeline(self, bctype, channel, start, stop, title, desc,longdesc, category):
 870         db = self.connect_db()
 871         db[1].execute('\
 872         INSERT IGNORE INTO epg_timeline \
 873         VALUES (%s,%s,%s,%s,%s,%s,%s,%s)', \
 874                       (bctype, channel, start, stop, title, desc,longdesc,category))
 875         #db.commit()
 876         self.close_db(db)
 877     def add_multi_epg_timeline(self, tvlists):
 878         """
 879         tvlists is (bctype,channel,start,stop,title,desc,longdesc,category) lists.
 880         """
 881         db = self.connect_db()
 882         db[1].executemany('\
 883         INSERT IGNORE INTO epg_timeline \
 884         (bctype,channel,start,stop,title,exp,longexp,category) \
 885         values(%s,%s,%s,%s,%s,%s,%s,%s)', \
 886                           tvlists)
 887         self.close_db(db)
 888     def select_by_time_ngram_epg_timeline(self, btime, etime, chtxt):
 889         db = self.connect_db()
 890         dbexe = "\
 891         SELECT \
 892         epg_ch.chtxt,title,start,stop,exp,longexp,category \
 893         FROM epg_timeline \
 894         INNER JOIN epg_ch \
 895         WHERE epg_ch.ontv=epg_timeline.channel \
 896         AND \
 897         start >= %s \
 898         AND \
 899         start <= %s \
 900         AND \
 901         epg_ch.chtxt=%s"
 902         dbcmd = db[1].execute(dbexe, (btime, etime, chtxt))
 903         retall = []
 904         if dbcmd > 0:
 905             retall = db[1].fetchall()
 906         self.close_db(db)
 907         return retall
 908     def select_by_time_keyword_auto_suggest_epg_timeline(self,keyword,btime,etime):
 909         db = self.connect_db()
 910         dbexe = "\
 911         SELECT \
 912         epg_ch.chtxt,title,start,stop,exp,longexp,category \
 913         FROM epg_timeline \
 914         INNER JOIN epg_ch \
 915         WHERE epg_ch.ontv=epg_timeline.channel \
 916         AND \
 917         start >= %s \
 918         AND \
 919         stop <= %s \
 920         AND \
 921         ( \
 922         ( title LIKE \'%%"+keyword+"%%\' ) \
 923         OR \
 924         ( exp LIKE \'%%"+keyword+"%%\' ) \
 925         OR \
 926         ( longexp LIKE \'%%"+keyword+"%%\' ) \
 927         )"
 928         dbcmd = db[1].execute(dbexe,(btime, etime))
 929         retall = []
 930         if dbcmd > 0:
 931             retall = db[1].fetchall()
 932         self.close_db(db)
 933         return retall
 934     def new_in_auto_bayes_key(self):
 935         db = self.connect_db()
 936         try:
 937             db[1].execute('CREATE TABLE in_auto_bayes_key \
 938             (\
 939             keychar VARCHAR(10),\
 940             chtxt VARCHAR(20),\
 941             ratio_rec DECIMAL(32,14),\
 942             ratio_all DECIMAL(32,14),\
 943             UNIQUE unibayeskey(keychar,chtxt)\
 944             )')
 945             db[1].execute('CREATE INDEX keycharindex ON in_auto_bayes_key(keychar)')
 946         except:
 947             ""
 948         self.close_db(db)
 949
 950     def add_in_auto_bayes_key(self,key,chtxt,ratio_rec,ratio_all):
 951         db = self.connect_db()
 952         ratio_rec=str(ratio_rec)
 953         ratio_all=str(ratio_all)
 954         db[1].execute('\
 955         INSERT IGNORE INTO in_auto_bayes_key \
 956         (keychar,chtxt,ratio_rec,ratio_all) \
 957         values (%s,%s,%s,%s)',\
 958         (key,chtxt,ratio_rec,ratio_all))
 959         self.close_db(db)
 960     def add_num_in_auto_bayes_key(self,chtxt,add_rec_num,add_all_num):
 961         db = self.connect_db()
 962         add_rec_num=str(add_rec_num)
 963         add_all_num=str(add_all_num)
 964         db[1].execute("\
 965         UPDATE in_auto_bayes_key SET ratio_rec=CONVERT(ratio_rec+%s,DECIMAL(32,14)),ratio_all=CONVERT(ratio_all+%s,DECIMAL(32,14)) WHERE keychar=\"NUM\" AND chtxt=%s",\
 966         (add_rec_num,add_all_num,chtxt))
 967         self.close_db(db)
 968     def change_in_auto_bayes_key(self,key,chtxt,new_ratio_rec,new_ratio_all):
 969         """
 970         """
 971         db = self.connect_db()
 972         db[1].execute("\
 973         UPDATE in_auto_bayes_key SET ratio_rec=%s,ratio_all=%s WHERE keychar=%s AND chtxt=%s",(str(new_ratio_rec),str(new_ratio_all),key,chtxt)\
 974         )
 975         self.close_db(db)
 976     def change_ratio_all_reduce_in_auto_bayes_key(self,chtxt,beforenum,newnum):
 977         beforenum=str(beforenum)
 978         newnum=str(newnum)
 979         db = self.connect_db()
 980         db[1].execute("\
 981         UPDATE in_auto_bayes_key SET ratio_all=CONVERT(ratio_all*%s/(%s+%s),DECIMAL(32,14)) WHERE chtxt=%s AND NOT (keychar=\"NUM\")",(beforenum,newnum,beforenum,chtxt)\
 982         )
 983         self.close_db(db)
 984     def change_ratio_all_in_auto_bayes_key(self,key,chtxt,beforenum,addnum):
 985         db = self.connect_db()
 986         beforenumf=beforenum
 987         beforenum=str(beforenum)
 988         db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
 989         VALUES (%s,%s,%s,%s)\
 990         ON DUPLICATE KEY UPDATE \
 991         ratio_all=CONVERT((ratio_all*%s+%s)/%s,DECIMAL(32,14))",(key,chtxt,"0",str(Decimal(addnum)/beforenumf),beforenum,chtxt,key))
 992         self.close_db(db)
 993     def change_multi_ratio_all_in_auto_bayes_key(self,chtxt,beforenum,list):
 994         """
 995         list={key:addnum}のリスト
 996         """
 997         beforenumf=beforenum
 998         beforenum=str(beforenum)
 999         db = self.connect_db()
1000         for i,j in list.items():
1001             retl=(i,chtxt,"0",str(Decimal(j)/beforenumf),beforenum,str(j),beforenum)
1002             try:
1003                 db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
1004                 VALUES (%s,%s,%s,%s)\
1005                 ON DUPLICATE KEY UPDATE \
1006                 ratio_all=CONVERT((ratio_all*%s+%s)/%s,DECIMAL(32,14))",retl)
1007             except:
1008                 ""
1009         self.close_db(db)
1010     def change_ratio_rec_reduce_in_auto_bayes_key(self,chtxt,beforenum,newnum):
1011         beforenum=str(beforenum)
1012         newnum=str(newnum)
1013         db = self.connect_db()
1014         db[1].execute("\
1015         UPDATE in_auto_bayes_key SET ratio_rec=CONVERT(ratio_rec*%s/(%s+%s),DECIMAL(32,14)) WHERE chtxt=%s AND NOT (keychar=\"NUM\")",(beforenum,newnum,beforenum,chtxt)\
1016         )
1017         self.close_db(db)
1018     def change_ratio_rec_in_auto_bayes_key(self,key,chtxt,beforenum,addnum):
1019         db = self.connect_db()
1020         beforenumf=beforenum
1021         beforenum=str(beforenum)
1022         db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
1023         VALUES (%s,%s,%s,%s)\
1024         ON DUPLICATE KEY UPDATE \
1025         ratio_rec=CONVERT((ratio_rec*%s+%s)/%s,DECIMAL(32,14))",(key,chtxt,str(Decimal(addnum)/beforenumf),"0",beforenum,chtxt,key))
1026         self.close_db(db)
1027     def change_multi_ratio_rec_in_auto_bayes_key(self,chtxt,beforenum,list):#self,key,chtxt,beforenum,addnum):
1028         beforenumf=beforenum
1029         beforenum=str(beforenum)
1030         db = self.connect_db()
1031         for i,j in list.items():
1032             retl=(i,chtxt,str(Decimal(j)/beforenumf),"0",beforenum,str(j),beforenum)
1033             try:
1034                 db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
1035                 VALUES (%s,%s,%s,%s)\
1036                 ON DUPLICATE KEY UPDATE \
1037                 ratio_rec=CONVERT((ratio_rec*%s+%s)/%s,DECIMAL(32,14))",retl)
1038             except:
1039                 ""
1040         self.close_db(db)
1041     def select_by_key_in_auto_bayes_key(self,key,chtxt):
1042         db = self.connect_db()
1043         dbexe = db[1].execute("\
1044         SELECT keychar,chtxt,ratio_rec,ratio_all \
1045         FROM in_auto_bayes_key \
1046         WHERE keychar = %s AND chtxt = %s", \
1047                               (key,chtxt))
1048         dls = []
1049         if dbexe > 0:
1050             dls = db[1].fetchall()
1051         self.close_db(db)
1052         if len(dls)>0:
1053             return dls[0]
1054         else:
1055             return dls
1056     def new_auto_timeline_keyword(self):
1057         db = self.connect_db()
1058         try:
1059             db[1].execute('\
1060             CREATE TABLE auto_timeline_keyword \
1061             (\
1062             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
1063             chtxt VARCHAR(40),\
1064             title VARCHAR(100),\
1065             btime DATETIME,\
1066             etime DATETIME,\
1067             UNIQUE uni (chtxt,title,btime,etime)\
1068             )')
1069         except:
1070             ""
1071     def add_auto_timeline_keyword(self,chtxt="", title="", btime="", etime=""):
1072         db = self.connect_db()
1073         db[1].execute('\
1074         INSERT IGNORE into auto_timeline_keyword \
1075         (chtxt,title,btime,etime) \
1076         values (%s,%s,%s,%s)', \
1077                        (chtxt, title, btime, etime))
1078         ##db.commit()
1079         self.close_db(db)
1080     def delete_old_auto_timeline_keyword(self, dhour):
1081         db = self.connect_db()
1082         db[1].execute("\
1083         DELETE FROM auto_timeline_keyword \
1084         WHERE \
1085         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
1086         self.close_db(db)
1087     def new_auto_timeline_bayes(self):
1088         db = self.connect_db()
1089         try:
1090             db[1].execute('\
1091             CREATE TABLE auto_timeline_bayes \
1092             (\
1093             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
1094             chtxt VARCHAR(40),\
1095             title VARCHAR(100),\
1096             btime DATETIME,\
1097             etime DATETIME,\
1098             point INT,\
1099             UNIQUE uni (chtxt,title,btime,etime)\
1100             )')
1101         except:
1102             ""
1103     def add_auto_timeline_bayes(self,chtxt="", title="", btime="", etime="",point=""):
1104         db = self.connect_db()
1105         db[1].execute('\
1106         INSERT IGNORE into auto_timeline_bayes \
1107         (chtxt,title,btime,etime,point) \
1108         values (%s,%s,%s,%s,%s)', \
1109                       (chtxt, title, btime, etime,point))
1110         self.close_db(db)
1111     def delete_old_auto_timeline_bayes(self, dhour):
1112         db = self.connect_db()
1113         db[1].execute("\
1114         DELETE FROM auto_timeline_bayes \
1115         WHERE \
1116         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
1117         self.close_db(db)
1118     def update_db_to93(self):
1119         db = self.connect_db()
1120         self.drop_in_settings()
1121         self.new_in_settings()
1122         db[1].execute("\
1123         ALTER TABLE timeline ADD epgtitle VARCHAR(100),\
1124         ADD epgbtime DATETIME,\
1125         ADD epgetime DATETIME,\
1126         ADD epgduplicate TINYINT DEFAULT 0,\
1127         ADD epgchange TINYINT DEFAULT 0")
1128         db[1].execute("\
1129         ALTER TABLE in_status ADD version TINYINT")
1130         self.close_db(db)
1131         self.change_version_in_status("93")
1132     def update_db_93to94(self):
1133         db = self.connect_db()
1134         self.drop_in_settings()
1135         self.new_in_settings()
1136         db[1].execute("\
1137         ALTER TABLE timeline ADD counter TINYINT DEFAULT -1")
1138         self.close_db(db)
1139         self.change_version_in_status("94")
1140     def update_db_94to95(self):
1141         db = self.connect_db()
1142         self.drop_in_settings()
1143         self.new_in_settings()
1144         db[1].execute("\
1145         ALTER TABLE timeline ADD epgexp VARCHAR(200)")
1146         self.close_db(db)
1147         self.change_version_in_status("95")
1148     def update_db_95to96(self):
1149         db = self.connect_db()
1150         self.drop_in_settings()
1151         self.new_in_settings()
1152         self.close_db(db)
1153         self.change_version_in_status("96")