AnnotationQuery.java

  1. /*
  2.  *  AnnotationQuery.java
  3.  *
  4.  *  Copyright (c) 2007-2011, The University of Sheffield.
  5.  *
  6.  *  This file is part of GATE Mímir (see http://gate.ac.uk/family/mimir.html), 
  7.  *  and is free software, licenced under the GNU Lesser General Public License,
  8.  *  Version 3, June 2007 (also included with this distribution as file
  9.  *  LICENCE-LGPL3.html).
  10.  *
  11.  *  Valentin Tablan, 4 Mar 2009
  12.  *
  13.  *  $Id: AnnotationQuery.java 17236 2014-01-17 15:31:02Z valyt $
  14.  */
  15. package gate.mimir.search.query;


  18. import gate.mimir.Constraint;
  19. import gate.mimir.ConstraintType;
  20. import gate.mimir.SemanticAnnotationHelper;
  21. import gate.mimir.search.QueryEngine;
  22. import gate.mimir.search.terms.AnnotationTermsQuery;
  23. import gate.mimir.search.terms.TermsResultSet;
  24. import it.unimi.di.big.mg4j.index.Index;
  25. import it.unimi.di.big.mg4j.search.visitor.DocumentIteratorVisitor;
  26. import it.unimi.dsi.fastutil.objects.ReferenceSet;
  27. import it.unimi.dsi.fastutil.objects.ReferenceSets;

  29. import java.io.IOException;
  30. import java.util.ArrayList;
  31. import java.util.HashMap;
  32. import java.util.List;
  33. import java.util.Map;

  35. import org.slf4j.Logger;
  36. import org.slf4j.LoggerFactory;


  39. /**
  40.  * A query for the annotations index. 
  41.  */
  42. public class AnnotationQuery implements QueryNode {

  44.   private static final long serialVersionUID = 5996543707885867821L;


  47.   public static class AnnotationQueryExecutor extends AbstractQueryExecutor{

  49.     
  50.     /**
  51.      * @param engine
  52.      * @param query
  53.      */
  54.     public AnnotationQueryExecutor(AnnotationQuery query, QueryEngine engine) throws IOException {
  55.       super(engine, query);
  56.       this.query = query;
  57.       buildQuery();
  58.     }
  59.     
  60.     /**
  61.      * The query being executed.
  62.      */
  63.     private AnnotationQuery query;
  64.     
  65.     /**
  66.      * Logger for this class.
  67.      */
  68.     private static Logger logger = LoggerFactory.getLogger(AnnotationQueryExecutor.class);

  70.     /**
  71.      * The underlying OrQuery executor that actually does the work.
  72.      */
  73.     private QueryExecutor underlyingExecutor;
  74.     
  75.     private transient boolean isInDocumentMode;
  76.     
  77.     /**
  78.      * Build the underlying OrQuery executor that this annotation query uses.
  79.      */
  80.     protected void buildQuery() throws IOException {
  81.       SemanticAnnotationHelper helper = engine.getAnnotationHelper(query);
  82.       isInDocumentMode = (helper.getMode() == 
  83.           SemanticAnnotationHelper.Mode.DOCUMENT);
  84.       // get the mention URIs
  85.       TermsResultSet trs = new AnnotationTermsQuery(query).execute(engine);
  86.       if(trs.termStrings != null && trs.termStrings.length > 0 && 
  87.          trs.termLengths != null) {
  88.         QueryNode[] disjuncts = new QueryNode[trs.termStrings.length];
  89.         for(int index = 0; index < trs.termStrings.length; index++) {
  90.           // create a term query for the mention URI
  91.           disjuncts[index] = new TermQuery(query.annotationType, 
  92.               trs.termStrings[index], trs.termLengths[index]);
  93.         }
  94.         QueryNode underlyingQuery = new OrQuery(disjuncts);
  95.         underlyingExecutor = underlyingQuery.getQueryExecutor(engine);        
  96.       } else {
  97.         // no results from the helper => no results from us
  98.         latestDocument = -1;
  99.       }
  100.     }
  101.     
  102.     
  103.     /* (non-Javadoc)
  104.      * @see gate.mimir.search.query.QueryExecutor#close()
  105.      */
  106.     public void close() throws IOException {
  107.       if(closed) return;
  108.       super.close();
  109.       if(underlyingExecutor != null) underlyingExecutor.close();
  110.     }

  112.     /* (non-Javadoc)
  113.      * @see gate.mimir.search.query.QueryExecutor#getLatestDocument()
  114.      */
  115.     public long getLatestDocument() {
  116.       if(closed || latestDocument == -1) return -1;
  117.       return underlyingExecutor.getLatestDocument();
  118.     }

  120.     /* (non-Javadoc)
  121.      * @see gate.mimir.search.query.QueryExecutor#nextDocument(int)
  122.      */
  123.     public long nextDocument(long greaterThan) throws IOException {
  124.       if(closed || latestDocument == -1) return -1;
  125.       return latestDocument = underlyingExecutor.nextDocument(greaterThan);
  126.     }

  128.     /* (non-Javadoc)
  129.      * @see gate.mimir.search.query.QueryExecutor#nextHit()
  130.      */
  131.     public Binding nextHit() throws IOException {
  132.       if(closed || latestDocument == -1) return null;
  133.       Binding underlyingHit = underlyingExecutor.nextHit();
  134.       if(underlyingHit == null) return null;
  135.       long doc = underlyingHit.getDocumentId();
  136.       if(isInDocumentMode) {
  137.         return new Binding(query, doc, 0, engine.getIndex().getDocumentSize(doc),
  138.           null);
  139.       } else {
  140.         return new Binding(query, doc,
  141.           underlyingHit.getTermPosition(),
  142.           underlyingHit.getLength(),
  143.           null);
  144.       }
  145.     }
  146.    
  147.     @Override
  148.     public ReferenceSet<Index> indices() {
  149.       if(underlyingExecutor != null) {
  150.         return underlyingExecutor.indices();
  151.       } else {
  152.         return ReferenceSets.EMPTY_SET;
  153.       }
  154.     }
  155.     
  156.     public <T> T accept( final DocumentIteratorVisitor<T> visitor ) throws IOException {
  157.       if(underlyingExecutor == null) return null;
  158.       if ( ! visitor.visitPre( this ) ) return null;
  159.       final T[] a = visitor.newArray( 1 );
  160.       if ( a == null ) {
  161.         if ( underlyingExecutor.accept( visitor ) == null ) return null;
  162.       }
  163.       else {
  164.         if ( ( a[ 0 ] = underlyingExecutor.accept( visitor ) ) == null ) return null;
  165.       }
  166.       return visitor.visitPost( this, a );
  167.     }

  169.     public <T> T acceptOnTruePaths( final DocumentIteratorVisitor<T> visitor ) throws IOException {
  170.       if(underlyingExecutor == null) return null;
  171.       if ( ! visitor.visitPre( this ) ) return null;
  172.       final T[] a = visitor.newArray( 1 );
  173.       if ( a == null ) {
  174.         if ( underlyingExecutor.acceptOnTruePaths( visitor ) == null ) return null;     
  175.       }
  176.       else {
  177.         if ( ( a[ 0 ] = underlyingExecutor.acceptOnTruePaths( visitor ) ) == null ) return null;
  178.       }
  179.       return visitor.visitPost( this, a );
  180.     }
  181.   }
  182.   
  183.   /**
  184.    * Constructs a new {@link AnnotationQuery}.
  185.    * 
  186.    * Convenience variant of {@link #AnnotationQuery(String, List)} 
  187.    * for cases where all predicates are of type 
  188.    * {@link SemanticAnnotationHelper.ConstraintType#EQ}.
  189.    * 
  190.    * @param annotationType the desired annotation type, for the annotations to 
  191.    * be matched.
  192.    * @param featureConstraints the constraints over the features of the 
  193.    * annotations to be found. This is represented as a {@link Map} from feature
  194.    * name (a {@link String}) to feature value (also a {@link String}).
  195.    * 
  196.    * @see AnnotationQuery#AnnotationQuery(String, List)  
  197.    */
  198.   public AnnotationQuery(String annotationType,
  199.           Map<String, String> featureConstraints) {
  200.     if(featureConstraints == null){
  201.       featureConstraints = new HashMap<String, String>();
  202.     }
  203.     this.annotationType = annotationType;
  204.     this.constraints = new ArrayList<Constraint>(featureConstraints.size());
  205.     for(Map.Entry<String, String> entry : featureConstraints.entrySet()){
  206.       this.constraints.add(new Constraint(ConstraintType.EQ,
  207.               entry.getKey(), entry.getValue()));
  208.     }
  209.   }

  211.   /**
  212.    * Constructs a new Annotation Query.
  213.    *  
  214.    * @param annotationType the type of annotation being sought.
  215.    * @param constraints a list of constraints placed on the feature values. An 
  216.    * empty constraints list will make no requests regarding the feature values,
  217.    * hence it will match all annotations of the right type. 
  218.    */
  219.   public AnnotationQuery(String annotationType, List<Constraint> constraints) {
  220.     this.annotationType = annotationType;
  221.     this.constraints = constraints == null ? new ArrayList<Constraint>() :constraints;
  222.   }
  223.   
  224.   /* (non-Javadoc)
  225.    * @see gate.mimir.search.query.QueryNode#getQueryExecutor(java.util.Map)
  226.    */
  227.   public QueryExecutor getQueryExecutor(QueryEngine engine)
  228.           throws IOException {
  229.     return new AnnotationQueryExecutor(this, engine);
  230.   }
  231.   
  232.   
  233.   /**
  234.    * Gets the annotation type for this query. 
  235.    * @return the annotationType
  236.    */
  237.   public String getAnnotationType() {
  238.     return annotationType;
  239.   }

  241.   /**
  242.    * Gets the feature constraints, represented as a {@link Map} from 
  243.    * feature name (a {@link String}) to feature value (also a {@link String}). 
  244.    * @return the featureConstraints
  245.    */
  246.   public List<Constraint> getConstraints() {
  247.     return constraints;
  248.   }


  251.   /**
  252.    * The annotation type for this query.
  253.    */
  254.   private String annotationType;
  255.   
  256.   /**
  257.    * The constrains over the annotation features.
  258.    */
  259.   private List<Constraint> constraints;
  260.   
  261.   
  262.   public String toString() {
  263.     return "Annotation ( type = " + 
  264.     annotationType + ", features=" + 
  265.     (constraints != null ? constraints.toString() : "[]") +
  266.     ")";
  267.   }

  269. }
Created with JaCoCo 0.8.5.201910111838