snowflake-cli-labs 3.0.0rc4__py3-none-any.whl → 3.0.1__py3-none-any.whl

snowflake/cli/api/project/util.py

@@ -1,278 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import annotations
-
-import codecs
-import os
-import re
-from typing import List, Optional
-from urllib.parse import quote
-
-IDENTIFIER = r'((?:"[^"]*(?:""[^"]*)*")|(?:[A-Za-z_][\w$]{0,254}))'
-IDENTIFIER_NO_LENGTH = r'((?:"[^"]*(?:""[^"]*)*")|(?:[A-Za-z_][\w$]*))'
-DB_SCHEMA_AND_NAME = f"{IDENTIFIER}[.]{IDENTIFIER}[.]{IDENTIFIER}"
-SCHEMA_AND_NAME = f"{IDENTIFIER}[.]{IDENTIFIER}"
-GLOB_REGEX = r"^[a-zA-Z0-9_\-./*?**\p{L}\p{N}]+$"
-RELATIVE_PATH = r"^[^/][\p{L}\p{N}_\-.][^/]*$"
-
-SINGLE_QUOTED_STRING_LITERAL_REGEX = r"'((?:\\.|''|[^'\n])+?)'"
-
-# See https://docs.snowflake.com/en/sql-reference/identifiers-syntax for identifier syntax
-UNQUOTED_IDENTIFIER_REGEX = r"([a-zA-Z_])([a-zA-Z0-9_$]{0,254})"
-QUOTED_IDENTIFIER_REGEX = r'"((""|[^"]){0,255})"'
-VALID_IDENTIFIER_REGEX = f"(?:{UNQUOTED_IDENTIFIER_REGEX}|{QUOTED_IDENTIFIER_REGEX})"
-
-# An env var that is used to suffix the names of some account-level resources
-TEST_RESOURCE_SUFFIX_VAR = "SNOWFLAKE_CLI_TEST_RESOURCE_SUFFIX"
-
-
-def encode_uri_component(s: str) -> str:
-    """
-    Implementation of JavaScript's encodeURIComponent.
-    """
-    return quote(s, safe="!~*'()")
-
-
-def sanitize_identifier(input_: str):
-    """
-    Removes characters that cannot be used in an unquoted identifier.
-    If the identifier does not start with a letter or underscore, prefix it with an underscore.
-    Limits the identifier to 255 characters.
-    """
-    value = re.sub(r"[^a-zA-Z0-9_$]", "", f"{input_}")
-
-    # if it does not start with a letter or underscore, prefix it with an underscore
-    if not value or not re.match(r"[a-zA-Z_]", value[0]):
-        value = f"_{value}"
-
-    # limit it to 255 characters
-    return value[:255]
-
-
-def is_valid_unquoted_identifier(identifier: str) -> bool:
-    """
-    Determines whether the provided identifier is a valid Snowflake unquoted identifier.
-    """
-    return re.fullmatch(UNQUOTED_IDENTIFIER_REGEX, identifier) is not None
-
-
-def is_valid_quoted_identifier(identifier: str) -> bool:
-    """
-    Determines whether the provided identifier is a valid Snowflake quoted identifier.
-    """
-    return re.fullmatch(QUOTED_IDENTIFIER_REGEX, identifier) is not None
-
-
-def is_valid_identifier(identifier: str) -> bool:
-    """
-    Determines whether the provided identifier is a valid Snowflake quoted or unquoted identifier.
-    """
-    return is_valid_unquoted_identifier(identifier) or is_valid_quoted_identifier(
-        identifier
-    )
-
-
-def is_valid_object_name(name: str, max_depth=2, allow_quoted=True) -> bool:
-    """
-    Determines whether the given identifier is a valid object name in the form <name>, <schema>.<name>, or <database>.<schema>.<name>.
-    Max_depth determines how many valid identifiers are allowed. For example, account level objects would have a max depth of 0
-    because they cannot be qualified by a database or schema, just the single identifier.
-    """
-    if max_depth < 0:
-        raise ValueError("max_depth must be non-negative")
-    identifier_pattern = (
-        VALID_IDENTIFIER_REGEX if allow_quoted else UNQUOTED_IDENTIFIER_REGEX
-    )
-    pattern = rf"{identifier_pattern}(?:\.{identifier_pattern}){{0,{max_depth}}}"
-    return re.fullmatch(pattern, name) is not None
-
-
-def to_quoted_identifier(input_value: str) -> str:
-    """
-    Turn the input into a valid quoted identifier.
-    If it is already a valid quoted identifier,
-    return it as is.
-    """
-    if is_valid_quoted_identifier(input_value):
-        return input_value
-
-    return '"' + input_value.replace('"', '""') + '"'
-
-
-def to_identifier(name: str) -> str:
-    """
-    Converts a name to a valid Snowflake identifier. If the name is already a valid
-    Snowflake identifier, then it is returned unmodified.
-    """
-    if is_valid_identifier(name):
-        return name
-
-    return to_quoted_identifier(name)
-
-
-def identifier_to_str(identifier: str) -> str:
-    if is_valid_quoted_identifier(identifier):
-        unquoted_id = identifier[1:-1]
-        return unquoted_id.replace('""', '"')
-
-    return identifier
-
-
-def append_to_identifier(identifier: str, suffix: str) -> str:
-    """
-    Appends a suffix to a valid identifier.
-    """
-    if is_valid_unquoted_identifier(identifier):
-        return to_identifier(f"{identifier}{suffix}")
-    else:
-        # the identifier is quoted, so insert the suffix within the quotes
-        unquoted = identifier[1:-1]
-        return f'"{unquoted}{suffix}"'
-
-
-def unquote_identifier(identifier: str) -> str:
-    """
-    Returns a version of this identifier that can be used inside of a
-    string for a LIKE clause, or to match an identifier passed back as
-    a value from a SQL statement.
-    """
-    if match := re.fullmatch(QUOTED_IDENTIFIER_REGEX, identifier):
-        return match.group(1).replace('""', '"')
-    # unquoted identifiers are internally represented as uppercase
-    return identifier.upper()
-
-
-def identifier_for_url(identifier: str) -> str:
-    """
-    Returns a version of this identifier that can be used as part of a URL.
-    """
-    return encode_uri_component(unquote_identifier(identifier))
-
-
-def is_valid_string_literal(literal: str) -> bool:
-    """
-    Determines if a literal is a valid single quoted string literal
-    """
-    return re.fullmatch(SINGLE_QUOTED_STRING_LITERAL_REGEX, literal) is not None
-
-
-def to_string_literal(raw_value: str) -> str:
-    """
-    Converts the raw string value to a correctly escaped, single-quoted string literal.
-    """
-    # encode escape sequences
-    escaped = str(codecs.encode(raw_value, "unicode-escape"), "utf-8")
-
-    # escape single quotes
-    escaped = re.sub(r"^'|(?<!')'", r"\'", escaped)
-
-    return f"'{escaped}'"
-
-
-def extract_schema(qualified_name: str):
-    """
-    Extracts the schema from either a two-part or three-part qualified name
-    (i.e. schema.object or database.schema.object). If qualified_name is not
-    qualified with a schema, returns None.
-    """
-    if match := re.fullmatch(DB_SCHEMA_AND_NAME, qualified_name):
-        return match.group(2)
-    elif match := re.fullmatch(SCHEMA_AND_NAME, qualified_name):
-        return match.group(1)
-    return None
-
-
-def first_set_env(*keys: str):
-    for k in keys:
-        v = os.getenv(k)
-        if v:
-            return v
-
-    return None
-
-
-def get_env_username() -> Optional[str]:
-    return first_set_env("USER", "USERNAME", "LOGNAME")
-
-
-def concat_identifiers(identifiers: list[str]) -> str:
-    """
-    Concatenate multiple identifiers.
-    If any of them is quoted identifier or contains unsafe characters, quote the result.
-    Otherwise, the resulting identifier will be unquoted.
-    """
-    quotes_found = False
-    stringified_identifiers: List[str] = []
-
-    for identifier in identifiers:
-        if is_valid_quoted_identifier(identifier):
-            quotes_found = True
-        stringified_identifiers.append(identifier_to_str(identifier))
-
-    concatenated_ids_str = "".join(stringified_identifiers)
-    if quotes_found:
-        return to_quoted_identifier(concatenated_ids_str)
-
-    return to_identifier(concatenated_ids_str)
-
-
-SUPPORTED_VERSIONS = [1]
-
-
-def validate_version(version: str):
-    if version in SUPPORTED_VERSIONS:
-        raise ValueError(
-            f"Project definition version {version} is not supported by this version of Snowflake CLI. Supported versions: {SUPPORTED_VERSIONS}"
-        )
-
-
-def escape_like_pattern(pattern: str, escape_sequence: str = r"\\") -> str:
-    """
-    When used with LIKE in Snowflake, '%' and '_' are wildcard characters and must be escaped to be used literally.
-    The escape character is '\\' when used in SHOW LIKE and must be specified when used with string matching using the
-    following syntax: <subject> LIKE <pattern> [ ESCAPE <escape> ].
-    """
-    pattern = pattern.replace("%", rf"{escape_sequence}%").replace(
-        "_", rf"{escape_sequence}_"
-    )
-    return pattern
-
-
-def identifier_to_show_like_pattern(identifier: str) -> str:
-    """
-    Takes an identifier and converts it into a pattern to be used with SHOW ... LIKE ... to get all rows with name
-    matching this identifier
-    """
-    return f"'{escape_like_pattern(unquote_identifier(identifier))}'"
-
-
-def append_test_resource_suffix(identifier: str) -> str:
-    """
-    Append a suffix that should be added to specified account-level resources.
-
-    This is an internal concern that is currently only used in tests
-    to isolate concurrent runs and to add the test name to resources.
-    """
-    suffix = os.environ.get(TEST_RESOURCE_SUFFIX_VAR, "")
-    if identifier_to_str(identifier).endswith(identifier_to_str(suffix)):
-        # If the suffix has already been added, don't add it again
-        return identifier
-    if is_valid_quoted_identifier(identifier) or is_valid_quoted_identifier(suffix):
-        # If either identifier is already quoted, use concat_identifier
-        # to add the suffix inside the quotes
-        return concat_identifiers([identifier, suffix])
-    # Otherwise just append the string, don't add quotes
-    # in case the user doesn't want them
-    return f"{identifier}{suffix}"

