Java Query.setMaxRows方法代码示例

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包/类
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包/类
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 (RuntimeException e) {
        logger.error("Error occurred while compiling lookup query", e);
        throw e;
    }
}
 

import org.apache.metamodel.query.Query; //导入方法依赖的package包/类
@Override
public Query optimizeQuery(Query q, Category category) {
    if (category == Category.VALID) {
        q.setMaxRows(maxRows);

        if (firstRow > 1) {
            q.setFirstRow(firstRow);
        }

        if (orderColumn != null) {
            Column physicalColumn = orderColumn.getPhysicalColumn();
            q.orderBy(physicalColumn);
        }
    } else {
        throw new IllegalStateException("Can only optimize the VALID max rows category");
    }
    return q;
}
 

import org.apache.metamodel.query.Query; //导入方法依赖的package包/类
public void testQueryWithFilter() throws Exception {
    JdbcDataContext dc = new JdbcDataContext(_connection, new TableType[] { TableType.TABLE, TableType.VIEW },
            null);
    Query q = dc.query().from("APP", "CUSTOMERS").select("CUSTOMERNUMBER").where("ADDRESSLINE2").isNotNull()
            .toQuery();
    assertEquals(25000, dc.getFetchSizeCalculator().getFetchSize(q));

    q.setMaxRows(5);

    assertEquals(5, dc.getFetchSizeCalculator().getFetchSize(q));

    assertEquals(
            "SELECT \"CUSTOMERS\".\"CUSTOMERNUMBER\" FROM APP.\"CUSTOMERS\" WHERE \"CUSTOMERS\".\"ADDRESSLINE2\" IS NOT NULL",
            q.toSql());

    DataSet dataSet = dc.executeQuery(q);
    assertEquals("[\"CUSTOMERS\".\"CUSTOMERNUMBER\"]", Arrays.toString(dataSet.getSelectItems().toArray()));
    assertTrue(dataSet.next());
    assertEquals("Row[values=[114]]", dataSet.getRow().toString());
    assertTrue(dataSet.next());
    assertTrue(dataSet.next());
    assertTrue(dataSet.next());
    assertTrue(dataSet.next());
    assertFalse(dataSet.next());
    dataSet.close();
}
 

import org.apache.metamodel.query.Query; //导入方法依赖的package包/类
@Test
public void testOffsetFetchConstruct() {
    final int offset = 1000;
    final int rows = 100;
    final String where = "x > 1";

    final String offsetClause = " OFFSET " + (offset - 1) + " ROWS";
    final String fetchClause = " FETCH NEXT " + rows + " ROWS ONLY";

    final Query query = new Query().from(table).select(column);
    Assert.assertEquals("There shouldn't be OFFSET-FETCH clause.", query.toSql(), qr.rewriteQuery(query));

    query.setFirstRow(offset);
    Assert.assertEquals("Wrong or missing OFFSET clause.", query.toSql() + offsetClause, qr.rewriteQuery(query));

    query.setMaxRows(rows);
    Assert.assertEquals("Wrong or missing OFFSET and FETCH clauses.", query.toSql() + offsetClause + fetchClause,
            qr.rewriteQuery(query));

    query.setFirstRow(null);
    Assert.assertEquals("Wrong or missing FETCH clause.", query.toSql() + fetchClause, qr.rewriteQuery(query));
}
 

import org.apache.metamodel.query.Query; //导入方法依赖的package包/类
public void testOffsetFetchConstruct() {
    final int offset = 1000;
    final int rows = 100;

    final String baseQuery = "SELECT MY_SCHEMA.\"foo\".\"bar\" FROM MY_SCHEMA.\"foo\" ORDER BY id ASC";
    final String baseQueryWithTop =
            "SELECT TOP " + rows + " MY_SCHEMA.\"foo\".\"bar\" FROM MY_SCHEMA.\"foo\" ORDER BY id ASC";
    final String offsetClause = " OFFSET " + (offset - 1) + " ROWS";
    final String fetchClause = " FETCH NEXT " + rows + " ROWS ONLY";

    Query query = new Query();
    query.from(table).select(column).orderBy("id");
    Assert.assertEquals("There shouldn't be OFFSET-FETCH clause.", baseQuery, qr.rewriteQuery(query));

    query.setFirstRow(offset);
    Assert.assertEquals("Wrong or missing OFFSET clause.", baseQuery + offsetClause, qr.rewriteQuery(query));

    query.setMaxRows(rows);
    Assert.assertEquals("Wrong or missing OFFSET and FETCH clauses.", baseQuery + offsetClause + fetchClause,
            qr.rewriteQuery(query));

    query.setFirstRow(null);
    Assert.assertEquals("Using FETCH clause instead of TOP clause.", baseQueryWithTop, qr.rewriteQuery(query));
}
 

