extensions/net.sf.basedb.reggie/trunk/src/net/sf/basedb/reggie/plugins/release/QueryManager.java

Code
Comments
Other
Rev Date Author Line
5098 15 Nov 18 nicklas 1 package net.sf.basedb.reggie.plugins.release;
5098 15 Nov 18 nicklas 2
5098 15 Nov 18 nicklas 3 import java.util.ArrayList;
5098 15 Nov 18 nicklas 4 import java.util.List;
5098 15 Nov 18 nicklas 5
5098 15 Nov 18 nicklas 6 import net.sf.basedb.core.AnnotationType;
5098 15 Nov 18 nicklas 7 import net.sf.basedb.core.BioMaterial;
5098 15 Nov 18 nicklas 8 import net.sf.basedb.core.DbControl;
5102 16 Nov 18 nicklas 9 import net.sf.basedb.core.DerivedBioAssay;
5099 15 Nov 18 nicklas 10 import net.sf.basedb.core.Extract;
5102 16 Nov 18 nicklas 11 import net.sf.basedb.core.Item;
5198 19 Dec 18 nicklas 12 import net.sf.basedb.core.ItemList;
5098 15 Nov 18 nicklas 13 import net.sf.basedb.core.ItemQuery;
5103 16 Nov 18 nicklas 14 import net.sf.basedb.core.RawBioAssay;
5098 15 Nov 18 nicklas 15 import net.sf.basedb.core.Sample;
5098 15 Nov 18 nicklas 16 import net.sf.basedb.core.Type;
5098 15 Nov 18 nicklas 17 import net.sf.basedb.core.query.Annotations;
5098 15 Nov 18 nicklas 18 import net.sf.basedb.core.query.Expressions;
5098 15 Nov 18 nicklas 19 import net.sf.basedb.core.query.Hql;
5107 19 Nov 18 nicklas 20 import net.sf.basedb.core.query.Orders;
5098 15 Nov 18 nicklas 21 import net.sf.basedb.core.query.Restrictions;
5098 15 Nov 18 nicklas 22 import net.sf.basedb.reggie.Reggie;
5103 16 Nov 18 nicklas 23 import net.sf.basedb.reggie.dao.AlignedSequences;
5098 15 Nov 18 nicklas 24 import net.sf.basedb.reggie.dao.Annotationtype;
5198 19 Dec 18 nicklas 25 import net.sf.basedb.reggie.dao.BiomaterialList;
5142 22 Nov 18 nicklas 26 import net.sf.basedb.reggie.dao.Blood;
7007 25 Jan 23 nicklas 27 import net.sf.basedb.reggie.dao.BloodDna;
5098 15 Nov 18 nicklas 28 import net.sf.basedb.reggie.dao.Case;
7006 24 Jan 23 nicklas 29 import net.sf.basedb.reggie.dao.Dna;
7007 25 Jan 23 nicklas 30 import net.sf.basedb.reggie.dao.GenotypeCall;
5107 19 Nov 18 nicklas 31 import net.sf.basedb.reggie.dao.Histology;
5102 16 Nov 18 nicklas 32 import net.sf.basedb.reggie.dao.Library;
5100 15 Nov 18 nicklas 33 import net.sf.basedb.reggie.dao.Lysate;
5103 16 Nov 18 nicklas 34 import net.sf.basedb.reggie.dao.MaskedSequences;
5103 16 Nov 18 nicklas 35 import net.sf.basedb.reggie.dao.MergedSequences;
5098 15 Nov 18 nicklas 36 import net.sf.basedb.reggie.dao.Patient;
5549 08 Aug 19 nicklas 37 import net.sf.basedb.reggie.dao.Pipeline;
5103 16 Nov 18 nicklas 38 import net.sf.basedb.reggie.dao.Rawdatatype;
5098 15 Nov 18 nicklas 39 import net.sf.basedb.reggie.dao.ReggieItem;
5099 15 Nov 18 nicklas 40 import net.sf.basedb.reggie.dao.SpecimenTube;
5098 15 Nov 18 nicklas 41 import net.sf.basedb.reggie.dao.Subtype;
5098 15 Nov 18 nicklas 42
5098 15 Nov 18 nicklas 43 /**
5098 15 Nov 18 nicklas 44   Helper class for generating and keeping track of queries that are 
5098 15 Nov 18 nicklas 45   needed in order to load relase data at different levels.
5098 15 Nov 18 nicklas 46   @author nicklas
5098 15 Nov 18 nicklas 47   @since 4.21
5098 15 Nov 18 nicklas 48 */
5098 15 Nov 18 nicklas 49 public class QueryManager
5098 15 Nov 18 nicklas 50 {
5098 15 Nov 18 nicklas 51   // NOTE! This DbControl belongs to the writing transaction and should 
5098 15 Nov 18 nicklas 52   // not be used for loading release data. Basically, we need it to
5098 15 Nov 18 nicklas 53   // make sure subtypes, annotation types, etc. that are used for
5098 15 Nov 18 nicklas 54   // building queries can be loaded.
5098 15 Nov 18 nicklas 55   private final DbControl dc;
5098 15 Nov 18 nicklas 56   
5098 15 Nov 18 nicklas 57   private ItemQuery<Sample> caseQuery;
5138 22 Nov 18 nicklas 58   private ItemQuery<Sample> bloodQuery;
5098 15 Nov 18 nicklas 59   private ItemQuery<Sample> specimenQuery;
5136 22 Nov 18 nicklas 60   private ItemQuery<Sample> noSpecimenQuery;
5107 19 Nov 18 nicklas 61   private ItemQuery<Sample> histologyQuery;
5107 19 Nov 18 nicklas 62   private ItemQuery<Sample> goodStainQuery;
5142 22 Nov 18 nicklas 63   private ItemQuery<Extract> bloodDnaQuery;
5099 15 Nov 18 nicklas 64   private ItemQuery<Extract> lysateQuery;
5100 15 Nov 18 nicklas 65   private ItemQuery<Extract> rnaQuery;
5131 21 Nov 18 nicklas 66   private ItemQuery<Extract> dnaQuery;
5131 21 Nov 18 nicklas 67   private ItemQuery<Extract> flowThroughQuery;
5101 16 Nov 18 nicklas 68   private ItemQuery<Extract> libQuery;
7006 24 Jan 23 nicklas 69   private ItemQuery<DerivedBioAssay> methylationQuery;
5102 16 Nov 18 nicklas 70   private ItemQuery<DerivedBioAssay> mergedQuery;
5103 16 Nov 18 nicklas 71   private ItemQuery<DerivedBioAssay> maskedQuery;
5103 16 Nov 18 nicklas 72   private ItemQuery<DerivedBioAssay> alignedQuery;
5103 16 Nov 18 nicklas 73   private ItemQuery<RawBioAssay> stringTieQuery;
5103 16 Nov 18 nicklas 74   private ItemQuery<RawBioAssay> cufflinksQuery;
5873 23 Mar 20 nicklas 75   private ItemQuery<RawBioAssay> variantCallQuery;
7007 25 Jan 23 nicklas 76   private ItemQuery<DerivedBioAssay> genotypeCallQuery;
7007 25 Jan 23 nicklas 77   private ItemQuery<RawBioAssay> oncoArrayQuery;
5104 16 Nov 18 nicklas 78   private ItemQuery<DerivedBioAssay> demuxedQuery;
5104 16 Nov 18 nicklas 79   private ItemQuery<DerivedBioAssay> sequencingRunQuery;
5104 16 Nov 18 nicklas 80   private ItemQuery<Extract> poolsFromLibQuery;
5098 15 Nov 18 nicklas 81   
5098 15 Nov 18 nicklas 82   public QueryManager(DbControl dc) 
5098 15 Nov 18 nicklas 83   {
5098 15 Nov 18 nicklas 84     this.dc = dc;
5098 15 Nov 18 nicklas 85   }
5098 15 Nov 18 nicklas 86   
5098 15 Nov 18 nicklas 87   /**
5098 15 Nov 18 nicklas 88     Get a query that is returning all cases that are related to the
5098 15 Nov 18 nicklas 89     given patient. The query is filtered to only return cases with
5098 15 Nov 18 nicklas 90     Consent=Yes and DoNotUse=null.
5098 15 Nov 18 nicklas 91     @return A query or null if the patient is null
5098 15 Nov 18 nicklas 92   */
5098 15 Nov 18 nicklas 93   public ItemQuery<Sample> getCaseQuery(Patient patient)
5098 15 Nov 18 nicklas 94   {
5098 15 Nov 18 nicklas 95     if (patient == null) return null;
5098 15 Nov 18 nicklas 96     if (caseQuery == null)
5098 15 Nov 18 nicklas 97     {
5098 15 Nov 18 nicklas 98       caseQuery = Sample.getQuery();
5101 16 Nov 18 nicklas 99       initBioMaterialQuery(caseQuery, Subtype.CASE, Subtype.PATIENT, ParentRestriction.SINGLE_ENTITY);
5098 15 Nov 18 nicklas 100       annotationEquals(caseQuery, Annotationtype.CONSENT, "Yes");
5098 15 Nov 18 nicklas 101       annotationEquals(caseQuery, Annotationtype.DO_NOT_USE, null);
5098 15 Nov 18 nicklas 102     }
5098 15 Nov 18 nicklas 103     caseQuery.setEntityParameter("parent", patient.getItem());
5098 15 Nov 18 nicklas 104     return caseQuery;
5098 15 Nov 18 nicklas 105   }
5098 15 Nov 18 nicklas 106   
5098 15 Nov 18 nicklas 107   /**
5138 22 Nov 18 nicklas 108     Get a query that is returning all blood items that are related to the
5138 22 Nov 18 nicklas 109     given patient. The query is filtered to only return items with
5138 22 Nov 18 nicklas 110     Consent=Yes and DoNotUse=null.
5138 22 Nov 18 nicklas 111     @return A query or null if the patient is null
5138 22 Nov 18 nicklas 112   */
5138 22 Nov 18 nicklas 113   public ItemQuery<Sample> getBloodQuery(Patient patient)
5138 22 Nov 18 nicklas 114   {
5138 22 Nov 18 nicklas 115     if (patient == null) return null;
5138 22 Nov 18 nicklas 116     if (bloodQuery == null)
5138 22 Nov 18 nicklas 117     {
5138 22 Nov 18 nicklas 118       bloodQuery = Sample.getQuery();
5138 22 Nov 18 nicklas 119       initBioMaterialQuery(bloodQuery, Subtype.BLOOD, Subtype.PATIENT, ParentRestriction.SINGLE_ENTITY);
5138 22 Nov 18 nicklas 120       annotationEquals(bloodQuery, Annotationtype.CONSENT, "Yes");
5138 22 Nov 18 nicklas 121       annotationEquals(bloodQuery, Annotationtype.DO_NOT_USE, null);
5138 22 Nov 18 nicklas 122     }
5138 22 Nov 18 nicklas 123     bloodQuery.setEntityParameter("parent", patient.getItem());
5138 22 Nov 18 nicklas 124     return bloodQuery;
5138 22 Nov 18 nicklas 125   }
5138 22 Nov 18 nicklas 126
5138 22 Nov 18 nicklas 127   /**
5142 22 Nov 18 nicklas 128     Get a query that is returning all BloodDNA items that are related 
5142 22 Nov 18 nicklas 129     to the given list of parent Blood. The query is filtered to only return 
5142 22 Nov 18 nicklas 130     items with DoNotUse=null.
5142 22 Nov 18 nicklas 131     @return A query or null if the list is null or empty
5142 22 Nov 18 nicklas 132   */
5142 22 Nov 18 nicklas 133   public ItemQuery<Extract> getBloodDnaQuery(List<Blood> blood)
5142 22 Nov 18 nicklas 134   {
5142 22 Nov 18 nicklas 135     if (blood == null || blood.isEmpty()) return null;
5142 22 Nov 18 nicklas 136     if (bloodDnaQuery == null)
5142 22 Nov 18 nicklas 137     {
5142 22 Nov 18 nicklas 138       bloodDnaQuery = Extract.getQuery();
5142 22 Nov 18 nicklas 139       initBioMaterialQuery(bloodDnaQuery, Subtype.BLOOD_DNA, Subtype.BLOOD, ParentRestriction.LIST_ID);
5142 22 Nov 18 nicklas 140       annotationEquals(bloodDnaQuery, Annotationtype.DO_NOT_USE, null);
5142 22 Nov 18 nicklas 141     }
5142 22 Nov 18 nicklas 142     bloodDnaQuery.setParameter("parents", idList(blood), Type.INT);
5142 22 Nov 18 nicklas 143     return bloodDnaQuery;
5142 22 Nov 18 nicklas 144   }
5142 22 Nov 18 nicklas 145
5142 22 Nov 18 nicklas 146   
5142 22 Nov 18 nicklas 147   /**
5098 15 Nov 18 nicklas 148     Get a query that is returning all specimen tubes that are related 
5098 15 Nov 18 nicklas 149     to the given list of cases. The query is filtered to only return 
5098 15 Nov 18 nicklas 150     specimen with DoNotUse=null.
5101 16 Nov 18 nicklas 151     @return A query or null if the list is null or empty
5098 15 Nov 18 nicklas 152   */
5098 15 Nov 18 nicklas 153   public ItemQuery<Sample> getSpecimenQuery(List<Case> cases)
5098 15 Nov 18 nicklas 154   {
5098 15 Nov 18 nicklas 155     if (cases == null || cases.isEmpty()) return null;
5098 15 Nov 18 nicklas 156     if (specimenQuery == null)
5098 15 Nov 18 nicklas 157     {
5098 15 Nov 18 nicklas 158       specimenQuery = Sample.getQuery();
5101 16 Nov 18 nicklas 159       initBioMaterialQuery(specimenQuery, Subtype.SPECIMEN, Subtype.CASE, ParentRestriction.LIST_ID);
5098 15 Nov 18 nicklas 160       annotationEquals(specimenQuery, Annotationtype.DO_NOT_USE, null);
5098 15 Nov 18 nicklas 161     }
5098 15 Nov 18 nicklas 162     specimenQuery.setParameter("parents", idList(cases), Type.INT);
5098 15 Nov 18 nicklas 163     return specimenQuery;
5098 15 Nov 18 nicklas 164   }
5098 15 Nov 18 nicklas 165   
5098 15 Nov 18 nicklas 166   /**
5136 22 Nov 18 nicklas 167     Get a query that is returning all NoSpecimen items that are related 
5136 22 Nov 18 nicklas 168     to the given list of cases. The query is filtered to only return 
6580 10 Feb 22 nicklas 169     items with DoNotUse=null and ExternalSpecimenExists!=Yes 
5136 22 Nov 18 nicklas 170     @return A query or null if the list is null or empty
5136 22 Nov 18 nicklas 171   */
5136 22 Nov 18 nicklas 172   public ItemQuery<Sample> getNoSpecimenQuery(List<Case> cases)
5136 22 Nov 18 nicklas 173   {
5136 22 Nov 18 nicklas 174     if (cases == null || cases.isEmpty()) return null;
5136 22 Nov 18 nicklas 175     if (noSpecimenQuery == null)
5136 22 Nov 18 nicklas 176     {
5136 22 Nov 18 nicklas 177       noSpecimenQuery = Sample.getQuery();
5136 22 Nov 18 nicklas 178       initBioMaterialQuery(noSpecimenQuery, Subtype.NO_SPECIMEN, Subtype.CASE, ParentRestriction.LIST_ID);
5136 22 Nov 18 nicklas 179       annotationEquals(noSpecimenQuery, Annotationtype.DO_NOT_USE, null);
6580 10 Feb 22 nicklas 180       noSpecimenQuery.join(Annotations.leftJoin(Annotationtype.EXTERNAL_SPECIMEN_EXISTS.load(dc), "es"));
6580 10 Feb 22 nicklas 181       noSpecimenQuery.restrict(
6580 10 Feb 22 nicklas 182         Restrictions.or(
6580 10 Feb 22 nicklas 183           Restrictions.eq(Hql.alias("es"), null),
6580 10 Feb 22 nicklas 184           Restrictions.neq(Hql.alias("es"), Expressions.string("Yes"))
6580 10 Feb 22 nicklas 185         ));
5136 22 Nov 18 nicklas 186     }
5136 22 Nov 18 nicklas 187     noSpecimenQuery.setParameter("parents", idList(cases), Type.INT);
5136 22 Nov 18 nicklas 188     return noSpecimenQuery;
5136 22 Nov 18 nicklas 189   }
5136 22 Nov 18 nicklas 190
5136 22 Nov 18 nicklas 191   /**
5107 19 Nov 18 nicklas 192     Get a query that is returning the Histology item that is related
5107 19 Nov 18 nicklas 193     to the given specimen. The query is filtered to only return 
5164 03 Dec 18 nicklas 194     histology with a creation date, DoNotUse=null and if there is more than one it
5107 19 Nov 18 nicklas 195     will only return the histology with the latest partition date.
5107 19 Nov 18 nicklas 196     @return A query or null if the specimen is null
5107 19 Nov 18 nicklas 197   */
5107 19 Nov 18 nicklas 198   public ItemQuery<Sample> getHistologyQuery(SpecimenTube specimen)
5107 19 Nov 18 nicklas 199   {
5107 19 Nov 18 nicklas 200     if (specimen == null) return null;
5107 19 Nov 18 nicklas 201     if (histologyQuery == null)
5107 19 Nov 18 nicklas 202     {
5107 19 Nov 18 nicklas 203       histologyQuery = Sample.getQuery();
5107 19 Nov 18 nicklas 204       initBioMaterialQuery(histologyQuery, Subtype.HISTOLOGY, Subtype.SPECIMEN, ParentRestriction.SINGLE_ENTITY);
5164 03 Dec 18 nicklas 205       hasCreationDate(histologyQuery);
5107 19 Nov 18 nicklas 206       annotationEquals(histologyQuery, Annotationtype.DO_NOT_USE, null);
5107 19 Nov 18 nicklas 207       // If there is more than one Histology we load the last one
5107 19 Nov 18 nicklas 208       // TODO -- is this what we want?
5107 19 Nov 18 nicklas 209       histologyQuery.join(Annotations.innerJoin(null, Annotationtype.PARTITION_DATE.load(dc), "pd"));
5107 19 Nov 18 nicklas 210       histologyQuery.order(Orders.desc(Hql.alias("pd")));
5107 19 Nov 18 nicklas 211       histologyQuery.setMaxResults(1);
5107 19 Nov 18 nicklas 212     }
5107 19 Nov 18 nicklas 213     histologyQuery.setEntityParameter("parent", specimen.getItem());
5107 19 Nov 18 nicklas 214     return histologyQuery;
5107 19 Nov 18 nicklas 215   }
5107 19 Nov 18 nicklas 216   
5107 19 Nov 18 nicklas 217   /**
5107 19 Nov 18 nicklas 218     Get a query that is returning the HE-stained item that is related
5107 19 Nov 18 nicklas 219     to the given histology item. The query is filtered to only return 
5107 19 Nov 18 nicklas 220     stained item with GoodStain=true (there should only be a single such item).
5107 19 Nov 18 nicklas 221     @return A query or null if the histology item is null
5107 19 Nov 18 nicklas 222   */
5107 19 Nov 18 nicklas 223   public ItemQuery<Sample> getGoodStainQuery(Histology histology)
5107 19 Nov 18 nicklas 224   {
5107 19 Nov 18 nicklas 225     if (histology == null) return null;
5107 19 Nov 18 nicklas 226     if (goodStainQuery == null)
5107 19 Nov 18 nicklas 227     {
5107 19 Nov 18 nicklas 228       goodStainQuery = Sample.getQuery();
5107 19 Nov 18 nicklas 229       initBioMaterialQuery(goodStainQuery, Subtype.STAINED, Subtype.HISTOLOGY, ParentRestriction.SINGLE_ENTITY);
5107 19 Nov 18 nicklas 230       annotationEquals(goodStainQuery, Annotationtype.GOOD_STAIN, true);
5107 19 Nov 18 nicklas 231     }
5107 19 Nov 18 nicklas 232     goodStainQuery.setEntityParameter("parent", histology.getItem());
5107 19 Nov 18 nicklas 233     return goodStainQuery;
5107 19 Nov 18 nicklas 234   }
5107 19 Nov 18 nicklas 235   
5107 19 Nov 18 nicklas 236   /**
5099 15 Nov 18 nicklas 237     Get a query that is returning all lysates that are related 
5099 15 Nov 18 nicklas 238     to the given list of specimen. The query is filtered to only return 
5164 03 Dec 18 nicklas 239     lysates with a creation date and DoNotUse=null.
5101 16 Nov 18 nicklas 240     @return A query or null if the list is null or empty
5099 15 Nov 18 nicklas 241   */
5099 15 Nov 18 nicklas 242   public ItemQuery<Extract> getLysateQuery(List<SpecimenTube> specimen)
5099 15 Nov 18 nicklas 243   {
5099 15 Nov 18 nicklas 244     if (specimen == null || specimen.isEmpty()) return null;
5099 15 Nov 18 nicklas 245     if (lysateQuery == null)
5099 15 Nov 18 nicklas 246     {
5099 15 Nov 18 nicklas 247       lysateQuery = Extract.getQuery();
5101 16 Nov 18 nicklas 248       initBioMaterialQuery(lysateQuery, Subtype.LYSATE, Subtype.SPECIMEN, ParentRestriction.LIST_ID);
5164 03 Dec 18 nicklas 249       hasCreationDate(lysateQuery);
5099 15 Nov 18 nicklas 250       annotationEquals(lysateQuery, Annotationtype.DO_NOT_USE, null);
5099 15 Nov 18 nicklas 251     }
5099 15 Nov 18 nicklas 252     lysateQuery.setParameter("parents", idList(specimen), Type.INT);
5099 15 Nov 18 nicklas 253     return lysateQuery;
5099 15 Nov 18 nicklas 254   }
5099 15 Nov 18 nicklas 255
5099 15 Nov 18 nicklas 256   /**
5100 15 Nov 18 nicklas 257     Get a query that is returning all RNA items that are related 
5100 15 Nov 18 nicklas 258     to the given list of lysates. The query is filtered to only return 
5100 15 Nov 18 nicklas 259     RNA with DoNotUse=null.
5101 16 Nov 18 nicklas 260     @return A query or null if the list is null or empty
5100 15 Nov 18 nicklas 261   */
5100 15 Nov 18 nicklas 262   public ItemQuery<Extract> getRnaQuery(List<Lysate> lysates)
5100 15 Nov 18 nicklas 263   {
5100 15 Nov 18 nicklas 264     if (lysates == null || lysates.isEmpty()) return null;
5100 15 Nov 18 nicklas 265     if (rnaQuery == null)
5100 15 Nov 18 nicklas 266     {
5100 15 Nov 18 nicklas 267       rnaQuery = Extract.getQuery();
5101 16 Nov 18 nicklas 268       initBioMaterialQuery(rnaQuery, Subtype.RNA, Subtype.LYSATE, ParentRestriction.LIST_ID);
5100 15 Nov 18 nicklas 269       annotationEquals(rnaQuery, Annotationtype.DO_NOT_USE, null);
5100 15 Nov 18 nicklas 270     }
5100 15 Nov 18 nicklas 271     rnaQuery.setParameter("parents", idList(lysates), Type.INT);
5100 15 Nov 18 nicklas 272     return rnaQuery;
5100 15 Nov 18 nicklas 273   }
5100 15 Nov 18 nicklas 274
5100 15 Nov 18 nicklas 275   /**
5131 21 Nov 18 nicklas 276     Get a query that is returning all DNA items that are related 
5131 21 Nov 18 nicklas 277     to the given list of lysates. The query is filtered to only return 
5131 21 Nov 18 nicklas 278     DNA with DoNotUse=null.
5131 21 Nov 18 nicklas 279     @return A query or null if the list is null or empty
5131 21 Nov 18 nicklas 280   */
5131 21 Nov 18 nicklas 281   public ItemQuery<Extract> getDnaQuery(List<Lysate> lysates)
5131 21 Nov 18 nicklas 282   {
5131 21 Nov 18 nicklas 283     if (lysates == null || lysates.isEmpty()) return null;
5131 21 Nov 18 nicklas 284     if (dnaQuery == null)
5131 21 Nov 18 nicklas 285     {
5131 21 Nov 18 nicklas 286       dnaQuery = Extract.getQuery();
5131 21 Nov 18 nicklas 287       initBioMaterialQuery(dnaQuery, Subtype.DNA, Subtype.LYSATE, ParentRestriction.LIST_ID);
5131 21 Nov 18 nicklas 288       annotationEquals(dnaQuery, Annotationtype.DO_NOT_USE, null);
5131 21 Nov 18 nicklas 289     }
5131 21 Nov 18 nicklas 290     dnaQuery.setParameter("parents", idList(lysates), Type.INT);
5131 21 Nov 18 nicklas 291     return dnaQuery;
5131 21 Nov 18 nicklas 292   }
5131 21 Nov 18 nicklas 293
5131 21 Nov 18 nicklas 294   /**
5131 21 Nov 18 nicklas 295     Get a query that is returning all FlowThrough items that are related 
5131 21 Nov 18 nicklas 296     to the given list of lysates. The query is filtered to only return 
5131 21 Nov 18 nicklas 297     FlowThrough with DoNotUse=null.
5131 21 Nov 18 nicklas 298     @return A query or null if the list is null or empty
5131 21 Nov 18 nicklas 299   */
5131 21 Nov 18 nicklas 300   public ItemQuery<Extract> getFlowThroughQuery(List<Lysate> lysates)
5131 21 Nov 18 nicklas 301   {
5131 21 Nov 18 nicklas 302     if (lysates == null || lysates.isEmpty()) return null;
5131 21 Nov 18 nicklas 303     if (flowThroughQuery == null)
5131 21 Nov 18 nicklas 304     {
5131 21 Nov 18 nicklas 305       flowThroughQuery = Extract.getQuery();
5131 21 Nov 18 nicklas 306       initBioMaterialQuery(flowThroughQuery, Subtype.FLOW_THROUGH, Subtype.LYSATE, ParentRestriction.LIST_ID);
5131 21 Nov 18 nicklas 307       annotationEquals(flowThroughQuery, Annotationtype.DO_NOT_USE, null);
5131 21 Nov 18 nicklas 308     }
5131 21 Nov 18 nicklas 309     flowThroughQuery.setParameter("parents", idList(lysates), Type.INT);
5131 21 Nov 18 nicklas 310     return flowThroughQuery;
5131 21 Nov 18 nicklas 311   }
5131 21 Nov 18 nicklas 312
5131 21 Nov 18 nicklas 313   /**
5101 16 Nov 18 nicklas 314     Get a query that is returning all Library items that are related to the
5549 08 Aug 19 nicklas 315     given list of RNA or DNA. The query is filtered to only return libraries
5197 19 Dec 18 nicklas 316     with a creation date, DoNotUse=null, a name that doesn't end with '.dil' and located
5197 19 Dec 18 nicklas 317     on a LibPlate with PlateProcessResult=Successful. Since there are multiple variants 
5549 08 Aug 19 nicklas 318     of the path from library to RNA/DNA (depending on the protocol used) the query is matching 
5197 19 Dec 18 nicklas 319     items by name instead of actual links.
5101 16 Nov 18 nicklas 320     @return A query or null if the list is null or empty
5101 16 Nov 18 nicklas 321   */
5549 08 Aug 19 nicklas 322   public ItemQuery<Extract> getLibraryQuery(List<? extends ReggieItem<Extract>> rnaOrDna, Pipeline pipeline)
5101 16 Nov 18 nicklas 323   {
5549 08 Aug 19 nicklas 324     if (rnaOrDna == null || rnaOrDna.isEmpty()) return null;
5101 16 Nov 18 nicklas 325     if (libQuery == null)
5101 16 Nov 18 nicklas 326     {
5101 16 Nov 18 nicklas 327       libQuery = Extract.getQuery();
5101 16 Nov 18 nicklas 328       initBioMaterialQuery(libQuery, Subtype.LIBRARY, null, ParentRestriction.REGEXP_NAME);
5164 03 Dec 18 nicklas 329       hasCreationDate(libQuery);
5101 16 Nov 18 nicklas 330       libQuery.restrict(Restrictions.not(Restrictions.like(Hql.property("name"), Expressions.string("%.dil")))); // Exclude .dil items
5101 16 Nov 18 nicklas 331       annotationEquals(libQuery, Annotationtype.DO_NOT_USE, null);
5549 08 Aug 19 nicklas 332       Pipeline.createFilterParameter(dc, libQuery);
5549 08 Aug 19 nicklas 333       
5197 19 Dec 18 nicklas 334       // Join bioplate
5197 19 Dec 18 nicklas 335       libQuery.join(Hql.innerJoin("bioWell", "bw"));
5197 19 Dec 18 nicklas 336       libQuery.join(Hql.innerJoin("bw", "bioPlate", "bp"));
5197 19 Dec 18 nicklas 337       annotationEquals(libQuery, "bp", Annotationtype.PLATE_PROCESS_RESULT, "Successful");
5101 16 Nov 18 nicklas 338     }
5549 08 Aug 19 nicklas 339     libQuery.setParameter("parents", namesRegexp(rnaOrDna), Type.STRING);
5549 08 Aug 19 nicklas 340     libQuery.setParameter("pipeline", pipeline.getName(), Type.STRING);
5101 16 Nov 18 nicklas 341     return libQuery;
5101 16 Nov 18 nicklas 342   }
5101 16 Nov 18 nicklas 343   
5101 16 Nov 18 nicklas 344   /**
5104 16 Nov 18 nicklas 345     Get a query that is returning all PooledLibrary items where the
5104 16 Nov 18 nicklas 346     given Library is included. 
5104 16 Nov 18 nicklas 347   */
5104 16 Nov 18 nicklas 348   public ItemQuery<Extract> getPoolQuery(Library library)
5104 16 Nov 18 nicklas 349   {
5104 16 Nov 18 nicklas 350     if (library == null) return null;
5104 16 Nov 18 nicklas 351     if (poolsFromLibQuery == null)
5104 16 Nov 18 nicklas 352     {
5197 19 Dec 18 nicklas 353       // We can't use the 'init...(...)' method since this is a many-to-many relation and not a one-to-many 
5104 16 Nov 18 nicklas 354       poolsFromLibQuery = Extract.getQuery();
5104 16 Nov 18 nicklas 355       poolsFromLibQuery.setIncludes(Reggie.INCLUDE_IN_CURRENT_PROJECT);
5104 16 Nov 18 nicklas 356       Subtype.POOLED_LIBRARY.addFilter(dc, poolsFromLibQuery);
5104 16 Nov 18 nicklas 357
5104 16 Nov 18 nicklas 358       // Join libraries
5104 16 Nov 18 nicklas 359       poolsFromLibQuery.join(Hql.innerJoin("creationEvent", "ce"));
5104 16 Nov 18 nicklas 360       poolsFromLibQuery.join(Hql.innerJoin("ce", "sources", "src"));
5104 16 Nov 18 nicklas 361       poolsFromLibQuery.restrict(
5104 16 Nov 18 nicklas 362         Restrictions.eq(
5104 16 Nov 18 nicklas 363           Hql.property("src", "bioMaterial"), 
5104 16 Nov 18 nicklas 364           Hql.entityParameter("parent", Subtype.LIBRARY.getMainType())));
5104 16 Nov 18 nicklas 365     }
5104 16 Nov 18 nicklas 366     poolsFromLibQuery.setEntityParameter("parent", library.getItem());
5104 16 Nov 18 nicklas 367     return poolsFromLibQuery;
5104 16 Nov 18 nicklas 368   }
5104 16 Nov 18 nicklas 369   
5104 16 Nov 18 nicklas 370   /**
5104 16 Nov 18 nicklas 371     Get a query that is returning all DemuxedSequences items that are parents
5104 16 Nov 18 nicklas 372     to the given MergedSequences item.
5104 16 Nov 18 nicklas 373   */
5104 16 Nov 18 nicklas 374   public ItemQuery<DerivedBioAssay> getDemuxedSequencesQuery(MergedSequences merged)
5104 16 Nov 18 nicklas 375   {
5104 16 Nov 18 nicklas 376     if (merged == null) return null;
5104 16 Nov 18 nicklas 377     if (demuxedQuery == null)
5104 16 Nov 18 nicklas 378     {
5104 16 Nov 18 nicklas 379       demuxedQuery = DerivedBioAssay.getQuery();
5104 16 Nov 18 nicklas 380       demuxedQuery.setIncludes(Reggie.INCLUDE_IN_CURRENT_PROJECT);
5104 16 Nov 18 nicklas 381       Subtype.DEMUXED_SEQUENCES.addFilter(dc, demuxedQuery);
5104 16 Nov 18 nicklas 382       demuxedQuery.join(Hql.innerJoin("children", "c"));
5104 16 Nov 18 nicklas 383       demuxedQuery.restrict(Restrictions.eq(Hql.alias("c"), Hql.entityParameter("child", Item.DERIVEDBIOASSAY)));
5104 16 Nov 18 nicklas 384     }
5104 16 Nov 18 nicklas 385     demuxedQuery.setEntityParameter("child", merged.getItem());
5104 16 Nov 18 nicklas 386     return demuxedQuery;
5104 16 Nov 18 nicklas 387   }
5104 16 Nov 18 nicklas 388   
5104 16 Nov 18 nicklas 389   /**
5104 16 Nov 18 nicklas 390     Get a query that is returning all SequencingRun items that are parents
5104 16 Nov 18 nicklas 391     to the given MergedSequences item.
5104 16 Nov 18 nicklas 392   */
5104 16 Nov 18 nicklas 393   public ItemQuery<DerivedBioAssay> getSequencingRunsQuery(MergedSequences merged)
5104 16 Nov 18 nicklas 394   {
5104 16 Nov 18 nicklas 395     if (merged == null) return null;
5104 16 Nov 18 nicklas 396     if (sequencingRunQuery == null)
5104 16 Nov 18 nicklas 397     {
5104 16 Nov 18 nicklas 398       sequencingRunQuery = DerivedBioAssay.getQuery();
5104 16 Nov 18 nicklas 399       sequencingRunQuery.setIncludes(Reggie.INCLUDE_IN_CURRENT_PROJECT);
5104 16 Nov 18 nicklas 400       Subtype.SEQUENCING_RUN.addFilter(dc, sequencingRunQuery);
5104 16 Nov 18 nicklas 401       sequencingRunQuery.join(Hql.innerJoin("children", "c1"));
5104 16 Nov 18 nicklas 402       sequencingRunQuery.join(Hql.innerJoin("c1", "children", "c"));
5104 16 Nov 18 nicklas 403       sequencingRunQuery.restrict(Restrictions.eq(Hql.alias("c"), Hql.entityParameter("child", Item.DERIVEDBIOASSAY)));
5104 16 Nov 18 nicklas 404     }
5104 16 Nov 18 nicklas 405     sequencingRunQuery.setEntityParameter("child", merged.getItem());
5104 16 Nov 18 nicklas 406     return sequencingRunQuery;
5104 16 Nov 18 nicklas 407   }
5104 16 Nov 18 nicklas 408   
5104 16 Nov 18 nicklas 409   /**
5102 16 Nov 18 nicklas 410     Get a query that is returning all MergedSequences items that are related to the
5102 16 Nov 18 nicklas 411     given list of libraries. The query is filtered to only return items
5102 16 Nov 18 nicklas 412     with DoNotUse=null and AnalysisResult=Successful.
5102 16 Nov 18 nicklas 413     @return A query or null if the list is null or empty
5102 16 Nov 18 nicklas 414   */
5550 09 Aug 19 nicklas 415   public ItemQuery<DerivedBioAssay> getMergedSequencesQuery(List<Library> libraries, Pipeline pipeline)
5102 16 Nov 18 nicklas 416   {
5102 16 Nov 18 nicklas 417     if (libraries == null || libraries.isEmpty()) return null;
5102 16 Nov 18 nicklas 418     if (mergedQuery == null)
5102 16 Nov 18 nicklas 419     {
5102 16 Nov 18 nicklas 420       mergedQuery = DerivedBioAssay.getQuery();
5102 16 Nov 18 nicklas 421       initDerivedBioAssayQuery(mergedQuery, Subtype.MERGED_SEQUENCES, Subtype.LIBRARY, ParentRestriction.LIST_ID);
5550 09 Aug 19 nicklas 422       Pipeline.createFilterParameter(dc, mergedQuery);
5102 16 Nov 18 nicklas 423       annotationEquals(mergedQuery, Annotationtype.DO_NOT_USE, null);
5102 16 Nov 18 nicklas 424       annotationEquals(mergedQuery, Annotationtype.ANALYSIS_RESULT, "Successful");
5102 16 Nov 18 nicklas 425     }
5102 16 Nov 18 nicklas 426     mergedQuery.setParameter("parents", idList(libraries), Type.INT);
5550 09 Aug 19 nicklas 427     mergedQuery.setParameter("pipeline", pipeline.getName(), Type.STRING);
5102 16 Nov 18 nicklas 428     return mergedQuery;
5102 16 Nov 18 nicklas 429   }
5103 16 Nov 18 nicklas 430
5103 16 Nov 18 nicklas 431   /**
5103 16 Nov 18 nicklas 432     Get a query that is returning all MaskedSequences items that are related to the
5103 16 Nov 18 nicklas 433     given list of merged sequences. The query is filtered to only return items
5103 16 Nov 18 nicklas 434     with DoNotUse=null.
5103 16 Nov 18 nicklas 435     @return A query or null if the list is null or empty
5103 16 Nov 18 nicklas 436   */
5103 16 Nov 18 nicklas 437   public ItemQuery<DerivedBioAssay> getMaskedSequencesQuery(List<MergedSequences> merged)
5103 16 Nov 18 nicklas 438   {
5103 16 Nov 18 nicklas 439     if (merged == null || merged.isEmpty()) return null;
5103 16 Nov 18 nicklas 440     if (maskedQuery == null)
5103 16 Nov 18 nicklas 441     {
5103 16 Nov 18 nicklas 442       maskedQuery = DerivedBioAssay.getQuery();
5103 16 Nov 18 nicklas 443       initDerivedBioAssayQuery(maskedQuery, Subtype.MASKED_SEQUENCES, Subtype.MERGED_SEQUENCES, ParentRestriction.LIST_ID);
5103 16 Nov 18 nicklas 444       annotationEquals(maskedQuery, Annotationtype.DO_NOT_USE, null);
5103 16 Nov 18 nicklas 445     }
5103 16 Nov 18 nicklas 446     maskedQuery.setParameter("parents", idList(merged), Type.INT);
5103 16 Nov 18 nicklas 447     return maskedQuery;
5103 16 Nov 18 nicklas 448   }
5102 16 Nov 18 nicklas 449   
5102 16 Nov 18 nicklas 450   /**
5103 16 Nov 18 nicklas 451     Get a query that is returning all AlignedSequences items that are related to the
5103 16 Nov 18 nicklas 452     given list of masked sequences. The query is filtered to only return items
5103 16 Nov 18 nicklas 453     with DoNotUse=null and AnalysisResult=Successful.
5103 16 Nov 18 nicklas 454     @return A query or null if the list is null or empty
5103 16 Nov 18 nicklas 455   */
5103 16 Nov 18 nicklas 456   public ItemQuery<DerivedBioAssay> getAlignedSequencesQuery(List<MaskedSequences> masked)
5103 16 Nov 18 nicklas 457   {
5103 16 Nov 18 nicklas 458     if (masked == null || masked.isEmpty()) return null;
5103 16 Nov 18 nicklas 459     if (alignedQuery == null)
5103 16 Nov 18 nicklas 460     {
5103 16 Nov 18 nicklas 461       alignedQuery = DerivedBioAssay.getQuery();
5103 16 Nov 18 nicklas 462       initDerivedBioAssayQuery(alignedQuery, Subtype.ALIGNED_SEQUENCES, Subtype.MASKED_SEQUENCES, ParentRestriction.LIST_ID);
5103 16 Nov 18 nicklas 463       annotationEquals(alignedQuery, Annotationtype.DO_NOT_USE, null);
5103 16 Nov 18 nicklas 464     }
5103 16 Nov 18 nicklas 465     alignedQuery.setParameter("parents", idList(masked), Type.INT);
5103 16 Nov 18 nicklas 466     return alignedQuery;
5103 16 Nov 18 nicklas 467   }
5103 16 Nov 18 nicklas 468   
5103 16 Nov 18 nicklas 469   /**
5103 16 Nov 18 nicklas 470     Get a query that is returning all StringTie raw bioassays that are related to the
5103 16 Nov 18 nicklas 471     given list of aligned sequences. The query is filtered to only return items
5103 16 Nov 18 nicklas 472     with DoNotUse=null and AnalysisResult=Successful.
5103 16 Nov 18 nicklas 473     @return A query or null if the list is null or empty
5103 16 Nov 18 nicklas 474   */
5103 16 Nov 18 nicklas 475   public ItemQuery<RawBioAssay> getStringTieQuery(List<AlignedSequences> aligned)
5103 16 Nov 18 nicklas 476   {
5103 16 Nov 18 nicklas 477     if (aligned == null || aligned.isEmpty()) return null;
5103 16 Nov 18 nicklas 478     if (stringTieQuery == null)
5103 16 Nov 18 nicklas 479     {
5103 16 Nov 18 nicklas 480       stringTieQuery = RawBioAssay.getQuery();
5103 16 Nov 18 nicklas 481       initRawBioAssayQuery(stringTieQuery, Rawdatatype.STRINGTIE, Subtype.ALIGNED_SEQUENCES, ParentRestriction.LIST_ID);
5103 16 Nov 18 nicklas 482       annotationEquals(stringTieQuery, Annotationtype.DO_NOT_USE, null);
5103 16 Nov 18 nicklas 483       annotationEquals(stringTieQuery, Annotationtype.ANALYSIS_RESULT, "Successful");
5103 16 Nov 18 nicklas 484     }
5103 16 Nov 18 nicklas 485     stringTieQuery.setParameter("parents", idList(aligned), Type.INT);
5103 16 Nov 18 nicklas 486     return stringTieQuery;
5103 16 Nov 18 nicklas 487   }
5103 16 Nov 18 nicklas 488
5103 16 Nov 18 nicklas 489   /**
5103 16 Nov 18 nicklas 490     Get a query that is returning all Cufflinks raw bioassays that are related to the
5103 16 Nov 18 nicklas 491     given list of aligned sequences. The query is filtered to only return items
5103 16 Nov 18 nicklas 492     with DoNotUse=null and AnalysisResult=Successful.
5103 16 Nov 18 nicklas 493     @return A query or null if the list is null or empty
5103 16 Nov 18 nicklas 494   */
5103 16 Nov 18 nicklas 495   public ItemQuery<RawBioAssay> getCufflinksQuery(List<AlignedSequences> aligned)
5103 16 Nov 18 nicklas 496   {
5103 16 Nov 18 nicklas 497     if (aligned == null || aligned.isEmpty()) return null;
5103 16 Nov 18 nicklas 498     if (cufflinksQuery == null)
5103 16 Nov 18 nicklas 499     {
5103 16 Nov 18 nicklas 500       cufflinksQuery = RawBioAssay.getQuery();
5103 16 Nov 18 nicklas 501       initRawBioAssayQuery(cufflinksQuery, Rawdatatype.CUFFLINKS, Subtype.ALIGNED_SEQUENCES, ParentRestriction.LIST_ID);
5103 16 Nov 18 nicklas 502       annotationEquals(cufflinksQuery, Annotationtype.DO_NOT_USE, null);
5103 16 Nov 18 nicklas 503       annotationEquals(cufflinksQuery, Annotationtype.ANALYSIS_RESULT, "Successful");
5103 16 Nov 18 nicklas 504     }
5103 16 Nov 18 nicklas 505     cufflinksQuery.setParameter("parents", idList(aligned), Type.INT);
5103 16 Nov 18 nicklas 506     return cufflinksQuery;
5103 16 Nov 18 nicklas 507   }
5103 16 Nov 18 nicklas 508   
5198 19 Dec 18 nicklas 509   /**
5873 23 Mar 20 nicklas 510     Get a query that is returning all VariantCall raw bioassays that are related to the
5873 23 Mar 20 nicklas 511     given list of aligned sequences. The query is filtered to only return items
5873 23 Mar 20 nicklas 512     with DoNotUse=null and AnalysisResult=Successful.
5873 23 Mar 20 nicklas 513     @return A query or null if the list is null or empty
5873 23 Mar 20 nicklas 514     @since 4.26
5873 23 Mar 20 nicklas 515   */
5873 23 Mar 20 nicklas 516   public ItemQuery<RawBioAssay> getVariantCallQuery(List<AlignedSequences> aligned)
5873 23 Mar 20 nicklas 517   {
5873 23 Mar 20 nicklas 518     if (aligned == null || aligned.isEmpty()) return null;
5873 23 Mar 20 nicklas 519     if (variantCallQuery == null)
5873 23 Mar 20 nicklas 520     {
5873 23 Mar 20 nicklas 521       variantCallQuery = RawBioAssay.getQuery();
5873 23 Mar 20 nicklas 522       initRawBioAssayQuery(variantCallQuery, Rawdatatype.VARIANT_CALL, Subtype.ALIGNED_SEQUENCES, ParentRestriction.LIST_ID);
5873 23 Mar 20 nicklas 523       annotationEquals(variantCallQuery, Annotationtype.DO_NOT_USE, null);
5873 23 Mar 20 nicklas 524       annotationEquals(variantCallQuery, Annotationtype.ANALYSIS_RESULT, "Successful");
5873 23 Mar 20 nicklas 525     }
5873 23 Mar 20 nicklas 526     variantCallQuery.setParameter("parents", idList(aligned), Type.INT);
5873 23 Mar 20 nicklas 527     return variantCallQuery;
5873 23 Mar 20 nicklas 528   }
5873 23 Mar 20 nicklas 529
7006 24 Jan 23 nicklas 530   /**
7006 24 Jan 23 nicklas 531     Get a query that is returning all Methylation derived bioassays that are related to the
7006 24 Jan 23 nicklas 532     given list of DNA items. The query is filtered to only return items
7006 24 Jan 23 nicklas 533     with DoNotUse=null and AnalysisResult=Successful. Since there are multiple levels
7006 24 Jan 23 nicklas 534     of items on the path from DNA to Methylation the query is
7006 24 Jan 23 nicklas 535     matching items by name instead of actual links.
7006 24 Jan 23 nicklas 536
7006 24 Jan 23 nicklas 537     @return A query or null if the list is null or empty
7006 24 Jan 23 nicklas 538     @since 4.44
7006 24 Jan 23 nicklas 539   */
7006 24 Jan 23 nicklas 540   public ItemQuery<DerivedBioAssay> getMethylationQuery(List<Dna> dna)
7006 24 Jan 23 nicklas 541   {
7006 24 Jan 23 nicklas 542     if (dna == null || dna.isEmpty()) return null;
7006 24 Jan 23 nicklas 543     if (methylationQuery == null)
7006 24 Jan 23 nicklas 544     {
7006 24 Jan 23 nicklas 545       methylationQuery = DerivedBioAssay.getQuery();
7006 24 Jan 23 nicklas 546       initDerivedBioAssayQuery(methylationQuery, Subtype.METHYLATION, null, ParentRestriction.REGEXP_NAME);
7006 24 Jan 23 nicklas 547       annotationEquals(methylationQuery, Annotationtype.DO_NOT_USE, null);
7006 24 Jan 23 nicklas 548       annotationEquals(methylationQuery, Annotationtype.ANALYSIS_RESULT, "Successful");
7006 24 Jan 23 nicklas 549     }
7006 24 Jan 23 nicklas 550     methylationQuery.setParameter("parents", namesRegexp(dna), Type.STRING);
7006 24 Jan 23 nicklas 551     return methylationQuery;
7006 24 Jan 23 nicklas 552   }
7006 24 Jan 23 nicklas 553
5873 23 Mar 20 nicklas 554   
5873 23 Mar 20 nicklas 555   /**
7007 25 Jan 23 nicklas 556     Get a query that is returning all GenotypeCall derived bioassays that are related to the
7007 25 Jan 23 nicklas 557     given list of BloodDNA items. The query is filtered to only return items
7007 25 Jan 23 nicklas 558     with DoNotUse=null and AnalysisResult=Successful. Since there are multiple levels
7007 25 Jan 23 nicklas 559     of items on the path from BloodDNA to GenotypeCall the query is
7007 25 Jan 23 nicklas 560     matching items by name instead of actual links.
7007 25 Jan 23 nicklas 561   
7007 25 Jan 23 nicklas 562     @return A query or null if the list is null or empty
7007 25 Jan 23 nicklas 563     @since 4.44
7007 25 Jan 23 nicklas 564   */
7007 25 Jan 23 nicklas 565   public ItemQuery<DerivedBioAssay> getGenotypeCallsQuery(List<BloodDna> dna)
7007 25 Jan 23 nicklas 566   {
7007 25 Jan 23 nicklas 567     if (dna == null || dna.isEmpty()) return null;
7007 25 Jan 23 nicklas 568     if (genotypeCallQuery == null)
7007 25 Jan 23 nicklas 569     {
7007 25 Jan 23 nicklas 570       genotypeCallQuery = DerivedBioAssay.getQuery();
7007 25 Jan 23 nicklas 571       initDerivedBioAssayQuery(genotypeCallQuery, Subtype.GENOTYPE_CALL, null, ParentRestriction.REGEXP_NAME);
7007 25 Jan 23 nicklas 572       annotationEquals(genotypeCallQuery, Annotationtype.DO_NOT_USE, null);
7007 25 Jan 23 nicklas 573       annotationEquals(genotypeCallQuery, Annotationtype.ANALYSIS_RESULT, "Successful");
7007 25 Jan 23 nicklas 574     }
7007 25 Jan 23 nicklas 575     genotypeCallQuery.setParameter("parents", namesRegexp(dna), Type.STRING);
7007 25 Jan 23 nicklas 576     return genotypeCallQuery;
7007 25 Jan 23 nicklas 577   }
7007 25 Jan 23 nicklas 578   
7007 25 Jan 23 nicklas 579   /**
7007 25 Jan 23 nicklas 580     Get a query that is returning all OncoArray raw bioassays that are related to the
7007 25 Jan 23 nicklas 581     given list of genotype calls. The query is filtered to only return items
7007 25 Jan 23 nicklas 582     with DoNotUse=null and AnalysisResult=Successful.
7007 25 Jan 23 nicklas 583     @return A query or null if the list is null or empty
7007 25 Jan 23 nicklas 584     @since 4.44
7007 25 Jan 23 nicklas 585   */
7007 25 Jan 23 nicklas 586   public ItemQuery<RawBioAssay> getOncoArrayQuery(List<GenotypeCall> genotypeCalls)
7007 25 Jan 23 nicklas 587   {
7007 25 Jan 23 nicklas 588     if (genotypeCalls == null || genotypeCalls.isEmpty()) return null;
7007 25 Jan 23 nicklas 589     if (oncoArrayQuery == null)
7007 25 Jan 23 nicklas 590     {
7007 25 Jan 23 nicklas 591       oncoArrayQuery = RawBioAssay.getQuery();
7007 25 Jan 23 nicklas 592       initRawBioAssayQuery(oncoArrayQuery, Rawdatatype.ONCOARRAY500K, Subtype.GENOTYPE_CALL, ParentRestriction.LIST_ID);
7007 25 Jan 23 nicklas 593       annotationEquals(oncoArrayQuery, Annotationtype.DO_NOT_USE, null);
7007 25 Jan 23 nicklas 594       annotationEquals(oncoArrayQuery, Annotationtype.ANALYSIS_RESULT, "Successful");
7007 25 Jan 23 nicklas 595     }
7007 25 Jan 23 nicklas 596     oncoArrayQuery.setParameter("parents", idList(genotypeCalls), Type.INT);
7007 25 Jan 23 nicklas 597     return oncoArrayQuery;
7007 25 Jan 23 nicklas 598   }
7007 25 Jan 23 nicklas 599
7007 25 Jan 23 nicklas 600   /**
5198 19 Dec 18 nicklas 601     Get a query that load all libraries that has at least one alignment in the
5198 19 Dec 18 nicklas 602     "Flagged alignments" list.
5198 19 Dec 18 nicklas 603   */
5198 19 Dec 18 nicklas 604   public ItemQuery<Extract> getLibrariesWithFlaggedAlignments()
5198 19 Dec 18 nicklas 605   {
5198 19 Dec 18 nicklas 606     ItemQuery<Extract> query = Extract.getQuery();
5198 19 Dec 18 nicklas 607     initBioMaterialQuery(query, Subtype.LIBRARY, null, null);
5198 19 Dec 18 nicklas 608     query.join(Hql.innerJoin("derivedBioAssays", "aligned"));
5198 19 Dec 18 nicklas 609     Subtype.ALIGNED_SEQUENCES.addFilter(dc, query, "aligned");
5198 19 Dec 18 nicklas 610     ItemList flagged = BiomaterialList.FLAGGED_ALIGNMENT.get(dc);
5198 19 Dec 18 nicklas 611     query.restrict(Hql.restriction("aligned.id IN (SELECT mmb FROM ItemListData lst INNER JOIN lst.members mmb WHERE lst.id=" +flagged.getId()+")", "$"));
5198 19 Dec 18 nicklas 612     return query;
5198 19 Dec 18 nicklas 613   }
5104 16 Nov 18 nicklas 614   
5103 16 Nov 18 nicklas 615   /**
5098 15 Nov 18 nicklas 616     Initializes a query for biomaterial items of a given type that also
5098 15 Nov 18 nicklas 617     must have a parent item of some other type. The parent item is joined
5098 15 Nov 18 nicklas 618     with alias 'p'.
5098 15 Nov 18 nicklas 619   */
5098 15 Nov 18 nicklas 620   private void initBioMaterialQuery(ItemQuery<? extends BioMaterial> query, 
5098 15 Nov 18 nicklas 621     Subtype subtype, Subtype parentType, ParentRestriction parentRestriction)
5098 15 Nov 18 nicklas 622   {
5098 15 Nov 18 nicklas 623     query.setIncludes(Reggie.INCLUDE_IN_CURRENT_PROJECT);
5098 15 Nov 18 nicklas 624     subtype.addFilter(dc, query);
5101 16 Nov 18 nicklas 625     if (parentType != null)
5098 15 Nov 18 nicklas 626     {
5101 16 Nov 18 nicklas 627       // INNER JOIN parent item
5101 16 Nov 18 nicklas 628       query.join(Hql.innerJoin("parent", "p"));
5101 16 Nov 18 nicklas 629       parentType.addFilter(dc, query, "p");
5101 16 Nov 18 nicklas 630     }
5101 16 Nov 18 nicklas 631     if (parentRestriction == ParentRestriction.SINGLE_ENTITY)
5101 16 Nov 18 nicklas 632     {
5098 15 Nov 18 nicklas 633       query.restrict(Restrictions.eq(Hql.alias("p"), Hql.entityParameter("parent", parentType.getMainType())));
5098 15 Nov 18 nicklas 634     }
5101 16 Nov 18 nicklas 635     else if (parentRestriction == ParentRestriction.LIST_ID)
5098 15 Nov 18 nicklas 636     {
5098 15 Nov 18 nicklas 637       query.restrict(Restrictions.in(Hql.alias("p"), Expressions.parameter("parents", Type.INT)));
5098 15 Nov 18 nicklas 638     }
5101 16 Nov 18 nicklas 639     else if (parentRestriction == ParentRestriction.REGEXP_NAME)
5101 16 Nov 18 nicklas 640     {
5101 16 Nov 18 nicklas 641       query.restrict(Restrictions.rlike(Hql.property("name"), Expressions.parameter("parents", Type.STRING)));
5101 16 Nov 18 nicklas 642     }
5098 15 Nov 18 nicklas 643   }
5098 15 Nov 18 nicklas 644   
5098 15 Nov 18 nicklas 645   /**
5102 16 Nov 18 nicklas 646     Initializes a query for derived bioassay items of a given type that also
5102 16 Nov 18 nicklas 647     must have a parent derived bioassay or extract item of some other type. 
5102 16 Nov 18 nicklas 648     The parent item is joined with alias 'p'.
5102 16 Nov 18 nicklas 649   */
5102 16 Nov 18 nicklas 650   private void initDerivedBioAssayQuery(ItemQuery<DerivedBioAssay> query, 
5102 16 Nov 18 nicklas 651     Subtype subtype, Subtype parentType, ParentRestriction parentRestriction)
5102 16 Nov 18 nicklas 652   {
5102 16 Nov 18 nicklas 653     query.setIncludes(Reggie.INCLUDE_IN_CURRENT_PROJECT);
5102 16 Nov 18 nicklas 654     subtype.addFilter(dc, query);
5102 16 Nov 18 nicklas 655     
7006 24 Jan 23 nicklas 656     if (parentType != null)
5102 16 Nov 18 nicklas 657     {
7006 24 Jan 23 nicklas 658       Item parentItemType = parentType.getMainType();
7006 24 Jan 23 nicklas 659       if (parentItemType == Item.EXTRACT)
7006 24 Jan 23 nicklas 660       {
7006 24 Jan 23 nicklas 661         query.join(Hql.innerJoin("extract", "p"));
7006 24 Jan 23 nicklas 662         parentType.addFilter(dc, query, "p");
7006 24 Jan 23 nicklas 663       }
7006 24 Jan 23 nicklas 664       else if (parentItemType == Item.DERIVEDBIOASSAY)
7006 24 Jan 23 nicklas 665       {
7006 24 Jan 23 nicklas 666         query.join(Hql.innerJoin("parents", "p"));
7006 24 Jan 23 nicklas 667         parentType.addFilter(dc, query, "p");
7006 24 Jan 23 nicklas 668       }
5102 16 Nov 18 nicklas 669     }
5102 16 Nov 18 nicklas 670     
5102 16 Nov 18 nicklas 671     if (parentRestriction == ParentRestriction.LIST_ID)
5102 16 Nov 18 nicklas 672     {
5102 16 Nov 18 nicklas 673       query.restrict(Restrictions.in(Hql.alias("p"), Expressions.parameter("parents", Type.INT)));
5102 16 Nov 18 nicklas 674     }
7006 24 Jan 23 nicklas 675     else if (parentRestriction == ParentRestriction.REGEXP_NAME)
7006 24 Jan 23 nicklas 676     {
7006 24 Jan 23 nicklas 677       query.restrict(Restrictions.rlike(Hql.property("name"), Expressions.parameter("parents", Type.STRING)));
7006 24 Jan 23 nicklas 678     }
5102 16 Nov 18 nicklas 679   }
5103 16 Nov 18 nicklas 680   
5103 16 Nov 18 nicklas 681   /**
5103 16 Nov 18 nicklas 682     Initializes a query for raw bioassay items of a given type that also
5103 16 Nov 18 nicklas 683     must have a parent derived bioassay or extract item of some other type. 
5103 16 Nov 18 nicklas 684     The parent item is joined with alias 'p'.
5103 16 Nov 18 nicklas 685   */
5103 16 Nov 18 nicklas 686   private void initRawBioAssayQuery(ItemQuery<RawBioAssay> query, 
5103 16 Nov 18 nicklas 687     Rawdatatype rawtype, Subtype parentType, ParentRestriction parentRestriction)
5103 16 Nov 18 nicklas 688   {
5103 16 Nov 18 nicklas 689     query.setIncludes(Reggie.INCLUDE_IN_CURRENT_PROJECT);
5103 16 Nov 18 nicklas 690     rawtype.addFilter(dc, query);
5103 16 Nov 18 nicklas 691     
5103 16 Nov 18 nicklas 692     Item parentItemType = parentType.getMainType();
5103 16 Nov 18 nicklas 693     if (parentItemType == Item.EXTRACT)
5103 16 Nov 18 nicklas 694     {
5103 16 Nov 18 nicklas 695       query.join(Hql.innerJoin("parentExtract", "p"));
5103 16 Nov 18 nicklas 696       parentType.addFilter(dc, query, "p");
5103 16 Nov 18 nicklas 697     }
5103 16 Nov 18 nicklas 698     else if (parentItemType == Item.DERIVEDBIOASSAY)
5103 16 Nov 18 nicklas 699     {
5103 16 Nov 18 nicklas 700       query.join(Hql.innerJoin("parentBioAssay", "p"));
5103 16 Nov 18 nicklas 701       parentType.addFilter(dc, query, "p");
5103 16 Nov 18 nicklas 702     }
5103 16 Nov 18 nicklas 703     
5103 16 Nov 18 nicklas 704     if (parentRestriction == ParentRestriction.LIST_ID)
5103 16 Nov 18 nicklas 705     {
5103 16 Nov 18 nicklas 706       query.restrict(Restrictions.in(Hql.alias("p"), Expressions.parameter("parents", Type.INT)));
5103 16 Nov 18 nicklas 707     }
5103 16 Nov 18 nicklas 708   }
5102 16 Nov 18 nicklas 709
5164 03 Dec 18 nicklas 710   /**
5164 03 Dec 18 nicklas 711     Adds a restriction to a biomaterial query so that only
5164 03 Dec 18 nicklas 712     items with a creation date are returned. This will avoid
5164 03 Dec 18 nicklas 713     items that have been pre-created for some process that has 
5164 03 Dec 18 nicklas 714     not yet been performed in the lab.
5164 03 Dec 18 nicklas 715   */
5164 03 Dec 18 nicklas 716   private void hasCreationDate(ItemQuery<? extends BioMaterial> query)
5164 03 Dec 18 nicklas 717   {
5164 03 Dec 18 nicklas 718     query.restrict(Restrictions.neq(Hql.property("creationEvent.eventDate"), null));
5164 03 Dec 18 nicklas 719   }
5102 16 Nov 18 nicklas 720   
5197 19 Dec 18 nicklas 721   private void annotationEquals(ItemQuery<?> query, Annotationtype at, Object value)
5197 19 Dec 18 nicklas 722   {
5197 19 Dec 18 nicklas 723     annotationEquals(query, null, at, value);
5197 19 Dec 18 nicklas 724   }
5197 19 Dec 18 nicklas 725   
5102 16 Nov 18 nicklas 726   /**
5164 03 Dec 18 nicklas 727     Adds a restriction to a query that filters on a single-valued annotation
5098 15 Nov 18 nicklas 728     type having a specific value. The restriction is using an INNER JOIN if
5098 15 Nov 18 nicklas 729     a specific value is requested, or a LEFT JOIN if the value should be null.
5098 15 Nov 18 nicklas 730     The annotation is join with alias 'a{id}' where {id}=ID of the annotation type.
5098 15 Nov 18 nicklas 731   */
5197 19 Dec 18 nicklas 732   private void annotationEquals(ItemQuery<?> query, String joinedAlias, Annotationtype at, Object value)
5098 15 Nov 18 nicklas 733   {
5098 15 Nov 18 nicklas 734     AnnotationType a = at.load(dc);
5098 15 Nov 18 nicklas 735     String alias = "a"+a.getId();
5098 15 Nov 18 nicklas 736     if (value == null)
5098 15 Nov 18 nicklas 737     {
5098 15 Nov 18 nicklas 738       // 'null' value requires LEFT JOIN
5197 19 Dec 18 nicklas 739       query.join(Annotations.leftJoin(joinedAlias, a, alias));
5098 15 Nov 18 nicklas 740       query.restrict(Restrictions.eq(Hql.alias(alias), null));
5098 15 Nov 18 nicklas 741     }
5098 15 Nov 18 nicklas 742     else
5098 15 Nov 18 nicklas 743     {
5098 15 Nov 18 nicklas 744       // Otherwise we use INNER JOIN
5197 19 Dec 18 nicklas 745       query.join(Annotations.innerJoin(joinedAlias, at.load(dc), alias));
5098 15 Nov 18 nicklas 746       query.restrict(
5098 15 Nov 18 nicklas 747         Restrictions.eq(
5098 15 Nov 18 nicklas 748           Hql.alias(alias), 
5098 15 Nov 18 nicklas 749           Expressions.parameter(alias, value, at.getValueType())
5098 15 Nov 18 nicklas 750         ));
5098 15 Nov 18 nicklas 751     }
5098 15 Nov 18 nicklas 752   }
5098 15 Nov 18 nicklas 753
5098 15 Nov 18 nicklas 754   private List<Integer> idList(List<? extends ReggieItem<?>> items)
5098 15 Nov 18 nicklas 755   {
5101 16 Nov 18 nicklas 756     List<Integer> ids = new ArrayList<>(items.size());
5098 15 Nov 18 nicklas 757     for (ReggieItem<?> r : items)
5098 15 Nov 18 nicklas 758     {
5098 15 Nov 18 nicklas 759       ids.add(r.getId());
5098 15 Nov 18 nicklas 760     }
5098 15 Nov 18 nicklas 761     return ids;
5098 15 Nov 18 nicklas 762   }
5098 15 Nov 18 nicklas 763   
5101 16 Nov 18 nicklas 764   private String namesRegexp(List<? extends ReggieItem<?>> items)
5101 16 Nov 18 nicklas 765   {
5101 16 Nov 18 nicklas 766     StringBuilder sb = new StringBuilder();
5101 16 Nov 18 nicklas 767     sb.append("^(");
5101 16 Nov 18 nicklas 768     String sep = "";
5101 16 Nov 18 nicklas 769     for (ReggieItem<?> r : items)
5101 16 Nov 18 nicklas 770     {
5101 16 Nov 18 nicklas 771       sb.append(sep);
5101 16 Nov 18 nicklas 772       sep = "|";
5101 16 Nov 18 nicklas 773       sb.append(r.getName().replace(".", "\\."));
5101 16 Nov 18 nicklas 774     }
5101 16 Nov 18 nicklas 775     sb.append(").+");
5101 16 Nov 18 nicklas 776     return sb.toString();
5101 16 Nov 18 nicklas 777   }
5101 16 Nov 18 nicklas 778
5098 15 Nov 18 nicklas 779   enum ParentRestriction
5098 15 Nov 18 nicklas 780   {
5104 16 Nov 18 nicklas 781     SINGLE_ENTITY, LIST_ID, REGEXP_NAME;
5098 15 Nov 18 nicklas 782   }
5098 15 Nov 18 nicklas 783
5098 15 Nov 18 nicklas 784 }

Generated on Tue Nov 21 03:34:41 2023 (UTC) by svndigest 0.11.2pre (dev build 1672)