snowflake/cli/api/rendering/__init__.py

@@ -1,13 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.

snowflake/cli/api/rendering/jinja.py

@@ -1,118 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-from __future__ import annotations
-
-from pathlib import Path
-from textwrap import dedent
-from typing import Any, Dict, Optional
-
-import jinja2
-from jinja2 import Environment, StrictUndefined, loaders
-from snowflake.cli.api.secure_path import UNLIMITED, SecurePath
-
-CONTEXT_KEY = "ctx"
-FUNCTION_KEY = "fn"
-
-
-def read_file_content(file_name: str):
-    return SecurePath(file_name).read_text(file_size_limit_mb=UNLIMITED)
-
-
-@jinja2.pass_environment  # type: ignore
-def procedure_from_js_file(env: jinja2.Environment, file_name: str):
-    template = env.from_string(
-        dedent(
-            """\
-            var module = {};
-            var exports = {};
-            module.exports = exports;
-            (function() {
-            {{ code }}
-            })()
-            return module.exports.apply(this, arguments);
-            """
-        )
-    )
-    return template.render(
-        code=SecurePath(file_name).read_text(file_size_limit_mb=UNLIMITED)
-    )
-
-
-_CUSTOM_FILTERS = [read_file_content, procedure_from_js_file]
-
-
-def env_bootstrap(env: Environment) -> Environment:
-    for custom_filter in _CUSTOM_FILTERS:
-        env.filters[custom_filter.__name__] = custom_filter
-
-    return env
-
-
-class IgnoreAttrEnvironment(Environment):
-    """
-    extend Environment class and ignore attributes during rendering.
-    This ensures that attributes of classes
-    do not get used during rendering (e.g. __class__, get, etc).
-    Only dict items can be used for rendering.
-    """
-
-    def getattr(self, obj, attribute):  # noqa: A003
-        try:
-            return obj[attribute]
-        except (TypeError, LookupError, AttributeError):
-            return self.undefined(obj=obj, name=attribute)
-
-    def getitem(self, obj, argument):
-        try:
-            return obj[argument]
-        except (AttributeError, TypeError, LookupError):
-            return self.undefined(obj=obj, name=argument)
-
-
-def get_basic_jinja_env(loader: Optional[loaders.BaseLoader] = None) -> Environment:
-    return env_bootstrap(
-        IgnoreAttrEnvironment(
-            loader=loader or loaders.BaseLoader(),
-            keep_trailing_newline=True,
-            undefined=StrictUndefined,
-        )
-    )
-
-
-def jinja_render_from_file(
-    template_path: Path, data: Dict[str, Any], output_file_path: Optional[Path] = None
-) -> Optional[str]:
-    """
-    Renders a jinja template and outputs either the rendered contents as string or writes to a file.
-
-    Args:
-        template_path (Path): Path to the template
-        data (dict): A dictionary of jinja variables and their actual values
-        output_file_path (Optional[Path]): If provided then rendered template will be written to this file
-
-    Returns:
-        None if file path is provided, else returns the rendered string.
-    """
-    env = get_basic_jinja_env(
-        loader=loaders.FileSystemLoader(template_path.parent.as_posix())
-    )
-    loaded_template = env.get_template(template_path.name)
-    rendered_result = loaded_template.render(**data)
-    if output_file_path:
-        SecurePath(output_file_path).write_text(rendered_result)
-        return None
-    else:
-        return rendered_result

