int bindGeneric()

in query/binder.hpp [102:264]
150 lines of code
36 McCabe index (conditional complexity)

  int bindGeneric(InputIterators... boundInputIterators) {
    InputVectorBinderBase<Context, NumVectors, NumUnboundIterators - 1>
        nextBinder(context, inputVectors, indexVector, baseCounts, startCount);

    InputVector input = inputVectors[NumVectors - NumUnboundIterators];

    #define BIND_CONSTANT_INPUT(defaultValue, isValid) \
      return nextBinder.bind( \
            boundInputIterators..., \
            make_constant_iterator( \
                defaultValue, isValid));

    if (input.Type == ConstantInput) {
      ConstantVector constant = input.Vector.Constant;
      if (constant.DataType == ConstInt) {
        BIND_CONSTANT_INPUT(constant.Value.IntVal, constant.IsValid)
      } else if (constant.DataType == ConstFloat) {
        BIND_CONSTANT_INPUT(constant.Value.FloatVal, constant.IsValid)
      }
    } else if (input.Type == ScratchSpaceInput) {
      ScratchSpaceVector scratchSpace = input.Vector.ScratchSpace;
      uint32_t nullsOffset = scratchSpace.NullsOffset;

      #define BIND_SCRATCH_SPACE_INPUT(dataType) \
      return nextBinder.bind( \
              boundInputIterators..., \
              make_scratch_space_input_iterator<dataType>( \
                  scratchSpace.Values, \
                  nullsOffset));

      switch (scratchSpace.DataType) {
        case Int32:
          BIND_SCRATCH_SPACE_INPUT(int32_t)
        case Uint32:
          BIND_SCRATCH_SPACE_INPUT(uint32_t)
        case Float32:
          BIND_SCRATCH_SPACE_INPUT(float_t)
        case UUID:
          BIND_SCRATCH_SPACE_INPUT(UUIDT)
        case GeoPoint:
          BIND_SCRATCH_SPACE_INPUT(GeoPointT)
        default:
          throw std::invalid_argument(
              "Unsupported data type for ScratchSpaceInput");
      }
    } else if (input.Type == ForeignColumnInput) {
      // Note: for now foreign vectors are dimension table columns
      // that are not compressed nor pre sliced
      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;
      int16_t *const timezoneLookup = input.Vector.ForeignVP.TimezoneLookup;
      int16_t timezoneLookupSize = input.Vector.ForeignVP.TimezoneLookupSize;
      DataType dataType = input.Vector.ForeignVP.DataType;
      bool hasDefault = input.Vector.ForeignVP.DefaultValue.HasDefault;
      DefaultValue defaultValueStruct = input.Vector.ForeignVP.DefaultValue;
      uint8_t stepInBytes = getStepInBytes(dataType);

      switch (dataType) {
        #define BIND_FOREIGN_COLUMN_INPUT(defaultValue, dataType) \
          ForeignTableIterator<dataType> *vpIters = \
            prepareForeignTableIterators(numBatches, vpSlices, stepInBytes, \
              hasDefault, defaultValue, context.getStream()); \
          int res = nextBinder.bind(boundInputIterators..., \
                                RecordIDJoinIterator<dataType>( \
                                    recordIDs, numBatches, baseBatchID, \
                                    vpIters, numRecordsInLastBatch, \
                                    timezoneLookup, timezoneLookupSize)); \
          deviceFree(vpIters); \
          return res;

        case Bool: {
          BIND_FOREIGN_COLUMN_INPUT(defaultValueStruct.Value.BoolVal, bool)
        }
        case Int8:
        case Int16:
        case Int32: {
          BIND_FOREIGN_COLUMN_INPUT(
              defaultValueStruct.Value.Int32Val, int32_t)
        }
        case Uint8:
        case Uint16:
        case Uint32: {
          BIND_FOREIGN_COLUMN_INPUT(
              defaultValueStruct.Value.Uint32Val, uint32_t)
        }
        case Float32: {
          BIND_FOREIGN_COLUMN_INPUT(
              defaultValueStruct.Value.FloatVal, float_t)
        }
        default:
          throw std::invalid_argument(
              "Unsupported data type for VectorPartyInput: " +
                  std::to_string(__LINE__));
      }
    }

    VectorPartySlice inputVP = input.Vector.VP;
    bool hasDefault = inputVP.DefaultValue.HasDefault;
    bool isConstant = inputVP.BasePtr == nullptr;
    DefaultValue defaultValue = inputVP.DefaultValue;

    if (isConstant) {
      switch (inputVP.DataType) {
        case Bool:
          BIND_CONSTANT_INPUT(defaultValue.Value.BoolVal, hasDefault)
        case Int8:
        case Int16:
        case Int32:
          BIND_CONSTANT_INPUT(defaultValue.Value.Int32Val, hasDefault)
        case Uint8:
        case Uint16:
        case Uint32:
          BIND_CONSTANT_INPUT(defaultValue.Value.Uint32Val, hasDefault)
        case Float32:
          BIND_CONSTANT_INPUT(defaultValue.Value.FloatVal, hasDefault)
        default:
          throw std::invalid_argument(
              "Unsupported data type for VectorPartyInput: " +
                  std::to_string(__LINE__));
      }
    }

    // Non constant.
    uint8_t *basePtr = inputVP.BasePtr;
    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;
    switch (inputVP.DataType) {
      #define BIND_COLUMN_INPUT(dataType) \
        return nextBinder.bind(boundInputIterators..., \
                               make_column_iterator<dataType>(indexVector, \
                                                          baseCounts, \
                                                          startCount, \
                                                          basePtr, \
                                                          nullsOffset, \
                                                          valuesOffset, \
                                                          length, \
                                                          stepInBytes, \
                                                          startingIndex));
      case Bool:
        BIND_COLUMN_INPUT(bool)
      case Int8:
      case Int16:
      case Int32:
        BIND_COLUMN_INPUT(int32_t)
      case Uint8:
      case Uint16:
      case Uint32:
        BIND_COLUMN_INPUT(uint32_t)
      case Float32:
        BIND_COLUMN_INPUT(float_t)
      default:
        throw std::invalid_argument(
            "Unsupported data type for VectorPartyInput: " +
                std::to_string(__LINE__));
    }
  }