Nowa funkcja TriGramSimilarość Django.Contrib.postgres była świetna dla problemu, jaki miałem. Używam go do paska wyszukiwania, aby znaleźć ciężko przeliterować nazwy łacińskie. Problem polega na tym, że istnieje ponad 2 miliony nazw, a wyszukiwanie trwa dłużej niż chcę.

Chciałbym utworzyć indeks na trygramy, jak opisano w dokumentacji postgres https://www.postgresql.org/docs/9.6/static/pgtrgm. HTML.

Ale nie jestem pewien, jak to zrobić w taki sposób, że API Django wykorzystałby go. W poszukiwaniu tekstu Postgres znajduje się opis, jak utworzyć indeks, ale nie dla podobieństwa TriGram. https://docs.djangoproject.com/en/1.11 / Ref / Atformacje / Postgre / Search / # Performance

Oto, co mam teraz:

class NCBI_names(models.Model):
    tax_id          =   models.ForeignKey(NCBI_nodes, on_delete=models.CASCADE, default = 0)
    name_txt        =   models.CharField(max_length=255, default = '')
    name_class      =   models.CharField(max_length=32, db_index=True, default = '')

    class Meta:
        indexes = [GinIndex(fields=['name_txt'])]

W trybie widoku get_queryset:

class TaxonSearchListView(ListView):    
    #form_class=TaxonSearchForm
    template_name='collectie/taxon_list.html'
    paginate_by=20
    model=NCBI_names
    context_object_name = 'taxon_list'

    def dispatch(self, request, *args, **kwargs):
        query = request.GET.get('q')
        if query:
            try:
                tax_id = self.model.objects.get(name_txt__iexact=query).tax_id.tax_id
                return redirect('collectie:taxon_detail', tax_id)
            except (self.model.DoesNotExist, self.model.MultipleObjectsReturned) as e:
                return super(TaxonSearchListView, self).dispatch(request, *args, **kwargs)
        else:
            return super(TaxonSearchListView, self).dispatch(request, *args, **kwargs)

    def get_queryset(self):
        result = super(TaxonSearchListView, self).get_queryset()
        #
        query = self.request.GET.get('q')
        if query:            
            result = result.exclude(name_txt__icontains = 'sp.')
            result = result.annotate(similarity=TrigramSimilarity('name_txt', query)).filter(similarity__gt=0.3).order_by('-similarity')
        return result
15
Allcor 29 czerwiec 2017, 11:46

5 odpowiedzi

Najlepsza odpowiedź

Znalazłem Artykuł 12/2020 wykorzystuje najnowszą wersję Django Orm jako taki:

class Author(models.Model):
    first_name = models.CharField(max_length=100)
    last_name = models.CharField(max_length=100)

    class Meta:
        indexes = [
            GinIndex(
                name='review_author_ln_gin_idx', 
                fields=['last_name'], 
                opclasses=['gin_trgm_ops'],
            )
        ]

Zainspirowany z Stary artykuł na ten temat, ja Wylądował do Aktualny jeden, który podaje następujące rozwiązanie dla GistIndex:

Aktualizacja: Z Django-1.11 rzeczy wydają się być prostsze, jak Ta odpowiedź i Django-2.2 , atrybut {x0}} będzie dostępny w class Index(fields=(), name=None, db_tablespace=None, opclasses=()) w tym celu.


from django.contrib.postgres.indexes import GistIndex

class GistIndexTrgrmOps(GistIndex):
    def create_sql(self, model, schema_editor):
        # - this Statement is instantiated by the _create_index_sql()
        #   method of django.db.backends.base.schema.BaseDatabaseSchemaEditor.
        #   using sql_create_index template from
        #   django.db.backends.postgresql.schema.DatabaseSchemaEditor
        # - the template has original value:
        #   "CREATE INDEX %(name)s ON %(table)s%(using)s (%(columns)s)%(extra)s"
        statement = super().create_sql(model, schema_editor)
        # - however, we want to use a GIST index to accelerate trigram
        #   matching, so we want to add the gist_trgm_ops index operator
        #   class
        # - so we replace the template with:
        #   "CREATE INDEX %(name)s ON %(table)s%(using)s (%(columns)s gist_trgrm_ops)%(extra)s"
        statement.template =\
            "CREATE INDEX %(name)s ON %(table)s%(using)s (%(columns)s gist_trgm_ops)%(extra)s"

        return statement

Który możesz następnie użyć w swojej klasie modelu:

class YourModel(models.Model):
    some_field = models.TextField(...)

    class Meta:
        indexes = [
            GistIndexTrgrmOps(fields=['some_field'])
        ]
6
raratiru 29 grudzień 2020, 14:13

Ma już odpowiedź, ale w Django 2.2 możesz zrobić to znacznie łatwiejsze:

class MyModel(models.Model):
   name = models.TextField()
   class Meta:
       indexes = [GistIndex(name="gist_trgm_idx", fields=("name",), opclasses=("gist_trgm_ops",))]

Alternatywnie możesz użyć GinIndex.

5
Alex Shkop 4 grudzień 2019, 07:52

Aby zrobić Django 2.2 Użyj indeksu dla icontains i podobnych wyszukiwań:

SubClass Ginindex, aby dokonać indeksu niewrażliwego przypadku (górne wartości wszystkie wartości pola):

from django.contrib.postgres.indexes import GinIndex

