functions.query_executor 

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

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

Parameters
  • query (str): A consulta a ser inserida.
  • list_quantity (int): A quantidade de listas que deverão ser criadas.
  • params (tuple): A tupla com os valores a serem consultados.
Returns
  • lists (list): A lista com as listas de cada valor da consulta.
def complex_compund_brute_query(self, query: str, list_quantity: int): 
135    def complex_compund_brute_query(self, query: str, list_quantity: int):
136        """
137        Realiza uma consulta composta no banco de dados, de acordo com os parametros informados.
138
139        Parameters
140        ----------
141        query : str
142            A consulta a ser inserida.
143        list_quantity : int
144            A quantidade de listas que deverão ser criadas.
145        params : tuple
146            A tupla com os valores a serem consultados.
147
148        Returns
149        -------
150        lists : list
151            A lista com as listas de cada valor da consulta.
152        """
153        try:
154            connection = mysql.connector.connect(**db_config)
155            cursor = connection.cursor()
156            cursor.execute(query)
157
158            lists = [[] for _ in range(list_quantity)]
159
160            for row in cursor.fetchall():
161                for i in range(list_quantity):
162                    lists[i].append(row[i])
163
164            return lists
165
166        except mysql.connector.Error as err:
167            st.error("Erro ao consultar dados compostos: {}".format(err))
168            return None
169
170        finally:
171            if connection.is_connected():
172                connection.close()

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

Parameters
  • query (str): A consulta a ser inserida.
  • list_quantity (int): A quantidade de listas que deverão ser criadas.
  • params (tuple): A tupla com os valores a serem consultados.
Returns
  • lists (list): A lista com as listas de cada valor da consulta.
