DE-Lib 0.0.20__tar.gz → 0.0.36__tar.gz

{de_lib-0.0.20 → de_lib-0.0.36}/DE_LIB.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: DE_Lib
-Version: 0.0.20
+Version: 0.0.36
 Summary: Biblioteca de funcionalidades
 Home-page: https://github.com/DE-DATAx/DAX_DB.git
 Author: Almir J Gomes
@@ -22,6 +22,7 @@ Dynamic: author-email
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: summary
 

{de_lib-0.0.20 → de_lib-0.0.36}/DE_LIB.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ DE_Lib/DataBase/Metadata.py
 DE_Lib/DataBase/MsSql.py
 DE_Lib/DataBase/MySql.py
 DE_Lib/DataBase/Oracle.py
+DE_Lib/DataBase/OracleDDL.py
 DE_Lib/DataBase/Postgres.py
 DE_Lib/DataBase/RedShift.py
 DE_Lib/DataBase/SQCipher.py
@@ -32,6 +33,7 @@ DE_Lib/Files/JSon.py
 DE_Lib/Files/Parquet.py
 DE_Lib/Files/Txt.py
 DE_Lib/Files/Xlsx.py
+DE_Lib/Files/Zip.py
 DE_Lib/Files/__init__.py
 DE_Lib/Log/DE_LogEventos.py
 DE_Lib/Log/Level.py
@@ -41,6 +43,7 @@ DE_Lib/Utils/Colors.py
 DE_Lib/Utils/DateUtils.py
 DE_Lib/Utils/Generic.py
 DE_Lib/Utils/SQL.py
+DE_Lib/Utils/Sql.py
 DE_Lib/Utils/System.py
 DE_Lib/Utils/WebHook.py
 DE_Lib/Utils/__init__.py

de_lib-0.0.36/DE_Lib/DataBase/Azure.py

@@ -0,0 +1,55 @@
+"""
+Faltam testes mais conclusivos
+"""
+import redshift_connector as redshift
+from azure.storage.filedatalake import DataLakeServiceClient
+import os
+import json
+
+from DE_Lib.Utils import Generic
+
+gen = Generic.GENERIC()
+
+
+class AZURE:
+    def __init__(self):
+        self._connection_is_valid = None
+        self._nome_database = None
+        self._cnn = None
+        self.__database_error = None
+
+    def Connect(self, string_connect: dict):
+        conn, result = None, None
+        try:
+            conn = DataLakeServiceClient(host=string_connect["host"],
+                              database=string_connect["instance"],
+                              user=string_connect["username"],
+                              password=string_connect["password"]
+                              )
+            self._connection_is_valid = True
+            self._cnn = result
+            self.__database_error = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nConexao bem sucedida!"""
+            self._nome_database = gen.nvl(string_connect["database"], "")
+        except Exception as error:
+            msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nFalha ao tentar se conectar com o banco de dados AZURE\nException Error: {error} """
+            result = msg
+            self._connection_is_valid = False
+            self.__database_error = msg
+        finally:
+            return result
+
+    @property
+    def CONNECTION(self):
+        return self._cnn
+
+    @property
+    def CONNECTION_VALID(self):
+        return self._connection_is_valid
+
+    @property
+    def NOME_DATABASE(self):
+        return self._nome_database.upper()
+
+    @property
+    def DATABASE_ERROR(self):
+        return self.__database_error

{de_lib-0.0.20 → de_lib-0.0.36}/DE_Lib/DataBase/Cache.py

@@ -3,7 +3,11 @@ import jpype as jp
 import os
 import json
 
-class Cache:
+from DE_Lib.Utils import Generic
+
+gen = Generic.GENERIC()
+
+class CACHE:
     def __init__(self):
         self._connection_is_valid = None
         self._nome_database = None
@@ -48,7 +52,7 @@ class Cache:
             self._connection_is_valid = True
             self._cnn = result
             self._database_error = f"""{json.dumps(string_connect, indent=4).replace(string_connect["pwd"], "******")}\nConexao bem sucedida!"""
