code: def create_table(
      self,
      table_name: Identifier,
      result_set,
      is_replace=False,
      is_create=False,
  ):
      # is_create - create table
      # is_replace - drop table if exists
      # is_create==False and is_replace==False: just insert
  
      table_columns_meta = {}
      table_columns = []
      for col in result_set.columns:
          # assume this is pandas type
          column_type = Text
          if isinstance(col.type, np_dtype):
              if pd_types.is_integer_dtype(col.type):
                  column_type = Integer
              elif pd_types.is_numeric_dtype(col.type):
                  column_type = Float
  
          table_columns.append(
              TableColumn(name=col.alias, type=column_type)
          )
          table_columns_meta[col.alias] = column_type
  
      if is_replace:
          # drop
          drop_ast = DropTables(tables=[table_name], if_exists=True)
          result = self.integration_handler.query(drop_ast)
          if result.type == RESPONSE_TYPE.ERROR:
              raise Exception(result.error_message)
          is_create = True
  
      if is_create:
          create_table_ast = CreateTable(
              name=table_name, columns=table_columns, is_replace=True
          )
  
          result = self.integration_handler.query(create_table_ast)
          if result.type == RESPONSE_TYPE.ERROR:
              raise Exception(result.error_message)
  
      insert_columns = [
          Identifier(parts=[x.alias]) for x in result_set.columns
      ]
      formatted_data = []
  
      for rec in result_set.get_records():
          new_row = []
          for col in result_set.columns:
              value = rec[col.alias]
              column_type = table_columns_meta[col.alias]
  
              python_type = str
              if column_type == Integer:
                  python_type = int
              elif column_type == Float:
                  python_type = float
  
              try:
                  value = (
                      python_type(value) if value is not None else value
                  )
              except Exception:
                  pass
              new_row.append(value)
          formatted_data.append(new_row)
  
      if len(formatted_data) == 0:
          # not need to insert
          return
  
      insert_ast = Insert(
          table=table_name,
          columns=insert_columns,
          values=formatted_data,
      )
  
      try:
          result = self.integration_handler.query(insert_ast)
      except Exception as e:
          msg = f"[{self.ds_type}/{self.integration_name}]: {str(e)}"
          raise DBHandlerException(msg) from e
  
      if result.type == RESPONSE_TYPE.ERROR:
          raise Exception(result.error_message)
  
imports: import numpy
  from numpy import dtype
  import pandas
  from pandas.api import types
  from sqlalchemy.types import Integer, Float, Text
  from mindsdb_sql.parser.ast import Insert, Identifier, CreateTable, TableColumn, DropTables
  from mindsdb.api.executor.datahub.datanodes.datanode import DataNode
  from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
  from mindsdb.api.executor.datahub.classes.tables_row import TablesRow
  from mindsdb.utilities import log
  from mindsdb.utilities.profiler import profiler
label_desc: Use image node_id 7 for calling the IntegrationDataNode obj's underlying member method code with example usage: obj.create_table(table_name, result_set, is_replace, is_create) without return types