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             modify 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,\"G\",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=""):
 416         db = self.connect_db()
 417         db[1].execute('\
 418         INSERT IGNORE into timeline \
 419         (type,chtxt,title,btime,etime,deltatime,deltaday,opt) \
 420         values (%s,%s,%s,%s,%s,%s,%s,%s)', \
 421                       (type, chtxt, title, btime, etime, deltatime, deltaday, opt))
 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 update_status_modify_timeline(self,type,chtxt,title,btime,modify):
 452         db = self.connect_db()
 453         db[1].execute('\
 454         UPDATE timeline \
 455         SET modify =%s \
 456         WHERE type=%s AND chtxt=%s AND title=%s AND btime=%s ', \
 457                       (epgduplicate , type, chtxt, title, btime))
 458         self.close_db(db)
 459     def del_timeline(self, type="", title="", chtxt="", btime=""):
 460         """
 461
 462         """
 463         db = self.connect_db()
 464         db[1].execute("\
 465         DELETE FROM timeline \
 466         WHERE type = %s AND title = %s AND chtxt = %s AND btime = %s", \
 467                       (type, title, chtxt, btime))
 468         #db.commit()
 469         self.close_db(db)
 470     def select_all_timeline(self):
 471         db = self.connect_db()
 472         recdata = []
 473         dbr = db[1].execute("\
 474         SELECT type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 475         FROM timeline")
 476         dbl = db[1].fetchall()
 477         self.close_db(db)
 478         if dbr > 0:
 479             recdata = self.getdic_timeline(dbl)
 480         return recdata
 481     def select_bytime_timeline(self, dminutes):
 482         db = self.connect_db()
 483         recdatum = []
 484         #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 )")
 485         dbr = db[1].execute("SELECT \
 486         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 487         FROM timeline \
 488         WHERE btime BETWEEN DATE_SUB(now(),INTERVAL " + dminutes + " MINUTE ) AND \
 489         DATE_ADD(now(),INTERVAL " + dminutes + " MINUTE )")
 490         dbl = db[1].fetchall()
 491         self.close_db(db)
 492         #recdblist.printutf8(dbl)
 493         if dbr > 0:
 494             recdatum = self.getdic_timeline(dbl)
 495         return recdatum
 496     def select_by_name_time_timeline(self,title,btime,btime2):
 497         db = self.connect_db()
 498         recdatum = []
 499         #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 )")
 500         dbr = db[1].execute("SELECT \
 501         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 502         FROM timeline \
 503         WHERE btime > %s AND \
 504         btime < %s AND title = %s",(btime,btime2,title))
 505         dbl = db[1].fetchall()
 506         self.close_db(db)
 507         #recdblist.printutf8(dbl)
 508         if dbr > 0:
 509             recdatum = self.getdic_timeline(dbl)
 510         return recdatum
 511     def select_bytime_all_timeline(self,btime,etime):
 512         db = self.connect_db()
 513         recdatum = []
 514         #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 )")
 515         dbr = db[1].execute("SELECT \
 516         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 517         FROM timeline \
 518         WHERE btime > %s AND \
 519         etime < %s",(btime,etime))
 520         dbl = db[1].fetchall()
 521         self.close_db(db)
 522         #recdblist.printutf8(dbl)
 523         if dbr > 0:
 524             recdatum = self.getdic_timeline(dbl)
 525         return recdatum
 526     def select_byepgtime_all_timeline(self,epgbtime,epgetime):
 527         db = self.connect_db()
 528         recdatum = []
 529         #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 )")
 530         dbr = db[1].execute("SELECT \
 531         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 532         FROM timeline \
 533         WHERE epgbtime >= %s AND \
 534         epgetime <= %s",(epgbtime,epgetime))
 535         dbl = db[1].fetchall()
 536         self.close_db(db)
 537         #recdblist.printutf8(dbl)
 538         if dbr > 0:
 539             recdatum=self.getdic_timeline(dbl)
 540         return recdatum
 541     def select_byepgtime_over_timeline(self,epgbtime,epgetime):
 542         db = self.connect_db()
 543         recdatum = []
 544         #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 )")
 545         dbr = db[1].execute("SELECT \
 546         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 547         FROM timeline \
 548         WHERE (NOT(( timeline.epgetime <= %s )OR( timeline.epgbtime >= %s )))"\
 549         ,(epgbtime,epgetime))
 550         dbl = db[1].fetchall()
 551         self.close_db(db)
 552         #recdblist.printutf8(dbl)
 553         if dbr > 0:
 554             recdatum=self.getdic_timeline(dbl)
 555         return recdatum
 556     def select_bymodify_all_timeline(self):
 557         db = self.connect_db()
 558         recdatum = []
 559         #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 )")
 560         dbr = db[1].execute("SELECT \
 561         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 562         FROM timeline \
 563         WHERE modify > 0")
 564         dbl = db[1].fetchall()
 565         self.close_db(db)
 566         if dbr > 0:
 567             recdatum=self.getdic_timeline(dbl)
 568         return recdatum
 569     def count_schedule_timeline(self, btime, etime):
 570         """
 571         count rectasknum
 572         return [te num,bs/cs num]
 573         """
 574         db = self.connect_db()
 575         dbexe = "SELECT type,epg_ch.bctype,timeline.chtxt,title 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         Srec = 0
 578         Trec = 0
 579         db[1].execute(dbexe, (btime, etime,btime,etime))
 580         dbl=db[1].fetchall()
 581         for typet, bctypet, chtxtt, titlet 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                 if bctypet.find("cs") > -1:
 584                     Srec = Srec + 1
 585                 elif bctypet.find("bs") > -1:
 586                     Srec = Srec + 1
 587                 elif bctypet.find("te") > -1:
 588                     Trec = Trec + 1
 589         self.close_db(db)
 590         return [Trec, Srec]
 591     def search_schedule_timeline(self,btime,etime):
 592         """
 593         count rectasknum
 594         return [(type,bctype,chtxt,title,btime,etime)]
 595         """
 596         db = self.connect_db()
 597         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"
 598         dbexe = dbexe + " WHERE ((NOT(( timeline.etime <= %s )OR( timeline.btime >= %s ))) OR ((timeline.btime = %s) AND (timeline.etime = %s) ) )"
 599         ret=[]
 600         db[1].execute(dbexe, (btime, etime,btime,etime))
 601         dbl=db[1].fetchall()
 602         for typet, bctypet, chtxtt, titlet , btimet, etimet in dbl:
 603             if (typet == recdblist.REC_RESERVE) or (typet == recdblist.REC_FINAL_RESERVE) or (typet == recdblist.REC_KEYWORD) or (typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS):
 604                 ret.append([typet,bctypet,chtxtt,titlet,btimet,etimet])
 605         self.close_db(db)
 606         return ret
 607     def count_epgschedule_timeline(self, epgbtime, epgetime):
 608         """
 609         count rectasknum
 610         return [te num,bs/cs num]
 611         """
 612         db = self.connect_db()
 613         dbexe = "SELECT type,epg_ch.bctype,timeline.chtxt,title FROM timeline INNER JOIN epg_ch ON timeline.chtxt=epg_ch.chtxt"
 614         dbexe = dbexe + " WHERE (NOT(( timeline.epgetime <= %s )OR( timeline.epgbtime >= %s )))"
 615         Srec = 0
 616         Trec = 0
 617         db[1].execute(dbexe, (epgbtime, epgetime))
 618         dbl=db[1].fetchall()
 619         for typet, bctypet, chtxtt, titlet 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                 if bctypet.find("cs") > -1:
 622                     Srec = Srec + 1
 623                 elif bctypet.find("bs") > -1:
 624                     Srec = Srec + 1
 625                 elif bctypet.find("te") > -1:
 626                     Trec = Trec + 1
 627         self.close_db(db)
 628         return [Trec, Srec]
 629     def search_epgschedule_timeline(self,epgbtime,epgetime):
 630         """
 631         count rectasknum
 632         return [(type,bctype,chtxt,title,btime,etime)]
 633         """
 634         db = self.connect_db()
 635         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"
 636         dbexe = dbexe + " WHERE ((NOT(( timeline.epgetime <= %s )OR( timeline.epgbtime >= %s ))) OR ((timeline.epgbtime = %s) AND (timeline.epgetime = %s) ) )"
 637         ret=[]
 638         db[1].execute(dbexe, (epgbtime, epgetime,epgbtime,epgetime))
 639         dbl=db[1].fetchall()
 640         for typet, bctypet, chtxtt, titlet , btimet, etimet in dbl:
 641             if (typet == recdblist.REC_RESERVE) or (typet == recdblist.REC_FINAL_RESERVE) or (typet == recdblist.REC_KEYWORD) or (typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS):
 642                 ret.append([typet,bctypet,chtxtt,titlet,btimet,etimet])
 643         self.close_db(db)
 644         return ret
 645     def select_bytime_bychtxt_all_timeline(self,btime,etime,chtxt):
 646         db = self.connect_db()
 647         recdatum = []
 648         #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 )")
 649         dbr = db[1].execute("SELECT \
 650         type, chtxt, title, btime, etime, deltatime ,deltaday ,opt ,epgbtime ,epgetime ,epgtitle ,epgduplicate ,epgchange \
 651         FROM timeline \
 652         WHERE btime > %s AND \
 653         etime < %s\
 654         AND chtxt=%s ",(btime,etime,chtxt))
 655         dbl = db[1].fetchall()
 656         self.close_db(db)
 657         #recdblist.printutf8(dbl)
 658         if dbr > 0:
 659             recdatum = self.getdic_timeline(dbl)
 660         return recdatum
 661     def getdic_timeline(self,timelinelists):
 662         recdatum=[]
 663         for typet, chtxt, title, btime, etime, deltatime, deltaday, opt ,epgbtimet , epgetimet ,epgtitlet ,epgduplicatet ,epgchanget  in timelinelists:
 664             ret = {}
 665             ret['type'] = typet
 666             ret['chtxt'] = chtxt
 667             ret['title'] = title
 668             btime = btime.strftime("%Y-%m-%d %H:%M:%S")
 669             etime = etime.strftime("%Y-%m-%d %H:%M:%S")
 670             ret['btime'] = btime
 671             ret['etime'] = etime
 672             ret['opt'] = opt
 673             try:
 674                 ret['epgbtime'] = epgbtimet.strftime("%Y-%m-%d %H:%M:%S")
 675                 ret['epgetime'] = epgetimet.strftime("%Y-%m-%d %H:%M:%S")
 676             except:
 677                 ret['epgbtime'] = "2010-01-01 00:00:00"
 678                 ret['epgetime'] = "2010-01-01 00:00:00"
 679             ret['epgtitle'] = epgtitlet
 680             ret['epgduplicate'] = epgduplicatet
 681             ret['epgchange'] = epgchanget
 682             if deltatime == None or deltatime == "":
 683                 deltatime = "3"
 684             if deltaday == None or deltaday == "":
 685                 deltaday = "7"
 686             if typet == recdblist.REC_KEYWORD:
 687                 ret['deltatime'] = deltatime
 688             elif typet == recdblist.REC_KEYWORD_EVERY_SOME_DAYS:
 689                 ret['deltatime'] = deltatime
 690                 ret['deltaday'] = deltaday
 691             recdatum.append(ret)
 692         return recdatum
 693     def delete_old_timeline(self, dhour):
 694         db = self.connect_db()
 695         db[1].execute("\
 696         DELETE FROM timeline \
 697         WHERE \
 698         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
 699         #db.commit()
 700         self.close_db(db)
 701     def new_in_auto_jbk_key(self):
 702         db = self.connect_db()
 703         try:
 704             db[1].execute("\
 705             CREATE TABLE in_auto_jbk_key \
 706             (\
 707             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
 708             keyword VARCHAR(200),\
 709             UNIQUE unijbk (keyword)\
 710             )")
 711         except:
 712             ""
 713         self.close_db(db)
 714     def add_in_auto_jbk_key(self,key):
 715         db = self.connect_db()
 716         db[1].execute('\
 717         INSERT IGNORE into in_auto_jbk_key \
 718         (keyword) \
 719         values (%s)', \
 720                       (key,))
 721         ##db.commit()
 722         self.close_db(db)
 723     def select_all_in_auto_jbk_key(self):
 724         db = self.connect_db()
 725         dbexe = db[1].execute("\
 726         SELECT keyword \
 727         FROM in_auto_jbk_key \
 728         ")
 729         ret = []
 730         if dbexe > 0:
 731             ret = db[1].fetchall()
 732         self.close_db(db)
 733         return ret
 734     def drop_in_status(self):
 735         db = self.connect_db()
 736         try:
 737             db[1].execute('drop table in_status')
 738         except:
 739             ""
 740         self.close_db(db)
 741     def new_in_status(self):
 742         db = self.connect_db()
 743         try:
 744             db[1].execute("\
 745             CREATE TABLE in_status \
 746             (\
 747             ts2avi TINYINT DEFAULT 0,\
 748             terec TINYINT DEFAULT 0,\
 749             bscsrec TINYINT DEFAULT 0,\
 750             b252ts TINYINT DEFAULT 0,\
 751             installed TINYINT DEFAULT 0\
 752             )")
 753             db[1].execute("INSERT IGNORE into in_status VALUE (0,0,0,0,0)")
 754         except:
 755             ""
 756         self.close_db(db)
 757     def select_all_in_status(self):
 758         db = self.connect_db()
 759         dbexe = db[1].execute("\
 760         SELECT ts2avi,terec,bscsrec,b252ts \
 761         FROM in_status \
 762         ")
 763         ret = []
 764         dls = []
 765         if dbexe > 0:
 766             dls = db[1].fetchall()
 767         self.close_db(db)
 768         for dl in dls:
 769             r = list(dl)
 770             r[0]=str(r[0])
 771             r[1]=str(r[1])
 772             r[2]=str(r[2])
 773             r[3]=str(r[3])
 774             ret.append(r)
 775         return ret
 776
 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
1051     def new_auto_timeline_keyword(self):
1052         db = self.connect_db()
1053         try:
1054             db[1].execute('\
1055             CREATE TABLE auto_timeline_keyword \
1056             (\
1057             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
1058             chtxt VARCHAR(40),\
1059             title VARCHAR(100),\
1060             btime DATETIME,\
1061             etime DATETIME,\
1062             UNIQUE uni (chtxt,title,btime,etime)\
1063             )')
1064         except:
1065             ""
1066     def add_auto_timeline_keyword(self,chtxt="", title="", btime="", etime=""):
1067         db = self.connect_db()
1068         db[1].execute('\
1069         INSERT IGNORE into auto_timeline_keyword \
1070         (chtxt,title,btime,etime) \
1071         values (%s,%s,%s,%s)', \
1072                        (chtxt, title, btime, etime))
1073         ##db.commit()
1074         self.close_db(db)
1075     def delete_old_auto_timeline_keyword(self, dhour):
1076         db = self.connect_db()
1077         db[1].execute("\
1078         DELETE FROM auto_timeline_keyword \
1079         WHERE \
1080         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
1081         self.close_db(db)
1082     def new_auto_timeline_bayes(self):
1083         db = self.connect_db()
1084         try:
1085             db[1].execute('\
1086             CREATE TABLE auto_timeline_bayes \
1087             (\
1088             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
1089             chtxt VARCHAR(40),\
1090             title VARCHAR(100),\
1091             btime DATETIME,\
1092             etime DATETIME,\
1093             point INT,\
1094             UNIQUE uni (chtxt,title,btime,etime)\
1095             )')
1096         except:
1097             ""
1098     def add_auto_timeline_bayes(self,chtxt="", title="", btime="", etime="",point=""):
1099         db = self.connect_db()
1100         db[1].execute('\
1101         INSERT IGNORE into auto_timeline_bayes \
1102         (chtxt,title,btime,etime,point) \
1103         values (%s,%s,%s,%s,%s)', \
1104                       (chtxt, title, btime, etime,point))
1105         self.close_db(db)
1106     def delete_old_auto_timeline_bayes(self, dhour):
1107         db = self.connect_db()
1108         db[1].execute("\
1109         DELETE FROM auto_timeline_bayes \
1110         WHERE \
1111         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
1112         self.close_db(db)