code: def _extract_table_arrays(table):
      """Get buffer info from arrays in table, outputs are padded so dim sizes
         are rectangular.
  
      Args:
          table: A pyarrow.Table
      Return:
          tuple of:
          array_buffer_addrs: 3-dim list of buffer addresses where dims are
                               columns, chunks, buffer addresses
          array_buffer_sizes: 3-dim list of buffer sizes, follows addrs layout
          array_lengths: 3-dim list of array lengths where dims are columns,
                          chunks, length of array followed by child array lengths
      """
      array_buffer_addrs = []
      array_buffer_sizes = []
      array_lengths = []
      max_num_bufs = 0
      max_num_chunks = 0
      max_num_lengths = 0
  
      # Iterate over each column in the Table
      for chunked_array in table:
          array_chunk_buffer_addrs = []
          array_chunk_buffer_sizes = []
          array_chunk_lengths = []
  
          # Iterate over each data chunk in the column
          for arr in chunked_array.iterchunks():
              bufs = arr.buffers()
              array_chunk_buffer_addrs.append(
                  [b.address if b is not None else 0 for b in bufs]
              )
              array_chunk_buffer_sizes.append(
                  [b.size if b is not None else 0 for b in bufs]
              )
  
              # Get the total length of the array followed by lenghts of children
              array_and_child_lengths = [len(arr)]
  
              # Check if has child array, e.g. list type
              if arr.type.num_children > 0:
                  if hasattr(arr, "values"):
                      array_and_child_lengths.append(len(arr.values))
                  else:
                      raise ValueError(
                          "Only nested type currently supported is ListType"
                      )
  
              array_chunk_lengths.append(array_and_child_lengths)
              if len(bufs) > max_num_bufs:
                  max_num_bufs = len(bufs)
              if len(array_and_child_lengths) > max_num_lengths:
                  max_num_lengths = len(array_and_child_lengths)
  
          array_buffer_addrs.append(array_chunk_buffer_addrs)
          array_buffer_sizes.append(array_chunk_buffer_sizes)
          array_lengths.append(array_chunk_lengths)
          if len(array_chunk_lengths) > max_num_chunks:
              max_num_chunks = len(array_chunk_lengths)
  
      # Pad buffer addrs, sizes and array lengths so inputs are rectangular
      num_columns = len(array_buffer_sizes)
      for i in range(num_columns):
          # pad chunk list with empty lists that will be padded with null bufs
          if len(array_buffer_sizes[i]) < max_num_chunks:
              array_buffer_sizes[i].extend(
                  [[]] * (max_num_chunks - len(array_buffer_sizes[i]))
              )
          if len(array_lengths[i]) < max_num_chunks:
              array_lengths[i].extend(
                  [-1] * (max_num_chunks - len(array_lengths[i]))
              )
  
          num_chunks = len(array_buffer_sizes[i])
          for j in range(num_chunks):
              # pad buffer addr, size, and array length lists
              if len(array_buffer_sizes[i][j]) < max_num_bufs:
                  array_buffer_sizes[i][j].extend(
                      [-1]
                      * (max_num_bufs - len(array_buffer_sizes[i][j]))
                  )
                  array_buffer_addrs[i][j].extend(
                      [0]
                      * (max_num_bufs - len(array_buffer_addrs[i][j]))
                  )
              if len(array_lengths[i][j]) < max_num_lengths:
                  array_lengths[i][j].extend(
                      [-1]
                      * (max_num_lengths - len(array_lengths[i][j]))
                  )
      return array_buffer_addrs, array_buffer_sizes, array_lengths
  
imports: import uuid
  import tensorflow
  from tensorflow_io.python.ops import io_tensor_ops
  from tensorflow_io.python.ops import core_ops
label_desc: Use image node_id 1 for calling a global function with example usage: _extract_table_arrays(table) and returns: array_buffer_addrs,  array_buffer_sizes,  array_lengths