code: def _bind_select_statement(self, node: SelectStatement):
      if node.from_table:
          self.bind(node.from_table)
  
      if node.where_clause:
          self.bind(node.where_clause)
          if node.where_clause.etype == ExpressionType.COMPARE_LIKE:
              check_column_name_is_string(node.where_clause.children[0])
  
      if node.target_list:
          # SELECT * support
          if (
              len(node.target_list) == 1
              and isinstance(node.target_list[0], TupleValueExpression)
              and node.target_list[0].name == "*"
          ):
              node.target_list = extend_star(self._binder_context)
          for expr in node.target_list:
              self.bind(expr)
              if isinstance(expr, FunctionExpression):
                  output_cols = (
                      get_bound_func_expr_outputs_as_tuple_value_expr(
                          expr
                      )
                  )
                  self._binder_context.add_derived_table_alias(
                      expr.alias.alias_name, output_cols
                  )
  
      if node.groupby_clause:
          self.bind(node.groupby_clause)
          check_table_object_is_groupable(node.from_table)
          check_groupby_pattern(
              node.from_table, node.groupby_clause.value
          )
      if node.orderby_list:
          for expr in node.orderby_list:
              self.bind(expr[0])
      if node.union_link:
          current_context = self._binder_context
          self._binder_context = StatementBinderContext(self._catalog)
          self.bind(node.union_link)
          self._binder_context = current_context
  
      # chunk_params only supported for DOCUMENT TYPE
      if node.from_table and node.from_table.chunk_params:
          assert is_document_table(
              node.from_table.table.table_obj
          ), "CHUNK related parameters only supported for DOCUMENT tables."
  
      assert not (
          self._binder_context.is_retrieve_audio()
          and self._binder_context.is_retrieve_video()
      ), "Cannot query over both audio and video streams"
  
      if self._binder_context.is_retrieve_audio():
          node.from_table.get_audio = True
      if self._binder_context.is_retrieve_video():
          node.from_table.get_video = True
  
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 7 for calling the StatementBinder obj's underlying member method code with example usage: obj._bind_select_statement(node) without return types