Class: Queries::TaxonName::Filter

Inherits:
Query::Filter show all
Includes:
Concerns::Citations, Concerns::Confidences, Concerns::DataAttributes, Concerns::Depictions, Concerns::Notes, Concerns::Tags, Helpers
Defined in:
lib/queries/taxon_name/filter.rb

Constant Summary collapse

PARAMS = 
[
  :ancestors,
  :ancestrify,
  :author,
  :author_exact,
  :authors,
  :collecting_event_id,
  :collection_object_id,
  :combinations,
  :combinationify,
  :descendants,
  :descendants_max_depth,
  :epithet_only,
  :etymology,
  :leaves,
  :name,
  :name_exact,
  :nomenclature_code,
  :nomenclature_date,
  :nomenclature_group, # !! different than autocomplete
  :not_specified,
  :original_combination,
  :otu_id,
  :otus,
  :rank,
  :synonymify,
  :taxon_name_author_id_or,
  :taxon_name_id,
  :taxon_name_type,
  :type_metadata,
  :validify,
  :validity,
  :verbatim_name,
  :year,
  :year_end,
  :year_start,

  collection_object_id: [],
  collecting_event_id: [],
  combination_taxon_name_id: [],
  name: [],
  otu_id: [],
  parent_id: [],
  rank: [],
  taxon_name_author_id: [],
  taxon_name_classification: [],
  taxon_name_id: [],
  taxon_name_relationship: [
    :subject_taxon_name_id,
    :object_taxon_name_id,
    :type,
  ],
  taxon_name_relationship_type: [],
  type: [],
].freeze

Constants inherited from Query::Filter

Query::Filter::FILTER_QUERIES, Query::Filter::SUBQUERIES

Instance Attribute Summary collapse

Attributes inherited from Query::Filter

#api, #asserted_distribution_query, #biological_association_query, #biological_associations_graph_query, #collecting_event_query, #collection_object_query, #content_query, #controlled_vocabulary_term_query, #data_attribute_query, #descriptor_query, #document_query, #dwc_occurrence_query, #extract_query, #field_occurrence_query, #image_query, #loan_query, #object_global_id, #observation_query, #order_by, #otu_query, #page, #paginate, #params, #per, #person_query, #project_id, #recent, #recent_target, #taxon_name_query, #venn, #venn_mode

Attributes inherited from Query

#query_string, #terms

Instance Method Summary collapse

Methods included from Helpers

#boolean_param, #integer_param

Methods inherited from Query::Filter

#all_and_clauses, #all_merge_clauses, #annotator_and_clauses, #annotator_merge_clauses, annotator_params, api_except_params, api_excluded_params, #apply_venn, #attribute_exact_facet, base_filter, base_query_name, base_query_to_h, #deep_permit, included_annotator_facets, instantiated_base_filter, inverted_subqueries, #object_global_id_facet, #only_project?, params, #permitted_params, #process_url_into_params, #project_id_facet, query_name, #query_name, #set_nested_queries, #shared_and_clauses, #subquery_vector, #target_and_clauses, #venn_query

Methods inherited from Query

#alphabetic_strings, #alphanumeric_strings, base_name, #base_name, #base_query, #build_terms, #cached_facet, #end_wildcard, #levenshtein_distance, #match_ordered_wildcard_pieces_in_cached, #no_terms?, referenced_klass, #referenced_klass, #referenced_klass_except, #referenced_klass_intersection, #referenced_klass_union, #start_and_end_wildcard, #start_wildcard, #table, #wildcard_pieces

Constructor Details

#initialize(query_params) ⇒ Filter

Returns a new instance of Filter.

Parameters:

  • params (Params) —

    as permitted via controller



300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
 
# File 'lib/queries/taxon_name/filter.rb', line 300

def initialize(query_params)
  super

  @ancestors = boolean_param(params, :ancestors)
  @ancestrify = boolean_param(params, :ancestrify)
  @author = params[:author]
  @author_exact = boolean_param(params, :author_exact)
  @authors = boolean_param(params, :authors)
  @collecting_event_id = params[:collecting_event_id]
  @collection_object_id = params[:collection_object_id]
  @combination_taxon_name_id = params[:combination_taxon_name_id]
  @combinations = boolean_param(params, :combinations)
  @combinationify = boolean_param(params, :combinationify)
  @descendants = boolean_param(params, :descendants)
  @descendants_max_depth = params[:descendants_max_depth]
  @etymology = boolean_param(params, :etymology)
  @epithet_only = params[:epithet_only]
  @geo_json = params[:geo_json]
  @leaves = boolean_param(params, :leaves)
  @name = params[:name]
  @name_exact = boolean_param(params, :name_exact)
  @nomenclature_date = boolean_param(params, :nomenclature_date)
  @nomenclature_code = params[:nomenclature_code] if params[:nomenclature_code].present?
  @nomenclature_group = params[:nomenclature_group] if params[:nomenclature_group].present?
  @not_specified = boolean_param(params, :not_specified)
  @otu_id = params[:otu_id]
  @otus = boolean_param(params, :otus)
  @original_combination = boolean_param(params, :original_combination)
  @parent_id = params[:parent_id]
  @rank = params[:rank]
  @sort = params[:sort]
  @synonymify = boolean_param(params, :synonymify)
  @taxon_name_author_id = params[:taxon_name_author_id]
  @taxon_name_author_id_or = boolean_param(params, :taxon_name_author_id_or)
  @taxon_name_classification = params[:taxon_name_classification] || []
  @taxon_name_id = params[:taxon_name_id]
  @taxon_name_relationship = params[:taxon_name_relationship] || []
  @taxon_name_relationship_type = params[:taxon_name_relationship_type] || []
  @taxon_name_type = params[:taxon_name_type]
  @type_metadata = boolean_param(params, :type_metadata)
  @validify = boolean_param(params, :validify)
  @validity = boolean_param(params, :validity)
  @verbatim_name = boolean_param(params, :verbatim_name)

  @year = params[:year]
  @year_end = params[:year_end]
  @year_start = params[:year_start]

  set_confidences_params(params)
  set_citations_params(params)
  set_depiction_params(params)
  set_notes_params(params)
  set_data_attributes_params(params)
  set_tags_params(params)
end

Instance Attribute Details

#ancestors ⇒ Object

Returns Boolean Ignored when taxon_name_id[].empty? Works as AND clause with descendants :(.

Parameters:

  • ancestors (Boolean, 'true', 'false', nil)

Returns:

  • Boolean Ignored when taxon_name_id[].empty? Works as AND clause with descendants :(



72
73
74
 
# File 'lib/queries/taxon_name/filter.rb', line 72

def ancestors
  @ancestors
end

#ancestrify ⇒ Object

!! This parameter is not like the others, it is applied POST result, see also synonymify and validify, etc.

Parameters:

  • ancestrify (Boolean) —

    true - extend result to include all ancestors of names in the result along with the result false/nil - ignore



78
79
80
 
# File 'lib/queries/taxon_name/filter.rb', line 78

def ancestrify
  @ancestrify
end

#author ⇒ Object

Parameters:

  • author (String) —

    Use “&” for “and”. Matches against cached_author_year. See also author_exact.



120
121
122
 
# File 'lib/queries/taxon_name/filter.rb', line 120

def author
  @author
end

#author_exact ⇒ Object

Returns Boolean.

Returns:

  • Boolean



123
124
125
 
# File 'lib/queries/taxon_name/filter.rb', line 123

def author_exact
  @author_exact
end

#authors ⇒ Object

‘true’ or ‘false’

on initialize

whether the name has an author string, from any source, provided

Parameters:

  • authors (Boolean, nil) 


237
238
239
 
# File 'lib/queries/taxon_name/filter.rb', line 237

def authors
  @authors
end

#collecting_event_id ⇒ Object

Returns Array.

Parameters:

  • collecting_event_id (String, Array)

Returns:

  • Array



108
109
110
 
# File 'lib/queries/taxon_name/filter.rb', line 108

def collecting_event_id
  @collecting_event_id
end

#collection_object_id ⇒ Object

Returns Array.

Parameters:

  • collection_object_id (String, Array)

Returns:

  • Array



87
88
89
 
# File 'lib/queries/taxon_name/filter.rb', line 87

def collection_object_id
  @collection_object_id
end

#combination_taxon_name_id ⇒ Array

Returns taxon_name_ids for which all Combinations will be returned.

Returns:

  • (Array) —

    taxon_name_ids for which all Combinations will be returned



287
288
289
 
# File 'lib/queries/taxon_name/filter.rb', line 287

def combination_taxon_name_id
  @combination_taxon_name_id
end

#combinationify ⇒ Object

!! This parameter is not like the others, it is applied POST result, see also synonymify and validify

Parameters:

  • combinationify (Boolean) —

    true - extend result to include all Combinations in which the finest name is a member of the result false/nil - ignore



100
101
102
 
# File 'lib/queries/taxon_name/filter.rb', line 100

def combinationify
  @combinationify
end

#combinations ⇒ Object

This parameter should be used along side species or genus group limits.

Parameters:

  • combinations (Boolean) —

    true - only return names that have (subsequent) Combinations false - only return names without (subequent) Combinations nil - ignore



94
95
96
 
# File 'lib/queries/taxon_name/filter.rb', line 94

def combinations
  @combinations
end

#descendants ⇒ Boolean

Returns true - only descendants NOT SELF false - self AND descendants nil - ignored Ignored when taxon_name_id[].empty?.

Parameters:

  • descendants (Boolean, 'true', 'false', nil) —

    Read carefully! descendants = false is NOT no descendants, it’s descendants and self

Returns:

  • (Boolean) —

    true - only descendants NOT SELF false - self AND descendants nil - ignored Ignored when taxon_name_id[].empty?



181
182
183
 
# File 'lib/queries/taxon_name/filter.rb', line 181

def descendants
  @descendants
end

#descendants_max_depth ⇒ Integer?

A positive integer indicating how many levels deep of descendants to retrieve.

Ignored when descentants is false/unspecified.
Defaults to nil

Parameters:

  • descendants_max_depth (Integer)

Returns:

  • (Integer, nil) 


188
189
190
 
# File 'lib/queries/taxon_name/filter.rb', line 188

def descendants_max_depth
  @descendants_max_depth
end

#epithet_only ⇒ Object

Parameters:

  • epithet_only (Boolean) —

    true - use name property instead of cached to find taxon name false/nil - ignore



83
84
85
 
# File 'lib/queries/taxon_name/filter.rb', line 83

def epithet_only
  @epithet_only
end

#etymology ⇒ Object

‘true’ or ‘false’

on initialize

whether the name has etymology

Parameters:

  • etymology (Boolean, nil) 


232
233
234
 
# File 'lib/queries/taxon_name/filter.rb', line 232

def etymology
  @etymology
end

#geo_json ⇒ Object

Returns the value of attribute geo_json.



296
297
298
 
# File 'lib/queries/taxon_name/filter.rb', line 296

def geo_json
  @geo_json
end

#leaves ⇒ Boolean?

TODO: inverse is duplicated in autocomplete

Returns:

  • (Boolean, nil) —

    &leaves=<“true”|“false”> if ‘true’ then return only names without descendents if ‘false’ then return only names with descendents



265
266
267
 
# File 'lib/queries/taxon_name/filter.rb', line 265

def leaves
  @leaves
end

#name ⇒ Array

Returns Matches against cached. See also name_exact.

Parameters:

  • name (String, Array)

Returns:

  • (Array) —

    Matches against cached. See also name_exact.



113
114
115
 
# File 'lib/queries/taxon_name/filter.rb', line 113

def name
  @name
end

#name_exact ⇒ Object

Returns Boolean.

Returns:

  • Boolean



116
117
118
 
# File 'lib/queries/taxon_name/filter.rb', line 116

def name_exact
  @name_exact
end

#nomenclature_code ⇒ String?

Returns accessor for attr :nomenclature_code, wrap with needed wildcards.

Returns:

  • (String, nil) —

    accessor for attr :nomenclature_code, wrap with needed wildcards



258
259
260
 
# File 'lib/queries/taxon_name/filter.rb', line 258

def nomenclature_code
  @nomenclature_code
end

#nomenclature_date ⇒ Object

Returns Boolean with/out cached nomenclature date set.

Parameters:

  • ancestors (Boolean, 'true', 'false', nil)

Returns:

  • Boolean with/out cached nomenclature date set



133
134
135
 
# File 'lib/queries/taxon_name/filter.rb', line 133

def nomenclature_date
  @nomenclature_date
end

#nomenclature_group ⇒ String?

Returns accessor for attr :nomenclature_group, wrap with needed wildcards.

Returns:

  • (String, nil) —

    accessor for attr :nomenclature_group, wrap with needed wildcards



254
255
256
 
# File 'lib/queries/taxon_name/filter.rb', line 254

def nomenclature_group
  @nomenclature_group
end

#not_specified ⇒ Object

Returns the value of attribute not_specified.



249
250
251
 
# File 'lib/queries/taxon_name/filter.rb', line 249

def not_specified
  @not_specified
end

#original_combination ⇒ Boolean?

Returns true - name has at least one element of original combination false - name has no element of original combination nil - ignored.

Parameters:

  • original_combination (Boolean)

Returns:

  • (Boolean, nil) —

    true - name has at least one element of original combination false - name has no element of original combination nil - ignored



217
218
219
 
# File 'lib/queries/taxon_name/filter.rb', line 217

def original_combination
  @original_combination
end

#otu_id ⇒ Array?

Returns one or more OTU ids.

Parameters:

  • otu_id (Array, nil)

Returns:

  • (Array, nil) —

    one or more OTU ids



222
223
224
 
# File 'lib/queries/taxon_name/filter.rb', line 222

def otu_id
  @otu_id
end

#otus ⇒ Object

‘true’ or ‘false’

on initialize

whether the name has an Otu

Parameters:

  • otus (Boolean, nil) 


227
228
229
 
# File 'lib/queries/taxon_name/filter.rb', line 227

def otus
  @otus
end

#parent_id ⇒ Object

Return the taxon names with this/these parent_ids

Returns:

  • Return the taxon names with this/these parent_ids



172
173
174
 
# File 'lib/queries/taxon_name/filter.rb', line 172

def parent_id
  @parent_id
end

#rank ⇒ Array

Returns:

  • (Array) 


294
295
296
 
# File 'lib/queries/taxon_name/filter.rb', line 294

def rank
  @rank
end

#sort ⇒ String?

Parameters:

  • sort (String, nil) —

    one of :classification, :alphabetical

Returns:

  • (String, nil) 


283
284
285
 
# File 'lib/queries/taxon_name/filter.rb', line 283

def sort
  @sort
end

#synonymify ⇒ Object

!! This parameter is not like the others, it is applied POST result, see also combinationify and validify

Parameters:

  • synonymify (Boolean) —

    true - extend result to include all Synonyms of any member of the list false/nil - ignore



194
195
196
 
# File 'lib/queries/taxon_name/filter.rb', line 194

def synonymify
  @synonymify
end

#taxon_name_author_id ⇒ Array

Returns:

  • (Array) 


272
273
274
 
# File 'lib/queries/taxon_name/filter.rb', line 272

def taxon_name_author_id
  @taxon_name_author_id
end

#taxon_name_author_id_or ⇒ Boolean

Parameters:

  • `false`, (String) —

    nil - treat the ids in taxon_name_author_id as “or” (match any TaxonName with any of these authors) ‘true’ - treat the ids in taxon_name_author_id as “and” (only TaxonNames with all and only all will match)

Returns:

  • (Boolean) 


278
279
280
 
# File 'lib/queries/taxon_name/filter.rb', line 278

def taxon_name_author_id_or
  @taxon_name_author_id_or
end

#taxon_name_classification ⇒ Object

Parameters:

  • taxon_name_classification (Array) —

    Class names of TaxonNameClassification, as strings.



210
211
212
 
# File 'lib/queries/taxon_name/filter.rb', line 210

def taxon_name_classification
  @taxon_name_classification
end

#taxon_name_id ⇒ Object

Return the taxon name(s) with this/these ids

Returns:

  • Return the taxon name(s) with this/these ids



166
167
168
 
# File 'lib/queries/taxon_name/filter.rb', line 166

def taxon_name_id
  @taxon_name_id
end

#taxon_name_relationship ⇒ Object

Each entry must have a ‘type’ Each entry must have one (and only one) of ‘subject_taxon_name_id’ or ‘object_taxon_name_id’

Return all taxon names in a relationship of a given type and in relation to a another name. For example, return all synonyms of Aus bus.

Parameters:

  • taxon_name_relationship (Array) —
    { ‘type’ => ‘TaxonNameRelationship::<>’, ‘subject|object_taxon_name_id’ => ‘123’ } … {} 


202
203
204
 
# File 'lib/queries/taxon_name/filter.rb', line 202

def taxon_name_relationship
  @taxon_name_relationship
end

#taxon_name_relationship_type ⇒ Object

Parameters:

  • taxon_name_relationship (Array) —

    All names involved in any of these relationship



206
207
208
 
# File 'lib/queries/taxon_name/filter.rb', line 206

def taxon_name_relationship_type
  @taxon_name_relationship_type
end

#taxon_name_type ⇒ String?

Returns &taxon_name_type=<Protonym|Combination|Hybrid>.

Returns:

  • (String, nil) —

    &taxon_name_type=<Protonym|Combination|Hybrid>



269
270
271
 
# File 'lib/queries/taxon_name/filter.rb', line 269

def taxon_name_type
  @taxon_name_type
end

#type_metadata ⇒ Object

‘true’ or ‘false’

on initialize

whether the name has TypeMaterial



242
243
244
 
# File 'lib/queries/taxon_name/filter.rb', line 242

def type_metadata
  @type_metadata
end

#validify ⇒ Object

name is returned !! This param is not like the others. !!

Returns:

  • Boolean if true then for each name in the result its valid



155
156
157
 
# File 'lib/queries/taxon_name/filter.rb', line 155

def validify
  @validify
end

#validity ⇒ Object

‘true’ or ‘false’

on initialize

true if only valid, false if only invalid, nil if both



148
149
150
 
# File 'lib/queries/taxon_name/filter.rb', line 148

def validity
  @validity
end

#verbatim_name ⇒ Object

Returns Boolean if true then ‘verbatim_name` is populated.

Returns:

  • Boolean if true then ‘verbatim_name` is populated



160
161
162
 
# File 'lib/queries/taxon_name/filter.rb', line 160

def verbatim_name
  @verbatim_name
end

#year ⇒ Object

Matches against cached_author_year.

Parameters:

  • year (String) —

    “yyyy”



128
129
130
 
# File 'lib/queries/taxon_name/filter.rb', line 128

def year
  @year
end

#year_end ⇒ Object

Matches against cached_nomenclature_date

Parameters:

  • year_end (String) —

    “yyyy”



143
144
145
 
# File 'lib/queries/taxon_name/filter.rb', line 143

def year_end
  @year_end
end

#year_start ⇒ Object

Matches against cached_nomenclature_date

Parameters:

  • year_start (String) —

    “yyyy”



138
139
140
 
# File 'lib/queries/taxon_name/filter.rb', line 138

def year_start
  @year_start
end

Instance Method Details

#all(nil_empty = false) ⇒ ActiveRecord::Relation

Returns:

  • (ActiveRecord::Relation) 


936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
 
# File 'lib/queries/taxon_name/filter.rb', line 936

def all(nil_empty = false)
  q = super

  # Order matters, use this first to go up
  q = ancestrify_result(q) if ancestrify

  # Then out in various ways
  q = validify_result(q) if validify
  q = combinationify_result(q) if combinationify
  q = synonimify_result(q) if synonymify

  # Then sort
  q = order_clause(q) if sort

  q
end

#ancestor_facet ⇒ Object

A merge facet.

Returns:

  • Scope match only names that are a ancestor of some taxon_name_id



508
509
510
511
512
513
514
515
516
517
518
 
# File 'lib/queries/taxon_name/filter.rb', line 508

def ancestor_facet
  return nil if taxon_name_id.empty? || !(ancestors == true)

  ancestors_subquery = ::TaxonNameHierarchy.where(
    ::TaxonNameHierarchy.arel_table[:ancestor_id].eq(::TaxonName.arel_table[:id]).and(
      ::TaxonNameHierarchy.arel_table[:descendant_id].in(taxon_name_id)
    )
  )

  ::TaxonName.where(ancestors_subquery.arel.exists)
end

#ancestrify_result(q) ⇒ Object 



905
906
907
908
909
910
911
912
913
914
915
 
# File 'lib/queries/taxon_name/filter.rb', line 905

def ancestrify_result(q)
  s = 'WITH tn_result_query_anc AS (' + q.to_sql + ') ' +
      ::TaxonName
        .joins('JOIN taxon_name_hierarchies tnh on tnh.ancestor_id = taxon_names.id')
        .joins('JOIN tn_result_query_anc as tn_result_query_anc1 on tn_result_query_anc1.id = tnh.descendant_id')
        .distinct
        .to_sql

  # !! Do not use .distinct here
  ::TaxonName.from('(' + s + ') as taxon_names')
end

#and_clauses ⇒ ActiveRecord::Relation

Returns:

  • (ActiveRecord::Relation) 


816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
 
# File 'lib/queries/taxon_name/filter.rb', line 816

def and_clauses
  [
    nomenclature_date_facet,
    author_facet,
    name_facet,
    parent_id_facet,
    rank_facet,
    taxon_name_type_facet,
    validity_facet,
    verbatim_name_facet,
    with_nomenclature_code,
    with_nomenclature_group,
    year_facet,
  ]
end

#asserted_distribution_query_facet ⇒ Object 



765
766
767
768
769
770
771
772
773
774
 
# File 'lib/queries/taxon_name/filter.rb', line 765

def asserted_distribution_query_facet
  return nil if asserted_distribution_query.nil?
  s = 'WITH query_ad_tn AS (' + asserted_distribution_query.all.to_sql + ') ' +
      ::TaxonName
        .joins(otus: [:asserted_distributions])
        .joins('JOIN query_ad_tn as query_ad_tn1 on query_ad_tn1.otu_id = asserted_distributions.otu_id')
        .to_sql

  ::TaxonName.from('(' + s + ') as taxon_names').distinct
end

#author_facet ⇒ Object 



685
686
687
688
689
690
691
692
 
# File 'lib/queries/taxon_name/filter.rb', line 685

def author_facet
  return nil if author.blank?
  if author_exact
    table[:cached_author_year].eq(author.strip)
  else
    table[:cached_author_year].matches('%' + author.strip.gsub(/\s/, '%') + '%')
  end
end

#authors_facet ⇒ Object

This is not true! It includes records that are year only.

Returns:

  • Scope



538
539
540
541
542
543
 
# File 'lib/queries/taxon_name/filter.rb', line 538

def authors_facet
  return nil if authors.nil?
  authors ?
    ::TaxonName.where.not(cached_author_year: nil) :
    ::TaxonName.where(cached_author_year: nil)
end

#biological_association_query_facet ⇒ Object 



798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
 
# File 'lib/queries/taxon_name/filter.rb', line 798

def biological_association_query_facet
  return nil if biological_association_query.nil?
  s = 'WITH query_tn_ba AS (' + biological_association_query.all.to_sql + ') '

  a = ::TaxonName
    .joins(:otus)
    .joins("JOIN query_tn_ba as query_tn_ba1 on query_tn_ba1.biological_association_subject_id = otus.id AND query_tn_ba1.biological_association_subject_type = 'Otu'").to_sql

  b = ::TaxonName
    .joins(:otus)
    .joins("JOIN query_tn_ba as query_tn_ba2 on query_tn_ba2.biological_association_object_id = otus.id AND query_tn_ba2.biological_association_object_type = 'Otu'").to_sql

  s << ::TaxonName.from("((#{a}) UNION (#{b})) as taxon_names").to_sql

  ::TaxonName.from('(' + s + ') as taxon_names')
end

#collecting_event_id_facet ⇒ Object 



737
738
739
740
741
742
 
# File 'lib/queries/taxon_name/filter.rb', line 737

def collecting_event_id_facet
  return nil if collecting_event_id.empty?
  ::TaxonName
    .joins(:collection_objects)
    .where(collection_objects: { collecting_event_id: })
end

#collecting_event_query_facet ⇒ Object 



787
788
789
790
791
792
793
794
795
796
 
# File 'lib/queries/taxon_name/filter.rb', line 787

def collecting_event_query_facet
  return nil if collecting_event_query.nil?
  s = 'WITH query_ce_tns AS (' + collecting_event_query.all.to_sql + ') ' +
      ::TaxonName
        .joins(:collection_objects)
        .joins('JOIN query_ce_tns as query_ce_tns1 on collection_objects.collecting_event_id = query_ce_tns1.id')
        .to_sql

  ::TaxonName.from('(' + s + ') as taxon_names').distinct
end

#collection_object_id_facet ⇒ Object 



520
521
522
523
 
# File 'lib/queries/taxon_name/filter.rb', line 520

def collection_object_id_facet
  return nil if collection_object_id.empty?
  ::TaxonName.joins(:collection_objects).where(collection_objects: { id: collection_object_id })
end

#collection_object_query_facet ⇒ Object 



776
777
778
779
780
781
782
783
784
785
 
# File 'lib/queries/taxon_name/filter.rb', line 776

def collection_object_query_facet
  return nil if collection_object_query.nil?
  s = 'WITH query_collection_objects AS (' + collection_object_query.all.to_sql + ') ' +
      ::TaxonName
        .joins(:collection_objects)
        .joins('JOIN query_collection_objects as query_collection_objects1 on collection_objects.id = query_collection_objects1.id')
        .to_sql

  ::TaxonName.from('(' + s + ') as taxon_names').distinct
end

#combination_taxon_name_id_facet ⇒ Object 



726
727
728
729
730
731
732
733
734
735
 
# File 'lib/queries/taxon_name/filter.rb', line 726

def combination_taxon_name_id_facet
  return nil if combination_taxon_name_id.empty?
  ::Combination.joins(:related_taxon_name_relationships)
    .where(
      taxon_name_relationships: {
        type: ::TAXON_NAME_RELATIONSHIP_COMBINATION_TYPES.values,
        subject_taxon_name_id: combination_taxon_name_id,
      },
    ).distinct
end

#combinationify_result(q) ⇒ Object 



893
894
895
896
897
898
899
900
901
902
903
 
# File 'lib/queries/taxon_name/filter.rb', line 893

def combinationify_result(q)
  s = 'WITH tn_result_query AS (' + q.to_sql + ') ' +
      ::TaxonName
        .joins('JOIN tn_result_query as tn_result_query3 on tn_result_query3.id = taxon_names.cached_valid_taxon_name_id')
        .where("taxon_names.type = 'Combination'")
        .to_sql

  a = ::TaxonName.from('(' + s + ') as taxon_names').distinct

  referenced_klass_union([q, a])
end

#combinations_facet ⇒ Object 



744
745
746
747
748
749
750
751
752
 
# File 'lib/queries/taxon_name/filter.rb', line 744

def combinations_facet
  return nil if combinations.nil?
  a = ::Protonym.joins(:combination_relationships)
  if combinations
    a
  else
    referenced_klass_except(a)
  end
end

#descendant_facet ⇒ Object

Returns Scope match only names that are a descendant of some taxon_name_id.

Returns:

  • Scope match only names that are a descendant of some taxon_name_id



478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
 
# File 'lib/queries/taxon_name/filter.rb', line 478

def descendant_facet
  return nil if taxon_name_id.empty? || descendants.nil?

  h = ::TaxonNameHierarchy.arel_table

  if descendants
    descendants_subquery = ::TaxonNameHierarchy.where(
      h[:descendant_id].eq(::TaxonName.arel_table[:id]).and(
        h[:ancestor_id].in(taxon_name_id)
      )
    ).where(h[:ancestor_id].not_eq(h[:descendant_id]))

    if descendants_max_depth.present?
      descendants_subquery = descendants_subquery.where(::TaxonNameHierarchy.arel_table[:generations].lteq(descendants_max_depth.to_i))
    end

    ::TaxonName.where(descendants_subquery.arel.exists)
  else
    q = ::TaxonName.joins('JOIN taxon_name_hierarchies ON taxon_name_hierarchies.descendant_id = taxon_names.id')
      .where(taxon_name_hierarchies: {ancestor_id: taxon_name_id})
     if descendants_max_depth.present?
       q = q.where(::TaxonNameHierarchy.arel_table[:generations].lteq(descendants_max_depth.to_i))
     end
     q
  end
end

#geo_json_facet ⇒ Object 



434
435
436
437
438
439
440
441
442
443
 
# File 'lib/queries/taxon_name/filter.rb', line 434

def geo_json_facet
  return nil if geo_json.nil?
  otus = ::Queries::Otu::Filter.new(geo_json:).all
  collection_objects = ::Queries::CollectionObject::Filter.new(geo_json:).all

  a = ::TaxonName.joins(:taxon_taxon_determinations).where(taxon_determinations: { taxon_determination_object: collection_objects })
  b = ::TaxonName.joins(:otus).where(otus:)

  ::TaxonName.from("((#{a.to_sql}) UNION (#{b.to_sql})) as taxon_names")
end

#leaves_facet ⇒ Object

Returns Scope.

Returns:

  • Scope



560
561
562
563
 
# File 'lib/queries/taxon_name/filter.rb', line 560

def leaves_facet
  return nil if leaves.nil?
  leaves ? ::TaxonName.leaves : ::TaxonName.not_leaves
end

#merge_clauses ⇒ Object 



832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
 
# File 'lib/queries/taxon_name/filter.rb', line 832

def merge_clauses
  clauses = [
    asserted_distribution_query_facet,
    biological_association_query_facet,
    collecting_event_query_facet,
    collection_object_query_facet,
    otu_query_facet,

    ancestor_facet,
    authors_facet,
    collecting_event_id_facet,
    collection_object_id_facet,
    combination_taxon_name_id_facet,
    combinations_facet,
    descendant_facet,
    leaves_facet,
    not_specified_facet,
    original_combination_facet,
    otu_id_facet,
    taxon_name_author_id_facet,
    otus_facet,
    taxon_name_classification_facet,
    taxon_name_relationship_type_facet,
    type_metadata_facet,
    with_etymology_facet,
    year_range_facet,
  ]

  taxon_name_relationship.each do |hsh|
    clauses << taxon_name_relationship_facet(hsh)
  end

  clauses.compact
end

#model_id_facet ⇒ Object

Overrides base class



868
869
870
871
 
# File 'lib/queries/taxon_name/filter.rb', line 868

def model_id_facet
  return nil if taxon_name_id.empty? || !descendants.nil? || ancestors
  table[:id].in(taxon_name_id)
end

#name_facet ⇒ Object 



662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
 
# File 'lib/queries/taxon_name/filter.rb', line 662

def name_facet
  return nil if name.empty?
  if name_exact
    if (epithet_only)
      table[:name].in(name)
    else
      table[:cached].in(name).or(table[:cached_original_combination].in(name))
    end
    #  table[:cached].eq(name.strip).or(table[:cached_original_combination].eq(name.strip))
  else
    if (epithet_only)
      table[:name].matches_any(name.collect { |n| '%' + n.gsub(/\s+/, '%') + '%' })
    else
      table[:cached].matches_any(name.collect { |n| '%' + n.gsub(/\s+/, '%') + '%' }).or(table[:cached_original_combination].matches_any(name.collect { |n| '%' + n.gsub(/\s+/, '%') + '%' }))
    end
  end
end

#nomenclature_date_facet ⇒ Object 



467
468
469
470
471
472
473
474
 
# File 'lib/queries/taxon_name/filter.rb', line 467

def nomenclature_date_facet
  return nil if nomenclature_date.nil?
  if nomenclature_date
    table[:cached_nomenclature_date].not_eq(nil)
  else
    table[:cached_nomenclature_date].eq(nil)
  end
end

#not_specified_facet ⇒ Object 



445
446
447
448
449
450
451
452
453
454
455
456
 
# File 'lib/queries/taxon_name/filter.rb', line 445

def not_specified_facet
  return nil if not_specified.nil?
  if not_specified
    ::TaxonName.where(table[:cached].matches('%NOT SPECIFIED%').or(
      table[:cached_original_combination].matches('%NOT SPECIFIED%')
    ))
  else
    ::TaxonName.where(table[:cached].does_not_match('%NOT SPECIFIED%').and(
      table[:cached_original_combination].does_not_match('%NOT SPECIFIED%')
    ))
  end
end

#order_clause(query) ⇒ Object 



917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
 
# File 'lib/queries/taxon_name/filter.rb', line 917

def order_clause(query)
  case sort
  when 'alphabetical'
    ::TaxonName.select('*').from(
      query.order('taxon_names.cached'), :inner_query
    )
  when 'classification'
    ::TaxonName.select('*').from(
      query
        .joins('INNER JOIN taxon_name_hierarchies ON taxon_names.id = taxon_name_hierarchies.descendant_id')
        .order('taxon_name_hierarchies.generations, taxon_name_hierarchies.ancestor_id, taxon_names.cached'),
      :inner_query
    )
  else
    query
  end
end

#original_combination_facet ⇒ Object 



458
459
460
461
462
463
464
465
 
# File 'lib/queries/taxon_name/filter.rb', line 458

def original_combination_facet
  return nil if original_combination.nil?
  if original_combination
    ::Protonym.joins(:original_combination_relationships).distinct
  else
    ::Protonym.left_joins(:original_combination_relationships).where(taxon_name_relationships: {id: nil})
  end
end

#otu_id_facet ⇒ Object 



525
526
527
528
 
# File 'lib/queries/taxon_name/filter.rb', line 525

def otu_id_facet
  return nil if otu_id.empty?
  ::TaxonName.joins(:otus).where(otus: { id: otu_id })
end

#otu_query_facet ⇒ Object 



754
755
756
757
758
759
760
761
762
763
 
# File 'lib/queries/taxon_name/filter.rb', line 754

def otu_query_facet
  return nil if otu_query.nil?
  s = 'WITH query_otu_tn AS (' + otu_query.all.to_sql + ') ' +
      ::TaxonName
        .joins(:otus)
        .joins('JOIN query_otu_tn as query_otu_tn1 on otus.id = query_otu_tn1.id') # Don't change, see `validify`
        .to_sql

  ::TaxonName.from('(' + s + ') as taxon_names').distinct
end

#otus_facet ⇒ Object

Returns Scope.

Returns:

  • Scope



631
632
633
634
635
 
# File 'lib/queries/taxon_name/filter.rb', line 631

def otus_facet
  return nil if otus.nil?
  subquery = ::Otu.where(::Otu.arel_table[:taxon_name_id].eq(::TaxonName.arel_table[:id])).arel.exists
  ::TaxonName.where(otus ? subquery : subquery.not)
end

#parent_id_facet ⇒ Object 



680
681
682
683
 
# File 'lib/queries/taxon_name/filter.rb', line 680

def parent_id_facet
  return nil if parent_id.empty?
  table[:parent_id].in(parent_id)
end

#rank_facet ⇒ Arel::Nodes::Grouping?

Returns:

  • (Arel::Nodes::Grouping, nil) 


644
645
646
647
648
649
 
# File 'lib/queries/taxon_name/filter.rb', line 644

def rank_facet
  return nil if rank.blank?
  # We don't wildcard end so that we can isolate to specific ranks and below
  r = rank.collect { |i| "%#{i}" }
  table[:rank_class].matches_any(r)
end

#synonimify_result(q) ⇒ Object 



882
883
884
885
886
887
888
889
890
891
 
# File 'lib/queries/taxon_name/filter.rb', line 882

def synonimify_result(q)
  s = 'WITH tn_result_query AS (' + q.to_sql + ') ' +
      ::TaxonName
        .joins('JOIN tn_result_query as tn_result_query2 on tn_result_query2.id = taxon_names.cached_valid_taxon_name_id')
        .to_sql

  a = ::TaxonName.from('(' + s + ') as taxon_names').distinct

  referenced_klass_union([q, a])
end

#taxon_name_author_id_facet ⇒ Object 



595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
 
# File 'lib/queries/taxon_name/filter.rb', line 595

def taxon_name_author_id_facet
  return nil if taxon_name_author_id.empty?
  o = table
  r = ::Role.arel_table

  a = o.alias('a_')
  b = o.project(a[Arel.star]).from(a)

  c = r.alias('r1')

  b = b.join(c, Arel::Nodes::OuterJoin)
    .on(
      a[:id].eq(c[:role_object_id])
        .and(c[:role_object_type].eq('TaxonName'))
        .and(c[:type].eq('TaxonNameAuthor'))
    )

  e = c[:id].not_eq(nil)
  f = c[:person_id].in(taxon_name_author_id)

  b = b.where(e.and(f))
  b = b.group(a['id'])
  b = b.having(a['id'].count.eq(taxon_name_author_id.length)) unless taxon_name_author_id_or
  b = b.as('tn_z1_')

  ::TaxonName.joins(Arel::Nodes::InnerJoin.new(b, Arel::Nodes::On.new(b['id'].eq(o['id']))))
end

#taxon_name_classification_facet ⇒ Object

Returns Scope.

Returns:

  • Scope



583
584
585
586
587
588
589
590
591
592
593
 
# File 'lib/queries/taxon_name/filter.rb', line 583

def taxon_name_classification_facet
  return nil if taxon_name_classification.empty?

  ::TaxonName.where(
    ::TaxonNameClassification.where(
      ::TaxonNameClassification.arel_table[:taxon_name_id].eq(::TaxonName.arel_table[:id]).and(
        ::TaxonNameClassification.arel_table[:type].in(taxon_name_classification)
      )
    ).arel.exists
  )
end

#taxon_name_relationship_facet(hsh) ⇒ Object

Returns Scope wrapped in descendant_facet!.

Returns:

  • Scope wrapped in descendant_facet!



567
568
569
570
571
572
573
574
575
576
577
578
579
580
 
# File 'lib/queries/taxon_name/filter.rb', line 567

def taxon_name_relationship_facet(hsh)
  param_key = hsh['subject_taxon_name_id'] ? 'subject_taxon_name_id' : 'object_taxon_name_id'
  join_key = hsh['subject_taxon_name_id'] ? 'object_taxon_name_id' : 'subject_taxon_name_id'

  ::TaxonName.where(
    ::TaxonNameRelationship.where(
      ::TaxonNameRelationship.arel_table[join_key].eq(::TaxonName.arel_table[:id]).and(
        ::TaxonNameRelationship.arel_table[param_key].eq(hsh[param_key])
      ).and(
        ::TaxonNameRelationship.arel_table[:type].eq(hsh['type'])
      )
    ).arel.exists
  )
end

#taxon_name_relationship_type_facet ⇒ Object

Returns Scope.

Returns:

  • Scope



554
555
556
557
 
# File 'lib/queries/taxon_name/filter.rb', line 554

def taxon_name_relationship_type_facet
  return nil if taxon_name_relationship_type.empty?
  ::TaxonName.with_taxon_name_relationship(taxon_name_relationship_type)
end

#taxon_name_type_facet ⇒ Object 



657
658
659
660
 
# File 'lib/queries/taxon_name/filter.rb', line 657

def taxon_name_type_facet
  return nil if taxon_name_type.blank?
  table[:type].eq(taxon_name_type)
end

#type_metadata_facet ⇒ Object

Returns Scope.

Returns:

  • Scope



624
625
626
627
628
 
# File 'lib/queries/taxon_name/filter.rb', line 624

def type_metadata_facet
  return nil if type_metadata.nil?
  subquery = ::TypeMaterial.where(::TypeMaterial.arel_table[:protonym_id].eq(::TaxonName.arel_table[:id])).arel.exists
  ::TaxonName.where(type_metadata ? subquery : subquery.not)
end

#validify_result(q) ⇒ Object 



873
874
875
876
877
878
879
880
 
# File 'lib/queries/taxon_name/filter.rb', line 873

def validify_result(q)
  s = 'WITH tn_result_query AS (' + q.to_sql + ') ' +
      ::TaxonName
        .joins('JOIN tn_result_query as tn_result_query1 on tn_result_query1.cached_valid_taxon_name_id = taxon_names.id')
        .to_sql

  ::TaxonName.from('(' + s + ') as taxon_names').distinct
end

#validity_facet ⇒ Object 



708
709
710
711
712
713
714
715
 
# File 'lib/queries/taxon_name/filter.rb', line 708

def validity_facet
  return nil if validity.nil?
  if validity
    table[:cached_is_valid].eq(true)
  else
    table[:cached_is_valid].eq(false)
  end
end

#verbatim_name_facet ⇒ Object 



717
718
719
720
721
722
723
724
 
# File 'lib/queries/taxon_name/filter.rb', line 717

def verbatim_name_facet
  return nil if verbatim_name.nil?
  if verbatim_name
    table[:verbatim_name].not_eq(nil)
  else
    table[:verbatim_name].eq(nil)
  end
end

#with_etymology_facet ⇒ Object

Returns Scope.

Returns:

  • Scope



546
547
548
549
550
551
 
# File 'lib/queries/taxon_name/filter.rb', line 546

def with_etymology_facet
  return nil if etymology.nil?
  etymology ?
    ::TaxonName.where.not(etymology: nil) :
    ::TaxonName.where(etymology: nil)
end

#with_nomenclature_code ⇒ Arel::Nodes::Grouping?

Returns:

  • (Arel::Nodes::Grouping, nil) 


652
653
654
655
 
# File 'lib/queries/taxon_name/filter.rb', line 652

def with_nomenclature_code
  return nil if nomenclature_code.nil?
  table[:rank_class].matches(nomenclature_code)
end

#with_nomenclature_group ⇒ Arel::Nodes::Grouping?

Returns:

  • (Arel::Nodes::Grouping, nil) 


638
639
640
641
 
# File 'lib/queries/taxon_name/filter.rb', line 638

def with_nomenclature_group
  return nil if nomenclature_group.blank?
  table[:rank_class].matches(nomenclature_group)
end

#year_facet ⇒ Object 



694
695
696
697
698
699
700
 
# File 'lib/queries/taxon_name/filter.rb', line 694

def year_facet
  return nil if year.blank?

  s = Date.new(@year.to_i)
  e = Date.new(@year.to_i, 12, 31)
  table[:cached_nomenclature_date].between(s..e)
end

#year_range_facet ⇒ Object 



702
703
704
705
706
 
# File 'lib/queries/taxon_name/filter.rb', line 702

def year_range_facet
  return nil if year_end.nil? && year_start.nil?
  s, e = [year_start, year_end].compact
  ::TaxonName.where(cached_nomenclature_date: (s..e))
end