Method WriteCollectionVarlenChild

be/src/runtime/raw-value.cc:362–390

template <bool COLLECT_VAR_LEN_VALS>
void RawValue::WriteCollectionVarlenChild(Tuple* child_dest_tuple, Tuple* child_src_tuple,
    const SlotDescriptor* slot_desc, MemPool* pool, vector<StringValue*>* string_values,
    vector<pair<CollectionValue*, int64_t>>* collection_values ) {
  DCHECK(slot_desc != nullptr);
  DCHECK(slot_desc->type().IsVarLenStringType() || slot_desc->type().IsCollectionType());

  if (!child_dest_tuple->IsNull(slot_desc->null_indicator_offset())) {
    // The fixed length part of the child (the pointer and the length / number of tuples)
    // is already in the destination tuple, copied there as the var-len data of the
    // parent. We continue the recursion for two things:
    //   1. deep-copying the var-len data of the child
    //   2. collecting var-len slots.
    // At least one of these is true, otherwise we never get here. The called recursive
    // function will once again set the length (always unnecessary) and the pointer
    // (unnecessary if we're not deep-copying, only collecting). This is not costly enough
    // to justify complicating the code. Note, however, that although at this point the
    // source and destination slots hold the same value (pointer and length / number of
    // tuples), we take 'child_value', the source in the recursive call, from the source
    // tuple, because in case of deep-copying, the pointer of the destination slot will be
    // re-assigned to the newly allocated buffer, and if we took 'child_value' from the
    // destination slot, the 'source' pointer and the 'destination' pointer would be the
    // same, meaning the 'source' pointer would also be overwritten before we copied the
    // data it pointed to.
    void* child_value = child_src_tuple->GetSlot(slot_desc->tuple_offset());

    WriteNonNull<COLLECT_VAR_LEN_VALS>(child_value, child_dest_tuple,
        slot_desc, pool, string_values, collection_values);
  }
}

template <bool COLLECT_VAR_LEN_VALS>
void RawValue::WritePrimitiveCollectVarlen(const void* value, Tuple* tuple,