Java DataSet.getSelectItems方法代码示例

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
private void runConversionTest(SalesforceDataContext dc, String tableName) {
    Query q = dc.query().from(tableName).selectAll().toQuery();
    q.setMaxRows(1);

    final DataSet ds = dc.executeQuery(q);
    final List<SelectItem> selectItems = ds.getSelectItems();
    while (ds.next()) {
        Row row = ds.getRow();

        for (SelectItem selectItem : selectItems) {
            Column column = selectItem.getColumn();
            Object value = row.getValue(column);
            if (value != null) {
                ColumnType type = column.getType();
                Class<?> expected = type.getJavaEquivalentClass();
                Class<? extends Object> actual = value.getClass();
                assertEquals("Unexpected type of value: " + value + ". Expected " + expected.getName()
                        + " but found " + actual.getName() + ". Native type was: " + column.getNativeType(),
                        expected, actual);
            }
        }
    }
}
 

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
public static DataSet getFiltered(DataSet dataSet, Collection<FilterItem> filterItems) {
    if (filterItems == null || filterItems.isEmpty()) {
        return dataSet;
    }
    final List<SelectItem> selectItemsOnOutput = dataSet.getSelectItems();
    final Iterable<SelectItem> selectItems =
            filterItems.stream().map(f -> f.getSelectItem()).filter(s -> s != null)::iterator;
    final List<SelectItem> scalarFunctionSelectItems =
            getUnmaterializedScalarFunctionSelectItems(selectItems, dataSet);
    final boolean calculateScalarFunctions = !scalarFunctionSelectItems.isEmpty();
    if (calculateScalarFunctions) {
        // scalar functions are needed in evaluation of the filters
        dataSet = new ScalarFunctionDataSet(scalarFunctionSelectItems, dataSet);
    }
    final FilteredDataSet filteredDataSet = new FilteredDataSet(dataSet, filterItems);
    if (calculateScalarFunctions) {
        return getSelection(selectItemsOnOutput, filteredDataSet);
    } else {
        return filteredDataSet;
    }
}
 

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
@Override
public final DataSet intercept(DataSet dataSet) {
	Map<Column, TypeConverter<?, ?>> converters = getConverters(dataSet);
	if (converters.isEmpty()) {
		return dataSet;
	}

	boolean hasConverter = false;
	List<SelectItem> selectItems = dataSet.getSelectItems();
	TypeConverter<?, ?>[] converterArray = new TypeConverter[selectItems.size()];
	for (int i = 0; i < selectItems.size(); i++) {
		SelectItem selectItem = selectItems.get(i);
		Column column = selectItem.getColumn();
		if (column != null && selectItem.getAggregateFunction() == null) {
			TypeConverter<?, ?> converter = converters.get(column);
			if (converter != null) {
				hasConverter = true;
				converterArray[i] = converter;
			}
		}
	}

	if (!hasConverter) {
		return dataSet;
	}

	return new ConvertedDataSet(dataSet, converterArray);
}
 

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
/**
 * Executes a simple nested loop join. The innerLoopDs will be copied in an in-memory dataset.
 *
 */
public static InMemoryDataSet nestedLoopJoin(DataSet innerLoopDs, DataSet outerLoopDs,
        Iterable<FilterItem> filtersIterable) {

    List<FilterItem> filters = new ArrayList<>();
    for (FilterItem fi : filtersIterable) {
        filters.add(fi);
    }
    List<Row> innerRows = innerLoopDs.toRows();

    List<SelectItem> allItems = new ArrayList<>(outerLoopDs.getSelectItems());
    allItems.addAll(innerLoopDs.getSelectItems());

    Set<FilterItem> applicableFilters = applicableFilters(filters, allItems);

    DataSetHeader jointHeader = new CachingDataSetHeader(allItems);

    List<Row> resultRows = new ArrayList<>();
    for (Row outerRow : outerLoopDs) {
        for (Row innerRow : innerRows) {

            Object[] joinedRowObjects = new Object[outerRow.getValues().length + innerRow.getValues().length];

            System.arraycopy(outerRow.getValues(), 0, joinedRowObjects, 0, outerRow.getValues().length);
            System.arraycopy(innerRow.getValues(), 0, joinedRowObjects, outerRow.getValues().length,
                    innerRow.getValues().length);

            Row joinedRow = new DefaultRow(jointHeader, joinedRowObjects);

            if (applicableFilters.isEmpty() || applicableFilters.stream().allMatch(fi -> fi.accept(joinedRow))) {
                resultRows.add(joinedRow);
            }
        }
    }

    return new InMemoryDataSet(jointHeader, resultRows);
}
 

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
public static DataSet getSelection(final List<SelectItem> selectItems, final DataSet dataSet) {
    final List<SelectItem> dataSetSelectItems = dataSet.getSelectItems();

    // check if the selection is already the same
    if (selectItems.equals(dataSetSelectItems)) {
        // return the DataSet unmodified
        return dataSet;
    }

    final List<SelectItem> scalarFunctionSelectItemsToEvaluate = new ArrayList<>();

    for (SelectItem selectItem : selectItems) {
        if (selectItem.getScalarFunction() != null) {
            if (!dataSetSelectItems.contains(selectItem)
                    && dataSetSelectItems.contains(selectItem.replaceFunction(null))) {
                scalarFunctionSelectItemsToEvaluate.add(selectItem);
            }
        }
    }

    if (scalarFunctionSelectItemsToEvaluate.isEmpty()) {
        return new SubSelectionDataSet(selectItems, dataSet);
    }

    final ScalarFunctionDataSet scalaFunctionDataSet =
            new ScalarFunctionDataSet(scalarFunctionSelectItemsToEvaluate, dataSet);
    return new SubSelectionDataSet(selectItems, scalaFunctionDataSet);
}
 

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
/**
 * Performs a right join (aka right outer join) operation on two datasets.
 * 
 * @param ds1 the left dataset
 * @param ds2 the right dataset
 * @param onConditions the conditions to join by
 * @return the right joined result dataset
 */
