Java DataSet.getRow方法代码示例

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包/类
@Override
public void execute() throws MetaModelException {
    Table table = getTable();
    List<FilterItem> whereItems = getWhereItems();

    CouchDbConnector connector = _updateCallback.getConnector(table.getName());
    CouchDbDataContext dataContext = _updateCallback.getDataContext();

    DataSet dataSet = dataContext.query().from(table)
            .select(CouchDbDataContext.FIELD_ID, CouchDbDataContext.FIELD_REV).where(whereItems).execute();
    try {
        while (dataSet.next()) {
            Row row = dataSet.getRow();
            String id = (String) row.getValue(0);
            String revision = (String) row.getValue(1);
            connector.delete(id, revision);
        }
    } finally {
        dataSet.close();
    }
}
 

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
@Test
public void testJoin() {
    Stopwatch duration = Stopwatch.createStarted();
    CompositeDataContext compDcon = new CompositeDataContext(this.emp_dcon, this.dep_dcon);

    DataSet ds = compDcon.query().from("employee").innerJoin("department").on("dep_id", "id").selectAll().execute();
    int rowCount = 0;
    while (ds.next()) {
        Row row = ds.getRow();
        Assert.assertNotNull(row);
        rowCount++;
    }
    duration.stop();
    logger.info("Test duration was {} ms", duration.elapsed(TimeUnit.MILLISECONDS));

    Assert.assertEquals(employeeSize, rowCount);

}
 

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
@Test
public void testSelectiveJoin() {
    Stopwatch duration = Stopwatch.createStarted();
    CompositeDataContext compDcon = new CompositeDataContext(this.emp_dcon, this.dep_dcon);

    DataSet ds = compDcon.query().from("employee").innerJoin("department").on("dep_id", "id").selectAll().where(
            compDcon.getTableByQualifiedLabel("department").getColumnByName("id")).eq(1).execute();
    int rowCount = 0;
    while (ds.next()) {
        Row row = ds.getRow();
        Assert.assertNotNull(row);
        rowCount++;
    }
    duration.stop();
    logger.info("Test duration was {} ms", duration.elapsed(TimeUnit.MILLISECONDS));

    Assert.assertEquals(employeesPerDepartment, rowCount);
}
 

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 void testNewAggregateFunctions() throws Exception {
    MockDataContext dc = new MockDataContext("sch", "tab", null);
    Table table = dc.getDefaultSchema().getTable(0);
    DataSet dataSet = dc.query().from(table).select(FunctionType.FIRST, "foo").select(FunctionType.LAST, "foo")
            .select(FunctionType.RANDOM, "foo").execute();
    assertTrue(dataSet.next());

    final Row row = dataSet.getRow();
    assertEquals("1", row.getValue(0));
    assertEquals("4", row.getValue(1));

    final Object randomValue = row.getValue(2);
    assertTrue(Arrays.asList("1", "2", "3", "4").contains(randomValue));

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

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
public void testSimpleSelect() throws Exception {
    DataContext dc = getDataContext();
    Query q = new Query();
    q.from(table1);
    q.select(table1.getColumns());
    DataSet dataSet = dc.executeQuery(q);
    assertTrue(dataSet.next());
    Row row = dataSet.getRow();
    assertEquals("Row[values=[1, kasper, denmark]]", row.toString());
    assertTrue(dataSet.next());
    assertTrue(dataSet.next());
    assertTrue(dataSet.next());
    assertTrue(dataSet.next());
    assertTrue(dataSet.next());
    assertFalse(dataSet.next());
}
 

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
public static List<LicensedProject> getLicensedProjects() {
    final List<LicensedProject> result = new ArrayList<>();
    final URL url = resourceManager.getUrl("licenses/dependency-licenses.csv");
    if (url == null) {
        throw new IllegalStateException("Could not find dependencies file");
    }
    try {
        final DataContext dc = DataContextFactory.createCsvDataContext(url.openStream(), ',', '"');
        final Table table = dc.getDefaultSchema().getTable(0);
        final Column projectColumn = table.getColumnByName("Project");
        final Column websiteColumn = table.getColumnByName("Website");
        final Column licenseColumn = table.getColumnByName("License");
        final Query q = dc.query().from(table).select(table.getColumns()).orderBy(projectColumn).asc().toQuery();
        final DataSet ds = dc.executeQuery(q);
        while (ds.next()) {
            final LicensedProject licensedProject = new LicensedProject();
            final Row row = ds.getRow();
            final String licenseName = row.getValue(licenseColumn).toString();

            licensedProject.name = row.getValue(projectColumn).toString();
            licensedProject.websiteUrl = row.getValue(websiteColumn).toString();
            licensedProject.license = getLicense(licenseName);

            result.add(licensedProject);
        }

    } catch (final IOException e) {
        throw new IllegalStateException("Error occurred while reading dependencies file", e);
    }

    return result;
}
 

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
public void testQuery() throws Exception {
	Schema schema = dc.getSchemaByName("report.dbf");
	Table table = schema.getTableByName("report");

	List<Column> columns = table.getColumns();
	Query q = new Query().select(columns).from(table);
	DataSet ds = dc.executeQuery(q);

	while (ds.next()) {
		Row row = ds.getRow();
		List<SelectItem> selectItems = row.getSelectItems();
		for (int i = 0; i < selectItems.size(); i++) {
			SelectItem selectItem = selectItems.get(i);
			Column column = columns.get(i);
			assertSame(selectItem.getColumn(), column);

			Object selectItemValue = row.getValue(selectItem);
			Object columnValue = row.getValue(column);
			assertEquals(selectItemValue, columnValue);

			assertNotNull(columnValue);

			assertTrue(columnValue instanceof Character
					|| columnValue instanceof String);
		}
	}
	ds.close();
}
 

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
public void testDeveloperTable() throws Exception {
    Schema schema = dc.getDefaultSchema();
    assertEquals("developers.mdb", schema.getName());

    assertEquals("[developer, product]", schema.getTableNames().toString());

    Table table = schema.getTableByName("developer");
    assertEquals("[id, name, email, male, developer_since]", table.getColumnNames().toString());
    
    List<Column> primaryKeys = table.getPrimaryKeys();
    assertEquals("[Column[name=id,columnNumber=0,type=INTEGER,nullable=null,nativeType=LONG,columnSize=4]]", primaryKeys.toString());

    Column nameCol = table.getColumnByName("name");
    assertEquals(
            "Column[name=name,columnNumber=1,type=VARCHAR,nullable=null,nativeType=TEXT,columnSize=100]",
            nameCol.toString());

    Column maleCol = table.getColumnByName("male");
    assertEquals(
            "Column[name=male,columnNumber=3,type=BOOLEAN,nullable=null,nativeType=BOOLEAN,columnSize=1]",
            maleCol.toString());

    Column developerSinceCol = table.getColumnByName("developer_since");
    assertEquals(
            "Column[name=developer_since,columnNumber=4,type=TIMESTAMP,nullable=null,nativeType=SHORT_DATE_TIME,columnSize=8]",
            developerSinceCol.toString());

    DataSet ds = dc.executeQuery(new Query().select(nameCol, maleCol, developerSinceCol).from(table));
    while (ds.next()) {
        Row row = ds.getRow();
        assertEquals(3, row.getValues().length);
        Object value = row.getValue(0);
        assertEquals(String.class, value.getClass());
        value = row.getValue(1);
        assertEquals(Boolean.class, value.getClass());
        value = row.getValue(2);
        assertTrue(value instanceof Date);
    }
}
 

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
@Override
public Collection<Synonym> getSynonyms() {
    final Datastore datastore = getDatastore();

    try (DatastoreConnection datastoreConnection = datastore.openConnection()) {
        final DataContext dataContext = datastoreConnection.getDataContext();

        final SchemaNavigator schemaNavigator = datastoreConnection.getSchemaNavigator();

        final Column masterTermColumn = schemaNavigator.convertToColumn(_masterTermColumnPath);
        final Column[] columns = schemaNavigator.convertToColumns(_synonymColumnPaths);

        final Table table = masterTermColumn.getTable();

        final Query query = dataContext.query().from(table.getName()).select(masterTermColumn).select(columns)
                .toQuery();
        final DataSet results = dataContext.executeQuery(query);

        final List<Synonym> synonyms = new ArrayList<Synonym>();

        while (results.next()) {
            final Row row = results.getRow();
            synonyms.add(new SimpleSynonym(getMasterTerm(row, masterTermColumn), getSynonyms(row,
                    table.getColumns())));
        }

        return synonyms;
    }
}
 

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
public void testInvalidFormula() throws Exception {
    ExcelDataContext dc = new ExcelDataContext(copyOf("src/test/resources/invalid_formula.xls"));
    Table table = dc.getDefaultSchema().getTables().get(0);

    assertEquals("[name]", Arrays.toString(table.getColumnNames().toArray()));

    Query q = dc.query().from(table).select("name").toQuery();

    DataSet ds = dc.executeQuery(dc.query().from(table).selectCount().toQuery());
    assertTrue(ds.next());
    assertEquals(3, Integer.parseInt(ds.getRow().getValue(0).toString()));
    assertFalse(ds.next());
    assertFalse(ds.next());
    ds.close();

    ds = dc.executeQuery(q);

    Row row;

    assertTrue(ds.next());
    row = ds.getRow();
    assertEquals("TismmerswerskisMFSTLandsmeers                                                          ", row
            .getValue(0).toString());

    assertTrue(ds.next());
    row = ds.getRow();
    assertEquals("-\"t\" \"houetismfsthueiss\"", row.getValue(0).toString());

    assertTrue(ds.next());
    row = ds.getRow();
    assertEquals("TismmerswerskisMFSTLandsmeers                                                          ", row
            .getValue(0).toString());

    assertFalse(ds.next());
    ds.close();
}
 

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
private static int getCount(DataSet ds) {
    assertTrue(ds.next());
    Row row = ds.getRow();
    assertFalse(ds.next());
    ds.close();

    Number count = (Number) row.getValue(0);
    return count.intValue();
}
 

import org.apache.metamodel.data.DataSet; //导入方法依赖的package包/类
/**
 * Executes a single row query, like "SELECT COUNT(*), MAX(SOME_COLUMN) FROM MY_TABLE" or similar.
 * 
 * @param dataContext the DataContext object to use for executing the query
 * @param query the query to execute
 * @return a row object representing the single row returned from the query
 * @throws MetaModelException if less or more than one Row is returned from the query
 */
public static Row executeSingleRowQuery(DataContext dataContext, Query query) throws MetaModelException {
    DataSet dataSet = dataContext.executeQuery(query);
    boolean next = dataSet.next();
    if (!next) {
        throw new MetaModelException("No rows returned from query: " + query);
    }
    Row row = dataSet.getRow();
    next = dataSet.next();
    if (next) {
        throw new MetaModelException("More than one row returned from query: " + query);
    }
    dataSet.close();
    return row;
}