Example usage for org.apache.commons.lang SerializationUtils serialize

List of usage examples for org.apache.commons.lang SerializationUtils serialize

Introduction

In this page you can find the example usage for org.apache.commons.lang SerializationUtils serialize.

Prototype

public static byte[] serialize(Serializable obj) 

Source Link

Document

Serializes an Object to a byte array for storage/serialization.

Usage

From source file:com.comphenix.protocol.events.PacketContainerTest.java

@Test
public void testDeepClone() {
    // Try constructing all the packets
    for (PacketType type : PacketType.values()) {
        if (BLACKLISTED.contains(type) || type.isDeprecated()) {
            continue;
        }/*from   w w  w  .j av  a  2s .  co m*/

        // Whether or not this packet has been registered
        boolean registered = type.isSupported();

        try {
            PacketContainer constructed = new PacketContainer(type);

            if (!registered) {
                fail("Expected IllegalArgumentException(Packet " + type + " not registered");
            }

            // Initialize default values
            constructed.getModifier().writeDefaults();

            // Make sure watchable collections can be cloned
            if (type == PacketType.Play.Server.ENTITY_METADATA) {
                constructed.getWatchableCollectionModifier().write(0, Util.asList(
                        new WrappedWatchableObject(new WrappedDataWatcherObject(0, Registry.get(Byte.class)),
                                (byte) 1),
                        new WrappedWatchableObject(new WrappedDataWatcherObject(0, Registry.get(String.class)),
                                "String"),
                        new WrappedWatchableObject(new WrappedDataWatcherObject(0, Registry.get(Float.class)),
                                1.0F)));
            }

            // Clone the packet
            PacketContainer cloned = constructed.deepClone();

            // Make sure they're equivalent
            StructureModifier<Object> firstMod = constructed.getModifier(), secondMod = cloned.getModifier();
            assertEquals(firstMod.size(), secondMod.size());

            if (PacketType.Status.Server.SERVER_INFO.equals(type)) {
                assertArrayEquals(SerializationUtils.serialize(constructed),
                        SerializationUtils.serialize(cloned));
            } else {
                // Make sure all the fields are equivalent
                for (int i = 0; i < firstMod.size(); i++) {
                    if (firstMod.getField(i).getType().isArray())
                        assertArrayEquals(getArray(firstMod.read(i)), getArray(secondMod.read(i)));
                    else
                        testEquality(firstMod.read(i), secondMod.read(i));
                }
            }
        } catch (IllegalArgumentException e) {
            if (!registered) {
                e.printStackTrace();
            } else {
                // Something is very wrong
                throw e;
            }
        } catch (RuntimeException e) {
            throw new RuntimeException("Failed to serialize packet " + type, e);
        }
    }
}

From source file:fr.inria.oak.paxquery.translation.Logical2Pact.java

