rec10/trunk/src/dbMySQL.py

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