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