private static final Operator<Record>[] translate(Join j) {
    Operator<Record>[] childPlan1 = translate(j.getLeft());
    Operator<Record>[] childPlan2 = translate(j.getRight());

    Operator<Record>[] join;/*from w w w.j a  v a2 s .com*/

    if (!j.getPred().isOnlyEqui()) { //THETA INNER JOIN
        // create CrossOperator for theta join
        join = new Operator[] { CrossOperator.builder(ThetaJoinOperator.class).input1(childPlan1)
                .input2(childPlan2).name("JoinEval").build() };

        //  for theta join configuration
        final String encodedNRSMD1 = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(j.getLeft().getNRSMD()));
        join[0].setParameter(PACTOperatorsConfiguration.NRSMD1_BINARY.toString(), encodedNRSMD1);
        final String encodedNRSMD2 = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(j.getRight().getNRSMD()));
        join[0].setParameter(PACTOperatorsConfiguration.NRSMD2_BINARY.toString(), encodedNRSMD2);
        final String encodedPredicate = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(j.getPred()));
        join[0].setParameter(PACTOperatorsConfiguration.PRED_BINARY.toString(), encodedPredicate);
    } else if (j.getPred() instanceof DisjunctivePredicate
            && ((DisjunctivePredicate) j.getPred()).getConjunctivePreds().size() != 1) { //DISJ INNER JOIN
        // create CoGroup contracts for disjunctive equi join
        DisjunctivePredicate disjPred = (DisjunctivePredicate) j.getPred();
        final int[][] leftColumns = j.getPred().getLeftColumns();
        final int[][] rightColumns = j.getPred().getRightColumns();

        //Parameters that will be used later for configuring each contract
        final String encodedNRSMD1 = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(j.getLeft().getNRSMD()));
        final String encodedNRSMD2 = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(j.getRight().getNRSMD()));
        final String encodedPredicate = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(disjPred));

        final NestedMetadata leftNRSMD = j.getLeft().getNRSMD();

        //We create the join with the number of contracts needed for evaluation
        join = new Operator[disjPred.getConjunctivePreds().size()];
        for (int i = 0; i < join.length; i++) {
            JoinOperator.Builder conjEquiJoinBuilder = JoinOperator.builder(DisjEquiJoinOperator.class,
                    MetadataTypesMapping.getKeyClass(leftNRSMD.getType(leftColumns[i][0])), leftColumns[i][0],
                    rightColumns[i][0] - leftNRSMD.getColNo());
            conjEquiJoinBuilder.input1(childPlan1).input2(childPlan2).name("JoinEval(" + i + ")");

            for (int k = 1; k < leftColumns[i].length; k++)
                KeyFactoryOperations.addKey(conjEquiJoinBuilder,
                        MetadataTypesMapping.getKeyClass(leftNRSMD.getType(leftColumns[i][k])),
                        leftColumns[i][k], rightColumns[i][k] - leftNRSMD.getColNo());

            join[i] = conjEquiJoinBuilder.build();
            // join configuration
            join[i].setParameter(PACTOperatorsConfiguration.NRSMD1_BINARY.toString(), encodedNRSMD1);
            join[i].setParameter(PACTOperatorsConfiguration.NRSMD2_BINARY.toString(), encodedNRSMD2);
            join[i].setParameter(PACTOperatorsConfiguration.PRED_BINARY.toString(), encodedPredicate);
            join[i].setParameter(PACTOperatorsConfiguration.PRED_INT.toString(), i);
        }
    } else { //CONJ INNER JOIN
        // create JoinOperator for conjunctive equi join
        final int[] leftColumns = j.getPred().getLeftColumns()[0];
        final int[] rightColumns = j.getPred().getRightColumns()[0];

        final NestedMetadata leftNRSMD = j.getLeft().getNRSMD();

        JoinOperator.Builder conjEquiJoinBuilder = JoinOperator.builder(ConjEquiJoinOperator.class,
                MetadataTypesMapping.getKeyClass(leftNRSMD.getType(leftColumns[0])), leftColumns[0],
                rightColumns[0] - leftNRSMD.getColNo());
        conjEquiJoinBuilder.input1(childPlan1).input2(childPlan2).name("JoinConcat");

        for (int i = 1; i < leftColumns.length; i++)
            KeyFactoryOperations.addKey(conjEquiJoinBuilder,
                    MetadataTypesMapping.getKeyClass(leftNRSMD.getType(leftColumns[i])), leftColumns[i],
                    rightColumns[i] - leftNRSMD.getColNo());

        join = new Operator[] { conjEquiJoinBuilder.build() };
        // for equi join configuration
        final String encodedNRSMD1 = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(j.getLeft().getNRSMD()));
        join[0].setParameter(PACTOperatorsConfiguration.NRSMD1_BINARY.toString(), encodedNRSMD1);
        final String encodedNRSMD2 = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(j.getRight().getNRSMD()));
        join[0].setParameter(PACTOperatorsConfiguration.NRSMD2_BINARY.toString(), encodedNRSMD2);
    }

    return join;
}

From source file:edu.mayo.cts2.framework.plugin.service.bioportal.rest.BioportalRestService.java

/**
 * Write update log.//  w ww . j  a v  a 2  s .  c  o  m
 *
 * @param lastUpdate the last update
 */
