Fixed bug when attempting to create bequeath connections to a local

database (#114).

Author: anthony-tuininga

doc/src/release_notes.rst

@@ -22,6 +22,10 @@ Thin Mode Changes
 Thick Mode Changes
 ++++++++++++++++++
 
+#)  Fixed bug when attempting to create bequeath connections to a local
+    database
+    (`issue 114 <https://github.com/oracle/python-oracledb/issues/114>`__).
+
 Common Changes
 ++++++++++++++
 

src/oracledb/base_impl.pxd

@@ -1,5 +1,5 @@
 #------------------------------------------------------------------------------
-# Copyright (c) 2020, 2022, Oracle and/or its affiliates.
+# Copyright (c) 2020, 2023, Oracle and/or its affiliates.
 #
 # This software is dual-licensed to you under the Universal Permissive License
 # (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
@@ -115,6 +115,7 @@ cdef class AddressList:
         bint load_balance
         int lru_index
 
+    cdef bint _uses_tcps(self)
     cdef str build_connect_string(self)
 
 
@@ -191,7 +192,6 @@ cdef class ConnectParamsImpl:
         bytearray _token_obfuscator
         bytearray _private_key
         bytearray _private_key_obfuscator
-        bint _has_components
 
     cdef int _check_credentials(self) except -1
     cdef int _copy(self, ConnectParamsImpl other_params) except -1

src/oracledb/impl/base/connect_params.pyx

@@ -1,5 +1,5 @@
 #------------------------------------------------------------------------------
-# Copyright (c) 2022, Oracle and/or its affiliates.
+# Copyright (c) 2022, 2023, Oracle and/or its affiliates.
 #
 # This software is dual-licensed to you under the Universal Permissive License
 # (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
@@ -169,8 +169,6 @@ cdef class ConnectParamsImpl:
         self._default_address.set_from_args(args)
         _set_bool_param(args, "externalauth", &self.externalauth)
         self._set_access_token_param(args.get("access_token"))
-        if args:
-            self._has_components = True
 
     cdef int _check_credentials(self) except -1:
         """
@@ -344,7 +342,6 @@ cdef class ConnectParamsImpl:
         # to be a full connect descriptor
         if connect_string.startswith("("):
             _parse_connect_descriptor(connect_string, args)
-            self._has_components = True
             return self._process_connect_descriptor(args)
 
         # otherwise, see if the connect string is an EasyConnect string
@@ -389,9 +386,6 @@ cdef class ConnectParamsImpl:
             _parse_connect_descriptor(connect_string, args)
             self._process_connect_descriptor(args)
 
-        # mark that object has components
-        self._has_components = True
-
     cdef int _process_connect_descriptor(self, dict args) except -1:
         """
         Internal method used for processing the parsed connect descriptor into
@@ -538,8 +532,7 @@ cdef class ConnectParamsImpl:
         will be a connect string built up from the components supplied when the
         object was built.
         """
-        if self._has_components:
-            return self.description_list.build_connect_string()
+        return self.description_list.build_connect_string()
 
     def get_full_user(self):
         """
@@ -613,16 +606,18 @@ cdef class Address:
 
     cdef str build_connect_string(self):
         """
-        Build a connect string from the components.
+        Build a connect string from the components. If no host is specified,
+        None is returned (used for bequeath connections).
         """
-        parts = [f"(PROTOCOL={self.protocol})",
-                 f"(HOST={self.host})",
-                 f"(PORT={self.port})"]
-        if self.https_proxy is not None:
-            parts.append(f"(HTTPS_PROXY={self.https_proxy})")
-        if self.https_proxy_port != 0:
-            parts.append(f"(HTTPS_PROXY_PORT={self.https_proxy_port})")
-        return f'(ADDRESS={"".join(parts)})'
+        if self.host is not None:
+            parts = [f"(PROTOCOL={self.protocol})",
+                     f"(HOST={self.host})",
+                     f"(PORT={self.port})"]
+            if self.https_proxy is not None:
+                parts.append(f"(HTTPS_PROXY={self.https_proxy})")
+            if self.https_proxy_port != 0:
+                parts.append(f"(HTTPS_PROXY_PORT={self.https_proxy_port})")
+            return f'(ADDRESS={"".join(parts)})'
 
     def copy(self):
         """
@@ -667,12 +662,25 @@ cdef class AddressList:
     def __init__(self):
         self.addresses = []
 
+    cdef bint _uses_tcps(self):
+        """
+        Returns a boolean indicating if any of the addresses in the address
+        list use the protocol TCPS.
+        """
+        cdef Address address
+        for address in self.addresses:
+            if address.protocol == "tcps":
+                return True
+        return False
+
     cdef str build_connect_string(self):
         """
         Build a connect string from the components.
         """
         cdef Address a
         parts = [a.build_connect_string() for a in self.addresses]
+        if len(parts) == 1:
+            return parts[0]
         return f'(ADDRESS_LIST={"".join(parts)})'
 
     def set_from_args(self, dict args):
@@ -713,37 +721,12 @@ cdef class Description:
         Build a connect string from the components.
         """
         cdef:
-            str connect_data, security, temp
-            list parts, address_lists
-            AddressList a
-
-        # build connect data segment
-        parts = []
-        if self.service_name is not None:
-            parts.append(f"(SERVICE_NAME={self.service_name})")
-        elif self.sid is not None:
-            parts.append(f"(SID={self.sid})")
-        if self.server_type is not None:
-            parts.append(f"(SERVER={self.server_type})")
-        if self.cclass is not None:
-            parts.append(f"(POOL_CONNECTION_CLASS={self.cclass})")
-        if self.purity != 0:
-            parts.append(f"(POOL_PURITY={self.purity})")
-        if cid is not None:
-            parts.append(f"(CID={cid})")
-        connect_data = f'(CONNECT_DATA={"".join(parts)})'
+            AddressList address_list
+            list parts, temp_parts
+            bint uses_tcps = False
+            str temp
 
-        # build security segment, if applicable
-        parts = []
-        if self.ssl_server_dn_match:
-            parts.append("(SSL_SERVER_DN_MATCH=ON)")
-        if self.ssl_server_cert_dn is not None:
-            parts.append(f"(SSL_SERVER_CERT_DN={self.ssl_server_cert_dn})")
-        if self.wallet_location is not None:
-            parts.append(f"(MY_WALLET_DIRECTORY={self.wallet_location})")
-        security = f'(SECURITY={"".join(parts)})'
-
-        # build connect string
+        # build top-level description parts
         parts = []
         if self.load_balance:
             parts.append("(LOAD_BALANCE=ON)")
@@ -758,10 +741,48 @@ cdef class Description:
         if self.tcp_connect_timeout != DEFAULT_TCP_CONNECT_TIMEOUT:
             temp = self._build_duration_str(self.tcp_connect_timeout)
             parts.append(f"(TRANSPORT_CONNECT_TIMEOUT={temp})")
-        address_lists = [a.build_connect_string() for a in self.address_lists]
-        parts.extend(address_lists)
-        parts.append(connect_data)
-        parts.append(security)
+
+        # add address lists, but if the address list contains only a single
+        # entry and that entry does not have a host, the other parts aren't
+        # relevant anyway!
+        for address_list in self.address_lists:
+            temp = address_list.build_connect_string()
+            if temp is None:
+                return None
+            parts.append(temp)
+            if not uses_tcps:
+                uses_tcps = address_list._uses_tcps()
+
+        # build connect data segment
+        temp_parts = []
+        if self.service_name is not None:
+            temp_parts.append(f"(SERVICE_NAME={self.service_name})")
+        elif self.sid is not None:
+            temp_parts.append(f"(SID={self.sid})")
+        if self.server_type is not None:
+            temp_parts.append(f"(SERVER={self.server_type})")
+        if self.cclass is not None:
+            temp_parts.append(f"(POOL_CONNECTION_CLASS={self.cclass})")
+        if self.purity != 0:
+            temp_parts.append(f"(POOL_PURITY={self.purity})")
+        if cid is not None:
+            temp_parts.append(f"(CID={cid})")
+        if temp_parts:
+            parts.append(f'(CONNECT_DATA={"".join(temp_parts)})')
+
+        # build security segment, if applicable
+        if uses_tcps:
+            temp_parts = []
+            if self.ssl_server_dn_match:
+                temp_parts.append("(SSL_SERVER_DN_MATCH=ON)")
+            if self.ssl_server_cert_dn is not None:
+                temp = f"(SSL_SERVER_CERT_DN={self.ssl_server_cert_dn})"
+                temp_parts.append(temp)
+            if self.wallet_location is not None:
+                temp = f"(MY_WALLET_DIRECTORY={self.wallet_location})"
+                temp_parts.append(temp)
+            parts.append(f'(SECURITY={"".join(temp_parts)})')
+
         return f'(DESCRIPTION={"".join(parts)})'
 
     def copy(self):

tests/test_4500_connect_params.py

@@ -1,5 +1,5 @@
 #------------------------------------------------------------------------------
-# Copyright (c) 2021, 2022, Oracle and/or its affiliates.
+# Copyright (c) 2021, 2023, Oracle and/or its affiliates.
 #
 # This software is dual-licensed to you under the Universal Permissive License
 # (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl and Apache License
@@ -478,10 +478,9 @@ def test_4531_build_connect_string_with_tcp_connect_timeout(self):
                                             tcp_connect_timeout=in_val)
             tcp_timeout_val = f"(TRANSPORT_CONNECT_TIMEOUT={out_val})"
             connect_string = f"(DESCRIPTION={tcp_timeout_val}" + \