-            self._nome_database = string_connect["database"]
+            self._nome_database = gen.nvl(string_connect["database"], "")
         except Exception as error:
             msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["pwd"], "******")}\nFalha ao tentar se conectar com o banco de dados CACHÉ (intersystem)\nException Error: {error} """
             result = msg
@@ -57,6 +61,8 @@ class Cache:
         finally:
             return result
 
+
+
     @property
     def CONNECTION(self):
         return self._cnn

{de_lib-0.0.20 → de_lib-0.0.36}/DE_Lib/DataBase/Firebird.py

@@ -1,6 +1,12 @@
 import fbd
+import os
+import json
 
-class Firebird:
+from DE_Lib.Utils import Generic
+
+gen = Generic.GENERIC()
+
+class FIREBIRD:
     def __init__(self):
         self._connection_is_valid = None
         self._nome_database = None
@@ -10,7 +16,7 @@ class Firebird:
     # ----------------------------------------------------------------
     # Falta driver - maquina local não permite
     def Connect(self, string_connect: dict):
-        msg, conn = None, None
+        msg, conn, result = None, None, None
         try:
             user = string_connect["username"]
             pwd = string_connect["password"]
@@ -19,13 +25,16 @@ class Firebird:
             instance = string_connect["instance"]
             conn = fbd.connect(host=host, database=instance, user=user, password=pwd, port=port)
             self._connection_is_valid = True
-            self._nome_database = string_connect["database"]
-            self._cnn = conn
+            self._nome_database = gen.nvl(string_connect["database"], "")
+            self._cnn = result
+            self.__database_error = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nConexao bem sucedida!"""
         except Exception as error:
-            conn = error
+            msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nFalha ao tentar se conectar com o banco de dados ORACLE\nException Error: {error} """
+            result = msg
             self._connection_is_valid = False
-            self._DATABASE_ERROR = conn.DatabaseError
+            self.__database_error = msg
         finally:
+            return result
             return conn
 
     @property

{de_lib-0.0.20 → de_lib-0.0.36}/DE_Lib/DataBase/Informix.py

@@ -1,6 +1,11 @@
+import os
+import json
 
+from DE_Lib.Utils import Generic
 
-class Informix:
+gen = Generic.GENERIC()
+
+class INFORMIX:
     def __init__(self):
         self._connection_is_valid = None
         self._nome_database = None
@@ -10,15 +15,20 @@ class Informix:
     # ----------------------------------------------------------------
     # Falta tudo (Instalar driver ODBC) Maquina local não permite
     def Connect(self, string_connect: dict):
+        msg, result = None, None
         try:
             pass
             self._connection_is_valid = True
-            self._cnn = None
+            self._nome_database = gen.nvl(string_connect["database"], "")
+            self._cnn = result
+            self.__database_error = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nConexao bem sucedida!"""
         except Exception as error:
