code: def execute(cls, ctx, op):
      import tiledb
  
      chunk = op.outputs[0]
      from ..array_utils import array_module
      from ..utils import get_tiledb_ctx
  
      xp = array_module(op.gpu)
  
      axis_offsets = [
          offset + dim_start
          for offset, dim_start in zip(
              op.axis_offsets, op.tiledb_dim_starts
          )
      ]
      tiledb_ctx = get_tiledb_ctx(op.tiledb_config)
      uri = op.tiledb_uri
      key = op.tiledb_key
      timestamp = op.tiledb_timestamp
  
      slcs = []
      for axis in range(chunk.ndim):
          axis_offset = axis_offsets[axis]
          axis_length = chunk.shape[axis]
          slcs.append(slice(axis_offset, axis_offset + axis_length))
  
      if not op.sparse:
          # read dense array from tiledb
          with tiledb.DenseArray(
              uri=uri, ctx=tiledb_ctx, key=key, timestamp=timestamp
          ) as tiledb_arr:
              ctx[chunk.key] = tiledb_arr[tuple(slcs)]
      else:
          # read sparse array from tiledb
          with tiledb.SparseArray(
              uri=uri, ctx=tiledb_ctx, key=key, timestamp=timestamp
          ) as tiledb_arr:
              if tiledb_arr.ndim > 2:
                  raise NotImplementedError(
                      "Does not support to read array with more than 2 dimensions"
                  )
  
              data = tiledb_arr[tuple(slcs)]
              coords = data["coords"]
  
              value = data[tiledb_arr.attr(0).name]
              if tiledb_arr.ndim == 2:
                  # 2-d
                  ij = tuple(
                      coords[tiledb_arr.domain.dim(k).name]
                      - axis_offsets[k]
                      for k in range(tiledb_arr.ndim)
                  )
                  spmatrix = sps.coo_matrix(
                      (value, ij), shape=chunk.shape
                  )
                  ctx[chunk.key] = SparseNDArray(spmatrix)
              else:
                  # 1-d
                  ij = (
                      xp.zeros(coords.shape),
                      coords[tiledb_arr.domain.dim(0).name]
                      - axis_offsets[0],
                  )
                  spmatrix = sps.coo_matrix(
                      (value, ij), shape=(1,) + chunk.shape
                  )
                  ctx[chunk.key] = SparseNDArray(
                      spmatrix, shape=chunk.shape
                  )
  
file_path: mars/mars/tensor/datasource/from_tiledb.py
imports: from ...None import opcodes
  from ...serialization.serializables import FieldTypes, DictField, TupleField, StringField, Int64Field
  from ...lib.sparse.core import sps
  from ...lib.sparse import SparseNDArray
  from ..core import TensorOrder
  from .core import TensorNoInput
label_desc: Use image node_id 9 for calling the TensorTileDBDataSource obj's underlying member method code with example usage: obj.execute(cls, ctx, op) without return types