Package org.apache.cayenne.query

Examples of org.apache.cayenne.query.QueryMetadata


    public String createSqlString() throws Exception {

        String sqlString = super.createSqlString();

        QueryMetadata info = getQuery().getMetaData(getEntityResolver());
        if (info.getFetchLimit() > 0) {
            sqlString = "SELECT * FROM ("
                    + sqlString
                    + ") WHERE rownum <= "
                    + info.getFetchLimit();
        }

        return sqlString;
    }
View Full Code Here


        // (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

     * @deprecated since 1.2. Note that this implementation no longer resolves prefetches
     *             properly.
     */
    public List getResultsAsObjects(DataContext dataContext, Query rootQuery) {

        QueryMetadata info = rootQuery.getMetaData(dataContext.getEntityResolver());
        return dataContext.objectsFromDataRows(
                info.getObjEntity(),
                getResults(rootQuery),
                info.isRefreshingObjects(),
                info.isResolvingInherited());
    }
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(
                    "IncrementalFaultList does not support unpaged queries. Query page size is "
                            + metadata.getPageSize());
        }

        this.elements = Collections.synchronizedList(new ArrayList());
        this.dataContext = dataContext;
        this.pageSize = metadata.getPageSize();
        this.rootEntity = metadata.getObjEntity();

        // 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.setResolvingInherited(metadata.isResolvingInherited());

        if (metadata.isFetchingDataRows()) {
            helper = new DataRowListHelper();
        }
        else {
            helper = new DataObjectListHelper();
        }

        if (!metadata.isFetchingDataRows() && (query instanceof SelectQuery)) {
            SelectQuery select = (SelectQuery) query;

            this.internalQuery.setPrefetchTree(select.getPrefetchTree());

            if (select.getPrefetchTree() != null) {
View Full Code Here

     * fully resolved. For the rest of the list, only ObjectIds are read.
     *
     * @since 1.0.6
     */
    protected void fillIn(Query query) {
        QueryMetadata info = query.getMetaData(dataContext.getEntityResolver());

        synchronized (elements) {

            boolean fetchesDataRows = internalQuery.isFetchingDataRows();

            // start fresh
            elements.clear();
            rowWidth = 0;

            try {
                int lastResolved = 0;
                long t1 = System.currentTimeMillis();
                ResultIterator it = dataContext.performIteratedQuery(query);
                try {

                    rowWidth = it.getDataRowWidth();

                    // resolve first page if we can
                    if (resolvesFirstPage()) {
                        // read first page completely, the rest as ObjectIds
                        for (int i = 0; i < pageSize && it.hasNextRow(); i++) {
                            elements.add(it.nextDataRow());
                            lastResolved++;
                        }

                        // defer DataRows -> Objects conversion till we are completely done.
                    }

                    // continue reading ids
                    DbEntity entity = rootEntity.getDbEntity();
                    while (it.hasNextRow()) {
                        elements.add(it.nextObjectId(entity));
                    }

                    QueryLogger.logSelectCount(elements.size(), System
                            .currentTimeMillis()
                            - t1);
                }
                finally {
                    it.close();
                }
               
                // fill in the first page AFTER the iterator was closed, otherwise we may
                // cause an (unobvious) deadlock due to connection pool exhaustion
                if (!fetchesDataRows && lastResolved > 0) {
                    List objects = dataContext.objectsFromDataRows(
                            rootEntity,
                            elements.subList(0, lastResolved),
                            info.isRefreshingObjects(),
                            info.isResolvingInherited());
                   
                    for(int i = 0; i < lastResolved; i++) {
                        elements.set(i, objects.get(i));
                    }
                }
View Full Code Here

        if (parent == null) {
            return null;
        }

        QueryMetadata metadata = query.getMetaData(parent.getEntityResolver());
        Entity entity = metadata.getObjEntity();
        if (entity == null) {
            entity = metadata.getDbEntity();
        }

        // if no entity is found register warning and return null
        if (entity == null) {
            validator.registerWarning("Unknown query root.", path);
View Full Code Here

            // a joint prefetch warrants full row compare

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

            QueryMetadata md = query.getMetaData(getEntityResolver());
            final PrefetchTreeNode rootPrefetch = md.getPrefetchTree();

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

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

    protected void readResultSet(ResultSet resultSet, RowDescriptor descriptor, Query query, OperationObserver delegate)
            throws SQLException, Exception {

        long t1 = System.currentTimeMillis();

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

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

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

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

    @SuppressWarnings("unchecked")
    @Override
    public <T> ResultIterator<T> iterator(Select<T> query) {
        final ResultIterator<DataRow> rows = performIteratedQuery(query);

        QueryMetadata md = query.getMetaData(getEntityResolver());
        if (md.isFetchingDataRows()) {
            return (ResultIterator<T>) rows;
        } else {

            // this is a bit optimized version of 'objectFromDataRow' with
            // resolver cached for reuse... still the rest is pretty suboptimal
            ClassDescriptor descriptor = md.getClassDescriptor();
            final ObjectResolver resolver = new ObjectResolver(this, descriptor, true);
            return new ResultIterator<T>() {

                public Iterator<T> iterator() {
                    return new ResultIteratorIterator<T>(this);
View Full Code Here

        }
        catch (Exception ex) {
            prepStmt.close();
            throw ex;
        }
        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

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.