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