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             try:
 671                 ret['counter'] = int(countert)
 672             except:
 673                 ret['counter']=-1
 674             recdatum.append(ret)
 675         return recdatum
 676     def delete_old_timeline(self, dhour):
 677         db = self.connect_db()
 678         db[1].execute("\
 679         DELETE FROM timeline \
 680         WHERE \
 681         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
 682         #db.commit()
 683         self.close_db(db)
 684     def new_in_auto_jbk_key(self):
 685         db = self.connect_db()
 686         try:
 687             db[1].execute("\
 688             CREATE TABLE in_auto_jbk_key \
 689             (\
 690             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
 691             keyword VARCHAR(200),\
 692             UNIQUE unijbk (keyword)\
 693             )")
 694         except:
 695             ""
 696         self.close_db(db)
 697     def add_in_auto_jbk_key(self,key):
 698         db = self.connect_db()
 699         db[1].execute('\
 700         INSERT IGNORE into in_auto_jbk_key \
 701         (keyword) \
 702         values (%s)', \
 703                       (key,))
 704         ##db.commit()
 705         self.close_db(db)
 706     def select_all_in_auto_jbk_key(self):
 707         db = self.connect_db()
 708         dbexe = db[1].execute("\
 709         SELECT keyword \
 710         FROM in_auto_jbk_key \
 711         ")
 712         ret = []
 713         if dbexe > 0:
 714             ret = db[1].fetchall()
 715         self.close_db(db)
 716         return ret
 717     def drop_in_status(self):
 718         db = self.connect_db()
 719         try:
 720             db[1].execute('drop table in_status')
 721         except:
 722             ""
 723         self.close_db(db)
 724     def new_in_status(self):
 725         db = self.connect_db()
 726         try:
 727             db[1].execute("\
 728             CREATE TABLE in_status \
 729             (\
 730             ts2avi TINYINT DEFAULT 0,\
 731             terec TINYINT DEFAULT 0,\
 732             bscsrec TINYINT DEFAULT 0,\
 733             b252ts TINYINT DEFAULT 0,\
 734             installed TINYINT DEFAULT 0,\
 735             version TINYINT\
 736             )")
 737             db[1].execute("INSERT IGNORE into in_status VALUE (0,0,0,0,0)")
 738         except:
 739             ""
 740         self.close_db(db)
 741     def select_all_in_status(self):
 742         db = self.connect_db()
 743         dbexe = db[1].execute("\
 744         SELECT ts2avi,terec,bscsrec,b252ts \
 745         FROM in_status \
 746         ")
 747         ret = []
 748         dls = []
 749         if dbexe > 0:
 750             dls = db[1].fetchall()
 751         self.close_db(db)
 752         for dl in dls:
 753             r = list(dl)
 754             r[0]=str(r[0])
 755             r[1]=str(r[1])
 756             r[2]=str(r[2])
 757             r[3]=str(r[3])
 758             ret.append(r)
 759         return ret
 760     def select_version_in_status(self):
 761         db = self.connect_db()
 762         version=0
 763         try:
 764             dbexe = db[1].execute("\
 765             SELECT version \
 766             FROM in_status \
 767             ")
 768             if dbexe > 0:
 769                 dls = db[1].fetchall()
 770             self.close_db(db)
 771             for dl in dls:
 772                 r = list(dl)
 773                 version=int(str(r[0]))
 774         except:
 775             ""
 776         return version
 777     def change_version_in_status(self,version):
 778         db = self.connect_db()
 779         db[1].execute("\
 780         UPDATE in_status SET version=%s",str(version))
 781         self.close_db(db)
 782     def change_ts2avi_in_status(self,i):
 783         """
 784         statuをiだけ増減する
 785         iはint
 786         """
 787         db = self.connect_db()
 788         db[1].execute("\
 789         UPDATE in_status SET ts2avi=ts2avi+%s",i)
 790         self.close_db(db)
 791     def change_terec_in_status(self,i):
 792         """
 793         statuをiだけ増減する
 794         iはint
 795         """
 796         db = self.connect_db()
 797         db[1].execute("\
 798         UPDATE in_status SET terec=terec+%s",i)
 799         self.close_db(db)
 800     def change_bscsrec_in_status(self,i):
 801         """
 802         statuをiだけ増減する
 803         iはint
 804         """
 805         db = self.connect_db()
 806         db[1].execute("\
 807         UPDATE in_status SET bscsrec=bscsrec+%s",i)
 808         self.close_db(db)
 809     def change_b252ts_in_status(self,i):
 810         """
 811         statuをiだけ増減する
 812         iはint
 813         """
 814         db = self.connect_db()
 815         db[1].execute("\
 816         UPDATE in_status SET b252ts=b252ts+%s",i)
 817         self.close_db(db)
 818     def select_installed_in_status(self):
 819         db = self.connect_db()
 820         dbexe = db[1].execute("\
 821         SELECT ts2avi,terec,bscsrec,b252ts,installed \
 822         FROM in_status \
 823         ")
 824         ret = 0
 825         dls = []
 826         if dbexe > 0:
 827             dls = db[1].fetchall()
 828         self.close_db(db)
 829         for dl in dls:
 830             r = list(dl)
 831             ret=r[4]
 832         return ret
 833     def change_installed_in_status(self):
 834         """
 835         installedを設定する
 836         """
 837         db = self.connect_db()
 838         db[1].execute("\
 839         UPDATE in_status SET installed=1")
 840         self.close_db(db)
 841     def new_epg_timeline(self, bctype):
 842         db = self.connect_db()
 843         try:
 844             db[1].execute("\
 845             DELETE FROM epg_timeline \
 846             WHERE bctype = %s", \
 847                           (bctype,))
 848         except:
 849             ""
 850         try:
 851             db[1].execute("\
 852             CREATE TABLE epg_timeline \
 853             (\
 854             bctype VARCHAR(20),\
 855             channel VARCHAR(100) NOT NULL,\
 856             start VARCHAR(30),\
 857             stop  VARCHAR(30),\
 858             title VARCHAR(100),\
 859             exp VARCHAR(200),\
 860             longexp TEXT,\
 861             category VARCHAR(100),\
 862             UNIQUE unitv(bctype,channel,start,stop,title)\
 863             )")
 864         except:
 865             ""
 866         #db.commit()
 867         self.close_db(db)
 868     def add_epg_timeline(self, bctype, channel, start, stop, title, desc,longdesc, category):
 869         db = self.connect_db()
 870         db[1].execute('\
 871         INSERT IGNORE INTO epg_timeline \
 872         VALUES (%s,%s,%s,%s,%s,%s,%s,%s)', \
 873                       (bctype, channel, start, stop, title, desc,longdesc,category))
 874         #db.commit()
 875         self.close_db(db)
 876     def add_multi_epg_timeline(self, tvlists):
 877         """
 878         tvlists is (bctype,channel,start,stop,title,desc,longdesc,category) lists.
 879         """
 880         db = self.connect_db()
 881         db[1].executemany('\
 882         INSERT IGNORE INTO epg_timeline \
 883         (bctype,channel,start,stop,title,exp,longexp,category) \
 884         values(%s,%s,%s,%s,%s,%s,%s,%s)', \
 885                           tvlists)
 886         self.close_db(db)
 887     def select_by_time_ngram_epg_timeline(self, btime, etime, chtxt):
 888         db = self.connect_db()
 889         dbexe = "\
 890         SELECT \
 891         epg_ch.chtxt,title,start,stop,exp,longexp,category \
 892         FROM epg_timeline \
 893         INNER JOIN epg_ch \
 894         WHERE epg_ch.ontv=epg_timeline.channel \
 895         AND \
 896         start >= %s \
 897         AND \
 898         start <= %s \
 899         AND \
 900         epg_ch.chtxt=%s"
 901         dbcmd = db[1].execute(dbexe, (btime, etime, chtxt))
 902         retall = []
 903         if dbcmd > 0:
 904             retall = db[1].fetchall()
 905         self.close_db(db)
 906         return retall
 907     def select_by_time_keyword_auto_suggest_epg_timeline(self,keyword,btime,etime):
 908         db = self.connect_db()
 909         dbexe = "\
 910         SELECT \
 911         epg_ch.chtxt,title,start,stop,exp,longexp,category \
 912         FROM epg_timeline \
 913         INNER JOIN epg_ch \
 914         WHERE epg_ch.ontv=epg_timeline.channel \
 915         AND \
 916         start >= %s \
 917         AND \
 918         stop <= %s \
 919         AND \
 920         ( \
 921         ( title LIKE \'%%"+keyword+"%%\' ) \
 922         OR \
 923         ( exp LIKE \'%%"+keyword+"%%\' ) \
 924         OR \
 925         ( longexp LIKE \'%%"+keyword+"%%\' ) \
 926         )"
 927         dbcmd = db[1].execute(dbexe,(btime, etime))
 928         retall = []
 929         if dbcmd > 0:
 930             retall = db[1].fetchall()
 931         self.close_db(db)
 932         return retall
 933     def new_in_auto_bayes_key(self):
 934         db = self.connect_db()
 935         try:
 936             db[1].execute('CREATE TABLE in_auto_bayes_key \
 937             (\
 938             keychar VARCHAR(10),\
 939             chtxt VARCHAR(20),\
 940             ratio_rec DECIMAL(32,14),\
 941             ratio_all DECIMAL(32,14),\
 942             UNIQUE unibayeskey(keychar,chtxt)\
 943             )')
 944             db[1].execute('CREATE INDEX keycharindex ON in_auto_bayes_key(keychar)')
 945         except:
 946             ""
 947         self.close_db(db)
 948
 949     def add_in_auto_bayes_key(self,key,chtxt,ratio_rec,ratio_all):
 950         db = self.connect_db()
 951         ratio_rec=str(ratio_rec)
 952         ratio_all=str(ratio_all)
 953         db[1].execute('\
 954         INSERT IGNORE INTO in_auto_bayes_key \
 955         (keychar,chtxt,ratio_rec,ratio_all) \
 956         values (%s,%s,%s,%s)',\
 957         (key,chtxt,ratio_rec,ratio_all))
 958         self.close_db(db)
 959     def add_num_in_auto_bayes_key(self,chtxt,add_rec_num,add_all_num):
 960         db = self.connect_db()
 961         add_rec_num=str(add_rec_num)
 962         add_all_num=str(add_all_num)
 963         db[1].execute("\
 964         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",\
 965         (add_rec_num,add_all_num,chtxt))
 966         self.close_db(db)
 967     def change_in_auto_bayes_key(self,key,chtxt,new_ratio_rec,new_ratio_all):
 968         """
 969         """
 970         db = self.connect_db()
 971         db[1].execute("\
 972         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)\
 973         )
 974         self.close_db(db)
 975     def change_ratio_all_reduce_in_auto_bayes_key(self,chtxt,beforenum,newnum):
 976         beforenum=str(beforenum)
 977         newnum=str(newnum)
 978         db = self.connect_db()
 979         db[1].execute("\
 980         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)\
 981         )
 982         self.close_db(db)
 983     def change_ratio_all_in_auto_bayes_key(self,key,chtxt,beforenum,addnum):
 984         db = self.connect_db()
 985         beforenumf=beforenum
 986         beforenum=str(beforenum)
 987         db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
 988         VALUES (%s,%s,%s,%s)\
 989         ON DUPLICATE KEY UPDATE \
 990         ratio_all=CONVERT((ratio_all*%s+%s)/%s,DECIMAL(32,14))",(key,chtxt,"0",str(Decimal(addnum)/beforenumf),beforenum,chtxt,key))
 991         self.close_db(db)
 992     def change_multi_ratio_all_in_auto_bayes_key(self,chtxt,beforenum,list):
 993         """
 994         list={key:addnum}のリスト
 995         """
 996         beforenumf=beforenum
 997         beforenum=str(beforenum)
 998         db = self.connect_db()
 999         for i,j in list.items():
1000             retl=(i,chtxt,"0",str(Decimal(j)/beforenumf),beforenum,str(j),beforenum)
1001             try:
1002                 db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
1003                 VALUES (%s,%s,%s,%s)\
1004                 ON DUPLICATE KEY UPDATE \
1005                 ratio_all=CONVERT((ratio_all*%s+%s)/%s,DECIMAL(32,14))",retl)
1006             except:
1007                 ""
1008         self.close_db(db)
1009     def change_ratio_rec_reduce_in_auto_bayes_key(self,chtxt,beforenum,newnum):
1010         beforenum=str(beforenum)
1011         newnum=str(newnum)
1012         db = self.connect_db()
1013         db[1].execute("\
1014         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)\
1015         )
1016         self.close_db(db)
1017     def change_ratio_rec_in_auto_bayes_key(self,key,chtxt,beforenum,addnum):
1018         db = self.connect_db()
1019         beforenumf=beforenum
1020         beforenum=str(beforenum)
1021         db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
1022         VALUES (%s,%s,%s,%s)\
1023         ON DUPLICATE KEY UPDATE \
1024         ratio_rec=CONVERT((ratio_rec*%s+%s)/%s,DECIMAL(32,14))",(key,chtxt,str(Decimal(addnum)/beforenumf),"0",beforenum,chtxt,key))
1025         self.close_db(db)
1026     def change_multi_ratio_rec_in_auto_bayes_key(self,chtxt,beforenum,list):#self,key,chtxt,beforenum,addnum):
1027         beforenumf=beforenum
1028         beforenum=str(beforenum)
1029         db = self.connect_db()
1030         for i,j in list.items():
1031             retl=(i,chtxt,str(Decimal(j)/beforenumf),"0",beforenum,str(j),beforenum)
1032             try:
1033                 db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
1034                 VALUES (%s,%s,%s,%s)\
1035                 ON DUPLICATE KEY UPDATE \
1036                 ratio_rec=CONVERT((ratio_rec*%s+%s)/%s,DECIMAL(32,14))",retl)
1037             except:
1038                 ""
1039         self.close_db(db)
1040     def select_by_key_in_auto_bayes_key(self,key,chtxt):
1041         db = self.connect_db()
1042         dbexe = db[1].execute("\
1043         SELECT keychar,chtxt,ratio_rec,ratio_all \
1044         FROM in_auto_bayes_key \
1045         WHERE keychar = %s AND chtxt = %s", \
1046                               (key,chtxt))
1047         dls = []
1048         if dbexe > 0:
1049             dls = db[1].fetchall()
1050         self.close_db(db)
1051         if len(dls)>0:
1052             return dls[0]
1053         else:
1054             return dls
1055     def new_auto_timeline_keyword(self):
1056         db = self.connect_db()
1057         try:
1058             db[1].execute('\
1059             CREATE TABLE auto_timeline_keyword \
1060             (\
1061             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
1062             chtxt VARCHAR(40),\
1063             title VARCHAR(100),\
1064             btime DATETIME,\
1065             etime DATETIME,\
1066             UNIQUE uni (chtxt,title,btime,etime)\
1067             )')
1068         except:
1069             ""
1070     def add_auto_timeline_keyword(self,chtxt="", title="", btime="", etime=""):
1071         db = self.connect_db()
1072         db[1].execute('\
1073         INSERT IGNORE into auto_timeline_keyword \
1074         (chtxt,title,btime,etime) \
1075         values (%s,%s,%s,%s)', \
1076                        (chtxt, title, btime, etime))
1077         ##db.commit()
1078         self.close_db(db)
1079     def delete_old_auto_timeline_keyword(self, dhour):
1080         db = self.connect_db()
1081         db[1].execute("\
1082         DELETE FROM auto_timeline_keyword \
1083         WHERE \
1084         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
1085         self.close_db(db)
1086     def new_auto_timeline_bayes(self):
1087         db = self.connect_db()
1088         try:
1089             db[1].execute('\
1090             CREATE TABLE auto_timeline_bayes \
1091             (\
1092             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
1093             chtxt VARCHAR(40),\
1094             title VARCHAR(100),\
1095             btime DATETIME,\
1096             etime DATETIME,\
1097             point INT,\
1098             UNIQUE uni (chtxt,title,btime,etime)\
1099             )')
1100         except:
1101             ""
1102     def add_auto_timeline_bayes(self,chtxt="", title="", btime="", etime="",point=""):
1103         db = self.connect_db()
1104         db[1].execute('\
1105         INSERT IGNORE into auto_timeline_bayes \
1106         (chtxt,title,btime,etime,point) \
1107         values (%s,%s,%s,%s,%s)', \
1108                       (chtxt, title, btime, etime,point))
1109         self.close_db(db)
1110     def delete_old_auto_timeline_bayes(self, dhour):
1111         db = self.connect_db()
1112         db[1].execute("\
1113         DELETE FROM auto_timeline_bayes \
1114         WHERE \
1115         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
1116         self.close_db(db)
1117     def update_db_to93(self):
1118         db = self.connect_db()
1119         self.drop_in_settings()
1120         self.new_in_settings()
1121         db[1].execute("\
1122         ALTER TABLE timeline ADD epgtitle VARCHAR(100),\
1123         ADD epgbtime DATETIME,\
1124         ADD epgetime DATETIME,\
1125         ADD epgduplicate TINYINT DEFAULT 0,\
1126         ADD epgchange TINYINT DEFAULT 0")
1127         db[1].execute("\
1128         ALTER TABLE in_status ADD version TINYINT")
1129         self.close_db(db)
1130         self.change_version_in_status("93")
1131     def update_db_93to94(self):
1132         db = self.connect_db()
1133         self.drop_in_settings()
1134         self.new_in_settings()
1135         db[1].execute("\
1136         ALTER TABLE timeline ADD counter TINYINT DEFAULT -1")
1137         self.close_db(db)
1138         self.change_version_in_status("94")