+            msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nFalha ao tentar se conectar com o banco de dados ORACLE\nException Error: {error} """
+            result = msg
             self._connection_is_valid = False
-            self._DATABASE_ERROR = True
+            self.__database_error = msg
         finally:
-            pass
+            return result
 
     @property
     def CONNECTION(self):

{de_lib-0.0.20 → de_lib-0.0.36}/DE_Lib/DataBase/Metadata.py

@@ -1,6 +1,6 @@
 import pandas as pd
 
-class Metadata:
+class METADATA:
     def __init__(self):
         ...
 

de_lib-0.0.20/DE_Lib/DataBase/MySql.py → de_lib-0.0.36/DE_Lib/DataBase/MsSql.py

@@ -1,7 +1,10 @@
-import mysql.connector as mysql
-import json
+import pymssql as mssql
 
-class MySql:
+from DE_Lib.Utils import Generic
+
+gen = Generic.GENERIC()
+
+class MSSQL:
     def __init__(self):
         self._connection_is_valid = None
         self._nome_database = None
@@ -12,16 +15,16 @@ class MySql:
         msg, conn = None, None
         try:
             # Efetuando a conexao com a instancia do BANCO
-            result = mysql.connect(user=string_connect["username"], password=string_connect["password"], database=string_connect["instance"], host=string_connect["host"])
+            conn = mssql.connect(user=string_connect["username"], password=string_connect["password"], database=string_connect["instance"], server=string_connect["host"])
             self._connection_is_valid = True
             self._cnn = result
-            self._DATABASE_ERROR = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nConexao bem sucedida!"""
-            self._nome_database = string_connect["database"]
+            self.__database_error = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nConexao bem sucedida!"""
+            self._nome_database = gen.nvl(string_connect["database"], "")
         except Exception as error:
-            msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nFalha ao tentar se conectar com o banco de dados MYSQL\nException Error: {error} """
+            msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nFalha ao tentar se conectar com o banco de dados MSSQL (SqlAlchemy)\nException Error: {error} """
             result = msg
             self._connection_is_valid = False
-            self._DATABASE_ERROR = msg
+            self.__database_error = msg
         finally:
             return result
 

de_lib-0.0.36/DE_Lib/DataBase/MySql.py

@@ -0,0 +1,68 @@
+import mysql.connector as mysql
+import pymysql
+import sqlalchemy as sqa
+import json
+
+from DE_Lib.Utils import Generic
+
+gen = Generic.GENERIC()
+
+class MYSQL:
+    def __init__(self):
+        self._connection_is_valid = None
+        self._nome_database = None
+        self.__database_driver = None
+        self._cnn = None
+        self.__database_error = None
+
+    def Connect(self, conn: dict):
+        msg, result = None, True
+        try:
+            # Efetuando a conexao com a instancia do BANCO
+            __conn = None
+            if conn["driver_conexao"].upper() == "SQLALCHEMY":
+                __dns = f"""{conn["database"].lower()}+pymysql://{conn["username"]}:{conn["password"]}@{conn["host"]}:{conn["port"]}/{conn["instance"]}"""
+                __engine = sqa.create_engine(url=__dns)
+                __conn = __engine.connect().connection
+                #__conn = __conn.connection
+            elif conn["driver_conexao"].upper() == "MYSQL":
+                __conn = mysql.connect(user=conn["username"], password=conn["password"], database=conn["instance"], host=conn["host"])
+            elif conn["driver_conexao"].upper() == "PYMYSQL":
+                __conn = pymysql.connect(user=conn["username"], password=conn["password"], database=conn["instance"], host=conn["host"])#, cursorclass=pymysql.cursors.DictCursor)
+            self._connection_is_valid = True
+            self._nome_database = gen.nvl(conn["database"], "")
+            self.__database_driver = conn["driver_conexao"]
+            self._cnn = __conn
+            self.__database_error = result
+            result = True
+        except Exception as error:
+            msg = f"""{json.dumps(conn, indent=4).replace(conn["password"], "******")}\nFalha ao tentar se conectar com o banco de dados MYSQL\nException Error: {error} """
+            result = msg
+            self._connection_is_valid = False
+            self.__database_error = msg
+        finally:
+            return result
+
+    @property
+    def CONNECTION(self):
+        return self._cnn
+
+    @property
+    def CONNECTION_VALID(self):
+        return self._connection_is_valid
+
+    @property
+    def NOME_DATABASE(self):
+        return self._nome_database
+
+    @property
+    def DATABASE_ERROR(self):
+        return self.__database_error
+
+    @property
+    def DATABASE_DRIVER(self):
+        return self.__database_driver
+
+    @DATABASE_DRIVER.setter
+    def DATABASE_DRIVER(self, value):
+        self._DATABASE_DRIVER = value

de_lib-0.0.36/DE_Lib/DataBase/Oracle.py

