code: def load_database(
      storage,
      load_host,
      resolve=None,
      name=None,
      version=None,
      progress_callback=None,
  ):
      """Import data into a database
  
      Parameters
      ----------
      storage: BaseStorageProtocol
          storage of destination database to load into
      load_host:
          file path containing data to import
          (should be a pickled file representing a PickledDB)
      resolve:
          policy to resolve import conflict. Either None, 'ignore', 'overwrite' or 'bump'.
          - None will raise an exception on any conflict detected
          - 'ignore' will ignore imported data on conflict
          - 'overwrite' will overwrite old data in destination database on conflict
          - 'bump' will bump imported data version before adding it,
            if data with same ID is found in destination
      name:
          (optional) name of experiment to import (by default, whole file is imported)
      version:
          (optional) version of experiment to import.
          By default, use the latest version of provided `name`.
      progress_callback:
          Optional callback to report progression. Receives 2 parameters:
          - step description (string)
          - overall progress (0 <= floating value <= 1)
      """
      load_host = os.path.abspath(load_host)
  
      # For pickled databases, make sure src is not dst
      if hasattr(storage, "_db"):
          dst_db = storage._db
          if isinstance(
              dst_db, PickledDB
          ) and load_host == os.path.abspath(dst_db.host):
              raise DatabaseError("Cannot load pickleddb to itself.")
  
      src_storage: BaseStorageProtocol = setup_storage(
          {"database": {"host": load_host, "type": "pickleddb"}}
      )
      logger.info(f"Loaded src {load_host}")
  
      import_benchmarks = False
      _describe_import_progress(
          STEP_COLLECT_EXPERIMENTS, 0, 1, progress_callback
      )
      if name is None:
          import_benchmarks = True
          # Retrieve all src experiments for export
          experiments = src_storage.fetch_experiments({})
      else:
          # Find experiments based on given name and version
          query = {"name": name}
          if version is not None:
              query["version"] = version
          experiments = src_storage.fetch_experiments(query)
          if not experiments:
              raise DatabaseError(
                  f"No experiment found with query {query}. Nothing to import."
              )
          if len(experiments) > 1:
              experiments = sorted(
                  experiments, key=lambda d: d["version"]
              )[-1:]
          logger.info(
              f"Found experiment {experiments[0]['name']}.{experiments[0]['version']}"
          )
      _describe_import_progress(
          STEP_COLLECT_EXPERIMENTS, 1, 1, progress_callback
      )
  
      preparation = _prepare_import(
          src_storage,
          storage,
          experiments,
          resolve,
          import_benchmarks,
          progress_callback=progress_callback,
      )
      _execute_import(
          storage, *preparation, progress_callback=progress_callback
      )
  
imports: import logging
  import os
  import shutil
  from typing import Any, Dict, List
  from orion.core.io.database import DatabaseError
  from orion.core.io.database.pickleddb import PickledDB
  from orion.core.utils import generate_temporary_file
  from orion.core.utils.tree import TreeNode
  from orion.storage.base import BaseStorageProtocol, setup_storage
label_desc: Use image node_id 2 for calling a global function with example usage: load_database(storage, load_host, resolve, name, version, progress_callback) without return types