repo migration

db/mssql/Merger.py

@@ -0,0 +1,327 @@
+from sqlalchemy import text
+
+class SQLGenerate():
+    
+    def __init__(self):
+        pass
+    
+    def merge_updates(self):
+        updatesql = text('''
+            MERGE updates.tvupdatedata
+            USING updates.tvupdates
+            ON updates.tvupdatedata.seriesid = updates.tvupdates.seriesid
+            WHEN MATCHED THEN
+              UPDATE  SET updates.tvupdatedata.seriesid = updates.tvupdates.seriesid,updates.tvupdatedata.timestamp = updates.tvupdates.timestamp
+            WHEN NOT MATCHED THEN  
+              INSERT (seriesid, timestamp) 
+              VALUES (updates.tvupdates.seriesid, updates.tvupdates.timestamp);
+            ''')
+        return(updatesql)
+    
+    def merge_series(self):
+        seriessql = text('''
+            MERGE dbo.seriesdata
+              USING updates.newseriesdata ON
+            dbo.seriesdata.seriesid = updates.newseriesdata.seriesid
+            WHEN MATCHED THEN UPDATE
+            SET
+              dbo.seriesdata.seriesid = updates.newseriesdata.seriesid,
+              dbo.seriesdata.thetvdb = updates.newseriesdata.thetvdb,
+              dbo.seriesdata.tvrage = updates.newseriesdata.tvrage,
+              dbo.seriesdata.imdb = updates.newseriesdata.imdb,
+              dbo.seriesdata.[language] = updates.newseriesdata.[language],
+              dbo.seriesdata.genres = updates.newseriesdata.genres,
+              dbo.seriesdata.name = updates.newseriesdata.name,
+              dbo.seriesdata.status = updates.newseriesdata.status,
+              dbo.seriesdata.premiered = updates.newseriesdata.premiered,
+              dbo.seriesdata.days = updates.newseriesdata.days,
+              dbo.seriesdata.[time] = updates.newseriesdata.[time],
+              dbo.seriesdata.runtime = updates.newseriesdata.runtime,
+              dbo.seriesdata.rating = updates.newseriesdata.rating,
+              dbo.seriesdata.[type] = updates.newseriesdata.[type],
+              dbo.seriesdata.summary = updates.newseriesdata.summary,
+              dbo.seriesdata.medium = updates.newseriesdata.medium,
+              dbo.seriesdata.original = updates.newseriesdata.original,
+              dbo.seriesdata.[weight] = updates.newseriesdata.[weight],
+              dbo.seriesdata.networkid = updates.newseriesdata.networkid,
+              dbo.seriesdata.webchannelid = updates.newseriesdata.webchannelid,
+              dbo.seriesdata.officialsite = updates.newseriesdata.officalsite,
+              dbo.seriesdata.url = updates.newseriesdata.url,
+              dbo.seriesdata.serieslink = updates.newseriesdata.serieslink,
+              dbo.seriesdata.updated_on = GETDATE()
+              WHEN NOT MATCHED THEN INSERT
+                (seriesid,
+                thetvdb,
+                tvrage,
+                imdb,
+                [language],
+                genres,
+                name,
+                status,
+                premiered,
+                days,
+                [time],
+                runtime,
+                rating,
+                [type],
+                summary,
+                medium,
+                original,
+                weight,
+                networkid,
+                webchannelid,
+                officialsite,
+                url,
+                serieslink,
+                created_on)
+              VALUES (updates.newseriesdata.seriesid,
+              updates.newseriesdata.thetvdb,
+              updates.newseriesdata.tvrage,
+              updates.newseriesdata.imdb,
+              updates.newseriesdata.[language],
+              updates.newseriesdata.genres,
+              updates.newseriesdata.name,
+              updates.newseriesdata.status,
+              updates.newseriesdata.premiered,
+              updates.newseriesdata.days,
+              updates.newseriesdata.[time],
+              updates.newseriesdata.runtime,
+              updates.newseriesdata.rating,
+              updates.newseriesdata.[type],
+              updates.newseriesdata.summary,
+              updates.newseriesdata.medium,
+              updates.newseriesdata.original,
+              updates.newseriesdata.weight,
+              updates.newseriesdata.networkid,
+              updates.newseriesdata.webchannelid,
+              updates.newseriesdata.officalsite,
+              updates.newseriesdata.url,
+              updates.newseriesdata.serieslink,
+              GETDATE());
+            ''')
+        return(seriessql)
+
+    def merge_episodes(self):
+        episodesql = text('''
+            MERGE dbo.epdata
+              USING updates.newepdata ON
+            dbo.epdata.episodeid = updates.newepdata.episodeid
+            WHEN MATCHED THEN UPDATE
+            SET
+              dbo.epdata.episodeid = updates.newepdata.episodeid,
+              dbo.epdata.seriesid = updates.newepdata.seriesid,
+              dbo.epdata.season = updates.newepdata.season,
+              dbo.epdata.episodenumber = updates.newepdata.episodenumber,
+              dbo.epdata.episodename = updates.newepdata.episodename,
+              dbo.epdata.airdate = updates.newepdata.airdate,
+              dbo.epdata.airtime = updates.newepdata.airtime,
+              dbo.epdata.episodesummary = updates.newepdata.episodesummary,
+              dbo.epdata.airstamp = updates.newepdata.airstamp,
+              dbo.epdata.runtime = updates.newepdata.runtime,
+              dbo.epdata.eplink = updates.newepdata.eplink,
+              dbo.epdata.mediumimage = updates.newepdata.mediumimage,
+              dbo.epdata.originalimage = updates.newepdata.originalimage,
+              dbo.epdata.[url] = updates.newepdata.[url],
+              dbo.epdata.updated_on = GETDATE()
+              WHEN NOT MATCHED THEN INSERT
+                (episodeid,
+                seriesid,
+                season,
+                episodenumber,
+                episodename,
+                airdate,
+                airtime,
+                episodesummary,
+                airstamp,
+                runtime,
+                eplink,
+                mediumimage,
+                originalimage,
+                [url],
+                created_on)
+              VALUES (updates.newepdata.episodeid,
+              updates.newepdata.seriesid,
+              updates.newepdata.season,
+              updates.newepdata.episodenumber,
+              updates.newepdata.episodename,
+              updates.newepdata.airdate,
+              updates.newepdata.airtime,
+              updates.newepdata.episodesummary,
+              updates.newepdata.airstamp,
+              updates.newepdata.runtime,
+              updates.newepdata.eplink,
+              updates.newepdata.mediumimage,
+              updates.newepdata.originalimage,
+              updates.newepdata.[url],
+              GETDATE());
+            ''')
+        return(episodesql)   
+
+    def merge_cast(self):
+        castsql = text('''
+        MERGE castdata as N
+        USING updates.newcastdata as O
+        ON N.seriesid = O.seriesid and N.characterid = O.characterid and N.actorid = O.actorid
+         WHEN MATCHED THEN
+          UPDATE  SET N.seriesid = O.seriesid, N.characterid = O.characterid,N.actorid = O.actorid,N.charactername = O.charactername,N.mediumimage = O.mediumimage,N.originalimage = O.originalimage,N.apilink = O.apilink,N.tvmazelink = O.tvmazelink, N.updated_on = GETDATE()
+        WHEN NOT MATCHED THEN  
+          INSERT (seriesid,characterid,actorid,charactername,mediumimage,originalimage,apilink,tvmazelink, created_on) 
+          VALUES 
+          (O.seriesid,O.characterid,O.actorid,O.charactername,O.mediumimage,O.originalimage,O.apilink,O.tvmazelink, GETDATE());
+        ''')
+        return(castsql)
+    
+    def merge_actors(self):
+        actorsql = text('''
+        MERGE actors as N
+        USING updates.newactordata as O
+        ON N.actorid = O.actorid and N.actorname = O.actorname
+         WHEN MATCHED THEN
+          UPDATE  SET N.actorid = O.actorid, N.actorname = O.actorname, N.countryname = O.countryname, N.countrytimezone = O.countrytimezone, N.birthday = O.birthday, N.deathday = O.deathday, N.gender = O.gender, N.mediumimage = O.mediumimage, N.originalimage = O.originalimage, N.apilink = O.apilink, N.url = O.url, N.countrycode = O.countrycode, N.updated_on = GETDATE()
+        WHEN NOT MATCHED THEN  
+          INSERT (actorid,actorname,countryname,countrytimezone,birthday,deathday,gender,mediumimage,originalimage,apilink,url,countrycode,created_on) 
+          VALUES 
+          (O.actorid,O.actorname,O.countryname,O.countrytimezone,O.birthday,O.deathday,O.gender,O.mediumimage,O.originalimage,O.apilink,O.url,O.countrycode, GETDATE());
+        ''')
+        return(actorsql)
+    
+    def merge_crew(self):
+      crewsql = text('''
+      MERGE dbo.crewdata as N
+      USING updates.newcrewdata as O ON
+      N.[type] = O.[type]
+      and N.seriesid = O.seriesid
+      and N.crewid = O.crewid
+      WHEN MATCHED THEN UPDATE
+      SET
+        N.seriesid = O.seriesid,
+        N.crewid = O.crewid,
+        N.countryid = O.countryid,
+        N.type = O.type,
+        N.name = O.name,
+        N.medium = O.medium,
+        N.original = O.original,
+        N.apilink = O.apilink,
+        N.gender = O.gender,
+        N.birthday = O.birthday,
+        N.deathday = O.deathday,
+        N.updated_on = GETDATE()
+        WHEN NOT MATCHED THEN INSERT
+          (seriesid,
+          crewid,
+          countryid,
+          type,
+          name,
+          medium,
+          original,
+          apilink,
+          gender,
+          birthday,
+          deathday,
+          created_on)
+        VALUES (O.seriesid,
+          O.crewid,
+          O.countryid,
+          O.type,
+          O.name,
+          O.medium,
+          O.original,
+          O.apilink,
+          O.gender,
+          O.birthday,
+          O.deathday,
+        GETDATE());
+        ''')
+      return(crewsql)
+    
+    def merge_country(self):
+        countrysql = text('''
+            MERGE countrydata
+            USING updates.newcountrydata
+            ON countrydata.id = updates.newcountrydata.id
+            WHEN MATCHED THEN
+              UPDATE  SET countrydata.name = updates.newcountrydata.name, countrydata.code = updates.newcountrydata.code, countrydata.timezone = updates.newcountrydata.timezone, countrydata.updated_on = GETDATE()
+            WHEN NOT MATCHED THEN  
+              INSERT (name, code, timezone, created_on) 
+              VALUES 
+              (updates.newcountrydata.name,updates.newcountrydata.code,updates.newcountrydata.timezone, GETDATE());
+            ''')
+        return(countrysql)   
+                
+    def __del__(self):
+        pass
+        
+class Charactermerge():
+    
+    def __init__(self):
+        pass
+    
+    def __del__(self):
+        pass
+
+class Episodemerge():
+    def __init_(self):
+        pass
+
+    def __del__(self):
+        pass
+
+class Jsonmerge():
+    
+    def __init__(self):
+        pass
+    
+    def merge(self, engine):
+        seriessql = text('''BEGIN TRANSACTION;
+            MERGE dbo.seriesjson as N
+            USING updates.seriesjsonnewvals as O
+            ON N.seriesid = O.seriesid and N.jdata = O.jdata
+            WHEN MATCHED THEN
+              UPDATE  SET N.seriesid = O.seriesid, N.jdata = O.jdata, N.updated_on = GETDATE()
+            WHEN NOT MATCHED THEN  
+              INSERT (seriesid, jdata, created_on) 
+              VALUES 
+              (O.seriesid, O.jdata, GETDATE());
+            COMMIT;
+            ''')
+        with engine.connect() as con:
+            rs = con.execute(seriessql)
+        #engine.commit()
+            
+        episodesql = text('''BEGIN TRANSACTION;
+            MERGE updates.tvmaze_episodejson as N
+            USING updates.episodejsonnewvals as O
+            ON N.seriesid = O.seriesid
+             WHEN MATCHED THEN
+              UPDATE  SET N.seriesid = O.seriesid, N.jdata = O.jdata, N.updated_on = GETDATE()
+            WHEN NOT MATCHED THEN  
+              INSERT (seriesid, jdata, created_on) 
+              VALUES 
+              (O.seriesid, O.jdata, GETDATE());
+            SELECT * FROM updates.tvmaze_episodejson;COMMIT;
+            ''')
+        with engine.connect() as con:
+            rs = con.execute(episodesql)
+        #engine.commit()
+            
+        charactersql = text('''BEGIN TRANSACTION;
+            MERGE updates.tvmaze_characterjson as N
+            USING updates.characterjsonnewvals as O
+            ON N.seriesid = O.seriesid
+             WHEN MATCHED THEN
+              UPDATE  SET N.seriesid = O.seriesid, N.jdata = O.jdata, N.updated_on = GETDATE()
+            WHEN NOT MATCHED THEN  
+              INSERT (seriesid, jdata, created_on) 
+              VALUES 
+              (O.seriesid, O.jdata, GETDATE());
+            SELECT * FROM updates.tvmaze_characterjson;COMMIT;
+            ''')
+        with engine.connect() as con:
+            rs = con.execute(charactersql)
+        #engine.commit()
+    
+    def __del__(self):
+        pass
+
+    
+    

