We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
URI type does not allow NULL value to be set.
## Description
A column with the `URI` type does not allow `null` value to be set after creation even though the column `nullable` option is enabled

## Expected behaviour
Allow setting a null value to a nullable `URI` type column without throwing up an error 

## To Reproduce
1. Create a new column with the type `URI`.
2. Try setting a null value to the column by creating a new row and not entering any data.
3. New row does not get created due to an error with `URI` type not accepting a null value




--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `db/types/uri.py`
Content:
```
1 from enum import Enum
2 import os
3 from sqlalchemy import text, Text, Table, Column, String, MetaData
4 from sqlalchemy.sql import quoted_name
5 from sqlalchemy.sql.functions import GenericFunction
6 from sqlalchemy.types import UserDefinedType
7 
8 from db.functions import hints
9 from db.functions.base import DBFunction, Contains, sa_call_sql_function, Equal
10 from db.functions.packed import DBFunctionPacked
11 
12 from db.types import base
13 
14 URI_STR = base.MathesarCustomType.URI.value
15 DB_TYPE = base.get_qualified_name(URI_STR)
16 
17 TLDS_PATH = os.path.join(
18     os.path.join(os.path.abspath(os.path.dirname(__file__)), "resources"),
19     "tlds.txt"
20 )
21 
22 TLDS_TABLE_NAME = "top_level_domains"
23 QUALIFIED_TLDS = base.get_qualified_name(TLDS_TABLE_NAME)
24 
25 
26 class URIFunction(Enum):
27     PARTS = URI_STR + "_parts"
28     SCHEME = URI_STR + "_scheme"
29     AUTHORITY = URI_STR + "_authority"
30     PATH = URI_STR + "_path"
31     QUERY = URI_STR + "_query"
32     FRAGMENT = URI_STR + "_fragment"
33 
34 
35 QualifiedURIFunction = Enum(
36     "QualifiedURIFunction",
37     {
38         func_name.name: base.get_qualified_name(func_name.value)
39         for func_name in URIFunction
40     }
41 )
42 
43 
44 # This regex and the use of it are based on the one given in RFC 3986.
45 URI_REGEX_STR = r"'^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?'"
46 
47 
48 class URI(UserDefinedType):
49     def get_col_spec(self, **_):
50         # This results in the type name being upper case when viewed.
51         # Actual usage in the DB is case-insensitive.
52         return DB_TYPE.upper()
53 
54 
55 # This function lets us avoid having to define repetitive classes for
56 # adding custom SQL functions to SQLAlchemy
57 def build_generic_function_def_class(name):
58     class_dict = {
59         "type": Text,
60         "name": quoted_name(QualifiedURIFunction[name].value, False),
61         "identifier": URIFunction[name].value
62     }
63     return type(class_dict["identifier"], (GenericFunction,), class_dict)
64 
65 
66 # We need to add these classes to the globals() dict so they get picked
67 # up by SQLAlchemy
68 globals().update(
69     {f.name: build_generic_function_def_class(f.name) for f in URIFunction}
70 )
71 
72 
73 def install(engine):
74     drop_domain_query = f"""
75     DROP DOMAIN IF EXISTS {DB_TYPE};
76     """
77 
78     create_uri_parts_query = f"""
79     CREATE OR REPLACE FUNCTION {QualifiedURIFunction.PARTS.value}({base.PostgresType.TEXT.value})
80     RETURNS {base.PostgresType.TEXT.value}[] AS $$
81         SELECT regexp_match($1, {URI_REGEX_STR});
82     $$
83     LANGUAGE SQL IMMUTABLE RETURNS NULL ON NULL INPUT;
84     """
85     uri_parts_map = {
86         QualifiedURIFunction.SCHEME.value: 2,
87         QualifiedURIFunction.AUTHORITY.value: 4,
88         QualifiedURIFunction.PATH.value: 5,
89         QualifiedURIFunction.QUERY.value: 7,
90         QualifiedURIFunction.FRAGMENT.value: 9,
91     }
92 
93     create_domain_query = f"""
94     CREATE DOMAIN {DB_TYPE} AS text CHECK (
95         {QualifiedURIFunction.SCHEME.value}(value) IS NOT NULL
96         AND {QualifiedURIFunction.PATH.value}(value) IS NOT NULL
97     );
98     """
99 
100     with engine.begin() as conn:
101         conn.execute(text(drop_domain_query))
102         conn.execute(text(create_uri_parts_query))
103         for part, index in uri_parts_map.items():
104             create_uri_part_getter_query = f"""
105             CREATE OR REPLACE FUNCTION {part}({base.PostgresType.TEXT.value})
106             RETURNS {base.PostgresType.TEXT.value} AS $$
107                 SELECT ({QualifiedURIFunction.PARTS.value}($1))[{index}];
108             $$
109             LANGUAGE SQL IMMUTABLE RETURNS NULL ON NULL INPUT;
110             """
111             conn.execute(text(create_uri_part_getter_query))
112         conn.execute(text(create_domain_query))
113         conn.commit()
114 
115 
116 def install_tld_lookup_table(engine):
117     tlds_table = Table(
118         TLDS_TABLE_NAME,
119         MetaData(bind=engine),
120         Column("tld", String, primary_key=True),
121         schema=base.preparer.quote_schema(base.SCHEMA)
122     )
123     tlds_table.create()
124     with engine.begin() as conn, open(TLDS_PATH) as f:
125         conn.execute(
126             tlds_table.insert(),
127             [{"tld": tld.strip().lower()} for tld in f if tld[:2] != "# "],
128         )
129 
130 
131 class ExtractURIAuthority(DBFunction):
132     id = 'extract_uri_authority'
133     name = 'extract URI authority'
134     hints = tuple([
135         hints.parameter_count(1),
136         hints.parameter(1, hints.uri),
137     ])
138     depends_on = tuple([URIFunction.AUTHORITY])
139 
140     @staticmethod
141     def to_sa_expression(uri):
142         return sa_call_sql_function(URIFunction.AUTHORITY.value, uri)
143 
144 
145 class ExtractURIScheme(DBFunction):
146     id = 'extract_uri_scheme'
147     name = 'extract URI scheme'
148     hints = tuple([
149         hints.parameter_count(1),
150         hints.parameter(1, hints.uri),
151     ])
152     depends_on = tuple([URIFunction.SCHEME])
153 
154     @staticmethod
155     def to_sa_expression(uri):
156         return sa_call_sql_function(URIFunction.SCHEME.value, uri)
157 
158 
159 class URIAuthorityContains(DBFunctionPacked):
160     id = 'uri_authority_contains'
161     name = 'URI authority contains'
162     hints = tuple([
163         hints.returns(hints.boolean),
164         hints.parameter_count(2),
165         hints.parameter(0, hints.uri),
166         hints.parameter(1, hints.string_like),
167         hints.mathesar_filter,
168     ])
169     depends_on = tuple([URIFunction.AUTHORITY])
170 
171     def unpack(self):
172         param0 = self.parameters[0]
173         param1 = self.parameters[1]
174         return Contains([
175             ExtractURIAuthority([param0]),
176             param1,
177         ])
178 
179 
180 class URISchemeEquals(DBFunctionPacked):
181     id = 'uri_scheme_equals'
182     name = 'URI scheme is'
183     hints = tuple([
184         hints.returns(hints.boolean),
185         hints.parameter_count(2),
186         hints.parameter(0, hints.uri),
187         hints.parameter(1, hints.string_like),
188         hints.mathesar_filter,
189     ])
190     depends_on = tuple([URIFunction.SCHEME])
191 
192     def unpack(self):
193         param0 = self.parameters[0]
194         param1 = self.parameters[1]
195         return Equal([
196             ExtractURIScheme([param0]),
197             param1,
198         ])
199
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/db/types/uri.py b/db/types/uri.py
--- a/db/types/uri.py
+++ b/db/types/uri.py
@@ -92,8 +92,8 @@
 
     create_domain_query = f"""
     CREATE DOMAIN {DB_TYPE} AS text CHECK (
-        {QualifiedURIFunction.SCHEME.value}(value) IS NOT NULL
-        AND {QualifiedURIFunction.PATH.value}(value) IS NOT NULL
+        (value IS NULL) OR ({QualifiedURIFunction.SCHEME.value}(value) IS NOT NULL
+        AND {QualifiedURIFunction.PATH.value}(value) IS NOT NULL)
     );
     """

{"golden_diff": "diff --git a/db/types/uri.py b/db/types/uri.py\n--- a/db/types/uri.py\n+++ b/db/types/uri.py\n@@ -92,8 +92,8 @@\n \n     create_domain_query = f\"\"\"\n     CREATE DOMAIN {DB_TYPE} AS text CHECK (\n-        {QualifiedURIFunction.SCHEME.value}(value) IS NOT NULL\n-        AND {QualifiedURIFunction.PATH.value}(value) IS NOT NULL\n+        (value IS NULL) OR ({QualifiedURIFunction.SCHEME.value}(value) IS NOT NULL\n+        AND {QualifiedURIFunction.PATH.value}(value) IS NOT NULL)\n     );\n     \"\"\"\n", "issue": "URI type does not allow NULL value to be set.\n## Description\r\nA column with the `URI` type does not allow `null` value to be set after creation even though the column `nullable` option is enabled\r\n\r\n## Expected behaviour\r\nAllow setting a null value to a nullable `URI` type column without throwing up an error \r\n\r\n## To Reproduce\r\n1. Create a new column with the type `URI`.\r\n2. Try setting a null value to the column by creating a new row and not entering any data.\r\n3. New row does not get created due to an error with `URI` type not accepting a null value\r\n\r\n\r\n\n", "before_files": [{"content": "from enum import Enum\nimport os\nfrom sqlalchemy import text, Text, Table, Column, String, MetaData\nfrom sqlalchemy.sql import quoted_name\nfrom sqlalchemy.sql.functions import GenericFunction\nfrom sqlalchemy.types import UserDefinedType\n\nfrom db.functions import hints\nfrom db.functions.base import DBFunction, Contains, sa_call_sql_function, Equal\nfrom db.functions.packed import DBFunctionPacked\n\nfrom db.types import base\n\nURI_STR = base.MathesarCustomType.URI.value\nDB_TYPE = base.get_qualified_name(URI_STR)\n\nTLDS_PATH = os.path.join(\n    os.path.join(os.path.abspath(os.path.dirname(__file__)), \"resources\"),\n    \"tlds.txt\"\n)\n\nTLDS_TABLE_NAME = \"top_level_domains\"\nQUALIFIED_TLDS = base.get_qualified_name(TLDS_TABLE_NAME)\n\n\nclass URIFunction(Enum):\n    PARTS = URI_STR + \"_parts\"\n    SCHEME = URI_STR + \"_scheme\"\n    AUTHORITY = URI_STR + \"_authority\"\n    PATH = URI_STR + \"_path\"\n    QUERY = URI_STR + \"_query\"\n    FRAGMENT = URI_STR + \"_fragment\"\n\n\nQualifiedURIFunction = Enum(\n    \"QualifiedURIFunction\",\n    {\n        func_name.name: base.get_qualified_name(func_name.value)\n        for func_name in URIFunction\n    }\n)\n\n\n# This regex and the use of it are based on the one given in RFC 3986.\nURI_REGEX_STR = r\"'^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?'\"\n\n\nclass URI(UserDefinedType):\n    def get_col_spec(self, **_):\n        # This results in the type name being upper case when viewed.\n        # Actual usage in the DB is case-insensitive.\n        return DB_TYPE.upper()\n\n\n# This function lets us avoid having to define repetitive classes for\n# adding custom SQL functions to SQLAlchemy\ndef build_generic_function_def_class(name):\n    class_dict = {\n        \"type\": Text,\n        \"name\": quoted_name(QualifiedURIFunction[name].value, False),\n        \"identifier\": URIFunction[name].value\n    }\n    return type(class_dict[\"identifier\"], (GenericFunction,), class_dict)\n\n\n# We need to add these classes to the globals() dict so they get picked\n# up by SQLAlchemy\nglobals().update(\n    {f.name: build_generic_function_def_class(f.name) for f in URIFunction}\n)\n\n\ndef install(engine):\n    drop_domain_query = f\"\"\"\n    DROP DOMAIN IF EXISTS {DB_TYPE};\n    \"\"\"\n\n    create_uri_parts_query = f\"\"\"\n    CREATE OR REPLACE FUNCTION {QualifiedURIFunction.PARTS.value}({base.PostgresType.TEXT.value})\n    RETURNS {base.PostgresType.TEXT.value}[] AS $$\n        SELECT regexp_match($1, {URI_REGEX_STR});\n    $$\n    LANGUAGE SQL IMMUTABLE RETURNS NULL ON NULL INPUT;\n    \"\"\"\n    uri_parts_map = {\n        QualifiedURIFunction.SCHEME.value: 2,\n        QualifiedURIFunction.AUTHORITY.value: 4,\n        QualifiedURIFunction.PATH.value: 5,\n        QualifiedURIFunction.QUERY.value: 7,\n        QualifiedURIFunction.FRAGMENT.value: 9,\n    }\n\n    create_domain_query = f\"\"\"\n    CREATE DOMAIN {DB_TYPE} AS text CHECK (\n        {QualifiedURIFunction.SCHEME.value}(value) IS NOT NULL\n        AND {QualifiedURIFunction.PATH.value}(value) IS NOT NULL\n    );\n    \"\"\"\n\n    with engine.begin() as conn:\n        conn.execute(text(drop_domain_query))\n        conn.execute(text(create_uri_parts_query))\n        for part, index in uri_parts_map.items():\n            create_uri_part_getter_query = f\"\"\"\n            CREATE OR REPLACE FUNCTION {part}({base.PostgresType.TEXT.value})\n            RETURNS {base.PostgresType.TEXT.value} AS $$\n                SELECT ({QualifiedURIFunction.PARTS.value}($1))[{index}];\n            $$\n            LANGUAGE SQL IMMUTABLE RETURNS NULL ON NULL INPUT;\n            \"\"\"\n            conn.execute(text(create_uri_part_getter_query))\n        conn.execute(text(create_domain_query))\n        conn.commit()\n\n\ndef install_tld_lookup_table(engine):\n    tlds_table = Table(\n        TLDS_TABLE_NAME,\n        MetaData(bind=engine),\n        Column(\"tld\", String, primary_key=True),\n        schema=base.preparer.quote_schema(base.SCHEMA)\n    )\n    tlds_table.create()\n    with engine.begin() as conn, open(TLDS_PATH) as f:\n        conn.execute(\n            tlds_table.insert(),\n            [{\"tld\": tld.strip().lower()} for tld in f if tld[:2] != \"# \"],\n        )\n\n\nclass ExtractURIAuthority(DBFunction):\n    id = 'extract_uri_authority'\n    name = 'extract URI authority'\n    hints = tuple([\n        hints.parameter_count(1),\n        hints.parameter(1, hints.uri),\n    ])\n    depends_on = tuple([URIFunction.AUTHORITY])\n\n    @staticmethod\n    def to_sa_expression(uri):\n        return sa_call_sql_function(URIFunction.AUTHORITY.value, uri)\n\n\nclass ExtractURIScheme(DBFunction):\n    id = 'extract_uri_scheme'\n    name = 'extract URI scheme'\n    hints = tuple([\n        hints.parameter_count(1),\n        hints.parameter(1, hints.uri),\n    ])\n    depends_on = tuple([URIFunction.SCHEME])\n\n    @staticmethod\n    def to_sa_expression(uri):\n        return sa_call_sql_function(URIFunction.SCHEME.value, uri)\n\n\nclass URIAuthorityContains(DBFunctionPacked):\n    id = 'uri_authority_contains'\n    name = 'URI authority contains'\n    hints = tuple([\n        hints.returns(hints.boolean),\n        hints.parameter_count(2),\n        hints.parameter(0, hints.uri),\n        hints.parameter(1, hints.string_like),\n        hints.mathesar_filter,\n    ])\n    depends_on = tuple([URIFunction.AUTHORITY])\n\n    def unpack(self):\n        param0 = self.parameters[0]\n        param1 = self.parameters[1]\n        return Contains([\n            ExtractURIAuthority([param0]),\n            param1,\n        ])\n\n\nclass URISchemeEquals(DBFunctionPacked):\n    id = 'uri_scheme_equals'\n    name = 'URI scheme is'\n    hints = tuple([\n        hints.returns(hints.boolean),\n        hints.parameter_count(2),\n        hints.parameter(0, hints.uri),\n        hints.parameter(1, hints.string_like),\n        hints.mathesar_filter,\n    ])\n    depends_on = tuple([URIFunction.SCHEME])\n\n    def unpack(self):\n        param0 = self.parameters[0]\n        param1 = self.parameters[1]\n        return Equal([\n            ExtractURIScheme([param0]),\n            param1,\n        ])\n", "path": "db/types/uri.py"}], "after_files": [{"content": "from enum import Enum\nimport os\nfrom sqlalchemy import text, Text, Table, Column, String, MetaData\nfrom sqlalchemy.sql import quoted_name\nfrom sqlalchemy.sql.functions import GenericFunction\nfrom sqlalchemy.types import UserDefinedType\n\nfrom db.functions import hints\nfrom db.functions.base import DBFunction, Contains, sa_call_sql_function, Equal\nfrom db.functions.packed import DBFunctionPacked\n\nfrom db.types import base\n\nURI_STR = base.MathesarCustomType.URI.value\nDB_TYPE = base.get_qualified_name(URI_STR)\n\nTLDS_PATH = os.path.join(\n    os.path.join(os.path.abspath(os.path.dirname(__file__)), \"resources\"),\n    \"tlds.txt\"\n)\n\nTLDS_TABLE_NAME = \"top_level_domains\"\nQUALIFIED_TLDS = base.get_qualified_name(TLDS_TABLE_NAME)\n\n\nclass URIFunction(Enum):\n    PARTS = URI_STR + \"_parts\"\n    SCHEME = URI_STR + \"_scheme\"\n    AUTHORITY = URI_STR + \"_authority\"\n    PATH = URI_STR + \"_path\"\n    QUERY = URI_STR + \"_query\"\n    FRAGMENT = URI_STR + \"_fragment\"\n\n\nQualifiedURIFunction = Enum(\n    \"QualifiedURIFunction\",\n    {\n        func_name.name: base.get_qualified_name(func_name.value)\n        for func_name in URIFunction\n    }\n)\n\n\n# This regex and the use of it are based on the one given in RFC 3986.\nURI_REGEX_STR = r\"'^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?'\"\n\n\nclass URI(UserDefinedType):\n    def get_col_spec(self, **_):\n        # This results in the type name being upper case when viewed.\n        # Actual usage in the DB is case-insensitive.\n        return DB_TYPE.upper()\n\n\n# This function lets us avoid having to define repetitive classes for\n# adding custom SQL functions to SQLAlchemy\ndef build_generic_function_def_class(name):\n    class_dict = {\n        \"type\": Text,\n        \"name\": quoted_name(QualifiedURIFunction[name].value, False),\n        \"identifier\": URIFunction[name].value\n    }\n    return type(class_dict[\"identifier\"], (GenericFunction,), class_dict)\n\n\n# We need to add these classes to the globals() dict so they get picked\n# up by SQLAlchemy\nglobals().update(\n    {f.name: build_generic_function_def_class(f.name) for f in URIFunction}\n)\n\n\ndef install(engine):\n    drop_domain_query = f\"\"\"\n    DROP DOMAIN IF EXISTS {DB_TYPE};\n    \"\"\"\n\n    create_uri_parts_query = f\"\"\"\n    CREATE OR REPLACE FUNCTION {QualifiedURIFunction.PARTS.value}({base.PostgresType.TEXT.value})\n    RETURNS {base.PostgresType.TEXT.value}[] AS $$\n        SELECT regexp_match($1, {URI_REGEX_STR});\n    $$\n    LANGUAGE SQL IMMUTABLE RETURNS NULL ON NULL INPUT;\n    \"\"\"\n    uri_parts_map = {\n        QualifiedURIFunction.SCHEME.value: 2,\n        QualifiedURIFunction.AUTHORITY.value: 4,\n        QualifiedURIFunction.PATH.value: 5,\n        QualifiedURIFunction.QUERY.value: 7,\n        QualifiedURIFunction.FRAGMENT.value: 9,\n    }\n\n    create_domain_query = f\"\"\"\n    CREATE DOMAIN {DB_TYPE} AS text CHECK (\n        (value IS NULL) OR ({QualifiedURIFunction.SCHEME.value}(value) IS NOT NULL\n        AND {QualifiedURIFunction.PATH.value}(value) IS NOT NULL)\n    );\n    \"\"\"\n\n    with engine.begin() as conn:\n        conn.execute(text(drop_domain_query))\n        conn.execute(text(create_uri_parts_query))\n        for part, index in uri_parts_map.items():\n            create_uri_part_getter_query = f\"\"\"\n            CREATE OR REPLACE FUNCTION {part}({base.PostgresType.TEXT.value})\n            RETURNS {base.PostgresType.TEXT.value} AS $$\n                SELECT ({QualifiedURIFunction.PARTS.value}($1))[{index}];\n            $$\n            LANGUAGE SQL IMMUTABLE RETURNS NULL ON NULL INPUT;\n            \"\"\"\n            conn.execute(text(create_uri_part_getter_query))\n        conn.execute(text(create_domain_query))\n        conn.commit()\n\n\ndef install_tld_lookup_table(engine):\n    tlds_table = Table(\n        TLDS_TABLE_NAME,\n        MetaData(bind=engine),\n        Column(\"tld\", String, primary_key=True),\n        schema=base.preparer.quote_schema(base.SCHEMA)\n    )\n    tlds_table.create()\n    with engine.begin() as conn, open(TLDS_PATH) as f:\n        conn.execute(\n            tlds_table.insert(),\n            [{\"tld\": tld.strip().lower()} for tld in f if tld[:2] != \"# \"],\n        )\n\n\nclass ExtractURIAuthority(DBFunction):\n    id = 'extract_uri_authority'\n    name = 'extract URI authority'\n    hints = tuple([\n        hints.parameter_count(1),\n        hints.parameter(1, hints.uri),\n    ])\n    depends_on = tuple([URIFunction.AUTHORITY])\n\n    @staticmethod\n    def to_sa_expression(uri):\n        return sa_call_sql_function(URIFunction.AUTHORITY.value, uri)\n\n\nclass ExtractURIScheme(DBFunction):\n    id = 'extract_uri_scheme'\n    name = 'extract URI scheme'\n    hints = tuple([\n        hints.parameter_count(1),\n        hints.parameter(1, hints.uri),\n    ])\n    depends_on = tuple([URIFunction.SCHEME])\n\n    @staticmethod\n    def to_sa_expression(uri):\n        return sa_call_sql_function(URIFunction.SCHEME.value, uri)\n\n\nclass URIAuthorityContains(DBFunctionPacked):\n    id = 'uri_authority_contains'\n    name = 'URI authority contains'\n    hints = tuple([\n        hints.returns(hints.boolean),\n        hints.parameter_count(2),\n        hints.parameter(0, hints.uri),\n        hints.parameter(1, hints.string_like),\n        hints.mathesar_filter,\n    ])\n    depends_on = tuple([URIFunction.AUTHORITY])\n\n    def unpack(self):\n        param0 = self.parameters[0]\n        param1 = self.parameters[1]\n        return Contains([\n            ExtractURIAuthority([param0]),\n            param1,\n        ])\n\n\nclass URISchemeEquals(DBFunctionPacked):\n    id = 'uri_scheme_equals'\n    name = 'URI scheme is'\n    hints = tuple([\n        hints.returns(hints.boolean),\n        hints.parameter_count(2),\n        hints.parameter(0, hints.uri),\n        hints.parameter(1, hints.string_like),\n        hints.mathesar_filter,\n    ])\n    depends_on = tuple([URIFunction.SCHEME])\n\n    def unpack(self):\n        param0 = self.parameters[0]\n        param1 = self.parameters[1]\n        return Equal([\n            ExtractURIScheme([param0]),\n            param1,\n        ])\n", "path": "db/types/uri.py"}]}