-                             f"(ADDRESS_LIST=(ADDRESS=(PROTOCOL=tcp)" + \
-                             f"(HOST={host})(PORT=1521)))(CONNECT_DATA=" + \
-                             f"(SERVICE_NAME={service_name}))" + \
-                             f"(SECURITY=(SSL_SERVER_DN_MATCH=ON)))"
+                             f"(ADDRESS=(PROTOCOL=tcp)" + \
+                             f"(HOST={host})(PORT=1521))(CONNECT_DATA=" + \
+                             f"(SERVICE_NAME={service_name})))"
             self.assertEqual(params.get_connect_string(), connect_string)
 
     def test_4532_multiple_alias_entry_tnsnames(self):
@@ -582,9 +581,15 @@ def test_4536_build_connect_string_with_source_route(self):
                     f"(ADDRESS_LIST=" + \
                     f"(ADDRESS=(PROTOCOL=tcp)(HOST=host1)(PORT=1521))" + \
                     f"(ADDRESS=(PROTOCOL=tcp)(HOST=host2)(PORT=1522)))" + \
-                    f"(CONNECT_DATA=(SERVICE_NAME=my_service_35))" + \
-                    f"(SECURITY=(SSL_SERVER_DN_MATCH=ON)))"
+                    f"(CONNECT_DATA=(SERVICE_NAME=my_service_35)))"
             self.assertEqual(params.get_connect_string(), connect_string)
 
+    def test_4537_no_connect_string(self):
+        "4537 - test connect parameters which generate no connect string"
+        params = oracledb.ConnectParams()
+        self.assertEqual(params.get_connect_string(), None)
+        params.set(mode=oracledb.SYSDBA)
+        self.assertEqual(params.get_connect_string(), None)
+
 if __name__ == "__main__":
     test_env.run_test_cases()