Package org.knime.core.data.container

Implementation of a DataContainer.

See: Description

Interface Summary

Interface	Description
CellFactory	Factory for a ColumnRearranger to provide new columns which are, e.g.
KNIMEStreamConstants	Defines some constants commonly used when writing Buffer files.
RowAppender	This is a very simple interface that allows adding DataRows to a DataTable, DataContainer, or anything else.

Class Summary

Class	Description
AbstractCellFactory	Default implementation of a CellFactory, which creates more than a single new column.
BlobDataCell	Abstract Binary large object cell used to handle potentially large cells.
BlobDataCell.BlobAddress	Utility class that holds information where the blob is located.
BlobSupportDataRow	Special row implementation that supports to access the wrapper cells of BlobDataCell.
BlobWrapperDataCell	Wrapper for BlobDataCell.
BlockableInputStream	Input Stream that wraps a given input stream and searches for terminated end blocks.
BlockableOutputStream	Output stream that allows to set block marks.
Buffer	A buffer writes the rows from a DataContainer to a file.
Buffer.FromFileIterator	Super class of all file iterators.
BufferFromFileIteratorVersion1x	(Obsolete) File iterator to read files written by a Buffer.
BufferFromFileIteratorVersion20	File iterator to read stream written by a Buffer.
BufferFromFileIteratorVersion20.DataCellStreamReader	Utility class that separates the logic of reading DataCells from the stream.
BufferTracker	This class is only used for testing.
CellClassInfo	Pair of cell class and possibly a DataType that represents the collection element type (only if cell class is a collection).
CloseableRowIterator	A row iterator that can be closed in order to save resources.
ColumnRearranger	Meta object to describe in which way a table shall be modified (column-based) to create a new table.
ColumnRearranger.DataCellTypeConverterCellFactory
ColumnRearranger.SpecAndFactoryObject	Utility class that helps us with internal data structures.
ColumnRearrangerFunction
ConcatenateTable
ContainerTable	Class implementing the DataTable interface and using a buffer from a DataContainer as data source.
CopyOnAccessTask	Opens (on demand) a zip file from the workspace location and copies the binary data content to temp for further reading.
DataContainer	Buffer that collects DataRow objects and creates a DataTable on request.
DataContainer.BufferCreator	Helper class to create a Buffer instance given a binary file and the data table spec.
DCObjectInputStream	Obsolete input stream to read Files written with Buffer objects in KNIME 1.x (and 2.0TechPreview).
DCObjectInputVersion2	Class interpreting the file format as written by the Buffer class.
DCObjectOutputVersion2	Object writing the binary stream of a Buffer.
JoinedTable	Class that realizes a join table of two BufferedDataTable arguments.
JoinTableIterator	Internal iterator class that concatenates two rows.
LongUTFDataInputStream	Input Stream that's used to read from stream written by LongUTFDataOuputStream.
LongUTFDataOutputStream	Wrapper class of a DataOutputStream that also allows to write UTF strings longer than 65535.
NoKeyBuffer	Buffer implementation that does not write the row keys.
PriorityGlobalObjectInputStream	Object input stream, which can be used to load classes using a given preferred ClassLoader.
RearrangeColumnsTable	Table implementation that is created based on a ColumnRearranger.
RearrangeColumnsTable.NewColumnsProducerMapping	A class that helps to distinguish SpecAndFactoryObjects.
SingleCellFactory	Convenience implementation of a cell factory with one new column.
TableSpecReplacerTable	Table that only replaces the data table spec of an underlying table.
VoidTable	A table that is void and only a placeholder for a streamed output.
WrappedTable	Special table implementation that simply wraps a given BufferedDataTable.

Enum Summary

Enum	Description
Buffer.CompressionFormat	Compression on the binary (main) file.

Exception Summary

Exception	Description
DataContainerException	Exception that may be thrown by a DataContainer if the data is invalid.

Package org.knime.core.data.container Description

Implementation of a DataContainer.

A DataContainer is a buffer that you can use to fill a data table. Use this class when you create much (and also just little) data and you don't want to bother about a data structure that keeps the calculated data. A DataContainer will take care of it, it will memorize the rows that you've added and also buffer it to the disk when the data gets large so that memory gets a bottleneck. Typically, you write code like this:

  DataContainer container = new DataContainer();
  container.open(aDataTableSpec);
  for (...) {
    DataRow newRow = calculateRow();
    container.add(newRow)
  }
  container.close();
  DataTable result = container.getTable();
        

This package contains also implementations for easy storage of datatables whose columns have changed. For further details on how to use them, refer to the description of NodeModel and its execute method.