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