functions.query_executor 

  1from dictionary.db_config import db_config
  2from dictionary.vars import operational_system
  3import mysql.connector
  4import streamlit as st
  5
  6
  7class QueryExecutor:
  8    """
  9    Classe com métodos para inserção, atualização e tratamento de dados obtidos do banco de dados.
 10    """
 11
 12    def insert_query(self, query: str, values: tuple, success_message: str, error_message: str):
 13        """
 14        Realiza a inserção da consulta no banco de dados.
 15
 16        Parameters
 17        ----------
 18        query : str
 19            A consulta a ser inserida.
 20        values : tuple
 21            A tupla com os valores a serem inseridos.
 22        success_message : str
 23            A mensagem a ser exibida caso a consulta seja inserida com sucesso.
 24        error_message : str
 25            A mensagem a ser exibida caso a consulta apresente erros ao ser inserida.
 26        """
 27        try:
 28            connection = mysql.connector.connect(**db_config)
 29            cursor = connection.cursor()
 30            cursor.execute(query, values)
 31            connection.commit()
 32            cursor.close()
 33            st.toast(":white_check_mark: {}".format(success_message))
 34        except mysql.connector.Error as error:
 35            if error.errno == 1062 or error.errno == 23000:
 36                st.error("Já há um registro com estes dados.")
 37            else:
 38                st.toast(":warning: {} {}".format(error_message, error))
 39                st.error(error)
 40        finally:
 41            if connection.is_connected():
 42                connection.close()
 43                st.toast(body="Inserção finalizada.")
 44
 45    def simple_consult_query(self, query: str, params: tuple):
 46        """
 47        Realiza uma consulta simples no banco de dados, de acordo com os parametros informados.
 48
 49        Parameters
 50        ----------
 51        query : str
 52            A consulta a ser inserida.
 53        params : tuple
 54            A tupla com os valores a serem consultados.
 55        """
 56        try:
 57            connection = mysql.connector.connect(**db_config)
 58            cursor = connection.cursor()
 59            cursor.execute(query, params)
 60            simple_value = cursor.fetchone()
 61            cursor.close()
 62            if simple_value is not None:
 63                return simple_value
 64            else:
 65                return 0
 66        except mysql.connector.Error as error:
 67            st.toast(":warning: Erro ao consultar dado: {}".format(error))
 68            st.error(error)
 69        finally:
 70            if connection.is_connected():
 71                connection.close()
 72
 73    def simple_consult_brute_query(self, query: str):
 74        """
 75        Realiza uma consulta simples no banco de dados.
 76
 77        Parameters
 78        ----------
 79        query : str
 80            A consulta a ser inserida.
 81        """
 82        try:
 83            connection = mysql.connector.connect(**db_config)
 84            cursor = connection.cursor() 
 85            cursor.execute(query)
 86            simple_value = cursor.fetchone()
 87            cursor.close()
 88            if simple_value is not None:
 89                return simple_value
 90            else:
 91                return 0
 92        except mysql.connector.Error as error:
 93            if operational_system == "posix":
 94                st.toast(":warning: Erro ao consultar dado: {}".format(error))
 95                st.error(error)
 96            elif operational_system == "nt":
 97                print("Erro ao consultar dado: {}".format(error))
 98        finally:
 99            if connection.is_connected():
