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