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,chname,status,visible \
 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,chname,status,visible \
 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,chname,status,visible \
 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,chname,status,visible \
 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 vim         ")
 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         epg_ch.visible=1 \
 945         AND \
 946         start >= %s \
 947         AND \
 948         stop <= %s \
 949         AND \
 950         ( \
 951         ( title LIKE \'%%"+keyword+"%%\' ) \
 952         OR \
 953         ( exp LIKE \'%%"+keyword+"%%\' ) \
 954         OR \
 955         ( longexp LIKE \'%%"+keyword+"%%\' ) \
 956         )"
 957         dbcmd = db[1].execute(dbexe,(btime, etime))
 958         retall = []
 959         if dbcmd > 0:
 960             retall = db[1].fetchall()
 961         self.close_db(db)
 962         return retall
 963     def new_in_auto_bayes_key(self):
 964         db = self.connect_db()
 965         try:
 966             db[1].execute('CREATE TABLE in_auto_bayes_key \
 967             (\
 968             keychar VARCHAR(10),\
 969             chtxt VARCHAR(20),\
 970             ratio_rec DECIMAL(32,14),\
 971             ratio_all DECIMAL(32,14),\
 972             UNIQUE unibayeskey(keychar,chtxt)\
 973             )')
 974             db[1].execute('CREATE INDEX keycharindex ON in_auto_bayes_key(keychar)')
 975         except Exception, inst:
 976             if not ((type(inst)==MySQLdb.ProgrammingError and inst[0]==1007)or(type(inst)==MySQLdb.OperationalError and inst[0]==1050)):
 977                 recdblist.addCommonlogEX("Error", "new_in_auto_bayes_key (dbMySQL.py)", str(type(inst)),str(inst)+traceback.format_exc(),log_level=200)
 978         self.close_db(db)
 979
 980     def add_in_auto_bayes_key(self,key,chtxt,ratio_rec,ratio_all):
 981         db = self.connect_db()
 982         ratio_rec=str(ratio_rec)
 983         ratio_all=str(ratio_all)
 984         db[1].execute('\
 985         INSERT IGNORE INTO in_auto_bayes_key \
 986         (keychar,chtxt,ratio_rec,ratio_all) \
 987         values (%s,%s,%s,%s)',\
 988         (key,chtxt,ratio_rec,ratio_all))
 989         self.close_db(db)
 990     def add_num_in_auto_bayes_key(self,chtxt,add_rec_num,add_all_num):
 991         db = self.connect_db()
 992         add_rec_num=str(add_rec_num)
 993         add_all_num=str(add_all_num)
 994         db[1].execute("\
 995         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",\
 996         (add_rec_num,add_all_num,chtxt))
 997         self.close_db(db)
 998     def change_in_auto_bayes_key(self,key,chtxt,new_ratio_rec,new_ratio_all):
 999         """
1000         """
1001         db = self.connect_db()
1002         db[1].execute("\
1003         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)\
1004         )
1005         self.close_db(db)
1006     def change_ratio_all_reduce_in_auto_bayes_key(self,chtxt,beforenum,newnum):
1007         beforenum=str(beforenum)
1008         newnum=str(newnum)
1009         db = self.connect_db()
1010         db[1].execute("\
1011         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)\
1012         )
1013         self.close_db(db)
1014     def change_ratio_all_in_auto_bayes_key(self,key,chtxt,beforenum,addnum):
1015         db = self.connect_db()
1016         beforenumf=beforenum
1017         beforenum=str(beforenum)
1018         db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
1019         VALUES (%s,%s,%s,%s)\
1020         ON DUPLICATE KEY UPDATE \
1021         ratio_all=CONVERT((ratio_all*%s+%s)/%s,DECIMAL(32,14))",(key,chtxt,"0",str(Decimal(addnum)/beforenumf),beforenum,chtxt,key))
1022         self.close_db(db)
1023     def change_multi_ratio_all_in_auto_bayes_key(self,chtxt,beforenum,list):
1024         """
1025         list={key:addnum}のリスト
1026         """
1027         beforenumf=beforenum
1028         beforenum=str(beforenum)
1029         db = self.connect_db()
1030         for i,j in list.items():
1031             retl=(i,chtxt,"0",str(Decimal(j)/beforenumf),beforenum,str(j),beforenum)
1032             try:
1033                 db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
1034                 VALUES (%s,%s,%s,%s)\
1035                 ON DUPLICATE KEY UPDATE \
1036                 ratio_all=CONVERT((ratio_all*%s+%s)/%s,DECIMAL(32,14))",retl)
1037             except Exception, inst:
1038                 if not ((type(inst)==MySQLdb.ProgrammingError and inst[0]==1007)or(type(inst)==MySQLdb.OperationalError and inst[0]==1050)):
1039                     recdblist.addCommonlogEX("Error", "change_multi_ratio_all_in_auto_bayes_key (dbMySQL.py)", str(type(inst)),str(inst)+traceback.format_exc(),log_level=200)
1040         self.close_db(db)
1041     def change_ratio_rec_reduce_in_auto_bayes_key(self,chtxt,beforenum,newnum):
1042         beforenum=str(beforenum)
1043         newnum=str(newnum)
1044         db = self.connect_db()
1045         db[1].execute("\
1046         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)\
1047         )
1048         self.close_db(db)
1049     def change_ratio_rec_in_auto_bayes_key(self,key,chtxt,beforenum,addnum):
1050         db = self.connect_db()
1051         beforenumf=beforenum
1052         beforenum=str(beforenum)
1053         db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
1054         VALUES (%s,%s,%s,%s)\
1055         ON DUPLICATE KEY UPDATE \
1056         ratio_rec=CONVERT((ratio_rec*%s+%s)/%s,DECIMAL(32,14))",(key,chtxt,str(Decimal(addnum)/beforenumf),"0",beforenum,chtxt,key))
1057         self.close_db(db)
1058     def change_multi_ratio_rec_in_auto_bayes_key(self,chtxt,beforenum,list):#self,key,chtxt,beforenum,addnum):
1059         beforenumf=beforenum
1060         beforenum=str(beforenum)
1061         db = self.connect_db()
1062         for i,j in list.items():
1063             retl=(i,chtxt,str(Decimal(j)/beforenumf),"0",beforenum,str(j),beforenum)
1064             try:
1065                 db[1].execute("INSERT INTO in_auto_bayes_key (keychar,chtxt,ratio_rec,ratio_all) \
1066                 VALUES (%s,%s,%s,%s)\
1067                 ON DUPLICATE KEY UPDATE \
1068                 ratio_rec=CONVERT((ratio_rec*%s+%s)/%s,DECIMAL(32,14))",retl)
1069             except Exception, inst:
1070                 if not ((type(inst)==MySQLdb.ProgrammingError and inst[0]==1007)or(type(inst)==MySQLdb.OperationalError and inst[0]==1050)):
1071                     recdblist.addCommonlogEX("Error", "change_multi_ratio_rec_in_auto_bayes_key (dbMySQL.py)", str(type(inst)),str(inst)+traceback.format_exc(),log_level=200)
1072         self.close_db(db)
1073     def select_by_key_in_auto_bayes_key(self,key,chtxt):
1074         db = self.connect_db()
1075         dbexe = db[1].execute("\
1076         SELECT keychar,chtxt,ratio_rec,ratio_all \
1077         FROM in_auto_bayes_key \
1078         WHERE keychar = %s AND chtxt = %s", \
1079                               (key,chtxt))
1080         dls = []
1081         if dbexe > 0:
1082             dls = db[1].fetchall()
1083         self.close_db(db)
1084         if len(dls)>0:
1085             return dls[0]
1086         else:
1087             return dls
1088     def new_auto_timeline_keyword(self):
1089         db = self.connect_db()
1090         try:
1091             db[1].execute('\
1092             CREATE TABLE auto_timeline_keyword \
1093             (\
1094             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
1095             chtxt VARCHAR(40),\
1096             title VARCHAR(100),\
1097             btime DATETIME,\
1098             etime DATETIME,\
1099             UNIQUE uni (chtxt,title,btime,etime)\
1100             )')
1101         except Exception, inst:
1102             if not ((type(inst)==MySQLdb.ProgrammingError and inst[0]==1007)or(type(inst)==MySQLdb.OperationalError and inst[0]==1050)):
1103                 recdblist.addCommonlogEX("Error", "new_auto_timeline_keyword (dbMySQL.py)", str(type(inst)),str(inst)+traceback.format_exc(),log_level=200)
1104     def add_auto_timeline_keyword(self,chtxt="", title="", btime="", etime=""):
1105         db = self.connect_db()
1106         db[1].execute('\
1107         INSERT IGNORE into auto_timeline_keyword \
1108         (chtxt,title,btime,etime) \
1109         values (%s,%s,%s,%s)', \
1110                        (chtxt, title, btime, etime))
1111         ##db.commit()
1112         self.close_db(db)
1113     def delete_old_auto_timeline_keyword(self, dhour):
1114         db = self.connect_db()
1115         db[1].execute("\
1116         DELETE FROM auto_timeline_keyword \
1117         WHERE \
1118         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
1119         self.close_db(db)
1120     def new_auto_timeline_bayes(self):
1121         db = self.connect_db()
1122         try:
1123             db[1].execute('\
1124             CREATE TABLE auto_timeline_bayes \
1125             (\
1126             id INT UNSIGNED AUTO_INCREMENT NOT NULL PRIMARY KEY,\
1127             chtxt VARCHAR(40),\
1128             title VARCHAR(100),\
1129             btime DATETIME,\
1130             etime DATETIME,\
1131             point INT,\
1132             UNIQUE uni (chtxt,title,btime,etime)\
1133             )')
1134         except Exception, inst:
1135             if not ((type(inst)==MySQLdb.ProgrammingError and inst[0]==1007)or(type(inst)==MySQLdb.OperationalError and inst[0]==1050)):
1136                 recdblist.addCommonlogEX("Error", "new_auto_timeline_bayes (dbMySQL.py)", str(type(inst)),str(inst)+traceback.format_exc(),log_level=200)
1137     def add_auto_timeline_bayes(self,chtxt="", title="", btime="", etime="",point=""):
1138         db = self.connect_db()
1139         db[1].execute('\
1140         INSERT IGNORE into auto_timeline_bayes \
1141         (chtxt,title,btime,etime,point) \
1142         values (%s,%s,%s,%s,%s)', \
1143                       (chtxt, title, btime, etime,point))
1144         self.close_db(db)
1145     def delete_old_auto_timeline_bayes(self, dhour):
1146         db = self.connect_db()
1147         db[1].execute("\
1148         DELETE FROM auto_timeline_bayes \
1149         WHERE \
1150         btime < DATE_SUB(now(),INTERVAL " + dhour + " HOUR )")
1151         self.close_db(db)
1152     def update_db_to93(self):
1153         db = self.connect_db()
1154         self.drop_in_settings()
1155         self.new_in_settings()
1156         db[1].execute("\
1157         ALTER TABLE timeline ADD epgtitle VARCHAR(100),\
1158         ADD epgbtime DATETIME,\
1159         ADD epgetime DATETIME,\
1160         ADD epgduplicate TINYINT DEFAULT 0,\
1161         ADD epgchange TINYINT DEFAULT 0")
1162         db[1].execute("\
1163         ALTER TABLE in_status ADD version TINYINT")
1164         self.close_db(db)
1165         self.change_version_in_status("93")
1166     def update_db_93to94(self):
1167         db = self.connect_db()
1168         self.drop_in_settings()
1169         self.new_in_settings()
1170         db[1].execute("\
1171         ALTER TABLE timeline ADD counter TINYINT DEFAULT -1")
1172         self.close_db(db)
1173         self.change_version_in_status("94")
1174     def update_db_94to95(self):
1175         db = self.connect_db()
1176         self.drop_in_settings()
1177         self.new_in_settings()
1178         db[1].execute("\
1179         ALTER TABLE timeline ADD epgexp VARCHAR(200)")
1180         self.close_db(db)
1181         self.change_version_in_status("95")
1182     def update_db_95to96(self):
1183         db = self.connect_db()
1184         self.drop_in_settings()
1185         self.new_in_settings()
1186         self.close_db(db)
1187         self.change_version_in_status("96")
1188     def update_db_96to98(self):
1189         db = self.connect_db()
1190         self.drop_in_settings()
1191         self.new_in_settings()
1192         self.close_db(db)
1193         self.change_version_in_status("98")
1194     def update_db_98to100(self):
1195         ###ここで前のepg_chをバックアップしてchtxtの変換をする必要がある。
1196         db = self.connect_db()
1197         self.drop_in_settings()
1198         self.new_in_settings()
1199         db[1].execute("\
1200         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')")
1201         db[1].execute("\
1202         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'")
1203         db[1].execute("\
1204         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'")
1205         try:
1206             db[1].execute("\
1207             ALTER TABLE epg_ch DROP ontv")
1208         except:
1209             ""
1210         db[1].execute("\
1211         ALTER TABLE epg_ch ADD logo0 BLOB,\
1212         ADD logo1 BLOB,\
1213         ADD logo2 BLOB,\
1214         ADD logo3 BLOB,\
1215         ADD logo4 BLOB,\
1216         ADD logo5 BLOB\
1217         ")
1218         db[1].execute("\
1219         ALTER TABLE in_auto_jbk_key ADD auto TINYINT DEFAULT 0")
1220         db[1].execute("\
1221         ALTER TABLE in_auto_jbk_key ADD opt VARCHAR(20) DEFAULT \"\"")
1222         self.close_db(db)
1223         self.change_installed_in_status()#チャンネルスキャンをさせる
1224         self.change_version_in_status("100")