100                connection.close()
101
102    def complex_compund_query(self, query: str, list_quantity: int, params: tuple):
103        """
104        Executa uma consulta composta no banco de dados com base nos parâmetros fornecidos.
105
106        Parameters
107        ----------
108        query : str
109            A consulta SQL a ser executada.
110        list_quantity : int
111            O número de listas que deverão ser criadas para armazenar os resultados.
112        params : tuple
113            Uma tupla contendo os valores que serão utilizados como parâmetros na consulta.
114
115        Returns
116        -------
117        list
118            Uma lista contendo múltiplas listas, cada uma correspondendo aos valores retornados pela consulta.
119        """
120        try:
121            connection = mysql.connector.connect(**db_config)
122            cursor = connection.cursor()
123            cursor.execute(query, params)
124
125            lists = [[] for _ in range(list_quantity)]
126
127            for row in cursor.fetchall():
128                for i in range(list_quantity):
129                    lists[i].append(row[i])
130
131            return lists
132
133        except mysql.connector.Error as err:
134            st.error("Erro ao consultar dados compostos: {}".format(err))
135            return None
136
137        finally:
138            if connection.is_connected():
139                connection.close()
140
141    def complex_consult_query(self, query: str, params: tuple):
142        """
143        Realiza uma consulta complexa no banco de dados, de acordo com os parametros informados.
144
145        Parameters
146        ----------
147        query : str
148            A consulta a ser inserida.
149        params : tuple
150            A tupla com os valores a serem consultados.
151
152        Returns
153        -------
154        complex_value : list
155            A lista com os valores da consulta.
156        """
157        try:
158            connection = mysql.connector.connect(**db_config)
159            cursor = connection.cursor()
160            cursor.execute(query, params)
161            complex_value = cursor.fetchall()
162            cursor.close()
163            if complex_value is not None:
164                return complex_value
165            else:
166                return [0]
167        except mysql.connector.Error as error:
168            st.toast(":warning: Erro ao consultar dados: {}".format(error))
169            st.error(error)
170        finally:
171            if connection.is_connected():
172                connection.close()
173
174    def complex_consult_brute_query(self, query: str):
175        """
176        Realiza uma consulta complexa no banco de dados.
177
178        Parameters
179        ----------
180        query : str
181            A consulta a ser inserida.
182
183        Returns
184        -------
185        complex_value : list
186            A lista com os valores da consulta.
187        """
188        try:
189            connection = mysql.connector.connect(**db_config)
190            cursor = connection.cursor()
191            cursor.execute(query)
192            complex_value = cursor.fetchall()
193            cursor.close()
194            if complex_value is not None:
195                return complex_value
196            else:
197                return [0]
198        except mysql.connector.Error as error:
199            st.toast(":warning: Erro ao consultar dados: {}".format(error))
200            st.error(error)
201        finally:
202            if connection.is_connected():
203                connection.close()
204
205    def treat_simple_result(self, value_to_treat: str, values_to_remove: list):
206        """
207        Realiza o tratamento de uma cadeia de caracteres, de acordo com os parametros informados.
208
209        Parameters
210        ----------
211        value_to_treat : str
212            O valor a ser tratado.
213        values_to_remove : list
214            Os valores a serem removidos.
215
216        Returns
217        -------
218        final_result : str
219            O valor tratado.
220        """
221        final_result = str(value_to_treat)
222
223        for i in range(0, len(values_to_remove)):
224            final_result = final_result.replace(
225                "{}".format(values_to_remove[i]), "")
226
227        return final_result
228
229    def treat_numerous_simple_result(self, values_to_treat: list, values_to_remove: list):
230        """
231        Realiza o tratamento de varias cadeias de caracteres, de acordo com os parametros informados.
232
233        Parameters
234        ----------
235        value_to_treat : list
236            Os valores a serem tratados.
237        values_to_remove : list
238            Os valores a serem removidos.
239
240        Returns
241        -------
242        final_list : list
243            Os valores tratados.
244        """
245        aux_str = ""
246        aux_list = []
247
248        for i in range(0, len(values_to_treat)):
249            aux_str = str(values_to_treat[i])
250            aux_list.append(aux_str)
251
252        final_str = ""
253        final_list = []
254
255        for i in range(0, len(aux_list)):
256            final_str = str(aux_list[i])
257            for i in range(0, len(values_to_remove)):
258                final_str = final_str.replace(
259                    "{}".format(values_to_remove[i]), "")
260            final_list.append(final_str)
261
262        return final_list
263
264    def treat_complex_result(self, values_to_treat, values_to_remove: list):
265        """
266        Realiza o tratamento de uma cadeia de caracteres, de acordo com os parametros informados.
267
268        Parameters
269        ----------
270        value_to_treat : str
271            O valor a ser tratado.
272        values_to_remove : list
273            Os valores a serem removidos.
274
275        Returns
276        -------
277        final_result : str
278            O valor tratado.
279        """
280        aux_str = ""
281        aux_list = []
282
283        final_str = ""
284        final_list = []
285
286        for i in range(0, len(values_to_treat)):
287            aux_str = str(values_to_treat[i])
288            aux_list = aux_str.split(", ")
289            for i in range(0, len(aux_list)):
290                final_str = str(aux_list[i])
291                for i in range(0, len(values_to_remove)):
292                    final_str = final_str.replace(
293                        "{}".format(values_to_remove[i]), "")
294                final_list.append(final_str)
295
296        return final_list
297
298    def check_if_value_exists(self, query):
299        """
300        Verifica se o valor da consulta existe no banco de dados.
301
302        Parameters
303        ----------
304        query : str
305            A consulta a ser verificada.
306
307        Returns
308        -------
309        bool
310            Retorna se o dado consultado existe ou não no banco de dados.
311        """
312        connection = mysql.connector.connect(**db_config)
313        cursor = connection.cursor()
314        cursor.execute(query)
315        return cursor.fetchone() is not None
316
317    def update_table_registers(self, table: str, table_field: str, id_list: list):
318        """
319        Realiza a atualização de registros no banco de dados, de acordo com os parametros informados.
320
321        Parameters
322        ----------
323        table : str
324            A tabela que será atualizada.
325        table_field: str
326            O campo da tabela que será atualizado.
327        id_list : list
328            Os id's de identificação dos registros que serão atualizados.
329        """
330        for i in range(0, len(id_list)):
331
332            update_id_query = """UPDATE {} SET pago = 'S' WHERE id_{} = {}""".format(
333                table, table_field, id_list[i])
334
335            try:
336                connection = mysql.connector.connect(**db_config)
337                cursor = connection.cursor()
338                cursor.execute(update_id_query)
339                connection.commit()
340                cursor.close()
341
342            except mysql.connector.Error as err:
343                st.toast(f"Erro ao pagar despesas do cartão: {err}")
344            finally:
345                if connection.is_connected():
346                    connection.close()
347
348    def update_table_unique_register(self, query: str, success_message: str, error_message: str):
349        """
350        Realiza a atualização de um registro no banco de dados.
351
352        Parameters
353        ----------
354        query : str
355            A consulta de atualização.
356        success_message : str
357            A mensagem que será exibida caso a atualização seja concluída.
358        error_message : str
359            A mensagem que será exibida caso ocorram erros durante a atualização.
360        """
361        try:
362            connection = mysql.connector.connect(**db_config)
363            cursor = connection.cursor()
364            cursor.execute(query)
365            connection.commit()
366            cursor.close()
367
368            st.toast(":white_check_mark: {}".format(success_message))
369        except mysql.connector.Error as error:
370            st.toast(":warning: {} {}".format(error_message, error))
371        finally:
372            if connection.is_connected():
373                connection.close()
class QueryExecutor: 
  8class QueryExecutor:
  9    """
 10    Classe com métodos para inserção, atualização e tratamento de dados obtidos do banco de dados.
 11    """
 12
 13    def insert_query(self, query: str, values: tuple, success_message: str, error_message: str):
 14        """
 15        Realiza a inserção da consulta no banco de dados.
 16
 17        Parameters
 18        ----------
 19        query : str
 20            A consulta a ser inserida.
 21        values : tuple
 22            A tupla com os valores a serem inseridos.
 23        success_message : str
 24            A mensagem a ser exibida caso a consulta seja inserida com sucesso.
 25        error_message : str
 26            A mensagem a ser exibida caso a consulta apresente erros ao ser inserida.
 27        """
 28        try:
 29            connection = mysql.connector.connect(**db_config)
 30            cursor = connection.cursor()
 31            cursor.execute(query, values)
 32            connection.commit()
 33            cursor.close()
 34            st.toast(":white_check_mark: {}".format(success_message))
 35        except mysql.connector.Error as error:
 36            if error.errno == 1062 or error.errno == 23000:
 37                st.error("Já há um registro com estes dados.")
 38            else:
 39                st.toast(":warning: {} {}".format(error_message, error))
 40                st.error(error)
 41        finally:
 42            if connection.is_connected():
 43                connection.close()
 44                st.toast(body="Inserção finalizada.")
 45
 46    def simple_consult_query(self, query: str, params: tuple):
 47        """
 48        Realiza uma consulta simples no banco de dados, de acordo com os parametros informados.
 49
 50        Parameters
 51        ----------
 52        query : str
 53            A consulta a ser inserida.
 54        params : tuple
 55            A tupla com os valores a serem consultados.
 56        """
 57        try:
 58            connection = mysql.connector.connect(**db_config)
 59            cursor = connection.cursor()
 60            cursor.execute(query, params)
 61            simple_value = cursor.fetchone()
 62            cursor.close()
 63            if simple_value is not None:
 64                return simple_value
 65            else:
 66                return 0
 67        except mysql.connector.Error as error:
 68            st.toast(":warning: Erro ao consultar dado: {}".format(error))
 69            st.error(error)
 70        finally:
 71            if connection.is_connected():
 72                connection.close()
 73
 74    def simple_consult_brute_query(self, query: str):
 75        """
 76        Realiza uma consulta simples no banco de dados.
 77
 78        Parameters
 79        ----------
 80        query : str
 81            A consulta a ser inserida.
 82        """
 83        try:
 84            connection = mysql.connector.connect(**db_config)
 85            cursor = connection.cursor() 
 86            cursor.execute(query)
 87            simple_value = cursor.fetchone()
 88            cursor.close()
 89            if simple_value is not None:
 90                return simple_value
 91            else:
 92                return 0
 93        except mysql.connector.Error as error:
 94            if operational_system == "posix":
 95                st.toast(":warning: Erro ao consultar dado: {}".format(error))
 96                st.error(error)
 97            elif operational_system == "nt":
 98                print("Erro ao consultar dado: {}".format(error))
 99        finally:
