Java DataSet类代码示例

import org.apache.metamodel.data.DataSet; //导入依赖的package包/类
private void insertRowIntoBlockingQueue(DataSet dataset) throws InterruptedException {

		hashedColumn = table.getColumnByName(columnName);
		requests = metrics.meter("read thread");

		while (dataset.next()) {
			Row row = dataset.getRow();
			if (horizontal && isKey(row)) {
				queue.put(row);
				requests.mark();
			} else {
			    if(!horizontal){
				queue.put(row);
				requests.mark();
			    }
			}

		}

	}
 

import org.apache.metamodel.data.DataSet; //导入依赖的package包/类
public void readComplexData() throws Exception {
		Column primaryColumn = dataContext.getTableByQualifiedLabel(joinTable).getColumnByName(secondFkey);
		System.out.println(dataContext.query().from(joinTable).select(primaryColumn).groupBy(primaryColumn).toQuery().toString());
		DataSet dataSet = dataContext.query().from(joinTable).select(primaryColumn).groupBy(primaryColumn).execute();
		while (dataSet.next()) {

			arrayData = new ArrayList<Row>();
			Object dataValue = dataSet.getRow().getValue(primaryColumn);
			DataSet dataSetArray = dataContext.query().from(joinTable).select(forgeinKey).where(primaryColumn)
					.eq(dataValue).execute();
			System.out.println( dataContext.query().from(joinTable).select(forgeinKey).where(primaryColumn)
					.eq(dataValue).toQuery().toSql());
			readDataSet(dataSetArray);
			ComplexData complexDataObject = new ComplexData(dataSet.getRow(), arrayData);
			queueComplexData.put(complexDataObject);
			dataSetArray.close();
//			dataContext.executeUpdate();

		}
		insertPosion();
		dataSet.close();

	}
 

import org.apache.metamodel.data.DataSet; //导入依赖的package包/类
public SimpleDictionary loadIntoMemory(final DatastoreConnection datastoreConnection) {
    final DataContext dataContext = datastoreConnection.getDataContext();
    final Column column = getColumn(datastoreConnection);

    final Query query = dataContext.query().from(column.getTable()).select(column).toQuery();
    if (datastoreConnection.getDatastore().getPerformanceCharacteristics().isQueryOptimizationPreferred()) {
        query.getSelectClause().setDistinct(true);
    }

    final Set<String> values = new HashSet<>();

    try (DataSet dataSet = dataContext.executeQuery(query)) {
        while (dataSet.next()) {
            final Object value = dataSet.getRow().getValue(0);
            if (value != null) {
                values.add(value.toString());
            }
        }
    }

    return new SimpleDictionary(getName(), values);
}
 

import org.apache.metamodel.data.DataSet; //导入依赖的package包/类
public SimpleSynonymCatalog loadIntoMemory(final DatastoreConnection datastoreConnection) {
    final Map<String, String> synonymMap = new HashMap<>();

    final Column masterTermColumn = getMasterTermColumn(datastoreConnection);
    final Column[] columns = getSynonymColumns(datastoreConnection);

    try (DataSet dataSet = datastoreConnection.getDataContext().query().from(masterTermColumn.getTable().getName())
            .select(masterTermColumn).select(columns).execute()) {
        while (dataSet.next()) {
            final Row row = dataSet.getRow();
            final String masterTerm = getMasterTerm(row, masterTermColumn);
            final String[] synonyms = getSynonyms(row, columns);
            for (final String synonym : synonyms) {
                synonymMap.put(synonym, masterTerm);
            }
        }
    }

    return new SimpleSynonymCatalog(getName(), synonymMap);
}
 

import org.apache.metamodel.data.DataSet; //导入依赖的package包/类
private Object[] performQuery(final InputRow row, final List<Object> queryInput) {
    try {
        final Column[] queryConditionColumns = getQueryConditionColumns();

        final Object[] parameterValues = new Object[queryConditionColumns.length];
        for (int i = 0; i < queryConditionColumns.length; i++) {
            parameterValues[i] = queryInput.get(i);
        }

        try (DataSet dataSet = datastoreConnection.getDataContext().executeQuery(lookupQuery, parameterValues)) {
            return handleDataSet(row, dataSet);
        }
    } catch (final RuntimeException e) {
        logger.error("Error occurred while looking up based on conditions: " + queryInput, e);
        throw e;
    }
}
 

