Java Query类代码示例

import org.apache.metamodel.query.Query; //导入依赖的package包/类
@RequestMapping(method = RequestMethod.GET)
@ResponseBody
public QueryResponse get(@PathVariable("tenant") String tenantId,
        @PathVariable("dataContext") String dataSourceName, @PathVariable("schema") String schemaId,
        @PathVariable("table") String tableId, @RequestParam(value = "offset", required = false) Integer offset,
        @RequestParam(value = "limit", required = false) Integer limit) {
    final TenantContext tenantContext = tenantRegistry.getTenantContext(tenantId);
    final DataContext dataContext = tenantContext.getDataSourceRegistry().openDataContext(dataSourceName);

    final DataContextTraverser traverser = new DataContextTraverser(dataContext);

    final Table table = traverser.getTable(schemaId, tableId);

    final Query query = dataContext.query().from(table).selectAll().toQuery();

    return QueryController.executeQuery(tenantContext, dataSourceName, dataContext, query, offset, limit);
}
 

import org.apache.metamodel.query.Query; //导入依赖的package包/类
private LazyRef<RowProcessingQueryOptimizer> createQueryOptimizerRef() {
    return new LazyRef<RowProcessingQueryOptimizer>() {
        @Override
        protected RowProcessingQueryOptimizer fetch() {
            final Datastore datastore = getAnalysisJob().getDatastore();
            try (DatastoreConnection con = datastore.openConnection()) {
                final DataContext dataContext = con.getDataContext();

                final Column[] columnArray = _physicalColumns.toArray(new Column[_physicalColumns.size()]);
                final Query baseQuery = dataContext.query().from(getTable()).select(columnArray).toQuery();

                logger.debug("Base query for row processing: {}", baseQuery);

                // try to optimize

                return new RowProcessingQueryOptimizerImpl(datastore, getConsumersSorted(), baseQuery);
            } catch (final RuntimeException e) {
                logger.error("Failed to build query optimizer! {}", e.getMessage(), e);
                throw e;
            }
        }
    };
}
 

import org.apache.metamodel.query.Query; //导入依赖的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.query.Query; //导入依赖的package包/类
private void compileLookupQuery() {
    try {
        final Column[] queryOutputColumns = getQueryOutputColumns(false);
        final Column queryOutputColumn = queryOutputColumns[0];
        final Table table = queryOutputColumn.getTable();

        Query query = new Query().from(table).select(queryOutputColumns);

        if (!isCarthesianProductMode()) {
            final Column[] queryConditionColumns = getQueryConditionColumns();
            for (int i = 0; i < queryConditionColumns.length; i++) {
                query = query.where(queryConditionColumns[i], OperatorType.EQUALS_TO, new QueryParameter());
            }
        }

        if (joinSemantic == JoinSemantic.LEFT_JOIN_MAX_ONE) {
            query = query.setMaxRows(1);
        }

        lookupQuery = datastoreConnection.getDataContext().compileQuery(query);

    } catch (final RuntimeException e) {
        logger.error("Error occurred while compiling lookup query", e);
        throw e;
    }
}
 

import org.apache.metamodel.query.Query; //导入依赖的package包/类
public void testConnectAndExplore() throws Exception {
    final SasDatastore ds = new SasDatastore("my sas ds", new File("src/test/resources/sas"));
    try (DatastoreConnection con = ds.openConnection()) {
        final Schema schema = con.getSchemaNavigator().getDefaultSchema();
        assertEquals("[dummy1, dummy2, pizza]", schema.getTableNames().toString());

        final Table table = schema.getTableByName("pizza");
        assertEquals("[id, mois, prot, fat, ash, sodium, carb, cal, brand]",
                table.getColumnNames().toString());

        final Column col = table.getColumnByName("brand");

        final Query q = con.getDataContext().query().from(table).select(col).orderBy(col).toQuery();
        q.getSelectClause().setDistinct(true);

        final List<Object[]> objectArrays = con.getDataContext().executeQuery(q).toObjectArrays();
        assertEquals(10, objectArrays.size());
        assertEquals("a", objectArrays.get(0)[0]);
        assertEquals("b", objectArrays.get(1)[0]);
    }
}
 