100            if connection.is_connected():
101                connection.close()
102
103    def complex_compund_query(self, query: str, list_quantity: int, params: tuple):
104        """
105        Executa uma consulta composta no banco de dados com base nos parâmetros fornecidos.
106
107        Parameters
108        ----------
109        query : str
110            A consulta SQL a ser executada.
111        list_quantity : int
112            O número de listas que deverão ser criadas para armazenar os resultados.
113        params : tuple
114            Uma tupla contendo os valores que serão utilizados como parâmetros na consulta.
115
116        Returns
117        -------
118        list
119            Uma lista contendo múltiplas listas, cada uma correspondendo aos valores retornados pela consulta.
120        """
121        try:
122            connection = mysql.connector.connect(**db_config)
123            cursor = connection.cursor()
124            cursor.execute(query, params)
125
126            lists = [[] for _ in range(list_quantity)]
127
128            for row in cursor.fetchall():
129                for i in range(list_quantity):
130                    lists[i].append(row[i])
131
132            return lists
133
134        except mysql.connector.Error as err:
135            st.error("Erro ao consultar dados compostos: {}".format(err))
136            return None
137
138        finally:
139            if connection.is_connected():
140                connection.close()
141
142    def complex_consult_query(self, query: str, params: tuple):
143        """
144        Realiza uma consulta complexa no banco de dados, de acordo com os parametros informados.
145
146        Parameters
147        ----------
148        query : str
149            A consulta a ser inserida.
150        params : tuple
151            A tupla com os valores a serem consultados.
152
153        Returns
154        -------
155        complex_value : list
156            A lista com os valores da consulta.
157        """
158        try:
159            connection = mysql.connector.connect(**db_config)
160            cursor = connection.cursor()
161            cursor.execute(query, params)
162            complex_value = cursor.fetchall()
163            cursor.close()
164            if complex_value is not None:
165                return complex_value
166            else:
167                return [0]
168        except mysql.connector.Error as error:
169            st.toast(":warning: Erro ao consultar dados: {}".format(error))
170            st.error(error)
171        finally:
172            if connection.is_connected():
173                connection.close()
174
175    def complex_consult_brute_query(self, query: str):
176        """
177        Realiza uma consulta complexa no banco de dados.
178
179        Parameters
180        ----------
181        query : str
182            A consulta a ser inserida.
183
184        Returns
185        -------
186        complex_value : list
187            A lista com os valores da consulta.
188        """
189        try:
190            connection = mysql.connector.connect(**db_config)
191            cursor = connection.cursor()
192            cursor.execute(query)
193            complex_value = cursor.fetchall()
194            cursor.close()
195            if complex_value is not None:
196                return complex_value
197            else:
198                return [0]
199        except mysql.connector.Error as error:
200            st.toast(":warning: Erro ao consultar dados: {}".format(error))
201            st.error(error)
202        finally:
203            if connection.is_connected():
204                connection.close()
205
206    def treat_simple_result(self, value_to_treat: str, values_to_remove: list):
207        """
208        Realiza o tratamento de uma cadeia de caracteres, de acordo com os parametros informados.
209
210        Parameters
211        ----------
212        value_to_treat : str
213            O valor a ser tratado.
214        values_to_remove : list
215            Os valores a serem removidos.
216
217        Returns
218        -------
219        final_result : str
220            O valor tratado.
221        """
222        final_result = str(value_to_treat)
223
224        for i in range(0, len(values_to_remove)):
225            final_result = final_result.replace(
226                "{}".format(values_to_remove[i]), "")
227
228        return final_result
229
230    def treat_numerous_simple_result(self, values_to_treat: list, values_to_remove: list):
231        """
232        Realiza o tratamento de varias cadeias de caracteres, de acordo com os parametros informados.
233
234        Parameters
235        ----------
236        value_to_treat : list
237            Os valores a serem tratados.
238        values_to_remove : list
239            Os valores a serem removidos.
240
241        Returns
242        -------
243        final_list : list
244            Os valores tratados.
245        """
246        aux_str = ""
247        aux_list = []
248
249        for i in range(0, len(values_to_treat)):
250            aux_str = str(values_to_treat[i])
251            aux_list.append(aux_str)
252
253        final_str = ""
254        final_list = []
255
256        for i in range(0, len(aux_list)):
257            final_str = str(aux_list[i])
258            for i in range(0, len(values_to_remove)):
259                final_str = final_str.replace(
260                    "{}".format(values_to_remove[i]), "")
261            final_list.append(final_str)
262
263        return final_list
264
265    def treat_complex_result(self, values_to_treat, values_to_remove: list):
266        """
267        Realiza o tratamento de uma cadeia de caracteres, de acordo com os parametros informados.
268
269        Parameters
270        ----------
271        value_to_treat : str
272            O valor a ser tratado.
273        values_to_remove : list
274            Os valores a serem removidos.
275
276        Returns
277        -------
278        final_result : str
279            O valor tratado.
280        """
281        aux_str = ""
282        aux_list = []
283
284        final_str = ""
285        final_list = []
286
287        for i in range(0, len(values_to_treat)):
288            aux_str = str(values_to_treat[i])
289            aux_list = aux_str.split(", ")
290            for i in range(0, len(aux_list)):
291                final_str = str(aux_list[i])
292                for i in range(0, len(values_to_remove)):
293                    final_str = final_str.replace(
294                        "{}".format(values_to_remove[i]), "")
295                final_list.append(final_str)
296
297        return final_list
298
299    def check_if_value_exists(self, query):
300        """
301        Verifica se o valor da consulta existe no banco de dados.
302
303        Parameters
304        ----------
305        query : str
306            A consulta a ser verificada.
307
308        Returns
309        -------
310        bool
311            Retorna se o dado consultado existe ou não no banco de dados.
312        """
313        connection = mysql.connector.connect(**db_config)
314        cursor = connection.cursor()
315        cursor.execute(query)
316        return cursor.fetchone() is not None
317
318    def update_table_registers(self, table: str, table_field: str, id_list: list):
319        """
320        Realiza a atualização de registros no banco de dados, de acordo com os parametros informados.
321
322        Parameters
323        ----------
324        table : str
325            A tabela que será atualizada.
326        table_field: str
327            O campo da tabela que será atualizado.
328        id_list : list
329            Os id's de identificação dos registros que serão atualizados.
330        """
331        for i in range(0, len(id_list)):
332
333            update_id_query = """UPDATE {} SET pago = 'S' WHERE id_{} = {}""".format(
334                table, table_field, id_list[i])
335
336            try:
337                connection = mysql.connector.connect(**db_config)
338                cursor = connection.cursor()
339                cursor.execute(update_id_query)
340                connection.commit()
341                cursor.close()
342
343            except mysql.connector.Error as err:
344                st.toast(f"Erro ao pagar despesas do cartão: {err}")
345            finally:
346                if connection.is_connected():
347                    connection.close()
348
349    def update_table_unique_register(self, query: str, success_message: str, error_message: str):
350        """
351        Realiza a atualização de um registro no banco de dados.
352
353        Parameters
354        ----------
355        query : str
356            A consulta de atualização.
357        success_message : str
358            A mensagem que será exibida caso a atualização seja concluída.
359        error_message : str
360            A mensagem que será exibida caso ocorram erros durante a atualização.
361        """
362        try:
363            connection = mysql.connector.connect(**db_config)
364            cursor = connection.cursor()
365            cursor.execute(query)
366            connection.commit()
367            cursor.close()
368
369            st.toast(":white_check_mark: {}".format(success_message))
370        except mysql.connector.Error as error:
371            st.toast(":warning: {} {}".format(error_message, error))
372        finally:
373            if connection.is_connected():
374                connection.close()

