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         db = self.connect_db()
 417         db[1].execute('\
 418         INSERT IGNORE into timeline \
 419         (type,chtxt,title,btime,etime,deltatime,deltaday,opt,counter) \
 420         values (%s,%s,%s,%s,%s,%s,%s,%s,%s)', \
 421                       (type, chtxt, title, btime, etime, deltatime, deltaday, opt ,counter))
 422         ##db.commit()
 423         self.close_db(db)
 424     def update_epg_timeline(self,type,chtxt,title,btime,epgbtime,epgetime,epgtitle):
 425         db = self.connect_db()
 426         db[1].execute('\
 427         UPDATE timeline \
 428         SET epgbtime=%s,epgetime=%s,epgtitle=%s \
 429         WHERE type=%s AND chtxt=%s AND title=%s AND btime=%s ', \
 430                       (epgbtime,epgetime,epgtitle,type, chtxt, title, btime))
 431         ##db.commit()
 432         self.close_db(db)
 433     def update_status_change_timeline(self,type,chtxt,title,btime,epgchange):
 434         db = self.connect_db()
 435         db[1].execute('\
 436         UPDATE timeline \
 437         SET epgchange =%s \
 438         WHERE type=%s AND chtxt=%s AND title=%s AND btime=%s ', \
 439                       (epgchange , type, chtxt, title, btime))
 440         ##db.commit()
 441         self.close_db(db)
 442     def update_status_dup_timeline(self,type,chtxt,title,btime,epgduplicate):
 443         db = self.connect_db()
 444         db[1].execute('\
 445         UPDATE timeline \
 446         SET epgduplicate =%s \
 447         WHERE type=%s AND chtxt=%s AND title=%s AND btime=%s ', \
 448                       (epgduplicate , type, chtxt, title, btime))
 449         ##db.commit()
 450         self.close_db(db)
 451     def del_timeline(self, type="", title="", chtxt="", btime=""):
 452         """
 453
 454         """
 455         db = self.connect_db()
 456         db[1].execute("\
 457         DELETE FROM timeline \
 458         WHERE type = %s AND title = %s AND chtxt = %s AND btime = %s", \
 459                       (type, title, chtxt, btime))
 460         #db.commit()
 461         self.close_db(db)
 462     def select_all_timeline(self):
 463         db = self.connect_db()
 464         recdata = []
 465         dbr = db[1].execute("\
 466         SELECT type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange ,counter\
 467         FROM timeline")
 468         dbl = db[1].fetchall()
 469         self.close_db(db)
 470         if dbr > 0:
 471             recdata = self.getdic_timeline(dbl)
 472         return recdata
 473     def select_bytime_timeline(self, dminutes):
 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 BETWEEN DATE_SUB(now(),INTERVAL " + dminutes + " MINUTE ) AND \
 481         DATE_ADD(now(),INTERVAL " + dminutes + " MINUTE )")
 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_by_name_time_timeline(self,title,btime,btime2):
 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         btime < %s AND title = %s",(btime,btime2,title))
 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_bytime_all_timeline(self,btime,etime):
 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 btime > %s AND \
 511         etime < %s",(btime,etime))
 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_all_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 epgbtime >= %s AND \
 526         epgetime <= %s",(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 select_byepgtime_over_timeline(self,epgbtime,epgetime):
 534         db = self.connect_db()
 535         recdatum = []
 536         #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 )")
 537         dbr = db[1].execute("SELECT \
 538         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange ,counter\
 539         FROM timeline \
 540         WHERE (NOT(( timeline.epgetime <= %s )OR( timeline.epgbtime >= %s )))"\
 541         ,(epgbtime,epgetime))
 542         dbl = db[1].fetchall()
 543         self.close_db(db)
 544         #recdblist.printutf8(dbl)
 545         if dbr > 0:
 546             recdatum=self.getdic_timeline(dbl)
 547         return recdatum
 548     def count_schedule_timeline(self, btime, etime):
 549         """
 550         count rectasknum
 551         return [te num,bs/cs num]
 552         """
 553         db = self.connect_db()
 554         dbexe = "SELECT type,epg_ch.bctype,timeline.chtxt,title FROM timeline INNER JOIN epg_ch ON timeline.chtxt=epg_ch.chtxt"
 555         dbexe = dbexe + " WHERE ((NOT(( timeline.etime <= %s )OR( timeline.btime >= %s ))) OR ((timeline.btime = %s) AND (timeline.etime = %s) ) )"
 556         Srec = 0
 557         Trec = 0
 558         db[1].execute(dbexe, (btime, etime,btime,etime))
 559         dbl=db[1].fetchall()
 560         for typet, bctypet, chtxtt, titlet in dbl:
 561             if (typet == recdblist.REC_RESERVE) or (typet == recdblist.REC_FINAL_RESERVE) or (typet == recdblist.REC_KEYWORD) or (typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS):
 562                 if bctypet.find("cs") > -1:
 563                     Srec = Srec + 1
 564                 elif bctypet.find("bs") > -1:
 565                     Srec = Srec + 1
 566                 elif bctypet.find("te") > -1:
 567                     Trec = Trec + 1
 568         self.close_db(db)
 569         return [Trec, Srec]
 570     def search_schedule_timeline(self,btime,etime):
 571         """
 572         count rectasknum
 573         return [(type,bctype,chtxt,title,btime,etime)]
 574         """
 575         db = self.connect_db()
 576         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"
 577         dbexe = dbexe + " WHERE ((NOT(( timeline.etime <= %s )OR( timeline.btime >= %s ))) OR ((timeline.btime = %s) AND (timeline.etime = %s) ) )"
 578         ret=[]
 579         db[1].execute(dbexe, (btime, etime,btime,etime))
 580         dbl=db[1].fetchall()
 581         for typet, bctypet, chtxtt, titlet , btimet, etimet in dbl:
 582             if (typet == recdblist.REC_RESERVE) or (typet == recdblist.REC_FINAL_RESERVE) or (typet == recdblist.REC_KEYWORD) or (typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS):
 583                 ret.append([typet,bctypet,chtxtt,titlet,btimet,etimet])
 584         self.close_db(db)
 585         return ret
 586     def count_epgschedule_timeline(self, epgbtime, epgetime):
 587         """
 588         count rectasknum
 589         return [te num,bs/cs num]
 590         """
 591         db = self.connect_db()
 592         dbexe = "SELECT type,epg_ch.bctype,timeline.chtxt,title FROM timeline INNER JOIN epg_ch ON timeline.chtxt=epg_ch.chtxt"
 593         dbexe = dbexe + " WHERE (NOT(( timeline.epgetime <= %s )OR( timeline.epgbtime >= %s )))"
 594         Srec = 0
 595         Trec = 0
 596         db[1].execute(dbexe, (epgbtime, epgetime))
 597         dbl=db[1].fetchall()
 598         for typet, bctypet, chtxtt, titlet in dbl:
 599             if (typet == recdblist.REC_RESERVE) or (typet == recdblist.REC_FINAL_RESERVE) or (typet == recdblist.REC_KEYWORD) or (typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS):
 600                 if bctypet.find("cs") > -1:
 601                     Srec = Srec + 1
 602                 elif bctypet.find("bs") > -1:
 603                     Srec = Srec + 1
 604                 elif bctypet.find("te") > -1:
 605                     Trec = Trec + 1
 606         self.close_db(db)
 607         return [Trec, Srec]
 608     def search_epgschedule_timeline(self,epgbtime,epgetime):
 609         """
 610         count rectasknum
 611         return [(type,bctype,chtxt,title,btime,etime)]
 612         """
 613         db = self.connect_db()
 614         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"
 615         dbexe = dbexe + " WHERE ((NOT(( timeline.epgetime <= %s )OR( timeline.epgbtime >= %s ))) OR ((timeline.epgbtime = %s) AND (timeline.epgetime = %s) ) )"
 616         ret=[]
 617         db[1].execute(dbexe, (epgbtime, epgetime,epgbtime,epgetime))
 618         dbl=db[1].fetchall()
 619         for typet, bctypet, chtxtt, titlet , btimet, etimet in dbl:
 620             if (typet == recdblist.REC_RESERVE) or (typet == recdblist.REC_FINAL_RESERVE) or (typet == recdblist.REC_KEYWORD) or (typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS):
 621                 ret.append([typet,bctypet,chtxtt,titlet,btimet,etimet])
 622         self.close_db(db)
 623         return ret
 624     def select_bytime_bychtxt_all_timeline(self,btime,etime,chtxt):
 625         db = self.connect_db()
 626         recdatum = []
 627         #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 )")
 628         dbr = db[1].execute("SELECT \
 629         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange ,counter\
 630         FROM timeline \
 631         WHERE btime > %s AND \
 632         etime < %s\
 633         AND chtxt=%s ",(btime,etime,chtxt))
 634         dbl = db[1].fetchall()
 635         self.close_db(db)
 636         #recdblist.printutf8(dbl)
 637         if dbr > 0:
 638             recdatum = self.getdic_timeline(dbl)
 639         return recdatum
 640     def getdic_timeline(self,timelinelists):
 641         recdatum=[]
 642         for typet, chtxt, title, btime, etime, deltatime, deltaday, opt ,epgbtimet , epgetimet ,epgtitlet ,epgduplicatet ,epgchanget ,countert in timelinelists:
 643             ret = {}
 644             ret['type'] = typet
 645             ret['chtxt'] = chtxt
 646             ret['title'] = title
 647             btime = btime.strftime("%Y-%m-%d %H:%M:%S")
 648             etime = etime.strftime("%Y-%m-%d %H:%M:%S")
 649             ret['btime'] = btime
 650             ret['etime'] = etime
 651             ret['opt'] = opt
 652             try:
 653                 ret['epgbtime'] = epgbtimet.strftime("%Y-%m-%d %H:%M:%S")
 654                 ret['epgetime'] = epgetimet.strftime("%Y-%m-%d %H:%M:%S")
 655             except:
 656                 ret['epgbtime'] = "2010-01-01 00:00:00"
 657                 ret['epgetime'] = "2010-01-01 00:00:00"
 658             ret['epgtitle'] = epgtitlet
 659             ret['epgduplicate'] = epgduplicatet
 660             ret['epgchange'] = epgchanget
 661             if deltatime == None or deltatime == "":
 662                 deltatime = "3"
 663             if deltaday == None or deltaday == "":
 664                 deltaday = "7"
 665             if typet == recdblist.REC_KEYWORD:
 666                 ret['deltatime'] = deltatime
 667             elif typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS:
 668                 ret['deltatime'] = deltatime
 669                 ret['deltaday'] = deltaday
 670             ret['epgchange'] = int(countert)
 671             recdatum.append(ret)
 672         return recdatum
 673     def delete_old_timeline(self, dhour):
 674         db = self.connect_db()
 675         db[1].execute("\
 676         DELETE FROM timeline \
 677         WHERE \
 678         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
 679         #db.commit()
 680         self.close_db(db)
 681     def new_in_auto_jbk_key(self):
 682         db = self.connect_db()
 683         try:
 684             db[1].execute("\
 685             CREATE TABLE in_auto_jbk_key \
 686             (\
 687             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
 688             keyword VARCHAR(200),\
 689             UNIQUE unijbk (keyword)\
 690             )")
 691         except:
 692             ""
 693         self.close_db(db)
 694     def add_in_auto_jbk_key(self,key):
 695         db = self.connect_db()
 696         db[1].execute('\
 697         INSERT IGNORE into in_auto_jbk_key \
 698         (keyword) \
 699         values (%s)', \
 700                       (key,))
 701         ##db.commit()
 702         self.close_db(db)
 703     def select_all_in_auto_jbk_key(self):
 704         db = self.connect_db()
 705         dbexe = db[1].execute("\
 706         SELECT keyword \
 707         FROM in_auto_jbk_key \
 708         ")
 709         ret = []
 710         if dbexe > 0:
 711             ret = db[1].fetchall()
 712         self.close_db(db)
 713         return ret
 714     def drop_in_status(self):
 715         db = self.connect_db()
 716         try:
 717             db[1].execute('drop table in_status')
 718         except:
 719             ""
 720         self.close_db(db)
 721     def new_in_status(self):
 722         db = self.connect_db()
 723         try:
 724             db[1].execute("\
 725             CREATE TABLE in_status \
 726             (\
 727             ts2avi TINYINT DEFAULT 0,\
 728             terec TINYINT DEFAULT 0,\
 729             bscsrec TINYINT DEFAULT 0,\
 730             b252ts TINYINT DEFAULT 0,\
 731             installed TINYINT DEFAULT 0,\
 732             version TINYINT\
 733             )")
 734             db[1].execute("INSERT IGNORE into in_status VALUE (0,0,0,0,0)")
 735         except:
 736             ""
 737         self.close_db(db)
 738     def select_all_in_status(self):
 739         db = self.connect_db()
 740         dbexe = db[1].execute("\
 741         SELECT ts2avi,terec,bscsrec,b252ts \
 742         FROM in_status \
 743         ")
 744         ret = []
 745         dls = []
 746         if dbexe > 0:
 747             dls = db[1].fetchall()
 748         self.close_db(db)
 749         for dl in dls:
 750             r = list(dl)
 751             r[0]=str(r[0])
 752             r[1]=str(r[1])
 753             r[2]=str(r[2])
 754             r[3]=str(r[3])
 755             ret.append(r)
 756         return ret
 757     def select_version_in_status(self):
 758         db = self.connect_db()
 759         version=0
 760         try:
 761             dbexe = db[1].execute("\
 762             SELECT version \
 763             FROM in_status \
 764             ")
 765             if dbexe > 0:
 766                 dls = db[1].fetchall()
 767             self.close_db(db)
 768             for dl in dls:
 769                 r = list(dl)
 770                 version=int(str(r[0]))
 771         except:
 772             ""
 773         return version
 774     def change_version_in_status(self,version):
 775         db = self.connect_db()
 776         db[1].execute("\
 777         UPDATE in_status SET version=%s",str(version))
 778         self.close_db(db)
 779     def change_ts2avi_in_status(self,i):
 780         """
 781         statuをiだけ増減する
 782         iはint
 783         """
 784         db = self.connect_db()
 785         db[1].execute("\
 786         UPDATE in_status SET ts2avi=ts2avi+%s",i)
 787         self.close_db(db)
 788     def change_terec_in_status(self,i):
 789         """
 790         statuをiだけ増減する
 791         iはint
 792         """
 793         db = self.connect_db()
 794         db[1].execute("\
 795         UPDATE in_status SET terec=terec+%s",i)
 796         self.close_db(db)
 797     def change_bscsrec_in_status(self,i):
 798         """
 799         statuをiだけ増減する
 800         iはint
 801         """
 802         db = self.connect_db()
 803         db[1].execute("\
 804         UPDATE in_status SET bscsrec=bscsrec+%s",i)
 805         self.close_db(db)
 806     def change_b252ts_in_status(self,i):
 807         """
 808         statuをiだけ増減する
 809         iはint
 810         """
 811         db = self.connect_db()
 812         db[1].execute("\
 813         UPDATE in_status SET b252ts=b252ts+%s",i)
 814         self.close_db(db)
 815     def select_installed_in_status(self):
 816         db = self.connect_db()
 817         dbexe = db[1].execute("\
 818         SELECT ts2avi,terec,bscsrec,b252ts,installed \
 819         FROM in_status \
 820         ")
 821         ret = 0
 822         dls = []
 823         if dbexe > 0:
 824             dls = db[1].fetchall()
 825         self.close_db(db)
 826         for dl in dls:
 827             r = list(dl)
 828             ret=r[4]
 829         return ret
 830     def change_installed_in_status(self):
 831         """
 832         installedを設定する
 833         """
 834         db = self.connect_db()
 835         db[1].execute("\
 836         UPDATE in_status SET installed=1")
 837         self.close_db(db)
 838     def new_epg_timeline(self, bctype):
 839         db = self.connect_db()
 840         try:
 841             db[1].execute("\
 842             DELETE FROM epg_timeline \
 843             WHERE bctype = %s", \
 844                           (bctype,))
 845         except:
 846             ""
 847         try:
 848             db[1].execute("\
 849             CREATE TABLE epg_timeline \
 850             (\
 851             bctype VARCHAR(20),\
 852             channel VARCHAR(100) NOT NULL,\
 853             start VARCHAR(30),\
 854             stop  VARCHAR(30),\
 855             title VARCHAR(100),\
 856             exp VARCHAR(200),\
 857             longexp TEXT,\
 858             category VARCHAR(100),\
 859             UNIQUE unitv(bctype,channel,start,stop,title)\
 860             )")
 861         except:
 862             ""
 863         #db.commit()
 864         self.close_db(db)
 865     def add_epg_timeline(self, bctype, channel, start, stop, title, desc,longdesc, category):
 866         db = self.connect_db()
 867         db[1].execute('\
 868         INSERT IGNORE INTO epg_timeline \
 869         VALUES (%s,%s,%s,%s,%s,%s,%s,%s)', \
 870                       (bctype, channel, start, stop, title, desc,longdesc,category))
 871         #db.commit()
 872         self.close_db(db)
 873     def add_multi_epg_timeline(self, tvlists):
 874         """
 875         tvlists is (bctype,channel,start,stop,title,desc,longdesc,category) lists.
 876         """
 877         db = self.connect_db()
 878         db[1].executemany('\
 879         INSERT IGNORE INTO epg_timeline \
 880         (bctype,channel,start,stop,title,exp,longexp,category) \
 881         values(%s,%s,%s,%s,%s,%s,%s,%s)', \
 882                           tvlists)
 883         self.close_db(db)
 884     def select_by_time_ngram_epg_timeline(self, btime, etime, chtxt):
 885         db = self.connect_db()
 886         dbexe = "\
 887         SELECT \
 888         epg_ch.chtxt,title,start,stop,exp,longexp,category \
 889         FROM epg_timeline \
 890         INNER JOIN epg_ch \
 891         WHERE epg_ch.ontv=epg_timeline.channel \
 892         AND \
 893         start >= %s \
 894         AND \
 895         start <= %s \
 896         AND \
 897         epg_ch.chtxt=%s"
 898         dbcmd = db[1].execute(dbexe, (btime, etime, chtxt))
 899         retall = []
 900         if dbcmd > 0:
 901             retall = db[1].fetchall()
 902         self.close_db(db)
 903         return retall
 904     def select_by_time_keyword_auto_suggest_epg_timeline(self,keyword,btime,etime):
 905         db = self.connect_db()
 906         dbexe = "\
 907         SELECT \
 908         epg_ch.chtxt,title,start,stop,exp,longexp,category \
 909         FROM epg_timeline \
 910         INNER JOIN epg_ch \
 911         WHERE epg_ch.ontv=epg_timeline.channel \
 912         AND \
 913         start >= %s \
 914         AND \
 915         stop <= %s \
 916         AND \
 917         ( \
 918         ( title LIKE \'%%"+keyword+"%%\' ) \
 919         OR \
 920         ( exp LIKE \'%%"+keyword+"%%\' ) \
 921         OR \
 922         ( longexp LIKE \'%%"+keyword+"%%\' ) \
 923         )"
 924         dbcmd = db[1].execute(dbexe,(btime, etime))
 925         retall = []
 926         if dbcmd > 0:
 927             retall = db[1].fetchall()
 928         self.close_db(db)
 929         return retall
 930     def new_in_auto_bayes_key(self):
 931         db = self.connect_db()
 932         try:
 933             db[1].execute('CREATE TABLE in_auto_bayes_key \
 934             (\
 935             keychar VARCHAR(10),\
 936             chtxt VARCHAR(20),\
 937             ratio_rec DECIMAL(32,14),\
 938             ratio_all DECIMAL(32,14),\
 939             UNIQUE unibayeskey(keychar,chtxt)\
 940             )')
 941             db[1].execute('CREATE INDEX keycharindex ON in_auto_bayes_key(keychar)')
 942         except:
 943             ""
 944         self.close_db(db)
 945
 946     def add_in_auto_bayes_key(self,key,chtxt,ratio_rec,ratio_all):
 947         db = self.connect_db()
 948         ratio_rec=str(ratio_rec)
 949         ratio_all=str(ratio_all)
 950         db[1].execute('\
 951         INSERT IGNORE INTO in_auto_bayes_key \
 952         (keychar,chtxt,ratio_rec,ratio_all) \
 953         values (%s,%s,%s,%s)',\
 954         (key,chtxt,ratio_rec,ratio_all))
 955         self.close_db(db)
 956     def add_num_in_auto_bayes_key(self,chtxt,add_rec_num,add_all_num):
 957         db = self.connect_db()
 958         add_rec_num=str(add_rec_num)
 959         add_all_num=str(add_all_num)
 960         db[1].execute("\
 961         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",\
 962         (add_rec_num,add_all_num,chtxt))
 963         self.close_db(db)
 964     def change_in_auto_bayes_key(self,key,chtxt,new_ratio_rec,new_ratio_all):
 965         """
 966         """
 967         db = self.connect_db()
 968         db[1].execute("\
 969         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)\
 970         )
 971         self.close_db(db)
 972     def change_ratio_all_reduce_in_auto_bayes_key(self,chtxt,beforenum,newnum):
 973         beforenum=str(beforenum)
 974         newnum=str(newnum)
 975         db = self.connect_db()
 976         db[1].execute("\
 977         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)\
 978         )
 979         self.close_db(db)
 980     def change_ratio_all_in_auto_bayes_key(self,key,chtxt,beforenum,addnum):
 981         db = self.connect_db()
 982         beforenumf=beforenum
 983         beforenum=str(beforenum)
 984         db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
 985         VALUES (%s,%s,%s,%s)\
 986         ON DUPLICATE KEY UPDATE \
 987         ratio_all=CONVERT((ratio_all*%s+%s)/%s,DECIMAL(32,14))",(key,chtxt,"0",str(Decimal(addnum)/beforenumf),beforenum,chtxt,key))
 988         self.close_db(db)
 989     def change_multi_ratio_all_in_auto_bayes_key(self,chtxt,beforenum,list):
 990         """
 991         list={key:addnum}のリスト
 992         """
 993         beforenumf=beforenum
 994         beforenum=str(beforenum)
 995         db = self.connect_db()
 996         for i,j in list.items():
 997             retl=(i,chtxt,"0",str(Decimal(j)/beforenumf),beforenum,str(j),beforenum)
 998             try:
 999                 db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
1000                 VALUES (%s,%s,%s,%s)\
1001                 ON DUPLICATE KEY UPDATE \
1002                 ratio_all=CONVERT((ratio_all*%s+%s)/%s,DECIMAL(32,14))",retl)
1003             except:
1004                 ""
1005         self.close_db(db)
1006     def change_ratio_rec_reduce_in_auto_bayes_key(self,chtxt,beforenum,newnum):
1007         beforenum=str(beforenum)
1008         newnum=str(newnum)
1009         db = self.connect_db()
1010         db[1].execute("\
1011         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)\
1012         )
1013         self.close_db(db)
1014     def change_ratio_rec_in_auto_bayes_key(self,key,chtxt,beforenum,addnum):
1015         db = self.connect_db()
1016         beforenumf=beforenum
1017         beforenum=str(beforenum)
1018         db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
1019         VALUES (%s,%s,%s,%s)\
1020         ON DUPLICATE KEY UPDATE \
1021         ratio_rec=CONVERT((ratio_rec*%s+%s)/%s,DECIMAL(32,14))",(key,chtxt,str(Decimal(addnum)/beforenumf),"0",beforenum,chtxt,key))
1022         self.close_db(db)
1023     def change_multi_ratio_rec_in_auto_bayes_key(self,chtxt,beforenum,list):#self,key,chtxt,beforenum,addnum):
1024         beforenumf=beforenum
1025         beforenum=str(beforenum)
1026         db = self.connect_db()
1027         for i,j in list.items():
1028             retl=(i,chtxt,str(Decimal(j)/beforenumf),"0",beforenum,str(j),beforenum)
1029             try:
1030                 db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
1031                 VALUES (%s,%s,%s,%s)\
1032                 ON DUPLICATE KEY UPDATE \
1033                 ratio_rec=CONVERT((ratio_rec*%s+%s)/%s,DECIMAL(32,14))",retl)
1034             except:
1035                 ""
1036         self.close_db(db)
1037     def select_by_key_in_auto_bayes_key(self,key,chtxt):
1038         db = self.connect_db()
1039         dbexe = db[1].execute("\
1040         SELECT keychar,chtxt,ratio_rec,ratio_all \
1041         FROM in_auto_bayes_key \
1042         WHERE keychar = %s AND chtxt = %s", \
1043                               (key,chtxt))
1044         dls = []
1045         if dbexe > 0:
1046             dls = db[1].fetchall()
1047         self.close_db(db)
1048         if len(dls)>0:
1049             return dls[0]
1050         else:
1051             return dls
1052     def new_auto_timeline_keyword(self):
1053         db = self.connect_db()
1054         try:
1055             db[1].execute('\
1056             CREATE TABLE auto_timeline_keyword \
1057             (\
1058             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
1059             chtxt VARCHAR(40),\
1060             title VARCHAR(100),\
1061             btime DATETIME,\
1062             etime DATETIME,\
1063             UNIQUE uni (chtxt,title,btime,etime)\
1064             )')
1065         except:
1066             ""
1067     def add_auto_timeline_keyword(self,chtxt="", title="", btime="", etime=""):
1068         db = self.connect_db()
1069         db[1].execute('\
1070         INSERT IGNORE into auto_timeline_keyword \
1071         (chtxt,title,btime,etime) \
1072         values (%s,%s,%s,%s)', \
1073                        (chtxt, title, btime, etime))
1074         ##db.commit()
1075         self.close_db(db)
1076     def delete_old_auto_timeline_keyword(self, dhour):
1077         db = self.connect_db()
1078         db[1].execute("\
1079         DELETE FROM auto_timeline_keyword \
1080         WHERE \
1081         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
1082         self.close_db(db)
1083     def new_auto_timeline_bayes(self):
1084         db = self.connect_db()
1085         try:
1086             db[1].execute('\
1087             CREATE TABLE auto_timeline_bayes \
1088             (\
1089             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
1090             chtxt VARCHAR(40),\
1091             title VARCHAR(100),\
1092             btime DATETIME,\
1093             etime DATETIME,\
1094             point INT,\
1095             UNIQUE uni (chtxt,title,btime,etime)\
1096             )')
1097         except:
1098             ""
1099     def add_auto_timeline_bayes(self,chtxt="", title="", btime="", etime="",point=""):
1100         db = self.connect_db()
1101         db[1].execute('\
1102         INSERT IGNORE into auto_timeline_bayes \
1103         (chtxt,title,btime,etime,point) \
1104         values (%s,%s,%s,%s,%s)', \
1105                       (chtxt, title, btime, etime,point))
1106         self.close_db(db)
1107     def delete_old_auto_timeline_bayes(self, dhour):
1108         db = self.connect_db()
1109         db[1].execute("\
1110         DELETE FROM auto_timeline_bayes \
1111         WHERE \
1112         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
1113         self.close_db(db)
1114     def update_db_to93(self):
1115         db = self.connect_db()
1116         self.drop_in_settings()
1117         self.new_in_settings()
1118         db[1].execute("\
1119         ALTER TABLE timeline ADD epgtitle VARCHAR(100),\
1120         ADD epgbtime DATETIME,\
1121         ADD epgetime DATETIME,\
1122         ADD epgduplicate TINYINT DEFAULT 0,\
1123         ADD epgchange TINYINT DEFAULT 0")
1124         db[1].execute("\
1125         ALTER TABLE in_status ADD version TINYINT")
1126         self.close_db(db)
1127         self.change_version_in_status("93")
1128     def update_db_93to94(self):
1129         db = self.connect_db()
1130         self.drop_in_settings()
1131         self.new_in_settings()
1132         db[1].execute("\
1133         ALTER TABLE timeline ADD counter TINYINT DEFAULT -1")
1134         self.close_db(db)
1135         self.change_version_in_status("94")