docs-archive/1.10.13/_sources/_api/airflow/models/serialized_dag/index.rst.txt

:mod:`airflow.models.serialized_dag`
====================================

.. py:module:: airflow.models.serialized_dag

.. autoapi-nested-parse::

   Serialized DAG table in database.



Module Contents
---------------

.. data:: log
   

   

.. py:class:: SerializedDagModel(dag)

   Bases: :class:`airflow.models.base.Base`

   A table for serialized DAGs.

   serialized_dag table is a snapshot of DAG files synchronized by scheduler.
   This feature is controlled by:

   * ``[core] store_serialized_dags = True``: enable this feature
   * ``[core] min_serialized_dag_update_interval = 30`` (s):
     serialized DAGs are updated in DB when a file gets processed by scheduler,
     to reduce DB write rate, there is a minimal interval of updating serialized DAGs.
   * ``[scheduler] dag_dir_list_interval = 300`` (s):
     interval of deleting serialized DAGs in DB when the files are deleted, suggest
     to use a smaller interval such as 60

   It is used by webserver to load dags when ``store_serialized_dags=True``.
   Because reading from database is lightweight compared to importing from files,
   it solves the webserver scalability issue.

   .. attribute:: __tablename__
      :annotation: = serialized_dag

      

   .. attribute:: dag_id
      

      

   .. attribute:: fileloc
      

      

   .. attribute:: fileloc_hash
      

      

   .. attribute:: data
      

      

   .. attribute:: last_updated
      

      

   .. attribute:: dag_hash
      

      

   .. attribute:: __table_args__
      

      

   .. attribute:: dag
      

      The DAG deserialized from the ``data`` column


   
   .. method:: __repr__(self)



   
   .. classmethod:: write_dag(cls, dag, min_update_interval=None, session=None)

      Serializes a DAG and writes it into database.
      If the record already exists, it checks if the Serialized DAG changed or not. If it is
      changed, it updates the record, ignores otherwise.

      :param dag: a DAG to be written into database
      :param min_update_interval: minimal interval in seconds to update serialized DAG
      :param session: ORM Session



   
   .. classmethod:: read_all_dags(cls, session=None)

      Reads all DAGs in serialized_dag table.

      :param session: ORM Session
      :type session: Session
      :returns: a dict of DAGs read from database



   
   .. classmethod:: remove_dag(cls, dag_id, session=None)

      Deletes a DAG with given dag_id.

      :param dag_id: dag_id to be deleted
      :type dag_id: str
      :param session: ORM Session
      :type session: Session



   
   .. classmethod:: remove_deleted_dags(cls, alive_dag_filelocs, session=None)

      Deletes DAGs not included in alive_dag_filelocs.

      :param alive_dag_filelocs: file paths of alive DAGs
      :type alive_dag_filelocs: list
      :param session: ORM Session
      :type session: Session



   
   .. classmethod:: has_dag(cls, dag_id, session=None)

      Checks a DAG exist in serialized_dag table.

      :param dag_id: the DAG to check
      :type dag_id: str
      :param session: ORM Session
      :type session: Session
      :rtype: bool



   
   .. classmethod:: get(cls, dag_id, session=None)

      Get the SerializedDAG for the given dag ID.
      It will cope with being passed the ID of a subdag by looking up the
      root dag_id from the DAG table.

      :param dag_id: the DAG to fetch
      :param session: ORM Session
      :type session: Session



   
   .. classmethod:: get_last_updated_datetime(cls, dag_id, session)

      Get the date when the Serialized DAG associated to DAG was last updated
      in serialized_dag table

      :param dag_id: DAG ID
      :type dag_id: str
      :param session: ORM Session
      :type session: Session