code: def handle_bind_extract_object_function(
      node: FunctionExpression, binder_context: StatementBinderContext
  ):
      """Handles the binding of extract_object function.
          1. Bind the source video data
          2. Create and bind the detector function expression using the provided name.
          3. Create and bind the tracker function expression.
              Its inputs are id, data, output of detector.
          4. Bind the EXTRACT_OBJECT function expression and append the new children.
          5. Handle the alias and populate the outputs of the EXTRACT_OBJECT function
  
      Args:
          node (FunctionExpression): The function expression representing the extract object operation.
          binder_context (StatementBinderContext): The context object used to bind expressions in the statement.
  
      Raises:
          AssertionError: If the number of children in the `node` is not equal to 3.
      """
      assert (
          len(node.children) == 3
      ), f"Invalid arguments provided to {node}. Example correct usage, (data, Detector, Tracker)"
  
      # 1. Bind the source video
      video_data = node.children[0]
      binder_context.bind(video_data)
  
      # 2. Construct the detector
      # convert detector to FunctionExpression before binding
      # eg. YoloV5 -> YoloV5(data)
      detector = FunctionExpression(None, node.children[1].name)
      detector.append_child(video_data.copy())
      binder_context.bind(detector)
  
      # 3. Construct the tracker
      # convert tracker to FunctionExpression before binding
      # eg. ByteTracker -> ByteTracker(id, data, labels, bboxes, scores)
      tracker = FunctionExpression(None, node.children[2].name)
      # create the video id expression
      columns = get_video_table_column_definitions()
      tracker.append_child(
          TupleValueExpression(
              name=columns[1].name, table_alias=video_data.table_alias
          )
      )
      tracker.append_child(video_data.copy())
      binder_context.bind(tracker)
      # append the bound output of detector
      for obj in detector.output_objs:
          col_alias = "{}.{}".format(
              obj.function_name.lower(), obj.name.lower()
          )
          child = TupleValueExpression(
              obj.name,
              table_alias=obj.function_name.lower(),
              col_object=obj,
              col_alias=col_alias,
          )
          tracker.append_child(child)
  
      # 4. Bind the EXTRACT_OBJECT expression and append the new children.
      node.children = []
      node.children = [video_data, detector, tracker]
  
      # 5. assign the outputs of tracker to the output of extract_object
      node.output_objs = tracker.output_objs
      node.projection_columns = [
          obj.name.lower() for obj in node.output_objs
      ]
  
      # 5. resolve alias based on the what user provided
      # we assign the alias to tracker as it governs the output of the extract object
      resolve_alias_table_value_expression(node)
      tracker.alias = node.alias
  
imports: from __future__ import annotations
  import re
  from typing import TYPE_CHECKING, List
  import pandas
  from evadb.catalog.catalog_type import ColumnType, TableType
  from evadb.catalog.catalog_utils import get_video_table_column_definitions, is_document_table, is_pdf_table, is_string_col, is_video_table
  from evadb.catalog.models.column_catalog import ColumnCatalogEntry
  from evadb.catalog.models.table_catalog import TableCatalogEntry
  from evadb.catalog.sql_config import IDENTIFIER_COLUMN
  from evadb.catalog.sql_config import ROW_NUM_COLUMN
  from evadb.expression.abstract_expression import AbstractExpression, ExpressionType
  from evadb.expression.function_expression import FunctionExpression
  from evadb.expression.tuple_value_expression import TupleValueExpression
  from evadb.parser.alias import Alias
  from evadb.parser.create_statement import ColumnDefinition
  from evadb.parser.table_ref import TableInfo, TableRef
  from evadb.third_party.databases.interface import get_database_handler
  from evadb.utils.logging_manager import logger
label_desc: Use image node_id 12 for calling a global function with example usage: handle_bind_extract_object_function(node, binder_context) without return types