Add pydantic support in query arguments and UDFs

Author: kesmit13

singlestoredb/functions/ext/asgi.py

@@ -69,6 +69,12 @@
 except ImportError:
     has_cloudpickle = False
 
+try:
+    from pydantic import BaseModel
+    has_pydantic = True
+except ImportError:
+    has_pydantic = False
+
 
 logger = utils.get_logger('singlestoredb.functions.ext.asgi')
 
@@ -138,13 +144,24 @@ def get_func_names(funcs: str) -> List[Tuple[str, str]]:
 
 
 def as_tuple(x: Any) -> Any:
-    if hasattr(x, 'model_fields'):
-        return tuple(x.model_fields.values())
+    """Convert object to tuple."""
+    if has_pydantic and isinstance(x, BaseModel):
+        return tuple(x.model_dump().values())
     if dataclasses.is_dataclass(x):
         return dataclasses.astuple(x)
     return x
 
 
+def as_list_of_tuples(x: Any) -> Any:
+    """Convert object to a list of tuples."""
+    if isinstance(x, (list, tuple)) and len(x) > 0:
+        if has_pydantic and isinstance(x[0], BaseModel):
+            return [tuple(y.model_dump().values()) for y in x]
+        if dataclasses.is_dataclass(x[0]):
+            return [dataclasses.astuple(y) for y in x]
+    return x
+
+
 def make_func(
     name: str,
     func: Callable[..., Any],
@@ -183,7 +200,7 @@ async def do_func(
                 out_ids: List[int] = []
                 out = []
                 for i, res in zip(row_ids, func_map(func, rows)):
-                    out.extend(as_tuple(res))
+                    out.extend(as_list_of_tuples(res))
                     out_ids.extend([row_ids[i]] * (len(out)-len(out_ids)))
                 return out_ids, out
 

singlestoredb/http/connection.py

@@ -43,6 +43,12 @@
 except ImportError:
     has_shapely = False
 
+try:
+    import pydantic
+    has_pydantic = True
+except ImportError:
+    has_pydantic = False
+
 from .. import connection
 from .. import fusion
 from .. import types
@@ -533,6 +539,9 @@ def _execute(
             self._expect_results = True
             sql_type = 'query'
 
+        if has_pydantic and isinstance(params, pydantic.BaseModel):
+            params = params.model_dump()
+
         self._validate_param_subs(oper, params)
 
         handler = fusion.get_handler(oper)

singlestoredb/mysql/cursors.py

@@ -8,6 +8,12 @@
 from ..utils.debug import log_query
 from ..utils.results import get_schema
 
+try:
+    from pydantic import BaseModel
+    has_pydantic = True
+except ImportError:
+    has_pydantic = False
+
 
 #: Regular expression for :meth:`Cursor.executemany`.
 #: executemany only supports simple bulk insert.
@@ -149,6 +155,8 @@ def _escape_args(self, args, conn):
             return tuple(literal(arg) for arg in args)
         elif dtype is dict or isinstance(args, dict):
             return {key: literal(val) for (key, val) in args.items()}
+        elif has_pydantic and isinstance(args, BaseModel):
+            return {key: literal(val) for (key, val) in args.model_dump().items()}
         # If it's not a dictionary let's try escaping it anyways.
         # Worst case it will throw a Value error
         return conn.escape(args)

singlestoredb/tests/test_basics.py

@@ -6,6 +6,7 @@
 import math
 import os
 import unittest
+from typing import Optional
 
 from requests.exceptions import InvalidJSONError
 
@@ -28,6 +29,12 @@
 except ImportError:
     has_pygeos = False
 
+try:
+    import pydantic
+    has_pydantic = True
+except ImportError:
+    has_pydantic = False
+
 import singlestoredb as s2
 from . import utils
 # import traceback
@@ -1255,6 +1262,51 @@ def test_character_lengths(self):
         except Exception:
             pass
 
+    def test_pydantic(self):
+        if not has_pydantic:
+            self.skipTest('Test requires pydantic')
+
+        tblname = 'foo_' + str(id(self))
+
+        class FooData(pydantic.BaseModel):
+            x: Optional[int]
+            y: Optional[float]
+            z: Optional[str] = None
+
+        self.cur.execute(f'''
+            CREATE TABLE {tblname}(
+                x INT,
+                y DOUBLE,
+                z TEXT
+            )
+        ''')
+
+        self.cur.execute(
+            f'INSERT INTO {tblname}(x, y) VALUES (%(x)s, %(y)s)',
+            FooData(x=2, y=3.23),
+        )
+
+        self.cur.execute('SELECT * FROM ' + tblname)
+
+        assert list(sorted(self.cur.fetchall())) == \
+            list(sorted([(2, 3.23, None)]))
+
+        self.cur.executemany(
+            f'INSERT INTO {tblname}(x) VALUES (%(x)s)',
+            [FooData(x=3, y=3.12), FooData(x=10, y=100.11)],
+        )
+
+        self.cur.execute('SELECT * FROM ' + tblname)
+
+        assert list(sorted(self.cur.fetchall())) == \
+            list(
+                sorted([
+                    (2, 3.23, None),
+                    (3, None, None),
+                    (10, None, None),
+                ]),
+            )
+
 
 if __name__ == '__main__':
     import nose2