|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use BufferedDataTable | |
---|---|
org.knime.base.collection.list.create | Implementation of the collection create node. |
org.knime.base.collection.list.split | Implementation of the collection split node. |
org.knime.base.data.nominal | Utility package for retrieving nominal values from a DataTable. |
org.knime.base.data.normalize | This package contains the utility classes for normalization of DataRows. |
org.knime.base.data.sort | |
org.knime.base.data.statistics | This package holds the StatisticsTable. |
org.knime.base.node.io.arffreader | Contains the implementation of a node which reads ARFF files. |
org.knime.base.node.io.arffwriter | Contains the implementation of a node which writes the content of a data table into an ARFF file. |
org.knime.base.node.io.csvwriter | Node implementation that writes a DataTable to a file in
CSV (comma separated value) format (or with any other selectable separator). |
org.knime.base.node.io.database | Contains nodes to access data via a database connection. |
org.knime.base.node.io.def | (Obsolete) Node that produces predefined DataTables. |
org.knime.base.node.io.filereader | Contains a node implementation that reads in data from an ASCII file. |
org.knime.base.node.io.table.read | Node that reads data from a file as written by the Write table node. |
org.knime.base.node.io.table.write | Node that writes a datatable to a file. |
org.knime.base.node.meta.feature.backwardelim | |
org.knime.base.node.meta.looper | The looper package contains all classes for building for loops. |
org.knime.base.node.meta.looper.condition | Contains two nodes with which a loop can be built. |
org.knime.base.node.meta.xvalidation | The xvalidation package contains all classes for a cross validation flow. |
org.knime.base.node.mine.bayes.naivebayes.datamodel | This package implements the naive bayes algorithm for numerical and nominal attributes. |
org.knime.base.node.mine.bfn | Contains abstract and util classes to train and perform prediction to rule models, also called BasisFunction models. |
org.knime.base.node.mine.cluster.hierarchical | Contains the implementation of a node performing hierarchical clustering. |
org.knime.base.node.mine.decisiontree2.learner | |
org.knime.base.node.mine.knn | |
org.knime.base.node.mine.mds | A node that applies multi dimensional scaling (MDS) on high dimensional data. |
org.knime.base.node.mine.mds.mdsprojection | A node that applies multi dimensional scaling (MDS) projection on high dimensional data. |
org.knime.base.node.mine.pca | This package contains all classes for the PCA (principal component analysis) Node. |
org.knime.base.node.mine.scorer.accuracy | Similar to the default scorer. |
org.knime.base.node.mine.scorer.entrop | Node that performs an entropy calculation and compares two clustering results. |
org.knime.base.node.mine.smote | Node that oversample patterns in an input table. |
org.knime.base.node.mine.subgroupminer | This package contains everything necessary for normal subgroup mining. |
org.knime.base.node.parallel | This subpackage contains some classes that can be used to implemet nodes that process their data in parallel. |
org.knime.base.node.parallel.appender | |
org.knime.base.node.parallel.builder | |
org.knime.base.node.preproc.append.row | |
org.knime.base.node.preproc.binner | Contains a node to bin/group a number of numeric columns into a string column by predefined intervals. |
org.knime.base.node.preproc.caseconvert | Node to convert alphanumeric characters to lowercase or uppercase. |
org.knime.base.node.preproc.cellsplit | Contains the implementation of a node that splits (and replaces) a values in a column into multiple new ones. |
org.knime.base.node.preproc.cellsplitbypos | |
org.knime.base.node.preproc.colcombine | Node to combine the content of a set of columns into a single column (to be appended). |
org.knime.base.node.preproc.colcompare | Node to combine the content of a set of columns into a single column (to be appended). |
org.knime.base.node.preproc.colconvert | Node to convert String columns to Double columns or the other way around. |
org.knime.base.node.preproc.colconvert.numbertostring | Node to convert DoubleValue columns to StringValue columns. |
org.knime.base.node.preproc.colconvert.stringtonumber | Node to convert StringValue columns to NumberValue columns. |
org.knime.base.node.preproc.colsort | This package contains all classes for the Column Resorter node. |
org.knime.base.node.preproc.columnTrans | This package contains the classes of the Many2One and One2Many column transformation nodes. |
org.knime.base.node.preproc.correlation.pmcc | |
org.knime.base.node.preproc.discretization.caim2.modelcreator | Contains the classes implementing a node that learns a class supervised discretization (binning) model. |
org.knime.base.node.preproc.domain | Contains a node to determine the DataTableSpec of the input data. |
org.knime.base.node.preproc.double2int | |
org.knime.base.node.preproc.filter.column | Contains the filter column node which can be used the extract certain columns from the input data table. |
org.knime.base.node.preproc.filter.columnref | Contains a Reference Column Filter node that allows columns to be included or excluded from the first table while the second one is used as reference table. |
org.knime.base.node.preproc.filter.hilite | Node to seperate hilited and not hilited rows of given DataTable. |
org.knime.base.node.preproc.filter.nominal | This package implements a possible value row filter. |
org.knime.base.node.preproc.filter.row | Contains a node filtering out rows from an input data table, including only those rows into the output/result table that match a certain criteria. |
org.knime.base.node.preproc.filter.rowref | Contains a Reference Row Filter node that allows rows to be included or excluded from the first table while the second one is used as reference table. |
org.knime.base.node.preproc.groupby | Contains a node to perform a group by operation on an input table. |
org.knime.base.node.preproc.joiner | This package contains classes for a node that joins two data tables. |
org.knime.base.node.preproc.lowvarfilter | Node implementation that allows the user to filter out numeric columns, which have a low or no variance. |
org.knime.base.node.preproc.missingval | Implemenation of the node that treats missing values. |
org.knime.base.node.preproc.partition | Node that partitions the data into train- and test set. |
org.knime.base.node.preproc.pivot | Contains a node to perform a pivoting on one column against another group column. |
org.knime.base.node.preproc.regexsplit | Node that splits an input string (column) into multiple groups according to a regular expression (realized by java.util.regex.Pattern). |
org.knime.base.node.preproc.rename | Node that allows to rename column names or change the type. |
org.knime.base.node.preproc.rowkey | This package contains all classes of the RowKey node which provides the following function: Replacing of the current rowkey with the values of a column Creating a column with the row key values |
org.knime.base.node.preproc.rowsplit | Node splits a data table according to a numeric filter criterion. |
org.knime.base.node.preproc.sample | Node that samples rows from an input table. |
org.knime.base.node.preproc.setoperator | Contains a node to perform a set operation on two columns from two input tables. |
org.knime.base.node.preproc.shuffle | Implementation of the Fisher Yates shuffle, that guarantees that all n! possible outcomes are possible and equally likely. |
org.knime.base.node.preproc.sorter | Contains the Sorter Node which can be used to sort columns from the input data table. |
org.knime.base.node.preproc.split | Node that splits an input table into two output table. |
org.knime.base.node.preproc.stringreplacer | This package contains a node that can be used to replace strings in a column based on wildcard matches. |
org.knime.base.node.preproc.stringreplacer.dict | Node that replaces the content of a selected column by dictionary entries. |
org.knime.base.node.preproc.transpose | Contains a node to transpose a table by swaping rows and columns. |
org.knime.base.node.preproc.unpivot | |
org.knime.base.node.preproc.valcount | |
org.knime.base.node.rules | |
org.knime.base.node.util.cache | Contains node that allows caching of data for fast access. |
org.knime.base.node.util.sampledata | |
org.knime.base.node.viz.condbox | Contains all classes that realize a conditional box plot. |
org.knime.base.node.viz.enrichment | The enrichment plotter node allows you to plot enrichment curves. |
org.knime.base.node.viz.histogram.node | Contains classes for KNIME nodes which uses the classes of the histogram package to display a histogram view. |
org.knime.base.node.viz.liftchart | The liftchart package contains all classes for building a lift chart node. |
org.knime.base.node.viz.pie.node | This package contains the KNIME node classes for the fixed and interactive pie chart. |
org.knime.base.node.viz.pie.node.fixed | This package contains the KNIME node classes for the fixed pie chart. |
org.knime.base.node.viz.pie.node.interactive | This package contains the KNIME node classes for the interactive pie chart. |
org.knime.base.node.viz.plotter.box | Contains all classes that realize a box plot. |
org.knime.base.node.viz.plotter.node | This package contains a default node implementation which can be used if a simple plotter is implemented, which displays data from one inport and also wants to display only a restricted number of rows. |
org.knime.base.node.viz.roc | The ROC node allows you to plot ROC curves. |
org.knime.base.node.viz.statistics | Contains the Statistics Node which can be used to compute statistics based on the input data table. |
org.knime.base.node.viz.table | Node implementation of the interactive table view. |
org.knime.core.data.container |
Implementation of a DataContainer . |
org.knime.core.node | Contains all classes needed to implement a new node in the workflow. |
org.knime.core.node.interrupt | This package contains the necessary classes for an interruptible framework. |
org.knime.core.node.port.database | |
org.knime.core.node.workflow | Contains wrapper classes which control the communication between Node and GUI Workflow. |
org.knime.core.node.workflow.execresult |
Uses of BufferedDataTable in org.knime.base.collection.list.create |
---|
Methods in org.knime.base.collection.list.create that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
CollectionCreateNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.collection.list.create with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
CollectionCreateNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.collection.list.split |
---|
Methods in org.knime.base.collection.list.split that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
CollectionSplitNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.collection.list.split with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
CollectionSplitNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.data.nominal |
---|
Methods in org.knime.base.data.nominal with parameters of type BufferedDataTable | |
---|---|
static DataTableSpec |
NominalTable.computeValues(BufferedDataTable table,
ExecutionMonitor exec)
Wraps the given table into a new table by computing all possible values for all columns. |
static DataTableSpec |
NominalTable.computeValues(BufferedDataTable table,
ExecutionMonitor exec,
int... columnIndex)
Finds all possible values based on a table and a number of given column indices by iterating through the table. |
static DataTableSpec |
NominalTable.computeValues(BufferedDataTable table,
ExecutionMonitor exec,
String... columns)
Computes all possible values based in the given table and column name. |
Constructors in org.knime.base.data.nominal with parameters of type BufferedDataTable | |
---|---|
NominalTable(BufferedDataTable table,
ExecutionMonitor exec)
Wraps the given table into a new table by computing all possible values for all columns. |
|
NominalTable(BufferedDataTable table,
ExecutionMonitor exec,
int... columnIndex)
Wraps the given table into a new table by computing all possible values for the given column indices. |
|
NominalTable(BufferedDataTable table,
ExecutionMonitor exec,
String... columns)
Wraps the given table into a new table by computing all possible values for the given column . |
Uses of BufferedDataTable in org.knime.base.data.normalize |
---|
Constructors in org.knime.base.data.normalize with parameters of type BufferedDataTable | |
---|---|
Normalizer(BufferedDataTable table,
String[] columns)
Prepares a Normalizer to process the buffered data table table . |
Uses of BufferedDataTable in org.knime.base.data.sort |
---|
Methods in org.knime.base.data.sort that return BufferedDataTable | |
---|---|
BufferedDataTable |
SortedTable.getBufferedDataTable()
|
Constructors in org.knime.base.data.sort with parameters of type BufferedDataTable | |
---|---|
SortedTable(BufferedDataTable dataTable,
Comparator<DataRow> rowComparator,
boolean sortInMemory,
ExecutionContext exec)
Creates a new sorted table. |
|
SortedTable(BufferedDataTable dataTable,
List<String> inclList,
boolean[] sortAscending,
boolean sortInMemory,
ExecutionContext exec)
Creates a sorted table from the given table and the sorting parameters. |
|
SortedTable(BufferedDataTable dataTable,
List<String> inclList,
boolean[] sortAscending,
ExecutionContext exec)
Creates a sorted table from the given table and the sorting parameters. |
Uses of BufferedDataTable in org.knime.base.data.statistics |
---|
Constructors in org.knime.base.data.statistics with parameters of type BufferedDataTable | |
---|---|
Statistics2Table(BufferedDataTable table,
boolean computeMedian,
int numNomValuesOutput,
List<String> nominalValueColumns,
ExecutionContext exec)
Create new statistic table from an existing one. |
Uses of BufferedDataTable in org.knime.base.node.io.arffreader |
---|
Methods in org.knime.base.node.io.arffreader that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ARFFReaderNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.io.arffreader with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ARFFReaderNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.io.arffwriter |
---|
Methods in org.knime.base.node.io.arffwriter that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ARFFWriterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.io.arffwriter with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ARFFWriterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.io.csvwriter |
---|
Methods in org.knime.base.node.io.csvwriter that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
CSVWriterNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.io.csvwriter with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
CSVWriterNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.io.database |
---|
Methods in org.knime.base.node.io.database that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
DBReaderNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
protected BufferedDataTable[] |
DBWriterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
protected BufferedDataTable[] |
DatabaseLoopingNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.io.database with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
DBReaderNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
protected BufferedDataTable[] |
DBWriterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
protected BufferedDataTable[] |
DatabaseLoopingNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
(package private) static String |
DBWriterConnection.writeData(DatabaseConnectionSettings dbConn,
String table,
BufferedDataTable data,
boolean appendData,
ExecutionMonitor exec,
Map<String,String> sqlTypes)
Create connection to write into database. |
Uses of BufferedDataTable in org.knime.base.node.io.def |
---|
Methods in org.knime.base.node.io.def that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
DefaultTableNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.io.def with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
DefaultTableNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.io.filereader |
---|
Methods in org.knime.base.node.io.filereader that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
FileReaderNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.io.filereader with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
FileReaderNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.io.table.read |
---|
Methods in org.knime.base.node.io.table.read that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ReadTableNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.io.table.read with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ReadTableNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.io.table.write |
---|
Methods in org.knime.base.node.io.table.write that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
WriteTableNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.io.table.write with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
WriteTableNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.meta.feature.backwardelim |
---|
Methods in org.knime.base.node.meta.feature.backwardelim that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
BWElimLoopStartNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.meta.feature.backwardelim with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
BWElimLoopStartNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.meta.looper |
---|
Methods in org.knime.base.node.meta.looper that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
LoopEndNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.meta.looper with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
LoopEndNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.meta.looper.condition |
---|
Methods in org.knime.base.node.meta.looper.condition that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
LoopStartGenericNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
protected BufferedDataTable[] |
LoopEndConditionNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.meta.looper.condition with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
LoopStartGenericNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
protected BufferedDataTable[] |
LoopEndConditionNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.meta.xvalidation |
---|
Methods in org.knime.base.node.meta.xvalidation that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
XValidatePartitionModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
protected BufferedDataTable[] |
AggregateOutputNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.meta.xvalidation with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
XValidatePartitionModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
protected BufferedDataTable[] |
AggregateOutputNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.mine.bayes.naivebayes.datamodel |
---|
Constructors in org.knime.base.node.mine.bayes.naivebayes.datamodel with parameters of type BufferedDataTable | |
---|---|
NaiveBayesModel(BufferedDataTable data,
String classColName,
ExecutionContext exec,
int maxNoOfNominalVals,
boolean skipMissingVals)
Constructor which iterates through the DataTable to
calculate the needed Bayes variables. |
Uses of BufferedDataTable in org.knime.base.node.mine.bfn |
---|
Methods in org.knime.base.node.mine.bfn that return BufferedDataTable | |
---|---|
BufferedDataTable[] |
BasisFunctionPredictorNodeModel.execute(PortObject[] portObj,
ExecutionContext exec)
Execute method for general port types. |
Methods in org.knime.base.node.mine.bfn with parameters of type BufferedDataTable | |
---|---|
void |
BasisFunctionLearnerTable.explain(BufferedDataTable data,
String[] dataColumns,
String[] targetColumns)
Assigns all explained examples to to basis functions. |
Constructors in org.knime.base.node.mine.bfn with parameters of type BufferedDataTable | |
---|---|
BasisFunctionLearnerTable(BufferedDataTable data,
String[] dataColumns,
String[] targetColumns,
BasisFunctionFactory factory,
BasisFunctionLearnerTable.MissingValueReplacementFunction missing,
boolean shrinkAfterCommit,
boolean maxClassCoverage,
int maxEpochs,
ExecutionMonitor exec)
Creates a new basis function learner and starts the training algorithm. |
|
BasisFunctionLearnerTable(BufferedDataTable data,
String[] dataColumns,
String[] targetColumns,
BasisFunctionFactory factory,
BasisFunctionLearnerTable.MissingValueReplacementFunction missing,
boolean shrinkAfterCommit,
boolean maxClassCoverage,
int maxEpochs,
int[] startRuleCount,
ExecutionMonitor exec)
Creates a new basisfunction learner and starts the training algorithm. |
Uses of BufferedDataTable in org.knime.base.node.mine.cluster.hierarchical |
---|
Methods in org.knime.base.node.mine.cluster.hierarchical that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
HierarchicalClusterNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.mine.cluster.hierarchical with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
HierarchicalClusterNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.mine.decisiontree2.learner |
---|
Constructors in org.knime.base.node.mine.decisiontree2.learner with parameters of type BufferedDataTable | |
---|---|
InMemoryTableCreator(BufferedDataTable table,
int classColumnIndex,
double minNumberRowsPerNode)
Creates a creator from the given table and the specified class index. |
Uses of BufferedDataTable in org.knime.base.node.mine.knn |
---|
Methods in org.knime.base.node.mine.knn that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
KnnNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.mine.knn with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
KnnNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.mine.mds |
---|
Methods in org.knime.base.node.mine.mds that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
MDSNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.mine.mds with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
MDSNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Constructors in org.knime.base.node.mine.mds with parameters of type BufferedDataTable | |
---|---|
MDSManager(int dimension,
String distance,
boolean fuzzy,
BufferedDataTable inData,
ExecutionContext exec)
Creates a new instance of MDSManager with the given
dimension, distance metric, fuzzy flag and in data to use. |
Uses of BufferedDataTable in org.knime.base.node.mine.mds.mdsprojection |
---|
Methods in org.knime.base.node.mine.mds.mdsprojection that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
MDSProjectionNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.mine.mds.mdsprojection with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
MDSProjectionNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Constructors in org.knime.base.node.mine.mds.mdsprojection with parameters of type BufferedDataTable | |
---|---|
MDSProjectionManager(int dimension,
String distance,
boolean fuzzy,
BufferedDataTable inData,
BufferedDataTable fixedDataPoints,
int[] fixedDataMdsIndices,
ExecutionContext exec)
Creates a new instance of MDSProjectionManager with the
given dimension, distance metric, fuzzy flag, in data and fixed data to
use. |
Uses of BufferedDataTable in org.knime.base.node.mine.pca |
---|
Methods in org.knime.base.node.mine.pca that return BufferedDataTable | |
---|---|
static BufferedDataTable |
PCANodeModel.createCovarianceTable(ExecutionContext exec,
double[][] m,
String[] inputColumnNames)
create data table from covariance matrix. |
static BufferedDataTable |
PCANodeModel.createDecompositionOutputTable(ExecutionContext exec,
double[] evs,
Jama.Matrix eigenvectors)
create a table containing the given spectral decomposition. |
Methods in org.knime.base.node.mine.pca with parameters of type BufferedDataTable | |
---|---|
(package private) static int |
PCANodeModel.getCovarianceMatrix(ExecutionContext exec,
BufferedDataTable dataTable,
int[] numericIndices,
double[] means,
double[][] dataMatrix)
Converts a DataTable to the 2D-double array representing its
covariance matrix. |
Uses of BufferedDataTable in org.knime.base.node.mine.scorer.accuracy |
---|
Methods in org.knime.base.node.mine.scorer.accuracy that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
AccuracyScorerNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
Starts the scoring in the scorer. |
Methods in org.knime.base.node.mine.scorer.accuracy with parameters of type BufferedDataTable | |
---|---|
protected DataCell[] |
AccuracyScorerNodeModel.determineColValues(BufferedDataTable in,
int index1,
int index2,
ExecutionMonitor exec)
Called to determine all possible values in the respective columns. |
protected BufferedDataTable[] |
AccuracyScorerNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
Starts the scoring in the scorer. |
Uses of BufferedDataTable in org.knime.base.node.mine.scorer.entrop |
---|
Methods in org.knime.base.node.mine.scorer.entrop that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
EntropyNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.mine.scorer.entrop with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
EntropyNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.mine.smote |
---|
Methods in org.knime.base.node.mine.smote that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
SmoteNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.mine.smote with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
SmoteNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Constructors in org.knime.base.node.mine.smote with parameters of type BufferedDataTable | |
---|---|
Smoter(BufferedDataTable in,
String colName,
ExecutionContext exec,
Random rand)
Creates a new instance given the input table in and the
target column colName . |
Uses of BufferedDataTable in org.knime.base.node.mine.subgroupminer |
---|
Methods in org.knime.base.node.mine.subgroupminer that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
BitVectorGeneratorNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
protected BufferedDataTable[] |
SubgroupMinerModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.mine.subgroupminer with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
BitVectorGeneratorNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
protected BufferedDataTable[] |
SubgroupMinerModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.parallel |
---|
Methods in org.knime.base.node.parallel that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
AbstractParallelNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.parallel with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
AbstractParallelNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
protected abstract void |
AbstractParallelNodeModel.executeByChunk(BufferedDataTable inDataChunk,
BufferedDataTable[] additionalData,
RowAppender[] outputTables,
ExecutionMonitor exec)
This method is called as often as necessary by multiple threads. |
protected abstract void |
AbstractParallelNodeModel.executeByChunk(BufferedDataTable inDataChunk,
BufferedDataTable[] additionalData,
RowAppender[] outputTables,
ExecutionMonitor exec)
This method is called as often as necessary by multiple threads. |
Uses of BufferedDataTable in org.knime.base.node.parallel.appender |
---|
Methods in org.knime.base.node.parallel.appender that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ThreadedColAppenderNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
protected BufferedDataTable[] |
ThreadedColAppenderNodeModel.getAdditionalTables()
Returns all additional tables passed into the node, i.e. |
protected BufferedDataTable[] |
ThreadedColAppenderNodeModel.postExecute(BufferedDataTable[] res,
ExecutionContext exec)
This method is called after all rows have been processed and combined into the final result tables. |
Methods in org.knime.base.node.parallel.appender with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ThreadedColAppenderNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
protected BufferedDataTable[] |
ThreadedColAppenderNodeModel.postExecute(BufferedDataTable[] res,
ExecutionContext exec)
This method is called after all rows have been processed and combined into the final result tables. |
Uses of BufferedDataTable in org.knime.base.node.parallel.builder |
---|
Methods in org.knime.base.node.parallel.builder that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ThreadedTableBuilderNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.parallel.builder with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ThreadedTableBuilderNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
protected abstract void |
ThreadedTableBuilderNodeModel.processRow(DataRow inRow,
BufferedDataTable[] additionalData,
RowAppender[] outputTables)
This method is called once for each row in the first input table. |
Uses of BufferedDataTable in org.knime.base.node.preproc.append.row |
---|
Methods in org.knime.base.node.preproc.append.row that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
AppendedRowsNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.append.row with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
AppendedRowsNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.binner |
---|
Methods in org.knime.base.node.preproc.binner that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
BinnerNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.binner with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
BinnerNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.caseconvert |
---|
Methods in org.knime.base.node.preproc.caseconvert that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
CaseConvertNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.caseconvert with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
CaseConvertNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.cellsplit |
---|
Methods in org.knime.base.node.preproc.cellsplit that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
CellSplitterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.cellsplit with parameters of type BufferedDataTable | |
---|---|
(package private) static CellSplitterSettings |
CellSplitterCellFactory.createNewColumnTypes(BufferedDataTable table,
CellSplitterUserSettings userSettings,
ExecutionContext exec)
Analyzes the values in the user selected column and tries to figure out how many columns are needed to hold the splitted values and of which type the new resulting column have to be. |
protected BufferedDataTable[] |
CellSplitterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.cellsplitbypos |
---|
Methods in org.knime.base.node.preproc.cellsplitbypos that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
CellSplitterByPosNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.cellsplitbypos with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
CellSplitterByPosNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.colcombine |
---|
Methods in org.knime.base.node.preproc.colcombine that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ColCombineNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.colcombine with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ColCombineNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.colcompare |
---|
Methods in org.knime.base.node.preproc.colcompare that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ColumnComparatorNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.colcompare with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ColumnComparatorNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.colconvert |
---|
Methods in org.knime.base.node.preproc.colconvert that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ColConvertNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.colconvert with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ColConvertNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.colconvert.numbertostring |
---|
Methods in org.knime.base.node.preproc.colconvert.numbertostring that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
NumberToStringNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.colconvert.numbertostring with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
NumberToStringNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.colconvert.stringtonumber |
---|
Methods in org.knime.base.node.preproc.colconvert.stringtonumber that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
StringToNumberNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.colconvert.stringtonumber with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
StringToNumberNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.colsort |
---|
Methods in org.knime.base.node.preproc.colsort that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ColumnResorterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.colsort with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ColumnResorterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.columnTrans |
---|
Methods in org.knime.base.node.preproc.columnTrans that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
One2ManyColNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
protected BufferedDataTable[] |
Many2OneColNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.columnTrans with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
One2ManyColNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
protected BufferedDataTable[] |
Many2OneColNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.correlation.pmcc |
---|
Methods in org.knime.base.node.preproc.correlation.pmcc that return BufferedDataTable | |
---|---|
(package private) BufferedDataTable |
PMCCPortObjectAndSpec.createCorrelationMatrix(ExecutionContext con)
Creates the correlation table, used in the view and as output table. |
BufferedDataTable[] |
PMCCNodeModel.getInternalTables()
|
Methods in org.knime.base.node.preproc.correlation.pmcc with parameters of type BufferedDataTable | |
---|---|
void |
PMCCNodeModel.setInternalTables(BufferedDataTable[] tables)
Allows the WorkflowManager to set information about new BDTs, for instance after load. |
Uses of BufferedDataTable in org.knime.base.node.preproc.discretization.caim2.modelcreator |
---|
Methods in org.knime.base.node.preproc.discretization.caim2.modelcreator that return BufferedDataTable | |
---|---|
static BufferedDataTable |
CAIMDiscretizationNodeModel.createResultTable(ExecutionContext exec,
BufferedDataTable table,
DiscretizationModel discretizationModel)
Creates BufferedDataTable from a given input table and an
appropriate DiscretizationScheme . |
Methods in org.knime.base.node.preproc.discretization.caim2.modelcreator with parameters of type BufferedDataTable | |
---|---|
void |
QuantaMatrix2D.countData(BufferedDataTable inputTable,
int columnIndex,
int classColumnIndex)
Counts the distribution of the given column of the input table and stores it into the quanta matrix. |
static BufferedDataTable |
CAIMDiscretizationNodeModel.createResultTable(ExecutionContext exec,
BufferedDataTable table,
DiscretizationModel discretizationModel)
Creates BufferedDataTable from a given input table and an
appropriate DiscretizationScheme . |
Uses of BufferedDataTable in org.knime.base.node.preproc.domain |
---|
Methods in org.knime.base.node.preproc.domain that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
DomainNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.domain with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
DomainNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.double2int |
---|
Methods in org.knime.base.node.preproc.double2int that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
DoubleToIntNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.double2int with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
DoubleToIntNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.filter.column |
---|
Methods in org.knime.base.node.preproc.filter.column that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
FilterColumnNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.filter.column with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
FilterColumnNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.filter.columnref |
---|
Methods in org.knime.base.node.preproc.filter.columnref that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ColumnFilterRefNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.filter.columnref with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ColumnFilterRefNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.filter.hilite |
---|
Methods in org.knime.base.node.preproc.filter.hilite that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
HiliteFilterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.filter.hilite with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
HiliteFilterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.filter.nominal |
---|
Methods in org.knime.base.node.preproc.filter.nominal that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
NominalValueRowFilterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.filter.nominal with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
NominalValueRowFilterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.filter.row |
---|
Methods in org.knime.base.node.preproc.filter.row that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
RowFilterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
protected BufferedDataTable[] |
RowFilter2PortNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.filter.row with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
RowFilterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
protected BufferedDataTable[] |
RowFilter2PortNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.filter.rowref |
---|
Methods in org.knime.base.node.preproc.filter.rowref that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
RowFilterRefNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.filter.rowref with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
RowFilterRefNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.groupby |
---|
Methods in org.knime.base.node.preproc.groupby that return BufferedDataTable | |
---|---|
BufferedDataTable |
GroupByTable.getBufferedTable()
|
Constructors in org.knime.base.node.preproc.groupby with parameters of type BufferedDataTable | |
---|---|
GroupByTable(ExecutionContext exec,
BufferedDataTable inDataTable,
List<String> groupByCols,
ColumnAggregator[] colAggregators,
int maxUniqueValues,
boolean sortInMemory,
boolean enableHilite,
ColumnNamePolicy colNamePolicy)
Constructor for class GroupByTable. |
|
GroupByTable(ExecutionContext exec,
BufferedDataTable inDataTable,
List<String> groupByCols,
ColumnAggregator[] colAggregators,
int maxUniqueValues,
boolean sortInMemory,
boolean enableHilite,
ColumnNamePolicy colNamePolicy,
boolean retainOrder)
Constructor for class GroupByTable. |
Uses of BufferedDataTable in org.knime.base.node.preproc.joiner |
---|
Methods in org.knime.base.node.preproc.joiner that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
NewJoinerNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.joiner with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
NewJoinerNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.lowvarfilter |
---|
Methods in org.knime.base.node.preproc.lowvarfilter that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
LowVarFilterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.lowvarfilter with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
LowVarFilterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.missingval |
---|
Methods in org.knime.base.node.preproc.missingval that return BufferedDataTable | |
---|---|
static BufferedDataTable |
MissingValueHandlingTable.createMissingValueHandlingTable(DataTable table,
ColSetting[] colSettings,
ExecutionContext exec,
StringBuffer warningBuffer)
Does missing value handling to the argument table given the col settings in an array and also reports progress. |
protected BufferedDataTable[] |
MissingValueHandlingNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.missingval with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
MissingValueHandlingNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.partition |
---|
Methods in org.knime.base.node.preproc.partition that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
PartitionNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.partition with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
PartitionNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.pivot |
---|
Methods in org.knime.base.node.preproc.pivot that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
PivotNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.pivot with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
PivotNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.regexsplit |
---|
Methods in org.knime.base.node.preproc.regexsplit that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
RegexSplitNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.regexsplit with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
RegexSplitNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.rename |
---|
Methods in org.knime.base.node.preproc.rename that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
RenameNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.rename with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
RenameNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.rowkey |
---|
Methods in org.knime.base.node.preproc.rowkey that return BufferedDataTable | |
---|---|
BufferedDataTable |
RowKeyUtil.changeRowKey(BufferedDataTable inData,
ExecutionContext exec,
String selRowKeyColName,
boolean appendColumn,
DataColumnSpec newColSpec,
boolean ensureUniqueness,
boolean replaceMissingVals,
boolean removeRowKeyCol,
boolean hiliteMap)
Replaces the row key by the values of the column with the given name and appends a new column with the old key values if the newColName variable is a non empty String . |
protected BufferedDataTable[] |
RowKeyNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.rowkey with parameters of type BufferedDataTable | |
---|---|
BufferedDataTable |
RowKeyUtil.changeRowKey(BufferedDataTable inData,
ExecutionContext exec,
String selRowKeyColName,
boolean appendColumn,
DataColumnSpec newColSpec,
boolean ensureUniqueness,
boolean replaceMissingVals,
boolean removeRowKeyCol,
boolean hiliteMap)
Replaces the row key by the values of the column with the given name and appends a new column with the old key values if the newColName variable is a non empty String . |
protected BufferedDataTable[] |
RowKeyNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.rowsplit |
---|
Methods in org.knime.base.node.preproc.rowsplit that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
NumericRowSplitterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.rowsplit with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
NumericRowSplitterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.sample |
---|
Methods in org.knime.base.node.preproc.sample that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
SamplingNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.sample with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
SamplingNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
protected RowFilter |
AbstractSamplingNodeModel.getSamplingRowFilter(BufferedDataTable in,
ExecutionMonitor exec)
Method to be used in the execute method to determine the row filter for the sampling. |
Uses of BufferedDataTable in org.knime.base.node.preproc.setoperator |
---|
Methods in org.knime.base.node.preproc.setoperator that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
SetOperatorNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
BufferedDataTable |
SetOperationTable.getBufferedTable()
|
Methods in org.knime.base.node.preproc.setoperator with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
SetOperatorNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Constructors in org.knime.base.node.preproc.setoperator with parameters of type BufferedDataTable | |
---|---|
SetOperationTable(ExecutionContext exec,
boolean useRowID1,
String col1,
BufferedDataTable table1,
boolean useRowID2,
String col2,
BufferedDataTable table2,
SetOperation op,
boolean enableHilite,
boolean skipMissing,
boolean sortInMemory)
Constructor for class SetOperationTable. |
Uses of BufferedDataTable in org.knime.base.node.preproc.shuffle |
---|
Methods in org.knime.base.node.preproc.shuffle that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ShuffleNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.shuffle with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ShuffleNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.sorter |
---|
Methods in org.knime.base.node.preproc.sorter that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
SorterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
When the model gets executed, the DataTable
is split in several DataContainer s. |
Methods in org.knime.base.node.preproc.sorter with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
SorterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
When the model gets executed, the DataTable
is split in several DataContainer s. |
Uses of BufferedDataTable in org.knime.base.node.preproc.split |
---|
Methods in org.knime.base.node.preproc.split that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
SplitNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.split with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
SplitNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.stringreplacer |
---|
Methods in org.knime.base.node.preproc.stringreplacer that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
StringReplacerNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.stringreplacer with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
StringReplacerNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.stringreplacer.dict |
---|
Methods in org.knime.base.node.preproc.stringreplacer.dict that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
SearchReplaceDictNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.stringreplacer.dict with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
SearchReplaceDictNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.transpose |
---|
Methods in org.knime.base.node.preproc.transpose that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
TransposeTableNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.transpose with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
TransposeTableNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.unpivot |
---|
Methods in org.knime.base.node.preproc.unpivot that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
UnpivotNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.unpivot with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
UnpivotNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.preproc.valcount |
---|
Methods in org.knime.base.node.preproc.valcount that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ValueCounterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.preproc.valcount with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ValueCounterNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.rules |
---|
Methods in org.knime.base.node.rules that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
RuleEngineNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.rules with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
RuleEngineNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.util.cache |
---|
Methods in org.knime.base.node.util.cache that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
CacheNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.util.cache with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
CacheNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.util.sampledata |
---|
Methods in org.knime.base.node.util.sampledata that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
SampleDataNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.util.sampledata with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
SampleDataNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.viz.condbox |
---|
Methods in org.knime.base.node.viz.condbox that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ConditionalBoxPlotNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.viz.condbox with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ConditionalBoxPlotNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.viz.enrichment |
---|
Methods in org.knime.base.node.viz.enrichment that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
EnrichmentPlotterModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.viz.enrichment with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
EnrichmentPlotterModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.viz.histogram.node |
---|
Methods in org.knime.base.node.viz.histogram.node with parameters of type BufferedDataTable | |
---|---|
protected void |
FixedColumnHistogramNodeModel.createHistogramModel(ExecutionContext exec,
int noOfRows,
BufferedDataTable table)
This method should use the given information to create the internal histogram data model. |
protected void |
HistogramNodeModel.createHistogramModel(ExecutionContext exec,
int noOfRows,
BufferedDataTable data)
This method should use the given information to create the internal histogram data model. |
protected abstract void |
AbstractHistogramNodeModel.createHistogramModel(ExecutionContext exec,
int noOfRows,
BufferedDataTable table)
This method should use the given information to create the internal histogram data model. |
Uses of BufferedDataTable in org.knime.base.node.viz.liftchart |
---|
Methods in org.knime.base.node.viz.liftchart that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
LiftChartNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.viz.liftchart with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
LiftChartNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.viz.pie.node |
---|
Methods in org.knime.base.node.viz.pie.node that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
PieNodeModel.execute(PortObject[] inData,
ExecutionContext exec)
Execute method for general port types. |
Methods in org.knime.base.node.viz.pie.node with parameters of type BufferedDataTable | |
---|---|
protected abstract void |
PieNodeModel.createModel(ExecutionContext exec,
DataColumnSpec pieColSpec,
DataColumnSpec aggrColSpec,
BufferedDataTable dataTable,
int noOfRows,
boolean containsColorHandler)
Called prior #addDataRow(...) method to allow the
implementing class the specific model creation. |
Uses of BufferedDataTable in org.knime.base.node.viz.pie.node.fixed |
---|
Methods in org.knime.base.node.viz.pie.node.fixed with parameters of type BufferedDataTable | |
---|---|
protected void |
FixedPieNodeModel.createModel(ExecutionContext exec,
DataColumnSpec pieColSpec,
DataColumnSpec aggrColSpec,
BufferedDataTable dataTable,
int noOfRows,
boolean containsColorHandler)
Called prior #addDataRow(...) method to allow the
implementing class the specific model creation. |
Uses of BufferedDataTable in org.knime.base.node.viz.pie.node.interactive |
---|
Methods in org.knime.base.node.viz.pie.node.interactive with parameters of type BufferedDataTable | |
---|---|
protected void |
InteractivePieNodeModel.createModel(ExecutionContext exec,
DataColumnSpec pieColSpec,
DataColumnSpec aggrColSpec,
BufferedDataTable dataTable,
int noOfRows,
boolean containsColorHandler)
Called prior #addDataRow(...) method to allow the
implementing class the specific model creation. |
Uses of BufferedDataTable in org.knime.base.node.viz.plotter.box |
---|
Methods in org.knime.base.node.viz.plotter.box that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
BoxPlotNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.viz.plotter.box with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
BoxPlotNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.viz.plotter.node |
---|
Methods in org.knime.base.node.viz.plotter.node that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
DefaultVisualizationNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
Converts the input data at inport 0 into a DataArray with maximum number of rows as
defined in the DefaultVisualizationNodeDialog . |
Methods in org.knime.base.node.viz.plotter.node with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
DefaultVisualizationNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
Converts the input data at inport 0 into a DataArray with maximum number of rows as
defined in the DefaultVisualizationNodeDialog . |
Uses of BufferedDataTable in org.knime.base.node.viz.roc |
---|
Methods in org.knime.base.node.viz.roc that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ROCNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Methods in org.knime.base.node.viz.roc with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
ROCNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
Uses of BufferedDataTable in org.knime.base.node.viz.statistics |
---|
Methods in org.knime.base.node.viz.statistics that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
Statistics2NodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
Computes the statistics for the DataTable at the in-port. |
Methods in org.knime.base.node.viz.statistics with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
Statistics2NodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
Computes the statistics for the DataTable at the in-port. |
Uses of BufferedDataTable in org.knime.base.node.viz.table |
---|
Methods in org.knime.base.node.viz.table that return BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
TableNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
Called when new data is available. |
BufferedDataTable[] |
TableNodeModel.getInternalTables()
|
Methods in org.knime.base.node.viz.table with parameters of type BufferedDataTable | |
---|---|
protected BufferedDataTable[] |
TableNodeModel.execute(BufferedDataTable[] data,
ExecutionContext exec)
Called when new data is available. |
void |
TableNodeModel.setInternalTables(BufferedDataTable[] tables)
Allows the WorkflowManager to set information about new BDTs, for instance after load. |
Uses of BufferedDataTable in org.knime.core.data.container |
---|
Methods in org.knime.core.data.container that return BufferedDataTable | |
---|---|
BufferedDataTable[] |
WrappedTable.getReferenceTables()
Reference to the underlying tables, if any. |
BufferedDataTable[] |
RearrangeColumnsTable.getReferenceTables()
Get handle to the reference table in an array of length 1. |
BufferedDataTable[] |
TableSpecReplacerTable.getReferenceTables()
Get handle to reference table in an array of length 1. |
BufferedDataTable[] |
ContainerTable.getReferenceTables()
Returns an empty array. |
BufferedDataTable[] |
JoinedTable.getReferenceTables()
Reference to the underlying tables, if any. |
BufferedDataTable[] |
ConcatenateTable.getReferenceTables()
Reference to the underlying tables, if any. |
Methods in org.knime.core.data.container with parameters of type BufferedDataTable | |
---|---|
static JoinedTable |
JoinedTable.create(BufferedDataTable left,
BufferedDataTable right,
ExecutionMonitor prog)
Creates new join table, does the sanity checks. |
static RearrangeColumnsTable |
RearrangeColumnsTable.create(ColumnRearranger rearranger,
BufferedDataTable table,
ExecutionMonitor subProgress,
ExecutionContext context)
This factory method is intended to be used immediately before the BufferedDataTable is created. |
static ConcatenateTable |
ConcatenateTable.create(ExecutionMonitor mon,
BufferedDataTable... tables)
Creates a new table from argument tables. |
Method parameters in org.knime.core.data.container with type arguments of type BufferedDataTable | |
---|---|
static TableSpecReplacerTable |
TableSpecReplacerTable.load(NodeSettingsRO s,
DataTableSpec newSpec,
Map<Integer,BufferedDataTable> tblRep)
Restores table from a file that has been written using KNIME 1.2.0 or later. |
static JoinedTable |
JoinedTable.load(NodeSettingsRO s,
DataTableSpec spec,
Map<Integer,BufferedDataTable> tblRep)
Method being called when the workflow is restored and the table shall recreated. |
static ConcatenateTable |
ConcatenateTable.load(NodeSettingsRO s,
DataTableSpec spec,
Map<Integer,BufferedDataTable> tblRep)
Restore table form node settings object. |
static WrappedTable |
WrappedTable.load(NodeSettingsRO s,
Map<Integer,BufferedDataTable> tblRep)
Restore table, reverse operation to save . |
static TableSpecReplacerTable |
TableSpecReplacerTable.load11x(File f,
NodeSettingsRO s,
Map<Integer,BufferedDataTable> tblRep)
Restores table from a file that has been written using KNIME 1.1.x or before. |
Constructors in org.knime.core.data.container with parameters of type BufferedDataTable | |
---|---|
TableSpecReplacerTable(BufferedDataTable table,
DataTableSpec newSpec)
Creates new table. |
|
WrappedTable(BufferedDataTable table)
Creates new table wrapping the argument. |
Constructor parameters in org.knime.core.data.container with type arguments of type BufferedDataTable | |
---|---|
RearrangeColumnsTable(ReferencedFile f,
NodeSettingsRO settings,
Map<Integer,BufferedDataTable> tblRep,
DataTableSpec spec,
int tableID,
HashMap<Integer,ContainerTable> bufferRep)
Creates new object based on the content in settings and
the content from the file f . |
Uses of BufferedDataTable in org.knime.core.node |
---|
Methods in org.knime.core.node that return BufferedDataTable | |
---|---|
BufferedDataTable |
ExecutionContext.createBufferedDataTable(DataTable table,
ExecutionMonitor subProgressMon)
Caches the table argument and returns a reference to a BufferedDataTable wrapping the content. |
BufferedDataTable[] |
ExecutionContext.createBufferedDataTables(DataTable[] tables,
ExecutionMonitor exec)
Performs the creation of buffered datatables for an array of DataTables. |
BufferedDataTable |
ExecutionContext.createColumnRearrangeTable(BufferedDataTable in,
ColumnRearranger rearranger,
ExecutionMonitor subProgressMon)
Creates a new BufferedDataTable based on a given input table
(in ) whereby only some of the columns of in
have changed. |
BufferedDataTable |
ExecutionContext.createConcatenateTable(ExecutionMonitor exec,
BufferedDataTable... tables)
Creates a new BufferedDataTable , which is row-wise
concatenation of the argument tables. |
BufferedDataTable |
ExecutionContext.createJoinedTable(BufferedDataTable left,
BufferedDataTable right,
ExecutionMonitor exec)
Creates a new BufferedDataTable that is a column based join of
the argument tables. |
BufferedDataTable |
ExecutionContext.createSpecReplacerTable(BufferedDataTable in,
DataTableSpec newSpec)
Creates a new BufferedDataTable based on a given input table
(in ) whereby only the table spec of it has changed. |
BufferedDataTable |
ExecutionContext.createWrappedTable(BufferedDataTable in)
Creates a new BufferedDataTable that simply wraps the
argument table. |
protected BufferedDataTable[] |
NodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
static BufferedDataTable |
BufferedDataTable.getDataTable(Map<Integer,BufferedDataTable> tblRep,
Integer tableID)
Method that is used internally while the workflow is being loaded. |
BufferedDataTable[] |
NodePersistorVersion1xx.getInternalHeldTables()
|
BufferedDataTable[] |
Node.getInternalHeldTables()
Get the current set of tables internally held by a NodeModel that implements BufferedDataTableHolder . |
BufferedDataTable[] |
NodeContentPersistor.getInternalHeldTables()
|
BufferedDataTable[] |
CopyNodePersistor.getInternalHeldTables()
|
BufferedDataTable[] |
BufferedDataTableHolder.getInternalTables()
|
BufferedDataTable[] |
BufferedDataTable.KnowsRowCountTable.getReferenceTables()
Reference to the underlying tables, if any. |
BufferedDataTable |
BufferedDataContainer.getTable()
Returns the content of this container in a BufferedDataTable. |
(package private) static BufferedDataTable |
BufferedDataTable.loadFromFile(ReferencedFile dirRef,
NodeSettingsRO settings,
ExecutionMonitor exec,
Map<Integer,BufferedDataTable> tblRep,
HashMap<Integer,ContainerTable> bufferRep)
Factory method to restore a table that has been written using the save method. |
Methods in org.knime.core.node that return types with arguments of type BufferedDataTable | |
---|---|
(package private) static PortObject.PortObjectSerializer<BufferedDataTable> |
BufferedDataTable.getPortObjectSerializer()
Throws IllegalStateException as this method is not
supposed to be called; refer to the API of PortObject for details
on this method. |
Methods in org.knime.core.node with parameters of type BufferedDataTable | |
---|---|
BufferedDataTable |
ExecutionContext.createColumnRearrangeTable(BufferedDataTable in,
ColumnRearranger rearranger,
ExecutionMonitor subProgressMon)
Creates a new BufferedDataTable based on a given input table
(in ) whereby only some of the columns of in
have changed. |
BufferedDataTable |
ExecutionContext.createConcatenateTable(ExecutionMonitor exec,
BufferedDataTable... tables)
Creates a new BufferedDataTable , which is row-wise
concatenation of the argument tables. |
BufferedDataTable |
ExecutionContext.createJoinedTable(BufferedDataTable left,
BufferedDataTable right,
ExecutionMonitor exec)
Creates a new BufferedDataTable that is a column based join of
the argument tables. |
BufferedDataTable |
ExecutionContext.createSpecReplacerTable(BufferedDataTable in,
DataTableSpec newSpec)
Creates a new BufferedDataTable based on a given input table
(in ) whereby only the table spec of it has changed. |
BufferedDataTable |
ExecutionContext.createWrappedTable(BufferedDataTable in)
Creates a new BufferedDataTable that simply wraps the
argument table. |
protected BufferedDataTable[] |
NodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
This function is invoked by the Node#executeNode() method
of the node (through the
#executeModel(BufferedDataTable[],ExecutionMonitor)
method)only after all predecessor nodes have been successfully executed
and all data is therefore available at the input ports. |
static void |
Node.invokeEnsureOpen(BufferedDataTable table)
Exposes ensureOpen() as public method. |
static void |
BufferedDataTable.putDataTable(Map<Integer,BufferedDataTable> tblRep,
BufferedDataTable t)
Method that is used internally while the workflow is being loaded. |
void |
NodePersistorVersion1xx.setInternalHeldTables(BufferedDataTable[] internalHeldTables)
|
void |
BufferedDataTableHolder.setInternalTables(BufferedDataTable[] tables)
Allows the WorkflowManager to set information about new BDTs, for instance after load. |
Method parameters in org.knime.core.node with type arguments of type BufferedDataTable | |
---|---|
static BufferedDataTable |
BufferedDataTable.getDataTable(Map<Integer,BufferedDataTable> tblRep,
Integer tableID)
Method that is used internally while the workflow is being loaded. |
void |
NodePersistorVersion1xx.load(Node node,
ReferencedFile configFileRef,
ExecutionMonitor exec,
Map<Integer,BufferedDataTable> loadTblRep,
HashMap<Integer,ContainerTable> tblRep,
WorkflowPersistor.LoadResult loadResult)
Loads content into node instance. |
(package private) static BufferedDataTable |
BufferedDataTable.loadFromFile(ReferencedFile dirRef,
NodeSettingsRO settings,
ExecutionMonitor exec,
Map<Integer,BufferedDataTable> tblRep,
HashMap<Integer,ContainerTable> bufferRep)
Factory method to restore a table that has been written using the save method. |
protected void |
NodePersistorVersion1xx.loadInternalHeldTables(Node node,
ExecutionMonitor execMon,
NodeSettingsRO settings,
Map<Integer,BufferedDataTable> loadTblRep,
HashMap<Integer,ContainerTable> tblRep)
|
protected void |
NodePersistorVersion200.loadInternalHeldTables(Node node,
ExecutionMonitor execMon,
NodeSettingsRO settings,
Map<Integer,BufferedDataTable> loadTblRep,
HashMap<Integer,ContainerTable> tblRep)
|
protected void |
NodePersistorVersion200.loadPort(Node node,
ReferencedFile portDir,
NodeSettingsRO settings,
ExecutionMonitor exec,
int portIdx,
Map<Integer,BufferedDataTable> loadTblRep,
HashMap<Integer,ContainerTable> tblRep)
|
protected void |
NodePersistorVersion1xx.loadPorts(Node node,
ExecutionMonitor execMon,
NodeSettingsRO settings,
Map<Integer,BufferedDataTable> loadTblRep,
HashMap<Integer,ContainerTable> tblRep)
|
protected void |
NodePersistorVersion200.loadPorts(Node node,
ExecutionMonitor exec,
NodeSettingsRO settings,
Map<Integer,BufferedDataTable> loadTblRep,
HashMap<Integer,ContainerTable> tblRep)
|
static void |
BufferedDataTable.putDataTable(Map<Integer,BufferedDataTable> tblRep,
BufferedDataTable t)
Method that is used internally while the workflow is being loaded. |
Uses of BufferedDataTable in org.knime.core.node.interrupt |
---|
Methods in org.knime.core.node.interrupt that return BufferedDataTable | |
---|---|
BufferedDataTable[] |
InterruptibleNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
Initialises the NodeModel, starts the execution, pauses it, resumes it and finishes it. |
BufferedDataTable[] |
InterruptibleNodeModel.getInputData()
Returns the input data that was connected to the node at the beginning of the execute method as a whole. |
abstract BufferedDataTable[] |
InterruptibleNodeModel.getOutput(ExecutionContext exec)
Is called at the end of the execute method when it is finished and the data should be available. |
Methods in org.knime.core.node.interrupt with parameters of type BufferedDataTable | |
---|---|
BufferedDataTable[] |
InterruptibleNodeModel.execute(BufferedDataTable[] inData,
ExecutionContext exec)
Initialises the NodeModel, starts the execution, pauses it, resumes it and finishes it. |
abstract void |
InterruptibleNodeModel.init(BufferedDataTable[] inData,
ExecutionContext exec)
Do here the initialisation of the model. |
Uses of BufferedDataTable in org.knime.core.node.port.database |
---|
Methods in org.knime.core.node.port.database that return BufferedDataTable | |
---|---|
BufferedDataTable |
DatabaseReaderConnection.createTable(ExecutionContext exec)
Read data from database. |
Uses of BufferedDataTable in org.knime.core.node.workflow |
---|
Methods in org.knime.core.node.workflow that return BufferedDataTable | |
---|---|
BufferedDataTable[] |
SingleNodeContainer.getInternalHeldTables()
Get the tables that are kept by the underlying node. |
Uses of BufferedDataTable in org.knime.core.node.workflow.execresult |
---|
Methods in org.knime.core.node.workflow.execresult that return BufferedDataTable | |
---|---|
BufferedDataTable[] |
NodeExecutionResult.getInternalHeldTables()
|
Methods in org.knime.core.node.workflow.execresult with parameters of type BufferedDataTable | |
---|---|
void |
NodeExecutionResult.setInternalHeldTables(BufferedDataTable[] internalHeldTables)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |