rec10/trunk/src/dbMySQL.py

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