Classe com métodos para inserção, atualização e tratamento de dados obtidos do banco de dados.

def insert_query( self, query: str, values: tuple, success_message: str, error_message: str): 
13    def insert_query(self, query: str, values: tuple, success_message: str, error_message: str):
14        """
15        Realiza a inserção da consulta no banco de dados.
16
17        Parameters
18        ----------
19        query : str
20            A consulta a ser inserida.
21        values : tuple
22            A tupla com os valores a serem inseridos.
23        success_message : str
24            A mensagem a ser exibida caso a consulta seja inserida com sucesso.
25        error_message : str
26            A mensagem a ser exibida caso a consulta apresente erros ao ser inserida.
27        """
28        try:
29            connection = mysql.connector.connect(**db_config)
30            cursor = connection.cursor()
31            cursor.execute(query, values)
32            connection.commit()
33            cursor.close()
34            st.toast(":white_check_mark: {}".format(success_message))
35        except mysql.connector.Error as error:
36            if error.errno == 1062 or error.errno == 23000:
37                st.error("Já há um registro com estes dados.")
38            else:
39                st.toast(":warning: {} {}".format(error_message, error))
40                st.error(error)
41        finally:
42            if connection.is_connected():
43                connection.close()
44                st.toast(body="Inserção finalizada.")

