Skip to main content

gqlalchemy.vendors.memgraph

Memgraph Objects​

class Memgraph(DatabaseClient)

get_indexes​

def get_indexes() -> List[MemgraphIndex]

Returns a list of all database indexes (label and label-property types).

ensure_indexes​

def ensure_indexes(indexes: List[MemgraphIndex]) -> None

Ensures that database indexes match input indexes.

get_constraints​

def get_constraints(
) -> List[Union[MemgraphConstraintExists, MemgraphConstraintUnique]]

Returns a list of all database constraints (label and label-property types).

new_connection​

def new_connection() -> Connection

Creates new Memgraph connection.

create_stream​

def create_stream(stream: MemgraphStream) -> None

Create a stream.

start_stream​

def start_stream(stream: MemgraphStream) -> None

Start a stream.

get_streams​

def get_streams() -> List[str]

Returns a list of all streams.

drop_stream​

def drop_stream(stream: MemgraphStream) -> None

Drop a stream.

create_trigger​

def create_trigger(trigger: MemgraphTrigger) -> None

Creates a trigger.

get_triggers​

def get_triggers() -> List[str]

Returns a list of all database triggers.

drop_trigger​

def drop_trigger(trigger: MemgraphTrigger) -> None

Drop a trigger.

drop_triggers​

def drop_triggers() -> None

Drops all triggers in the database.

init_disk_storage​

def init_disk_storage(on_disk_db: OnDiskPropertyDatabase) -> None

Adds and OnDiskPropertyDatabase to the database so that any property that has a Field(on_disk=True) can be stored to and loaded from an OnDiskPropertyDatabase.

remove_on_disk_storage​

def remove_on_disk_storage() -> None

Removes the OnDiskPropertyDatabase from the database.

save_node​

def save_node(node: Node) -> Node

Saves node to the database. If the node._id is not None it fetches the node with the same id from the database and updates it's fields. If the node has unique fields it fetches the nodes with the same unique fields from the database and updates it's fields. Otherwise it creates a new node with the same properties. Null properties are ignored.

load_node​

def load_node(node: Node) -> Optional[Node]

Loads a node from the database. If the node._id is not None it fetches the node from the database with that internal id. If the node has unique fields it fetches the node from the database with those unique fields set. Otherwise it tries to find any node in the database that has all properties set to exactly the same values. If no node is found or no properties are set it raises a GQLAlchemyError.

load_relationship​

def load_relationship(relationship: Relationship) -> Optional[Relationship]

Returns a relationship loaded from the database. If the relationship._id is not None it fetches the relationship from the database that has the same internal id. Otherwise it returns the relationship whose relationship._start_node_id and relationship._end_node_id and all relationship properties that are not None match the relationship in the database. If there is no relationship like that in the database, or if there are multiple relationships like that in the database, throws GQLAlchemyError.

save_relationship​

def save_relationship(relationship: Relationship) -> Optional[Relationship]

Saves a relationship to the database. If relationship._id is not None it finds the relationship in the database and updates it's properties with the values in relationship. If relationship._id is None, it creates a new relationship. If you want to set a relationship._id instead of creating a new relationship, use load_relationship first.

get_procedures​

def get_procedures(starts_with: Optional[str] = None,
                   update: bool = False) -> List["QueryModule"]

Return query procedures.

Maintains a list of query modules in the Memgraph object. If starts_with is defined then return those modules that start with starts_with string.

Arguments:

  • starts_with - Return those modules that start with this string. (Optional)
  • update - Whether to update the list of modules in self.query_modules. (Optional)

add_query_module​

def add_query_module(file_path: str, module_name: str) -> "Memgraph"

Function for adding a query module in Python written language to Memgraph. Example can be found in the functions below (with_kafka_stream, with_power_bi).

The module is synced dynamically then with the database to enable higher processing capabilities.

Arguments:

  • file_name str - path to file containing module.
  • module_name str - name of the module.

Returns:

  • Memgraph - Memgraph object.

with_kafka_stream​

def with_kafka_stream() -> "Memgraph"

Load kafka stream query module.

Returns:

  • Memgraph - Memgraph instance

with_power_bi​

def with_power_bi() -> "Memgraph"

Load power_bi stream query module.

Returns:

  • Memgraph - Memgraph instance