import org.apache.metamodel.query.Query; //导入依赖的package包/类
@Override
public void actionPerformed(final ActionEvent e) {
    List<Column> columns = _columns;
    if (_columns == null) {
        final List<Column> cols = new ArrayList<>();
        for (final InputColumn<?> col : _inputColumns) {
            if (col.isPhysicalColumn()) {
                cols.add(col.getPhysicalColumn());
            }
        }
        columns = cols;
    }

    if (columns.isEmpty()) {
        throw new IllegalStateException("No columns found - could not determine which columns to query");
    }

    try (DatastoreConnection con = _datastore.openConnection()) {
        final DataContext dc = con.getDataContext();
        final Query q = dc.query().from(columns.get(0).getTable()).select(columns).toQuery();

        final DataSetWindow window = new DataSetWindow(q, dc, PAGE_SIZE, _windowContext);
        window.open();
    }
}
 

import org.apache.metamodel.query.Query; //导入依赖的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.query.Query; //导入依赖的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.query.Query; //导入依赖的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.query.Query; //导入依赖的package包/类
@Override
public void initializeOutputDataStream(final OutputDataStream outputDataStream, final Query query,
        final OutputRowCollector outputRowCollector) {
    Assert.assertNotNull(outputDataStream);
    Assert.assertNotNull(query);
    Assert.assertNotNull(outputRowCollector);

    if (outputDataStream.equals(stream1)) {
        collector1 = outputRowCollector;
    } else if (outputDataStream.equals(stream2)) {
        collector2 = outputRowCollector;
        counter = new AtomicInteger();
    } else {
        Assert.fail("Unexpected outputDataStream: " + outputDataStream);
    }
}
 

import org.apache.metamodel.query.Query; //导入依赖的package包/类
public void testOptimizeQueryValueColumn() throws Exception {
    final DatastoreConnection con = datastore.openConnection();
    final Column column1 = con.getSchemaNavigator().convertToColumn("PUBLIC.EMPLOYEES.FIRSTNAME");
    final Column column2 = con.getSchemaNavigator().convertToColumn("PUBLIC.EMPLOYEES.LASTNAME");
    final InputColumn<?> inputColumn1 = new MetaModelInputColumn(column1);
    final InputColumn<?> inputColumn2 = new MetaModelInputColumn(column2);

    final EqualsFilter filter = new EqualsFilter(inputColumn1, inputColumn2);
    assertTrue(filter.isOptimizable(EqualsFilter.Category.EQUALS));
    assertTrue(filter.isOptimizable(EqualsFilter.Category.NOT_EQUALS));

    final Query query = con.getDataContext().query().from(column1.getTable()).select(column1, column2).toQuery();
    final String originalSql = query.toSql();
    assertEquals("SELECT \"EMPLOYEES\".\"FIRSTNAME\", \"EMPLOYEES\".\"LASTNAME\" FROM PUBLIC.\"EMPLOYEES\"",
            originalSql);

    Query result;
    result = filter.optimizeQuery(query.clone(), EqualsFilter.Category.EQUALS);
    assertEquals(originalSql + " WHERE \"EMPLOYEES\".\"FIRSTNAME\" = \"EMPLOYEES\".\"LASTNAME\"", result.toSql());

    result = filter.optimizeQuery(query.clone(), EqualsFilter.Category.NOT_EQUALS);
    assertEquals(originalSql + " WHERE \"EMPLOYEES\".\"FIRSTNAME\" <> \"EMPLOYEES\".\"LASTNAME\"", result.toSql());

    con.close();
}
 

import org.apache.metamodel.query.Query; //导入依赖的package包/类
public void testOptimizeQueryValuesArray() throws Exception {
    final DatastoreConnection con = datastore.openConnection();
    final Column column = con.getSchemaNavigator().convertToColumn("PUBLIC.EMPLOYEES.FIRSTNAME");
    final InputColumn<?> inputColumn = new MetaModelInputColumn(column);

    final EqualsFilter filter = new EqualsFilter(new String[] { "foobar" }, inputColumn);
    assertTrue(filter.isOptimizable(EqualsFilter.Category.EQUALS));
    assertTrue(filter.isOptimizable(EqualsFilter.Category.NOT_EQUALS));

    final Query query = con.getDataContext().query().from(column.getTable()).select(column).toQuery();
    final String originalSql = query.toSql();
    assertEquals("SELECT \"EMPLOYEES\".\"FIRSTNAME\" FROM PUBLIC.\"EMPLOYEES\"", originalSql);

    Query result;
    result = filter.optimizeQuery(query.clone(), EqualsFilter.Category.EQUALS);
    assertEquals(originalSql + " WHERE \"EMPLOYEES\".\"FIRSTNAME\" = 'foobar'", result.toSql());

    result = filter.optimizeQuery(query.clone(), EqualsFilter.Category.NOT_EQUALS);
    assertEquals(originalSql + " WHERE \"EMPLOYEES\".\"FIRSTNAME\" <> 'foobar'", result.toSql());

    con.close();
}
 

