COLLECT_SET() in Hive, keep duplicates?

后端 未结 9 1520
离开以前
离开以前 2020-12-12 17:06

Is there a way to keep the duplicates in a collected set in Hive, or simulate the sort of aggregate collection that Hive provides using some other method? I want to aggregat

9条回答
  •  自闭症患者
    2020-12-12 17:49

    Modified Jeff Mc's code to remove the restriction (presumably inherited from collect_set) that input must be primitive types. This version can collect structs, maps and arrays as well as primitives.

    package com.example;
    
    import java.util.ArrayList;
    import org.apache.hadoop.hive.ql.exec.UDFArgumentTypeException;
    import org.apache.hadoop.hive.ql.metadata.HiveException;
    import org.apache.hadoop.hive.ql.parse.SemanticException;
    import org.apache.hadoop.hive.ql.udf.generic.AbstractGenericUDAFResolver;
    import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator;
    import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector;
    import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory;
    import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorUtils;
    import org.apache.hadoop.hive.serde2.objectinspector.StandardListObjectInspector;
    import org.apache.hadoop.hive.serde2.typeinfo.TypeInfo;
    
    public class CollectAll extends AbstractGenericUDAFResolver
    {
        @Override
        public GenericUDAFEvaluator getEvaluator(TypeInfo[] tis)
                throws SemanticException
        {
            if (tis.length != 1)
            {
                throw new UDFArgumentTypeException(tis.length - 1, "Exactly one argument is expected.");
            }
            return new CollectAllEvaluator();
        }
    
        public static class CollectAllEvaluator extends GenericUDAFEvaluator
        {
            private ObjectInspector inputOI;
            private StandardListObjectInspector loi;
            private StandardListObjectInspector internalMergeOI;
    
            @Override
            public ObjectInspector init(Mode m, ObjectInspector[] parameters)
                    throws HiveException
            {
                super.init(m, parameters);
                if (m == Mode.PARTIAL1)
                {
                    inputOI = parameters[0];
                    return ObjectInspectorFactory
                            .getStandardListObjectInspector(ObjectInspectorUtils
                            .getStandardObjectInspector(inputOI));
                }
                else
                {
                    if (!(parameters[0] instanceof StandardListObjectInspector))
                    {
                        inputOI = ObjectInspectorUtils
                                .getStandardObjectInspector(parameters[0]);
                        return (StandardListObjectInspector) ObjectInspectorFactory
                                .getStandardListObjectInspector(inputOI);
                    }
                    else
                    {
                        internalMergeOI = (StandardListObjectInspector) parameters[0];
                        inputOI = internalMergeOI.getListElementObjectInspector();
                        loi = (StandardListObjectInspector) ObjectInspectorUtils.getStandardObjectInspector(internalMergeOI);
                        return loi;
                    }
                }
            }
    
            static class ArrayAggregationBuffer implements AggregationBuffer
            {
                ArrayList container;
            }
    
            @Override
            public void reset(AggregationBuffer ab)
                    throws HiveException
            {
                ((ArrayAggregationBuffer) ab).container = new ArrayList();
            }
    
            @Override
            public AggregationBuffer getNewAggregationBuffer()
                    throws HiveException
            {
                ArrayAggregationBuffer ret = new ArrayAggregationBuffer();
                reset(ret);
                return ret;
            }
    
            @Override
            public void iterate(AggregationBuffer ab, Object[] parameters)
                    throws HiveException
            {
                assert (parameters.length == 1);
                Object p = parameters[0];
                if (p != null)
                {
                    ArrayAggregationBuffer agg = (ArrayAggregationBuffer) ab;
                    agg.container.add(ObjectInspectorUtils.copyToStandardObject(p, this.inputOI));
                }
            }
    
            @Override
            public Object terminatePartial(AggregationBuffer ab)
                    throws HiveException
            {
                ArrayAggregationBuffer agg = (ArrayAggregationBuffer) ab;
                ArrayList ret = new ArrayList(agg.container.size());
                ret.addAll(agg.container);
                return ret;
            }
    
            @Override
            public void merge(AggregationBuffer ab, Object o)
                    throws HiveException
            {
                ArrayAggregationBuffer agg = (ArrayAggregationBuffer) ab;
                ArrayList partial = (ArrayList)internalMergeOI.getList(o);
                for(Object i : partial)
                {
                    agg.container.add(ObjectInspectorUtils.copyToStandardObject(i, this.inputOI));
                }
            }
    
            @Override
            public Object terminate(AggregationBuffer ab)
                    throws HiveException
            {
                ArrayAggregationBuffer agg = (ArrayAggregationBuffer) ab;
                ArrayList ret = new ArrayList(agg.container.size());
                ret.addAll(agg.container);
                return ret;
            }
        }
    }
    
        

    提交回复
    热议问题