import org.apache.metamodel.query.Query; //导入方法依赖的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.query.Query; //导入方法依赖的package包/类
public void testMaxRowsQuery() throws Exception {
    if (!isConfigured()) {
        System.err.println(getInvalidConfigurationMessage());
        return;
    }
    dataContext = new SugarCrmDataContext(BASE_URL + "/", getUsername(), getPassword(), "Test");

    Query query = dataContext.query().from("Employees").select("id", "name").toQuery();
    query.setMaxRows(3);
    final DataSet ds = dataContext.executeQuery(query);

    assertNotNull(ds);
    assertTrue(ds instanceof MaxRowsDataSet);

    assertTrue(ds.next());
    assertNotNull(ds.getRow().getValue(0));
    assertNotNull(ds.getRow().getValue(1));
    assertTrue(ds.next());
    assertNotNull(ds.getRow().getValue(0));
    assertNotNull(ds.getRow().getValue(1));
    assertTrue(ds.next());
    assertNotNull(ds.getRow().getValue(0));
    assertNotNull(ds.getRow().getValue(1));
    assertFalse(ds.next());
}
 

import org.apache.metamodel.query.Query; //导入方法依赖的package包/类
public static QueryResponse executeQuery(TenantContext tenant, String dataSource, DataContext dataContext,
        Query query, Integer offset, Integer limit) {

    if (offset != null) {
        query.setFirstRow(offset);
    }
    if (limit != null) {
        query.setMaxRows(limit);
    }

    logger.info("{}/{} - Executing query: {}", tenant.getTenantName(), dataSource, query);

    final List<String> headers;
    final List<List<Object>> data = new ArrayList<>();

    try (final DataSet dataSet = dataContext.executeQuery(query)) {
        headers = dataSet.getSelectItems().stream().map((si) -> si.toString()).collect(Collectors.toList());
        while (dataSet.next()) {
            final Object[] values = dataSet.getRow().getValues();
            data.add(Arrays.asList(values));
        }
    }

    final QueryResponse resp = new QueryResponse();
    resp.type("dataset");
    resp.headers(headers);
    resp.data(data);
    return resp;
}
 

import org.apache.metamodel.query.Query; //导入方法依赖的package包/类
public PojoTableType createPojoTable(final DataContext dataContext, final Table table, final List<Column> usedColumns,
        final int maxRows) {
    final PojoTableType tableType = new PojoTableType();
    tableType.setName(table.getName());

    // read columns
    final Columns columnsType = new Columns();
    for (final Column column : usedColumns) {
        columnsType.getColumn().add(createPojoColumn(column.getName(), column.getType()));
    }
    tableType.setColumns(columnsType);

    if (maxRows > 0) {
        // read values
        final Query q = dataContext.query().from(table).select(usedColumns).toQuery();
        q.setMaxRows(maxRows);

        final Document document = XmlUtils.createDocument();
        final Rows rowsType = new Rows();
        try (DataSet ds = dataContext.executeQuery(q)) {
            while (ds.next()) {
                final Row row = ds.getRow();
                rowsType.getRow().add(createPojoRow(row, document));
            }
        }

        tableType.setRows(rowsType);
    }

    return tableType;
}
 

