def search(self, config, start, stop, score_field=None):
# TODO: Handle MatchAll nested inside other search query classes.
if isinstance(self.query, MatchAll):
return self.queryset[start:stop]
search_query = self.build_database_query(config=config)
if self.fields is None:
vector = F('index_entries__autocomplete')
if not self.is_autocomplete:
vector = vector._combine(F('index_entries__body'), '||', False)
else:
vector = ADD(
SearchVector(field_lookup, config=search_query.config,
weight=get_weight(search_field.boost))
for field_lookup, search_field in self.search_fields.items()
if not self.is_autocomplete or search_field.partial_match)
rank_expression = SearchRank(vector, search_query,
weights=self.sql_weights)
queryset = self.queryset.annotate(
_vector_=vector).filter(_vector_=search_query)
if self.order_by_relevance:
queryset = queryset.order_by(rank_expression.desc(), '-pk')
elif not queryset.query.order_by:
# Adds a default ordering to avoid issue #3729.
queryset = queryset.order_by('-pk')
rank_expression = F('pk')
if score_field is not None:
queryset = queryset.annotate(**{score_field: rank_expression})
return queryset[start:stop]
def get_queryset(self):
queryset = Outcome.objects.filter(is_public=True)
query = SearchQuery(prepare_search_term(
self.request.GET.get('query', '')),
search_type='raw')
vector = SearchVector('title', weight='A') + SearchVector(
'description', weight='B')
rank = SearchRank(vector, query)
return Outcome.objects.annotate(rank=rank).filter(
rank__gt=0.2).order_by('rank')[:20]
def search(self, query=None):
qs = self
if query is not None:
vector = SearchVector('title', weight='A') \
+ SearchVector('description', weight='B')\
+ SearchVector('slug', weight='C')
query = SearchQuery(query)
result = Article.objects.annotate(rank=SearchRank(vector,
query)).filter(rank__gte=0.3).order_by('rank').order_by('-rank')
return result
def search(self, text):
if text == "":
# search_rank = SearchRank(search_vectors, search_query)
return self.get_queryset().annotate(search=search_vectors)
else:
search_query = SearchQuery(text, config='english')
search_rank = SearchRank(search_vectors, search_query)
return self.get_queryset().annotate(search=search_vectors).filter(
search=search_query).annotate(
rank=search_rank).order_by('-rank')
def get_queryset(self):
query = self.request.GET.get('q')
vector = SearchVector('name', weight='A') + SearchVector(
'content', weight='C') + SearchVector('categories__name',
weight='B')
query = SearchQuery(query)
results = Article.objects.annotate(
rank=SearchRank(vector, query)).filter(
rank__gte=0.2).order_by('rank')
return results
def get_queryset(self):
qs = Video.objects.all()
keywords = self.request.GET.get('q')
if keywords:
query = SearchQuery(keywords)
vector = SearchVector('json', 'name')
qs = qs.annotate(search=vector).filter(search=query)
qs = qs.annotate(rank=SearchRank(vector, query)).order_by('-rank')
return qs
def get_search_results(self, request, queryset, search_term):
if not search_term:
return super().get_search_results(request, queryset, search_term)
query = SearchQuery(search_term, config="portuguese")
rank = SearchRank(F("search_vector"), query)
queryset = (File.objects.annotate(rank=rank).filter(
search_vector=query).order_by("-rank"))
return queryset, False
def search(self, search_terms):
vector = SearchVector(
models.F("name"), config="simple_unaccented",
weight="A") + SearchVector(models.F("code_departement"),
config="simple_unaccented",
weight="B")
query = PrefixSearchQuery(search_terms, config="simple_unaccented")
return (self.annotate(search=vector).filter(search=query).annotate(
rank=SearchRank(vector, query)).order_by("-rank"))
def search_users(phrase):
"""Return matching users for dashboard views."""
sv = (SearchVector("email", weight="A") +
SearchVector("first_name", weight="B") +
SearchVector("last_name", weight="B") +
SearchVector("default_billing_address__first_name", weight="B") +
SearchVector("default_billing_address__last_name", weight="B"))
rank = SearchRank(sv, SearchQuery(phrase))
return User.objects.annotate(rank=rank).filter(
rank__gte=0.2).order_by("-rank")
def search(self, query):
search_query = Q(
Q(search_vector=SearchQuery(query))
)
return self.annotate(
variety_headline=SearchHeadLine(F('variety'), SearchQuery(query)),
winery_headline=SearchHeadLine(F('winery'), SearchQuery(query)),
description_headline=SearchHeadLine(F('description'), SearchQuery(query)),
search_rank=SearchRank(F('search_vector'), SearchQuery(query)),
).filter(search_query).order_by('-search_rank', 'id')
def get_queryset(self):
super().get_queryset()
if 'query' in self.request.GET:
query = self.request.GET['query']
search_vector = SearchVector('name', 'subcategory', 'category',
'body')
search_query = SearchQuery(query)
results = Worker.objects.annotate(search=search_vector, rank=SearchRank(search_vector, search_query)). \
filter(search=search_query)
return results
def get(self, request):
query = request.GET.get('q')
# igts = Ingredient.objects.filter(Q(long_desc__icontains=query) | Q(short_desc__icontains=query))[:5]
# igts = Ingredient.objects.filter(long_desc__search=query)[:5]
body_vector = SearchVector('long_desc')
term_query = SearchQuery(query)
igts = Ingredient.objects.annotate(
rank=SearchRank(body_vector, term_query))[:5]
serializer = IngredientSerializer(igts, many=True)
return Response(serializer.data)
def search(self, request):
q = request.GET['q']
vector = SearchVector('tip', weight='A')
query = SearchQuery(q, search_type='phrase')
rank = SearchRank(vector, query)
tweets = Tweet.objects.annotate(rank=rank).filter(
rank__gte=0.3).order_by('-rank')
serializer = TweetSerializerSearch(tweets, many=True)
return Response({'items': serializer.data})
def search(query):
vector = SearchVector('title', weight='A') + \
SearchVector('description', weight='A')
query = SearchQuery(query)
return Petition.objects.annotate(rank=SearchRank(vector, query)) \
.select_related('author', 'response') \
.prefetch_related('tags', 'updates') \
.filter(status=1) \
.filter(rank__gte=0.35) \
.order_by('-rank')[:45]
def search_by_name(self, search_text, objects=None):
vector = SearchVector("name")
query = SearchQuery(search_text)
if not objects:
objects = self.get_queryset()
return (
objects.annotate(search=vector, rank=SearchRank(vector, query))
.filter(search=search_text)
.order_by("-rank")
)
def search(self, termes: str):
"""Réalise une recherche plein texte dans le queryset
:param termes: Les termes à rechercher
:return: le queryset filtré et ordonné selon les termes à rechercher
"""
query = PrefixSearchQuery(termes, config="data_france_search")
return (self.filter(search=query).annotate(
rank=SearchRank(models.F("search"), query)).order_by("-rank"))
def get_can_help(self, query=""):
results = Experience.objects.filter(
profile=self, exp_type=Experience.Type.CAN_HELP).order_by("-level")
if query:
vector = SearchVector("skill__skill")
or_query = SearchQuery(query.replace(" ", " | "),
search_type="raw")
results = results.annotate(rank=SearchRank(vector, or_query))
results = results.order_by("-rank")
return results
def search_users(phrase):
"""Return matching users for dashboard views."""
sv = (SearchVector('email', weight='A') +
SearchVector('first_name', weight='B') +
SearchVector('last_name', weight='B') +
SearchVector('default_billing_address__first_name', weight='B') +
SearchVector('default_billing_address__last_name', weight='B'))
rank = SearchRank(sv, SearchQuery(phrase))
return User.objects.annotate(rank=rank).filter(
rank__gte=0.2).order_by('-rank')
def filter_datasets(
datasets: Union[ReferenceDataset, DataSet],
query,
source,
use=None,
user=None,
form=None,
):
search = SearchVector('name', 'short_description', config='english')
search_query = SearchQuery(query, config='english')
dataset_filter = Q(published=True)
if user:
if datasets.model is ReferenceDataset:
reference_type = DataSetType.REFERENCE.value
reference_perm = dataset_type_to_manage_unpublished_permission_codename(
reference_type)
if user.has_perm(reference_perm):
dataset_filter |= Q(published=False)
if datasets.model is DataSet:
master_type, datacut_type = (
DataSetType.MASTER.value,
DataSetType.DATACUT.value,
)
master_perm = dataset_type_to_manage_unpublished_permission_codename(
master_type)
datacut_perm = dataset_type_to_manage_unpublished_permission_codename(
datacut_type)
if user.has_perm(master_perm) and (not use
or str(master_type) in use):
dataset_filter |= Q(published=False, type=master_type)
if user.has_perm(datacut_perm) and (not use
or str(datacut_type) in use):
dataset_filter |= Q(published=False, type=datacut_type)
datasets = datasets.filter(dataset_filter).annotate(search=search,
search_rank=SearchRank(
search,
search_query))
if query:
datasets = datasets.filter(search=query)
if source:
datasets = datasets.filter(source_tags__in=source)
if use:
datasets = datasets.filter(type__in=use)
return datasets
def search(request):
# print("in search function")
ctx = {}
query_param = str(request.GET.get("q1"))
search_cat = str(request.GET.get("q2", 'all')).lower()
if query_param not in [None, "", " "]:
query_param = str(query_param.strip())
if (search_cat in ['all', 'search_options']):
# medicines = medicineDetail.objects.annotate(search=SearchVector('sku_name', 'manufacturer_name', 'salt_name')).filter(
# search=query_param)
vector = SearchVector('sku_name', weight='A') + SearchVector(
'manufacturer_name', weight='B') + SearchVector('salt_name',
weight='C')
query = SearchQuery(query_param)
medicines = medicineDetail.objects.annotate(
# similarity=TrigramSimilarity(
# 'sku_name', query_param
# )*0.5 + TrigramSimilarity(
# 'manufacturer_name', query_param
# )*0.4 + TrigramSimilarity(
# 'salt_name', query_param
# )*0.1,
distance=TrigramDistance('sku_name', query_param) * 0.5 +
TrigramDistance('manufacturer_name', query_param) * 0.4 +
TrigramDistance('salt_name', query_param) * 0.1,
rank=SearchRank(vector, query)).order_by('distance')[:20]
print(medicines)
elif search_cat == 'product_name':
medicines = medicineDetail.objects.annotate(distance=TrigramDistance('sku_name', query_param)) \
.order_by('distance')[:20]
# print(medicines)
elif search_cat == 'manufacturer_name':
# print("in manu fac")
medicines = medicineDetail.objects.annotate(
distance=TrigramDistance('manufacturer_name', query_param
)).order_by('distance')[:20]
# print(medicines)
elif search_cat == 'salt_name':
medicines = medicineDetail.objects.annotate(distance=TrigramDistance('salt_name', query_param)) \
.order_by('distance')[:20]
else:
medicines = medicineDetail.objects.none()
ctx["medicines"] = medicines
# print(ctx)
if request.is_ajax():
html = render_to_string(
template_name="navia_home/medicines-results-partial.html",
context={"medicines": medicines})
data_dict = {"html_from_view": html}
# print(data_dict)
return JsonResponse(data=data_dict, safe=False)
return render(request, "navia_home.html", context=ctx)
def get_queryset(self):
search = self.request.GET.get("search")
if search:
search_vector = SearchVector("title", weight="A") + SearchVector("body", weight="B")
search_query = SearchQuery(search)
return Post.published.annotate(
search_vector=search_vector,
search_rank=SearchRank(search_vector, search_query)
).filter(search_vector=search_query, search_rank__gte=0.3).order_by("-search_rank")
return Post.published.all()
def get_search_results(self, request, queryset, search_term):
if not search_term:
return super().get_search_results(request, queryset, search_term)
query = SearchQuery(search_term, search_type="websearch", config="english")
rank = SearchRank(F('locality__search_vector'), query)
query = Q(locality__search_vector=query)
if ' ' not in search_term:
query |= Q(atco_code=search_term)
queryset = queryset.annotate(rank=rank).filter(query).order_by("-rank")
return queryset, False
def get_queryset(self):
qs = Producto.objects.all()
keywords = self.request.GET.get('barraBusqueda')
if keywords:
consulta = SearchQuery(keywords)
vector = SearchVector('nombre', 'descripcion')
qs = qs.annotate(search=vector).filter(search=consulta)
qs = qs.annotate(
rank=SearchRank(vector, consulta)).order_by('-rank')
return qs
def get_queryset(self): # new
query = self.request.GET.get('search_query')
search_query = SearchQuery(query)
search_vector = SearchVector('name', 'body', 'address')
search_rank = SearchRank(search_vector, search_query)
trigram_similarity = TrigramSimilarity('name', query)
object_list = Agency.objects.annotate(search=search_vector).filter(
search=search_query).annotate(rank=search_rank +
trigram_similarity).order_by('-rank')
return object_list
def search_posts(request, value):
if request.POST:
return redirect(reverse_lazy('posts:search_posts', args=[request.POST.get('value')]))
else:
search_vector = SearchVector('title', weight='A') + SearchVector('content', weight='B')
search_query = SearchQuery(value)
results = Post.published.annotate(
search=search_vector,
rank=SearchRank(search_vector, search_query)
).filter(search=search_query).order_by('-rank')
return render(request, "blog/founded_posts.html", {'results': results, 'value': value})
def get_queryset(self):
qs = super().get_queryset()
keywords = self.request.GET.get('q')
if keywords:
query = SearchQuery(keywords)
vector = SearchVector('title', 'text')
qs = qs.annotate(search=vector).filter(search=query)
qs = qs.annotate(rank=SearchRank(vector, query)).order_by('-rank')
print("qs {}".format(qs.__dict__))
return qs
def get_specs_search_rank(self, ct_obj: ContentType, cat_list=None):
"""Rank and filter specifications by search text"""
query = self.query
vector = self.get_specs_vector()
qs_prod = self.get_products_search(ct_obj)
product = qs_prod.filter(id=OuterRef('object_id'))
product_rank = product.annotate(rank=SearchRank('search', query))
qs = get_specs(ct_id=ct_obj.id).annotate(search=vector)
if cat_list is None:
qs = qs.filter(Q(Exists(product)) | Q(search=query))
else:
qs = qs.filter(category_id__in=cat_list)
qs = qs.annotate(
rank_prod=Subquery(product_rank.order_by().values('rank')),
rank_spec=SearchRank('search', query),
).annotate(rank=Case(
When(rank_prod__isnull=True, then='rank_spec'),
default=(F('rank_prod') + F('rank_spec')),
))
return get_specs_with_rating(qs)
def get_queryset(self):
quotes = Quote.objects.filter(
created_by=self.request.user).order_by('-modified')
if 'search' in self.request.GET and self.request.GET['search']:
query = SearchQuery(self.request.GET['search'])
vector = SearchVector('text', 'book__title', 'book__author')
quotes = quotes.annotate(
search=vector, rank=SearchRank(vector, query)).filter(
search=self.request.GET['search']).order_by('-rank')
return quotes
def slow_search(request):
query = request.GET.get('search_text')
#vector = SearchVector('tsv')
q = SearchQuery(query, config='english')
#results = ArchivePage.objects.filter(tsv=query)[:10]
#This is really really slow :(
results = ArchivePage.objects.annotate(
rank=SearchRank(F('tsv'), q)).order_by('-rank')[:10]
#print(results.query)
context = {'results': results}
return render(request, 'archive/search.html', context)
def _search_by_keywords_no_sort(self, keywords):
now = datetime.now().timestamp()
# Use expressions.Value to represent search_vector column.
# This can avoid create the search vector for each request.
# The search_vector has already added as a SearchVectorField and updated by the trigger, we can use it directly.
products = self.annotate(rank=SearchRank(expressions.Value('search_vector'), keywords)) \
.filter(active=True,
promotion_start_date__lte=now,
promotion_end_date__gt=now,
search_vector=keywords)
return products
def get_queryset(self):
qs = Post.objects.published()
keywords = self.request.GET.get('q')
if keywords:
query = SearchQuery(keywords)
vector = SearchVector('title', 'content')
qs = qs.annotate(search=vector).filter(search=query)
qs = qs.annotate(rank=SearchRank(vector, query)).order_by('-rank')
return qs
