Skip to main content

gqlalchemy.vendors.database_client

DatabaseClient Objects

class DatabaseClient(ABC)

execute_and_fetch

def execute_and_fetch(query: str, connection: Connection = None) -> Iterator[Dict[str, Any]]

Executes Cypher query and returns iterator of results.

execute

def execute(query: str, connection: Connection = None) -> None

Executes Cypher query without returning any results.

create_index

def create_index(index: Index) -> None

Creates an index (label or label-property type) in the database.

drop_index

def drop_index(index: Index) -> None

Drops an index (label or label-property type) in the database.

get_indexes

@abstractmethod
def get_indexes() -> List[Index]

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

ensure_indexes

@abstractmethod
def ensure_indexes(indexes: List[Index]) -> None

Ensures that database indexes match input indexes.

drop_indexes

def drop_indexes() -> None

Drops all indexes in the database

create_constraint

def create_constraint(index: Constraint) -> None

Creates a constraint (label or label-property type) in the database.

drop_constraint

def drop_constraint(index: Constraint) -> None

Drops a constraint (label or label-property type) in the database.

get_constraints

@abstractmethod
def get_constraints() -> List[Constraint]

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

ensure_constraints

def ensure_constraints(constraints: List[Constraint]) -> None

Ensures that database constraints match input constraints.

drop_database

def drop_database()

Drops database by removing all nodes and edges.

new_connection

@abstractmethod
def new_connection() -> Connection

Creates new database connection.

get_variable_assume_one

def get_variable_assume_one(query_result: Iterator[Dict[str, Any]], variable_name: str) -> Any

Returns a single result from the query_result (usually gotten from the execute_and_fetch function). If there is more than one result, raises a GQLAlchemyError.

create_node

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

Creates a node in database from the node object.

save_node

@abstractmethod
def save_node(node: Node) -> Node

Saves node to 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.

save_nodes

def save_nodes(nodes: List[Node]) -> None

Saves a list of nodes to the database.

save_node_with_id

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

Saves a node to the database using the internal id.

load_node

@abstractmethod
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_node_with_all_properties

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

Loads a node from the database with all equal property values.

load_node_with_id

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

Loads a node with the same internal database id.

load_relationship

@abstractmethod
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 database, or if there are multiple relationships like that in database, throws GQLAlchemyError.

load_relationship_with_id

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

Loads a relationship from the database using the internal id.

load_relationship_with_start_node_id_and_end_node_id

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

Loads a relationship from the database using start node and end node id for which all properties of the relationship that are not None match.

save_relationship

@abstractmethod
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.

save_relationships

def save_relationships(relationships: List[Relationship]) -> None

Saves a list of relationships to the database.

save_relationship_with_id

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

Saves a relationship to the database using the relationship._id.

create_relationship

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

Creates a new relationship in the database.