import org.apache.metamodel.query.Query; //导入方法依赖的package包/类
private Supplier<Integer> createExpectedRowsRef() {
    // TODO: This only seems valid for source tables
    return new LazyRef<Integer>() {

        @Override
        protected Integer fetch() {
            int expectedRows = -1;
            {
                final Query originalQuery = getQuery();
                final Query countQuery = originalQuery.clone();
                countQuery.setMaxRows(null);
                countQuery.setFirstRow(null);
                countQuery.getSelectClause().removeItems();
                countQuery.getOrderByClause().removeItems();
                countQuery.selectCount();
                countQuery.getSelectClause().getItem(0).setFunctionApproximationAllowed(true);

                final Datastore datastore = _publisher.getStream().getAnalysisJob().getDatastore();
                try (DatastoreConnection connection = datastore.openConnection()) {
                    try (DataSet countDataSet = connection.getDataContext().executeQuery(countQuery)) {
                        if (countDataSet.next()) {
                            final Number count =
                                    ConvertToNumberTransformer.transformValue(countDataSet.getRow().getValue(0));
                            if (count != null) {
                                expectedRows = count.intValue();
                            }
                        }
                    }
                }

                final Integer maxRows = originalQuery.getMaxRows();
                if (maxRows != null) {
                    expectedRows = Math.min(expectedRows, maxRows.intValue());
                }
            }

            return expectedRows;
        }
    };
}
 

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

    logger.info("Attempting to fetch preview data from resource: {}", resource);

    final D datastore = getPreviewDatastore(resource);
    try (DatastoreConnection con = datastore.openConnection()) {
        final DataContext dc = con.getDataContext();
        final Table table = getPreviewTable(dc);
        if (table == null) {
            logger.info("Not displaying preview because getPreviewTable(..) returned null");
            return null;
        }

        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(PREVIEW_ROWS);

        return dc.executeQuery(q);
    }
}
 

import org.apache.metamodel.query.Query; //导入方法依赖的package包/类
public PojoTableType createPojoTable(final DataContext dataContext, final Table table, final Column[] usedColumns,
        final int maxRows) {
    final PojoTableType tableType = new PojoTableType();
    tableType.setName(table.getName());

    // read columns
    final Columns columnsType = new Columns();
    for (Column column : usedColumns) {
        columnsType.getColumn().add(createPojoColumn(column.getName(), column.getType()));
    }
    tableType.setColumns(columnsType);

    if (maxRows > 0) {
        // read values
        final Query q = dataContext.query().from(table).select(usedColumns).toQuery();
        q.setMaxRows(maxRows);

        final DocumentBuilder documentBuilder = createDocumentBuilder();
        final Document document = documentBuilder.newDocument();
        final Rows rowsType = new Rows();
        try (final DataSet ds = dataContext.executeQuery(q)) {
            while (ds.next()) {
                final Row row = ds.getRow();
                rowsType.getRow().add(createPojoRow(row, document));
            }
        }

        tableType.setRows(rowsType);
    }

    return tableType;
}
 

import org.apache.metamodel.query.Query; //导入方法依赖的package包/类
private Ref<Integer> createExpectedRowsRef() {
    return new LazyRef<Integer>() {

        @Override
        protected Integer fetch() {
            int expectedRows = -1;
            {
                final Query originalQuery = getQuery();
                final Query countQuery = originalQuery.clone();
                countQuery.setMaxRows(null);
                countQuery.setFirstRow(null);
                countQuery.getSelectClause().removeItems();
                countQuery.getOrderByClause().removeItems();
                countQuery.selectCount();
                countQuery.getSelectClause().getItem(0).setFunctionApproximationAllowed(true);

                final Datastore datastore = _publishers.getDatastore();
                try (final DatastoreConnection connection = datastore.openConnection()) {
                    try (final DataSet countDataSet = connection.getDataContext().executeQuery(countQuery)) {
                        if (countDataSet.next()) {
                            final Number count = ConvertToNumberTransformer.transformValue(countDataSet.getRow()
                                    .getValue(0));
                            if (count != null) {
                                expectedRows = count.intValue();
                            }
                        }
                    }
                }

                final Integer maxRows = originalQuery.getMaxRows();
                if (maxRows != null) {
                    expectedRows = Math.min(expectedRows, maxRows.intValue());
                }
            }

            return expectedRows;
        }
    };
}