singlestoredb 1.12.1__cp38-abi3-win32.whl → 1.12.3__cp38-abi3-win32.whl

singlestoredb/__init__.py

@@ -13,7 +13,7 @@ Examples
 
 """
 
-__version__ = '1.12.1'
+__version__ = '1.12.3'
 
 from typing import Any
 

singlestoredb/config.py

@@ -80,7 +80,7 @@ register_option(
 )
 
 register_option(
-    'charset', 'string', check_str, 'utf8',
+    'charset', 'string', check_str, 'utf8mb4',
     'Specifies the character set for the session.',
     environ='SINGLESTOREDB_CHARSET',
 )

singlestoredb/functions/ext/asgi.py

@@ -69,6 +69,12 @@ try:
 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 @@ def make_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/functions/signature.py

@@ -6,6 +6,8 @@ import numbers
 import os
 import re
 import string
+import sys
+import types
 import typing
 from typing import Any
 from typing import Callable
@@ -32,6 +34,11 @@ except ImportError:
 from . import dtypes as dt
 from ..mysql.converters import escape_item  # type: ignore
 
+if sys.version_info >= (3, 10):
+    _UNION_TYPES = {typing.Union, types.UnionType}
+else:
+    _UNION_TYPES = {typing.Union}
+
 
 array_types: Tuple[Any, ...]
 
@@ -211,7 +218,7 @@ def simplify_dtype(dtype: Any) -> List[Any]:
     args = []
 
     # Flatten Unions
-    if origin is Union:
+    if origin in _UNION_TYPES:
         for x in typing.get_args(dtype):
             args.extend(simplify_dtype(x))
 

singlestoredb/fusion/handlers/utils.py

@@ -199,59 +199,65 @@ def get_deployment(
     """
     manager = get_workspace_manager()
 
+    #
+    # Search for deployment by name
+    #
     deployment_name = params.get('deployment_name') or \
         (params.get('in_deployment') or {}).get('deployment_name') or \
         (params.get('group') or {}).get('deployment_name') or \
         ((params.get('in') or {}).get('in_group') or {}).get('deployment_name') or \
         ((params.get('in') or {}).get('in_deployment') or {}).get('deployment_name')
+
     if deployment_name:
+        # Standard workspace group
         workspace_groups = [
             x for x in manager.workspace_groups
             if x.name == deployment_name
         ]
 
-        starter_workspaces = []
-        if not workspace_groups:
-            filtered_starter_workspaces = [
-                x for x in manager.starter_workspaces
-                if x.name == deployment_name
-            ]
-
-            if not filtered_starter_workspaces:
-                raise KeyError(
-                    f'no deployment found with name: {deployment_name}',
-                )
-
-            starter_workspaces = filtered_starter_workspaces
+        if len(workspace_groups) == 1:
+            return workspace_groups[0]
 
-        if len(workspace_groups) > 1:
+        elif len(workspace_groups) > 1:
             ids = ', '.join(x.id for x in workspace_groups)
             raise ValueError(
                 f'more than one workspace group with given name was found: {ids}',
             )
 
-        if len(starter_workspaces) > 1:
+        # Starter workspace
+        starter_workspaces = [
+            x for x in manager.starter_workspaces
+            if x.name == deployment_name
+        ]
+
+        if len(starter_workspaces) == 1:
+            return starter_workspaces[0]
+
+        elif len(starter_workspaces) > 1:
             ids = ', '.join(x.id for x in starter_workspaces)
             raise ValueError(
                 f'more than one starter workspace with given name was found: {ids}',
             )
 
-        if workspace_groups:
-            return workspace_groups[0]
-        else:
-            return starter_workspaces[0]
+        raise KeyError(f'no deployment found with name: {deployment_name}')
 
+    #
+    # Search for deployment by ID
+    #
     deployment_id = params.get('deployment_id') or \
         (params.get('in_deployment') or {}).get('deployment_id') or \
         (params.get('group') or {}).get('deployment_id') or \
         ((params.get('in') or {}).get('in_group') or {}).get('deployment_id') or \
         ((params.get('in') or {}).get('in_deployment') or {}).get('deployment_id')
+
     if deployment_id:
         try:
+            # Standard workspace group
             return manager.get_workspace_group(deployment_id)
         except ManagementError as exc:
             if exc.errno == 404:
                 try:
+                    # Starter workspace
                     return manager.get_starter_workspace(deployment_id)
                 except ManagementError as exc:
                     if exc.errno == 404:
@@ -260,6 +266,7 @@ def get_deployment(
             else:
                 raise
 
+    # Use workspace group from environment
     if os.environ.get('SINGLESTOREDB_WORKSPACE_GROUP'):
         try:
             return manager.get_workspace_group(
@@ -273,6 +280,7 @@ def get_deployment(
                 )
             raise
 
+    # Use cluster from environment
     if os.environ.get('SINGLESTOREDB_CLUSTER'):
         try:
             return manager.get_starter_workspace(

singlestoredb/http/connection.py

@@ -43,6 +43,12 @@ try:
 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 @@ class Cursor(connection.Cursor):
             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/management/files.py

@@ -348,6 +348,7 @@ class FilesObjectBytesReader(io.BytesIO):
 
 
 class FileLocation(ABC):
+
     @abstractmethod
     def open(
         self,

singlestoredb/mysql/cursors.py

@@ -8,6 +8,12 @@ from ..utils import results
 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 @@ class Cursor(BaseCursor):
             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 decimal
 import math
 import os
 import unittest
+from typing import Optional
 
 from requests.exceptions import InvalidJSONError
 
@@ -28,6 +29,12 @@ try:
 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,68 @@ class TestBasics(unittest.TestCase):
         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),
+                ]),
+            )
+
+    def test_charset(self):
+        with s2.connect(database=type(self).dbname) as conn:
+            with conn.cursor() as cur:
+                cur.execute('''
+                    select json_extract_string('{"foo":"😀"}', "bar");
+                ''')
+
+        if 'http' in self.conn.driver:
+            self.skipTest('Charset is not use in HTTP interface')
+
+        with self.assertRaises(s2.OperationalError):
+            with s2.connect(database=type(self).dbname, charset='utf8') as conn:
+                with conn.cursor() as cur:
+                    cur.execute('''
+                        select json_extract_string('{"foo":"😀"}', "bar");
+                    ''')
+
 
 if __name__ == '__main__':
     import nose2