@@ -0,0 +1,208 @@
+import os
+import cx_Oracle as ora
+import oracledb as odb
+import sqlalchemy as sqa
+import json
+
+from DE_Lib.Utils import Generic
+
+gen = Generic.GENERIC()
+
+class ORACLE:
+    def __init__(self):
+        self._connection_is_valid = None
+        self._nome_database = None
+        self._cnn = None
+        self.__database_error = None
+
+    # ---------------------------------
+    def Connect(self, conn: dict):
+        msg, result = None, True
+        try:
+
+            #region Definindo o tipo de instancia SID/SERVICE_NAME
+            if conn["type_conection"].upper() == "SID":
+                __dnsName = odb.makedsn(host=conn["host"], port=conn["port"],
+                                        sid=conn["instance"])
+            else:
+                __dnsName = odb.makedsn(host=conn["host"], port=conn["port"],
+                                        service_name=conn["instance"])
+            #endregion
+
+            #region Tipo de driver de conexao
+            """
+            Oracle Thin Mode vs Thick Mode no oracledb
+            O driver oracledb do Python pode operar em dois modos de conexão com o Oracle Database:            
+            . Thin Mode (Padrão) → Conexão nativa, sem necessidade do Oracle Client.
+            . Thick Mode → Usa o Oracle Client para recursos avançados e maior desempenho.
+            🔹 Comparação Geral
+                Característica	                    Thin Mode (Padrão)	Thick Mode
+                Requer Oracle Client?	            ❌ Não	            ✅ Sim
+                Performance	                           Média	        Alta
+                Suporta TNS (tnsnames.ora)?	        ❌ Não   	        ✅ Sim
+                Suporta Connection Pooling?	        ❌ Limitado	        ✅ Sim
+                Suporte a Banco de Dados Antigos?	❌ Não	            ✅ Sim
+                Uso recomendado	                    Ambientes simples	Produção, conexões complexas
+                                                    ,Cloud, Containers
+            """
+            if conn["driver_mode"].upper() == "THICK":
+                try:
+                    # region LIBRARY
+                    if conn["path_library"] is None:
+                        __pathlib = os.getenv("ORACLE_LIB")
+                    else:
+                        __pathlib = conn["path_library"]
+                    # endregion
+                    ora.init_oracle_client(lib_dir=__pathlib)
+                except  Exception as error:
+                    ...
+                    # Modo THIN apenas do banco 12 em diante
+            #endregion
+
+            #region Conexao via SQLALCHEMY | CX_ORACLE | ORACLEDB
+            __conn = None
+            if conn["driver_conexao"].upper() == "SQLALCHEMY":
+                # driver oracledb compativel com banco 12 em diante
+                if not conn["driver_library"]:
+                    # driver default caso não seja explicitado
+                    # para versões do oracle anterior a 12, este driver é o mais recomendado.
+                    __driver = "cx_oracle"
+                else:
+                    __driver = conn["driver_library"].lower()
+                conn_cnn = f"""{conn["database"].lower()}+{__driver}://{conn["username"]}:{conn["password"]}@{__dnsName}"""
+                __engine = sqa.create_engine(conn_cnn)
+                __conn = __engine.connect().connection
+            elif conn["driver_conexao"].upper() == "CX_ORACLE":
+                __conn = ora.connect(conn["username"], conn["password"], __dnsName, threaded=True)
+            elif conn["driver_conexao"].upper() == "ORACLEDB" or conn  is None:
+                # Conexao via ORACLEDB (Novo driver em substituicao do CX_ORACLE)
+                __conn = ora.connect(conn["username"], conn["password"], __dnsName, threaded=True)
+            #endregion
+
+            #region Populando propriedadas da classe
+            self.__connection_is_valid = True
+            self.__nome_database = gen.nvl(conn["database"], "")
+            self.__database_driver = conn["driver_conexao"]
+            self.__cnn = __conn
+            self.__database_error = result
+            #endregion
+        except Exception as error:
+            msg = f"""{json.dumps(conn, indent=4).replace(conn["password"], "******")}\nFalha ao tentar se conectar com o banco de dados ORACLE (SqlAlchemy)\nException Error: {error} """
+            self._connection_is_valid = False
+            self.__database_error = msg
+            result = self._connection_is_valid
+        finally:
+            return result
+
+    #region METODOS qQUE FICARÃO DEPRECIADOS A PARTIR DE 18/03/2025
+    def Connect_ORA(self, string_connect: dict):
+        pathlib, msg, result = None, None, None
+        try:
+            # Definindo a Library ORACLE
+            if "library" in string_connect.keys():
+                if string_connect["library"] is None:
+                    pathlib = os.getenv("ORACLE_LIB")
+                else:
+                    pathlib = string_connect["library"]
+            else:
+                pathlib = os.getenv("ORACLE_LIB")
+
+            # Consistindo se a biblioteca do oracle ja esta iniciada
+            try:
+                ora.init_oracle_client(lib_dir=pathlib)
+            except:
+                pass
+                # não faz nada (e para deixar assim se nao da erro)
+
+            # Definindo o tipo de instancia SID/SERVICE_NAME
+            if string_connect["type_conection"].upper() == "SID":
+                dnsName = ora.makedsn(host=string_connect["host"], port=string_connect["port"], sid=string_connect["instance"])
+            else:
+                dnsName = ora.makedsn(host=string_connect["host"], port=string_connect["port"], service_name=string_connect["instance"])
+
+            # Efetuando a conexao com a instancia do BANCO
+            result = ora.connect(string_connect["username"], string_connect["password"], dnsName, threaded=True)
+            self._connection_is_valid = True
+            self._nome_database = gen.nvl(string_connect["database"], "")
+            self._cnn = result
+            self.__database_error = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nConexao bem sucedida!"""
+        except Exception as error:
+            msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nFalha ao tentar se conectar com o banco de dados ORACLE\nException Error: {error} """
+            result = msg
+            self._connection_is_valid = False
+            self.__database_error = msg
+        finally:
+            return result
+
+    def Connect_SQLA(self, string_connect: dict):
+        conn = None
+        try:
+            # Definindo a Library ORACLE
+            if string_connect["path_library"] is None:
+                # ORACLE_LIB tem que estar previamente criada
+                pathlib = os.getenv("ORACLE_LIB")
+            else:
+                pathlib = string_connect["path_library"]
+
+            # Consistindo se a biblioteca do oracle ja esta iniciada
+            try:
+                ora.init_oracle_client(lib_dir=pathlib)
+            except:
+                pass
+                # não faz nada (e para deixar assim se nao da erro)
+            # Validando se foi passado um driver para conexao
+            if string_connect["driver_conexao"] is None:
+                string_connect["driver_conexao"] = "cx_oracle"
+            database = string_connect["database"]
+            driver = string_connect["driver_conexao"]
+            user = string_connect["username"]
+            pwd = string_connect["password"]
+            host = string_connect["host"]
+            port = string_connect["port"]
+            string_connect["instance"] = ora.makedsn(host, port, string_connect["instance"])
+            # Validando o tipo de conexao (SID ou SERVICE_NAME) apenas oracle
+            if string_connect["type_conection"].upper() == "SERVICE_NAME":
+                string_connect["instance"] = string_connect["instance"].replace("SID", "SERVICE_NAME")
+            dnsName = string_connect["instance"]
+            str_cnn = f"""{database.lower()}{driver}://{user}:{pwd}@{dnsName}"""
+            engine = sqa.create_engine(str_cnn)
+            result = engine.connect()
+            self._connection_is_valid = True
+            self._cnn = result
+            self.__database_error = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nConexao bem sucedida!"""
+            self._nome_database = gen.nvl(string_connect["database"], "")
+        except Exception as error:
+            msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nFalha ao tentar se conectar com o banco de dados ORACLE (SqlAlchemy)\nException Error: {error} """
+            result = msg
+            self._connection_is_valid = False
+            self.__database_error = msg
+        finally:
+            return result
+    #endregion
+
+    #region PROPRIEDADES
+    @property
+    def CONNECTION(self):
+        return self.__cnn
+
+    @property
+    def CONNECTION_VALID(self):
+        return self.__connection_is_valid
+
+    @property
+    def NOME_DATABASE(self):
+        return self.__nome_database.upper()
+
+    @property
+    def DATABASE_ERROR(self):
+        return self.__database_error
+
+    @property
+    def DATABASE_DRIVER(self):
+        return self.__database_driver
+
+    @DATABASE_DRIVER.setter
+    def DATABASE_DRIVER(self, value):
+        self._DATABASE_DRIVER = value
+
+    #endregion