snowflake/cli/api/rendering/project_definition_templates.py

@@ -1,43 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import annotations
-
-from jinja2 import Environment, StrictUndefined, loaders
-from snowflake.cli.api.rendering.jinja import (
-    IgnoreAttrEnvironment,
-    env_bootstrap,
-)
-
-_YML_TEMPLATE_START = "<%"
-_YML_TEMPLATE_END = "%>"
-
-
-def has_client_side_templates(template_content: str) -> bool:
-    return _YML_TEMPLATE_START in template_content
-
-
-def get_client_side_jinja_env() -> Environment:
-    _random_block = "___very___unique___block___to___disable___logic___blocks___"
-    return env_bootstrap(
-        IgnoreAttrEnvironment(
-            loader=loaders.BaseLoader(),
-            keep_trailing_newline=True,
-            variable_start_string=_YML_TEMPLATE_START,
-            variable_end_string=_YML_TEMPLATE_END,
-            block_start_string=_random_block,
-            block_end_string=_random_block,
-            undefined=StrictUndefined,
-        )
-    )

snowflake/cli/api/rendering/project_templates.py

@@ -1,98 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-from click import ClickException
-from jinja2 import (
-    Environment,
-    StrictUndefined,
-    TemplateSyntaxError,
-    UndefinedError,
-    loaders,
-)
-from snowflake.cli.api.exceptions import InvalidTemplate
-from snowflake.cli.api.rendering.jinja import IgnoreAttrEnvironment, env_bootstrap
-from snowflake.cli.api.secure_path import SecurePath
-
-_VARIABLE_TEMPLATE_START = "<!"
-_VARIABLE_TEMPLATE_END = "!>"
-_BLOCK_TEMPLATE_START = "<!!"
-_BLOCK_TEMPLATE_END = "!!>"
-
-
-def to_snowflake_identifier(value: Optional[str]) -> Optional[str]:
-    if not value:
-        # passing "None" through filter to allow jinja to handle "undefined value" exception
-        return value
-
-    import re
-
-    # TODO: remove code duplication when joining "init" with "snow app init"
-    # See https://docs.snowflake.com/en/sql-reference/identifiers-syntax for identifier syntax
-    unquoted_identifier_regex = r"([a-zA-Z_])([a-zA-Z0-9_$]{0,254})"
-    quoted_identifier_regex = r'"((""|[^"]){0,255})"'
-
-    if re.fullmatch(quoted_identifier_regex, value):
-        return value
-
-    result = re.sub(r"[. -]+", "_", value)
-    if not re.fullmatch(unquoted_identifier_regex, result):
-        raise ClickException(
-            f"Value '{value}' cannot be converted to valid Snowflake identifier."
-            ' Consider enclosing it in double quotes: ""'
-        )
-    return result
-
-
-PROJECT_TEMPLATE_FILTERS = [to_snowflake_identifier]
-
-
-def get_template_cli_jinja_env(template_root: SecurePath) -> Environment:
-    env = env_bootstrap(
-        IgnoreAttrEnvironment(
-            loader=loaders.FileSystemLoader(searchpath=template_root.path),
-            keep_trailing_newline=True,
-            variable_start_string=_VARIABLE_TEMPLATE_START,
-            variable_end_string=_VARIABLE_TEMPLATE_END,
-            block_start_string=_BLOCK_TEMPLATE_START,
-            block_end_string=_BLOCK_TEMPLATE_END,
-            undefined=StrictUndefined,
-        )
-    )
-    env.filters["to_snowflake_identifier"] = to_snowflake_identifier
-
-    return env
-
-
-def render_template_files(
-    template_root: SecurePath, files_to_render: List[str], data: Dict[str, Any]
-) -> None:
-    """Override all listed files with their rendered version."""
-    jinja_env = get_template_cli_jinja_env(template_root)
-    for path in files_to_render:
-        try:
-            jinja_template = jinja_env.get_template(path)
-            rendered_result = jinja_template.render(**data)
-            full_path = template_root / path
-            full_path.write_text(rendered_result)
-        except TemplateSyntaxError as err:
-            raise InvalidTemplate(
-                f"Invalid template syntax in line {err.lineno} of file {path}:\n"
-                f"{err.message}"
-            )
-        except UndefinedError as err:
-            raise InvalidTemplate(err.message)

