Session: Loading entities

The load method allow user to download a documents from database and convert them to entities.


def load(self, key_or_keys, object_type=None, includes=None, nested_object_types=None):
key_or_keys string or list Identifier of a document\s that will be loaded.
object_type classObj The class we want to get
includes list or str The path to a reference inside the loaded documents can be list (property name)
nested_object_types dict {str : classObj} A dict of classes for nested object the key will be the name of the class and the value will be the object we want to get for that attribute.
Return Value
object_type or None instance of object_type or None if document with given Id does not exist. (If the object_type equal to None return DynamicStructure entity)

Example I

with store.open_session() as session:
    # dynamic_employee will be a DynamicStructure
    employee = session.load("employees/1")

In this example the load will return DynamicStructure entity because we don't specify any classObj in object_type

Example II

A load with object_type:

with store.open_session() as session:
    # employee will be Employee object
    employee = session.load("employees/1", object_type=Employee )


class Student(object):
    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

class Teacher(object):
    def __init__(self, first, last):
        self.first_name = first
        self.last_name = last

with store.open_session() as session:
    # student will be Student object
    student = session.load("employees/1", object_type=Student)

    teacher = session.load("employees/1", object_type=Teacher)
    # Will raise TypeError because the way we convert the document to entity

If the class variables names are different from the method signature name. TypeError exception will be raise

load - multiple entities

To load multiple entities at once use the load just pass to key_or_keys a list of keys.

with store.open_session() as session:
    keys_to_load = ["employees/1", "employees/2", "employees/3"]
    employee = session.load(keys_to_load, object_type=Employee )

In this example the load method will return a list with the specific demanded documents


If some document couldn't be loaded we will put None in the list

load with includes

When there is a 'relationship' between documents, then those documents can be loaded in a single request call using load.

class Order(object):
    def __init__(self, company): = company

class Company(object):
    def __init__(self, name, address): = name
        self.address = address

with store.open_session() as session:"Hibernating Rhinos", "Israel" ))"companies/1"), key="orders/1")

with store.open_session() as session:
    order = session.load("orders/1", object_type=Order, includes="company")

The return value will be the same but next time we will try to load an include document we will get the document without doing any requests to the server

load with nested object types

Sometimes we will use some objects that have nested object with load you can specify your nested object type and try to convert those to the right type.

class Dog(object):
    def __init__(self, brand, color, age):
        self.brand = brand
        self.color = color
        self.age = age

class Car(object):
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color

class Person(object):
    def __init__(self, name, dog, car): = name = dog  # instance of Dog = car  # instance of Car

with store.open_session() as session:
    person = session.load("people/1", object_type=Person,
                          nested_object_types={"dog": Dog, "car": Car})