Examples with WritableDocumentSerializer datawave.query.function.serializer.WritableDocumentSerializer used on opensource projects

Example 1 with WritableDocumentSerializer

use of datawave.query.function.serializer.WritableDocumentSerializer in project datawave by NationalSecurityAgency.

the class QueryIterator method seek.

@Override
public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException {
    // preserve the original range for use with the Final Document tracking iterator because it is placed after the ResultCountingIterator
    // so the FinalDocumentTracking iterator needs the start key with the count already appended
    originalRange = range;
    getActiveQueryLog().get(getQueryId()).beginCall(this.originalRange, ActiveQuery.CallType.SEEK);
    Span span = Trace.start("QueryIterator.seek");
    if (!this.isIncludeGroupingContext() && (this.query.contains("grouping:") || this.query.contains("matchesInGroup") || this.query.contains("MatchesInGroup") || this.query.contains("atomValuesMatch"))) {
        this.setIncludeGroupingContext(true);
        this.groupingContextAddedByMe = true;
    } else {
        this.groupingContextAddedByMe = false;
    }
    try {
        if (log.isDebugEnabled()) {
            log.debug("Seek range: " + range + " " + query);
        }
        this.range = range;
        // determine whether this is a teardown/rebuild range
        long resultCount = 0;
        if (!range.isStartKeyInclusive()) {
            // see if we can fail fast. If we were rebuilt with the FinalDocument key, then we are already completely done
            if (collectTimingDetails && FinalDocumentTrackingIterator.isFinalDocumentKey(range.getStartKey())) {
                this.seekKeySource = new EmptyTreeIterable();
                this.serializedDocuments = EmptyIterator.emptyIterator();
                prepareKeyValue(span);
                return;
            }
            // see if we have a count in the cf
            Key startKey = range.getStartKey();
            String[] parts = StringUtils.split(startKey.getColumnFamily().toString(), '\0');
            if (parts.length == 3) {
                resultCount = NumericalEncoder.decode(parts[0]).longValue();
                // remove the count from the range
                startKey = new Key(startKey.getRow(), new Text(parts[1] + '\0' + parts[2]), startKey.getColumnQualifier(), startKey.getColumnVisibility(), startKey.getTimestamp());
                this.range = range = new Range(startKey, range.isStartKeyInclusive(), range.getEndKey(), range.isEndKeyInclusive());
            }
        }
        // determine whether this is a document specific range
        Range documentRange = isDocumentSpecificRange(range) ? range : null;
        // is done
        if (documentRange != null && !documentRange.isStartKeyInclusive()) {
            if (log.isTraceEnabled()) {
                log.trace("Received non-inclusive event specific range: " + documentRange);
            }
            if (gatherTimingDetails()) {
                this.seekKeySource = new EvaluationTrackingNestedIterator(QuerySpan.Stage.EmptyTree, trackingSpan, new EmptyTreeIterable(), myEnvironment);
            } else {
                this.seekKeySource = new EmptyTreeIterable();
            }
        } else // if the Range is for a single document and the query doesn't reference any index-only or tokenized fields
        if (documentRange != null && (!this.isContainsIndexOnlyTerms() && this.getTermFrequencyFields().isEmpty() && !super.mustUseFieldIndex)) {
            if (log.isTraceEnabled()) {
                log.trace("Received event specific range: " + documentRange);
            }
            // We can take a shortcut to the directly to the event
            Map.Entry<Key, Document> documentKey = Maps.immutableEntry(super.getDocumentKey.apply(documentRange), new Document());
            if (log.isTraceEnabled()) {
                log.trace("Transformed document key: " + documentKey);
            }
            if (gatherTimingDetails()) {
                this.seekKeySource = new EvaluationTrackingNestedIterator(QuerySpan.Stage.DocumentSpecificTree, trackingSpan, new DocumentSpecificNestedIterator(documentKey), myEnvironment);
            } else {
                this.seekKeySource = new DocumentSpecificNestedIterator(documentKey);
            }
        } else {
            this.seekKeySource = buildDocumentIterator(documentRange, range, columnFamilies, inclusive);
        }
        // Create the pipeline iterator for document aggregation and
        // evaluation within a thread pool
        PipelineIterator pipelineIter = PipelineFactory.createIterator(this.seekKeySource, getMaxEvaluationPipelines(), getMaxPipelineCachedResults(), getSerialPipelineRequest(), querySpanCollector, trackingSpan, this, sourceForDeepCopies.deepCopy(myEnvironment), myEnvironment, yield, yieldThresholdMs, columnFamilies, inclusive);
        pipelineIter.setCollectTimingDetails(collectTimingDetails);
        // TODO pipelineIter.setStatsdHostAndPort(statsdHostAndPort);
        pipelineIter.startPipeline();
        // gather Key,Document Entries from the pipelines
        Iterator<Entry<Key, Document>> pipelineDocuments = pipelineIter;
        if (log.isTraceEnabled()) {
            pipelineDocuments = Iterators.filter(pipelineDocuments, keyDocumentEntry -> {
                log.trace("after pipeline, keyDocumentEntry:" + keyDocumentEntry);
                return true;
            });
        }
        // now apply the unique transform if requested
        UniqueTransform uniquify = getUniqueTransform();
        if (uniquify != null) {
            pipelineDocuments = Iterators.filter(pipelineDocuments, uniquify.getUniquePredicate());
        }
        // apply the grouping transform if requested and if the batch size is greater than zero
        // if the batch size is 0, then grouping is computed only on the web server
        GroupingTransform groupify = getGroupingTransform();
        if (groupify != null && this.groupFieldsBatchSize > 0) {
            pipelineDocuments = groupingTransform.getGroupingIterator(pipelineDocuments, this.groupFieldsBatchSize, this.yield);
            if (log.isTraceEnabled()) {
                pipelineDocuments = Iterators.filter(pipelineDocuments, keyDocumentEntry -> {
                    log.trace("after grouping, keyDocumentEntry:" + keyDocumentEntry);
                    return true;
                });
            }
        }
        pipelineDocuments = Iterators.filter(pipelineDocuments, keyDocumentEntry -> {
            // last chance before the documents are serialized
            getActiveQueryLog().get(getQueryId()).recordStats(keyDocumentEntry.getValue(), querySpanCollector.getCombinedQuerySpan(null));
            // Always return true since we just want to record data in the ActiveQueryLog
            return true;
        });
        if (this.getReturnType() == ReturnType.kryo) {
            // Serialize the Document using Kryo
            this.serializedDocuments = Iterators.transform(pipelineDocuments, new KryoDocumentSerializer(isReducedResponse(), isCompressResults()));
        } else if (this.getReturnType() == ReturnType.writable) {
            // Use the Writable interface to serialize the Document
            this.serializedDocuments = Iterators.transform(pipelineDocuments, new WritableDocumentSerializer(isReducedResponse()));
        } else if (this.getReturnType() == ReturnType.tostring) {
            // Just return a toString() representation of the document
            this.serializedDocuments = Iterators.transform(pipelineDocuments, new ToStringDocumentSerializer(isReducedResponse()));
        } else {
            throw new IllegalArgumentException("Unknown return type of: " + this.getReturnType());
        }
        if (log.isTraceEnabled()) {
            KryoDocumentDeserializer dser = new KryoDocumentDeserializer();
            this.serializedDocuments = Iterators.filter(this.serializedDocuments, keyValueEntry -> {
                log.trace("after serializing, keyValueEntry:" + dser.apply(keyValueEntry));
                return true;
            });
        }
        // Cannot do this on document specific ranges as the count would place the keys outside the initial range
        if (!sortedUIDs && documentRange == null) {
            this.serializedDocuments = new ResultCountingIterator(serializedDocuments, resultCount, yield);
        } else if (this.sortedUIDs) {
            // we have sorted UIDs, so we can mask out the cq
            this.serializedDocuments = new KeyAdjudicator<>(serializedDocuments, yield);
        }
        // only add the final document tracking iterator which sends stats back to the client if collectTimingDetails is true
        if (collectTimingDetails) {
            // if there is no document to return, then add an empty document
            // to store the timing metadata
            this.serializedDocuments = new FinalDocumentTrackingIterator(querySpanCollector, trackingSpan, originalRange, this.serializedDocuments, this.getReturnType(), this.isReducedResponse(), this.isCompressResults(), this.yield);
        }
        if (log.isTraceEnabled()) {
            KryoDocumentDeserializer dser = new KryoDocumentDeserializer();
            this.serializedDocuments = Iterators.filter(this.serializedDocuments, keyValueEntry -> {
                log.debug("finally, considering:" + dser.apply(keyValueEntry));
                return true;
            });
        }
        // Determine if we have items to return
        prepareKeyValue(span);
    } catch (Exception e) {
        handleException(e);
    } finally {
        if (gatherTimingDetails() && trackingSpan != null && querySpanCollector != null) {
            querySpanCollector.addQuerySpan(trackingSpan);
        }
        if (null != span) {
            span.stop();
        }
        QueryStatsDClient client = getStatsdClient();
        if (client != null) {
            client.flush();
        }
        getActiveQueryLog().get(getQueryId()).endCall(this.originalRange, ActiveQuery.CallType.SEEK);
        if (this.key == null && this.value == null) {
            // no entries to return
            getActiveQueryLog().remove(getQueryId(), this.originalRange);
        }
    }
}