def complex_consult_query(self, query: str, params: tuple): 
174    def complex_consult_query(self, query: str, params: tuple):
175        """
176        Realiza uma consulta complexa no banco de dados, de acordo com os parametros informados.
177
178        Parameters
179        ----------
180        query : str
181            A consulta a ser inserida.
182        params : tuple
183            A tupla com os valores a serem consultados.
184
185        Returns
186        -------
187        complex_value : list
188            A lista com os valores da consulta.
189        """
190        try:
191            connection = mysql.connector.connect(**db_config)
192            cursor = connection.cursor()
193            cursor.execute(query, params, multi=True)
194            complex_value = cursor.fetchall()
195            cursor.close()
196            if complex_value is not None:
197                return complex_value
198            else:
199                return [0]
200        except mysql.connector.Error as error:
201            st.toast(":warning: Erro ao consultar dados: {}".format(error))
202            st.error(error)
203        finally:
204            if connection.is_connected():
205                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): 
207    def complex_consult_brute_query(self, query: str):
208        """
209        Realiza uma consulta complexa no banco de dados.
210
211        Parameters
212        ----------
213        query : str
214            A consulta a ser inserida.
215
216        Returns
217        -------
218        complex_value : list
219            A lista com os valores da consulta.
220        """
221        try:
222            connection = mysql.connector.connect(**db_config)
223            cursor = connection.cursor()
224            cursor.execute(query)
225            complex_value = cursor.fetchall()
226            cursor.close()
227            if complex_value is not None:
228                return complex_value
229            else:
230                return [0]
231        except mysql.connector.Error as error:
232            st.toast(":warning: Erro ao consultar dados: {}".format(error))
233            st.error(error)
234        finally:
235            if connection.is_connected():
236                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): 
238    def treat_simple_result(self, value_to_treat: str, values_to_remove: list):
239        """
240        Realiza o tratamento de uma cadeia de caracteres, de acordo com os parametros informados.
241
242        Parameters
243        ----------
244        value_to_treat : str
245            O valor a ser tratado.
246        values_to_remove : list
247            Os valores a serem removidos.
248
249        Returns
250        -------
251        final_result : str
252            O valor tratado.
253        """
254        final_result = str(value_to_treat)
255
256        for i in range(0, len(values_to_remove)):
257            final_result = final_result.replace(
258                "{}".format(values_to_remove[i]), "")
259
260        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): 
262    def treat_numerous_simple_result(self, values_to_treat: list, values_to_remove: list):
263        """
264        Realiza o tratamento de varias cadeias de caracteres, de acordo com os parametros informados.
265
266        Parameters
267        ----------
268        value_to_treat : list
269            Os valores a serem tratados.
270        values_to_remove : list
271            Os valores a serem removidos.
272
273        Returns
274        -------
275        final_list : list
276            Os valores tratados.
277        """
278        aux_str = ""
279        aux_list = []
280
281        for i in range(0, len(values_to_treat)):
282            aux_str = str(values_to_treat[i])
283            aux_list.append(aux_str)
284
285        final_str = ""
286        final_list = []
287
288        for i in range(0, len(aux_list)):
289            final_str = str(aux_list[i])
290            for i in range(0, len(values_to_remove)):
291                final_str = final_str.replace(
292                    "{}".format(values_to_remove[i]), "")
293            final_list.append(final_str)
294
295        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): 
297    def treat_complex_result(self, values_to_treat, values_to_remove: list):
298        """
299        Realiza o tratamento de uma cadeia de caracteres, de acordo com os parametros informados.
300
301        Parameters
302        ----------
303        value_to_treat : str
304            O valor a ser tratado.
305        values_to_remove : list
306            Os valores a serem removidos.
307
308        Returns
309        -------
310        final_result : str
311            O valor tratado.
312        """
313        aux_str = ""
314        aux_list = []
315
316        final_str = ""
317        final_list = []
318
319        for i in range(0, len(values_to_treat)):
320            aux_str = str(values_to_treat[i])
321            aux_list = aux_str.split(", ")
322            for i in range(0, len(aux_list)):
323                final_str = str(aux_list[i])
324                for i in range(0, len(values_to_remove)):
325                    final_str = final_str.replace(
326                        "{}".format(values_to_remove[i]), "")
327                final_list.append(final_str)
328
329        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): 
331    def check_if_value_exists(self, query):
332        """
333        Verifica se o valor da consulta existe no banco de dados.
334
335        Parameters
336        ----------
337        query : str
338            A consulta a ser verificada.
339
340        Returns
341        -------
342        bool
343            Retorna se o dado consultado existe ou não no banco de dados.
344        """
345        connection = mysql.connector.connect(**db_config)
346        cursor = connection.cursor()
347        cursor.execute(query)
348        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): 
350    def update_table_registers(self, table: str, table_field: str, id_list: list):
351        """
352        Realiza a atualização de registros no banco de dados, de acordo com os parametros informados.
353
354        Parameters
355        ----------
356        table : str
357            A tabela que será atualizada.
358        table_field : str
359            O campo da tabela que será atualizado.
360        id_list : list
361            Os id's de identificação dos registros que serão atualizados.
362        """
363        for i in range(0, len(id_list)):
364
365            update_id_query = """UPDATE {} SET pago = 'S' WHERE id_{} = {}""".format(
366                table, table_field, id_list[i])
367
368            try:
369                connection = mysql.connector.connect(**db_config)
370                cursor = connection.cursor()
371                cursor.execute(update_id_query)
372                connection.commit()
373                cursor.close()
374
375            except mysql.connector.Error as err:
376                st.toast(f"Erro ao pagar despesas do cartão: {err}")
377            finally:
378                if connection.is_connected():
379                    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): 
381    def update_table_unique_register(self, query: str, success_message: str, error_message: str):
382        """
383        Realiza a atualização de um registro no banco de dados.
384
385        Parameters
386        ----------
387        query : str
388            A consulta de atualização.
389        success_message : str
390            A mensagem que será exibida caso a atualização seja concluída.\n
391        error_message : str
392            A mensagem que será exibida caso ocorram erros durante a atualização.
393        """
394        try:
395            connection = mysql.connector.connect(**db_config)
396            cursor = connection.cursor()
397            cursor.execute(query)
398            connection.commit()
399            cursor.close()
400
401            st.toast(":white_check_mark: {}".format(success_message))
402        except mysql.connector.Error as error:
403            st.toast(":warning: {} {}".format(error_message, error))
404        finally:
405            if connection.is_connected():
406                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.