private void writeUpdateLog(Date lastUpdate) {
    log.info("Writing update log");

    File file = this.getUpdateLogFile();

    try {
        if (!file.exists()) {
            log.info("Creating new update log file at: " + file.getPath());
            file.getParentFile().mkdirs();
            file.createNewFile();
        }

        byte[] data = SerializationUtils.serialize(lastUpdate);
        FileUtils.writeByteArrayToFile(file, data);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

From source file:io.hops.tensorflow.Client.java

private Map<String, LocalResource> prepareLocalResources(FileSystem fs, ApplicationId appId,
        DistributedCacheList dcl) throws IOException {
    // set local resources for the application master
    // local files or archives as needed
    // In this scenario, the jar file for the application master is part of the local resources
    Map<String, LocalResource> localResources = new HashMap<>();

    // Copy the application master jar to the filesystem
    // Create a local resource to point to the destination jar path
    addResource(fs, appId, amJar, null, Constants.AM_JAR_PATH, null, localResources, null);

    if (!log4jPropFile.isEmpty()) {
        addResource(fs, appId, log4jPropFile, null, Constants.LOG4J_PATH, null, localResources, null);
    }// w  ww  .ja  v  a 2s .co m

    // Write distCacheList to HDFS and add to localResources
    Path baseDir = new Path(fs.getHomeDirectory(), Constants.YARNTF_STAGING + "/" + appId.toString());
    Path dclPath = new Path(baseDir, Constants.DIST_CACHE_PATH);
    FSDataOutputStream ostream = null;
    try {
        ostream = fs.create(dclPath);
        ostream.write(SerializationUtils.serialize(dcl));
    } finally {
        IOUtils.closeQuietly(ostream);
    }
    FileStatus dclStatus = fs.getFileStatus(dclPath);
    LocalResource distCacheResource = LocalResource.newInstance(
            ConverterUtils.getYarnUrlFromURI(dclPath.toUri()), LocalResourceType.FILE,
            LocalResourceVisibility.APPLICATION, dclStatus.getLen(), dclStatus.getModificationTime());
    localResources.put(Constants.DIST_CACHE_PATH, distCacheResource);

    return localResources;
}

From source file:fr.inria.oak.paxquery.translation.Logical2Pact.java

private static final Operator<Record>[] translate(LeftOuterJoin loj) {
    Operator<Record>[] childPlan1 = translate(loj.getLeft());
    Operator<Record>[] childPlan2 = translate(loj.getRight());

    Operator<Record>[] conjLeftOuterJoin;

    if (!loj.getPred().isOnlyEqui()) { // THETA
        // 1) create CrossOperator for join processing
        CrossOperator thetaJoin = CrossOperator.builder(ThetaLOJoinOperator.class).input1(childPlan1)
                .input2(childPlan2).name("LOJoinEval").build();

        // theta join configuration
        final String encodedNRSMD1 = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(loj.getLeft().getNRSMD()));
        thetaJoin.setParameter(PACTOperatorsConfiguration.NRSMD1_BINARY.toString(), encodedNRSMD1);
        final String encodedNRSMD2 = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(loj.getRight().getNRSMD()));
        thetaJoin.setParameter(PACTOperatorsConfiguration.NRSMD2_BINARY.toString(), encodedNRSMD2);

        final String encodedPredicate = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(loj.getPred()));
        thetaJoin.setParameter(PACTOperatorsConfiguration.PRED_BINARY.toString(), encodedPredicate);

        // 2) create ReduceOperator for post join processing
        ReduceOperator.Builder postJoinBuilder = ReduceOperator.builder(PostLOJoinOperator.class)
                .input(thetaJoin).name("PostLOJoin");
        //Document ID column
        KeyFactoryOperations.addKey(postJoinBuilder,
                MetadataTypesMapping.getKeyClass(loj.getLeft().getNRSMD().getType(loj.getDocumentIDColumn())),
                loj.getDocumentIDColumn());
        //Node ID columns
        for (int index : loj.getNodeIDColumns()) {
            KeyFactoryOperations.addKey(postJoinBuilder,
                    MetadataTypesMapping.getKeyClass(loj.getLeft().getNRSMD().getType(index)), index);
        }/*  w  w w  . j a va  2s  . c om*/
        ReduceOperator postJoin = postJoinBuilder.build();

        // postJoin configuration
        // we create the definitive NRSMD
        final NestedMetadata nrsmdPostJoin = loj.getNRSMD();
        final String encodedNRSMDPostJoin = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(nrsmdPostJoin));
        postJoin.setParameter(PACTOperatorsConfiguration.NRSMD1_BINARY.toString(), encodedNRSMDPostJoin);
        postJoin.setParameter(PACTOperatorsConfiguration.NESTED_RECORDS_COLUMN_INT.toString(),
                loj.getLeft().getNRSMD().getColNo());
        postJoin.setParameter(PACTOperatorsConfiguration.EVALUATION_COLUMN_INT.toString(),
                loj.getNRSMD().getColNo());

        conjLeftOuterJoin = new Operator[] { postJoin };
    } else if (loj.getPred() instanceof DisjunctivePredicate
            && ((DisjunctivePredicate) loj.getPred()).getConjunctivePreds().size() != 1) { // DISJ EQUI                  
        // 1) create CoGroup contracts for join processing
        // create CoGroup contracts for disjunctive equi join
        DisjunctivePredicate disjPred = (DisjunctivePredicate) loj.getPred();
        final int[][] leftColumns = loj.getPred().getLeftColumns();
        final int[][] rightColumns = loj.getPred().getRightColumns();

        //Parameters that will be used later for configuring each contract         
        final String encodedNRSMD1 = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(loj.getLeft().getNRSMD()));
        final String encodedNRSMD2 = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(loj.getRight().getNRSMD()));
        final String encodedPredicate = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(disjPred));

        //We create the join with the number of contracts needed for evaluation
        Operator[] disjJoin = new Operator[disjPred.getConjunctivePreds().size()];
        for (int i = 0; i < disjJoin.length; i++) {
            CoGroupOperator.Builder conjEquiJoinBuilder = CoGroupOperator.builder(DisjLOEquiJoinOperator.class,
                    MetadataTypesMapping.getKeyClass(loj.getLeft().getNRSMD().getType(leftColumns[i][0])),
                    leftColumns[i][0], rightColumns[i][0] - loj.getLeft().getNRSMD().getColNo());
            conjEquiJoinBuilder.input1(childPlan1).input2(childPlan2).name("LOJoinEval(" + i + ")");

            for (int k = 1; k < leftColumns[i].length; k++)
                KeyFactoryOperations.addKey(conjEquiJoinBuilder,
                        MetadataTypesMapping.getKeyClass(loj.getLeft().getNRSMD().getType(leftColumns[i][k])),
                        leftColumns[i][k], rightColumns[i][k] - loj.getLeft().getNRSMD().getColNo());

            disjJoin[i] = conjEquiJoinBuilder.build();
            // join configuration
            disjJoin[i].setParameter(PACTOperatorsConfiguration.NRSMD1_BINARY.toString(), encodedNRSMD1);
            disjJoin[i].setParameter(PACTOperatorsConfiguration.NRSMD2_BINARY.toString(), encodedNRSMD2);
            disjJoin[i].setParameter(PACTOperatorsConfiguration.PRED_BINARY.toString(), encodedPredicate);
            disjJoin[i].setParameter(PACTOperatorsConfiguration.PRED_INT.toString(), i);
        }

        // 2) create ReduceOperator for post join processing
        ReduceOperator.Builder postJoinBuilder = ReduceOperator.builder(PostLOJoinOperator.class)
                .input(disjJoin).name("PostLOJoin");
        //Document ID column
        KeyFactoryOperations.addKey(postJoinBuilder,
                MetadataTypesMapping.getKeyClass(loj.getLeft().getNRSMD().getType(loj.getDocumentIDColumn())),
                loj.getDocumentIDColumn());
        //Node ID columns
        for (int index : loj.getNodeIDColumns()) {
            KeyFactoryOperations.addKey(postJoinBuilder,
                    MetadataTypesMapping.getKeyClass(loj.getLeft().getNRSMD().getType(index)), index);
        }
        ReduceOperator postJoin = postJoinBuilder.build();

        // postJoin configuration
        // we create the definitive NRSMD
        final NestedMetadata nrsmdPostJoin = loj.getNRSMD();
        final String encodedNRSMDPostJoin = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(nrsmdPostJoin));
        postJoin.setParameter(PACTOperatorsConfiguration.NRSMD1_BINARY.toString(), encodedNRSMDPostJoin);
        postJoin.setParameter(PACTOperatorsConfiguration.NESTED_RECORDS_COLUMN_INT.toString(),
                loj.getLeft().getNRSMD().getColNo());
        postJoin.setParameter(PACTOperatorsConfiguration.EVALUATION_COLUMN_INT.toString(),
                loj.getNRSMD().getColNo());

        conjLeftOuterJoin = new Operator[] { postJoin };
    } else { // CONJ EQUI
        // create JoinOperator for conjunctive equi join
        final int[] leftColumns = loj.getPred().getLeftColumns()[0];
        final int[] rightColumns = loj.getPred().getRightColumns()[0];

        final NestedMetadata leftNRSMD = loj.getLeft().getNRSMD();

        CoGroupOperator.Builder conjLeftOuterEquiJoinBuilder = CoGroupOperator.builder(
                ConjLOEquiJoinOperator.class,
                MetadataTypesMapping.getKeyClass(leftNRSMD.getType(leftColumns[0])), leftColumns[0],
                rightColumns[0] - leftNRSMD.getColNo());
        conjLeftOuterEquiJoinBuilder.input1(childPlan1).input2(childPlan2).name("LOJoinConcat");

        for (int i = 1; i < leftColumns.length; i++)
            KeyFactoryOperations.addKey(conjLeftOuterEquiJoinBuilder,
                    MetadataTypesMapping.getKeyClass(leftNRSMD.getType(leftColumns[i])), leftColumns[i],
                    rightColumns[i] - leftNRSMD.getColNo());

        conjLeftOuterJoin = new Operator[] { conjLeftOuterEquiJoinBuilder.build() };
        // for equi join configuration
        final String encodedNRSMD1 = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(loj.getLeft().getNRSMD()));
        conjLeftOuterJoin[0].setParameter(PACTOperatorsConfiguration.NRSMD1_BINARY.toString(), encodedNRSMD1);
        final String encodedNRSMD2 = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(loj.getRight().getNRSMD()));
        conjLeftOuterJoin[0].setParameter(PACTOperatorsConfiguration.NRSMD2_BINARY.toString(), encodedNRSMD2);
    }

    return conjLeftOuterJoin;
}