Example 2 with WritableDocumentSerializer

use of datawave.query.function.serializer.WritableDocumentSerializer in project datawave by NationalSecurityAgency.

the class DynamicFacetIterator method seek.

@Override
public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException {
    if (log.isDebugEnabled()) {
        log.debug("Seek range: " + range);
    }
    this.range = range;
    Iterator<Entry<Key, Document>> fieldIndexDocuments = null;
    try {
        fieldIndexDocuments = getDocumentIterator(range, columnFamilies, inclusive);
    } catch (ConfigException | IllegalAccessException | InstantiationException e) {
        throw new IOException("Unable to create document iterator", e);
    }
    // at this point we should have the cardinality for all fields
    // so we should convert each Attribute into a Cardinality
    fieldIndexDocuments = Iterators.transform(fieldIndexDocuments, new AttributeToCardinality());
    // convert the stream into a single document, so that we can summarize the cardinality
    fieldIndexDocuments = summarize(fieldIndexDocuments);
    // minimize the list of facets that are returned.
    fieldIndexDocuments = Iterators.transform(fieldIndexDocuments, new MinimumEstimation(configuration.getMinimumFacetCount()));
    if (this.getReturnType() == ReturnType.kryo) {
        // Serialize the Document using Kryo
        this.serializedDocuments = Iterators.transform(fieldIndexDocuments, new KryoDocumentSerializer(isReducedResponse(), isCompressResults()));
    } else if (this.getReturnType() == ReturnType.writable) {
        // Use the Writable interface to serialize the Document
        this.serializedDocuments = Iterators.transform(fieldIndexDocuments, new WritableDocumentSerializer(isReducedResponse()));
    } else if (this.getReturnType() == ReturnType.tostring) {
        // Just return a toString() representation of the document
        this.serializedDocuments = Iterators.transform(fieldIndexDocuments, new ToStringDocumentSerializer(isReducedResponse()));
    } else {
        throw new IllegalArgumentException("Unknown return type of: " + this.getReturnType());
    }
    // Determine if we have items to return
    if (this.serializedDocuments.hasNext()) {
        Entry<Key, Value> entry = this.serializedDocuments.next();
        this.key = entry.getKey();
        this.value = entry.getValue();
        entry = null;
    } else {
        this.key = null;
        this.value = null;
    }
}