de_lib-0.0.36/DE_Lib/DataBase/OracleDDL.py

@@ -0,0 +1,89 @@
+import pandas as pd
+
+class OracleDDL:
+    def __init__(self):
+        msg = result = None, None
+        try:
+            ...
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            print(result)
+
+
+    def map_dtype_to_oracle(self, dtype):
+        msg = result = None, None
+        try:
+            if pd.api.types.is_integer_dtype(dtype):
+                result =  "NUMBER"
+            elif pd.api.types.is_float_dtype(dtype):
+                result =  "FLOAT"
+            elif pd.api.types.is_bool_dtype(dtype):
+                result =  "CHAR(1)"  # True = 'Y', False = 'N'
+            elif pd.api.types.is_string_dtype(dtype):
+                result =  "VARCHAR2(255)"
+            elif pd.api.types.is_datetime64_any_dtype(dtype):
+                result =  "DATE"
+            else:
+                result =  "VARCHAR2(4000)"
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+        
+    def generate_create_table_sql(self, table_name, df):
+        msg = result = None, None
+        try:
+            columns = []
+            for col in df.columns:
+                colname = col.lower()
+                oracle_type = self.map_dtype_to_oracle(df[col].dtype)
+                columns.append(f"{colname} {oracle_type}")
+            columns_sql = ",\n  ".join(columns)
+            result = f"CREATE TABLE {table_name} (\n  {columns_sql}\n)"
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result  
+        
+    def prepare_data_for_insert(self, df):
+        msg = result = None, None
+        try:
+            def convert_row(row):
+                return tuple(
+                    'Y' if isinstance(val, bool) and val else 'N' if isinstance(val, bool) else val for val in row)
+            result = [convert_row(row) for row in df.itertuples(index=False, name=None)]
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result
+
+    def create_table_and_insert_data(self, df, table_name, conn):
+        msg = result = None, None
+        try:
+            cur = conn.cursor()
+            try:
+                cur.execute(f"DROP TABLE {table_name}")
+            except:
+                pass # Ignora se a tabela não existir
+
+            create_sql = self.generate_create_table_sql(table_name, df)
+            cur.execute(create_sql)
+
+            placeholders = ', '.join([f":{i+1}" for i in range(len(df.columns))])
+            insert_sql = f"INSERT INTO {table_name} VALUES({placeholders})"
+            data = self.prepare_data_for_insert(df)
+            cur.executemany(insert_sql, data)
+            conn.commit()
+            cur.close()
+            conn.close()
+
+        except Exception as error:
+            msg = error
+            result = msg
+        finally:
+            return result