import org.apache.metamodel.query.Query; //导入依赖的package包/类
public void testOptimizeQueryValuesArray() throws Exception {
    final DatastoreConnection con = datastore.openConnection();
    final Column firstname = con.getSchemaNavigator().convertToColumn("PUBLIC.EMPLOYEES.FIRSTNAME");
    final Column lastname = con.getSchemaNavigator().convertToColumn("PUBLIC.EMPLOYEES.LASTNAME");
    final InputColumn<?> firstnameInputColumn = new MetaModelInputColumn(firstname);
    final InputColumn<?> lastnameInputColumn = new MetaModelInputColumn(lastname);

    final CompareFilter filter =
            new CompareFilter(firstnameInputColumn, CompareFilter.Operator.DIFFERENT_FROM, lastnameInputColumn);
    assertTrue(filter.isOptimizable(CompareFilter.Category.TRUE));
    assertFalse(filter.isOptimizable(CompareFilter.Category.FALSE));

    final Query query =
            con.getDataContext().query().from(firstname.getTable()).select(firstname, lastname).toQuery();
    final String originalSql = query.toSql();
    assertEquals("SELECT \"EMPLOYEES\".\"FIRSTNAME\", \"EMPLOYEES\".\"LASTNAME\" FROM PUBLIC.\"EMPLOYEES\"",
            originalSql);

    final Query result;
    result = filter.optimizeQuery(query.clone(), CompareFilter.Category.TRUE);
    assertEquals(originalSql + " WHERE \"EMPLOYEES\".\"FIRSTNAME\" <> \"EMPLOYEES\".\"LASTNAME\"", result.toSql());

    con.close();
}
 

import org.apache.metamodel.query.Query; //导入依赖的package包/类
public void testMultipleOptimizations() throws Exception {
    FilterJobBuilder<NullCheckFilter, NullCheckFilter.NullCheckCategory> notNullBuilder = ajb
            .addFilter(NullCheckFilter.class);
    Column emailColumn = con.getSchemaNavigator().convertToColumn("EMPLOYEES.EMAIL");
    ajb.addSourceColumn(emailColumn);
    InputColumn<?> emailInputColumn = ajb.getSourceColumnByName("email");
    notNullBuilder.addInputColumn(emailInputColumn);
    notNullBuilder.setRequirement(maxRowsBuilder, MaxRowsFilter.Category.VALID);
    stringAnalyzerBuilder.setRequirement(notNullBuilder, NullCheckCategory.NOT_NULL);

    consumers.remove(1);
    consumers.add(createConsumer(notNullBuilder));
    consumers.add(createConsumer(stringAnalyzerBuilder));

    RowProcessingQueryOptimizer optimizer = new RowProcessingQueryOptimizer(datastore, consumers, baseQuery);
    assertTrue(optimizer.isOptimizable());

    List<RowProcessingConsumer> optimizedConsumers = optimizer.getOptimizedConsumers();
    assertEquals(1, optimizedConsumers.size());

    Query q = optimizer.getOptimizedQuery();
    assertEquals(
            "SELECT \"EMPLOYEES\".\"LASTNAME\" FROM PUBLIC.\"EMPLOYEES\" WHERE \"EMPLOYEES\".\"EMAIL\" IS NOT NULL",
            q.toSql());
    assertEquals(1000, q.getMaxRows().intValue());
}
 

import org.apache.metamodel.query.Query; //导入依赖的package包/类
/**
 * Gets the optimized query.
 * 
 * @return
 */
public Query getOptimizedQuery() {
    // if (isOptimizable()) {
    // return _baseQuery;
    // }

    // create a copy/clone of the original query
    Query q = _baseQuery.clone();

    Set<Entry<FilterConsumer, FilterOutcome>> entries = _optimizedFilters.entrySet();
    for (Entry<FilterConsumer, FilterOutcome> entry : entries) {

        FilterConsumer consumer = entry.getKey();
        FilterOutcome outcome = entry.getValue();
        Filter<?> filter = consumer.getComponent();

        @SuppressWarnings("rawtypes")
        QueryOptimizedFilter queryOptimizedFilter = (QueryOptimizedFilter) filter;

        @SuppressWarnings("unchecked")
        Query newQuery = queryOptimizedFilter.optimizeQuery(q, outcome.getCategory());
        q = newQuery;
    }
    return q;
}