class UpperGinIndex(GinIndex):

    def create_sql(self, model, schema_editor, using=''):
        statement = super().create_sql(model, schema_editor, using=using)
        quote_name = statement.parts['columns'].quote_name

        def upper_quoted(column):
            return f'UPPER({quote_name(column)})'
        statement.parts['columns'].quote_name = upper_quoted
        return statement

Dodaj indeks do swojego modelu, w tym KWARG name, który jest wymagany przy użyciu opclasses:

class MyModel(Model):
    name = TextField(...)

    class Meta:
        indexes = [
            UpperGinIndex(fields=['name'], name='mymodel_name_gintrgm', opclasses=['gin_trgm_ops'])
        ]

Wygeneruj migrację i edytuj wygenerowany plik:

# Generated by Django 2.2.3 on 2019-07-15 10:46
from django.contrib.postgres.operations import TrigramExtension  # <<< add this
from django.db import migrations
import myapp.models


class Migration(migrations.Migration):

    operations = [
        TrigramExtension(),   # <<< add this
        migrations.AddIndex(
            model_name='mymodel',
            index=myapp.models.UpperGinIndex(fields=['name'], name='mymodel_name_gintrgm', opclasses=['gin_trgm_ops']),
        ),
    ]
5
Risadinha 11 listopad 2020, 10:07

W przypadku, gdy ktoś chce połączyć indeks na wielu kolumn (połączonych) z przestrzenią, możesz użyć mojego mędritego wbudowanego indeksu.

Tworzy indeks jak gin (("column1" || ' ' || "column2" || ' ' || ...) gin_trgm_ops)

class GinSpaceConcatIndex(GinIndex):

    def get_sql_create_template_values(self, model, schema_editor, using):

        fields = [model._meta.get_field(field_name) for field_name, order in self.fields_orders]
        tablespace_sql = schema_editor._get_index_tablespace_sql(model, fields)
        quote_name = schema_editor.quote_name
        columns = [
            ('%s %s' % (quote_name(field.column), order)).strip()
            for field, (field_name, order) in zip(fields, self.fields_orders)
        ]
        return {
            'table': quote_name(model._meta.db_table),
            'name': quote_name(self.name),
            'columns': "({}) gin_trgm_ops".format(" || ' ' || ".join(columns)),
            'using': using,
            'extra': tablespace_sql,
        }
5
n1_ 18 grudzień 2017, 09:26

Miałem podobny problem, próbując użyć rozszerzenia pg_tgrm, aby obsłużyć wydajne wyszukiwanie contains i icontains Django

Może być bardziej elegancki sposób, ale definiujący nowy typ indeksu, który działa dla mnie:

from django.contrib.postgres.indexes import GinIndex

class TrigramIndex(GinIndex):
    def get_sql_create_template_values(self, model, schema_editor, using):
        fields = [model._meta.get_field(field_name) for field_name, order in self.fields_orders]
        tablespace_sql = schema_editor._get_index_tablespace_sql(model, fields)
        quote_name = schema_editor.quote_name
        columns = [
            ('%s %s' % (quote_name(field.column), order)).strip() + ' gin_trgm_ops'
            for field, (field_name, order) in zip(fields, self.fields_orders)
        ]
        return {
            'table': quote_name(model._meta.db_table),
            'name': quote_name(self.name),
            'columns': ', '.join(columns),
            'using': using,
            'extra': tablespace_sql,
        }

Metoda get_sql_create_template_values jest kopiowana z Index.get_sql_create_template_values(), z jednym modyfikacją: dodanie + ' gin_trgm_ops'.

W przypadku każdego przypadku zostanie określony indeks na name_txt za pomocą tego TrigramIndex zamiast GinIndex. Następnie uruchom makemigrations, co wytworzy migrację, która generuje wymagane CREATE INDEX sql.

AKTUALIZACJA:

Widzę, że robisz również zapytanie za pomocą icontains:

result.exclude(name_txt__icontains = 'sp.')

Backend PostgreSQL zmieni to w coś w ten sposób:

UPPER("NCBI_names"."name_txt"::text) LIKE UPPER('sp.')

A następnie indeks trigrama nie zostanie użyty z powodu UPPER().

Miałem ten sam problem, a skończyłem podklasę bronią bazy danych do pracy:

from django.db.backends.postgresql import base, operations

class DatabaseFeatures(base.DatabaseFeatures):
    pass

class DatabaseOperations(operations.DatabaseOperations):
    def lookup_cast(self, lookup_type, internal_type=None):
        lookup = '%s'

        # Cast text lookups to text to allow things like filter(x__contains=4)
        if lookup_type in ('iexact', 'contains', 'icontains', 'startswith',
                           'istartswith', 'endswith', 'iendswith', 'regex', 'iregex'):
            if internal_type in ('IPAddressField', 'GenericIPAddressField'):
                lookup = "HOST(%s)"
            else:
                lookup = "%s::text"

        return lookup


class DatabaseWrapper(base.DatabaseWrapper):
    """
        Override the defaults where needed to allow use of trigram index
    """
    ops_class = DatabaseOperations

    def __init__(self, *args, **kwargs):
        self.operators.update({
            'icontains': 'ILIKE %s',
            'istartswith': 'ILIKE %s',
            'iendswith': 'ILIKE %s',
        })
        self.pattern_ops.update({
            'icontains': "ILIKE '%%' || {} || '%%'",
            'istartswith': "ILIKE {} || '%%'",
            'iendswith': "ILIKE '%%' || {}",
        })
        super(DatabaseWrapper, self).__init__(*args, **kwargs)
12
TimB 7 lipiec 2017, 05:22