{de_lib-0.0.20 → de_lib-0.0.36}/DE_Lib/DataBase/Postgres.py

@@ -1,6 +1,12 @@
 import psycopg2 as ps2
+import os
+import json
 
-class Postgres:
+from DE_Lib.Utils import Generic
+
+gen = Generic.GENERIC()
+
+class POSTGRES:
     def __init__(self):
         self._connection_is_valid = None
         self._nome_database = None
@@ -8,19 +14,21 @@ class Postgres:
         self.__database_error = None
 
     def Connect(self, string_connect: dict):
-        msg, conn = None, None
+        msg, conn, result = None, None, None
         try:
             # Efetuando a conexao com a instancia do BANCO
             conn = ps2.connect(user=string_connect["username"], password=string_connect["password"], database=string_connect["instance"], host=string_connect["host"])
             self._connection_is_valid = True
-            self._nome_database = string_connect["database"]
-            self._cnn = conn
+            self._cnn = result
+            self.__database_error = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nConexao bem sucedida!"""
+            self._nome_database = gen.nvl(string_connect["database"], "")
         except Exception as error:
-            conn = f"""Falha ao tentar se conectar com o banco de dados POSTGRES.\n """
+            msg = f"""{json.dumps(string_connect, indent=4).replace(string_connect["password"], "******")}\nFalha ao tentar se conectar com o banco de dados POSTGRES\nException Error: {error} """
+            result = msg
             self._connection_is_valid = False
-            self._DATABASE_ERROR = conn.DatabaseError
+            self.__database_error = msg
         finally:
-            return conn
+            return result
 
     @property
     def CONNECTION(self):