Examples with TableFilter org.knime.core.data.container.filter.TableFilter used on opensource projects

Example 1 with TableFilter

use of org.knime.core.data.container.filter.TableFilter in project knime-core by knime.

the class KnowsRowCountTableIteratorWithFilterTest method testColumnRearrangeTablePermute.

/**
 * Tests that {@link TableFilter TableFilters} are correctly transformed and applied to permuted
 * {@link RearrangeColumnsTable RearrangeColumnsTables}.
 *
 * @throws Exception any kind of exception
 */
@Test
public void testColumnRearrangeTablePermute() throws Exception {
    final BufferedDataTable table = createTable(0, 8, 8, 0, 16);
    ExecutionContext exec = exec();
    ColumnRearranger rearranger = new ColumnRearranger(table.getSpec());
    rearranger.permute(new int[] { 7, 6, 5, 4, 3, 2, 1, 0 });
    final BufferedDataTable rearrangedTable = exec.createColumnRearrangeTable(table, rearranger, exec);
    rearranger = new ColumnRearranger(rearrangedTable.getSpec());
    rearranger.permute(new int[] { 7, 6, 5, 4, 3, 2, 1, 0 });
    final BufferedDataTable reRearrangedTable = exec.createColumnRearrangeTable(rearrangedTable, rearranger, exec);
    final TableFilter filter = createFilter(2, 6, 4, 12);
    compareTables(table, reRearrangedTable, filter);
}

Example 2 with TableFilter

use of org.knime.core.data.container.filter.TableFilter in project knime-core by knime.

the class WindowCacheTable method getNewDataIterator.

/**
 * Get new iterator, only to be called when data is set. If predicates are set those are tried to push down to
 * the iterator.
 */
private RowIterator getNewDataIterator() {
    assert hasData();
    if (m_table instanceof BufferedDataTable && m_includedColumnIndices != null) {
        BufferedDataTable bdt = (BufferedDataTable) m_table;
        DataTableSpec spec = bdt.getSpec();
        TableFilter filter = materializeCols(spec, m_includedColumnIndices.stream().toArray(String[]::new));
        return bdt.filter(filter).iterator();
    }
    return m_table.iterator();
}

Example 3 with TableFilter

use of org.knime.core.data.container.filter.TableFilter in project knime-core by knime.

the class Buffer method iteratorWithFilter.

// This method might return a FilterDelegateRowIterator that wraps a CloseableRowIterator. This leads to a warning
// about the wrapped iterator potentially not being closed. It is safe to disregard this warning though, since
// the FilterDelegateRowIterator takes care of closing the wrapped iterator.
@SuppressWarnings("resource")
final synchronized CloseableRowIterator iteratorWithFilter(final TableFilter filter, final ExecutionMonitor exec) {
    if (m_isClearedLock.booleanValue()) {
        throw new IllegalStateException("Cannot iterate over table: buffer has been cleared.");
    }
    final List<BlobSupportDataRow> list = obtainListFromCacheOrBackIntoMemoryIterator();
    if (list == null) {
        // Case 1: We don't have have the table in memory and want to iterate it back into memory.
        if (m_useBackIntoMemoryIterator) {
            m_useBackIntoMemoryIterator = false;
            final TableStoreCloseableRowIterator tableStoreIt = m_outputReader.iterator();
            tableStoreIt.setBuffer(this);
            m_nrOpenInputStreams.incrementAndGet();
            final BackIntoMemoryIterator backIntoMemoryIt = new BackIntoMemoryIterator(tableStoreIt, size());
            m_openResources.register(tableStoreIt, backIntoMemoryIt);
            m_backIntoMemoryIteratorRef = new WeakReference<>(backIntoMemoryIt);
            final FromListIterator listIt = new FromListIterator(backIntoMemoryIt.getList(), exec);
            listIt.setBackIntoMemoryIterator(backIntoMemoryIt);
            return filter == null ? listIt : new FilterDelegateRowIterator(listIt, filter, size(), exec);
        }
        // Case 2: We don't have have the table in memory.
        final TableStoreCloseableRowIterator tableStoreIt = filter == null ? m_outputReader.iterator() : m_outputReader.iteratorWithFilter(filter, exec);
        // register the table store iterator with this buffer
        tableStoreIt.setBuffer(this);
        m_nrOpenInputStreams.incrementAndGet();
        m_openResources.register(tableStoreIt, tableStoreIt);
        return tableStoreIt;
    } else {
        final BackIntoMemoryIterator backIntoMemoryIt = m_backIntoMemoryIteratorRef != null ? m_backIntoMemoryIteratorRef.get() : null;
        if (filter != null && size() > 0) {
            // Case 3: We have the full table in memory and want to apply a filter.
            if (backIntoMemoryIt == null) {
                // We never store more than 2^31 rows in memory, therefore it's safe to cast to int.
                final int fromIndex = (int) Math.min(Integer.MAX_VALUE, filter.getFromRowIndex().orElse(0l));
                final int toIndex = (int) Math.min(Integer.MAX_VALUE, filter.getToRowIndex().orElse(size() - 1));
                final FromListRangeIterator rangeIterator = new FromListRangeIterator(list, fromIndex, toIndex, exec);
                /**
                 * In a future world (a world of predicates, see AP-11805), the filter might be configured to keep
                 * only rows with an index between 1000 and 2000 and a value greater than 42 in column 13. The
                 * rangeIterator will take care of only returning rows with an index between 1000 and 2000. In
                 * fact, it will return the row with index 1000 as its first row. Therefore, the
                 * FilterDelegateRowIterator that handles the column-13-greater-than-42-predicate, has to be
                 * provided with a copied filter with adjusted from- and toRowIndices.
                 */
                final TableFilter offsetFilter = // 
                new TableFilter.Builder(filter).withFromRowIndex(// 
                0).withToRowIndex(// 
                toIndex - fromIndex).build();
                return new FilterDelegateRowIterator(rangeIterator, offsetFilter, size(), exec);
            } else // Case 4: We are currently iterating the table back into memory and want to apply a filter.
            {
                final FromListIterator listIt = new FromListIterator(list, exec);
                listIt.setBackIntoMemoryIterator(backIntoMemoryIt);
                return new FilterDelegateRowIterator(listIt, filter, size(), exec);
            }
        }
        // Case 5: We have at least parts of the table in memory and don't want to apply a filter.
        final FromListIterator listIt = new FromListIterator(list, exec);
        if (backIntoMemoryIt != null) {
            listIt.setBackIntoMemoryIterator(backIntoMemoryIt);
        }
        return listIt;
    }
}