import org.apache.metamodel.data.DataSet; //导入依赖的package包/类
public DataSetWindow(final Query query, final DataContext dataContext, final int pageSize,
        final WindowContext windowContext) {
    super(windowContext);
    _table = new DCTable();
    _query = query;
    _pageSize = pageSize;
    _title = "DataSet: " + _query.toSql();
    _tableModelCallable = () -> {
        final DataSet dataSet = dataContext.executeQuery(_query);
        return new DataSetTableModel(dataSet);
    };
    _previousPageButton = WidgetFactory.createDefaultButton("Previous page", IconUtils.ACTION_BACK);
    _previousPageButton.setEnabled(false);
    _nextPageButton = WidgetFactory.createDefaultButton("Next page", IconUtils.ACTION_FORWARD);
    _nextPageButton.setHorizontalTextPosition(SwingConstants.LEFT);
    _nextPageButton.setEnabled(false);
}
 

import org.apache.metamodel.data.DataSet; //导入依赖的package包/类
private DataSet getPreviewData(final String filename) {
    if (!isPreviewDataAvailable()) {
        logger.info("Not displaying preview table because isPreviewDataAvailable() returned false");
        return null;
    }

    final D datastore = getPreviewDatastore(filename);
    try (DatastoreConnection con = datastore.openConnection()) {
        final DataContext dc = con.getDataContext();
        final Table table = getPreviewTable(dc);

        List<Column> columns = table.getColumns();
        if (columns.size() > getPreviewColumns()) {
            // include max 10 columns
            columns = columns.stream().limit(getPreviewColumns()).collect(Collectors.toList());
        }
        final Query q = dc.query().from(table).select(columns).toQuery();
        q.setMaxRows(7);

        return dc.executeQuery(q);
    }
}
 

import org.apache.metamodel.data.DataSet; //导入依赖的package包/类
public void performAssertions(final DataSet dataSet, final boolean typeSafe) {
    Assert.assertTrue(dataSet.next());
    assertEquals("hello, world", dataSet.getRow().getValue(0), typeSafe);
    assertEquals(null, dataSet.getRow().getValue(1), typeSafe);

    assertEquals(getExampleDate(), dataSet.getRow().getValue(2), typeSafe);
    assertEquals(null, dataSet.getRow().getValue(3), typeSafe);

    Assert.assertTrue(dataSet.next());
    assertEquals(null, dataSet.getRow().getValue(0), typeSafe);
    assertEquals(-20, dataSet.getRow().getValue(1), typeSafe);
    assertEquals(null, dataSet.getRow().getValue(2), typeSafe);
    assertEquals(3.14f, dataSet.getRow().getValue(3), typeSafe);
    assertEquals("testObject", dataSet.getRow().getValue(4), typeSafe);

    Assert.assertFalse(dataSet.next());
}
 

import org.apache.metamodel.data.DataSet; //导入依赖的package包/类
public void testFullScenario() throws Exception {
    final OutputWriterScenarioHelper scenarioHelper = new OutputWriterScenarioHelper();

    final String filename = "target/test-output/csv-file1.txt";
    final OutputWriter writer = CsvOutputWriterFactory.getWriter(filename, scenarioHelper.getColumns());

    scenarioHelper.writeExampleData(writer);
    writer.close();

    final DataContext dc = DataContextFactory.createCsvDataContext(new File(filename));
    final Table table = dc.getDefaultSchema().getTable(0);
    final Query q = dc.query().from(table).select(table.getColumns()).toQuery();
    final DataSet dataSet = dc.executeQuery(q);

    scenarioHelper.performAssertions(dataSet, false);
}
 

import org.apache.metamodel.data.DataSet; //导入依赖的package包/类
@Override
protected DataSet materializeMainSchemaTable(final Table table, final List<Column> columns, final int maxRows) {
    final SelectItem[] tableSelectItems = MetaModelHelper.createSelectItems(table.getColumns().toArray(new Column[0]));
    final SelectItem[] selectItems = MetaModelHelper.createSelectItems(columns.toArray(new Column[0]));
    final SimpleDataSetHeader header = new SimpleDataSetHeader(tableSelectItems);

    final List<Row> rows = new ArrayList<>();
    
    final SimpleDataSetHeader subSelectionHeader = new SimpleDataSetHeader(selectItems);

    rows.add(new DefaultRow(header, new Object[] { 1, "hello" }).getSubSelection(subSelectionHeader));
    rows.add(new DefaultRow(header, new Object[] { 2, "there" }).getSubSelection(subSelectionHeader));
    rows.add(new DefaultRow(header, new Object[] { 3, "big" }).getSubSelection(subSelectionHeader));
    rows.add(new DefaultRow(header, new Object[] { 4, "wide" }).getSubSelection(subSelectionHeader));
    rows.add(new DefaultRow(header, new Object[] { 5, "world" }).getSubSelection(subSelectionHeader));

    return new InMemoryDataSet(rows);
}
 