db/mssql/Tables.py

@@ -0,0 +1,376 @@
+import sqlalchemy
+from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, Sequence, text, UniqueConstraint
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.schema import MetaData
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.types import *
+
+class Tables():
+    def __init__(self):
+        global tvnetworknewvals
+        global tvwebchannelnewvals
+        global characterjsonnewvals
+        global seriesjsonnewvals
+        global episodejsonnewvals
+        global metadata
+        global engine
+        global session
+        global tvnetworknewvals
+        global tvwebchannelnewvals
+        global characterjsonnewvals
+        global seriesjsonnewvals
+        global episodejsonnewvals
+        global tvupdates
+        global newseriesdata
+        global actorlinks
+        global tablelist
+        
+    def __del__(self):
+        pass
+
+
+class Createtables():
+    
+    def __init__(self, session, metadata, engine, tablelist):
+        Base = declarative_base(metadata = metadata)
+        self.tablelist = self.settables(metadata, engine)
+        try:
+            self.drop(session, self.tablelist)
+        except:
+            pass
+        self.create(Base, engine, metadata, session, self.tablelist)
+        session.commit()
+        #self.send(tablelist)
+    
+    def settables(self, metadata, engine):
+        tablelist = []
+        newseriesdata = Table('newseriesdata', metadata,
+            Column('id', BIGINT, Sequence('newseriesdata_id_seq'), primary_key = True),
+            Column('seriesid',INTEGER, unique=True),
+            Column('tvdbid', String(25)),
+            Column('tvrageid', String(25)),
+            Column('imdbid', String(25)),
+            Column('serieslanguage', String(25)),
+            Column('genres', String(75)),
+            Column('seriesname', String(150)),
+            Column('seriesstatus', String(25)),
+            Column('premiered', String(25)),
+            Column('airdays', String(72)),
+            Column('airtime', String(25)),
+            Column('runtime', String(25)),
+            Column('rating', String(25)),
+            Column('showtype',TEXT),
+            Column('overview',TEXT),
+            Column('mediumimage',TEXT),
+            Column('originalimage',TEXT),
+            Column('weight',INTEGER),
+            Column('networkid', String(25)),
+            Column('webchannelid', String(25)),
+            Column('officialsite',TEXT),
+            Column('showurl',TEXT),
+            Column('apilink',TEXT),
+            schema = "updates")
+        tablelist.append(newseriesdata)
+        newactordata = Table('newactordata', metadata,
+            Column('id', BIGINT, Sequence('newactordata_id_seq'), primary_key = True),
+            Column('actorid', INTEGER, unique=True),
+            Column('actorname', VARCHAR(72)),
+            Column('countryname', VARCHAR(144)),
+            Column('countrytimezone', VARCHAR(72)),
+            Column('birthday', DATE),
+            Column('deathday', DATE),
+            Column('gender', VARCHAR(6)),
+            Column('mediumimage', TEXT),
+            Column('originalimage', TEXT),
+            Column('apilink', TEXT),
+            Column('url', TEXT),
+            Column('countrycode', VARCHAR(12)),
+            schema = "updates")
+        tablelist.append(newactordata)
+        newepdata = Table('newepdata', metadata,
+        Column('id', BIGINT, Sequence('newepdata_id_seq'), primary_key = True),
+            Column('episodeid', INTEGER),
+            Column('seriesid', INTEGER),
+            Column('season', INTEGER),
+            Column('episodenumber', INTEGER),
+            Column('episodename', TEXT),
+            Column('airdate', VARCHAR(32)),
+            Column('airtime', VARCHAR(32)),
+            Column('episodesummary', TEXT),
+            Column('airstamp', VARCHAR(32)),
+            Column('runtime', VARCHAR(6)),
+            Column('eplink', TEXT),
+            Column('mediumimage', TEXT),
+            Column('url', TEXT),
+            Column('originalimage', TEXT),
+            schema = "updates")
+        tablelist.append(newepdata)
+        newcastdata = Table('newcastdata', metadata,
+        Column('id', BIGINT, Sequence('newcastdata_id_seq'), primary_key = True),
+            Column('seriesid', INTEGER),
+            Column('characterid', INTEGER),
+            Column('actorid', INTEGER),
+            Column('charactername', VARCHAR(250)),
+            Column('mediumimage', TEXT),
+            Column('originalimage', TEXT),
+            Column('apilink', TEXT),
+            Column('tvmazelink', TEXT),
+            schema = "updates")
+        tablelist.append(newcastdata)
+        tvnetworks = Table('tvnetworkdata', metadata,
+          Column('id', BIGINT, Sequence('network_id_seq'), primary_key = True),
+          Column('networkid', String(12)),
+          Column('networkname', String(255)),
+          Column('country', String(255)),
+          Column('countrycode', String(4)),
+          Column('countrytimezone', String(25)),
+          schema = "updates")
+        tablelist.append(tvnetworks)
+        tvwebchannels = Table('tvwebchanneldata', metadata,
+          Column('id', BIGINT, Sequence('webchannel_id_seq'), primary_key = True),
+          Column('webchannelname', String(255)),
+          Column('webchannelcountrycode', String(4)),
+          Column('webchannelcountryname', String(255)),
+          Column('webchannelcountrytimezone', String(4)),
+          schema = "updates")
+        tablelist.append(tvwebchannels)
+        return(tablelist)
+    
+    def create(self, Base, engine, metadata, session, tablelist):
+        print('Creating Temporary Data Tables')
+        Base.metadata.create_all(engine, tables=tablelist)
+
+    def drop(self, session, tablelist):
+        for table in tablelist:
+            try:
+                #print('Dropping ' + str(table))
+                table.drop()
+            except sqlalchemy.exc.ProgrammingError as se:
+                pass
+            
+        def __del__(self):
+            pass
+            
+
+class Temptables():
+    
+    def __init__(self, session, metadata, engine, tablelist):
+        Base = declarative_base(metadata = metadata)
+        self.tablelist = self.settables(metadata, engine)
+        try:
+            self.drop(session, self.tablelist)
+        except:
+            pass
+        self.create(Base, engine, metadata, session, self.tablelist)
+        #session.commit()
+        
+    def settables(self, metadata, engine):
+        tablelist = []
+        tvnetworknewvals = Table('tvnetworknewvals', metadata,
+          Column('id', BIGINT, Sequence('network_id_seq'), primary_key = True),
+          Column('name', String(255)),
+          Column('countryid', String(255)),
+          schema = "updates")
+        tablelist.append(tvnetworknewvals)
+        tvwebchannelnewvals = Table('tvwebchannelnewvals', metadata,
+          Column('id', BIGINT, Sequence('webchannel_id_seq'), primary_key = True),
+          Column('name', String(255)),
+          Column('countryid', String(4)),
+          schema = "updates")
+        tablelist.append(tvwebchannelnewvals)
+        tvupdates = Table('tvupdates', metadata,
+        Column('seriesid', BIGINT, primary_key = True),
+            Column('timestamp', VARCHAR(15)),
+          schema = "updates")
+        tablelist.append(tvupdates)
+        tvupdatedata = Table('tvupdatedata', metadata,
+        Column('seriesid', BIGINT, primary_key = True),
+            Column('timestamp', VARCHAR(15)),
+          schema = "updates")
+        tablelist.append(tvupdatedata)
+        newactorlinks = Table('newactorlinks', metadata,
+          Column('id', BIGINT, Sequence('tempepisodejson_id_seq'), primary_key = True),
+          Column('actorid', INTEGER),
+          Column('characterid', INTEGER),
+          schema = "updates")
+        tablelist.append(newactorlinks)
+        return(tablelist)
+    
+    def create(self, Base, engine, metadata, session, tablelist):
+        tablelist.remove(tablelist[6])
+        print('Creating Temporary JSON Tables')
+        try:
+            Base.metadata.create_all(engine, tables=tablelist)
+        except sqlalchemy.exc.ProgrammingError as pe:
+            pass 
+
+    def drop(self, session, tablelist):
+        for table in tablelist:
+            if 'tvupdatedata' in table.description:
+                pass
+            else:
+                try:
+                    #print('Dropping ' + str(table))
+                    table.drop()
+                except sqlalchemy.exc.ProgrammingError as se:
+                    pass
+        #session.commit()
+
+class CreateTempTables():
+    
+    global tvnetworknewvals
+    global tvwebchannelnewvals
+    global characterjsonnewvals
+    global seriesjsonnewvals
+    global episodejsonnewvals
+    global metadata
+    global engine
+    global session
+    
+    global tablelist
+    
+    def __init__(self, session, metadata, engine, tablelist):
+        Base = declarative_base(metadata = metadata)
+        self.tablelist = self.settables(metadata, engine)
+        try:
+            self.drop(session, self.tablelist)
+        except:
+            pass
+        self.create(Base, engine, metadata, session, self.tablelist)
+        session.commit()
+        #self.send(tablelist)
+    
+    def settables(self, metadata, engine):
+        tablelist = []
+        newseriesdata = Table('newseriesdata', metadata,
+            Column('id', BIGINT, Sequence('newseriesdata_id_seq'), primary_key = True),
+            Column('seriesid',INTEGER, unique=True),
+            Column('thetvdb', String(25)),
+            Column('tvrage', String(25)),
+            Column('imdb', String(25)),
+            Column('language', String(25)),
+            Column('genres', String(75)),
+            Column('name', String(150)),
+            Column('status', String(25)),
+            Column('premiered', String(25)),
+            Column('days', String(72)),
+            Column('time', String(25)),
+            Column('runtime', String(25)),
+            Column('rating', String(25)),
+            Column('type',TEXT),
+            Column('summary',TEXT),
+            Column('medium',TEXT),
+            Column('original',TEXT),
+            Column('weight',INTEGER),
+            Column('networkid', String(25)),
+            Column('webchannelid', String(25)),
+            Column('officialsite',TEXT),
+            Column('url',TEXT),
+            Column('serieslink',TEXT),
+            schema="updates")
+        tablelist.append(newseriesdata)
+        newactordata = Table('newactordata', metadata,
+            Column('id', BIGINT, Sequence('newactordata_id_seq'), primary_key = True),
+            Column('actorid', INTEGER, unique=True),
+            Column('actorname', VARCHAR(72)),
+            Column('countryname', VARCHAR(36)),
+            Column('countrytimezone', VARCHAR(72)),
+            Column('birthday', DATE),
+            Column('deathday', DATE),
+            Column('gender', VARCHAR(6)),
+            Column('mediumimage', TEXT),
+            Column('originalimage', TEXT),
+            Column('apilink', TEXT),
+            Column('url', TEXT),
+            Column('countrycode', VARCHAR(12)),
+            schema="updates")
+        tablelist.append(newactordata)
+        newepdata = Table('newepdata', metadata,
+        Column('id', BIGINT, Sequence('newepdata_id_seq'), primary_key = True),
+            Column('episodeid', INTEGER),
+            Column('seriesid', INTEGER),
+            Column('season', INTEGER),
+            Column('episodenumber', INTEGER),
+            Column('episodename', TEXT),
+            Column('airdate', VARCHAR(32)),
+            Column('airtime', VARCHAR(32)),
+            Column('episodesummary', TEXT),
+            Column('airstamp', VARCHAR(32)),
+            Column('runtime', VARCHAR(6)),
+            Column('eplink', TEXT),
+            Column('mediumimage', TEXT),
+            Column('url', TEXT),
+            Column('originalimage', TEXT),
+            schema="updates")
+        tablelist.append(newepdata)
+        newcastdata = Table('newcastdata', metadata,
+        Column('id', BIGINT, Sequence('newcastdata_id_seq'), primary_key = True),
+            Column('seriesid', INTEGER),
+            Column('characterid', VARCHAR(24)),
+            Column('actorid', VARCHAR(24)),
+            Column('url', TEXT),
+            Column('charactername', VARCHAR(128)),
+            Column('mediumimage', TEXT),
+            Column('originalimage', TEXT),
+            Column('apilink', TEXT),
+            Column('tvmazelink', TEXT),
+            Column('self', CHAR),
+            Column('voice', CHAR),
+            schema="updates")
+        tablelist.append(newcastdata)
+        newcrewdata = Table('newcrewdata', metadata,
+        Column('id', BIGINT, Sequence('newcrewdata_id_seq'), primary_key = True),
+            Column('seriesid', INTEGER),
+            Column('crewid', VARCHAR(128)),
+            Column('type', VARCHAR(128)),
+            Column('url', TEXT),
+            Column('name', VARCHAR(256)),
+            Column('countryid', INTEGER),
+            Column('birthday', DATE),
+            Column('deathday', DATE),
+            Column('gender', VARCHAR(24)),
+            Column('medium', TEXT),
+            Column('original', TEXT),
+            Column('apilink', TEXT),
+            UniqueConstraint('seriesid', 'crewid', 'type', name='crew_unique'),
+            schema="updates")
+        tablelist.append(newcrewdata)
+        tvnetworks = Table('tvnetworkdata', metadata,
+          Column('id', BIGINT, Sequence('network_id_seq'), primary_key = True),
+          Column('name', String(255)),
+          Column('countryid', String(255)),
+          schema = "updates")
+        tablelist.append(tvnetworks)
+        tvwebchannels = Table('tvwebchanneldata', metadata,
+          Column('id', BIGINT, Sequence('webchannel_id_seq'), primary_key = True),
+          Column('name', String(255)),
+          Column('countryid', String(255)),
+          schema = "updates")
+        tablelist.append(tvwebchannels)
+        countries = Table('newcountrydata', metadata,
+          Column('id', BIGINT, Sequence('country_id_seq'), primary_key = True),
+          Column('name', String(255)),
+          Column('code', String(255)),
+          Column('timezone', String(255)),
+          UniqueConstraint('name', 'timezone', name='tz_name_uk'),
+          schema = "updates")
+        tablelist.append(countries)
+        tvupdates = Table('tvupdates', metadata,
+        Column('seriesid', BIGINT, primary_key = True),
+            Column('timestamp', VARCHAR(15)),
+          schema = "updates")
+        tablelist.append(tvupdates)
+        return(tablelist)
+    
+    def create(self, Base, engine, metadata, session, tablelist):
+        print('Creating Temporary Data Tables')
+        Base.metadata.create_all(engine, tables=tablelist)
+
+    def drop(self, session, tablelist):
+        print('Dropping temporary update tables.')
+        for table in tablelist:
+            try:
+                print('Dropping ' + str(table))
+                table.drop()
+            except sqlalchemy.exc.ProgrammingError as se:
+                pass

