WIP: Oracle named params.

Author: cpburnz

CHANGES.rst

@@ -3,6 +3,18 @@ Change History
 ==============
 
 
+6.1.0 (TBD)
+------------------
+
+New features:
+
+- `Issue #11`_/`Pull #12`_: Support Oracle named parameters enclosed in double quotes (style `named_oracle`).
+
+
+.. _`Issue #11`: https://github.com/cpburnz/python-sqlparams/issues/11
+.. _`Pull #12`: https://github.com/cpburnz/python-sqlparams/pull/12
+
+
 6.0.1 (2023-12-09)
 ------------------
 

pyproject.toml

@@ -18,6 +18,7 @@ classifiers = [
 	"Programming Language :: Python :: 3.10",
 	"Programming Language :: Python :: 3.11",
 	"Programming Language :: Python :: 3.12",
+	"Programming Language :: Python :: 3.13",
 	"Programming Language :: Python :: Implementation :: CPython",
 	"Programming Language :: Python :: Implementation :: PyPy",
 	"Topic :: Database",

sqlparams/__init__.py

@@ -66,7 +66,7 @@ def __init__(
 		escape_char: Union[str, bool, None] = None,
 		expand_tuples: Optional[bool] = None,
 		strip_comments: Union[Sequence[Union[str, Tuple[str, str]]], bool, None] = None,
-		allow_out_quotes: bool = False,
+		allow_out_quotes: Optional[bool] = None,
 	) -> None:
 		"""
 		Instantiates the :class:`.SQLParams` instance.
@@ -90,7 +90,7 @@ def __init__(
 		*out_style* is a named style, do not expand tuples by default (``False``).
 
 		.. NOTE:: Empty tuples will be safely expanded to ``(NULL)`` to prevent SQL
-		   syntax errors,
+		   syntax errors.
 
 		*strip_comments* (:class:`~collections.abc.Sequence`, :class:`bool`, or
 		``None``) whether to strip out comments and what style of comments to
@@ -104,6 +104,9 @@ def __init__(
 		``DEFAULT_COMMENTS`` will be used (``"--"`` and ``("/*", "*/")`` styles).
 		Default is ``None`` to not remove comments.
 
+		*allow_out_quotes* (:class:`bool` or ``None``) is whether to quote the out
+		parameters when *out_style* supports it. Default is ``None`` for ``False``.
+
 		The following parameter styles are supported by both *in_style* and
 		*out_style*:
 
@@ -213,7 +216,7 @@ def __init__(
 			in_style=in_style,
 			out_obj=out_obj,
 			out_style=out_style,
-			allow_out_quotes=allow_out_quotes,
+			allow_out_quotes=bool(allow_out_quotes),
 		)
 		"""
 		*__converter* (:class:`._converting.Converter`) is the parameter converter

sqlparams/_converting.py

@@ -73,14 +73,15 @@ def __init__(
 		string.
 		"""
 
-		self._out_style: _styles.Style = out_style
+		self._out_quotes: bool = out_style.param_quotes and allow_out_quotes
 		"""
-		*_out_style* (:class:`._styles.Style`) is the out-style to use.
+		*_out_quotes* (:class:`bool`) whether enclosing out parameters in double
+		quotes.
 		"""
 
-		self._out_quotes: bool = out_style.param_quotes and allow_out_quotes
+		self._out_style: _styles.Style = out_style
 		"""
-		*_out_quotes* (:class:`bool`) whether enclosing out parameters in double quotes.
+		*_out_style* (:class:`._styles.Style`) is the out-style to use.
 		"""
 
 	def convert(
@@ -287,14 +288,6 @@ def __convert_params(
 
 		return out_params
 
-	@staticmethod
-	def __unquote_param(param: str) -> str:
-		if len(param) > 1 and param[0] == param[-1] == '"':
-			return param[1:-1]
-		if len(param) > 0 and (param[0] == '"' or param[-1] == '"'):
-			raise KeyError(param)
-		return param.upper()
-
 	def __regex_replace(
 		self,
 		in_params: Dict[str, Any],
@@ -333,7 +326,7 @@ def __regex_replace(
 			if self._in_style.param_quotes:
 				in_name = in_name_sql if quote else in_name_sql.upper()
 				for in_name_param, in_value in in_params.items():
-					if NamedToNamedConverter.__unquote_param(in_name_param) == in_name:
+					if _unquote_oracle_param(in_name_param) == in_name:
 						value = in_value
 						break
 				else:
@@ -351,18 +344,23 @@ def __regex_replace(
 				out_names = []
 				out_replacements = []
 				for i, sub_value in enumerate(value):
-					out_name = "{}__{}_sqlp".format(in_name, i)
-					out_name = f'"{out_name}"' if self._out_quotes else out_name
+					out_name = f"{in_name}__{i}_sqlp"
+					if self._out_quotes:
+						out_name = _quote_oracle_param(out_name)
+
 					out_repl = self._out_format.format(param=out_name)
 					out_names.append(out_name)
 					out_replacements.append(out_repl)
 
-				param_conversions.append((True, in_name, out_names))
+				param_conversions.append((True, in_name_param, out_names))
 				return "({})".format(",".join(out_replacements))
 
 			else:
 				# Convert named parameter.
-				out_name = f'"{in_name}"' if self._out_quotes else in_name
+				out_name = in_name
+				if self._out_quotes:
+					out_name = _quote_oracle_param(out_name)
+
 				out_repl = self._out_format.format(param=out_name)
 				param_conversions.append((False, in_name_param, out_name))
 				return out_repl
@@ -586,9 +584,20 @@ def __regex_replace(
 
 		else:
 			# Named parameter matched, return numeric out-style parameter.
-			in_name = result['param']
+			in_name_sql = result['param']
+			quote = result.get("quote")
+			if self._in_style.param_quotes:
+				in_name = in_name_sql if quote else in_name_sql.upper()
+				for in_name_param, in_value in in_params.items():
+					if _unquote_oracle_param(in_name_param) == in_name:
+						value = in_value
+						break
+				else:
+					raise KeyError(in_name_sql)
+			else:
+				in_name_param = in_name = in_name_sql
+				value = in_params[in_name]
 
-			value = in_params[in_name]
 			if self._expand_tuples and isinstance(value, tuple):
 				if not value:
 					# Safely expand an empty tuple.
@@ -615,7 +624,7 @@ def __regex_replace(
 					out_replacements.append(out_repl)
 
 				if is_new:
-					param_conversions.append((True, in_name, out_indices))
+					param_conversions.append((True, in_name_param, out_indices))
 
 				return "({})".format(",".join(out_replacements))
 
@@ -631,7 +640,7 @@ def __regex_replace(
 					out_num = out_index + self.__out_start
 					out_repl = self._out_format.format(param=out_num)
 					out_lookup[in_name] = (out_index, out_repl)
-					param_conversions.append((False, in_name, out_index))
+					param_conversions.append((False, in_name_param, out_index))
 
 				return out_repl
 
@@ -826,22 +835,33 @@ def __regex_replace(
 			return escape[self._escape_start:]
 
 		else:
-			# Named parameter matched, return ordinal out-style parameter.
-			in_name = result['param']
+			# Named parameter matched, return numeric out-style parameter.
+			in_name_sql = result['param']
+			quote = result.get("quote")
+			if self._in_style.param_quotes:
+				in_name = in_name_sql if quote else in_name_sql.upper()
+				for in_name_param, in_value in in_params.items():
+					if _unquote_oracle_param(in_name_param) == in_name:
+						value = in_value
+						break
+				else:
+					raise KeyError(in_name_sql)
+			else:
+				in_name_param = in_name = in_name_sql
+				value = in_params[in_name]
 
-			value = in_params[in_name]
 			if self._expand_tuples and isinstance(value, tuple):
 				if not value:
 					# Safely expand an empty tuple.
 					return "(NULL)"
 
 				# Convert named parameter by flattening tuple values.
-				param_conversions.append((True, in_name, len(value)))
+				param_conversions.append((True, in_name_param, len(value)))
 				return "({})".format(",".join(out_format for _ in value))
 
 			else:
 				# Convert named parameter.
-				param_conversions.append((False, in_name, None))
+				param_conversions.append((False, in_name_param, None))
 				return out_format
 
 
@@ -2366,3 +2386,30 @@ def __regex_replace(
 				# Convert ordinal parameter.
 				param_conversions.append((False, in_index, None))
 				return out_format
+
+
+def _quote_oracle_param(param: str) -> str:
+	"""
+	Quote the Oracle parameter.
+
+	*param* (:class:`str`) is the out-parameter.
+
+	Returns the quoted parameter (:class:`str`).
+	"""
+	out_name = param.replace('"', '""')
+	return f'"{out_name}"'
+
+
+def _unquote_oracle_param(param: str) -> str:
+	"""
+	Unquote the Oracle parameter.
+
+	*param* (:class:`str`) is the in-parameter.
+
+	Returns the unquoted parameter (:class:`str`).
+	"""
+	if len(param) > 1 and param[0] == param[-1] == '"':
+		return param[1:-1]
+	elif len(param) > 0 and (param[0] == '"' or param[-1] == '"'):
+		raise KeyError(param)
+	return param.upper()

sqlparams/_styles.py

@@ -23,7 +23,7 @@ def __init__(
 		escape_regex: str,
 		out_format: str,
 		param_regex: str,
-		param_quotes: bool = False
+		param_quotes: bool = False,
 	) -> None:
 		"""
 		Initializes the :class:`.Style` instances.
@@ -51,15 +51,16 @@ def __init__(
 		*out_format* (:class:`str`) is the out-style parameter format string.
 		"""
 
-		self.param_regex: str = param_regex
+		self.param_quotes: bool = param_quotes
 		"""
-		*param_regex* (:class:`str`) is the regular expression used to extract the
-		parameter.
+		*param_quotes* (:class:`bool`) is whether the style supports enclosing
+		parameters in quotes.
 		"""
 
-		self.param_quotes: bool = param_quotes
+		self.param_regex: str = param_regex
 		"""
-		*param_quotes* (:class:`bool`) whether style supports enclosing parameters in quotes.
+		*param_regex* (:class:`str`) is the regular expression used to extract the
+		parameter.
 		"""
 
 
@@ -113,15 +114,6 @@ class OrdinalStyle(Style):
 	out_format=":{param}"
 )
 
-STYLES['named_oracle'] = NamedStyle(
-	name="named_oracle",
-	escape_char=":",
-	escape_regex="(?P<escape>{char}:)",
-	param_regex=r'(?<!:):(?P<quote>"?)(?P<param>[A-Za-z_]\w*)(?P=quote)',
-	out_format=":{param}",
-	param_quotes=True
-)
-
 # Define non-standard "named_dollar" parameter style.
 STYLES['named_dollar'] = NamedStyle(
 	name="named_dollar",
@@ -131,6 +123,16 @@ class OrdinalStyle(Style):
 	out_format="${param}",
 )
 
+# Define non-standard "named_oracle" parameter style.
+STYLES['named_oracle'] = NamedStyle(
+	name="named_oracle",
+	escape_char=":",
+	escape_regex="(?P<escape>{char}:)",
+	param_regex=r'(?<!:):(?P<quote>"?)(?P<param>[A-Za-z_]\w*)(?P=quote)',
+	out_format=":{param}",
+	param_quotes=True
+)
+
 # Define standard "numeric" parameter style.
 STYLES['numeric'] = NumericStyle(
 	name="numeric",