From source file:at.gv.egovernment.moa.id.storage.AuthenticationSessionStoreage.java

private static void encryptSession(AuthenticationSession session, AuthenticatedSessionStore dbsession)
        throws BuildException {
    byte[] serialized = SerializationUtils.serialize(session);

    EncryptedData encdata = SessionEncrytionUtil.getInstance().encrypt(serialized);
    dbsession.setSession(encdata.getEncData());
    dbsession.setIv(encdata.getIv());/*from  w w  w.j ava 2  s  . c  o  m*/
}

From source file:com.baidu.rigel.biplatform.tesseract.isservice.index.service.impl.IndexMetaServiceImpl.java

public void saveIndexMetaImage(Node node) {
    LOGGER.info(String.format(LogInfoConstants.INFO_PATTERN_FUNCTION_BEGIN, "saveNodeImage",
            "[node:" + node + "]"));
    if (node == null || StringUtils.isEmpty(node.getClusterName())) {
        LOGGER.info(String.format(LogInfoConstants.INFO_PATTERN_FUNCTION_EXCEPTION, "saveNodeImage",
                "[node:" + node + "]"));
        throw new IllegalArgumentException();
    }/*from w  w w.j a  v  a 2  s . co  m*/
    FileUtils.write(node.getImageFilePath(), SerializationUtils.serialize(node), true);
    LOGGER.info(
            String.format(LogInfoConstants.INFO_PATTERN_FUNCTION_END, "saveNodeImage", "[node:" + node + "]"));
}

