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