code: def create_planner(self):
      databases = self.session.database_controller.get_list()
  
      predictor_metadata = []
  
      query_tables = []
  
      def get_all_query_tables(node, is_table, **kwargs):
          if is_table and isinstance(node, Identifier):
              table_name = node.parts[-1]
              table_version = None
              project_name = self.session.database
              if table_name.isdigit():
                  # is predictor version
                  table_version = int(table_name)
                  table_name = node.parts[-2]
              if table_name != node.parts[0]:
                  project_name = node.parts[0]
              query_tables.append(
                  (table_name, table_version, project_name)
              )
  
      query_traversal(self.query, get_all_query_tables)
  
      for table_name, table_version, project_name in query_tables:
          args = {"name": table_name, "project_name": project_name}
          if table_version is not None:
              args["active"] = None
              args["version"] = table_version
  
          model_record = get_model_record(**args)
          if model_record is None:
              continue
  
          if (
              isinstance(model_record.data, dict) is False
              or "error" in model_record.data
          ):
              continue
  
          ts_settings = model_record.learn_args.get(
              "timeseries_settings", {}
          )
          predictor = {
              "name": table_name,
              "integration_name": project_name,  # integration_name,
              "timeseries": False,
              "id": model_record.id,
          }
          if ts_settings.get("is_timeseries") is True:
              window = ts_settings.get("window")
              order_by = ts_settings.get("order_by")
              if isinstance(order_by, list):
                  order_by = order_by[0]
              group_by = ts_settings.get("group_by")
              if (
                  isinstance(group_by, list) is False
                  and group_by is not None
              ):
                  group_by = [group_by]
              predictor.update(
                  {
                      "timeseries": True,
                      "window": window,
                      "horizon": ts_settings.get("horizon"),
                      "order_by_column": order_by,
                      "group_by_columns": group_by,
                  }
              )
  
          predictor["model_types"] = model_record.data.get("dtypes", {})
  
          predictor_metadata.append(predictor)
  
      database = (
          None
          if self.session.database == ""
          else self.session.database.lower()
      )
  
      self.context["predictor_metadata"] = predictor_metadata
      self.planner = query_planner.QueryPlanner(
          self.query,
          integrations=databases,
          predictor_metadata=predictor_metadata,
          default_namespace=database,
      )
  
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 3 for calling the SQLQuery obj's underlying member method code with example usage: obj.create_planner() without return types