snowflake-sqlalchemy 1.6.1__tar.gz → 1.7.0__tar.gz

{snowflake_sqlalchemy-1.6.1 → snowflake_sqlalchemy-1.7.0}/.pre-commit-config.yaml

@@ -4,6 +4,7 @@ repos:
     rev: v4.5.0
     hooks:
     -   id: trailing-whitespace
+        exclude: '\.ambr$'
     -   id: end-of-file-fixer
     -   id: check-yaml
         exclude: .github/repo_meta.yaml

{snowflake_sqlalchemy-1.6.1 → snowflake_sqlalchemy-1.7.0}/DESCRIPTION.md

@@ -9,6 +9,17 @@ Source code is also available at:
 
 # Release Notes
 
+- v1.7.0(November 22, 2024)
+
+  - Add support for dynamic tables and required options
+  - Add support for hybrid tables
+  - Fixed SAWarning when registering functions with existing name in default namespace
+  - Update options to be defined in key arguments instead of arguments.
+  - Add support for refresh_mode option in DynamicTable
+  - Add support for iceberg table with Snowflake Catalog
+  - Fix cluster by option to support explicit expressions
+  - Add support for MAP datatype
+
 - v1.6.1(July 9, 2024)
 
   - Update internal project workflow with pypi publishing
@@ -24,7 +35,7 @@ Source code is also available at:
 
 - v1.5.3(April 16, 2024)
 
-    - Limit SQLAlchemy to < 2.0.0 before releasing version compatible with 2.0
+  - Limit SQLAlchemy to < 2.0.0 before releasing version compatible with 2.0
 
 - v1.5.2(April 11, 2024)
 
@@ -33,7 +44,7 @@ Source code is also available at:
 
 - v1.5.1(November 03, 2023)
 
-  - Fixed a compatibility issue with Snowflake Behavioral Change 1057 on outer lateral join, for more details check https://docs.snowflake.com/en/release-notes/bcr-bundles/2023_04/bcr-1057.
+  - Fixed a compatibility issue with Snowflake Behavioral Change 1057 on outer lateral join, for more details check <https://docs.snowflake.com/en/release-notes/bcr-bundles/2023_04/bcr-1057>.
   - Fixed credentials with `externalbrowser` authentication not caching due to incorrect parsing of boolean query parameters.
     - This fixes other boolean parameter passing to driver as well.
 

