int bind()

in query/binder.hpp [316:426]
101 lines of code
21 McCabe index (conditional complexity)

  int bind() {
    InputVectorBinderBase<Context, NumVectors, NumUnboundIterators - 1>
        nextBinder(context, inputVectors, indexVector, baseCounts, startCount);
    InputVector input = inputVectors[NumVectors - NumUnboundIterators];
    if (input.Type == VectorPartyInput) {
      VectorPartySlice inputVP = input.Vector.VP;
      DataType dataType = inputVP.DataType;
      uint8_t *basePtr = inputVP.BasePtr;
      bool hasDefault = inputVP.DefaultValue.HasDefault;
      DefaultValue defaultValue = inputVP.DefaultValue;
      uint32_t nullsOffset = inputVP.NullsOffset;
      uint32_t valuesOffset = inputVP.ValuesOffset;
      uint8_t startingIndex = inputVP.StartingIndex;
      uint8_t stepInBytes = getStepInBytes(inputVP.DataType);
      uint32_t length = inputVP.Length;
      // This macro will bind column type with width > 4 bytes (GeoPoint, UUID
      // int64). Since our scratch space is always 4 bytes (int32, uint32,
      // float), parent nodes for those wider types must be a root node.

      #define BIND_WIDER_COLUMN_INPUT(dataType, defaultValue) \
      if (basePtr == nullptr) { \
          return nextBinder.bind(thrust::make_constant_iterator( \
              thrust::make_tuple<dataType, bool>( \
                  defaultValue, hasDefault))); \
        } \
        return nextBinder.bind(make_column_iterator<dataType>( \
            indexVector, baseCounts, startCount, basePtr, nullsOffset, \
            valuesOffset, length, stepInBytes, startingIndex));

      switch (dataType) {
        case GeoPoint:
          BIND_WIDER_COLUMN_INPUT(GeoPointT, defaultValue.Value.GeoPointVal)
        case UUID:
          BIND_WIDER_COLUMN_INPUT(UUIDT, defaultValue.Value.UUIDVal)
        case Int64:
          BIND_WIDER_COLUMN_INPUT(int64_t, defaultValue.Value.Int64Val)
        default: break;
      }
    } else if (input.Type == ForeignColumnInput) {
      RecordID *recordIDs = input.Vector.ForeignVP.RecordIDs;
      const int32_t numBatches = input.Vector.ForeignVP.NumBatches;
      const int32_t baseBatchID = input.Vector.ForeignVP.BaseBatchID;
      VectorPartySlice *vpSlices = input.Vector.ForeignVP.Batches;
      const int32_t numRecordsInLastBatch =
          input.Vector.ForeignVP.NumRecordsInLastBatch;
      DataType dataType = input.Vector.ForeignVP.DataType;
      bool hasDefault = input.Vector.ForeignVP.DefaultValue.HasDefault;
      DefaultValue defaultValueStruct = input.Vector.ForeignVP.DefaultValue;
      uint8_t stepInBytes = getStepInBytes(dataType);

      #define BIND_WIDER_FOREIGN_COLUMN_INPUT(defaultValue, dataType) { \
          ForeignTableIterator<dataType> *vpIters = \
            prepareForeignTableIterators(numBatches, vpSlices, stepInBytes, \
              hasDefault, defaultValue, context.getStream()); \
          int res = nextBinder.bind(RecordIDJoinIterator<dataType>( \
                                    recordIDs, numBatches, baseBatchID, \
                                    vpIters, numRecordsInLastBatch, \
                                    nullptr, 0)); \
          deviceFree(vpIters); \
          return res; \
          }

      switch (dataType) {
        case UUID: BIND_WIDER_FOREIGN_COLUMN_INPUT(
            defaultValueStruct.Value.UUIDVal, UUIDT)
        case Int64: BIND_WIDER_FOREIGN_COLUMN_INPUT(
            defaultValueStruct.Value.Int64Val, int64_t)
        default: break;
      }
    } else if (input.Type == ArrayVectorPartyInput) {
      // Array type can only bind to first argument for BinaryTransformer
      ArrayVectorPartySlice inputVP = input.Vector.ArrayVP;
      uint8_t *basePtr = inputVP.OffsetLengthVector;
      uint32_t length = inputVP.Length;
      int valueOffsetAdj = inputVP.ValueOffsetAdj;

      #define BIND_ARRAY_COLUMN_INPUT(dataType) \
        return nextBinder.bind(make_array_column_iterator<dataType>( \
            basePtr, valueOffsetAdj, length));

      switch (inputVP.DataType) {
        case Bool:
          BIND_ARRAY_COLUMN_INPUT(bool)
        case Int8:
          BIND_ARRAY_COLUMN_INPUT(int8_t)
        case Int16:
          BIND_ARRAY_COLUMN_INPUT(int16_t)
        case Int32:
          BIND_ARRAY_COLUMN_INPUT(int32_t)
        case Uint8:
          BIND_ARRAY_COLUMN_INPUT(uint8_t)
        case Uint16:
          BIND_ARRAY_COLUMN_INPUT(uint16_t)
        case Uint32:
          BIND_ARRAY_COLUMN_INPUT(uint32_t)
        case Float32:
          BIND_ARRAY_COLUMN_INPUT(float_t)
        case Int64:
          BIND_ARRAY_COLUMN_INPUT(int64_t)
        case UUID:
          BIND_ARRAY_COLUMN_INPUT(UUIDT)
        case GeoPoint:
          BIND_ARRAY_COLUMN_INPUT(GeoPointT)
        default:
          throw std::invalid_argument(
              "Unsupported data type for ArrayVectorPartyInput: " +
                  std::to_string(__LINE__));
      }
    }
    return bindGeneric();
  }