From source file:com.splicemachine.derby.utils.SpliceAdmin.java

public static void GET_ACTIVATION(final String statement, final ResultSet[] resultSet)
        throws SQLException, StandardException {
    LanguageConnectionContext lcc = ConnectionUtil.getCurrentLCC();
    GenericPreparedStatement gps = (GenericPreparedStatement) lcc.prepareInternalStatement(statement);
    GenericActivationHolder activationHolder = (GenericActivationHolder) gps.getActivation(lcc, false);
    Activation activation = activationHolder.ac;
    ActivationHolder ah = new ActivationHolder(activation, null);
    byte[] activationHolderBytes = SerializationUtils.serialize(ah);
    DataValueDescriptor[] dvds = new DataValueDescriptor[] { new SQLBlob() };
    int numCols = dvds.length;
    ExecRow dataTemplate = new ValueRow(numCols);
    dataTemplate.setRowArray(dvds);/* ww  w  . java2s .c o m*/

    List<ExecRow> rows = Lists.newArrayList();
    dvds[0].setValue(activationHolderBytes);
    rows.add(dataTemplate);

    // Describe the format of the output rows (ResultSet).
    ResultColumnDescriptor[] columnInfo = new ResultColumnDescriptor[numCols];
    columnInfo[0] = new GenericColumnDescriptor("ACTIVATION",
            DataTypeDescriptor.getBuiltInDataTypeDescriptor(Types.BLOB));
    EmbedConnection defaultConn = (EmbedConnection) getDefaultConn();
    Activation lastActivation = defaultConn.getLanguageConnection().getLastActivation();
    IteratorNoPutResultSet resultsToWrap = new IteratorNoPutResultSet(rows, columnInfo, lastActivation);
    resultsToWrap.openCore();
    EmbedResultSet ers = new EmbedResultSet40(defaultConn, resultsToWrap, false, null, true);

    resultSet[0] = ers;
}

From source file:fr.inria.oak.paxquery.translation.Logical2Pact.java