singlestoredb/tests/test_fusion.py

@@ -4,6 +4,7 @@
 import os
 import random
 import secrets
+import tempfile
 import time
 import unittest
 from typing import Any
@@ -714,3 +715,810 @@ class TestJobsFusion(unittest.TestCase):
         res = out[0]
         assert res[0] == job_id
         assert res[1] == 1
+
+
+@pytest.mark.management
+class TestStageFusion(unittest.TestCase):
+
+    id: str = secrets.token_hex(8)
+    dbname: str = 'information_schema'
+    manager: None
+    workspace_group: None
+    workspace_group_2: None
+
+    @classmethod
+    def setUpClass(cls):
+        cls.manager = s2.manage_workspaces()
+        us_regions = [x for x in cls.manager.regions if x.name.startswith('US')]
+        cls.workspace_group = cls.manager.create_workspace_group(
+            f'Stage Fusion Testing 1 {cls.id}',
+            region=random.choice(us_regions),
+            firewall_ranges=[],
+        )
+        cls.workspace_group_2 = cls.manager.create_workspace_group(
+            f'Stage Fusion Testing 2 {cls.id}',
+            region=random.choice(us_regions),
+            firewall_ranges=[],
+        )
+        # Wait for both workspace groups to start
+        time.sleep(5)
+
+        os.environ['SINGLESTOREDB_DEFAULT_DATABASE'] = 'information_schema'
+        os.environ['SINGLESTOREDB_WORKSPACE_GROUP'] = cls.workspace_group.id
+
+    @classmethod
+    def tearDownClass(cls):
+        if cls.workspace_group is not None:
+            cls.workspace_group.terminate(force=True)
+        if cls.workspace_group_2 is not None:
+            cls.workspace_group_2.terminate(force=True)
+        cls.manager = None
+        cls.workspace_group = None
+        cls.workspace_group_2 = None
+        cls.workspace = None
+        cls.workspace_2 = None
+        if os.environ.get('SINGLESTOREDB_WORKSPACE', None) is not None:
+            del os.environ['SINGLESTOREDB_WORKSPACE']
+        if os.environ.get('SINGLESTOREDB_WORKSPACE_GROUP', None) is not None:
+            del os.environ['SINGLESTOREDB_WORKSPACE_GROUP']
+        if os.environ.get('SINGLESTOREDB_DEFAULT_DATABASE', None) is not None:
+            del os.environ['SINGLESTOREDB_DEFAULT_DATABASE']
+
+    def setUp(self):
+        self.enabled = os.environ.get('SINGLESTOREDB_FUSION_ENABLED')
+        os.environ['SINGLESTOREDB_FUSION_ENABLED'] = '1'
+        self.conn = s2.connect(database=type(self).dbname, local_infile=True)
+        self.cur = self.conn.cursor()
+
+    def tearDown(self):
+        self._clear_stage()
+
+        if self.enabled:
+            os.environ['SINGLESTOREDB_FUSION_ENABLED'] = self.enabled
+        else:
+            del os.environ['SINGLESTOREDB_FUSION_ENABLED']
+
+        try:
+            if self.cur is not None:
+                self.cur.close()
+        except Exception:
+            # traceback.print_exc()
+            pass
+
+        try:
+            if self.conn is not None:
+                self.conn.close()
+        except Exception:
+            # traceback.print_exc()
+            pass
+
+    def _clear_stage(self):
+        if self.workspace_group is not None:
+            self.cur.execute(f'''
+                show stage files
+                    in group id '{self.workspace_group.id}' recursive
+            ''')
+            files = list(self.cur)
+            folders = []
+            for file in files:
+                if file[0].endswith('/'):
+                    folders.append(file)
+                    continue
+                self.cur.execute(f'''
+                    drop stage file '{file[0]}'
+                        in group id '{self.workspace_group.id}'
+                ''')
+            for folder in folders:
+                self.cur.execute(f'''
+                    drop stage folder '{folder[0]}'
+                        in group id '{self.workspace_group.id}'
+                ''')
+
+        if self.workspace_group_2 is not None:
+            self.cur.execute(f'''
+                show stage files
+                    in group id '{self.workspace_group_2.id}' recursive
+            ''')
+            files = list(self.cur)
+            folders = []
+            for file in files:
+                if file[0].endswith('/'):
+                    folders.append(file)
+                    continue
+                self.cur.execute(f'''
+                    drop stage file '{file[0]}'
+                        in group id '{self.workspace_group_2.id}'
+                ''')
+            for folder in folders:
+                self.cur.execute(f'''
+                    drop stage folder '{folder[0]}'
+                        in group id '{self.workspace_group_2.id}'
+                ''')
+
+    def test_show_stage(self):
+        test2_sql = os.path.join(os.path.dirname(__file__), 'test2.sql')
+
+        # Should be empty
+        self.cur.execute('''
+            show stage files
+        ''')
+        files = list(self.cur)
+        assert len(files) == 0
+
+        # Copy files to stage
+        self.cur.execute(
+            f'upload file to stage "new_test_1.sql" from "{test2_sql}"',
+        )
+        self.cur.execute('create stage folder "subdir1"')
+        self.cur.execute(
+            f'upload file to stage "subdir1/new_test_2.sql" from "{test2_sql}"',
+        )
+        self.cur.execute(
+            f'upload file to stage "subdir1/new_test_3.sql" from "{test2_sql}"',
+        )
+        self.cur.execute('create stage folder "subdir2"')
+        self.cur.execute(
+            f'upload file to stage "subdir2/new_test_4.sql" from "{test2_sql}"',
+        )
+        self.cur.execute(
+            f'upload file to stage "subdir2/new_test_5.sql" from "{test2_sql}"',
+        )
+
+        # Make sure files are there
+        self.cur.execute('''
+            show stage files recursive
+        ''')
+        files = list(self.cur)
+        assert len(files) == 7
+        assert list(sorted(x[0] for x in files)) == [
+            'new_test_1.sql',
+            'subdir1/',
+            'subdir1/new_test_2.sql',
+            'subdir1/new_test_3.sql',
+            'subdir2/',
+            'subdir2/new_test_4.sql',
+            'subdir2/new_test_5.sql',
+        ]
+
+        # Do non-recursive listing
+        self.cur.execute('''
+            show stage files
+        ''')
+        files = list(self.cur)
+        assert len(files) == 3
+        assert list(sorted(x[0] for x in files)) == [
+            'new_test_1.sql',
+            'subdir1/',
+            'subdir2/',
+        ]
+
+        # List files in specific workspace group
+        self.cur.execute(f'''
+            show stage files in group id '{self.workspace_group.id}'
+        ''')
+        files = list(self.cur)
+        assert len(files) == 3
+        assert list(sorted(x[0] for x in files)) == [
+            'new_test_1.sql',
+            'subdir1/',
+            'subdir2/',
+        ]
+
+        self.cur.execute(f'''
+            show stage files in id '{self.workspace_group.id}'
+        ''')
+        files = list(self.cur)
+        assert len(files) == 3
+        assert list(sorted(x[0] for x in files)) == [
+            'new_test_1.sql',
+            'subdir1/',
+            'subdir2/',
+        ]
+
+        self.cur.execute(f'''
+            show stage files in group '{self.workspace_group.name}'
+        ''')
+        files = list(self.cur)
+        assert len(files) == 3
+        assert list(sorted(x[0] for x in files)) == [
+            'new_test_1.sql',
+            'subdir1/',
+            'subdir2/',
+        ]
+
+        self.cur.execute(f'''
+            show stage files in '{self.workspace_group.name}'
+        ''')
+        files = list(self.cur)
+        assert len(files) == 3
+        assert list(sorted(x[0] for x in files)) == [
+            'new_test_1.sql',
+            'subdir1/',
+            'subdir2/',
+        ]
+
+        # Check other workspace group
+        self.cur.execute(f'''
+            show stage files in group '{self.workspace_group_2.name}'
+        ''')
+        files = list(self.cur)
+        assert len(files) == 0
+
+        # Limit results
+        self.cur.execute('''
+            show stage files recursive limit 5
+        ''')
+        files = list(self.cur)
+        assert len(files) == 5
+        assert list(sorted(x[0] for x in files)) == [
+            'new_test_1.sql',
+            'subdir1/',
+            'subdir1/new_test_2.sql',
+            'subdir1/new_test_3.sql',
+            'subdir2/',
+        ]
+
+        # Order by type and name
+        self.cur.execute('''
+            show stage files order by type, name recursive extended
+        ''')
+        files = list(self.cur)
+        assert len(files) == 7
+        assert list(x[0] for x in files) == [
+            'subdir1/',
+            'subdir2/',
+            'new_test_1.sql',
+            'subdir1/new_test_2.sql',
+            'subdir1/new_test_3.sql',
+            'subdir2/new_test_4.sql',
+            'subdir2/new_test_5.sql',
+        ]
+
+        # Order by type and name descending
+        self.cur.execute('''
+            show stage files order by type desc, name desc recursive extended
+        ''')
+        files = list(self.cur)
+        assert len(files) == 7
+        assert list(x[0] for x in files) == [
+            'subdir2/new_test_5.sql',
+            'subdir2/new_test_4.sql',
+            'subdir1/new_test_3.sql',
+            'subdir1/new_test_2.sql',
+            'new_test_1.sql',
+            'subdir2/',
+            'subdir1/',
+        ]
+
+        # List at specific path
+        self.cur.execute('''
+            show stage files at 'subdir2/' recursive
+        ''')
+        files = list(self.cur)
+        assert len(files) == 2
+        assert list(sorted(x[0] for x in files)) == [
+            'new_test_4.sql',
+            'new_test_5.sql',
+        ]
+
+        # LIKE clause
+        self.cur.execute('''
+            show stage files like '%_4.%' recursive
+        ''')
+        files = list(self.cur)
+        assert len(files) == 1
+        assert list(sorted(x[0] for x in files)) == [
+            'subdir2/new_test_4.sql',
+        ]
+
+    def test_download_stage(self):
+        test2_sql = os.path.join(os.path.dirname(__file__), 'test2.sql')
+
+        # Should be empty
+        self.cur.execute('''
+            show stage files
+        ''')
+        files = list(self.cur)
+        assert len(files) == 0
+
+        # Copy file to stage 1
+        self.cur.execute(f'''
+            upload file to stage 'dl_test.sql' from '{test2_sql}'
+        ''')
+
+        self.cur.execute('''
+            show stage files
+        ''')
+        files = list(self.cur)
+        assert len(files) == 1
+        assert list(sorted(x[0] for x in files)) == ['dl_test.sql']
+
+        # Copy file to stage 2
+        self.cur.execute(f'''
+            upload file to stage 'dl_test2.sql'
+                in group '{self.workspace_group_2.name}'
+                from '{test2_sql}'
+        ''')
+
+        # Make sure only one file in stage 2
+        self.cur.execute(f'''
+            show stage files in group '{self.workspace_group_2.name}'
+        ''')
+        files = list(self.cur)
+        assert len(files) == 1
+        assert list(sorted(x[0] for x in files)) == ['dl_test2.sql']
+
+        # Download file from stage 1
+        with tempfile.TemporaryDirectory() as tmpdir:
+            self.cur.execute(f'''
+                download stage file 'dl_test.sql' to '{tmpdir}/dl_test.sql'
+            ''')
+            with open(os.path.join(tmpdir, 'dl_test.sql'), 'r') as dl_file:
+                assert dl_file.read() == open(test2_sql, 'r').read()
+
+        # Download file from stage 2
+        with tempfile.TemporaryDirectory() as tmpdir:
+            self.cur.execute(f'''
+                download stage file 'dl_test2.sql'
+                    in group '{self.workspace_group_2.name}'
+                    to '{tmpdir}/dl_test2.sql'
+            ''')
+            with open(os.path.join(tmpdir, 'dl_test2.sql'), 'r') as dl_file:
+                assert dl_file.read() == open(test2_sql, 'r').read()
+
+    def test_stage_multi_wg_operations(self):
+        test_sql = os.path.join(os.path.dirname(__file__), 'test.sql')
+        test2_sql = os.path.join(os.path.dirname(__file__), 'test2.sql')
+
+        # Should be empty
+        self.cur.execute('''
+            show stage files
+        ''')
+        files = list(self.cur)
+        assert len(files) == 0
+
+        # Copy file to stage 1
+        self.cur.execute(f'''
+            upload file to stage 'new_test.sql' from '{test_sql}'
+        ''')
+
+        self.cur.execute('''
+            show stage files
+        ''')
+        files = list(self.cur)
+        assert len(files) == 1
+
+        # Copy file to stage 2
+        self.cur.execute(f'''
+            upload file to stage 'new_test2.sql'
+                in group '{self.workspace_group_2.name}'
+                from '{test2_sql}'
+        ''')
+
+        # Make sure only one file in stage 1
+        self.cur.execute('''
+            show stage files
+        ''')
+        files = list(self.cur)
+        assert len(files) == 1
+        assert files[0][0] == 'new_test.sql'
+
+        # Make sure only one file in stage 2
+        self.cur.execute(f'''
+            show stage files in group '{self.workspace_group_2.name}' recursive
+        ''')
+        files = list(self.cur)
+        assert len(files) == 1
+        assert list(sorted(x[0] for x in files)) == ['new_test2.sql']
+
+        # Make sure only one file in stage 2 (using IN)
+        self.cur.execute(f'''
+            show stage files in '{self.workspace_group_2.name}' recursive
+        ''')
+        files = list(self.cur)
+        assert len(files) == 1
+        assert list(sorted(x[0] for x in files)) == ['new_test2.sql']
+
+        # Make subdir
+        self.cur.execute(f'''
+            create stage folder 'data' in group '{self.workspace_group_2.name}'
+        ''')
+
+        # Upload file using workspace ID
+        self.cur.execute(f'''
+            upload file to stage 'data/new_test2_sub.sql'
+                in group id '{self.workspace_group_2.id}'
+                from '{test2_sql}'
+        ''')
+
+        # Make sure only one file in stage 1
+        self.cur.execute('''
+            show stage files
+        ''')
+        files = list(self.cur)
+        assert len(files) == 1
+        assert files[0][0] == 'new_test.sql'
+
+        # Make sure two files in stage 2
+        self.cur.execute(f'''
+            show stage files in group id '{self.workspace_group_2.id}' recursive
+        ''')
+        files = list(self.cur)
+        assert len(files) == 3
+        assert list(sorted(x[0] for x in files)) == \
+            ['data/', 'data/new_test2_sub.sql', 'new_test2.sql']
+
+        # Test overwrite
+        with self.assertRaises(OSError):
+            self.cur.execute(f'''
+                upload file to stage 'data/new_test2_sub.sql'
+                    in group id '{self.workspace_group_2.id}'
+                    from '{test2_sql}'
+            ''')
+
+        self.cur.execute(f'''
+            upload file to stage 'data/new_test2_sub.sql'
+                in group id '{self.workspace_group_2.id}'
+                from '{test2_sql}' overwrite
+        ''')
+
+        # Make sure two files in stage 2
+        self.cur.execute(f'''
+            show stage files in group id '{self.workspace_group_2.id}' recursive
+        ''')
+        files = list(self.cur)
+        assert len(files) == 3
+        assert list(sorted(x[0] for x in files)) == \
+            ['data/', 'data/new_test2_sub.sql', 'new_test2.sql']
+
+        # Test LIKE clause
+        self.cur.execute(f'''
+            show stage files
+                in group id '{self.workspace_group_2.id}'
+                like '%_sub%' recursive
+        ''')
+        files = list(self.cur)
+        assert len(files) == 1
+        assert list(sorted(x[0] for x in files)) == ['data/new_test2_sub.sql']
+
+        # Drop file from default stage
+        self.cur.execute('''
+            drop stage file 'new_test.sql'
+        ''')
+
+        # Make sure no files in stage 1
+        self.cur.execute('''
+            show stage files
+        ''')
+        files = list(self.cur)
+        assert len(files) == 0
+
+        # Make sure two files in stage 2
+        self.cur.execute(f'''
+            show stage files in group id '{self.workspace_group_2.id}' recursive
+        ''')
+        files = list(self.cur)
+        assert len(files) == 3
+        assert list(sorted(x[0] for x in files)) == \
+            ['data/', 'data/new_test2_sub.sql', 'new_test2.sql']
+
+        # Attempt to drop directory from stage 2
+        with self.assertRaises(OSError):
+            self.cur.execute(f'''
+                drop stage folder 'data'
+                    in group id '{self.workspace_group_2.id}'
+            ''')
+
+        self.cur.execute(f'''
+            drop stage file 'data/new_test2_sub.sql'
+                in group id '{self.workspace_group_2.id}'
+        ''')
+
+        # Make sure one file and one directory in stage 2
+        self.cur.execute(f'''
+            show stage files in group id '{self.workspace_group_2.id}' recursive
+        ''')
+        files = list(self.cur)
+        assert len(files) == 2
+        assert list(sorted(x[0] for x in files)) == ['data/', 'new_test2.sql']
+
+        # Drop stage folder from stage 2
+        self.cur.execute(f'''
+            drop stage folder 'data'
+                in group id '{self.workspace_group_2.id}'
+        ''')
+
+        # Make sure one file in stage 2
+        self.cur.execute(f'''
+            show stage files in group id '{self.workspace_group_2.id}' recursive
+        ''')
+        files = list(self.cur)
+        assert len(files) == 1
+        assert list(sorted(x[0] for x in files)) == ['new_test2.sql']
+
+        # Drop last file
+        self.cur.execute(f'''
+            drop stage file 'new_test2.sql'
+                in group id '{self.workspace_group_2.id}'
+        ''')
+
+        # Make sure no files in stage 2
+        self.cur.execute(f'''
+            show stage files in group id '{self.workspace_group_2.id}' recursive
+        ''')
+        files = list(self.cur)
+        assert len(files) == 0
+
+
+@pytest.mark.management
+class TestFilesFusion(unittest.TestCase):
+
+    id: str = secrets.token_hex(8)
+    dbname: str = 'information_schema'
+    manager: None
+    workspace_group: None
+
+    @classmethod
+    def setUpClass(cls):
+        cls.manager = s2.manage_workspaces()
+        us_regions = [x for x in cls.manager.regions if x.name.startswith('US')]
+        cls.workspace_group = cls.manager.create_workspace_group(
+            f'Files Fusion Testing {cls.id}',
+            region=random.choice(us_regions),
+            firewall_ranges=[],
+        )
+        # Wait for both workspace groups to start
+        time.sleep(5)
+
+        os.environ['SINGLESTOREDB_DEFAULT_DATABASE'] = 'information_schema'
+        os.environ['SINGLESTOREDB_WORKSPACE_GROUP'] = cls.workspace_group.id
+
+    @classmethod
+    def tearDownClass(cls):
+        if cls.workspace_group is not None:
+            cls.workspace_group.terminate(force=True)
+        cls.manager = None
+        cls.workspace_group = None
+        cls.workspace = None
+        if os.environ.get('SINGLESTOREDB_WORKSPACE', None) is not None:
+            del os.environ['SINGLESTOREDB_WORKSPACE']
+        if os.environ.get('SINGLESTOREDB_WORKSPACE_GROUP', None) is not None:
+            del os.environ['SINGLESTOREDB_WORKSPACE_GROUP']
+        if os.environ.get('SINGLESTOREDB_DEFAULT_DATABASE', None) is not None:
+            del os.environ['SINGLESTOREDB_DEFAULT_DATABASE']
+
+    def setUp(self):
+        self.enabled = os.environ.get('SINGLESTOREDB_FUSION_ENABLED')
+        os.environ['SINGLESTOREDB_FUSION_ENABLED'] = '1'
+        self.conn = s2.connect(database=type(self).dbname, local_infile=True)
+        self.cur = self.conn.cursor()
+
+    def tearDown(self):
+        self._clear_files()
+
+        if self.enabled:
+            os.environ['SINGLESTOREDB_FUSION_ENABLED'] = self.enabled
+        else:
+            del os.environ['SINGLESTOREDB_FUSION_ENABLED']
+
+        try:
+            if self.cur is not None:
+                self.cur.close()
+        except Exception:
+            # traceback.print_exc()
+            pass
+
+        try:
+            if self.conn is not None:
+                self.conn.close()
+        except Exception:
+            # traceback.print_exc()
+            pass
+
+    def _clear_files(self):
+        cls = type(self)
+        for prefix in ['show', 'dl', 'drop']:
+            for i in range(1, 6):
+                try:
+                    self.cur.execute(
+                        f'''drop personal file "{prefix}_test_{i}_{cls.id}.ipynb"''',
+                    )
+                except (OSError, s2.ManagementError):
+                    pass
+            for i in range(1, 6):
+                try:
+                    self.cur.execute(
+                        f'''drop shared file "{prefix}_test_{i}_{cls.id}.ipynb"''',
+                    )
+                except (OSError, s2.ManagementError):
+                    pass
+
+    def test_show_personal_files(self):
+        return self._test_show_files('personal')
+
+    def test_show_shared_files(self):
+        return self._test_show_files('shared')
+
+    def _test_show_files(self, ftype):
+        cls = type(self)
+        nb = os.path.join(os.path.dirname(__file__), 'test.ipynb')
+
+        # Should be empty
+        self.cur.execute(f'''
+            show {ftype} files like 'show_%{cls.id}%'
+        ''')
+        files = list(self.cur)
+        assert len(files) == 0
+
+        # Upload files
+        self.cur.execute(
+            f'upload {ftype} file to "show_test_1_{cls.id}.ipynb" from "{nb}"',
+        )
+        self.cur.execute(
+            f'upload {ftype} file to "show_test_2_{cls.id}.ipynb" from "{nb}"',
+        )
+        self.cur.execute(
+            f'upload {ftype} file to "show_test_3_{cls.id}.ipynb" from "{nb}"',
+        )
+        self.cur.execute(
+            f'upload {ftype} file to "show_test_4_{cls.id}.ipynb" from "{nb}"',
+        )
+        self.cur.execute(
+            f'upload {ftype} file to "show_test_5_{cls.id}.ipynb" from "{nb}"',
+        )
+
+        # Make sure files are there
+        self.cur.execute(f'''
+            show {ftype} files like 'show_%{cls.id}%'
+        ''')
+        files = list(self.cur)
+        assert len(files) == 5
+        assert list(sorted(x[0] for x in files)) == [
+            f'show_test_1_{cls.id}.ipynb',
+            f'show_test_2_{cls.id}.ipynb',
+            f'show_test_3_{cls.id}.ipynb',
+            f'show_test_4_{cls.id}.ipynb',
+            f'show_test_5_{cls.id}.ipynb',
+        ]
+
+        # Test ORDER BY
+        self.cur.execute(f'''
+            show {ftype} files like 'show_%{cls.id}%' order by name desc
+        ''')
+        files = list(self.cur)
+        assert len(files) == 5
+        assert list(x[0] for x in files) == [
+            f'show_test_5_{cls.id}.ipynb',
+            f'show_test_4_{cls.id}.ipynb',
+            f'show_test_3_{cls.id}.ipynb',
+            f'show_test_2_{cls.id}.ipynb',
+            f'show_test_1_{cls.id}.ipynb',
+        ]
+
+        # Test LIMIT
+        self.cur.execute(f'''
+            show {ftype} files like 'show_%{cls.id}%' order by name desc limit 3
+        ''')
+        files = list(self.cur)
+        assert len(files) == 3
+        assert list(x[0] for x in files) == [
+            f'show_test_5_{cls.id}.ipynb',
+            f'show_test_4_{cls.id}.ipynb',
+            f'show_test_3_{cls.id}.ipynb',
+        ]
+
+        # Test EXTENDED
+        self.cur.execute(f'''
+            show {ftype} files like 'show_%{cls.id}%' extended
+        ''')
+        assert [x[0] for x in self.cur.description] == \
+            ['Name', 'Type', 'Size', 'Writable', 'CreatedAt', 'LastModifiedAt']
+
+    def test_download_personal_files(self):
+        return self._test_download_files('personal')
+
+    def test_download_shared_files(self):
+        return self._test_download_files('shared')
+
+    def _test_download_files(self, ftype):
+        cls = type(self)
+        nb = os.path.join(os.path.dirname(__file__), 'test.ipynb')
+
+        # Should be empty
+        self.cur.execute(f'''
+            show {ftype} files like 'dl_%{cls.id}%'
+        ''')
+        files = list(self.cur)
+        assert len(files) == 0
+
+        # Upload files
+        self.cur.execute(f'upload {ftype} file to "dl_test_1_{cls.id}.ipynb" from "{nb}"')
+        self.cur.execute(f'upload {ftype} file to "dl_test_2_{cls.id}.ipynb" from "{nb}"')
+
+        # Make sure files are there
+        self.cur.execute(f'''
+            show {ftype} files like 'dl_%{cls.id}%'
+        ''')
+        files = list(self.cur)
+        assert len(files) == 2
+        assert list(sorted(x[0] for x in files)) == [
+            f'dl_test_1_{cls.id}.ipynb',
+            f'dl_test_2_{cls.id}.ipynb',
+        ]
+
+        # Download files
+        with tempfile.TemporaryDirectory() as tmpdir:
+            self.cur.execute(f'''
+                download {ftype} file 'dl_test_1_{cls.id}.ipynb'
+                    to '{tmpdir}/dl_test_1.ipynb'
+            ''')
+            with open(os.path.join(tmpdir, 'dl_test_1.ipynb'), 'r') as dl_file:
+                assert dl_file.read() == open(nb, 'r').read()
+
+            self.cur.execute(f'''
+                download {ftype} file 'dl_test_2_{cls.id}.ipynb'
+                    to '{tmpdir}/dl_test_2.ipynb'
+            ''')
+            with open(os.path.join(tmpdir, 'dl_test_2.ipynb'), 'r') as dl_file:
+                assert dl_file.read() == open(nb, 'r').read()
+
+    def test_drop_personal_files(self):
+        return self._test_drop_files('personal')
+
+    def test_drop_shared_files(self):
+        return self._test_drop_files('shared')
+
+    def _test_drop_files(self, ftype):
+        cls = type(self)
+        nb = os.path.join(os.path.dirname(__file__), 'test.ipynb')
+
+        # Should be empty
+        self.cur.execute(f'''
+            show {ftype} files like 'drop_%{cls.id}%'
+        ''')
+        files = list(self.cur)
+        assert len(files) == 0
+
+        # Upload files
+        self.cur.execute(
+            f'upload {ftype} file to "drop_test_1_{cls.id}.ipynb" from "{nb}"',
+        )
+        self.cur.execute(
+            f'upload {ftype} file to "drop_test_2_{cls.id}.ipynb" from "{nb}"',
+        )
+
+        # Make sure files are there
+        self.cur.execute(f'''
+            show {ftype} files like 'drop_%{cls.id}%'
+        ''')
+        files = list(self.cur)
+        assert len(files) == 2
+        assert list(sorted(x[0] for x in files)) == [
+            f'drop_test_1_{cls.id}.ipynb',
+            f'drop_test_2_{cls.id}.ipynb',
+        ]
+
+        # Drop 1 file
+        self.cur.execute(f'''
+            drop {ftype} file 'drop_test_1_{cls.id}.ipynb'
+        ''')
+
+        # Make sure 1 file is there
+        self.cur.execute(f'''
+            show {ftype} files like 'drop_%{cls.id}%'
+        ''')
+        files = list(self.cur)
+        assert len(files) == 1
+        assert list(x[0] for x in files) == [f'drop_test_2_{cls.id}.ipynb']
+
+        # Drop 2nd file
+        self.cur.execute(f'''
+            drop {ftype} file 'drop_test_2_{cls.id}.ipynb'
+        ''')
+
+        # Make sure no files are there
+        self.cur.execute(f'''
+            show {ftype} files like 'drop_%{cls.id}%'
+        ''')
+        files = list(self.cur)
+        assert len(files) == 0

