Examples with StreamableOperatorInternals org.knime.core.node.streamable.StreamableOperatorInternals used on opensource projects

Example 6 with StreamableOperatorInternals

use of org.knime.core.node.streamable.StreamableOperatorInternals in project knime-core by knime.

the class SimpleStreamableFunctionWithInternalsNodeModel method createMergeOperator.

/**
 * {@inheritDoc}
 */
@Override
public MergeOperator createMergeOperator() {
    return new MergeOperator() {

        @Override
        public StreamableOperatorInternals mergeFinal(final StreamableOperatorInternals[] internals) {
            @SuppressWarnings("unchecked") T[] castedInternals = (T[]) Array.newInstance(m_class, internals.length);
            for (int i = 0; i < internals.length; i++) {
                StreamableOperatorInternals o = internals[i];
                if (o == null) {
                    throw new NullPointerException("internals at position " + i + " is null");
                } else if (!m_class.isInstance(o)) {
                    throw new IllegalStateException(String.format("Internals at position %d is not of expected " + "class \"%s\", it's a \"%s\"", i, m_class.getSimpleName(), o.getClass().getSimpleName()));
                }
                castedInternals[i] = m_class.cast(o);
            }
            return mergeStreamingOperatorInternals(castedInternals);
        }
    };
}

Example 7 with StreamableOperatorInternals

use of org.knime.core.node.streamable.StreamableOperatorInternals in project knime-core by knime.

the class ReferenceColumnResorterNodeModel method createMergeOperator.

/**
 * {@inheritDoc}
 */
@Override
public MergeOperator createMergeOperator() {
    return new MergeOperator() {

        /**
         * {@inheritDoc}
         */
        @Override
        public StreamableOperatorInternals mergeIntermediate(final StreamableOperatorInternals[] operators) {
            return mergeFinal(operators);
        }

        @Override
        public StreamableOperatorInternals mergeFinal(final StreamableOperatorInternals[] operators) {
            StreamableOperatorInternals result = operators[0];
            String[] refOrder = readOrderFromStreamableOperatorInternals(result);
            for (int i = 1; i < operators.length; i++) {
                final String[] curOrder = readOrderFromStreamableOperatorInternals(operators[i]);
                if (!Arrays.equals(refOrder, curOrder)) {
                    StringBuilder b = new StringBuilder();
                    b.append("Inconsistent internals -- all workers should see same dictionary table; ");
                    b.append("index ").append(i).append("is different to position 0: ");
                    b.append(refOrder).append(" vs. ").append(curOrder);
                }
            }
            return result;
        }
    };
}

Example 8 with StreamableOperatorInternals

use of org.knime.core.node.streamable.StreamableOperatorInternals in project knime-core by knime.

the class ReferenceColumnResorterNodeModel method createStreamableOperator.

/**
 * {@inheritDoc}
 */