private static final Operator<Record>[] translate(LeftOuterNestedJoin lonj) {
    final boolean withAggregation = lonj instanceof LeftOuterNestedJoinWithAggregation;

    Operator<Record>[] childPlan1 = translate(lonj.getLeft());
    Operator<Record>[] childPlan2 = translate(lonj.getRight());

    Operator<Record>[] conjLeftOuterNestedJoin;

    if (!lonj.getPred().isOnlyEqui()) { // THETA
        // 1) create CrossOperator for join processing
        CrossOperator thetaJoin;// w  ww  . j  a v  a  2  s.  c o  m
        if (withAggregation)
            thetaJoin = CrossOperator.builder(ThetaLNOJoinWithAggregationOperator.class).input1(childPlan1)
                    .input2(childPlan2).name("LNOJoinEvalAgg").build();
        else
            thetaJoin = CrossOperator.builder(ThetaLNOJoinOperator.class).input1(childPlan1).input2(childPlan2)
                    .name("LNOJoinEval").build();

        // theta join configuration
        final String encodedNRSMD1 = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(lonj.getLeft().getNRSMD()));
        thetaJoin.setParameter(PACTOperatorsConfiguration.NRSMD1_BINARY.toString(), encodedNRSMD1);
        final String encodedNRSMD2 = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(lonj.getRight().getNRSMD()));
        thetaJoin.setParameter(PACTOperatorsConfiguration.NRSMD2_BINARY.toString(), encodedNRSMD2);
        final String encodedPredicate = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(lonj.getPred()));
        thetaJoin.setParameter(PACTOperatorsConfiguration.PRED_BINARY.toString(), encodedPredicate);
        if (withAggregation) {
            LeftOuterNestedJoinWithAggregation lonja = (LeftOuterNestedJoinWithAggregation) lonj;

            thetaJoin.setParameter(PACTOperatorsConfiguration.AGGREGATION_COLUMN_INT.toString(),
                    lonja.getAggregationColumn() - lonja.getLeft().getNRSMD().getColNo());

            final String encodedAggregationType = DatatypeConverter
                    .printBase64Binary(SerializationUtils.serialize(lonja.getAggregationType()));
            thetaJoin.setParameter(PACTOperatorsConfiguration.AGGREGATION_TYPE_BINARY.toString(),
                    encodedAggregationType);

            thetaJoin.setParameter(PACTOperatorsConfiguration.EXCLUDE_NESTED_FIELD_BOOLEAN.toString(),
                    lonja.isExcludeNestedField());
        }

        // 2) create ReduceOperator for post join processing
        ReduceOperator.Builder postJoinBuilder;
        if (withAggregation)
            postJoinBuilder = ReduceOperator.builder(PostLNOJoinWithAggregationOperator.class).input(thetaJoin)
                    .name("PostLNOJoinAgg");
        else
            postJoinBuilder = ReduceOperator.builder(PostLNOJoinOperator.class).input(thetaJoin)
                    .name("PostLNOJoin");
        //Document ID column
        KeyFactoryOperations.addKey(postJoinBuilder,
                MetadataTypesMapping.getKeyClass(lonj.getLeft().getNRSMD().getType(lonj.getDocumentIDColumn())),
                lonj.getDocumentIDColumn());
        //Node ID columns
        for (int index : lonj.getNodeIDColumns()) {
            KeyFactoryOperations.addKey(postJoinBuilder,
                    MetadataTypesMapping.getKeyClass(lonj.getLeft().getNRSMD().getType(index)), index);
        }
        ReduceOperator postJoin = postJoinBuilder.build();

        // postJoin configuration
        // we create the definitive NRSMD
        final NestedMetadata nrsmdPostJoin = lonj.getNRSMD();
        final String encodedNRSMDPostJoin = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(nrsmdPostJoin));
        postJoin.setParameter(PACTOperatorsConfiguration.NRSMD1_BINARY.toString(), encodedNRSMDPostJoin);
        if (withAggregation) {
            LeftOuterNestedJoinWithAggregation lonja = (LeftOuterNestedJoinWithAggregation) lonj;

            if (lonja.isExcludeNestedField())
                postJoin.setParameter(PACTOperatorsConfiguration.COMBINATION_COLUMN_INT.toString(),
                        lonj.getLeft().getNRSMD().getColNo());
            else {
                postJoin.setParameter(PACTOperatorsConfiguration.NESTED_RECORDS_COLUMN_INT.toString(),
                        lonj.getLeft().getNRSMD().getColNo());
                postJoin.setParameter(PACTOperatorsConfiguration.EVALUATION_COLUMN_INT.toString(),
                        lonj.getLeft().getNRSMD().getColNo() + 1);
                postJoin.setParameter(PACTOperatorsConfiguration.COMBINATION_COLUMN_INT.toString(),
                        lonj.getLeft().getNRSMD().getColNo() + 2);
            }

            final String encodedAggregationType = DatatypeConverter
                    .printBase64Binary(SerializationUtils.serialize(lonja.getAggregationType()));
            postJoin.setParameter(PACTOperatorsConfiguration.AGGREGATION_TYPE_BINARY.toString(),
                    encodedAggregationType);

            postJoin.setParameter(PACTOperatorsConfiguration.EXCLUDE_NESTED_FIELD_BOOLEAN.toString(),
                    lonja.isExcludeNestedField());
        } else {
            postJoin.setParameter(PACTOperatorsConfiguration.NESTED_RECORDS_COLUMN_INT.toString(),
                    lonj.getLeft().getNRSMD().getColNo());
            postJoin.setParameter(PACTOperatorsConfiguration.EVALUATION_COLUMN_INT.toString(),
                    lonj.getLeft().getNRSMD().getColNo() + 1);
        }

        conjLeftOuterNestedJoin = new Operator[] { postJoin };
    } else if (lonj.getPred() instanceof DisjunctivePredicate
            && ((DisjunctivePredicate) lonj.getPred()).getConjunctivePreds().size() != 1) { // DISJ EQUI                  
        // 1) create CoGroup contracts for join processing
        // create CoGroup contracts for disjunctive equi join
        DisjunctivePredicate disjPred = (DisjunctivePredicate) lonj.getPred();
        final int[][] leftColumns = lonj.getPred().getLeftColumns();
        final int[][] rightColumns = lonj.getPred().getRightColumns();

        //Parameters that will be used later for configuring each contract
        final String encodedNRSMD1 = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(lonj.getLeft().getNRSMD()));
        final String encodedNRSMD2 = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(lonj.getRight().getNRSMD()));
        final String encodedPredicate = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(disjPred));

        //We create the join with the number of contracts needed for evaluation
        Operator[] disjJoin = new Operator[disjPred.getConjunctivePreds().size()];
        for (int i = 0; i < disjJoin.length; i++) {
            CoGroupOperator.Builder conjEquiJoinBuilder;
            if (withAggregation) {
                conjEquiJoinBuilder = CoGroupOperator.builder(DisjLNOEquiJoinWithAggregationOperator.class,
                        MetadataTypesMapping.getKeyClass(lonj.getLeft().getNRSMD().getType(leftColumns[i][0])),
                        leftColumns[i][0], rightColumns[i][0] - lonj.getLeft().getNRSMD().getColNo());
                conjEquiJoinBuilder.input1(childPlan1).input2(childPlan2).name("LNOJoinEvalAgg(" + i + ")");
            } else {
                conjEquiJoinBuilder = CoGroupOperator.builder(DisjLNOEquiJoinOperator.class,
                        MetadataTypesMapping.getKeyClass(lonj.getLeft().getNRSMD().getType(leftColumns[i][0])),
                        leftColumns[i][0], rightColumns[i][0] - lonj.getLeft().getNRSMD().getColNo());
                conjEquiJoinBuilder.input1(childPlan1).input2(childPlan2).name("LNOJoinEval(" + i + ")");
            }

            for (int k = 1; k < leftColumns[i].length; k++)
                KeyFactoryOperations.addKey(conjEquiJoinBuilder,
                        MetadataTypesMapping.getKeyClass(lonj.getLeft().getNRSMD().getType(leftColumns[i][k])),
                        leftColumns[i][k], rightColumns[i][k] - lonj.getLeft().getNRSMD().getColNo());

            disjJoin[i] = conjEquiJoinBuilder.build();
            // join configuration
            disjJoin[i].setParameter(PACTOperatorsConfiguration.NRSMD1_BINARY.toString(), encodedNRSMD1);
            disjJoin[i].setParameter(PACTOperatorsConfiguration.NRSMD2_BINARY.toString(), encodedNRSMD2);
            disjJoin[i].setParameter(PACTOperatorsConfiguration.PRED_BINARY.toString(), encodedPredicate);
            disjJoin[i].setParameter(PACTOperatorsConfiguration.PRED_INT.toString(), i);
            if (withAggregation) {
                LeftOuterNestedJoinWithAggregation lonja = (LeftOuterNestedJoinWithAggregation) lonj;

                disjJoin[i].setParameter(PACTOperatorsConfiguration.AGGREGATION_COLUMN_INT.toString(),
                        lonja.getAggregationColumn() - lonja.getLeft().getNRSMD().getColNo());

                final String encodedAggregationType = DatatypeConverter
                        .printBase64Binary(SerializationUtils.serialize(lonja.getAggregationType()));
                disjJoin[i].setParameter(PACTOperatorsConfiguration.AGGREGATION_TYPE_BINARY.toString(),
                        encodedAggregationType);

                disjJoin[i].setParameter(PACTOperatorsConfiguration.EXCLUDE_NESTED_FIELD_BOOLEAN.toString(),
                        lonja.isExcludeNestedField());
            }
        }

        // 2) create ReduceOperator for post join processing
        ReduceOperator.Builder postJoinBuilder;
        if (withAggregation)
            postJoinBuilder = ReduceOperator.builder(PostLNOJoinWithAggregationOperator.class).input(disjJoin)
                    .name("PostLNOJoinAgg");
        else
            postJoinBuilder = ReduceOperator.builder(PostLNOJoinOperator.class).input(disjJoin)
                    .name("PostLNOJoin");

        //Document ID column
        KeyFactoryOperations.addKey(postJoinBuilder,
                MetadataTypesMapping.getKeyClass(lonj.getLeft().getNRSMD().getType(lonj.getDocumentIDColumn())),
                lonj.getDocumentIDColumn());
        //Node ID column
        for (int index : lonj.getNodeIDColumns()) {
            KeyFactoryOperations.addKey(postJoinBuilder,
                    MetadataTypesMapping.getKeyClass(lonj.getLeft().getNRSMD().getType(index)), index);
        }
        ReduceOperator postJoin = postJoinBuilder.build();

        // postJoin configuration
        // we create the definitive NRSMD
        final NestedMetadata nrsmdPostJoin = lonj.getNRSMD();
        final String encodedNRSMDPostJoin = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(nrsmdPostJoin));
        postJoin.setParameter(PACTOperatorsConfiguration.NRSMD1_BINARY.toString(), encodedNRSMDPostJoin);
        if (withAggregation) {
            LeftOuterNestedJoinWithAggregation lonja = (LeftOuterNestedJoinWithAggregation) lonj;

            if (lonja.isExcludeNestedField())
                postJoin.setParameter(PACTOperatorsConfiguration.COMBINATION_COLUMN_INT.toString(),
                        lonj.getLeft().getNRSMD().getColNo());
            else {
                postJoin.setParameter(PACTOperatorsConfiguration.NESTED_RECORDS_COLUMN_INT.toString(),
                        lonj.getLeft().getNRSMD().getColNo());
                postJoin.setParameter(PACTOperatorsConfiguration.EVALUATION_COLUMN_INT.toString(),
                        lonj.getLeft().getNRSMD().getColNo() + 1);
                postJoin.setParameter(PACTOperatorsConfiguration.COMBINATION_COLUMN_INT.toString(),
                        lonj.getLeft().getNRSMD().getColNo() + 2);
            }

            final String encodedAggregationType = DatatypeConverter
                    .printBase64Binary(SerializationUtils.serialize(lonja.getAggregationType()));
            postJoin.setParameter(PACTOperatorsConfiguration.AGGREGATION_TYPE_BINARY.toString(),
                    encodedAggregationType);

            postJoin.setParameter(PACTOperatorsConfiguration.EXCLUDE_NESTED_FIELD_BOOLEAN.toString(),
                    lonja.isExcludeNestedField());
        } else {
            postJoin.setParameter(PACTOperatorsConfiguration.NESTED_RECORDS_COLUMN_INT.toString(),
                    lonj.getLeft().getNRSMD().getColNo());
            postJoin.setParameter(PACTOperatorsConfiguration.EVALUATION_COLUMN_INT.toString(),
                    lonj.getLeft().getNRSMD().getColNo() + 1);
        }

        conjLeftOuterNestedJoin = new Operator[] { postJoin };
    } else { // CONJ EQUI
        // create JoinOperator for conjunctive equi join
        int[] leftColumns = lonj.getPred().getLeftColumns()[0];
        int[] rightColumns = lonj.getPred().getRightColumns()[0];

        CoGroupOperator.Builder conjLeftOuterNestedEquiJoinBuilder;
        if (withAggregation)
            conjLeftOuterNestedEquiJoinBuilder = CoGroupOperator
                    .builder(ConjLNOEquiJoinWithAggregationOperator.class,
                            MetadataTypesMapping.getKeyClass(lonj.getLeft().getNRSMD().getType(leftColumns[0])),
                            leftColumns[0], rightColumns[0] - lonj.getLeft().getNRSMD().getColNo())
                    .input1(childPlan1).input2(childPlan2).name("LNOJoinConcatAgg");
        else
            conjLeftOuterNestedEquiJoinBuilder = CoGroupOperator
                    .builder(ConjLNOEquiJoinOperator.class,
                            MetadataTypesMapping.getKeyClass(lonj.getLeft().getNRSMD().getType(leftColumns[0])),
                            leftColumns[0], rightColumns[0] - lonj.getLeft().getNRSMD().getColNo())
                    .input1(childPlan1).input2(childPlan2).name("LNOJoinConcat");

        for (int i = 1; i < leftColumns.length; i++)
            KeyFactoryOperations.addKey(conjLeftOuterNestedEquiJoinBuilder,
                    MetadataTypesMapping.getKeyClass(lonj.getLeft().getNRSMD().getType(leftColumns[i])),
                    leftColumns[i], rightColumns[i] - lonj.getLeft().getNRSMD().getColNo());
        conjLeftOuterNestedJoin = new Operator[] { conjLeftOuterNestedEquiJoinBuilder.build() };

        // for equi join configuration
        final String encodedNRSMD1 = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(lonj.getLeft().getNRSMD()));
        conjLeftOuterNestedJoin[0].setParameter(PACTOperatorsConfiguration.NRSMD1_BINARY.toString(),
                encodedNRSMD1);
        final String encodedNRSMD2 = DatatypeConverter
                .printBase64Binary(SerializationUtils.serialize(lonj.getRight().getNRSMD()));
        conjLeftOuterNestedJoin[0].setParameter(PACTOperatorsConfiguration.NRSMD2_BINARY.toString(),
                encodedNRSMD2);
        if (withAggregation) {
            LeftOuterNestedJoinWithAggregation lonja = (LeftOuterNestedJoinWithAggregation) lonj;

            conjLeftOuterNestedJoin[0].setParameter(
                    PACTOperatorsConfiguration.AGGREGATION_COLUMN_INT.toString(),
                    lonja.getAggregationColumn() - lonja.getLeft().getNRSMD().getColNo());

            final String encodedAggregationType = DatatypeConverter
                    .printBase64Binary(SerializationUtils.serialize(lonja.getAggregationType()));
            conjLeftOuterNestedJoin[0].setParameter(
                    PACTOperatorsConfiguration.AGGREGATION_TYPE_BINARY.toString(), encodedAggregationType);

            conjLeftOuterNestedJoin[0].setParameter(
                    PACTOperatorsConfiguration.EXCLUDE_NESTED_FIELD_BOOLEAN.toString(),
                    lonja.isExcludeNestedField());
        }
    }

    return conjLeftOuterNestedJoin;
}