Example 4 with TableFilter

use of org.knime.core.data.container.filter.TableFilter in project knime-core by knime.

the class KnowsRowCountTableIteratorWithFilterTest method testJoinedTable.

/**
 * Tests that {@link TableFilter TableFilters} are correctly transformed and applied to {@link JoinedTable
 * JoinedTables}.
 *
 * @throws Exception any kind of exception
 */
@Test
public void testJoinedTable() throws Exception {
    final BufferedDataTable fullTable = createTable(0, 16, 16, 0, 16);
    final BufferedDataTable leftTable = createTable(0, 8, 16, 0, 16);
    final BufferedDataTable rightTable = createTable(8, 16, 16, 0, 16);
    ExecutionContext exec = exec();
    final BufferedDataTable concatenateTable = exec.createJoinedTable(leftTable, rightTable, exec);
    final TableFilter filter = createFilter(4, 12, 4, 12);
    compareTables(fullTable, concatenateTable, filter);
    compareTables(fullTable, concatenateTable, createFilter(4, 12, 4, 12));
    compareTables(fullTable, concatenateTable, createFilter(4, 6, 4, 12));
    compareTables(fullTable, concatenateTable, createFilter(10, 12, 4, 12));
}

Example 5 with TableFilter

use of org.knime.core.data.container.filter.TableFilter in project knime-core by knime.

the class RearrangeColumnsTable method iterator.

/**
 * {@inheritDoc}
 */
@Override
@SuppressWarnings("resource")
public CloseableRowIterator iterator() {
    // determine iterator for appended table
    CloseableRowIterator appendIt = EMPTY_ITERATOR;
    if (m_appendTable != null) {
        final int[] appendIndices = // 
        IntStream.range(0, m_map.length).filter(// 
        i -> !m_isFromRefTable[i]).map(// 
        i -> m_map[i]).toArray();
        final TableFilter appendFilter = materializeCols(appendIndices);
        appendIt = m_appendTable.iteratorWithFilter(appendFilter);
    }
    // determine iterator for reference table
    final int[] refIndices = // 
    IntStream.range(0, m_map.length).filter(// 
    i -> m_isFromRefTable[i]).map(// 
    i -> m_map[i]).toArray();
    final TableFilter refFilter = materializeCols(refIndices);
    final CloseableRowIterator refIt = m_reference.filter(refFilter).iterator();
    return new JoinTableIterator(refIt, appendIt, m_map, m_isFromRefTable);
}