db/mssql/Updater.py

@@ -0,0 +1,39 @@
+import sqlalchemy
+import progressbar
+from tvmaze.Processor import loadjson
+
+class Updater():
+    def __init__(self):
+        global jprocess
+        
+    def __del__(self):
+        pass
+
+class tvupdates():
+    def __init__(self):
+        pass        
+
+    def update_tables(engine, updatesapi, tablename):
+        jprocess = loadjson()
+        print('Now retrieving available updates.')
+        print('Creating update transaction.')
+        ins = tablename.insert()
+        seriesupdates = jprocess.load(updatesapi)
+        updatelist = []
+        seriesrange = len(seriesupdates) 
+        with progressbar.ProgressBar(maxval=seriesrange, redirect_stdout=True) as p:
+            for key, value in seriesupdates.items():
+                i = int(key)
+                updater = {}
+                updater['seriesid'] = key
+                updater['timestamp'] = value
+                updatelist.append(updater)
+                if i <= seriesrange:
+                    p.update(i)
+                #time.sleep(0.1) 
+        print('Update of tvupdates table is complete.')
+        print('Done.')
+        return(ins, updatelist)
+
+    def __del__(self):
+        pass

db/mssql/execute.py

@@ -0,0 +1,80 @@
+import sqlalchemy
+import progressbar
+import psycopg2.errors
+
+class Update():
+    def __init__(self):
+        global jprocess
+
+    def rawexec(self, sqlquery):
+        connection = engine.connect()
+        try:    
+            trans = connection.begin()
+            connection.execute(str(sqlquery))
+        except:
+            trans.rollback()
+        else:
+            trans.commit()
+            connection.close()
+                
+    def fileexec(self, sqlfile):
+        connection = engine.connect()
+        trans = connection.begin()
+        for line in sqlfile:
+            sqlquery = sqlquery + str(line)
+        try:
+            connection.execute(str(sqlquery))
+        except:
+            trans.rollback()
+            lprint.logprint('error', 'Rollback for filename: ' + str(sqlfile))
+            sqlfile.close()
+            connection.close()
+        else:
+            trans.commit()
+            sqlfile.close()
+            connection.close()
+        
+    def ormexec(self, listing, tablename):
+        try:
+            ins = tablename.insert()
+            result = engine.execute(ins, listing)
+        except sqlalchemy.exc.IntegrityError as ie:
+            if 'UNIQUE KEY' in ie.args[0]:
+                return True
+        except psycopg2.errors.UniqueViolation as ie2:
+            if 'unique constraint' in ie.args[0]:
+                return True
+        else:
+            return False        
+        
+    def __del__(self):
+        pass
+
+class tvupdates():
+    def __init__(self):
+        pass        
+
+    def update_tables(engine, updatesapi, tablename):
+        jprocess = loadjson()
+        print('Now retrieving available updates.')
+        print('Creating update transaction.')
+        ins = tablename.insert()
+        seriesupdates = jprocess.load(updatesapi)
+        updatelist = []
+        seriesrange = len(seriesupdates) 
+        with progressbar.ProgressBar(maxval=seriesrange, redirect_stdout=True) as p:
+            for key, value in seriesupdates.items():
+                i = int(key)
+                updater = {}
+                updater['seriesid'] = key
+                updater['timestamp'] = value
+                updatelist.append(updater)
+                if i <= seriesrange:
+                    p.update(i)
+                #time.sleep(0.1) 
+        print('Update of tvupdates table is complete.')
+        print('Done.')
+        return(ins, updatelist)
+
+    def __del__(self):
+        pass