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