public static DataSet getRightJoin(DataSet ds1, DataSet ds2, FilterItem[] onConditions) {
    List<SelectItem> ds1selects = ds1.getSelectItems();
    List<SelectItem> ds2selects = ds2.getSelectItems();
    List<SelectItem> leftOrderedSelects = new ArrayList<>();
    leftOrderedSelects.addAll(ds1selects);
    leftOrderedSelects.addAll(ds2selects);

    // We will reuse the left join algorithm (but switch the datasets
    // around)
    DataSet dataSet = getLeftJoin(ds2, ds1, onConditions);

    dataSet = getSelection(leftOrderedSelects, dataSet);
    return dataSet;
}
 

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
public void testSelectItemReferencesToFromItems() throws Exception {
    MockDataContext dc = new MockDataContext("sch", "tab", "1");

    Table table = dc.getDefaultSchema().getTable(0);

    Query q = new Query();
    FromItem fromItem1 = q.from(table, "t1").getFromClause().getItem(0);
    FromItem fromItem2 = q.from(table, "t2").getFromClause().getItem(1);
    q.select(table.getColumnByName("foo"), fromItem1);
    q.select(table.getColumnByName("foo"), fromItem2);
    q.where(q.getSelectClause().getItem(0), OperatorType.EQUALS_TO, "2");
    assertEquals("SELECT t1.foo, t2.foo FROM sch.tab t1, sch.tab t2 WHERE t1.foo = '2'", q.toSql());

    DataSet ds = dc.executeQuery(q);
    List<SelectItem> selectItems = ds.getSelectItems();
    assertEquals(2, selectItems.size());
    assertEquals("t1.foo", selectItems.get(0).toSql());
    assertEquals("t2.foo", selectItems.get(1).toSql());
    assertTrue(ds.next());
    assertEquals("Row[values=[2, 1]]", ds.getRow().toString());
    assertTrue(ds.next());
    assertEquals("Row[values=[2, 2]]", ds.getRow().toString());
    assertTrue(ds.next());
    assertEquals("Row[values=[2, 3]]", ds.getRow().toString());
    assertTrue(ds.next());
    assertEquals("Row[values=[2, 4]]", ds.getRow().toString());
    assertFalse(ds.next());
    ds.close();
}
 

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
public ConvertedDataSet(DataSet dataSet, TypeConverter<?, ?>[] converters) {
    super(dataSet.getSelectItems());
    _dataSet = dataSet;
    _converters = converters;
}
 

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
/**
 * Performs a left join (aka left outer join) operation on two datasets.
 * 
 * @param ds1 the left dataset
 * @param ds2 the right dataset
 * @param onConditions the conditions to join by
 * @return the left joined result dataset
 */
public static DataSet getLeftJoin(DataSet ds1, DataSet ds2, FilterItem[] onConditions) {
    if (ds1 == null) {
        throw new IllegalArgumentException("Left DataSet cannot be null");
    }
    if (ds2 == null) {
        throw new IllegalArgumentException("Right DataSet cannot be null");
    }
    List<SelectItem> si1 = ds1.getSelectItems();
    List<SelectItem> si2 = ds2.getSelectItems();
    List<SelectItem> selectItems = Stream.concat(si1.stream(), si2.stream()).collect(Collectors.toList());
    List<Row> resultRows = new ArrayList<Row>();
    List<Row> ds2data = readDataSetFull(ds2);
    if (ds2data.isEmpty()) {
        // no need to join, simply return a new view (with null values) on
        // the previous dataset.
        return getSelection(selectItems, ds1);
    }

    final DataSetHeader header = new CachingDataSetHeader(selectItems);

    while (ds1.next()) {

        // Construct a single-row dataset for making a carthesian product
        // against ds2
        Row ds1row = ds1.getRow();
        List<Row> ds1rows = new ArrayList<Row>();
        ds1rows.add(ds1row);

        DataSet carthesianProduct =
                getCarthesianProduct(new DataSet[] { new InMemoryDataSet(new CachingDataSetHeader(si1), ds1rows),
                        new InMemoryDataSet(new CachingDataSetHeader(si2), ds2data) }, onConditions);
        List<Row> carthesianRows = readDataSetFull(carthesianProduct);
        if (carthesianRows.size() > 0) {
            resultRows.addAll(carthesianRows);
        } else {
            Object[] values = ds1row.getValues();
            Object[] row = new Object[selectItems.size()];
            System.arraycopy(values, 0, row, 0, values.length);
            resultRows.add(new DefaultRow(header, row));
        }
    }
    ds1.close();

    if (resultRows.isEmpty()) {
        return new EmptyDataSet(selectItems);
    }

    return new InMemoryDataSet(header, resultRows);
}
 

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
public static DataSet getDistinct(DataSet dataSet) {
    List<SelectItem> selectItems = dataSet.getSelectItems();
    List<GroupByItem> groupByItems = selectItems.stream().map(GroupByItem::new).collect(Collectors.toList());

    return getGrouped(selectItems, dataSet, groupByItems);
}