TypedValue public interface

Author: vgvoleg

tests/query/test_query_parameters.py

@@ -61,6 +61,27 @@ def test_select_implicit_dict_nested(pool: ydb.QuerySessionPool):
     assert expected_value == actual_value
 
 
+def test_select_implicit_custom_type_raises(pool: ydb.QuerySessionPool):
+    class CustomClass:
+        pass
+
+    expected_value = CustomClass()
+    with pytest.raises(ValueError):
+        pool.execute_with_retries(query, parameters={"$a": expected_value})
+
+
+def test_select_implicit_empty_list_raises(pool: ydb.QuerySessionPool):
+    expected_value = []
+    with pytest.raises(ValueError):
+        pool.execute_with_retries(query, parameters={"$a": expected_value})
+
+
+def test_select_implicit_empty_dict_raises(pool: ydb.QuerySessionPool):
+    expected_value = {}
+    with pytest.raises(ValueError):
+        pool.execute_with_retries(query, parameters={"$a": expected_value})
+
+
 def test_select_explicit_primitive(pool: ydb.QuerySessionPool):
     expected_value = 111
     res = pool.execute_with_retries(query, parameters={"$a": (expected_value, ydb.PrimitiveType.Int64)})
@@ -82,3 +103,44 @@ def test_select_explicit_dict(pool: ydb.QuerySessionPool):
     res = pool.execute_with_retries(query, parameters={"$a": (expected_value, type_)})
     actual_value = res[0].rows[0]["value"]
     assert expected_value == actual_value
+
+
+def test_select_explicit_empty_list_not_raises(pool: ydb.QuerySessionPool):
+    expected_value = []
+    type_ = ydb.ListType(ydb.PrimitiveType.Int64)
+    res = pool.execute_with_retries(query, parameters={"$a": (expected_value, type_)})
+    actual_value = res[0].rows[0]["value"]
+    assert expected_value == actual_value
+
+
+def test_select_explicit_empty_dict_not_raises(pool: ydb.QuerySessionPool):
+    expected_value = {}
+    type_ = ydb.DictType(ydb.PrimitiveType.Utf8, ydb.PrimitiveType.Utf8)
+    res = pool.execute_with_retries(query, parameters={"$a": (expected_value, type_)})
+    actual_value = res[0].rows[0]["value"]
+    assert expected_value == actual_value
+
+
+def test_select_typedvalue_full_primitive(pool: ydb.QuerySessionPool):
+    expected_value = 111
+    typed_value = ydb.TypedValue(expected_value, ydb.PrimitiveType.Int64)
+    res = pool.execute_with_retries(query, parameters={"$a": typed_value})
+    actual_value = res[0].rows[0]["value"]
+    assert expected_value == actual_value
+
+
+def test_select_typedvalue_implicit_primitive(pool: ydb.QuerySessionPool):
+    expected_value = 111
+    typed_value = ydb.TypedValue(expected_value)
+    res = pool.execute_with_retries(query, parameters={"$a": typed_value})
+    actual_value = res[0].rows[0]["value"]
+    assert expected_value == actual_value
+
+def test_select_typevalue_custom_type_raises(pool: ydb.QuerySessionPool):
+    class CustomClass:
+        pass
+
+    expected_value = CustomClass()
+    typed_value = ydb.TypedValue(expected_value)
+    with pytest.raises(ValueError):
+        pool.execute_with_retries(query, parameters={"$a": typed_value})

ydb/convert.py

@@ -288,12 +288,16 @@ def query_parameters_to_pb(parameters):
     parameters_types = {}
     parameters_values = {}
     for name, value in parameters.items():
-        if isinstance(value, tuple):
-            parameters_values[name] = value[0]
-            parameters_types[name] = value[1]
+        if isinstance(value, types.TypedValue):
+            if value.value_type is None:
+                value.value_type = _primitive_type_from_python_native(value.value)
+        elif isinstance(value, tuple):
+            value = types.TypedValue(*value)
         else:
-            parameters_values[name] = value
-            parameters_types[name] = _primitive_type_from_python_native(value)
+            value = types.TypedValue(value, _primitive_type_from_python_native(value))
+
+        parameters_values[name] = value.value
+        parameters_types[name] = value.value_type
 
     return parameters_to_pb(parameters_types, parameters_values)
 
@@ -308,26 +312,34 @@ def query_parameters_to_pb(parameters):
 
 def _primitive_type_from_python_native(value):
     t = type(value)
-    default_type = types.PrimitiveType.Int64
 
     if t in _from_python_type_map:
         return _from_python_type_map[t]
 
     if t == list:
         if len(value) == 0:
-            return types.ListType(default_type)
+            raise ValueError(
+                "Could not map empty list to any type, please specify "
+                "it manually by tuple(value, type) or ydb.TypedValue"
+            )
         entry_type = _primitive_type_from_python_native(value[0])
         return types.ListType(entry_type)
 
     if t == dict:
         if len(value) == 0:
-            return types.DictType(default_type, default_type)
+            raise ValueError(
+                "Could not map empty dict to any type, please specify "
+                "it manually by tuple(value, type) or ydb.TypedValue"
+            )
         entry = list(value.items())[0]
         key_type = _primitive_type_from_python_native(entry[0])
         value_type = _primitive_type_from_python_native(entry[1])
         return types.DictType(key_type, value_type)
 
-    return default_type
+    raise ValueError(
+        "Could not map value to any type, please specify "
+        "it manually by tuple(value, type) or ydb.TypedValue"
+    )
 
 
 def _unwrap_optionality(column):

ydb/types.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import abc
+from dataclasses import dataclass
 import enum
 import json
 from . import _utilities, _apis
@@ -441,3 +442,8 @@ def proto(self):
 
     def __str__(self):
         return "BulkUpsertColumns<%s>" % ",".join(self.__columns_repr)
+
+@dataclass
+class TypedValue:
+    value: typing.Any
+    value_type: typing.Optional[typing.Union[PrimitiveType, AbstractTypeBuilder]] = None