/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.pig.test.utils;
import java.io.IOException;
import org.apache.pig.AccumulatorEvalFunc;
import org.apache.pig.AlgebraicEvalFunc;
import org.apache.pig.EvalFunc;
import org.apache.pig.Accumulator;
import org.apache.pig.Algebraic;
import org.apache.pig.builtin.COUNT;
import org.apache.pig.builtin.LongSum;
import org.apache.pig.data.Tuple;
public class HelperEvalFuncUtils {
public static class AlgCOUNT extends AlgFunc<Long> {
public AlgCOUNT() {
super(new COUNT());
}
}
public static class AccCOUNT extends AccFunc<Long> {
public AccCOUNT() {
super(new COUNT());
}
}
public static class BasicCOUNT extends BasicFunc<Long> {
public BasicCOUNT() {
super(new COUNT());
}
}
public static class AlgSUM extends AlgFunc<Long> {
public AlgSUM() {
super(new LongSum());
}
}
public static class AccSUM extends AccFunc<Long> {
public AccSUM() {
super(new LongSum());
}
}
public static class BasicSUM extends BasicFunc<Long> {
public BasicSUM() {
super(new LongSum());
}
}
public static class AlgFunc<T> extends AlgebraicEvalFunc<T> {
Algebraic f;
public AlgFunc(Algebraic f) {
this.f=f;
}
@Override
public String getInitial() {
if (f==null) {
return LongSum.Initial.class.getName();
}
return f.getInitial();
}
@Override
public String getIntermed() {
if (f==null) {
return LongSum.Intermediate.class.getName();
}
return f.getIntermed();
}
@Override
public String getFinal() {
if (f==null) {
return LongSum.Final.class.getName();
}
return f.getFinal();
}
}
public static class AccFunc<T> extends AccumulatorEvalFunc<T> {
Accumulator<T> f;
public AccFunc(Accumulator<T> f) {
this.f=f;
}
@Override
public T getValue() {
return f.getValue();
}
@Override
public void accumulate(Tuple input) throws IOException {
f.accumulate(input);
}
@Override
public void cleanup() {
f.cleanup();
}
}
public static class BasicFunc<T> extends EvalFunc<T> {
EvalFunc<T> f;
public BasicFunc(EvalFunc<T> f) {
this.f=f;
}
@Override
public T exec(Tuple input) throws IOException {
return f.exec(input);
}
}
public static class AccLongCountWithConstructor extends AccFunc<Long> {
public AccLongCountWithConstructor(String mult) {
super(new AlgLongCountWithConstructor(mult));
}
}
public static class BasicLongCountWithConstructor extends BasicFunc<Long> {
public BasicLongCountWithConstructor(String mult) {
super(new AlgLongCountWithConstructor(mult));
}
}
//this exists to make sure that constructors work properly with AlgebraicEvalFunc
public static class AlgLongCountWithConstructor extends AlgebraicEvalFunc<Long> {
//this will inflate the count by the given factor
public AlgLongCountWithConstructor(String mult) {
super(mult);
}
public static class Initial extends COUNT.Initial {
long mult=1;
public Initial() {}
public Initial(String mult) {
this.mult = Long.parseLong(mult);
}
public Tuple exec(Tuple input) throws IOException {
Tuple t = super.exec(input);
t.set(0,((Long)t.get(0))*mult);
return t;
}
}
public static class Intermed extends COUNT.Intermediate {
public Intermed() {}
public Intermed(String mult) {}
}
public static class Final extends COUNT.Final {
public Final() {}
public Final(String mult) {}
}
@Override
public String getInitial() {
return Initial.class.getName();
}
@Override
public String getIntermed() {
return Intermed.class.getName();
}
@Override
public String getFinal() {
return Final.class.getName();
}
}
}