fakesnow 0.9.20__py3-none-any.whl → 0.9.21__py3-none-any.whl

fakesnow/__init__.py

@@ -8,12 +8,11 @@ import unittest.mock as mock
 from collections.abc import Iterator, Sequence
 from contextlib import contextmanager
 
-import duckdb
 import snowflake.connector
 import snowflake.connector.pandas_tools
 
 import fakesnow.fakes as fakes
-from fakesnow.global_database import create_global_database
+from fakesnow.instance import FakeSnow
 
 
 @contextmanager
@@ -52,20 +51,15 @@ def patch(
     # won't be able to patch extra targets
     assert not isinstance(snowflake.connector.connect, mock.MagicMock), "Snowflake connector is already patched"
 
-    duck_conn = duckdb.connect(database=":memory:")
-    create_global_database(duck_conn)
+    fs = FakeSnow(
+        create_database_on_connect=create_database_on_connect,
+        create_schema_on_connect=create_schema_on_connect,
+        db_path=db_path,
+        nop_regexes=nop_regexes,
+    )
 
     fake_fns = {
-        # every time we connect, create a new cursor (ie: connection) so we can isolate each connection's
-        # schema setting, see https://duckdb.org/docs/api/python/overview.html#startup--shutdown
-        snowflake.connector.connect: lambda **kwargs: fakes.FakeSnowflakeConnection(
-            duck_conn.cursor(),
-            create_database=create_database_on_connect,
-            create_schema=create_schema_on_connect,
-            db_path=db_path,
-            nop_regexes=nop_regexes,
-            **kwargs,
-        ),
+        snowflake.connector.connect: fs.connect,
         snowflake.connector.pandas_tools.write_pandas: fakes.write_pandas,
     }
 

fakesnow/arrow.py

@@ -0,0 +1,32 @@
+import pyarrow as pa
+
+
+def with_sf_metadata(schema: pa.Schema) -> pa.Schema:
+    # see https://github.com/snowflakedb/snowflake-connector-python/blob/e9393a6/src/snowflake/connector/nanoarrow_cpp/ArrowIterator/CArrowTableIterator.cpp#L32
+    # and https://github.com/snowflakedb/snowflake-connector-python/blob/e9393a6/src/snowflake/connector/nanoarrow_cpp/ArrowIterator/SnowflakeType.cpp#L10
+    fms = []
+    for i, t in enumerate(schema.types):
+        f = schema.field(i)
+
+        if isinstance(t, pa.Decimal128Type):
+            fm = f.with_metadata({"logicalType": "FIXED", "precision": str(t.precision), "scale": str(t.scale)})
+        elif t == pa.string():
+            fm = f.with_metadata({"logicalType": "TEXT"})
+        else:
+            raise NotImplementedError(f"Unsupported Arrow type: {t}")
+        fms.append(fm)
+    return pa.schema(fms)
+
+
+def to_ipc(table: pa.Table) -> pa.Buffer:
+    batches = table.to_batches()
+    if len(batches) != 1:
+        raise NotImplementedError(f"{len(batches)} batches")
+    batch = batches[0]
+
+    sink = pa.BufferOutputStream()
+
+    with pa.ipc.new_stream(sink, with_sf_metadata(batch.schema)) as writer:
+        writer.write_batch(batch)
+
+    return sink.getvalue()

fakesnow/fakes.py

@@ -203,6 +203,7 @@ class FakeSnowflakeCursor:
             .transform(transforms.sha256)
             .transform(transforms.create_clone)
             .transform(transforms.alias_in_join)
+            .transform(transforms.alter_table_strip_cluster_by)
         )
 
     def _execute(
@@ -522,9 +523,14 @@ class FakeSnowflakeConnection:
     ):
         self._duck_conn = duck_conn
         # upper case database and schema like snowflake unquoted identifiers
-        # NB: catalog names are not case-sensitive in duckdb but stored as cased in information_schema.schemata
+        # so they appear as upper-cased in information_schema
+        # catalog and schema names are not actually case-sensitive in duckdb even though
+        # they are as cased in information_schema.schemata, so when selecting from
+        # information_schema.schemata below we use upper-case to match any existing duckdb
+        # catalog or schemas like "information_schema"
         self.database = database and database.upper()
         self.schema = schema and schema.upper()