Realiza a inserção da consulta no banco de dados.

Parameters
  • query (str): A consulta a ser inserida.
  • values (tuple): A tupla com os valores a serem inseridos.
  • success_message (str): A mensagem a ser exibida caso a consulta seja inserida com sucesso.
  • error_message (str): A mensagem a ser exibida caso a consulta apresente erros ao ser inserida.
def simple_consult_query(self, query: str, params: tuple): 
46    def simple_consult_query(self, query: str, params: tuple):
47        """
48        Realiza uma consulta simples no banco de dados, de acordo com os parametros informados.
49
50        Parameters
51        ----------
52        query : str
53            A consulta a ser inserida.
54        params : tuple
55            A tupla com os valores a serem consultados.
56        """
57        try:
58            connection = mysql.connector.connect(**db_config)
59            cursor = connection.cursor()
60            cursor.execute(query, params)
61            simple_value = cursor.fetchone()
62            cursor.close()
63            if simple_value is not None:
64                return simple_value
65            else:
66                return 0
67        except mysql.connector.Error as error:
68            st.toast(":warning: Erro ao consultar dado: {}".format(error))
69            st.error(error)
70        finally:
71            if connection.is_connected():
72                connection.close()

Realiza uma consulta simples no banco de dados, de acordo com os parametros informados.