From source file:info.raack.appliancelabeler.data.JDBCDatabase.java

@Override
public void saveAlgorithmResult(final AlgorithmResult result) {
    int id = -1;// w w w .j  a  va2  s.c  o m
    try {
        id = jdbcTemplate.queryForInt(
                "select id from algorithm_models where energy_monitor_id = ? and detection_algorithm = ?",
                new Object[] { result.getMonitor().getId(), result.getAlgorithm().getId() });
    } catch (EmptyResultDataAccessException e) {
        // no model saved yet - no problem
    }

    byte[] bytes = SerializationUtils.serialize(result.getResult());

    if (result.getResult() instanceof byte[]) {
        logger.debug("Attempting to save model with " + ((byte[]) result.getResult()).length + " bytes");
    }

    if (id > 0) {
        // algorithm row already exists - update
        FileUtils.deleteQuietly(getResultFile(result.getMonitor().getId()));
    } else {
        // does not exist - add new row
        jdbcTemplate.update(
                "insert into algorithm_models (energy_monitor_id, detection_algorithm) values (?, ?)",
                new Object[] { result.getMonitor().getId(), result.getAlgorithm().getId() });
    }

    try {
        FileUtils.writeByteArrayToFile(getResultFile(result.getMonitor().getId()), bytes);
    } catch (IOException e) {
        throw new RuntimeException("Could not save model result to file", e);
    }
}