Uso del depurador Java integrado

Java dispone de un depurador de red integrado que puede utilizarse para depurar los EA de Java. Puede utilizarse para ejecutar la versión Java de la prueba de aplicación (la función escalar de Java), que se muestra aquí:

import org.netezza.ae.*;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

public class TestJavaInterface {

    private static final Executor exec =
        Executors.newCachedThreadPool();
    public static final void main(String [] args) {
        try {
            mainImpl(args);
        } catch (Throwable t) {
            System.err.println(t.toString());
            NzaeUtil.logException(t, "main");
        }
    }

    public static final void mainImpl(String [] args) {
       NzaeApiGenerator helper = new NzaeApiGenerator();
 
       while (true) {
           final NzaeApi api = helper.getApi(NzaeApi.FUNCTION,false);
           if (api.apiType == NzaeApi.FUNCTION) {
               if (!helper.isRemote()) {
                   run(api.aeFunction);
                   break;
               } else {
                   Runnable task = new Runnable() {
                           public void run() {
                               try {
                                   TestJavaInterface.run(api.aeFunction);
                               } finally {
                                   api.aeFunction.close();
                               }
                           }
                       };
                   exec.execute(task);

               }
           } 
        }
        helper.close(); 
    }

    public static class MyHandler implements NzaeMessageHandler
    {
        public void evaluate(Nzae ae, NzaeRecord input, NzaeRecord output) {
     
            final NzaeMetadata meta = ae.getMetadata();
 
            int op = 0;
            double result = 0;
 
            if (meta.getOutputColumnCount() != 1 ||
                meta.getOutputNzType(0) != NzaeDataTypes.NZUDSUDX_DOUBLE) {
                throw new NzaeException("expecting one output column of type
double");
            }
            if (meta.getInputColumnCount() < 1) {
                throw new NzaeException("expecting at least one input column");
            }
            if (meta.getInputNzType(0) != NzaeDataTypes.NZUDSUDX_FIXED &&
                meta.getInputNzType(0) != NzaeDataTypes.NZUDSUDX_VARIABLE) {
                throw new NzaeException("first input column expected to be a
string type");
            }

            for (int i = 0; i < input.size(); i++) {
                if (input.getField(i) == null) {
                    continue;
                }
                int dataType = meta.getInputNzType(i);
                if (i == 0) {
                    if (!(dataType == NzaeDataTypes.NZUDSUDX_FIXED
                            || dataType == NzaeDataTypes.NZUDSUDX_VARIABLE)) {
 
                        ae.userError("first column must be a string");
 
                    }
                    String opStr = input.getFieldAsString(0);
                    if (opStr.equals("*")) {
                        result = 1;
                        op = OP_MULT;
                    }
                    else if (opStr.equals("+")) {
                        result = 0;
                        op = OP_ADD;
                    }
                    else {
                        ae.userError("invalid operator = " + opStr);
                    }
                    continue;
                }
                switch (dataType) {
                    case NzaeDataTypes.NZUDSUDX_INT8:
                    case NzaeDataTypes.NZUDSUDX_INT16:
                    case NzaeDataTypes.NZUDSUDX_INT32:
                    case NzaeDataTypes.NZUDSUDX_INT64:
                    case NzaeDataTypes.NZUDSUDX_FLOAT:
                    case NzaeDataTypes.NZUDSUDX_DOUBLE:
                    case NzaeDataTypes.NZUDSUDX_NUMERIC32:
                    case NzaeDataTypes.NZUDSUDX_NUMERIC64:
                    case NzaeDataTypes.NZUDSUDX_NUMERIC128:
                        switch (op) {
                            case OP_ADD:
                                result +=
input.getFieldAsNumber(i).doubleValue();
                                break;
                            case OP_MULT:
                                result *=
input.getFieldAsNumber(i).doubleValue();
                                break;
                            default:
                                break;
                        }
                        break;

                    default:
                        break;
                }
            }  // end of column for loop

            output.setField(0, result); 
        }
    }
    private static final int OP_ADD = 1;
    private static final int OP_MULT = 2;

    public static int run(Nzae ae)
    { 

        ae.run(new MyHandler());
        return 0;
    }
}