예제 #1
0
 def base_query(self, query):
     query = Values.base_query(self, query)
     if self.parameter:
         query = query\
             .outerjoin(Counterpart.cognateset)\
             .outerjoin(LexibankLanguage.family)
     return query
예제 #2
0
    def base_query(self, query):
        query = Values.base_query(self, query)
        if self.language:
            query = query\
                .outerjoin(NameCategory)\
                .outerjoin(NameHabitat)\
                .outerjoin(Name.uses)\
                .options(
                    contains_eager(Name.uses),
                    joinedload(Name.habitats),
                    joinedload(Name.categories))
        if not self.language and not self.parameter:
            query = query.join(ValueSet.language).join(ValueSet.parameter)

        if self.parameter:
            query = query.join(Languoid.lineage).options(
                joinedload(Value.valueset).joinedload(
                    ValueSet.language).joinedload(Languoid.lineage))
        else:
            query = query.options(
                joinedload(Value.valueset, ValueSet.parameter,
                           Parameter._files))
        return query.options(
            joinedload(Value.valueset).joinedload(ValueSet.parameter),
            joinedload(Name.references).joinedload(NameReference.source))
예제 #3
0
 def base_query(self, query):
     query = Values.base_query(self, query)
     if self.family:
         if self.feature:
             query = query.filter(
                 common.ValueSet.parameter_pk == int(self.feature.pk))
         query = query.join(GrambankLanguage).join(Family).filter(
             GrambankLanguage.family == self.family)
         query = query.options(
             joinedload(common.Value.valueset).joinedload(
                 common.ValueSet.parameter),
             joinedload(common.Value.domainelement),
         )
     else:
         if self.language:
             query = query.options(
                 joinedload(common.Value.valueset).joinedload(
                     common.ValueSet.parameter),
                 joinedload(common.Value.domainelement),
             )
         if self.parameter:
             query = query\
                 .join(common.ValueSet.contribution)\
                 .join(common.Contribution.contributor_assocs)\
                 .join(common.ContributionContributor.contributor)\
                 .options(
                 joinedload(common.Value.valueset, common.ValueSet.language),
                 joinedload(common.Value.valueset)
                 .joinedload(common.ValueSet.contribution)
                 .joinedload(common.Contribution.contributor_assocs)
                 .joinedload(common.ContributionContributor.contributor))
     return query
예제 #4
0
파일: datatables.py 프로젝트: clld/waab
 def base_query(self, query):
     query = Values.base_query(self, query)
     if self.pair:
         query = query.join(ValueSet.parameter)
         return query.filter(waabValue.pair_pk == self.pair.pk)
     if self.parameter:
         return query.join(waabValue.pair)
     return query
예제 #5
0
 def base_query(self, query):
     query = Values.base_query(self, query)
     if self.language:
         query = query.options(
             joinedload_all(common.Value.valueset, common.ValueSet.parameter),
             joinedload(common.Value.domainelement),
         )
     return query
예제 #6
0
 def base_query(self, query):
     query = Values.base_query(self, query)
     if self.language:
         query = query.options(
             joinedload_all(common.Value.valueset,
                            common.ValueSet.parameter),
             joinedload(common.Value.domainelement),
         )
     return query
예제 #7
0
파일: datatables.py 프로젝트: clld/csd
 def base_query(self, query):
     query = Values.base_query(self, query)
     if not self.language and not self.parameter:
         query = query\
             .join(ValueSet.language)\
             .join(ValueSet.parameter)\
             .options(
                 joinedload(Value.valueset, ValueSet.language),
                 joinedload(Value.valueset, ValueSet.parameter))
     return query
예제 #8
0
    def base_query(self, query):
        query = Values.base_query(self, query)

        if not self.parameter:
            query = query.join(common.ValueSet.parameter).join(
                models.Param.contribution)
            if self.module:
                query = query.filter(models.CLDFDataset.module == self.module)

        return query
예제 #9
0
 def base_query(self, query):
     if not any([self.language, self.parameter, self.contribution]):
         return query\
             .join(common.ValueSet)\
             .join(common.Parameter)\
             .join(common.Language)\
             .options(
             joinedload(common.Value.valueset).joinedload(common.ValueSet.parameter),
             joinedload(common.Value.valueset).joinedload(common.ValueSet.language))
     else:
         return Values.base_query(self, query)
예제 #10
0
 def base_query(self, query):
     query = Values.base_query(self, query)
     if self.language:
         query = query\
             .outerjoin(SpeciesCategory, SpeciesCategory.species_pk == Parameter.pk)\
             .outerjoin(
                 Category,
                 and_(
                     SpeciesCategory.category_pk == Category.pk,
                     Category.language_pk == self.language.pk))
     return query.options(joinedload_all(
         Value.valueset, ValueSet.parameter, Species.categories))
