func appendToBldr()

in arrow/scalar/append.go [84:254]
160 lines of code
60 McCabe index (conditional complexity)

func appendToBldr(bldr array.Builder, scalars []Scalar) error {
	if len(scalars) == 0 {
		return nil
	}

	ty := bldr.Type()
	bldr.Reserve(len(scalars))
	switch bldr := bldr.(type) {
	case extbuilder:
		baseScalars := make([]Scalar, len(scalars))
		for i, sc := range scalars {
			baseScalars[i] = sc.(*Extension).Value
		}

		return appendToBldr(bldr.StorageBuilder(), baseScalars)
	case *array.BooleanBuilder:
		appendPrimitive(bldr, scalars)
	case *array.Decimal128Builder:
		appendPrimitive(bldr, scalars)
	case *array.Decimal256Builder:
		appendPrimitive(bldr, scalars)
	case *array.FixedSizeBinaryBuilder:
		for _, sc := range scalars {
			s := sc.(*FixedSizeBinary)
			if s.Valid {
				bldr.UnsafeAppend(s.Value.Bytes())
			} else {
				bldr.UnsafeAppendBoolToBitmap(false)
			}
		}
	case *array.Int8Builder:
		appendPrimitive(bldr, scalars)
	case *array.Uint8Builder:
		appendPrimitive(bldr, scalars)
	case *array.Int16Builder:
		appendPrimitive(bldr, scalars)
	case *array.Uint16Builder:
		appendPrimitive(bldr, scalars)
	case *array.Int32Builder:
		appendPrimitive(bldr, scalars)
	case *array.Uint32Builder:
		appendPrimitive(bldr, scalars)
	case *array.Int64Builder:
		appendPrimitive(bldr, scalars)
	case *array.Uint64Builder:
		appendPrimitive(bldr, scalars)
	case *array.Float16Builder:
		appendPrimitive(bldr, scalars)
	case *array.Float32Builder:
		appendPrimitive(bldr, scalars)
	case *array.Float64Builder:
		appendPrimitive(bldr, scalars)
	case *array.Date32Builder:
		appendPrimitive(bldr, scalars)
	case *array.Date64Builder:
		appendPrimitive(bldr, scalars)
	case *array.Time32Builder:
		appendPrimitive(bldr, scalars)
	case *array.Time64Builder:
		appendPrimitive(bldr, scalars)
	case *array.DayTimeIntervalBuilder:
		appendPrimitive(bldr, scalars)
	case *array.MonthIntervalBuilder:
		appendPrimitive(bldr, scalars)
	case *array.MonthDayNanoIntervalBuilder:
		appendPrimitive(bldr, scalars)
	case *array.DurationBuilder:
		appendPrimitive(bldr, scalars)
	case *array.TimestampBuilder:
		appendPrimitive(bldr, scalars)
	case array.StringLikeBuilder:
		appendBinary(bldr, scalars)
	case *array.BinaryBuilder:
		appendBinary(bldr, scalars)
	case array.ListLikeBuilder:
		var numChildren int
		for _, s := range scalars {
			if !s.IsValid() {
				continue
			}
			numChildren += s.(ListScalar).GetList().Len()
		}
		bldr.ValueBuilder().Reserve(numChildren)

		for _, s := range scalars {
			bldr.Append(s.IsValid())
			if s.IsValid() {
				list := s.(ListScalar).GetList()
				for i := 0; i < list.Len(); i++ {
					sc, err := GetScalar(list, i)
					if err != nil {
						return err
					}
					if err := Append(bldr.ValueBuilder(), sc); err != nil {
						return err
					}
				}
			}
		}
	case *array.StructBuilder:
		for _, sc := range scalars {
			s := sc.(*Struct)
			for i := 0; i < bldr.NumField(); i++ {
				if !s.Valid || s.Value[i] == nil {
					bldr.FieldBuilder(i).UnsafeAppendBoolToBitmap(false)
				} else {
					if err := Append(bldr.FieldBuilder(i), s.Value[i]); err != nil {
						return err
					}
				}
			}
			bldr.UnsafeAppendBoolToBitmap(s.Valid)
		}
	case *array.SparseUnionBuilder:
		ty := ty.(*arrow.SparseUnionType)
		for i := 0; i < bldr.NumChildren(); i++ {
			bldr.Child(i).Reserve(len(scalars))
		}

		for _, s := range scalars {
			// for each scalar
			// 1. append the type code
			// 2. append the value to the corresponding child
			// 3. append null to the other children
			s := s.(*SparseUnion)
			bldr.Append(s.TypeCode)
			for i := range ty.Fields() {
				child := bldr.Child(i)
				if s.ChildID == i {
					if s.Valid {
						if err := Append(child, s.Value[i]); err != nil {
							return err
						}
					} else {
						child.UnsafeAppendBoolToBitmap(false)
					}
				} else {
					child.UnsafeAppendBoolToBitmap(false)
				}
			}
		}
	case *array.DenseUnionBuilder:
		ty := ty.(*arrow.DenseUnionType)
		for i := 0; i < bldr.NumChildren(); i++ {
			bldr.Child(i).Reserve(len(scalars))
		}

		for _, s := range scalars {
			s := s.(*DenseUnion)
			fieldIndex := ty.ChildIDs()[s.TypeCode]
			bldr.Append(s.TypeCode)

			for i := range ty.Fields() {
				child := bldr.Child(i)
				if i == fieldIndex {
					if s.Valid {
						if err := Append(child, s.Value); err != nil {
							return err
						}
					} else {
						child.UnsafeAppendBoolToBitmap(false)
					}
				}
			}
		}
	default:
		return fmt.Errorf("%w: append scalar for type %s", arrow.ErrNotImplemented, ty)
	}

	return nil
}