def spazio_disco(self, p_ip_server, p_pwd): """ Funzione che esegue il comando "df -h" sul server indicato e lo restituisce come stringa di output Attenzione! Utente di collegamento è oracle """ #imposto i nomi dei file su cui ridirigere output dei comandi (in questo modo non escono le brutte window di dos) v_sshoutput = open( os.path.join(self.o_preferenze.work_dir, 'sshoutput.txt'), 'w') v_sshoutputerror = open( os.path.join(self.o_preferenze.work_dir, 'sshoutputerror.txt'), 'w') v_sshinput = '' try: #spazio del disco. Il comando vero e proprio è "df -h" v_command = 'echo y | utility_prog\\plink -pw ' + p_pwd + ' oracle@' + p_ip_server + ' df -h ' v_ssh = subprocess.Popen(v_command, shell=True, stdin=subprocess.PIPE, stdout=v_sshoutput, stderr=v_sshoutputerror) v_ssh.communicate(v_sshinput) except: message_error('Plink command error on ' + p_ip_server + '!') return 'ko' # leggo il risultato e lo visualizzo return open(self.o_preferenze.work_dir + '\\sshoutput.txt', 'r').read()
def folder_ora02(self, p_ip_server, p_pwd): """ Funzione che esegue il comando "ls" sul server indicato e lo restituisce come stringa di output Attenzione! Utente di collegamento è oracle """ #imposto i nomi dei file su cui ridirigere output dei comandi (in questo modo non escono le brutte window di dos) v_sshoutput = open( os.path.join(self.o_preferenze.work_dir, 'sshoutput.txt'), 'w') v_sshoutputerror = open( os.path.join(self.o_preferenze.work_dir, 'sshoutputerror.txt'), 'w') v_sshinput = '' try: #comando list con opzione verticale (-l) e unità di misura megabyte (-h) v_command = 'echo y | utility_prog\\plink -pw ' + p_pwd + ' oracle@' + p_ip_server + ' ls -lh /ora02/arch/' v_ssh = subprocess.Popen(v_command, shell=True, stdin=subprocess.PIPE, stdout=v_sshoutput, stderr=v_sshoutputerror) v_ssh.communicate(v_sshinput) except: message_error('Plink command error on ' + p_ip_server + '!') return 'ko' # leggo il risultato e lo visualizzo return open(self.o_preferenze.work_dir + '\\sshoutput.txt', 'r').read()
def starter(self): """ Caricamento della pagina iniziale """ # connessione al DB come amministratore try: self.oracle_con = cx_Oracle.connect( user=self.o_preferenze.v_oracle_user_sys, password=self.o_preferenze.v_oracle_password_sys, dsn=self.e_server_name.currentText(), mode=cx_Oracle.SYSDBA) except: message_error( 'Connection to oracle rejected. Please control login information.' ) return None # cambio la label del pulsante di calcoloo in modo sia riportata l'ora di riferimento self.b_calculate.setText( "Compute difference from " + str(datetime.datetime.now().strftime('%H:%M:%S'))) # cancello il contenuto delle pagine di ut_report (tranne record posizione 0) self.t_report.delete_page(self.fname, self.page1) # carico in pagina1 di ut_report, il punto di partenza della situazione sessioni self.load_from_oracle_top_sessions(self.page1) # visualizzo il contenuto della pagina3 self.load_screen(self.page1)
def top(self, p_ip_server, p_pwd): """ Funzione che esegue il comando "top" sul server indicato e lo restituisce come stringa di output Nello specifico l'opzione -b indica di mandare l'output sul file e -n il numero di iterazioni da svolgere Attenzione! Utente di collegamento è oracle """ #imposto i nomi dei file su cui ridirigere output dei comandi (in questo modo non escono le brutte window di dos) v_sshoutput = open( os.path.join(self.o_preferenze.work_dir, 'sshoutput.txt'), 'w') v_sshoutputerror = open( os.path.join(self.o_preferenze.work_dir, 'sshoutputerror.txt'), 'w') v_sshinput = '' try: #comando top con opzione -b (esecuzione in batch) e iterazioni 1 v_command = 'echo y | utility_prog\\plink -pw ' + p_pwd + ' oracle@' + p_ip_server + ' top -b -n 1 ' v_ssh = subprocess.Popen(v_command, shell=True, stdin=subprocess.PIPE, stdout=v_sshoutput, stderr=v_sshoutputerror) v_ssh.communicate(v_sshinput) except: message_error('Plink command error on ' + p_ip_server + '!') return 'ko' # leggo il risultato e lo visualizzo return open(self.o_preferenze.work_dir + '\\sshoutput.txt', 'r').read()
def o_lst1_slot(self, p_index): """ doppio click su listbox di ricerca stringa apre il file indicato """ v_selindex = self.lista_risultati.itemFromIndex(p_index) v_seltext = v_selindex.text() # apro il source scelto a video in base alla tipologia di appartenenza if v_seltext[0:11] == 'PACKAGE -->': self.apre_source_db( 'PACKAGE', v_seltext[v_seltext.find('>') + 2:len(v_seltext)]) elif v_seltext[0:11] == 'TRIGGER -->': self.apre_source_db( 'TRIGGER', v_seltext[v_seltext.find('>') + 2:len(v_seltext)]) elif v_seltext[0:13] == 'PROCEDURE -->': self.apre_source_db( 'PROCEDURE', v_seltext[v_seltext.find('>') + 2:len(v_seltext)]) elif v_seltext[0:12] == 'FUNCTION -->': self.apre_source_db( 'FUNCTION', v_seltext[v_seltext.find('>') + 2:len(v_seltext)]) elif v_seltext[0:9] == 'TABLE -->': self.apre_source_db( 'TABLE', v_seltext[v_seltext.find('>') + 2:len(v_seltext)]) elif v_seltext[0:8] == 'VIEW -->': self.apre_source_db( 'VIEW', v_seltext[v_seltext.find('>') + 2:len(v_seltext)]) # documento windows (es. form o report, doc, xls, ecc.) elif v_seltext != '': try: os.startfile(v_seltext) except: message_error( 'File not found or problem during open application!')
def carica_oggetti_invalidi_db(self): """ carica elenco degli oggetti invalidi """ # connessione al DB come amministratore try: v_connection = cx_Oracle.connect( user=self.o_preferenze.v_oracle_user_sys, password=self.o_preferenze.v_oracle_password_sys, dsn=self.e_server_name.currentText(), mode=cx_Oracle.SYSDBA) except: message_error( 'Connection to oracle rejected. Please control login information.' ) return [] # apro cursori v_cursor = v_connection.cursor() # select per la ricerca degli oggetti invalidi v_cursor.execute( "SELECT OWNER, OBJECT_NAME, OBJECT_TYPE FROM ALL_OBJECTS WHERE STATUS='INVALID' AND OWNER NOT IN ('SYS','APEX_040200') AND OBJECT_NAME NOT LIKE 'OLAP_OLEDB%' ORDER BY OBJECT_TYPE" ) # carico tutte le righe in una lista v_row = v_cursor.fetchall() v_cursor.close() v_connection.close() # restituisco la matrice return v_row
def pubblica(self, p_tipo_server): """ Pubblica il file Oracle Form o Oracle Report nei server indicati se p_tipo_server = 1 compila in SMILE, altrimenti in ICOM """ from compile_oracle_form_report import pubblica_form_report # ricerco la posizione dell'indice selezionato e ne ricavo il contenuto try: v_index = self.o_lst1.selectedIndexes()[0] except: return v_item = self.lista_risultati.itemFromIndex(v_index) v_file = v_item.text() # tipo server if p_tipo_server == '1': v_nome = 'SMILE' else: v_nome = 'ICOM' # se è stato selezionato qualcosa if v_file != '' and message_question_yes_no( "Do you want to compile the file " + chr(10) + v_file + chr(10) + "and post it in " + v_nome + " system?") == 'Yes': #sono ammessi solo file con suffissi specifici if '.fmb' not in v_file and '.rdf' not in v_file: message_error( 'File is not in format "Oracle Form" or "Oracle Report"!') else: # apro una nuova finestra figlia della principale pubblica_form_report(v_file, self.o_preferenze.work_dir, p_tipo_server)
def b_search_slot(self): """ esegue la ricerca """ if self.e_url.displayText() == '': message_error('Please insert a valid URL') return None # pulizia dell'item dei risultati self.lista_risultati.clear() # legge la pagina web try: v_pagina_web = request.urlopen(self.e_url.displayText()) except: message_error('Page not found or unknow error') return None v_contenuto = str(v_pagina_web.read()) v_pos = v_contenuto.find('<img alt="') v_risultato = [] while v_pos > 0: v_pos_fin = v_contenuto.find('"', v_pos + 10) v_risultato.append(v_contenuto[v_pos + 10:v_pos_fin]) v_pos = v_contenuto.find('<img alt="', v_pos + 1) # carica la lista ordinando i risultati alfabeticamente v_risultato_ordinato = sorted(v_risultato) for i in range(1, len(v_risultato_ordinato)): self.lista_risultati.appendRow( QtGui.QStandardItem(v_risultato_ordinato[i]))
def killa_sessione(p_sid, p_serial, p_oracle_user_sys, p_oracle_password_sys, p_oracle_dsn_real): """ killa la sessione oracle dalla coppia p_sid e p_serial """ if message_question_yes_no( "Do you want to kill the selected session?") == 'Yes': try: # connessione al DB come amministratore v_connection = cx_Oracle.connect(user=p_oracle_user_sys, password=p_oracle_password_sys, dsn=p_oracle_dsn_real, mode=cx_Oracle.SYSDBA) v_ok = True except: message_error( 'Connection to oracle rejected. Please control login information.' ) v_ok = False if v_ok: v_cursor = v_connection.cursor() v_cursor.execute("ALTER SYSTEM KILL SESSION '" + str(p_sid).strip() + "," + str(p_serial).strip() + "'") v_cursor.close() v_connection.close() message_info('The session is being closed.')
def get_totale_sessioni_per_utente(self): """ Restituisce totale delle sessioni aperte raggruppate per username """ try: # connessione al DB come amministratore v_connection = cx_Oracle.connect( user=self.o_preferenze.v_oracle_user_sys, password=self.o_preferenze.v_oracle_password_sys, dsn=self.e_server_name.currentText(), mode=cx_Oracle.SYSDBA) except: message_error( 'Connection to oracle rejected. Please control login information.' ) return [] # apro cursori v_cursor = v_connection.cursor() v_user = "" # ricerca parziale su nome utente if self.e_user_name.displayText() != '': v_user += " AND Upper(USERNAME) LIKE '%" + self.e_user_name.displayText( ).upper() + "%' " # ricerca parziale su nome programma if self.e_program_name.displayText() != '': v_user += " AND Upper(MODULE) LIKE '%" + self.e_program_name.displayText( ).upper() + "%' " # ricerca parziale su nome terminale if self.e_terminal.displayText() != '': v_user += " AND Upper(TERMINAL) LIKE '%" + self.e_terminal.displayText( ).upper() + "%' " # select per il conteggio delle sessioni aperte per utente. Se il modulo è ICOM viene preso il campo terminale v_select = "SELECT COUNT(*) \n\ FROM (SELECT DECODE(MODULE,'UNIFACE.EXE',TERMINAL,USERNAME) \n\ FROM V$SESSION,(SELECT PROG_CO, PROG_DE FROM ML_PROG WHERE LNG_CO = 'I') ML_PROG \n\ WHERE USERNAME NOT IN ('SYS','SYSTEM','DBSNMP') AND MODULE = PROG_CO(+) \n\ " + v_user + "GROUP BY DECODE(MODULE,'UNIFACE.EXE',TERMINAL,USERNAME) \n\ )" v_cursor.execute(v_select) # integro i risultati della prima select con altri dati e li carico in una tupla v_totale = 0 for result in v_cursor: # carico la riga nella tupla (notare le doppie parentesi iniziali che servono per inserire nella tupla una lista :-)) v_totale = result[0] # chiudo sessione v_cursor.close() v_connection.close() # restituisco totale return v_totale
def slot_create_script(self): """ Crea lo script SQL per lanciare la creazione di un nuovo DBFile """ # ottengo un oggetto index-qt della riga selezionata index = self.o_lst1.currentIndex() # non devo prendere la cella selezionata ma le celle 0 e 1 della riga selezionata (quella che contiene il nome dello schema e della tabella) v_item_0 = self.lista_risultati.itemFromIndex( index.sibling(index.row(), 0)) v_item_1 = self.lista_risultati.itemFromIndex( index.sibling(index.row(), 1)) if v_item_0 != None: v_schema = v_item_0.text() v_tabella = v_item_1.text() v_script = 'ALTER TABLE ' + v_schema + '.' + v_tabella + ' MOVE' try: # connessione al DB come amministratore v_connection = cx_Oracle.connect( user=self.o_preferenze.v_oracle_user_sys, password=self.o_preferenze.v_oracle_password_sys, dsn=self.e_server_name.currentText(), mode=cx_Oracle.SYSDBA) except: message_error( 'Connection to oracle rejected. Please control login information.' ) return [] # apro cursori v_cursor = v_connection.cursor() # select table space v_select = """SELECT INDEX_NAME, TABLESPACE_NAME FROM DBA_INDEXES WHERE OWNER = '""" + v_schema + """' AND TABLE_NAME= '""" + v_tabella + """' AND INDEX_TYPE='NORMAL' ORDER BY INDEX_NAME """ # carico i dati v_cursor.execute(v_select) v_rows = v_cursor.fetchall() # chiudo sessione v_cursor.close() v_connection.close() # compongo il resto dello script con il nome degli indici for v_row in v_rows: v_script = v_script + chr(10) + '/' + chr( 10 ) + 'ALTER INDEX ' + v_schema + '.' + v_row[0] + ' REBUILD' self.e_sql_script.setText(v_script)
def compila(self, p_nome_programma, p_server): """ Compila il p_nome_programma """ if p_nome_programma != '': try: os.system('c:\ITCCONF\compilaauto.bat "' + p_nome_programma + '" ' + p_server) except: message_error('Problem during object compile!')
def b_search_slot(self): """ esegue la ricerca del file """ # creazione della wait window self.progress = QtWidgets.QProgressDialog(self) self.progress.setMinimumDuration(0) self.progress.setWindowModality(QtCore.Qt.WindowModal) self.progress.setWindowTitle("Please wait...") # imposto valore minimo e massimo a 0 in modo venga considerata una progress a tempo indefinito # Attenzione! dentro nel ciclo deve essere usata la funzione setvalue altrimenti non visualizza e non avanza nulla! self.progress.setMinimum(0) self.progress.setMaximum(0) # creo un campo label che viene impostato con 100 caratteri in modo venga data una dimensione di base standard self.progress_label = QtWidgets.QLabel() self.progress_label.setText('.' * 100) # collego la label già presente nell'oggetto progress bar con la mia label self.progress.setLabel(self.progress_label) v_ok = True # controllo che ci siano i dati obbligatori if self.e_filesearch.displayText() == '': message_error('Please enter a file name') v_ok = False if self.e_pathname.displayText() == '': message_error('Please enter a pathname') v_ok = False # i controlli sono stati superati --> avvio la ricerca if v_ok: # Se la cache non è attiva, controllo se sono cambiati i valori di ricerca (es. path) perché allora vuol dire che la cache va ripristinata if not self.c_cache_file_system.isChecked(): if self.v_t2_pathname != self.e_pathname.displayText( ) or self.v_t2_filter != self.e_filter.displayText( ) or self.v_t2_excludepath != self.e_excludepath.displayText(): # I valori sono cambiati e la cache va ricaricata self.c_cache_file_system.setChecked() # Carico le var globali che permetteranno il confronto ai giri successivi. In pratica la cache va ricaricata automaticamente se sono cambiati dei parametri di ricerca self.v_t2_pathname = self.e_pathname.displayText() self.v_t2_filter = self.e_filter.displayText() self.v_t2_excludepath = self.e_excludepath.displayText() # pulizia dell'item dei risultati self.lista_risultati.clear() # richiama la ricerca nel file system se presente file system self.ricerca_file(self.e_pathname.displayText(), self.e_filesearch.displayText(), self.e_filter.displayText(), self.e_excludepath.displayText()) # chiudo la wait window self.progress.close()
def creo_tabella(self, p_definizione_colonne, p_table_name): #se siamo in modalità test --> cancello la tabella if self.v_debug: try: print("Cancellazione della tabella " + p_table_name) v_query = 'DROP TABLE ' + p_table_name self.v_oracle_cursor.execute(v_query) except: pass v_query = 'CREATE TABLE ' + p_table_name + '(' v_1a_volta = True #definizione_colonne risulta così strutturata #1° campo = Nome #2° campo = Tipo (varchar2, number) #3° campo = Larghezza colonna (per numeri solo la parte intera) #4° campo = Larghezza decimali (solo per numeri con decimali) for valori in p_definizione_colonne: if v_1a_volta: v_1a_volta = False else: v_query += ',' v_query += valori[0] + ' ' + valori[1] if valori[1] == 'VARCHAR2': #la colonna risulta varchar2 ma sono stati trovati all'interno dei numeri con decimali....per evitare #problemi aumento la grandezza della colonna aggiungendo anche i decimali + altri due caratteri per #separatore decimali e eventuale segno meno if valori[3] > 0: v_query += '(' + str(valori[2] + valori[3] + 2) + ')' #altrimenti è puro char else: v_query += '(' + str(valori[2]) + ')' elif valori[1] == 'NUMBER': v_query += '(' + str(valori[2] + valori[3]) + ',' + str( valori[3]) + ')' v_query += ')' if self.v_debug: print("Creazione della tabella " + v_query) #Invio del comando di creazione tabella try: self.v_oracle_cursor.execute(v_query) except: message_error( "Problem during create Oracle table!" + chr(10) + "The table " + p_table_name + " already exists?" + chr(10) + "Remember that the excel file must be haven't formatting and filters activated!" ) #esco return 'ko' return 'ok'
def slot_doppio_click_lista(self, p_index): """ Doppio click su listbox """ v_selindex = self.lista_risultati.itemFromIndex(p_index) v_seltext = v_selindex.text() if v_seltext != '': try: os.startfile(v_seltext) except: message_error( 'File not found or problem during open application!')
def slot_log_session(self, event): """ crea un file riportante le informazioni di sessione (al momento i cursori aperti) """ # ottengo un oggetto index-qt della riga selezionata index = self.o_lst1.currentIndex() # non devo prendere la cella selezionata ma la cella 0 e 1 della riga selezionata (esse contengono sid e serial nr della sessione) v_item_0 = self.lista_risultati.itemFromIndex( index.sibling(index.row(), 0)) v_item_1 = self.lista_risultati.itemFromIndex( index.sibling(index.row(), 1)) v_sid = v_item_0.text() v_serial_n = v_item_1.text() # apro il file dei risultati v_file_name = os.path.join(self.o_preferenze.work_dir, 'session_information.sql') v_file = open(v_file_name, 'w') try: # connessione al DB come amministratore v_connection = cx_Oracle.connect( user=self.o_preferenze.v_oracle_user_sys, password=self.o_preferenze.v_oracle_password_sys, dsn=self.e_server_name.currentText(), mode=cx_Oracle.SYSDBA) except: message_error( 'Connection to oracle rejected. Please control login information.' ) return None # apro cursore v_cursor = v_connection.cursor() # select per la ricerca dei cursori aperti e relativo sql v_select = "SELECT sql_text FROM v$sql WHERE hash_value IN (SELECT hash_value FROM v$open_cursor WHERE SID=" + str( v_sid) + ") GROUP BY sql_text" v_cursor.execute(v_select) for result in v_cursor: # scrivo i risultati nel file v_file.write(result[0] + '\n') v_cursor.close() v_connection.close() v_file.close() message_info(v_file_name + ' created!') # apre il file appena creato os.startfile(v_file_name)
def slot_load(self): """ Carica un file sql """ fileName = QtWidgets.QFileDialog.getOpenFileName( self, "Choose a sql file", "", "Sql (*.sql)") if fileName[0] != "": try: v_file = open(fileName[0], 'r') self.e_sql.clear() self.e_sql.setText(v_file.read()) except: message_error('Error to opened the file')
def o_lst1_slot(self, p_index): """ doppio click su listbox di ricerca stringa apre il file indicato """ v_selindex = self.lista_risultati.itemFromIndex(p_index) v_seltext = v_selindex.text() if v_seltext != '': try: os.startfile(v_seltext) except: message_error( 'File not found or problem during open application!')
def slot_b_start_download(self): """ esegue il download dell'oggetto indicato """ if self.e_source.displayText() == '': message_error('You must enter a source file name with suffix!') return None if self.e_destination_dir.displayText() == '': message_error('You must enter a destination dir!') return None # controllo che il file di destinazione non esista; questo perché al termine del download solo controllando la presenza del file # potrò dire che il download è stato correttamente eseguito v_sorgente = self.e_source.displayText() v_destinazione = os.path.join(self.e_destination_dir.displayText() + '/' + v_sorgente) if os.path.isfile(v_destinazione): message_error("Destination file already exists!") return None #imposto i nomi dei file su cui ridirigere output dei comandi (in questo modo non escono le brutte window di dos) v_sshoutput = open( os.path.join(self.o_preferenze.work_dir, 'sshoutput.txt'), 'w') v_sshoutputerror = open( os.path.join(self.o_preferenze.work_dir, 'sshoutputerror.txt'), 'w') v_sshinput = '' # eseguo il download try: # scarico il file nella directory indicata v_ip = '10.0.4.14' v_pwd = self.o_preferenze.v_server_password_iAS v_command = 'echo y | utility_prog\\pscp -pw ' + v_pwd + ' oracle@' + v_ip + ':/appl/source/' + v_sorgente + ' ' + v_destinazione v_ssh = subprocess.Popen(v_command, shell=True, stdin=subprocess.PIPE, stdout=v_sshoutput, stderr=v_sshoutputerror) v_ssh.communicate(v_sshinput) # controllo se il file è stato effettivamente scaricato if os.path.isfile(v_destinazione): message_info('Download finished!') else: message_error('Error to download ' + self.e_source.displayText() + '!') except: message_error('Error to download ' + self.e_source.displayText() + '!') return None
def fileSaveAs(self): fn, _ = QtWidgets.QFileDialog.getSaveFileName(oracle_my_sql_window, "Save as...", self.filename,"SQL files (*.sql)") if not fn: message_error('Error saving') return False lfn = fn.lower() if not lfn.endswith('.sql'): fn += '.sql' self.filename = fn self.fname = os.path.splitext(str(fn))[0].split("/")[-1] return self.fileSave()
def ricerca_stringa_in_icom(self, v_string1, v_string2, v_output): """ ricerca stringa in sorgenti ICOM-UNIFACE """ v_abort = False try: v_connection = cx_Oracle.connect( 'icom_ng_source/icom_ng_source@uniface') v_error = False except: message_error( 'Connection rejected! Search in ICOM-UNIFACE will skipped!') v_error = True v_progress_step = 0 if not v_error: # apro il file di output che conterra' i risultati della ricerca f_output = open(v_output, 'a') # apro cursori v_cursor = v_connection.cursor() v_cursor_det = v_connection.cursor() # output a video del file in elaborazione (notare incremento del value e impostazione della label) v_progress_step += 1 self.progress.setValue(v_progress_step) self.progress_label.setText('ICOM-UNIFACE') self.progress.setLabel(self.progress_label) # eseguo la ricerca con apposita funzione v_cursor.execute( 'SELECT rep_search_function(:string1,:string2) FROM dual', { 'string1': v_string1, 'string2': v_string2 }) for result in v_cursor: if result[0] is not None: v_lista = result[0].split(',') for i in v_lista: # output a video delle ricorrenze trovate self.lista_risultati.appendRow( QtGui.QStandardItem('ICOM source --> ' + i)) f_output.write('ICOM source' + ';' + i + ';\n') # chiusura cursori e connessione DB v_cursor.close() v_connection.close() f_output.close() return v_abort
def get_elenco_tabelle_bloccate(self): """ Restituisce in una tupla elenco delle sessioni bloccate """ if self.e_table_name.currentText() == '': message_error('Please insert a Oracle table name') return [] try: # connessione al DB come amministratore v_connection = cx_Oracle.connect( user=self.o_preferenze.v_oracle_user_sys, password=self.o_preferenze.v_oracle_password_sys, dsn=self.e_server_name.currentText(), mode=cx_Oracle.SYSDBA) except: message_error( 'Connection to oracle rejected. Please control login information.' ) return [] v_row = [] # apro cursori v_cursor = v_connection.cursor() # select per la ricerca degli oggetti invalidi v_select = """SELECT v$lock.SID SID, v$session.SERIAL# SERIAL_NUMBER, V$SESSION.USERNAME USERNAME, V$SESSION.STATUS STATUS, V$SESSION.OSUSER OSUSER, V$SESSION.MACHINE MACHINE, V$SESSION.PROGRAM||'.'||V$SESSION.MODULE PROGRAM FROM v$lock, v$session WHERE id1 = (SELECT object_id FROM all_objects WHERE owner ='SMILE' AND object_name = RTRIM(LTRIM(UPPER('""" + self.e_table_name.currentText( ) + """')))) AND v$lock.sid=v$session.sid""" v_cursor.execute(v_select) # carico tutte le righe in una lista v_row = v_cursor.fetchall() # chiudo connessione e restituisco la tupla v_cursor.close() v_connection.close() return v_row
def slot_startjob(self): """ Avvia un job """ if hasattr(self, 'lista_risultati'): # ottengo un oggetto index-qt della riga selezionata index = self.o_lst1.currentIndex() # non devo prendere la cella selezionata ma la cella 0 della riga selezionata (quella che contiene il nome del job) v_item_0 = self.lista_risultati.itemFromIndex( index.sibling(index.row(), 0)) if v_item_0 != None: v_job_name = v_item_0.text() if message_question_yes_no( 'Do you want start ' + v_job_name + ' job?\nNotice! MGrep will be waiting the end of job!' ) == 'Yes': try: # connessione al DB come amministratore v_connection = cx_Oracle.connect( user=self.o_preferenze.v_oracle_user_sys, password=self.o_preferenze.v_oracle_password_sys, dsn=self.e_server_name.currentText(), mode=cx_Oracle.SYSDBA) except: message_error( 'Connection to oracle rejected. Please control login information.' ) return [] # apro cursore v_cursor = v_connection.cursor() # imposto l'istruzione v_istruzione = "BEGIN DBMS_SCHEDULER.RUN_JOB (job_name => 'SMILE." + v_job_name + "'); END;" # eseguo istruzione monitorando eventuali errori (attivo l'icona della clessidra) try: QtWidgets.QApplication.setOverrideCursor( QtGui.QCursor(QtCore.Qt.WaitCursor)) v_cursor.execute(v_istruzione) QtWidgets.QApplication.restoreOverrideCursor() message_info('Job finished :-)') # se riscontrato errore --> emetto sia codice che messaggio except cx_Oracle.Error as e: errorObj, = e.args message_error("Error: " + errorObj.message) # chiudo e disattivo icona della clessidra v_cursor.close() v_connection.close() QtWidgets.QApplication.restoreOverrideCursor()
def get_elenco_tabelle(self, p_table_to_search): """ Restituisce elenco dbfile in una table in base al tablespace ricevuto in ingresso """ try: # connessione al DB come amministratore v_connection = cx_Oracle.connect( user=self.o_preferenze.v_oracle_user_sys, password=self.o_preferenze.v_oracle_password_sys, dsn=self.e_server_name.currentText(), mode=cx_Oracle.SYSDBA) except: message_error( 'Connection to oracle rejected. Please control login information.' ) return [] # apro cursori v_cursor = v_connection.cursor() # select table space if p_table_to_search != '': v_where = " AND TABLE_NAME LIKE '%' || '" + p_table_to_search.upper( ) + "' || '%'" else: v_where = '' v_select = """SELECT OWNER, TABLE_NAME, ROUND((BLOCKS * 8)/1000,0) "SIZE_MBYTE", ROUND((NUM_ROWS * AVG_ROW_LEN / 1024)/1000, 0) "ACTUAL_DATA_MBYTE", (ROUND((BLOCKS * 8)/1000,0) - ROUND((NUM_ROWS * AVG_ROW_LEN / 1024)/1000, 0)) "WASTED_MBYTE" FROM DBA_TABLES WHERE (ROUND((BLOCKS * 8)/1000,0) - ROUND((NUM_ROWS * AVG_ROW_LEN / 1024)/1000, 0)) > 0 AND OWNER <> 'SYS' """ + v_where + """ ORDER BY 5 DESC """ # carico i dati v_cursor.execute(v_select) v_row = v_cursor.fetchall() # chiudo sessione v_cursor.close() v_connection.close() # restituisco tupla delle righe return v_row
def get_elenco_table_space(self): """ Restituisce in una tupla elenco dei table space """ try: # connessione al DB come amministratore v_connection = cx_Oracle.connect( user=self.o_preferenze.v_oracle_user_sys, password=self.o_preferenze.v_oracle_password_sys, dsn=self.e_server_name.currentText(), mode=cx_Oracle.SYSDBA) except: message_error( 'Connection to oracle rejected. Please control login information.' ) return [] # apro cursori v_cursor = v_connection.cursor() # select table space v_select = """SELECT DF.TABLESPACE_NAME "TABLESPACE", ROUND(TU.TOTALUSEDSPACE * 100 / DF.TOTALSPACE) "PERC_USED", DF.TOTALSPACE "TOTAL MB", TOTALUSEDSPACE "USED MB", (DF.TOTALSPACE - TU.TOTALUSEDSPACE) "FREE MB" FROM (SELECT TABLESPACE_NAME, ROUND(SUM(BYTES) / 1048576) TOTALSPACE FROM DBA_DATA_FILES GROUP BY TABLESPACE_NAME) DF, (SELECT ROUND(SUM(BYTES)/(1024*1024)) TOTALUSEDSPACE, TABLESPACE_NAME FROM DBA_SEGMENTS GROUP BY TABLESPACE_NAME) TU WHERE DF.TABLESPACE_NAME = TU.TABLESPACE_NAME AND DF.TOTALSPACE <> 0 ORDER BY ROUND(TU.TOTALUSEDSPACE * 100 / DF.TOTALSPACE) DESC """ # carico i dati v_cursor.execute(v_select) v_row = v_cursor.fetchall() # chiudo sessione v_cursor.close() v_connection.close() # restituisco tupla delle righe return v_row
def slot_connect(self): """ Esegue connessione a Oracle """ try: # chiudo eventuale connessione già aperta if self.v_connesso: self.v_cursor.close() # connessione al DB come smile self.v_connection = cx_Oracle.connect(user='******', password='******', dsn=self.e_server_name.currentText()) # apro cursore self.v_cursor = self.v_connection.cursor() # imposto var che indica la connesione a oracle self.v_connesso = True except: message_error('Error to oracle connection!')
def slot_open_folder(self): """ Apre la cartella dove si trova il file selezionato """ try: # ricerco la posizione dell'indice selezionato e ne ricavo il contenuto v_index = self.o_lst1.selectedIndexes()[0] v_item = self.lista_risultati.itemFromIndex(v_index) v_seltext = v_item.text() if v_seltext != '': try: os.startfile(v_seltext[0:v_seltext.rfind('\\')]) except: message_error('Problem during open object folder!') except: message_error('Problem during open object folder!')
def slot_converte(self): ''' Esegue la conversione del testo semplice in testo graphics ascii ''' if self.e_converte.displayText() == '': message_error('Please insert a text') return None # il risultato viene impostato con il font richiesto (da non confondersi con il font con cui viene visualizzato) if self.e_fonts_list.currentText() != '': risultato = pyfiglet.figlet_format( self.e_converte.displayText(), font=self.e_fonts_list.currentText() ) # se però non è stato indicato alcun fonts, lascio il default else: risultato = pyfiglet.figlet_format( self.e_converte.displayText() ) # imposto il risultato nella textbox self.e_risultato.clear() self.e_risultato.append(risultato)
def fileSave(self): if (self.filename != ""): file = QtCore.QFile(self.filename[0]) if not file.open( QtCore.QFile.WriteOnly | QtCore.QFile.Text): message_error("Cannot write file %s:\n%s." % (self.filename, file.errorString())) return outstr = QtCore.QTextStream(file) QtWidgets.QApplication.setOverrideCursor(QtCore.Qt.WaitCursor) outstr << self.e_sql.toPlainText() QtWidgets.QApplication.restoreOverrideCursor() self.setModified(False) self.fname = QtCore.QFileInfo(self.filename[0]).fileName() oracle_my_sql_window.setWindowTitle(self.fname + "[*]") else: self.fileSaveAs()
def openFile(self): """ Apertura di un file """ if self.maybeSave(): fileName = QtWidgets.QFileDialog.getOpenFileName(oracle_my_sql_window, "Open File", QtCore.QDir.homePath() + "/Documents/","SQL Files (*.sql);;All Files (*.*)") if fileName[0] != "": try: v_file = open(fileName[0],'r') self.e_sql.clear() self.e_sql.setPlainText( v_file.read() ) self.filename = fileName self.setModified(False) oracle_my_sql_window.setWindowTitle(self.titolo_window + ': ' + fileName[0]) self.document = self.e_sql.document() except: message_error('Error to opened the file')