Example 3 with WritableDocumentSerializer

use of datawave.query.function.serializer.WritableDocumentSerializer in project datawave by NationalSecurityAgency.

the class FieldIndexOnlyQueryIterator method seek.

@Override
public void seek(Range range, Collection<ByteSequence> columnFamilies, boolean inclusive) throws IOException {
    if (log.isDebugEnabled()) {
        log.debug("Seek range: " + range);
    }
    this.range = range;
    Iterator<Entry<Key, Document>> fieldIndexDocuments = null;
    try {
        fieldIndexDocuments = getDocumentIterator(range, columnFamilies, inclusive);
    } catch (ConfigException e) {
        throw new IOException("Unable to create document iterator", e);
    } catch (IllegalAccessException e) {
        throw new IOException("Unable to create document iterator", e);
    } catch (InstantiationException e) {
        throw new IOException("Unable to create document iterator", e);
    }
    // Inject the data type as a field if the user requested it
    if (this.includeDatatype) {
        if (collectTimingDetails) {
            fieldIndexDocuments = Iterators.transform(fieldIndexDocuments, new EvaluationTrackingFunction<>(QuerySpan.Stage.DataTypeAsField, trackingSpan, new DataTypeAsField(this.datatypeKey)));
        } else {
            fieldIndexDocuments = Iterators.transform(fieldIndexDocuments, new DataTypeAsField(this.datatypeKey));
        }
    }
    // Filter out masked values if requested
    if (this.filterMaskedValues) {
    // Should we filter here, or not?
    }
    if (collectTimingDetails) {
        // store the timing metadata using the documentRange endKey
        if (fieldIndexDocuments.hasNext() == false) {
            fieldIndexDocuments = Collections.singletonMap(this.range.getEndKey(), new Document()).entrySet().iterator();
        }
        fieldIndexDocuments = Iterators.transform(fieldIndexDocuments, new LogTiming(trackingSpan));
    }
    if (this.getReturnType() == ReturnType.kryo) {
        // Serialize the Document using Kryo
        this.serializedDocuments = Iterators.transform(fieldIndexDocuments, new KryoDocumentSerializer(isReducedResponse(), isCompressResults()));
    } else if (this.getReturnType() == ReturnType.writable) {
        // Use the Writable interface to serialize the Document
        this.serializedDocuments = Iterators.transform(fieldIndexDocuments, new WritableDocumentSerializer(isReducedResponse()));
    } else if (this.getReturnType() == ReturnType.tostring) {
        // Just return a toString() representation of the document
        this.serializedDocuments = Iterators.transform(fieldIndexDocuments, new ToStringDocumentSerializer(isReducedResponse()));
    } else {
        throw new IllegalArgumentException("Unknown return type of: " + this.getReturnType());
    }
    // Determine if we have items to return
    if (this.serializedDocuments.hasNext()) {
        Entry<Key, Value> entry = this.serializedDocuments.next();
        this.key = entry.getKey();
        this.value = entry.getValue();
        entry = null;
    } else {
        this.key = null;
        this.value = null;
    }
}