Parameters
  • query (str): A consulta a ser inserida.
  • params (tuple): A tupla com os valores a serem consultados.
def simple_consult_brute_query(self, query: str): 
 74    def simple_consult_brute_query(self, query: str):
 75        """
 76        Realiza uma consulta simples no banco de dados.
 77
 78        Parameters
 79        ----------
 80        query : str
 81            A consulta a ser inserida.
 82        """
 83        try:
 84            connection = mysql.connector.connect(**db_config)
 85            cursor = connection.cursor() 
 86            cursor.execute(query)
 87            simple_value = cursor.fetchone()
 88            cursor.close()
 89            if simple_value is not None:
 90                return simple_value
 91            else:
 92                return 0
 93        except mysql.connector.Error as error:
 94            if operational_system == "posix":
 95                st.toast(":warning: Erro ao consultar dado: {}".format(error))
 96                st.error(error)
 97            elif operational_system == "nt":
 98                print("Erro ao consultar dado: {}".format(error))
 99        finally:
100            if connection.is_connected():
101                connection.close()

Realiza uma consulta simples no banco de dados.

Parameters
  • query (str): A consulta a ser inserida.
def complex_compund_query(self, query: str, list_quantity: int, params: tuple): 
103    def complex_compund_query(self, query: str, list_quantity: int, params: tuple):
104        """
105        Executa uma consulta composta no banco de dados com base nos parâmetros fornecidos.
106
107        Parameters
108        ----------
109        query : str
110            A consulta SQL a ser executada.
111        list_quantity : int
112            O número de listas que deverão ser criadas para armazenar os resultados.
113        params : tuple
114            Uma tupla contendo os valores que serão utilizados como parâmetros na consulta.
115
116        Returns
117        -------
118        list
119            Uma lista contendo múltiplas listas, cada uma correspondendo aos valores retornados pela consulta.
120        """
121        try:
122            connection = mysql.connector.connect(**db_config)
123            cursor = connection.cursor()
124            cursor.execute(query, params)
125
126            lists = [[] for _ in range(list_quantity)]
127
128            for row in cursor.fetchall():
129                for i in range(list_quantity):
130                    lists[i].append(row[i])
131
132            return lists
133
134        except mysql.connector.Error as err:
135            st.error("Erro ao consultar dados compostos: {}".format(err))
136            return None
137
138        finally:
139            if connection.is_connected():
140                connection.close()

Executa uma consulta composta no banco de dados com base nos parâmetros fornecidos.

Parameters
  • query (str): A consulta SQL a ser executada.
  • list_quantity (int): O número de listas que deverão ser criadas para armazenar os resultados.
  • params (tuple): Uma tupla contendo os valores que serão utilizados como parâmetros na consulta.
