Ottimizzazioni SqlAlchemy per i modelli di oggetti di sola lettura

Question

Ho una complessa rete di oggetti generata da un database SQLite che utilizza i mapping ORM sqlalchemy. Ho un bel po 'di nidificazione:

for parent in owner.collection: 
    for child in parent.collection: 
     for foo in child.collection: 
      do lots of calcs with foo.property 

mio profilazione mi sta dimostrando che la strumentazione sqlalchemy sta prendendo un sacco di tempo in questo caso d'uso.

Il fatto è: non cambio mai il modello di oggetto (proprietà mappate) in fase di esecuzione, quindi una volta caricati non ho bisogno della strumentazione, o del tutto di un sovraccarico di sqlalchemy. Dopo molte ricerche, penso che potrei dover clonare un insieme di oggetti "puro pitone" dai miei "oggetti strumentati" già caricati, ma sarebbe un dolore.

Le prestazioni sono davvero cruciali qui (è un simulatore), quindi forse scrivere quei livelli come estensioni C usando direttamente sqlite api sarebbe il migliore. qualche idea?

Answer 1

Se si fa riferimento a un singolo attributo di una singola istanza molte volte, un semplice trucco è memorizzarlo in una variabile locale.

Se si desidera un modo per creare a basso costo cloni puro Python, condividere l'oggetto dict con l'oggetto originale:

class CheapClone(object): 
    def __init__(self, original): 
     self.__dict__ = original.__dict__ 

Creazione di una copia del genere costa circa la metà della accesso agli attributi strumentato e attribuiamo le ricerche sono i veloce come al solito.

Potrebbe anche esserci un modo per fare in modo che il mapper crei istanze di una classe non strumentale al posto di quella strumentata. Se ho un po 'di tempo, potrei dare un'occhiata a quanto profondamente radicato sia l'assunto che le istanze popolate siano dello stesso tipo della classe strumentata.

---

Trovato un modo rapido e sporco che sembra funzionare almeno in qualche modo su 0.5.8 e 0.6. Non l'ho provato con l'ereditarietà o altre caratteristiche che potrebbero interagire male. Inoltre, questo tocca alcune API non pubbliche, quindi fai attenzione alle interruzioni quando cambi le versioni.

from sqlalchemy.orm.attributes import ClassManager, instrumentation_registry 

class ReadonlyClassManager(ClassManager): 
    """Enables configuring a mapper to return instances of uninstrumented 
    classes instead. To use add a readonly_type attribute referencing the 
    desired class to use instead of the instrumented one.""" 
    def __init__(self, class_): 
     ClassManager.__init__(self, class_) 
     self.readonly_version = getattr(class_, 'readonly_type', None) 
     if self.readonly_version: 
      # default instantiation logic doesn't know to install finders 
      # for our alternate class 
      instrumentation_registry._dict_finders[self.readonly_version] = self.dict_getter() 
      instrumentation_registry._state_finders[self.readonly_version] = self.state_getter() 

    def new_instance(self, state=None): 
     if self.readonly_version: 
      instance = self.readonly_version.__new__(self.readonly_version) 
      self.setup_instance(instance, state) 
      return instance 
     return ClassManager.new_instance(self, state) 

Base = declarative_base() 
Base.__sa_instrumentation_manager__ = ReadonlyClassManager 

Esempio di utilizzo:

class ReadonlyFoo(object): 
    pass 

class Foo(Base, ReadonlyFoo): 
    __tablename__ = 'foo' 
    id = Column(Integer, primary_key=True) 
    name = Column(String(32)) 

    readonly_type = ReadonlyFoo 

assert type(session.query(Foo).first()) is ReadonlyFoo 

Answer 2

Provare a utilizzare una singola query con JOINs invece dei loop python.

Answer 3

Dovresti essere in grado di disabilitare il caricamento lazy sulle relazioni in questione e sqlalchemy le recupererà tutte in una singola query.