snowflake/cli/api/rendering/sql_templates.py

@@ -1,105 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from __future__ import annotations
-
-from typing import Dict, Optional
-
-from click import ClickException
-from jinja2 import Environment, StrictUndefined, loaders, meta
-from snowflake.cli.api.cli_global_context import get_cli_context
-from snowflake.cli.api.console.console import cli_console
-from snowflake.cli.api.exceptions import InvalidTemplate
-from snowflake.cli.api.metrics import CLICounterField
-from snowflake.cli.api.rendering.jinja import (
-    CONTEXT_KEY,
-    FUNCTION_KEY,
-    IgnoreAttrEnvironment,
-    env_bootstrap,
-)
-
-_SQL_TEMPLATE_START = "<%"
-_SQL_TEMPLATE_END = "%>"
-_OLD_SQL_TEMPLATE_START = "&{"
-_OLD_SQL_TEMPLATE_END = "}"
-RESERVED_KEYS = [CONTEXT_KEY, FUNCTION_KEY]
-
-
-def _get_sql_jinja_env(template_start: str, template_end: str) -> Environment:
-    _random_block = "___very___unique___block___to___disable___logic___blocks___"
-    return env_bootstrap(
-        IgnoreAttrEnvironment(
-            variable_start_string=template_start,
-            variable_end_string=template_end,
-            loader=loaders.BaseLoader(),
-            block_start_string=_random_block,
-            block_end_string=_random_block,
-            keep_trailing_newline=True,
-            undefined=StrictUndefined,
-        )
-    )
-
-
-def _does_template_have_env_syntax(env: Environment, template_content: str) -> bool:
-    template = env.parse(template_content)
-    return bool(meta.find_undeclared_variables(template))
-
-
-def has_sql_templates(template_content: str) -> bool:
-    return (
-        _OLD_SQL_TEMPLATE_START in template_content
-        or _SQL_TEMPLATE_START in template_content
-    )
-
-
-def choose_sql_jinja_env_based_on_template_syntax(
-    template_content: str, reference_name: Optional[str] = None
-) -> Environment:
-    old_syntax_env = _get_sql_jinja_env(_OLD_SQL_TEMPLATE_START, _OLD_SQL_TEMPLATE_END)
-    new_syntax_env = _get_sql_jinja_env(_SQL_TEMPLATE_START, _SQL_TEMPLATE_END)
-    has_old_syntax = _does_template_have_env_syntax(old_syntax_env, template_content)
-    has_new_syntax = _does_template_have_env_syntax(new_syntax_env, template_content)
-    reference_name_str = f" in {reference_name}" if reference_name else ""
-    if has_old_syntax and has_new_syntax:
-        raise InvalidTemplate(
-            f"The SQL query{reference_name_str} mixes {_OLD_SQL_TEMPLATE_START} ... {_OLD_SQL_TEMPLATE_END} syntax"
-            f" and {_SQL_TEMPLATE_START} ... {_SQL_TEMPLATE_END} syntax."
-        )
-    if has_old_syntax:
-        cli_console.warning(
-            f"Warning: {_OLD_SQL_TEMPLATE_START} ... {_OLD_SQL_TEMPLATE_END} syntax{reference_name_str} is deprecated."
-            f" Use {_SQL_TEMPLATE_START} ... {_SQL_TEMPLATE_END} syntax instead."
-        )
-        return old_syntax_env
-    return new_syntax_env
-
-
-def snowflake_sql_jinja_render(content: str, data: Dict | None = None) -> str:
-    data = data or {}
-
-    for reserved_key in RESERVED_KEYS:
-        if reserved_key in data:
-            raise ClickException(
-                f"{reserved_key} in user defined data. The `{reserved_key}` variable is reserved for CLI usage."
-            )
-
-    context_data = get_cli_context().template_context
-    context_data.update(data)
-    env = choose_sql_jinja_env_based_on_template_syntax(content)
-
-    get_cli_context().metrics.set_counter(
-        CLICounterField.SQL_TEMPLATES, int(has_sql_templates(content))
-    )
-
-    return env.from_string(content).render(context_data)