Returns
  • list: Uma lista contendo múltiplas listas, cada uma correspondendo aos valores retornados pela consulta.
def complex_consult_query(self, query: str, params: tuple): 
142    def complex_consult_query(self, query: str, params: tuple):
143        """
144        Realiza uma consulta complexa no banco de dados, de acordo com os parametros informados.
145
146        Parameters
147        ----------
148        query : str
149            A consulta a ser inserida.
150        params : tuple
151            A tupla com os valores a serem consultados.
152
153        Returns
154        -------
155        complex_value : list
156            A lista com os valores da consulta.
157        """
158        try:
159            connection = mysql.connector.connect(**db_config)
160            cursor = connection.cursor()
161            cursor.execute(query, params)
162            complex_value = cursor.fetchall()
163            cursor.close()
164            if complex_value is not None:
165                return complex_value
166            else:
167                return [0]
168        except mysql.connector.Error as error:
169            st.toast(":warning: Erro ao consultar dados: {}".format(error))
170            st.error(error)
171        finally:
172            if connection.is_connected():
173                connection.close()

Realiza uma consulta complexa no banco de dados, de acordo com os parametros informados.

Parameters
  • query (str): A consulta a ser inserida.
  • params (tuple): A tupla com os valores a serem consultados.
Returns
  • complex_value (list): A lista com os valores da consulta.
def complex_consult_brute_query(self, query: str): 
175    def complex_consult_brute_query(self, query: str):
176        """
177        Realiza uma consulta complexa no banco de dados.
178
179        Parameters
180        ----------
181        query : str
182            A consulta a ser inserida.
183
184        Returns
185        -------
186        complex_value : list
187            A lista com os valores da consulta.
188        """
189        try:
190            connection = mysql.connector.connect(**db_config)
191            cursor = connection.cursor()
192            cursor.execute(query)
193            complex_value = cursor.fetchall()
194            cursor.close()
195            if complex_value is not None:
196                return complex_value
197            else:
198                return [0]
199        except mysql.connector.Error as error:
200            st.toast(":warning: Erro ao consultar dados: {}".format(error))
201            st.error(error)
202        finally:
203            if connection.is_connected():
204                connection.close()

Realiza uma consulta complexa no banco de dados.

Parameters
  • query (str): A consulta a ser inserida.
Returns
  • complex_value (list): A lista com os valores da consulta.
def treat_simple_result(self, value_to_treat: str, values_to_remove: list): 
206    def treat_simple_result(self, value_to_treat: str, values_to_remove: list):
207        """
208        Realiza o tratamento de uma cadeia de caracteres, de acordo com os parametros informados.
209
210        Parameters
211        ----------
212        value_to_treat : str
213            O valor a ser tratado.
214        values_to_remove : list
215            Os valores a serem removidos.
216
217        Returns
218        -------
219        final_result : str
220            O valor tratado.
221        """
222        final_result = str(value_to_treat)
223
224        for i in range(0, len(values_to_remove)):
225            final_result = final_result.replace(
226                "{}".format(values_to_remove[i]), "")
227
228        return final_result

Realiza o tratamento de uma cadeia de caracteres, de acordo com os parametros informados.

Parameters
  • value_to_treat (str): O valor a ser tratado.
  • values_to_remove (list): Os valores a serem removidos.
Returns
  • final_result (str): O valor tratado.
def treat_numerous_simple_result(self, values_to_treat: list, values_to_remove: list): 
230    def treat_numerous_simple_result(self, values_to_treat: list, values_to_remove: list):
231        """
232        Realiza o tratamento de varias cadeias de caracteres, de acordo com os parametros informados.
233
234        Parameters
235        ----------
236        value_to_treat : list
237            Os valores a serem tratados.
238        values_to_remove : list
239            Os valores a serem removidos.
240
241        Returns
242        -------
243        final_list : list
244            Os valores tratados.
245        """
246        aux_str = ""
247        aux_list = []
248
249        for i in range(0, len(values_to_treat)):
250            aux_str = str(values_to_treat[i])
251            aux_list.append(aux_str)
252
253        final_str = ""
254        final_list = []
255
256        for i in range(0, len(aux_list)):
257            final_str = str(aux_list[i])
258            for i in range(0, len(values_to_remove)):
259                final_str = final_str.replace(
260                    "{}".format(values_to_remove[i]), "")
261            final_list.append(final_str)
262
263        return final_list

Realiza o tratamento de varias cadeias de caracteres, de acordo com os parametros informados.

Parameters
  • value_to_treat (list): Os valores a serem tratados.
  • values_to_remove (list): Os valores a serem removidos.
