Konvertieren Sie eine komplexe SQL-Abfrage in SQLAlchemy

Ihr HAVING richtig gehandhabt wird, aber Sie übergeben ihm den falschen Ausdruck. Es scheint, dass Sie Python 2 verwenden, da der relationale Vergleich zwischen einer Zeichenfolge und einer Ganzzahl

'distance' < 25

löst keine Ausnahme aus, sondern wird zu False ausgewertet stattdessen. Mit anderen Worten, Ihre Abfrage ist gleich

locations = db.session.query(...).having(False).all()

was erklärt, warum Sie keine Ergebnisse erhalten:Alle Zeilen werden explizit durch die HAVING-Klausel herausgefiltert, wie in der gedruckten Version zu sehen ist:

...
HAVING false = 1  -- remove all rows

Eine Lösung ist die Verwendung eines geeigneten Konstrukts wie column() , um den Ausdruck zu erzeugen:

locations = db.session.query(...).having(column('distance') < 25).all()

Sie sollten den komplexen Elementausdruck der Auswahlliste nicht in einen select() , die eine SELECT-Anweisung darstellt. Beschriften Sie entweder den text() wie es ist:

text('( 6371 * acos( cos( radians("53.6209798282177") ) * '
     'cos( radians( lat ) ) * cos( radians( lng ) - radians("13.96948162900808") ) + '
     'sin( radians("53.6209798282177") ) * sin( radians( lat ) ) ) ) '
     'AS distance')

oder erstellen Sie den Ausdruck mit dem Modell:

(6371 *
 func.acos(func.cos(func.radians(53.6209798282177)) *
           func.cos(func.radians(Location.lat)) *
           func.cos(func.radians(Location.lng) - func.radians(13.96948162900808)) +
           func.sin(func.radians(53.6209798282177)) *
           func.sin(func.radians(Location.lat)))).label('distance')

Sie könnten die Lesbarkeit Ihrer Abfragekonstruktion verbessern, indem Sie eine Funktion für die Großkreisentfernung , und mit ein wenig Arbeit könnten Sie einen Hybridmethode auf Location :

import math

def gc_distance(lat1, lng1, lat2, lng2, math=math):
    ang = math.acos(math.cos(math.radians(lat1)) *
                    math.cos(math.radians(lat2)) *
                    math.cos(math.radians(lng2) -
                             math.radians(lng1)) +
                    math.sin(math.radians(lat1)) *
                    math.sin(math.radians(lat2)))

    return 6371 * ang

class Location(db.Model):
    ...
    @hybrid_method
    def distance(self, lat, lng):
        return gc_distance(lat, lng, self.lat, self.lng)

    @distance.expression
    def distance(cls, lat, lng):
        return gc_distance(lat, lng, cls.lat, cls.lng, math=func)

locations = db.session.query(
        Location,
        Location.distance(53.6209798282177,
                          13.96948162900808).label('distance')).\
    having(column('distance') < 25).\
    order_by('distance').\
    all()

Beachten Sie, dass die Art und Weise, wie Sie HAVING verwenden, um Nicht-Gruppenzeilen zu eliminieren, nicht portierbar ist. Zum Beispiel in Postgresql das Vorhandensein von HAVING-Klausel wandelt eine Abfrage in eine gruppierte Abfrage um, sogar ohne eine GROUP BY-Klausel. Sie könnten stattdessen eine Unterabfrage verwenden:

stmt = db.session.query(
        Location,
        Location.distance(53.6209798282177,
                          13.96948162900808).label('distance')).\
    subquery()

location_alias = db.aliased(Location, stmt)

locations = db.session.query(location_alias).\
    filter(stmt.c.distance < 25).\
    order_by(stmt.c.distance).\
    all()