code: def _bind_create_function_statement(
      self, node: CreateFunctionStatement
  ):
      if node.query is not None:
          self.bind(node.query)
          # Drop the automatically generated _row_id column
          node.query.target_list = drop_row_id_from_target_list(
              node.query.target_list
          )
          all_column_list = (
              get_column_definition_from_select_target_list(
                  node.query.target_list
              )
          )
          arg_map = {key: value for key, value in node.metadata}
          inputs, outputs = [], []
          if string_comparison_case_insensitive(
              node.function_type, "ludwig"
          ):
              assert (
                  "predict" in arg_map
              ), f"Creating {node.function_type} functions expects 'predict' metadata."
              # We only support a single predict column for now
              predict_columns = set([arg_map["predict"]])
              for column in all_column_list:
                  if column.name in predict_columns:
                      column.name = column.name + "_predictions"
  
                      outputs.append(column)
                  else:
                      inputs.append(column)
          elif string_comparison_case_insensitive(
              node.function_type, "sklearn"
          ) or string_comparison_case_insensitive(
              node.function_type, "XGBoost"
          ):
              assert (
                  "predict" in arg_map
              ), f"Creating {node.function_type} functions expects 'predict' metadata."
              # We only support a single predict column for now
              predict_columns = set([arg_map["predict"]])
              for column in all_column_list:
                  if column.name in predict_columns:
                      outputs.append(column)
                  else:
                      inputs.append(column)
          elif string_comparison_case_insensitive(
              node.function_type, "forecasting"
          ):
              # Forecasting models have only one input column which is horizon
              inputs = [
                  ColumnDefinition(
                      "horizon", ColumnType.INTEGER, None, None
                  )
              ]
              # Currently, we only support univariate forecast which should have three output columns, unique_id, ds, and y.
              # The y column is required. unique_id and ds will be auto generated if not found.
              required_columns = set([arg_map.get("predict", "y")])
              for column in all_column_list:
                  if column.name == arg_map.get("id", "unique_id"):
                      outputs.append(column)
                  elif column.name == arg_map.get("time", "ds"):
                      outputs.append(column)
                  elif column.name == arg_map.get("predict", "y"):
                      outputs.append(column)
                      required_columns.remove(column.name)
              assert (
                  len(required_columns) == 0
              ), f"Missing required {required_columns} columns for forecasting function."
              outputs.extend(
                  [
                      ColumnDefinition(
                          arg_map.get("predict", "y") + "-lo",
                          ColumnType.FLOAT,
                          None,
                          None,
                      ),
                      ColumnDefinition(
                          arg_map.get("predict", "y") + "-hi",
                          ColumnType.FLOAT,
                          None,
                          None,
                      ),
                  ]
              )
          else:
              raise BinderError(
                  f"Unsupported type of function: {node.function_type}."
              )
          assert (
              len(node.inputs) == 0 and len(node.outputs) == 0
          ), f"{node.function_type} functions' input and output are auto assigned"
          node.inputs, node.outputs = inputs, outputs
  
imports: from functools import singledispatchmethod
  from typing import Callable
  from evadb.binder.binder_utils import BinderError, bind_table_info, check_column_name_is_string, check_groupby_pattern, check_table_object_is_groupable, drop_row_id_from_target_list, extend_star, get_bound_func_expr_outputs_as_tuple_value_expr, get_column_definition_from_select_target_list
  from evadb.binder.statement_binder_context import StatementBinderContext
  from evadb.catalog.catalog_type import ColumnType, TableType
  from evadb.catalog.catalog_utils import is_document_table
  from evadb.catalog.sql_config import RESTRICTED_COL_NAMES
  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.create_function_statement import CreateFunctionStatement
  from evadb.parser.create_index_statement import CreateIndexStatement
  from evadb.parser.create_statement import ColumnDefinition, CreateTableStatement
  from evadb.parser.delete_statement import DeleteTableStatement
  from evadb.parser.explain_statement import ExplainStatement
  from evadb.parser.rename_statement import RenameTableStatement
  from evadb.parser.select_statement import SelectStatement
  from evadb.parser.statement import AbstractStatement
  from evadb.parser.table_ref import TableRef
  from evadb.utils.generic_utils import string_comparison_case_insensitive
label_desc: Use image node_id 6 for calling the StatementBinder obj's underlying member method code with example usage: obj._bind_create_function_statement(node) without return types