{singlestoredb-1.12.1.dist-info → singlestoredb-1.12.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: singlestoredb
-Version: 1.12.1
+Version: 1.12.3
 Summary: Interface to the SingleStoreDB database and workspace management APIs
 Home-page: https://github.com/singlestore-labs/singlestoredb-python
 Author: SingleStore

{singlestoredb-1.12.1.dist-info → singlestoredb-1.12.3.dist-info}/RECORD

@@ -1,7 +1,7 @@
-_singlestoredb_accel.pyd,sha256=BwsfOZcfwH1-KzraPk2zr67GLoOuKfvzBv98PfiiScc,61440
-singlestoredb/__init__.py,sha256=OPUFo7H7ruOIJ8PhqbIqFM3SLvfG3ny3REXme5oFLhc,1712
+_singlestoredb_accel.pyd,sha256=OpnFhIc45QCOH-rhsmVoomDaPUZitjBn_cd39ae1bGE,60928
+singlestoredb/__init__.py,sha256=Mt5lSYU33x17JRX_uk7ftkZ8RmWnyWINacQdbCFPSxY,1712
 singlestoredb/auth.py,sha256=RmYiH0Wlc2RXc4pTlRMysxtBI445ggCIwojWKC_eDLE,7844
-singlestoredb/config.py,sha256=5OY9RDlGBrBWAHsGrg0X4v0y_QwNb7G6FSQooMgT8rY,13032
+singlestoredb/config.py,sha256=7-M2c7IAv3B1AmAKizgeNn880TDBbM4gbElLfStejIU,13035
 singlestoredb/connection.py,sha256=Ty_idVYH50Qx-j8WXy7NeB-DYLAcpdjGYTrTHkKzG9U,47309
 singlestoredb/converters.py,sha256=6gN3_RzSbw0Aimd5cGgBNPNq1yiHb1a_NK8qC9DmOQ0,21636
 singlestoredb/exceptions.py,sha256=WCCJrNSsU-hD-621Jpd6bwmvGftQ7byXkk-XKXlaxpg,3354
@@ -22,10 +22,10 @@ singlestoredb/apps/_uvicorn_util.py,sha256=Petkmq5keBPfXZsHBrnZfY3O2rUHvb3Cw6o-B
 singlestoredb/functions/__init__.py,sha256=Ehyp1pa40cvizzSYNGZ4UP4tiEcyfaxf_LI-oyt-Lro,84
 singlestoredb/functions/decorator.py,sha256=6c0uIknQNZrN5LAj-mWUw25Bcnl-_dRel6RMDzn2vK8,11816
 singlestoredb/functions/dtypes.py,sha256=5IwMSaSzxtSowxXrm5hZXW1lpNm6QILxiU4mAUEkBO0,32854
-singlestoredb/functions/signature.py,sha256=np4DHtfLM-S38srVu9KzsJZnI7tiwrl0UtMnA8F6rZ0,23162
+singlestoredb/functions/signature.py,sha256=0d1mqH1J0cV7W1NBAqM2C98DWIZomF5qYSS5-T6OW_g,23324
 singlestoredb/functions/ext/__init__.py,sha256=5ppI8IZN_zOwoJFdu_Oq9ipxtyHw9n6OMVAa_s9T_yY,24
 singlestoredb/functions/ext/arrow.py,sha256=mQhwaMpvCH_dP92WIhP_j-stu272n4UAHsFUOBTgnq0,9436
-singlestoredb/functions/ext/asgi.py,sha256=ENwGjjLxFYjv6HFB5WdX4YT5GSs5sn3mirOLgAM0wTY,44807
+singlestoredb/functions/ext/asgi.py,sha256=TNQlzosguNaM1-Rs1XXO78phav25XdKsbLTFpIvXgRA,45362
 singlestoredb/functions/ext/json.py,sha256=CROdj37cuJhAZ-CM93EI-SoLb4kxFcMGudsJ5QGyCoI,10831
 singlestoredb/functions/ext/mmap.py,sha256=zo6eweOFCZp0KIzAeL1vvuSjqvQhE8ybVhHbU0ZICt4,14124
 singlestoredb/functions/ext/rowdat_1.py,sha256=KYj_y5JWm3_B2-QC47HK-CNOrzujBqGUwLJfE49jwRg,23050
@@ -41,10 +41,10 @@ singlestoredb/fusion/handlers/files.py,sha256=pCx1sqnjPtQrp39rv_V4RX9CVtj6uSiL6H
 singlestoredb/fusion/handlers/job.py,sha256=3enfxHwERH7T4u0FEwOPN0IL0GtepaCYgEsisiy3Df4,21753
 singlestoredb/fusion/handlers/models.py,sha256=XWaPJQc3GQIOAcjNcxBSGUBJ3xu2qkzQ4ILa40TFQmY,6486
 singlestoredb/fusion/handlers/stage.py,sha256=PP-SSP204lwpmnycSXXSmFPzoN535JVuwglDCbaQ8Lw,14789
-singlestoredb/fusion/handlers/utils.py,sha256=2Lhnb9GqRMhCnO_C63iKt2hU7XFsllRKvQm3ChNzlrA,10890
+singlestoredb/fusion/handlers/utils.py,sha256=nV2lSzKhv7CzM7I_uIh5kmDV0Ec6VeeKoHczx5pVNcw,11009
 singlestoredb/fusion/handlers/workspace.py,sha256=NxoEY5xd5lCQmXiim4nhAYCL0agHo1H_rGPpqa31hiw,28397
 singlestoredb/http/__init__.py,sha256=4cEDvLloGc3LSpU-PnIwacyu0n5oIIIE6xk2SPyWD_w,939
-singlestoredb/http/connection.py,sha256=dqXX5SSn6EOV7q0Ehh0E525eLT__B_jJLG-7jgVjbXg,40861
+singlestoredb/http/connection.py,sha256=kLA-LA4zinbNOSemRbGqbTHd3bNn-ucOwmQZa8HIKPI,41075
 singlestoredb/magics/__init__.py,sha256=fqCBQ0s8o1CYE4Xo_XiSbkLDzLgMNDgpSkOx66-uDZw,1244
 singlestoredb/magics/run_personal.py,sha256=M11xHi9lWquh_pLSpFI89LGE7PhOPQOGqlSPDl48itE,1900
 singlestoredb/magics/run_shared.py,sha256=rnKpW4d8CJvD6ehK8jG8FlxuqZvjZl4KocPTsk-23O8,1805
@@ -52,7 +52,7 @@ singlestoredb/management/__init__.py,sha256=A66ZnFyX--PsAZ2tvtYUfIUBvVGDBFQsnVc6
 singlestoredb/management/billing_usage.py,sha256=0UHFSPCrN0nyeGFFM-HXS3NP8pYmYo2BCCahDEPXvzg,3883
 singlestoredb/management/cluster.py,sha256=auBzNYIXvnI6rq3DNpPgJhwWoT6JsyZRikjpON23Pxg,14867
 singlestoredb/management/export.py,sha256=2dCvnTnkxVI-arX3_375DtWzHkI1YNK5zaFYdHKE4cs,5277
-singlestoredb/management/files.py,sha256=rDXWmxVC-rx_ghHrCkdHyeBGGy6lb73wLWO6VkxdqMQ,31577
+singlestoredb/management/files.py,sha256=Z9GpS2EHf9atE8kJdz1vJtsiT80O6TV00MPhqyXfAAw,31579
 singlestoredb/management/job.py,sha256=Npfe1JLYJlggGBrXLniPKwKUKF1i3alvSY1SFtvauSs,25498
 singlestoredb/management/manager.py,sha256=8zU0d7NG83PYMhoAs2JriTqbqh-R2tLX7VZoeZtcogY,9148
 singlestoredb/management/organization.py,sha256=JBsNC4R3boUKdYvyCZyfGoVMC1mD6SPuMI1UssBVoOM,5611
@@ -64,7 +64,7 @@ singlestoredb/mysql/_auth.py,sha256=YaqqyvAHmeraBv3BM207rNveUVPM-mPnW20ts_ynVWg,
 singlestoredb/mysql/charset.py,sha256=mnCdMpvdub1S2mm2PSk2j5JddgsWRjsVLtGx-y9TskE,10724
 singlestoredb/mysql/connection.py,sha256=Dlam7wNSfn4jVBNrqdvxLzwxJqCQUzuu_rlcKU45MB0,75113
 singlestoredb/mysql/converters.py,sha256=vebFFm6IrC0WgY-5Eh-esaPizY5cq3vDOUlEKGaYM-U,7771
-singlestoredb/mysql/cursors.py,sha256=pkrP-1t8IhBJRnYpdM7Rdm-332nOq1RYTDJ_yg_q5HI,27682
+singlestoredb/mysql/cursors.py,sha256=YoZU5_weniqXcoeA0GVSxmetkPYooiDkXMbVBYUNlrU,27942
 singlestoredb/mysql/err.py,sha256=aDbmfq08gWVmfgIea735wSeiFdvYbB5wusgd3qTVq1s,2480
 singlestoredb/mysql/optionfile.py,sha256=bz0cZp8tQZvab1iU7OT0yldHyaMVbvAcUJ3TSNwcmyI,675
 singlestoredb/mysql/protocol.py,sha256=UzHcrv0Pgb1FNofuBTnSxpC9VDkgNbPEbBrRETstxAg,14888
@@ -113,14 +113,14 @@ singlestoredb/tests/test.ipynb,sha256=IEgXbByXyWDplZvod1J2SqNHZiPOGdD4oNVMd0ArP7
 singlestoredb/tests/test.sql,sha256=winJzhZ2W52PcQ1j8X_NNIDRBmEa-xMAYrS_hoUtAP8,18337
 singlestoredb/tests/test2.ipynb,sha256=_kBQVvEoinQ1zInNcWFKpbdw-djkLsEO8l3g2MEU_Zs,236
 singlestoredb/tests/test2.sql,sha256=CEM8_lX189iQU65G3Pod7lig6osfrveQyoDz6HC35YQ,38
-singlestoredb/tests/test_basics.py,sha256=tLiR46qUy8-OHHRSHsQTBp5q9NAwNPR9HvfutI6YgnM,47629
+singlestoredb/tests/test_basics.py,sha256=7JZdyudRaW3ZJkQ-m21ZstFlHz1Fyw2eSfN7y_zEhpU,49703
 singlestoredb/tests/test_config.py,sha256=Ad0PDmCnJMOyy9f7WTKiRasSR_3mYRByUlSb7k5ZySg,11502
 singlestoredb/tests/test_connection.py,sha256=UmoNo8erkcifEMbHZl83yAaRsyh6HANRdEtY3aViOK8,122792
 singlestoredb/tests/test_dbapi.py,sha256=cNJoTEZvYG7ckcwT7xqlkJX-2TDEYGTDDU1Igucp48k,679
 singlestoredb/tests/test_exceptions.py,sha256=vscMYmdOJr0JmkTAJrNI2w0Q96Nfugjkrt5_lYnw8i0,1176
 singlestoredb/tests/test_ext_func.py,sha256=gQErR-wAN8BqLNG5U4pNbg4qkQEo6Re8Hd9_Ztqo1RM,38550
 singlestoredb/tests/test_ext_func_data.py,sha256=9kn8BWmCjkbnP6hSbFhmhcdW4OmVT-GSvBTIzFBLEys,48796
-singlestoredb/tests/test_fusion.py,sha256=ckATjXKcDBvej68PZgTRJirdoywtUJ7WXkZmfR0la_4,24544
+singlestoredb/tests/test_fusion.py,sha256=S0Jk2NrcOitqM98r5fosHGbZ1sCZ2uxar5t48v-uOD0,52045
 singlestoredb/tests/test_http.py,sha256=7hwXe61hlUes3nji0MTTZweo94tJAlJ-vA5ct9geXFQ,8868
 singlestoredb/tests/test_management.py,sha256=EJY-JDFNS83_pM0KKJlEHoRiEZWHxjK2XWtM0YAy63U,46462
 singlestoredb/tests/test_plugin.py,sha256=P1nXLnTafaHkHN-6bVbGryxTu7OWJPU9SYFZ_WQUwq8,845
@@ -141,9 +141,9 @@ singlestoredb/utils/results.py,sha256=wR70LhCqlobniZf52r67zYLBOKjWHQm68NAskdRQND
 singlestoredb/utils/xdict.py,sha256=-wi1lSPTnY99fhVMBhPKJ8cCsQhNG4GMUfkEBDKYgCw,13321
 sqlx/__init__.py,sha256=4Sdn8HN-Hf8v0_wCt60DCckCg8BvgM3-9r4YVfZycRE,89
 sqlx/magic.py,sha256=6VBlotgjautjev599tHaTYOfcfOA9m6gV_-P1_Qc4lI,3622
-singlestoredb-1.12.1.dist-info/LICENSE,sha256=Bojenzui8aPNjlF3w4ojguDP7sTf8vFV_9Gc2UAG1sg,11542
-singlestoredb-1.12.1.dist-info/METADATA,sha256=Va-hWQVTc0rFk4y48dBNEVNd1zyFcG_0MkbkrBQ8LQE,5778
-singlestoredb-1.12.1.dist-info/WHEEL,sha256=c4k7z5HB0t-y0nBCv6KyJ6KCjn8SEGPddD0lhaPtU3E,96
-singlestoredb-1.12.1.dist-info/entry_points.txt,sha256=bSLaTWB5zGjpVYPAaI46MkkDup0su-eb3uAhCNYuRV0,48
-singlestoredb-1.12.1.dist-info/top_level.txt,sha256=lA65Vf4qAMfg_s1oG3LEO90h4t1Z-SPDbRqkevI3bSY,40
-singlestoredb-1.12.1.dist-info/RECORD,,
+singlestoredb-1.12.3.dist-info/LICENSE,sha256=Bojenzui8aPNjlF3w4ojguDP7sTf8vFV_9Gc2UAG1sg,11542
+singlestoredb-1.12.3.dist-info/METADATA,sha256=f8Qx8NA3HZiI2rGrFk1g8d41iXhAHaiEVww6DMtDixM,5778
+singlestoredb-1.12.3.dist-info/WHEEL,sha256=c4k7z5HB0t-y0nBCv6KyJ6KCjn8SEGPddD0lhaPtU3E,96
+singlestoredb-1.12.3.dist-info/entry_points.txt,sha256=bSLaTWB5zGjpVYPAaI46MkkDup0su-eb3uAhCNYuRV0,48
+singlestoredb-1.12.3.dist-info/top_level.txt,sha256=lA65Vf4qAMfg_s1oG3LEO90h4t1Z-SPDbRqkevI3bSY,40
+singlestoredb-1.12.3.dist-info/RECORD,,