code: def execute_query(self, params=None):
      if self.fetched_data is not None:
          # no need to execute
          return
  
      process_mark = None
      try:
          steps = list(self.planner.execute_steps(params))
          steps_classes = (x.__class__ for x in steps)
          predict_steps = (
              ApplyPredictorRowStep,
              ApplyPredictorStep,
              ApplyTimeseriesPredictorStep,
          )
          if any(s in predict_steps for s in steps_classes):
              process_mark = create_process_mark("predict")
          for step in steps:
              with profiler.Context(f"step: {step.__class__.__name__}"):
                  data = self.execute_step(step)
              step.set_result(data)
              self.steps_data.append(data)
      except PlanningException as e:
          raise LogicError(e)
      except Exception as e:
          raise e
      finally:
          if process_mark is not None:
              delete_process_mark("predict", process_mark)
  
      # save updated query
      self.query = self.planner.query
  
      # there was no executing
      if len(self.steps_data) == 0:
          return
  
      try:
          if self.outer_query is not None:
              # workaround for subqueries in superset. remove it?
              # +++
              # ???
  
              result = self.steps_data[-1]
              df = result.to_df()
  
              df2 = query_df(df, self.outer_query)
  
              result2 = ResultSet().from_df(
                  df2, database="", table_name=""
              )
  
              self.columns_list = result2.columns
              self.fetched_data = result2
  
          else:
              result = self.steps_data[-1]
              self.fetched_data = result
      except Exception as e:
          raise UnknownError(
              "error in preparing result query step"
          ) from e
  
      try:
          if hasattr(self, "columns_list") is False:
              # how it becomes False?
              self.columns_list = self.fetched_data.columns
  
          if self.columns_list is None:
              self.columns_list = self.fetched_data.columns
  
          for col in self.fetched_data.find_columns("__mindsdb_row_id"):
              self.fetched_data.del_column(col)
  
      except Exception as e:
          raise UnknownError("error in column list step") from e
  
imports: import inspect
  import re
  from mindsdb_sql import parse_sql
  from mindsdb_sql.parser.ast import Identifier
  from mindsdb_sql.planner.steps import ApplyTimeseriesPredictorStep, ApplyPredictorRowStep, ApplyPredictorStep
  from mindsdb_sql.exceptions import PlanningException
  from mindsdb_sql.render.sqlalchemy_render import SqlalchemyRender
  from mindsdb_sql.planner import query_planner
  from mindsdb_sql.planner.utils import query_traversal
  from mindsdb.api.executor.utilities.sql import query_df
  from mindsdb.interfaces.model.functions import get_model_record
  from mindsdb.api.executor.exceptions import UnknownError, LogicError
  import mindsdb.utilities.profiler
  from mindsdb.utilities.fs import create_process_mark, delete_process_mark
  from .None import steps
  from .result_set import ResultSet, Column
  from .steps.base import BaseStepCall
label_desc: Use image node_id 6 for calling the SQLQuery obj's underlying member method code with example usage: obj.execute_query(params) without return types