class_docstr: Checks that the metrics given as SQL expressions are within tolerance of the ones from days_back before.
  
  This method constructs a query like so ::
  
      SELECT {metrics_threshold_dict_key} FROM {table}
      WHERE {date_filter_column}=<date>
  
  :param table: the table name
  :param days_back: number of days between ds and the ds we want to check
      against. Defaults to 7 days
  :param metrics_thresholds: a dictionary of ratios indexed by metrics, for
      example 'COUNT(*)': 1.5 would require a 50 percent or less difference
      between the current day, and the prior days_back.
  :param snowflake_conn_id: Reference to
      :ref:`Snowflake connection id<howto/connection:snowflake>`
  :param autocommit: if True, each command is automatically committed.
      (default value: True)
  :param parameters: (optional) the parameters to render the SQL query with.
  :param warehouse: name of warehouse (will overwrite any warehouse
      defined in the connection's extra JSON)
  :param database: name of database (will overwrite database defined
      in connection)
  :param schema: name of schema (will overwrite schema defined in
      connection)
  :param role: name of role (will overwrite any role defined in
      connection's extra JSON)
  :param authenticator: authenticator for Snowflake.
      'snowflake' (default) to use the internal Snowflake authenticator
      'externalbrowser' to authenticate using your web browser and
      Okta, ADFS or any other SAML 2.0-compliant identify provider
      (IdP) that has been defined for your account
      'https://<your_okta_account_name>.okta.com' to authenticate
      through native Okta.
  :param session_parameters: You can set session-level parameters at
      the time you connect to Snowflake
code: def __init__(
      self,
      *,
      table: str,
      metrics_thresholds: dict,
      date_filter_column: str = "ds",
      days_back: SupportsAbs[int] = -7,
      snowflake_conn_id: str = "snowflake_default",
      parameters: Iterable | Mapping[str, Any] | None = None,
      autocommit: bool = True,
      do_xcom_push: bool = True,
      warehouse: str | None = None,
      database: str | None = None,
      role: str | None = None,
      schema: str | None = None,
      authenticator: str | None = None,
      session_parameters: dict | None = None,
      **kwargs,
  ) -> None:
      self.snowflake_conn_id = snowflake_conn_id
      if any(
          [
              warehouse,
              database,
              role,
              schema,
              authenticator,
              session_parameters,
          ]
      ):
          hook_params = kwargs.pop("hook_params", {})
          kwargs["hook_params"] = {
              "warehouse": warehouse,
              "database": database,
              "role": role,
              "schema": schema,
              "authenticator": authenticator,
              "session_parameters": session_parameters,
              **hook_params,
          }
      super().__init__(
          table=table,
          metrics_thresholds=metrics_thresholds,
          date_filter_column=date_filter_column,
          days_back=days_back,
          conn_id=snowflake_conn_id,
          **kwargs,
      )
      self.query_ids: list[str] = []
  
imports: from __future__ import annotations
  import time
  import warnings
  from datetime import timedelta
  from typing import TYPE_CHECKING, Any, Iterable, List, Mapping, Sequence, SupportsAbs, cast
  from airflow.configuration import conf
  from airflow.exceptions import AirflowException, AirflowProviderDeprecationWarning
  from airflow.providers.common.sql.operators.sql import SQLCheckOperator, SQLExecuteQueryOperator, SQLIntervalCheckOperator, SQLValueCheckOperator
  from airflow.providers.snowflake.hooks.snowflake_sql_api import SnowflakeSqlApiHook
  from airflow.providers.snowflake.triggers.snowflake_trigger import SnowflakeSqlApiTrigger
label_desc: Use image node_id 1 to create a new SnowflakeIntervalCheckOperator object from inherited base classes: SQLIntervalCheckOperator with example: obj = SnowflakeIntervalCheckOperator()