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