Returns
  • final_list (list): Os valores tratados.
def treat_complex_result(self, values_to_treat, values_to_remove: list): 
265    def treat_complex_result(self, values_to_treat, values_to_remove: list):
266        """
267        Realiza o tratamento de uma cadeia de caracteres, de acordo com os parametros informados.
268
269        Parameters
270        ----------
271        value_to_treat : str
272            O valor a ser tratado.
273        values_to_remove : list
274            Os valores a serem removidos.
275
276        Returns
277        -------
278        final_result : str
279            O valor tratado.
280        """
281        aux_str = ""
282        aux_list = []
283
284        final_str = ""
285        final_list = []
286
287        for i in range(0, len(values_to_treat)):
288            aux_str = str(values_to_treat[i])
289            aux_list = aux_str.split(", ")
290            for i in range(0, len(aux_list)):
291                final_str = str(aux_list[i])
292                for i in range(0, len(values_to_remove)):
293                    final_str = final_str.replace(
294                        "{}".format(values_to_remove[i]), "")
295                final_list.append(final_str)
296
297        return final_list

Realiza o tratamento de uma cadeia de caracteres, de acordo com os parametros informados.

Parameters
  • value_to_treat (str): O valor a ser tratado.
  • values_to_remove (list): Os valores a serem removidos.
Returns
  • final_result (str): O valor tratado.
def check_if_value_exists(self, query): 
299    def check_if_value_exists(self, query):
300        """
301        Verifica se o valor da consulta existe no banco de dados.
302
303        Parameters
304        ----------
305        query : str
306            A consulta a ser verificada.
307
308        Returns
309        -------
310        bool
311            Retorna se o dado consultado existe ou não no banco de dados.
312        """
313        connection = mysql.connector.connect(**db_config)
314        cursor = connection.cursor()
315        cursor.execute(query)
316        return cursor.fetchone() is not None

Verifica se o valor da consulta existe no banco de dados.

Parameters
  • query (str): A consulta a ser verificada.
Returns
  • bool: Retorna se o dado consultado existe ou não no banco de dados.
def update_table_registers(self, table: str, table_field: str, id_list: list): 
318    def update_table_registers(self, table: str, table_field: str, id_list: list):
319        """
320        Realiza a atualização de registros no banco de dados, de acordo com os parametros informados.
321
322        Parameters
323        ----------
324        table : str
325            A tabela que será atualizada.
326        table_field: str
327            O campo da tabela que será atualizado.
328        id_list : list
329            Os id's de identificação dos registros que serão atualizados.
330        """
331        for i in range(0, len(id_list)):
332
333            update_id_query = """UPDATE {} SET pago = 'S' WHERE id_{} = {}""".format(
334                table, table_field, id_list[i])
335
336            try:
337                connection = mysql.connector.connect(**db_config)
338                cursor = connection.cursor()
339                cursor.execute(update_id_query)
340                connection.commit()
341                cursor.close()
342
343            except mysql.connector.Error as err:
344                st.toast(f"Erro ao pagar despesas do cartão: {err}")
345            finally:
346                if connection.is_connected():
347                    connection.close()

Realiza a atualização de registros no banco de dados, de acordo com os parametros informados.

Parameters
  • table (str): A tabela que será atualizada.
  • table_field (str): O campo da tabela que será atualizado.
  • id_list (list): Os id's de identificação dos registros que serão atualizados.
def update_table_unique_register(self, query: str, success_message: str, error_message: str): 
349    def update_table_unique_register(self, query: str, success_message: str, error_message: str):
350        """
351        Realiza a atualização de um registro no banco de dados.
352
353        Parameters
354        ----------
355        query : str
356            A consulta de atualização.
357        success_message : str
358            A mensagem que será exibida caso a atualização seja concluída.
359        error_message : str
360            A mensagem que será exibida caso ocorram erros durante a atualização.
361        """
362        try:
363            connection = mysql.connector.connect(**db_config)
364            cursor = connection.cursor()
365            cursor.execute(query)
366            connection.commit()
367            cursor.close()
368
369            st.toast(":white_check_mark: {}".format(success_message))
370        except mysql.connector.Error as error:
371            st.toast(":warning: {} {}".format(error_message, error))
372        finally:
373            if connection.is_connected():
374                connection.close()

Realiza a atualização de um registro no banco de dados.

Parameters
  • query (str): A consulta de atualização.
  • success_message (str): A mensagem que será exibida caso a atualização seja concluída.
  • error_message (str): A mensagem que será exibida caso ocorram erros durante a atualização.