@Override
public StreamableOperator createStreamableOperator(final PartitionInfo partitionInfo, final PortObjectSpec[] inSpecs) throws InvalidSettingsException {
    return new StreamableOperator() {

        private String[] m_streamableOperatorOrder;

        /**
         * {@inheritDoc}
         */
        @Override
        public void runIntermediate(final PortInput[] inputs, final ExecutionContext exec) throws Exception {
            BufferedDataTable orderTable = (BufferedDataTable) ((PortObjectInput) inputs[1]).getPortObject();
            m_streamableOperatorOrder = readOrderFromTable(orderTable);
        }

        @Override
        public void runFinal(final PortInput[] inputs, final PortOutput[] outputs, final ExecutionContext exec) throws Exception {
            RowInput dataInput = (RowInput) inputs[0];
            DataTableSpec dataInputSpec = dataInput.getDataTableSpec();
            ColumnRearranger rearranger = createColumnRearranger(dataInputSpec, m_streamableOperatorOrder);
            StreamableFunction streamableFunction = rearranger.createStreamableFunction();
            streamableFunction.runFinal(new PortInput[] { dataInput }, outputs, exec);
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public StreamableOperatorInternals saveInternals() {
            return createStreamableOperatorInternalsFromOrder(m_streamableOperatorOrder);
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public void loadInternals(final StreamableOperatorInternals internals) {
            m_streamableOperatorOrder = readOrderFromStreamableOperatorInternals(internals);
        }
    };
}

Example 9 with StreamableOperatorInternals

use of org.knime.core.node.streamable.StreamableOperatorInternals in project knime-core by knime.

the class StringToDurationPeriodNodeModel method createStreamableOperator.

/**
 * {@inheritDoc}
 */
@Override
public StreamableOperator createStreamableOperator(final PartitionInfo partitionInfo, final PortObjectSpec[] inSpecs) throws InvalidSettingsException {
    return new StreamableOperator() {

        private SimpleStreamableOperatorInternals m_internals = new SimpleStreamableOperatorInternals();

        /**
         * {@inheritDoc}
         */
        @Override
        public void runIntermediate(final PortInput[] inputs, final ExecutionContext exec) throws Exception {
            final RowInput rowInput = (RowInput) inputs[0];
            final DataRow row = rowInput.poll();
            if (row != null) {
                final DataTableSpec inSpec = rowInput.getDataTableSpec();
                final int[] includeIndexes = Arrays.stream(m_colSelect.applyTo(inSpec).getIncludes()).mapToInt(s -> inSpec.findColumnIndex(s)).toArray();
                final Config config = m_internals.getConfig();
                // detect types
                detectTypes(new OneRowAdditionalRowInput(rowInput, row));
                for (int i = 0; i < m_detectedTypes.length; i++) {
                    config.addDataType("detected_type" + i, m_detectedTypes[i]);
                }
                // write detected types and column names into config
                if (m_isReplaceOrAppend.getStringValue().equals(OPTION_REPLACE)) {
                    for (int i = 0; i < rowInput.getDataTableSpec().getNumColumns(); i++) {
                        final int searchIdx = Arrays.binarySearch(includeIndexes, i);
                        config.addString("colname" + i, inSpec.getColumnNames()[i]);
                        if (searchIdx < 0) {
                            config.addDataType("type" + i, inSpec.getColumnSpec(i).getType());
                        } else {
                            config.addDataType("type" + i, m_detectedTypes[searchIdx] != null ? m_detectedTypes[searchIdx] : null);
                        }
                    }
                    config.addInt("sizeRow", rowInput.getDataTableSpec().getNumColumns());
                } else {
                    for (int i = 0; i < inSpec.getNumColumns(); i++) {
                        config.addString("colname" + i, inSpec.getColumnNames()[i]);
                        config.addDataType("type" + i, inSpec.getColumnSpec(i).getType());
                    }
                    for (int i = 0; i < m_detectedTypes.length; i++) {
                        config.addString("colname" + (i + inSpec.getNumColumns()), new UniqueNameGenerator(inSpec).newName(inSpec.getColumnSpec(includeIndexes[i]).getName() + m_suffix.getStringValue()));
                        config.addDataType("type" + (i + inSpec.getNumColumns()), m_detectedTypes[i]);
                    }
                    config.addInt("sizeRow", inSpec.getNumColumns() + m_detectedTypes.length);
                }
                config.addBoolean("needsIteration", false);
            } else {
                m_internals.getConfig().addInt("sizeRow", 0);
            }
            rowInput.close();
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public StreamableOperatorInternals saveInternals() {
            return m_internals;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public void loadInternals(final StreamableOperatorInternals internals) {
            m_internals = (SimpleStreamableOperatorInternals) internals;
        }

        @Override
        public void runFinal(final PortInput[] inputs, final PortOutput[] outputs, final ExecutionContext exec) throws Exception {
            final RowInput in = (RowInput) inputs[0];
            final RowOutput out = (RowOutput) outputs[0];
            final DataTableSpec inSpec = in.getDataTableSpec();
            final int[] includeIndexes = Arrays.stream(m_colSelect.applyTo(inSpec).getIncludes()).mapToInt(s -> inSpec.findColumnIndex(s)).toArray();
            // read detected types from config
            final DataType[] detectedTypes = new DataType[includeIndexes.length];
            final Config config = m_internals.getConfig();
            for (int i = 0; i < includeIndexes.length; i++) {
                detectedTypes[i] = config.getDataType("detected_type" + i, null);
            }
            // compute every row
            DataRow row;
            while ((row = in.poll()) != null) {
                exec.checkCanceled();
                DataCell[] datacells = new DataCell[includeIndexes.length];
                for (int i = 0; i < includeIndexes.length; i++) {
                    if (m_isReplaceOrAppend.getStringValue().equals(OPTION_REPLACE)) {
                        final StringToDurationPeriodCellFactory cellFac = new StringToDurationPeriodCellFactory(new DataColumnSpecCreator(inSpec.getColumnNames()[includeIndexes[i]], detectedTypes[i]).createSpec(), includeIndexes[i]);
                        datacells[i] = cellFac.getCells(row)[0];
                    } else {
                        final DataColumnSpec dataColSpec = new UniqueNameGenerator(inSpec).newColumn(inSpec.getColumnNames()[includeIndexes[i]] + m_suffix.getStringValue(), detectedTypes[i]);
                        final StringToDurationPeriodCellFactory cellFac = new StringToDurationPeriodCellFactory(dataColSpec, includeIndexes[i]);
                        datacells[i] = cellFac.getCells(row)[0];
                    }
                }
                if (m_isReplaceOrAppend.getStringValue().equals(OPTION_REPLACE)) {
                    out.push(new ReplacedColumnsDataRow(row, datacells, includeIndexes));
                } else {
                    out.push(new AppendedColumnRow(row, datacells));
                }
            }
            in.close();
            out.close();
        }
    };
}

Example 10 with StreamableOperatorInternals

use of org.knime.core.node.streamable.StreamableOperatorInternals in project knime-core by knime.

the class StringToDurationPeriodNodeModel method createMergeOperator.

@Override
public MergeOperator createMergeOperator() {
    return new MergeOperator() {

        @Override
        public StreamableOperatorInternals mergeIntermediate(final StreamableOperatorInternals[] operators) {
            final SimpleStreamableOperatorInternals internals = new SimpleStreamableOperatorInternals();
            final Config config = internals.getConfig();
            for (StreamableOperatorInternals operator : operators) {
                final Config configToMerge = ((SimpleStreamableOperatorInternals) operator).getConfig();
                final int sizeRow = configToMerge.getInt("sizeRow", -1);
                config.addInt("sizeRow", sizeRow);
                for (int i = 0; i < sizeRow; i++) {
                    if (!config.containsKey("type" + i) && configToMerge.getDataType("type" + i, null) != null) {
                        config.addDataType("type" + i, configToMerge.getDataType("type" + i, null));
                        config.addString("colname" + i, configToMerge.getString("colname" + i, null));
                    }
                    if (!config.containsKey("detected_type" + i) && configToMerge.getDataType("detected_type" + i, null) != null) {
                        config.addDataType("detected_type" + i, configToMerge.getDataType("detected_type" + i, null));
                    }
                }
            }
            // if a column's type could not be detected, guess it to be a PeriodCell
            final Config configToMerge = ((SimpleStreamableOperatorInternals) operators[0]).getConfig();
            for (int i = 0; i < configToMerge.getInt("sizeRow", -1); i++) {
                if (!config.containsKey("type" + i)) {
                    config.addDataType("type" + i, PeriodCellFactory.TYPE);
                    config.addString("colname" + i, configToMerge.getString("colname" + i, null));
                }
                if (!config.containsKey("detected_type" + i)) {
                    config.addDataType("detected_type" + i, PeriodCellFactory.TYPE);
                }
            }
            return internals;
        }

        @Override
        public StreamableOperatorInternals mergeFinal(final StreamableOperatorInternals[] operators) {
            return null;
        }
    };
}