+
         self.database_set = False
         self.schema_set = False
         self.db_path = Path(db_path) if db_path else None
@@ -538,7 +544,7 @@ class FakeSnowflakeConnection:
             and self.database
             and not duck_conn.execute(
                 f"""select * from information_schema.schemata
-                where catalog_name = '{self.database}'"""
+                where upper(catalog_name) = '{self.database}'"""
             ).fetchone()
         ):
             db_file = f"{self.db_path/self.database}.db" if self.db_path else ":memory:"
@@ -553,7 +559,7 @@ class FakeSnowflakeConnection:
             and self.schema
             and not duck_conn.execute(
                 f"""select * from information_schema.schemata
-                where catalog_name = '{self.database}' and schema_name = '{self.schema}'"""
+                where upper(catalog_name) = '{self.database}' and upper(schema_name) = '{self.schema}'"""
             ).fetchone()
         ):
             duck_conn.execute(f"CREATE SCHEMA {self.database}.{self.schema}")
@@ -564,7 +570,7 @@ class FakeSnowflakeConnection:
             and self.schema
             and duck_conn.execute(
                 f"""select * from information_schema.schemata
-                where catalog_name = '{self.database}' and schema_name = '{self.schema}'"""
+                where upper(catalog_name) = '{self.database}' and upper(schema_name) = '{self.schema}'"""
             ).fetchone()
         ):
             duck_conn.execute(f"SET schema='{self.database}.{self.schema}'")
@@ -575,7 +581,7 @@ class FakeSnowflakeConnection:
             self.database
             and duck_conn.execute(
                 f"""select * from information_schema.schemata
-                where catalog_name = '{self.database}'"""
+                where upper(catalog_name) = '{self.database}'"""
             ).fetchone()
         ):
             duck_conn.execute(f"SET schema='{self.database}.main'")
@@ -602,6 +608,7 @@ class FakeSnowflakeConnection:
         self.cursor().execute("COMMIT")
 
     def cursor(self, cursor_class: type[SnowflakeCursor] = SnowflakeCursor) -> FakeSnowflakeCursor:
+        # TODO: use duck_conn cursor for thread-safety
         return FakeSnowflakeCursor(conn=self, duck_conn=self._duck_conn, use_dict_result=cursor_class == DictCursor)
 
     def execute_string(

fakesnow/info_schema.py

@@ -62,8 +62,8 @@ case when columns.data_type='BIGINT' then 10
 case when columns.data_type='DOUBLE' then NULL else columns.numeric_scale end as numeric_scale,
 collation_name, is_identity, identity_generation, identity_cycle,
     ddb_columns.comment as comment,
-    null as identity_start,
-    null as identity_increment,
+    null::VARCHAR as identity_start,
+    null::VARCHAR as identity_increment,
 from ${catalog}.information_schema.columns columns
 left join ${catalog}.information_schema._fs_columns_ext ext
   on ext_table_catalog = columns.table_catalog
@@ -86,7 +86,7 @@ select
     catalog_name as database_name,
     'SYSADMIN' as database_owner,
     'NO' as is_transient,
-    null as comment,
+    null::VARCHAR as comment,
     to_timestamp(0)::timestamptz as created,
     to_timestamp(0)::timestamptz as last_altered,
     1 as retention_time,
@@ -116,7 +116,7 @@ select
     to_timestamp(0)::timestamptz as last_altered,
     to_timestamp(0)::timestamptz as last_ddl,
     'SYSADMIN' as last_ddl_by,
-    null as comment
+    null::VARCHAR as comment
 from duckdb_views
 where database_name = '${catalog}'
   and schema_name != 'information_schema'

fakesnow/instance.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import os
+from typing import Any
+
+import duckdb
+
+import fakesnow.fakes as fakes
+
+GLOBAL_DATABASE_NAME = "_fs_global"
+USERS_TABLE_FQ_NAME = f"{GLOBAL_DATABASE_NAME}._fs_users_ext"
+
+# replicates the output structure of https://docs.snowflake.com/en/sql-reference/sql/show-users
+SQL_CREATE_INFORMATION_SCHEMA_USERS_TABLE_EXT = f"""
+create table if not exists {USERS_TABLE_FQ_NAME} (
+    name varchar,
+    created_on TIMESTAMPTZ,
+    login_name varchar,
+    display_name varchar,
+    first_name varchar,
+    last_name varchar,
+    email varchar,
+    mins_to_unlock varchar,
+    days_to_expiry varchar,
+    comment varchar,
+    disabled varchar,
+    must_change_password varchar,
+    snowflake_lock varchar,
+    default_warehouse varchar,
+    default_namespace varchar,
+    default_role varchar,
+    default_secondary_roles varchar,
+    ext_authn_duo varchar,
+    ext_authn_uid varchar,
+    mins_to_bypass_mfa varchar,
+    owner varchar,
+    last_success_login TIMESTAMPTZ,
+    expires_at_time TIMESTAMPTZ,
+    locked_until_time TIMESTAMPTZ,
+    has_password varchar,
+    has_rsa_public_key varchar,
+)
+"""
+
+
+def create_global_database(conn: duckdb.DuckDBPyConnection) -> None:
+    """Create a "global" database for storing objects which span databases.
+
+    Including (but not limited to):
+     - Users
+    """
+    conn.execute(f"ATTACH IF NOT EXISTS ':memory:' AS {GLOBAL_DATABASE_NAME}")
+    conn.execute(SQL_CREATE_INFORMATION_SCHEMA_USERS_TABLE_EXT)
+
+
+class FakeSnow:
+    def __init__(
+        self,
+        create_database_on_connect: bool = True,
+        create_schema_on_connect: bool = True,
+        db_path: str | os.PathLike | None = None,
+        nop_regexes: list[str] | None = None,
+    ):
+        self.create_database_on_connect = create_database_on_connect
+        self.create_schema_on_connect = create_schema_on_connect
+        self.db_path = db_path
+        self.nop_regexes = nop_regexes
+
+        self.duck_conn = duckdb.connect(database=":memory:")
+
+        # create a "global" database for storing objects which span databases.
+        self.duck_conn.execute(f"ATTACH IF NOT EXISTS ':memory:' AS {GLOBAL_DATABASE_NAME}")
+        self.duck_conn.execute(SQL_CREATE_INFORMATION_SCHEMA_USERS_TABLE_EXT)
+
+    def connect(
+        self, database: str | None = None, schema: str | None = None, **kwargs: Any
+    ) -> fakes.FakeSnowflakeConnection:
+        # every time we connect, create a new cursor (ie: connection) so we can isolate each connection's
+        # schema setting see
+        # https://github.com/duckdb/duckdb/blob/18254ec/tools/pythonpkg/src/pyconnection.cpp#L1440
+        # and to make connections thread-safe see
+        # https://duckdb.org/docs/api/python/overview.html#using-connections-in-parallel-python-programs
+        return fakes.FakeSnowflakeConnection(
+            self.duck_conn.cursor(),
+            database,
+            schema,
+            create_database=self.create_database_on_connect,
+            create_schema=self.create_schema_on_connect,
+            db_path=self.db_path,
+            nop_regexes=self.nop_regexes,
+            **kwargs,
+        )

fakesnow/server.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import gzip
+import json
+import secrets
+from base64 import b64encode
+from dataclasses import dataclass
+
+from starlette.applications import Starlette
+from starlette.concurrency import run_in_threadpool
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+from starlette.routing import Route
+
+from fakesnow.arrow import to_ipc
+from fakesnow.fakes import FakeSnowflakeConnection
+from fakesnow.instance import FakeSnow
+
+fs = FakeSnow()
+sessions = {}
+
+
+@dataclass
+class ServerError(Exception):
+    status_code: int
+    code: str
+    message: str
+
+
+def login_request(request: Request) -> JSONResponse:
+    database = request.query_params.get("databaseName")
+    schema = request.query_params.get("schemaName")
+    token = secrets.token_urlsafe(32)
+    sessions[token] = fs.connect(database, schema)
+    return JSONResponse({"data": {"token": token}, "success": True})
+
+
+async def query_request(request: Request) -> JSONResponse:
+    try:
+        conn = to_conn(request)
+
+        body = await request.body()
+        body_json = json.loads(gzip.decompress(body))
+
+        sql_text = body_json["sqlText"]
+
+        # only a single sql statement is sent at a time by the python snowflake connector
+        cur = await run_in_threadpool(conn.cursor().execute, sql_text)
+
+        assert cur._arrow_table, "No result set"  # noqa: SLF001
+
+        batch_bytes = to_ipc(cur._arrow_table)  # noqa: SLF001
+        rowset_b64 = b64encode(batch_bytes).decode("utf-8")
+
+        return JSONResponse(
+            {
+                "data": {
+                    "rowtype": [
+                        {
+                            "name": "'HELLO WORLD'",
+                            "nullable": False,
+                            "type": "text",
+                            "length": 11,
+                            "scale": None,
+                            "precision": None,
+                        }
+                    ],
+                    "rowsetBase64": rowset_b64,
+                    "total": 1,
+                    "queryResultFormat": "arrow",
+                },
+                "success": True,
+            }
+        )
+
+    except ServerError as e:
+        return JSONResponse(
+            {"data": None, "code": e.code, "message": e.message, "success": False, "headers": None},
+            status_code=e.status_code,
+        )
+
+
+def to_conn(request: Request) -> FakeSnowflakeConnection:
+    if not (auth := request.headers.get("Authorization")):
+        raise ServerError(status_code=401, code="390103", message="Session token not found in the request data.")
+
+    token = auth[17:-1]
+
+    if not (conn := sessions.get(token)):
+        raise ServerError(status_code=401, code="390104", message="User must login again to access the service.")
+
+    return conn
+
+
+routes = [
+    Route(
+        "/session/v1/login-request",
+        login_request,
+        methods=["POST"],
+    ),
+    Route(
+        "/queries/v1/query-request",
+        query_request,
+        methods=["POST"],
+    ),
+]
+
+app = Starlette(debug=True, routes=routes)

fakesnow/transforms.py

@@ -7,11 +7,11 @@ from typing import ClassVar, Literal, cast
 import sqlglot
 from sqlglot import exp
 
-from fakesnow.global_database import USERS_TABLE_FQ_NAME
+from fakesnow.instance import USERS_TABLE_FQ_NAME
 from fakesnow.variables import Variables
 
 MISSING_DATABASE = "missing_database"
-SUCCESS_NOP = sqlglot.parse_one("SELECT 'Statement executed successfully.'")
+SUCCESS_NOP = sqlglot.parse_one("SELECT 'Statement executed successfully.' as status")
 
 
 def alias_in_join(expression: exp.Expression) -> exp.Expression:
@@ -33,6 +33,18 @@ def alias_in_join(expression: exp.Expression) -> exp.Expression:
     return expression
 
 
+def alter_table_strip_cluster_by(expression: exp.Expression) -> exp.Expression:
+    """Turn alter table cluster by into a no-op"""
+    if (
+        isinstance(expression, exp.AlterTable)
+        and (actions := expression.args.get("actions"))
+        and len(actions) == 1
+        and (isinstance(actions[0], exp.Cluster))
+    ):
+        return SUCCESS_NOP
+    return expression
+
+
 def array_size(expression: exp.Expression) -> exp.Expression:
     if isinstance(expression, exp.ArraySize):
         # case is used to convert 0 to null, because null is returned by duckdb when no case matches
@@ -551,12 +563,13 @@ def information_schema_fs_columns_snowflake(expression: exp.Expression) -> exp.E
     """
 
     if (
-        isinstance(expression, exp.Select)
-        and (tbl_exp := expression.find(exp.Table))
-        and tbl_exp.name.upper() == "COLUMNS"
-        and tbl_exp.db.upper() == "INFORMATION_SCHEMA"
+        isinstance(expression, exp.Table)
+        and expression.db
+        and expression.db.upper() == "INFORMATION_SCHEMA"
+        and expression.name
+        and expression.name.upper() == "COLUMNS"
     ):
-        tbl_exp.set("this", exp.Identifier(this="_FS_COLUMNS_SNOWFLAKE", quoted=False))
+        expression.set("this", exp.Identifier(this="_FS_COLUMNS_SNOWFLAKE", quoted=False))
 
     return expression
 

fakesnow/variables.py

@@ -5,10 +5,23 @@ from sqlglot import exp
 
 
 # Implements snowflake variables: https://docs.snowflake.com/en/sql-reference/session-variables#using-variables-in-sql
+# [ ] Add support for setting multiple variables in a single statement
 class Variables:
     @classmethod
     def is_variable_modifier(cls, expr: exp.Expression) -> bool:
-        return isinstance(expr, exp.Set) or cls._is_unset_expression(expr)
+        return cls._is_set_expression(expr) or cls._is_unset_expression(expr)
+
+    @classmethod
+    def _is_set_expression(cls, expr: exp.Expression) -> bool:
+        if isinstance(expr, exp.Set):
+            is_set = not expr.args.get("unset")
+            if is_set:  # SET varname = value;
+                set_expressions = expr.args.get("expressions")
+                assert set_expressions, "SET without values in expression(s) is unexpected."
+                # Avoids mistakenly setting variables for statements that use SET in a different context.
+                # (eg. WHEN MATCHED THEN UPDATE SET x=7)
+                return isinstance(set_expressions[0], exp.SetItem)
+        return False
 
     @classmethod
     def _is_unset_expression(cls, expr: exp.Expression) -> bool:
@@ -22,11 +35,11 @@ class Variables:
 
     def update_variables(self, expr: exp.Expression) -> None:
         if isinstance(expr, exp.Set):
-            unset = expr.args.get("unset")
-            if not unset:  # SET varname = value;
-                unset_expressions = expr.args.get("expressions")
-                assert unset_expressions, "SET without values in expression(s) is unexpected."
-                eq = unset_expressions[0].this
+            is_set = not expr.args.get("unset")
+            if is_set:  # SET varname = value;
+                set_expressions = expr.args.get("expressions")
+                assert set_expressions, "SET without values in expression(s) is unexpected."
+                eq = set_expressions[0].this
                 name = eq.this.sql()
                 value = eq.args.get("expression").sql()
                 self._set(name, value)

{fakesnow-0.9.20.dist-info → fakesnow-0.9.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fakesnow
-Version: 0.9.20
+Version: 0.9.21
 Summary: Fake Snowflake Connector for Python. Run, mock and test Snowflake DB locally.
 License: Apache License
                                    Version 2.0, January 2004
@@ -213,20 +213,25 @@ License-File: LICENSE
 Requires-Dist: duckdb ~=1.0.0
 Requires-Dist: pyarrow
 Requires-Dist: snowflake-connector-python
-Requires-Dist: sqlglot ~=25.3.0
+Requires-Dist: sqlglot ~=25.5.1
 Provides-Extra: dev
 Requires-Dist: build ~=1.0 ; extra == 'dev'
 Requires-Dist: pandas-stubs ; extra == 'dev'
 Requires-Dist: snowflake-connector-python[pandas,secure-local-storage] ; extra == 'dev'
 Requires-Dist: pre-commit ~=3.4 ; extra == 'dev'
+Requires-Dist: pyarrow-stubs ; extra == 'dev'
 Requires-Dist: pytest ~=8.0 ; extra == 'dev'
-Requires-Dist: ruff ~=0.4.2 ; extra == 'dev'
+Requires-Dist: pytest-asyncio ; extra == 'dev'
+Requires-Dist: ruff ~=0.5.1 ; extra == 'dev'
 Requires-Dist: twine ~=5.0 ; extra == 'dev'
 Requires-Dist: snowflake-sqlalchemy ~=1.5.0 ; extra == 'dev'
 Provides-Extra: notebook
 Requires-Dist: duckdb-engine ; extra == 'notebook'
 Requires-Dist: ipykernel ; extra == 'notebook'
 Requires-Dist: jupysql ; extra == 'notebook'
+Provides-Extra: server
+Requires-Dist: starlette ; extra == 'server'
+Requires-Dist: uvicorn ; extra == 'server'
 
 # fakesnow ❄️
 

fakesnow-0.9.21.dist-info/RECORD

@@ -0,0 +1,21 @@
+fakesnow/__init__.py,sha256=9tFJJKvowKNW3vfnlmza6hOLN1I52DwChgNc5Ew6CcA,3499
+fakesnow/__main__.py,sha256=GDrGyNTvBFuqn_UfDjKs7b3LPtU6gDv1KwosVDrukIM,76
+fakesnow/arrow.py,sha256=1ypCsf-r2Ven6CuSm-bTLoeq1G31kBD6JnaLvDxpwhU,1218
+fakesnow/checks.py,sha256=-QMvdcrRbhN60rnzxLBJ0IkUBWyLR8gGGKKmCS0w9mA,2383
+fakesnow/cli.py,sha256=9qfI-Ssr6mo8UmIlXkUAOz2z2YPBgDsrEVaZv9FjGFs,2201
+fakesnow/expr.py,sha256=CAxuYIUkwI339DQIBzvFF0F-m1tcVGKEPA5rDTzmH9A,892
+fakesnow/fakes.py,sha256=wLSjKrNI8wxe3MuUAa97jpUHd5vZTzvrlF1-Hf0FC0M,31208
+fakesnow/fixtures.py,sha256=G-NkVeruSQAJ7fvSS2fR2oysUn0Yra1pohHlOvacKEk,455
+fakesnow/info_schema.py,sha256=LjS_-8YXBtCSvkdU5uL0aJdFcZEsBa6o5zf-Q_aV9i0,6302
+fakesnow/instance.py,sha256=3cJvPRuFy19dMKXbtBLl6imzO48pEw8uTYhZyFDuwhk,3133
+fakesnow/macros.py,sha256=pX1YJDnQOkFJSHYUjQ6ErEkYIKvFI6Ncz_au0vv1csA,265
+fakesnow/py.typed,sha256=B-DLSjYBi7pkKjwxCSdpVj2J02wgfJr-E7B1wOUyxYU,80
+fakesnow/server.py,sha256=HwCAZ5AhU4nRbFGIqDBs2rdwoK70dYZDyw1XfE1cHqU,3082
+fakesnow/transforms.py,sha256=GCpczoFdvnffQMvSG59PNiiTVTld9kROnnR5dWNXQvY,53624
+fakesnow/variables.py,sha256=WXyPnkeNwD08gy52yF66CVe2twiYC50tztNfgXV4q1k,3032
+fakesnow-0.9.21.dist-info/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
+fakesnow-0.9.21.dist-info/METADATA,sha256=6EzLZbGBTS0VEYCHdG4sNNZT-w5SiespKcitL_XEtM4,18043
+fakesnow-0.9.21.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+fakesnow-0.9.21.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
+fakesnow-0.9.21.dist-info/top_level.txt,sha256=500evXI1IFX9so82cizGIEMHAb_dJNPaZvd2H9dcKTA,24
+fakesnow-0.9.21.dist-info/RECORD,,

fakesnow/global_database.py

@@ -1,46 +0,0 @@
-from duckdb import DuckDBPyConnection
-
-GLOBAL_DATABASE_NAME = "_fs_global"
-USERS_TABLE_FQ_NAME = f"{GLOBAL_DATABASE_NAME}._fs_users_ext"
-
-# replicates the output structure of https://docs.snowflake.com/en/sql-reference/sql/show-users
-SQL_CREATE_INFORMATION_SCHEMA_USERS_TABLE_EXT = f"""
-create table if not exists {USERS_TABLE_FQ_NAME} (
-    name varchar,
-    created_on TIMESTAMPTZ,
-    login_name varchar,
-    display_name varchar,
-    first_name varchar,
-    last_name varchar,
-    email varchar,
-    mins_to_unlock varchar,
-    days_to_expiry varchar,
-    comment varchar,
-    disabled varchar,
-    must_change_password varchar,
-    snowflake_lock varchar,
-    default_warehouse varchar,
-    default_namespace varchar,
-    default_role varchar,
-    default_secondary_roles varchar,
-    ext_authn_duo varchar,
-    ext_authn_uid varchar,
-    mins_to_bypass_mfa varchar,
-    owner varchar,
-    last_success_login TIMESTAMPTZ,
-    expires_at_time TIMESTAMPTZ,
-    locked_until_time TIMESTAMPTZ,
-    has_password varchar,
-    has_rsa_public_key varchar,
-)
-"""
-
-
-def create_global_database(conn: DuckDBPyConnection) -> None:
-    """Create a "global" database for storing objects which span database.
-
-    Including (but not limited to):
-     - Users
-    """
-    conn.execute(f"ATTACH IF NOT EXISTS ':memory:' AS {GLOBAL_DATABASE_NAME}")
-    conn.execute(SQL_CREATE_INFORMATION_SCHEMA_USERS_TABLE_EXT)

fakesnow-0.9.20.dist-info/RECORD

@@ -1,19 +0,0 @@
-fakesnow/__init__.py,sha256=gEo6Jg6f8tJUwRTsrfb9q-FpDOufelf8Y3XeWtEJ9wg,3897
-fakesnow/__main__.py,sha256=GDrGyNTvBFuqn_UfDjKs7b3LPtU6gDv1KwosVDrukIM,76
-fakesnow/checks.py,sha256=-QMvdcrRbhN60rnzxLBJ0IkUBWyLR8gGGKKmCS0w9mA,2383
-fakesnow/cli.py,sha256=9qfI-Ssr6mo8UmIlXkUAOz2z2YPBgDsrEVaZv9FjGFs,2201
-fakesnow/expr.py,sha256=CAxuYIUkwI339DQIBzvFF0F-m1tcVGKEPA5rDTzmH9A,892
-fakesnow/fakes.py,sha256=MYzj3XqVokPbOdOcU4WFep1CRsuXlBIwaz9EWaNCGo4,30778
-fakesnow/fixtures.py,sha256=G-NkVeruSQAJ7fvSS2fR2oysUn0Yra1pohHlOvacKEk,455
-fakesnow/global_database.py,sha256=WTVIP1VhNvdCeX7TQncX1TRpGQU5rBf5Pbxim40zeSU,1399
-fakesnow/info_schema.py,sha256=CdIcGXHEQ_kmEAzdQKvA-PX41LA6wlK-4p1J45qgKYA,6266
-fakesnow/macros.py,sha256=pX1YJDnQOkFJSHYUjQ6ErEkYIKvFI6Ncz_au0vv1csA,265
-fakesnow/py.typed,sha256=B-DLSjYBi7pkKjwxCSdpVj2J02wgfJr-E7B1wOUyxYU,80
-fakesnow/transforms.py,sha256=7XS42Ehv3SRciQLpAL4swCFCkNpOTwarXEIX6jUzO4Y,53230
-fakesnow/variables.py,sha256=iE8fnyaMnIoWh_ftT2qUq39fCNglwtQoGbC7MkTqHGU,2341
-fakesnow-0.9.20.dist-info/LICENSE,sha256=kW-7NWIyaRMQiDpryfSmF2DObDZHGR1cJZ39s6B1Svg,11344
-fakesnow-0.9.20.dist-info/METADATA,sha256=RSk43Zbbb8LQsG3G03DwUO8nVbaxs5qNd5VKTHqg4Xw,17839
-fakesnow-0.9.20.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-fakesnow-0.9.20.dist-info/entry_points.txt,sha256=2riAUgu928ZIHawtO8EsfrMEJhi-EH-z_Vq7Q44xKPM,47
-fakesnow-0.9.20.dist-info/top_level.txt,sha256=500evXI1IFX9so82cizGIEMHAb_dJNPaZvd2H9dcKTA,24
-fakesnow-0.9.20.dist-info/RECORD,,