예제 #11
0
 def base_query(self, query):
     query = Values.base_query(self, query)
     if self.language:
         query = query.options(
             joinedload(common.Value.valueset).joinedload(common.ValueSet.parameter),
             joinedload(common.Value.domainelement),
         )
     elif self.parameter:
         query = query.outerjoin(Family).options(
             joinedload(common.Value.valueset)
             .joinedload(common.ValueSet.language)
             .joinedload(sailsLanguage.family))
     return query
예제 #12
0
 def base_query(self, query):
     query = Values.base_query(self, query)
     if self.language:
         query = query.options(
             joinedload_all(common.Value.valueset, common.ValueSet.parameter),
             joinedload(common.Value.domainelement),
         )
     elif self.parameter:
         query = query.outerjoin(Family)\
             .options(joinedload_all(
                 common.Value.valueset,
                 common.ValueSet.language,
                 sailsLanguage.family))
     return query
예제 #13
0
 def base_query(self, query):
     query = Values.base_query(self, query)
     if self.parameter:
         return query.join(Family, isouter=True).options(
             joinedload(Value.valueset).joinedload(ValueSet.language), )
     elif self.contribution:
         return query.options(
             joinedload(Value.valueset).joinedload(ValueSet.parameter),
             joinedload(Value.valueset).joinedload(ValueSet.language),
             joinedload(Value.valueset).joinedload(ValueSet.contribution),
             joinedload(Value.domainelement),
         )
     else:
         return query
예제 #14
0
 def base_query(self, query):
     query = Values.base_query(self, query)
     if self.contribution:
         query = query.join(ValueSet.parameter)
         for lang, alias in self._langs.items():
             query = query.outerjoin(
                 alias,
                 and_(alias.key == 'lang_' + lang, alias.object_pk == Concept.pk))
         query = query.options(
             joinedload(Value.data),
             joinedload_all(Value.valueset, ValueSet.parameter))
     elif self.parameter:
         pass
     else:
         query = query.join(ValueSet.parameter)
         query = query.options(joinedload_all(Value.valueset, ValueSet.parameter))
     return query
예제 #15
0
 def base_query(self, query):
     query = Values.base_query(self, query)
     if self.contribution:
         query = query.join(ValueSet.parameter)
         for lang, alias in self._langs.items():
             query = query.outerjoin(
                 alias,
                 and_(alias.key == 'lang_' + lang,
                      alias.object_pk == Concept.pk))
         query = query.options(
             joinedload(Value.data),
             joinedload_all(Value.valueset, ValueSet.parameter))
     elif self.parameter:
         pass
     else:
         query = query.join(ValueSet.parameter)
         query = query.options(
             joinedload_all(Value.valueset, ValueSet.parameter))
     return query
예제 #16
0
파일: datatables.py 프로젝트: clld/grambank
 def base_query(self, query):
     query = Values.base_query(self, query)
     if self.language:
         query = query.options(
             joinedload_all(common.Value.valueset, common.ValueSet.parameter),
             joinedload(common.Value.domainelement),
         )
     if self.parameter:
         query = query\
             .join(common.ValueSet.contribution)\
             .join(common.Contribution.contributor_assocs)\
             .join(common.ContributionContributor.contributor)\
             .options(
             joinedload(common.Value.valueset, common.ValueSet.language),
             joinedload_all(
                 common.Value.valueset,
                 common.ValueSet.contribution,
                 common.Contribution.contributor_assocs,
                 common.ContributionContributor.contributor))
     return query
예제 #17
0
    def base_query(self, query):
        query = Values.base_query(self, query)
        if self.language:
            query = query\
                .outerjoin(NameCategory)\
                .outerjoin(NameHabitat)\
                .outerjoin(Name.uses)\
                .options(
                    contains_eager(Name.uses),
                    joinedload(Name.habitats),
                    joinedload(Name.categories))
        if not self.language and not self.parameter:
            query = query.join(ValueSet.language).join(ValueSet.parameter)

        if self.parameter:
            query = query.join(Languoid.lineage).options(
                joinedload_all(Value.valueset, ValueSet.language, Languoid.lineage)
            )
        else:
            query = query.options(joinedload(
                Value.valueset, ValueSet.parameter, Parameter._files))
        return query.options(
            joinedload_all(Value.valueset, ValueSet.parameter),
            joinedload_all(Name.references, NameReference.source))
예제 #18
0
 def base_query(self, query):
     query = Values.base_query(self, query)
     if self.parameter:
         query = query.join(Sample.languoid)
     return query
예제 #19
0
 def base_query(self, query):
     query = Values.base_query(self, query)
     query = query.join(common.DomainElement)
     if not any({self.language, self.contribution, self.parameter}):
         query = query.join(common.Language)
     return query.distinct()
예제 #20
0
 def base_query(self, query):
     query = Values.base_query(self, query)
     if not self.language and not self.parameter:
         query = query.join(ValueSet.language).join(ValueSet.parameter)
     return query