Example 4 with WritableDocumentSerializer

use of datawave.query.function.serializer.WritableDocumentSerializer in project datawave by NationalSecurityAgency.

the class FinalDocumentTrackingIterator method getStatsEntry.

private Map.Entry<Key, Value> getStatsEntry(Key statsKey) {
    // now add our marker
    statsKey = new Key(statsKey.getRow(), statsKey.getColumnFamily(), Util.appendText(statsKey.getColumnQualifier(), MARKER_TEXT), statsKey.getColumnVisibility(), statsKey.getTimestamp());
    HashMap<Key, Document> documentMap = new HashMap();
    QuerySpan combinedQuerySpan = querySpanCollector.getCombinedQuerySpan(this.querySpan);
    if (combinedQuerySpan != null) {
        Document document = new Document();
        LogTiming.addTimingMetadata(document, combinedQuerySpan);
        documentMap.put(statsKey, document);
    }
    Iterator<Map.Entry<Key, Document>> emptyDocumentIterator = documentMap.entrySet().iterator();
    Iterator<Map.Entry<Key, Value>> serializedDocuments = null;
    if (returnType == DocumentSerialization.ReturnType.kryo) {
        // Serialize the Document using Kryo
        serializedDocuments = Iterators.transform(emptyDocumentIterator, new KryoDocumentSerializer(isReducedResponse, isCompressResults));
    } else if (returnType == DocumentSerialization.ReturnType.writable) {
        // Use the Writable interface to serialize the Document
        serializedDocuments = Iterators.transform(emptyDocumentIterator, new WritableDocumentSerializer(isReducedResponse));
    } else if (returnType == DocumentSerialization.ReturnType.tostring) {
        // Just return a toString() representation of the document
        serializedDocuments = Iterators.transform(emptyDocumentIterator, new ToStringDocumentSerializer(isReducedResponse));
    } else {
        throw new IllegalArgumentException("Unknown return type of: " + returnType);
    }
    return serializedDocuments.next();
}