{snowflake_sqlalchemy-1.6.1 → snowflake_sqlalchemy-1.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: snowflake-sqlalchemy
-Version: 1.6.1
+Version: 1.7.0
 Summary: Snowflake SQLAlchemy Dialect
 Project-URL: Changelog, https://github.com/snowflakedb/snowflake-sqlalchemy/blob/main/DESCRIPTION.md
 Project-URL: Documentation, https://docs.snowflake.com/en/user-guide/sqlalchemy.html
@@ -8,8 +8,7 @@ Project-URL: Homepage, https://www.snowflake.com/
 Project-URL: Issues, https://github.com/snowflakedb/snowflake-sqlalchemy/issues
 Project-URL: Source, https://github.com/snowflakedb/snowflake-sqlalchemy
 Author-email: "Snowflake Inc." <triage-snowpark-python-api-dl@snowflake.com>
-License-Expression: Apache-2.0
-License-File: LICENSE.txt
+License: Apache-2.0
 Keywords: Snowflake,analytics,cloud,database,db,warehouse
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
@@ -46,6 +45,7 @@ Requires-Dist: pytest-cov; extra == 'development'
 Requires-Dist: pytest-rerunfailures; extra == 'development'
 Requires-Dist: pytest-timeout; extra == 'development'
 Requires-Dist: pytz; extra == 'development'
+Requires-Dist: syrupy==4.6.1; extra == 'development'
 Provides-Extra: pandas
 Requires-Dist: snowflake-connector-python[pandas]; extra == 'pandas'
 Description-Content-Type: text/markdown
@@ -392,7 +392,7 @@ This example shows how to create a table with two columns, `id` and `name`, as t
 t = Table('myuser', metadata,
     Column('id', Integer, primary_key=True),
     Column('name', String),
-    snowflake_clusterby=['id', 'name'], ...
+    snowflake_clusterby=['id', 'name', text('id > 5')], ...
 )
 metadata.create_all(engine)
 ```

{snowflake_sqlalchemy-1.6.1 → snowflake_sqlalchemy-1.7.0}/README.md

@@ -340,7 +340,7 @@ This example shows how to create a table with two columns, `id` and `name`, as t
 t = Table('myuser', metadata,
     Column('id', Integer, primary_key=True),
     Column('name', String),
-    snowflake_clusterby=['id', 'name'], ...
+    snowflake_clusterby=['id', 'name', text('id > 5')], ...
 )
 metadata.create_all(engine)
 ```

{snowflake_sqlalchemy-1.6.1 → snowflake_sqlalchemy-1.7.0}/pyproject.toml

@@ -53,6 +53,7 @@ development = [
   "pytz",
   "numpy",
   "mock",
+  "syrupy==4.6.1",
 ]
 pandas = ["snowflake-connector-python[pandas]"]
 
@@ -91,6 +92,7 @@ SQLACHEMY_WARN_20 = "1"
 check = "pre-commit run --all-files"
 test-dialect = "pytest -ra -vvv --tb=short --cov snowflake.sqlalchemy --cov-append --junitxml ./junit.xml --ignore=tests/sqlalchemy_test_suite tests/"
 test-dialect-compatibility = "pytest -ra -vvv --tb=short --cov snowflake.sqlalchemy --cov-append --junitxml ./junit.xml tests/sqlalchemy_test_suite"
+test-dialect-aws = "pytest -m \"aws\" -ra -vvv --tb=short --cov snowflake.sqlalchemy --cov-append --junitxml ./junit.xml --ignore=tests/sqlalchemy_test_suite tests/"
 gh-cache-sum = "python -VV | sha256sum | cut -d' ' -f1"
 check-import = "python -c 'import snowflake.sqlalchemy; print(snowflake.sqlalchemy.__version__)'"
 
@@ -109,6 +111,7 @@ line-length = 88
 line-length = 88
 
 [tool.pytest.ini_options]
+addopts = "-m 'not feature_max_lob_size and not aws and not requires_external_volume'"
 markers = [
   # Optional dependency groups markers
   "lambda: AWS lambda tests",
@@ -125,5 +128,7 @@ markers = [
   # Other markers
   "timeout: tests that need a timeout time",
   "internal: tests that could but should only run on our internal CI",
+  "requires_external_volume: tests that needs a external volume to be executed",
   "external: tests that could but should only run on our external CI",
+  "feature_max_lob_size: tests that could but should only run on our external CI",
 ]

{snowflake_sqlalchemy-1.6.1 → snowflake_sqlalchemy-1.7.0}/src/snowflake/sqlalchemy/__init__.py

@@ -9,7 +9,7 @@ if sys.version_info < (3, 8):
 else:
     import importlib.metadata as importlib_metadata
 
-from sqlalchemy.types import (
+from sqlalchemy.types import (  # noqa
     BIGINT,
     BINARY,
     BOOLEAN,
@@ -27,8 +27,8 @@ from sqlalchemy.types import (
     VARCHAR,
 )
 
-from . import base, snowdialect
-from .custom_commands import (
+from . import base, snowdialect  # noqa
+from .custom_commands import (  # noqa
     AWSBucket,
     AzureContainer,
     CopyFormatter,
@@ -41,7 +41,7 @@ from .custom_commands import (
     MergeInto,
     PARQUETFormatter,
 )
-from .custom_types import (
+from .custom_types import (  # noqa
     ARRAY,
     BYTEINT,
     CHARACTER,
@@ -50,6 +50,7 @@ from .custom_types import (
     FIXED,
     GEOGRAPHY,
     GEOMETRY,
+    MAP,
     NUMBER,
     OBJECT,
     STRING,
@@ -61,13 +62,30 @@ from .custom_types import (
     VARBINARY,
     VARIANT,
 )
-from .util import _url as URL
+from .sql.custom_schema import (  # noqa
+    DynamicTable,
+    HybridTable,
+    IcebergTable,
+    SnowflakeTable,
+)
+from .sql.custom_schema.options import (  # noqa
+    AsQueryOption,
+    ClusterByOption,
+    IdentifierOption,
+    KeywordOption,
+    LiteralOption,
+    SnowflakeKeyword,
+    TableOptionKey,
+    TargetLagOption,
+    TimeUnit,
+)
+from .util import _url as URL  # noqa
 
 base.dialect = dialect = snowdialect.dialect
 
 __version__ = importlib_metadata.version("snowflake-sqlalchemy")
 
-__all__ = (
+_custom_types = (
     "BIGINT",
     "BINARY",
     "BOOLEAN",
@@ -102,6 +120,10 @@ __all__ = (
     "TINYINT",
     "VARBINARY",
     "VARIANT",
+    "MAP",
+)
+
+_custom_commands = (
     "MergeInto",
     "CSVFormatter",
     "JSONFormatter",
@@ -114,3 +136,27 @@ __all__ = (
     "CreateStage",
     "CreateFileFormat",
 )
+
+_custom_tables = ("HybridTable", "DynamicTable", "IcebergTable", "SnowflakeTable")
+
+_custom_table_options = (
+    "AsQueryOption",
+    "TargetLagOption",
+    "LiteralOption",
+    "IdentifierOption",
+    "KeywordOption",
+    "ClusterByOption",
+)
+
+_enums = (
+    "TimeUnit",
+    "TableOptionKey",
+    "SnowflakeKeyword",
+)
+__all__ = (
+    *_custom_types,
+    *_custom_commands,
+    *_custom_tables,
+    *_custom_table_options,
+    *_enums,
+)

{snowflake_sqlalchemy-1.6.1 → snowflake_sqlalchemy-1.7.0}/src/snowflake/sqlalchemy/_constants.py

@@ -10,3 +10,5 @@ PARAM_INTERNAL_APPLICATION_VERSION = "internal_application_version"
 
 APPLICATION_NAME = "SnowflakeSQLAlchemy"
 SNOWFLAKE_SQLALCHEMY_VERSION = VERSION
+DIALECT_NAME = "snowflake"
+NOT_NULL = "NOT NULL"

{snowflake_sqlalchemy-1.6.1 → snowflake_sqlalchemy-1.7.0}/src/snowflake/sqlalchemy/base.py

@@ -5,6 +5,7 @@
 import itertools
 import operator
 import re
+from typing import List
 
 from sqlalchemy import exc as sa_exc
 from sqlalchemy import inspect, sql
@@ -18,9 +19,22 @@ from sqlalchemy.sql.base import CompileState
 from sqlalchemy.sql.elements import quoted_name
 from sqlalchemy.sql.selectable import Lateral, SelectState
 
-from .compat import IS_VERSION_20, args_reducer, string_types
-from .custom_commands import AWSBucket, AzureContainer, ExternalStage
+from snowflake.sqlalchemy._constants import DIALECT_NAME
+from snowflake.sqlalchemy.compat import IS_VERSION_20, args_reducer, string_types
+from snowflake.sqlalchemy.custom_commands import (
+    AWSBucket,
+    AzureContainer,
+    ExternalStage,
+)
+
+from ._constants import NOT_NULL
+from .exc import (
+    CustomOptionsAreOnlySupportedOnSnowflakeTables,
+    UnexpectedOptionTypeError,
+)
 from .functions import flatten
+from .sql.custom_schema.custom_table_base import CustomTableBase
+from .sql.custom_schema.options.table_option import TableOption
 from .util import (
     _find_left_clause_to_join_from,
     _set_connection_interpolate_empty_sequences,
@@ -184,7 +198,6 @@ class SnowflakeSelectState(SelectState):
                     [element._from_objects for element in statement._where_criteria]
                 ),
             ):
-
                 potential[from_clause] = ()
 
             all_clauses = list(potential.keys())
@@ -879,7 +892,7 @@ class SnowflakeDDLCompiler(compiler.DDLCompiler):
 
         return " ".join(colspec)
 
-    def post_create_table(self, table):
+    def handle_cluster_by(self, table):
         """
         Handles snowflake-specific ``CREATE TABLE ... CLUSTER BY`` syntax.
 
@@ -896,7 +909,7 @@ class SnowflakeDDLCompiler(compiler.DDLCompiler):
         ...     metadata,
         ...     sa.Column('id', sa.Integer, primary_key=True),
         ...     sa.Column('name', sa.String),
-        ...     snowflake_clusterby=['id', 'name']
+        ...     snowflake_clusterby=['id', 'name', text("id > 5")]
         ... )
         >>> print(CreateTable(user).compile(engine))
         <BLANKLINE>
@@ -904,19 +917,49 @@ class SnowflakeDDLCompiler(compiler.DDLCompiler):
             id INTEGER NOT NULL AUTOINCREMENT,
             name VARCHAR,
             PRIMARY KEY (id)
-        ) CLUSTER BY (id, name)
+        ) CLUSTER BY (id, name, id > 5)
         <BLANKLINE>
         <BLANKLINE>
         """
         text = ""
-        info = table.dialect_options["snowflake"]
+        info = table.dialect_options[DIALECT_NAME]
         cluster = info.get("clusterby")
         if cluster:
             text += " CLUSTER BY ({})".format(
-                ", ".join(self.denormalize_column_name(key) for key in cluster)
+                ", ".join(
+                    (
+                        self.denormalize_column_name(key)
+                        if isinstance(key, str)
+                        else str(key)
+                    )
+                    for key in cluster
+                )
             )
         return text
 
+    def post_create_table(self, table):
+        text = self.handle_cluster_by(table)
+        options = []
+        invalid_options: List[str] = []
+
+        for key, option in table.dialect_options[DIALECT_NAME].items():
+            if isinstance(option, TableOption):
+                options.append(option)
+            elif key not in ["clusterby", "*"]:
+                invalid_options.append(key)
+
+        if len(invalid_options) > 0:
+            raise UnexpectedOptionTypeError(sorted(invalid_options))
+
+        if isinstance(table, CustomTableBase):
+            options.sort(key=lambda x: (x.priority.value, x.option_name), reverse=True)
+            for option in options:
+                text += "\t" + option.render_option(self)
+        elif len(options) > 0:
+            raise CustomOptionsAreOnlySupportedOnSnowflakeTables()
+
+        return text
+
     def visit_create_stage(self, create_stage, **kw):
         """
         This visitor will create the SQL representation for a CREATE STAGE command.
@@ -1029,6 +1072,12 @@ class SnowflakeTypeCompiler(compiler.GenericTypeCompiler):
     def visit_VARIANT(self, type_, **kw):
         return "VARIANT"
 
+    def visit_MAP(self, type_, **kw):
+        not_null = f" {NOT_NULL}" if type_.not_null else ""
+        return (
+            f"MAP({type_.key_type.compile()}, {type_.value_type.compile()}{not_null})"
+        )
+
     def visit_ARRAY(self, type_, **kw):
         return "ARRAY"
 
@@ -1065,4 +1114,4 @@ class SnowflakeTypeCompiler(compiler.GenericTypeCompiler):
 
 construct_arguments = [(Table, {"clusterby": None})]
 
-functions.register_function("flatten", flatten)
+functions.register_function("flatten", flatten, "snowflake")

{snowflake_sqlalchemy-1.6.1 → snowflake_sqlalchemy-1.7.0}/src/snowflake/sqlalchemy/custom_types.py

@@ -37,6 +37,26 @@ class VARIANT(SnowflakeType):
     __visit_name__ = "VARIANT"
 
 
+class StructuredType(SnowflakeType):
+    def __init__(self):
+        super().__init__()
+
+
+class MAP(StructuredType):
+    __visit_name__ = "MAP"
+
+    def __init__(
+        self,
+        key_type: sqltypes.TypeEngine,
+        value_type: sqltypes.TypeEngine,
+        not_null: bool = False,
+    ):
+        self.key_type = key_type
+        self.value_type = value_type
+        self.not_null = not_null
+        super().__init__()
+
+
 class OBJECT(SnowflakeType):
     __visit_name__ = "OBJECT"
 

snowflake_sqlalchemy-1.7.0/src/snowflake/sqlalchemy/exc.py

@@ -0,0 +1,82 @@
+#
+# Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
+
+from typing import List
+
+from sqlalchemy.exc import ArgumentError
+
+
+class NoPrimaryKeyError(ArgumentError):
+    def __init__(self, target: str):
+        super().__init__(f"Table {target} required primary key.")
+
+
+class UnsupportedPrimaryKeysAndForeignKeysError(ArgumentError):
+    def __init__(self, target: str):
+        super().__init__(f"Primary key and foreign keys are not supported in {target}.")
+
+
+class RequiredParametersNotProvidedError(ArgumentError):
+    def __init__(self, target: str, parameters: List[str]):
+        super().__init__(
+            f"{target} requires the following parameters: %s." % ", ".join(parameters)
+        )
+
+
+class UnexpectedTableOptionKeyError(ArgumentError):
+    def __init__(self, expected: str, actual: str):
+        super().__init__(f"Expected table option {expected} but got {actual}.")
+
+
+class OptionKeyNotProvidedError(ArgumentError):
+    def __init__(self, target: str):
+        super().__init__(
+            f"Expected option key in {target} option but got NoneType instead."
+        )
+
+
+class UnexpectedOptionParameterTypeError(ArgumentError):
+    def __init__(self, parameter_name: str, target: str, types: List[str]):
+        super().__init__(
+            f"Parameter {parameter_name} of {target} requires to be one"
+            f" of following types: {', '.join(types)}."
+        )
+
+
+class CustomOptionsAreOnlySupportedOnSnowflakeTables(ArgumentError):
+    def __init__(self):
+        super().__init__(
+            "Identifier, Literal, TargetLag and other custom options are only supported on Snowflake tables."
+        )
+
+
+class UnexpectedOptionTypeError(ArgumentError):
+    def __init__(self, options: List[str]):
+        super().__init__(
+            f"The following options are either unsupported or should be defined using a Snowflake table: {', '.join(options)}."
+        )
+
+
+class InvalidTableParameterTypeError(ArgumentError):
+    def __init__(self, name: str, input_type: str, expected_types: List[str]):
+        expected_types_str = "', '".join(expected_types)
+        super().__init__(
+            f"Invalid parameter type '{input_type}' provided for '{name}'. "
+            f"Expected one of the following types: '{expected_types_str}'.\n"
+        )
+
+
+class MultipleErrors(ArgumentError):
+    def __init__(self, errors):
+        self.errors = errors
+
+    def __str__(self):
+        return "".join(str(e) for e in self.errors)
+
+
+class StructuredTypeNotSupportedInTableColumnsError(ArgumentError):
+    def __init__(self, table_type: str, table_name: str, column_name: str):
+        super().__init__(
+            f"Column '{column_name}' is of a structured type, which is only supported on Iceberg tables. "
+            f"The table '{table_name}' is of type '{table_type}', not Iceberg."
+        )

snowflake_sqlalchemy-1.7.0/src/snowflake/sqlalchemy/parser/custom_type_parser.py

@@ -0,0 +1,190 @@
+#
+# Copyright (c) 2012-2023 Snowflake Computing Inc. All rights reserved.
+
+import sqlalchemy.types as sqltypes
+from sqlalchemy.sql.type_api import TypeEngine
+from sqlalchemy.types import (
+    BIGINT,
+    BINARY,
+    BOOLEAN,
+    CHAR,
+    DATE,
+    DATETIME,
+    DECIMAL,
+    FLOAT,
+    INTEGER,
+    REAL,
+    SMALLINT,
+    TIME,
+    TIMESTAMP,
+    VARCHAR,
+    NullType,
+)
+
+from ..custom_types import (
+    _CUSTOM_DECIMAL,
+    ARRAY,
+    DOUBLE,
+    GEOGRAPHY,
+    GEOMETRY,
+    MAP,
+    OBJECT,
+    TIMESTAMP_LTZ,
+    TIMESTAMP_NTZ,
+    TIMESTAMP_TZ,
+    VARIANT,
+)
+
+ischema_names = {
+    "BIGINT": BIGINT,
+    "BINARY": BINARY,
+    # 'BIT': BIT,
+    "BOOLEAN": BOOLEAN,
+    "CHAR": CHAR,
+    "CHARACTER": CHAR,
+    "DATE": DATE,
+    "DATETIME": DATETIME,
+    "DEC": DECIMAL,
+    "DECIMAL": DECIMAL,
+    "DOUBLE": DOUBLE,
+    "FIXED": DECIMAL,
+    "FLOAT": FLOAT,  # Snowflake FLOAT datatype doesn't has parameters
+    "INT": INTEGER,
+    "INTEGER": INTEGER,
+    "NUMBER": _CUSTOM_DECIMAL,
+    # 'OBJECT': ?
+    "REAL": REAL,
+    "BYTEINT": SMALLINT,
+    "SMALLINT": SMALLINT,
+    "STRING": VARCHAR,
+    "TEXT": VARCHAR,
+    "TIME": TIME,
+    "TIMESTAMP": TIMESTAMP,
+    "TIMESTAMP_TZ": TIMESTAMP_TZ,
+    "TIMESTAMP_LTZ": TIMESTAMP_LTZ,
+    "TIMESTAMP_NTZ": TIMESTAMP_NTZ,
+    "TINYINT": SMALLINT,
+    "VARBINARY": BINARY,
+    "VARCHAR": VARCHAR,
+    "VARIANT": VARIANT,
+    "MAP": MAP,
+    "OBJECT": OBJECT,
+    "ARRAY": ARRAY,
+    "GEOGRAPHY": GEOGRAPHY,
+    "GEOMETRY": GEOMETRY,
+}
+
+
+def extract_parameters(text: str) -> list:
+    """
+    Extracts parameters from a comma-separated string, handling parentheses.
+
+    :param text: A string with comma-separated parameters, which may include parentheses.
+
+    :return: A list of parameters as strings.
+
+    :example:
+        For input `"a, (b, c), d"`, the output is `['a', '(b, c)', 'd']`.
+    """
+
+    output_parameters = []
+    parameter = ""
+    open_parenthesis = 0
+    for c in text:
+
+        if c == "(":
+            open_parenthesis += 1
+        elif c == ")":
+            open_parenthesis -= 1
+
+        if open_parenthesis > 0 or c != ",":
+            parameter += c
+        elif c == ",":
+            output_parameters.append(parameter.strip(" "))
+            parameter = ""
+    if parameter != "":
+        output_parameters.append(parameter.strip(" "))
+    return output_parameters
+
+
+def parse_type(type_text: str) -> TypeEngine:
+    """
+    Parses a type definition string and returns the corresponding SQLAlchemy type.
+
+    The function handles types with or without parameters, such as `VARCHAR(255)` or `INTEGER`.
+
+    :param type_text: A string representing a SQLAlchemy type, which may include parameters
+                       in parentheses (e.g., "VARCHAR(255)" or "DECIMAL(10, 2)").
+    :return: An instance of the corresponding SQLAlchemy type class (e.g., `String`, `Integer`),
+             or `NullType` if the type is not recognized.
+
+    :example:
+        parse_type("VARCHAR(255)")
+        String(length=255)
+    """
+    index = type_text.find("(")
+    type_name = type_text[:index] if index != -1 else type_text
+    parameters = (
+        extract_parameters(type_text[index + 1 : -1]) if type_name != type_text else []
+    )
+
+    col_type_class = ischema_names.get(type_name, None)
+    col_type_kw = {}
+    if col_type_class is None:
+        col_type_class = NullType
+    else:
+        if issubclass(col_type_class, sqltypes.Numeric):
+            col_type_kw = __parse_numeric_type_parameters(parameters)
+        elif issubclass(col_type_class, (sqltypes.String, sqltypes.BINARY)):
+            col_type_kw = __parse_type_with_length_parameters(parameters)
+        elif issubclass(col_type_class, MAP):
+            col_type_kw = __parse_map_type_parameters(parameters)
+        if col_type_kw is None:
+            col_type_class = NullType
+            col_type_kw = {}
+
+    return col_type_class(**col_type_kw)
+
+
+def __parse_map_type_parameters(parameters):
+    if len(parameters) != 2:
+        return None
+
+    key_type_str = parameters[0]
+    value_type_str = parameters[1]
+    not_null_str = "NOT NULL"
+    not_null = False
+    if (
+        len(value_type_str) >= len(not_null_str)
+        and value_type_str[-len(not_null_str) :] == not_null_str
+    ):
+        not_null = True
+        value_type_str = value_type_str[: -len(not_null_str) - 1]
+
+    key_type: TypeEngine = parse_type(key_type_str)
+    value_type: TypeEngine = parse_type(value_type_str)
+    if isinstance(key_type, NullType) or isinstance(value_type, NullType):
+        return None
+
+    return {
+        "key_type": key_type,
+        "value_type": value_type,
+        "not_null": not_null,
+    }
+
+
+def __parse_type_with_length_parameters(parameters):
+    return (
+        {"length": int(parameters[0])}
+        if len(parameters) == 1 and str.isdigit(parameters[0])
+        else {}
+    )
+
+
+def __parse_numeric_type_parameters(parameters):
+    result = {}
+    if len(parameters) >= 1 and str.isdigit(parameters[0]):
+        result["precision"] = int(parameters[0])
+    if len(parameters) == 2 and str.isdigit(parameters[1]):
+        result["scale"] = int(parameters[1])
+    return result