SQL Alchemy Abfrage mehrere Tabellen

Question

Ich versuche, eine Abfrage mit SQL-Alchemie, die sonst sehr einfach wäre, wenn ich nicht ORM verwenden würde, so denke ich mir, sicherlich muss es eine direkte Möglichkeit. Ich habe die meisten Fragen zu diesem Thema beantwortet, aber meine Frage scheint nicht beantwortet zu werden. Ich habe diese beiden Tabellen

class Artisan(Base): 
    __tablename__ = 'artisan' 
    name = Column(String(80), nullable=False) 
    skill = Column(String(80), nullable=False) 
    id = Column(Integer, primary_key=True) 
    bio = Column(String(300)) 
    category = Column(Integer, ForeignKey(Category.id)) 
    user = Column(Integer, ForeignKey(Users.id)) 
    id_no = Column(Integer, nullable=False) 
    users = relationship(Users) 

und

class Address(Base): 
    __tablename__ = 'address' 
    building = Column(String(80), nullable=False) 
    floor = Column(String(80), nullable=False) 
    house_no = Column(String(80), nullable=False) 
    telephone = Column(String(80), nullable=False) 
    kwetu_address = Column(String(80), nullable=False) 
    id = Column(Integer, primary_key=True) 
    lat = Column(String(25)) 
    lng = Column(String(25)) 
    artisan = Column(Integer, ForeignKey(Artisan.id)) 
    user = Column(Integer, ForeignKey(Users.id)) 
    users = relationship(Users) 

Ich möchte die Artisans durch eine Kategorie filtern, dann filtern Sie die Adressen von den gefilterten Handwerker und präsentieren die Ergebnisse in einer Weise, die verbindet die Handwerker mit entsprechenden Adressen hoffentlich Sqlalchemy bekommen die Filterung

Das beste, was ich mit oben kommen kann beinhaltet zwei Abfragen und Nachbearbeitung zu tun, was ich fühle mich sehr ineffizient ist

my_artisans = (session.query(Artisan).filter_by(category=cat_id)) 
my_addresses = (session.query(Address) 
         .join(Artisan, Artisan.id ==Address.artisan).filter_by(category=cat_id)) 
return jsonify(artisans =[art.serialize for art in my_artisans], addresses=[add.serialize for add in my_addresses]) 

Dank

hinzufügen auf - alle zugehörigen Klassen

import sys 
from sqlalchemy import Column, ForeignKey, Integer, String, Float 
from sqlalchemy.ext.declarative import declarative_base 
from sqlalchemy.orm import relationship 
from sqlalchemy import create_engine 

Base = declarative_base() 


class Users(Base): 
    __tablename__ = 'users' 
    name = Column(String(80), nullable=False) 
    email = Column(String(80), nullable=False) 
    id = Column(Integer, primary_key=True) 
    bio = Column(String(300)) 
    picture = Column(String(80)) 


class Category(Base): 
    __tablename__ = 'category' 
    name = Column(String(80), nullable=False) 
    id = Column(Integer, primary_key=True) 
    user = Column(Integer, ForeignKey(Users.id)) 
    users = relationship(Users) 

    @property 
    def serialize(self): 
     return{ 
      'id': self.id, 
      'name': self.name 
     } 


class Artisan(Base): 
    __tablename__ = 'artisan' 
    name = Column(String(80), nullable=False) 
    skill = Column(String(80), nullable=False) 
    id = Column(Integer, primary_key=True) 
    bio = Column(String(300)) 
    category = Column(Integer, ForeignKey(Category.id)) 
    user = Column(Integer, ForeignKey(Users.id)) 
    id_no = Column(Integer, nullable=False) 
    users = relationship(Users) 

    @property 
    def serialize(self): 
     return{ 
      'id': self.id, 
      'name': self.name, 
      'skill': self.skill, 
      'category': self.category, 
      'bio': self.bio, 
      'id_no': self.id_no 

     } 


class Portfolio(Base): 
    __tablename__ = 'portfolio' 
    title = Column(String(80), nullable=False) 
    details = Column(String(300), nullable=False) 
    id = Column(Integer, primary_key=True) 
    artisan = Column(Integer, ForeignKey(Artisan.id)) 
    user = Column(Integer, ForeignKey(Users.id)) 
    users = relationship(Users) 

    @property 
    def serialize(self): 
     return{ 
      'id': self.id, 
      'title': self.title, 
      'details': self.details 
     } 


class Endorsements(Base): 
    __tablename__ = 'endorsements' 
    title = Column(String(80), nullable=False) 
    details = Column(String(300), nullable=False) 
    id = Column(Integer, primary_key=True) 
    artisan = Column(Integer, ForeignKey(Artisan.id)) 
    user = Column(Integer, ForeignKey(Users.id)) 
    users = relationship(Users) 

    @property 
    def serialize(self): 
     return{ 
      'id': self.id, 
      'title': self.title, 
      'details': self.details 
     } 


class Address(Base): 
    __tablename__ = 'address' 
    building = Column(String(80), nullable=False) 
    floor = Column(String(80), nullable=False) 
    house_no = Column(String(80), nullable=False) 
    telephone = Column(String(80), nullable=False) 
    kwetu_address = Column(String(80), nullable=False) 
    id = Column(Integer, primary_key=True) 
    lat = Column(String(25)) 
    lng = Column(String(25)) 
    artisan = Column(Integer, ForeignKey(Artisan.id)) 
    user = Column(Integer, ForeignKey(Users.id)) 
    users = relationship(Users) 

    @property 
    def serialize(self): 
     return{ 
      'id': self.id, 
      'lat': self.lat, 
      'lng': self.lng, 
      'kwetu_address': self.kwetu_address, 
      'artisan': self.artisan 
     } 


engine = create_engine('sqlite:///mycatalog.db') 

Base.metadata.create_all(engine) 

Answer 1

Das gab mir, was ich in Bezug brauchte, um meine Handwerker mit den jeweiligen Adressen zuordnet, obwohl immer noch mit zwei Abfragen

my_artisans = (session.query(Artisan).filter_by(category=cat_id)) 
my_addresses = (session.query(Address) 
         .join(Artisan, Artisan.id ==Address.artisan).filter_by(category=cat_id)) 
these_addresses = [] 
for art in my_artisans: 
    art_id = art.id 
    for add in my_addresses: 
     if art_id == add.artisan: 
      grouped_address = {"Artisan Id" : art.id, "name" : art.name, "skill" : art.skill, "Lat" : add.lat, "lng" : add.lng} 
       these_addresses.append(grouped_address) 

    return jsonify({'Addresses': these_addresses })