Package org.apache.cayenne.query

Examples of org.apache.cayenne.query.QueryMetadata


        // (assuming all lists are mutable)

        if (context != null) {

            EntityResolver resolver = context.getEntityResolver();
            QueryMetadata info = query.getMetaData(resolver);

            if (!info.isFetchingDataRows()) {

                response.reset();

                while (response.next()) {
                    if (response.isList()) {
View Full Code Here


        });

        SQLTemplate sqlQuery = context.getQuery();

        // update with metadata
        QueryMetadata md = query.getMetaData(getEntityResolver());
        sqlQuery.setFetchLimit(md.getFetchLimit());
        sqlQuery.setFetchOffset(md.getFetchOffset());
        sqlQuery.setResult(compiledExpression.getResult());
        sqlQuery.setPageSize(md.getPageSize());
       
        if (md.getStatementFetchSize() != 0) {
            sqlQuery.setStatementFetchSize(md.getStatementFetchSize());
        }

        actionFactory.sqlAction(sqlQuery).performAction(connection, observer);
    }
View Full Code Here

        long t1 = System.currentTimeMillis();

        SelectTranslator translator = createTranslator(connection);
        PreparedStatement prepStmt = translator.createStatement();
        ResultSet rs = prepStmt.executeQuery();
        QueryMetadata md = query.getMetaData(getEntityResolver());
        RowDescriptor descriptor = new RowDescriptorBuilder().setColumns(
                translator.getResultColumns()).getDescriptor(
                getAdapter().getExtendedTypes());

        JDBCResultIterator workerIterator = new JDBCResultIterator(
                connection,
                prepStmt,
                rs,
                descriptor,
                md);

        workerIterator.setPostProcessor(DataRowPostProcessor
                .createPostProcessor(translator));

        ResultIterator it = workerIterator;

        // wrap result iterator if distinct has to be suppressed
        if (translator.isSuppressingDistinct()) {

            // a joint prefetch warrants full row compare

            final boolean[] compareFullRows = new boolean[1];

            final PrefetchTreeNode rootPrefetch = md.getPrefetchTree();

            if (rootPrefetch != null) {
                rootPrefetch.traverse(new PrefetchProcessor() {

                    public void finishPrefetch(PrefetchTreeNode node) {
View Full Code Here

            Query query,
            OperationObserver delegate) throws SQLException, Exception {

        long t1 = System.currentTimeMillis();

        QueryMetadata metadata = query.getMetaData(getEntityResolver());

        JDBCResultIterator resultReader = new JDBCResultIterator(
                null,
                null,
                resultSet,
                descriptor,
                metadata);

        LimitResultIterator it = new LimitResultIterator(
                resultReader,
                getInMemoryOffset(metadata.getFetchOffset()),
                metadata.getFetchLimit());

        if (!delegate.isIteratedResult()) {
            List<DataRow> resultRows = (List<DataRow>) it.allRows();
            QueryLogger
                    .logSelectCount(resultRows.size(), System.currentTimeMillis() - t1);
View Full Code Here

     *            objects.
     * @param query Main query used to retrieve data. Must have "pageSize" property set to
     *            a value greater than zero.
     */
    public IncrementalFaultList(DataContext dataContext, Query query) {
        QueryMetadata metadata = query.getMetaData(dataContext.getEntityResolver());
        if (metadata.getPageSize() <= 0) {
            throw new CayenneRuntimeException("Not a paginated query; page size: "
                    + metadata.getPageSize());
        }

        this.dataContext = dataContext;
        this.pageSize = metadata.getPageSize();
        this.rootEntity = metadata.getObjEntity();

        if (rootEntity == null) {
            throw new CayenneRuntimeException(
                    "Pagination is not supported for queries not rooted in an ObjEntity");
        }

        // create an internal query, it is a partial replica of
        // the original query and will serve as a value holder for
        // various parameters
        this.internalQuery = new SelectQuery(rootEntity);
        this.internalQuery.setFetchingDataRows(metadata.isFetchingDataRows());
        this.internalQuery.setPrefetchTree(metadata.getPrefetchTree());

        this.helper = createHelper(metadata);
        this.idWidth = metadata.getDbEntity().getPrimaryKeys().size();

        List<Object> elementsUnsynced = new ArrayList<Object>();
        fillIn(query, elementsUnsynced);
        this.elements = Collections.synchronizedList(elementsUnsynced);
    }
View Full Code Here

        this.query = query;
        this.cacheKey = cacheKey;
    }

    public QueryMetadata getMetaData(EntityResolver resolver) {
        final QueryMetadata metadata = query.getMetaData(resolver);

        // the way paginated queries work on the server is that they are never cached
        // (IncrementalFaultList interception happens before cache interception). So
        // overriding caching settings in the metadata will only affect
        // ClientServerChannel behavior

        return new QueryMetadata() {

            public Query getOrginatingQuery() {
                return null;
            }

            public String getCacheKey() {
                return cacheKey;
            }

            public List<Object> getResultSetMapping() {
                return metadata.getResultSetMapping();
            }

            public String[] getCacheGroups() {
                return metadata.getCacheGroups();
            }

            /**
             * @deprecated since 3.0 in favor of 'getCacheStrategy'.
             */
            @Deprecated
            public String getCachePolicy() {
                return metadata.getCachePolicy();
            }

            /**
             * @since 3.0
             */
            public QueryCacheStrategy getCacheStrategy() {
                return metadata.getCacheStrategy();
            }

            public DataMap getDataMap() {
                return metadata.getDataMap();
            }

            public DbEntity getDbEntity() {
                return metadata.getDbEntity();
            }

            public int getFetchLimit() {
                return metadata.getFetchLimit();
            }

            public int getFetchOffset() {
                return metadata.getFetchOffset();
            }

            /**
             * @deprecated since 3.0
             */
            @Deprecated
            public int getFetchStartIndex() {
                return metadata.getFetchStartIndex();
            }

            public ObjEntity getObjEntity() {
                return metadata.getObjEntity();
            }

            public ClassDescriptor getClassDescriptor() {
                return metadata.getClassDescriptor();
            }

            public int getPageSize() {
                return metadata.getPageSize();
            }

            public PrefetchTreeNode getPrefetchTree() {
                return metadata.getPrefetchTree();
            }

            public Procedure getProcedure() {
                return metadata.getProcedure();
            }

            public Map<String, String> getPathSplitAliases() {
                return metadata.getPathSplitAliases();
            }

            public boolean isFetchingDataRows() {
                return metadata.isFetchingDataRows();
            }

            /**
             * @deprecated since 3.0
             */
            @Deprecated
            public boolean isRefreshingObjects() {
                return metadata.isRefreshingObjects();
            }

            /**
             * @deprecated since 3.0. Inheritance resolving is not optional anymore.
             */
            @Deprecated
            public boolean isResolvingInherited() {
                return metadata.isResolvingInherited();
            }

            public int getStatementFetchSize() {
                return metadata.getStatementFetchSize();
            }
        };
    }
View Full Code Here

    private ListHelper helper;

    public RemoteIncrementalFaultList(ObjectContext context, Query paginatedQuery) {

        QueryMetadata metadata = paginatedQuery.getMetaData(context.getEntityResolver());

        if (metadata.getPageSize() <= 0) {
            throw new IllegalArgumentException("Page size must be positive: "
                    + metadata.getPageSize());
        }

        this.pageSize = metadata.getPageSize();
        this.helper = (metadata.isFetchingDataRows())
                ? new DataRowListHelper()
                : new PersistentListHelper();
        this.context = context;

        // use provided cache key if possible; this would allow clients to
        // address the same server-side list from multiple queries.
        this.cacheKey = metadata.getCacheKey();
        if (cacheKey == null) {
            cacheKey = generateCacheKey();
        }

        Query query = paginatedQuery;
View Full Code Here

        this.fetchLimit = fetchLimit;
        this.originatingQuery = originatingQuery;
    }

    public QueryMetadata getMetaData(EntityResolver resolver) {
        final QueryMetadata originatingMetadata = originatingQuery.getMetaData(resolver);

        return new QueryMetadata() {

            public Query getOrginatingQuery() {
                return originatingQuery;
            }

            public List<Object> getResultSetMapping() {
                return null;
            }

            public String getCacheKey() {
                return cacheKey;
            }

            public String[] getCacheGroups() {
                return null;
            }

            public int getFetchOffset() {
                return fetchOffset;
            }
           
            /**
             * @deprecated since 3.0
             */
            @Deprecated
            public int getFetchStartIndex() {
                return getFetchOffset();
            }

            public int getFetchLimit() {
                return fetchLimit;
            }

            public boolean isFetchingDataRows() {
                return originatingMetadata.isFetchingDataRows();
            }

            public int getPageSize() {
                return 0;
            }

            /**
             * @deprecated since 3.0 in favor of 'getCacheStrategy'.
             */
            @Deprecated
            public String getCachePolicy() {
                return QueryMetadata.NO_CACHE;
            }

            /**
             * @since 3.0
             */
            public QueryCacheStrategy getCacheStrategy() {
                return QueryCacheStrategy.getDefaultStrategy();
            }

            public PrefetchTreeNode getPrefetchTree() {
                return originatingMetadata.getPrefetchTree();
            }

            public DataMap getDataMap() {
                throw new UnsupportedOperationException();
            }
View Full Code Here

        });

        SQLTemplate sqlQuery = context.getQuery();

        // update with metadata
        QueryMetadata md = query.getMetaData(getEntityResolver());
        sqlQuery.setFetchLimit(md.getFetchLimit());
        sqlQuery.setFetchOffset(md.getFetchOffset());
        sqlQuery.setResult(compiledExpression.getResult());
        sqlQuery.setPageSize(md.getPageSize());

        actionFactory.sqlAction(sqlQuery).performAction(connection, observer);
    }
View Full Code Here

        this.fetchLimit = fetchLimit;
        this.originatingQuery = originatingQuery;
    }

    public QueryMetadata getMetaData(EntityResolver resolver) {
        final QueryMetadata originatingMetadata = originatingQuery.getMetaData(resolver);

        return new QueryMetadata() {

            public Query getOrginatingQuery() {
                return originatingQuery;
            }

            public List<Object> getResultSetMapping() {
                return null;
            }

            public String getCacheKey() {
                return cacheKey;
            }

            public String[] getCacheGroups() {
                return null;
            }

            public int getFetchOffset() {
                return fetchOffset;
            }
           
            /**
             * @deprecated since 3.0
             */
            public int getFetchStartIndex() {
                return getFetchOffset();
            }

            public int getFetchLimit() {
                return fetchLimit;
            }

            public boolean isFetchingDataRows() {
                return originatingMetadata.isFetchingDataRows();
            }

            public int getPageSize() {
                return 0;
            }

            /**
             * @deprecated since 3.0 in favor of 'getCacheStrategy'.
             */
            public String getCachePolicy() {
                return QueryMetadata.NO_CACHE;
            }

            /**
             * @since 3.0
             */
            public QueryCacheStrategy getCacheStrategy() {
                return QueryCacheStrategy.getDefaultStrategy();
            }

            public PrefetchTreeNode getPrefetchTree() {
                return originatingMetadata.getPrefetchTree();
            }

            public DataMap getDataMap() {
                throw new UnsupportedOperationException();
            }
View Full Code Here

TOP

Related Classes of org.apache.cayenne.query.QueryMetadata

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.