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