Revise implementation to support multiple field projection, by names

[github-actions]

Revise implementation to support multiple field projection, by names

and indexes.

https://github.com/apache/incubator-wayang/blob/3fa657bcc8c86198b9532aa06bf27964c3f771be/wayang-commons/wayang-basic/src/main/java/org/apache/wayang/basic/function/ProjectionDescriptor.java#L41

package org.apache.wayang.basic.function;

import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

import org.apache.wayang.basic.data.Record;
import org.apache.wayang.basic.types.RecordType;
import org.apache.wayang.core.function.FunctionDescriptor;
import org.apache.wayang.core.function.TransformationDescriptor;
import org.apache.wayang.core.types.BasicDataUnitType;

/**
 * This descriptor pertains to projections. It takes field names of the input
 * type to describe the projection.
 */
public class ProjectionDescriptor<Input, Output> extends TransformationDescriptor<Input, Output> {

    /**
     * Java implementation of a projection on POJOs via reflection.
     */
    // TODO: Revise implementation to support multiple field projection, by names
    // and indexes.
    private static class PojoImplementation<Input, Output>
            implements FunctionDescriptor.SerializableFunction<Input, Output> {

        private final String fieldName;

        private Field field;

        private PojoImplementation(final String fieldName) {
            this.fieldName = fieldName;
        }

        @Override
        @SuppressWarnings("unchecked")
        public Output apply(final Input input) {
            // Initialization code.
            if (this.field == null) {

40e1e0f9785d58f9ab9731824c00aef5b0a84db7

[alisha-1000]

The current PojoImplementation only supports projection of a single field by name via String fieldName. To support multiple field projection by both names and indexes, the implementation could be generalized as follows:

Proposed Changes

Replace single field storage

Change private final String fieldName;

To something like:

private final List fieldNames;
private final List fieldIndexes;

Cache multiple Field objects

Instead of a single Field, maintain:

private List fields;

Initialize them lazily inside apply() and cache them for reuse.

Support projection by indexes

Retrieve all declared fields:

Field[] allFields = input.getClass().getDeclaredFields();

Map provided indexes to corresponding Field instances.

Optionally normalize indexes → field names internally to unify logic.

Return composite output

When projecting multiple fields, construct and return a Record containing all projected values.

This would align projection behavior with relational semantics.

Result

This change would allow:

Single-field projection (existing behavior)

Multi-field projection by name

Multi-field projection by index

It would also make the descriptor more flexible and consistent with relational-style projection.

Happy to contribute a patch if this approach aligns with the intended design.

[JunWang222]

/assign-me

[JunWang222]

Hi team, I created a PR for this issue:
#710

Plan
Add a new MultiFieldPojoImplementation class following the same pattern as the existing PojoImplementation and RecordImplementation. It takes multiple field names, extracts each field from the input POJO via reflection, and packs the values into a Record.
Expose it through two new factory methods — one for field names, one for indexes — and keep the existing single-field path untouched for backward compatibility. The existing constructor routes automatically: 1 field → old PojoImplementation (returns the raw value, same behavior as before), multiple fields → new MultiFieldPojoImplementation (returns a Record).