import org.apache.metamodel.data.DataSet; //导入依赖的package包/类
private Object[] performQuery(List<Object> queryInput) {
    try {
        final Column[] queryConditionColumns = getQueryConditionColumns();

        final Object[] parameterValues = new Object[queryConditionColumns.length];
        for (int i = 0; i < queryConditionColumns.length; i++) {
            parameterValues[i] = queryInput.get(i);
        }

        try (final DataSet dataSet = datastoreConnection.getDataContext()
                .executeQuery(lookupQuery, parameterValues)) {
            return handleDataSet(dataSet);
        }
    } catch (RuntimeException e) {
        logger.error("Error occurred while looking up based on conditions: " + queryInput, e);
        throw e;
    }
}
 

import org.apache.metamodel.data.DataSet; //导入依赖的package包/类
@Override
public Collection<String> getValues() {
    try (final DatastoreConnection con = _datastore.openConnection()) {
        final DataContext dataContext = con.getDataContext();

        final Query q = dataContext.query().from(_column.getTable()).select(_column).toQuery();
        q.selectDistinct();

        try (final DataSet dataSet = dataContext.executeQuery(q)) {
            final List<String> values = new ArrayList<String>();
            while (dataSet.next()) {
                final Row row = dataSet.getRow();
                
                Object value = row.getValue(0);
                if (value != null) {
                    value = value.toString();
                }
                values.add((String) value);
            }
            return values;
        }
    }
}
 

import org.apache.metamodel.data.DataSet; //导入依赖的package包/类
@Override
protected DataSet materializeMainSchemaTable(Table table, Column[] columns, int maxRows) {
    DataInputStream inputStream = createInputStream();

    // skip through the metadata section
    try {
        readMetadataSection(inputStream);
    } catch (RuntimeException e) {
        FileHelper.safeClose(inputStream);
        throw e;
    }

    DataSet dataSet = new KettleDataSet(columns, inputStream, rowMeta);
    if (maxRows >= 0) {
        dataSet = new MaxRowsDataSet(dataSet, maxRows);
    }
    return dataSet;
}
 

import org.apache.metamodel.data.DataSet; //导入依赖的package包/类
@Override
protected DataSet materializeMainSchemaTable(Table table, List<Column> columns, int firstRow, int maxRows) {
    // the connector represents a handle to the the couchdb "database".
    final String databaseName = table.getName();
    final CouchDbConnector connector = _couchDbInstance.createConnector(databaseName, false);

    ViewQuery query = new ViewQuery().allDocs().includeDocs(true);

    if (maxRows > 0) {
        query = query.limit(maxRows);
    }
    if (firstRow > 1) {
        final int skip = firstRow - 1;
        query = query.skip(skip);
    }

    final StreamingViewResult streamingView = connector.queryForStreamingView(query);

    final List<SelectItem> selectItems = columns.stream().map(SelectItem::new).collect(Collectors.toList());
    return new CouchDbDataSet(selectItems, streamingView);
}
 

import org.apache.metamodel.data.DataSet; //导入依赖的package包/类
@Override
public DataSet executeQuery(Table table, List<Column> columns, int maxRows) {
    final Workbook wb = ExcelUtils.readWorkbook(_resource);
    final Sheet sheet = wb.getSheet(table.getName());

    if (sheet == null || sheet.getPhysicalNumberOfRows() == 0) {
        return new EmptyDataSet(columns.stream().map(SelectItem::new).collect(Collectors.toList()));
    }

    DataSet dataSet = ExcelUtils.getDataSet(wb, sheet, table, _configuration);

    if (maxRows > 0) {
        dataSet = new MaxRowsDataSet(dataSet, maxRows);
    }
    return dataSet;
}