pymgclient

https://memgraph.github.io/pymgclient/
Admin
pymgclient is a DB-API 2.0 compliant Python adapter for Memgraph database, implemented as a C...
Tokens:11,761
Snippets:149
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install pymgclient Binaries (Windows Alternative)

Source: https://memgraph.github.io/pymgclient/introduction.html

Alternative installation command for Windows if the Python launcher is not installed.

```bash
$ pip install --user pymgclient

```

--------------------------------

### Build and Install pymgclient from Source Distribution

Source: https://memgraph.github.io/pymgclient/_sources/introduction.rst.txt

First, build the source distribution, then install the generated tarball. This is an alternative installation method.

```bash
python3 -m build --sdist
```

```bash
pip install dist/*.tar.gz
```

--------------------------------

### Install pymgclient on Windows

Source: https://memgraph.github.io/pymgclient/_sources/introduction.rst.txt

Install pymgclient using pip, with the --user flag for user-specific installation. The --no-binary flag ensures it's built from source.

```bash
pip install --user --no-binary pymgclient pymgclient
```

--------------------------------

### Install pymgclient from source using pip (Bash)

Source: https://memgraph.github.io/pymgclient/_sources/introduction.rst.txt

Install pymgclient from source using pip, either by forcing a source distribution build from PyPI or by installing directly from the repository or a built source distribution.

```bash
pip install --no-binary pymgclient pymgclient
```

```bash
pip install -e .
```

```bash
python3 -m build --sdist
pip install dist/*.tar.gz
```

--------------------------------

### Install pymgclient from Source

Source: https://memgraph.github.io/pymgclient/_sources/introduction.rst.txt

Use this command to install pymgclient in editable mode from the local repository.

```bash
pip install -e .
```

--------------------------------

### Install Build Prerequisites (CentOS/Fedora)

Source: https://memgraph.github.io/pymgclient/introduction.html

Installs necessary build tools and libraries for compiling pymgclient on CentOS or Fedora systems.

```bash
$ sudo dnf install -y python3-devel cmake3 make gcc gcc-c++ openssl-devel

```

--------------------------------

### Install Build Prerequisites (Debian/Ubuntu)

Source: https://memgraph.github.io/pymgclient/introduction.html

Installs necessary build tools and libraries for compiling pymgclient on Debian or Ubuntu systems.

```bash
$ sudo apt install python3-dev cmake make gcc g++ libssl-dev

```

--------------------------------

### Install build prerequisites on CentOS/Fedora (Bash)

Source: https://memgraph.github.io/pymgclient/_sources/introduction.rst.txt

Install the necessary build tools and libraries for compiling pymgclient from source on CentOS/Fedora-based systems.

```bash
sudo dnf install -y python3-devel cmake3 make gcc gcc-c++ openssl-devel
```

--------------------------------

### Install Build Prerequisites (macOS)

Source: https://memgraph.github.io/pymgclient/introduction.html

Installs C/C++ compiler and other build tools for macOS using xcode-select and brew.

```bash
# To install the C/C++ compiler, run:
$ xcode-select --install

# The rest of the build prerequisites can be installed easily via brew:
$ brew install python3 openssl cmake

```

--------------------------------

### Install build prerequisites on Debian/Ubuntu (Bash)

Source: https://memgraph.github.io/pymgclient/_sources/introduction.rst.txt

Install the necessary build tools and libraries for compiling pymgclient from source on Debian-based systems.

```bash
sudo apt install python3-dev cmake make gcc g++ libssl-dev
```

--------------------------------

### Install pymgclient from Source (Linux/macOS via built sdist)

Source: https://memgraph.github.io/pymgclient/introduction.html

Installs pymgclient from a locally built source distribution archive.

```bash
$ python3 -m build --sdist
$ pip install dist/*.tar.gz

```

--------------------------------

### Install pymgclient Binaries (Linux/macOS)

Source: https://memgraph.github.io/pymgclient/introduction.html

Installs the pymgclient package using pip for Linux and macOS. Ensure you have pip3 installed.

```bash
$ pip3 install --user pymgclient

```

--------------------------------

### Install pymgclient from Source (Linux/macOS via repo)

Source: https://memgraph.github.io/pymgclient/introduction.html

Installs pymgclient directly from the repository in editable mode after build prerequisites are met.

```bash
$ pip install -e .

```

--------------------------------

### Install pymgclient on Linux/macOS (Bash)

Source: https://memgraph.github.io/pymgclient/_sources/introduction.rst.txt

Install pymgclient using pip for the current user on Linux and macOS systems.

```bash
pip3 install --user pymgclient
```

--------------------------------

### Install pymgclient from Source (Linux/macOS via pip)

Source: https://memgraph.github.io/pymgclient/introduction.html

Installs pymgclient from source using pip after build prerequisites are met. Use --no-binary to ensure source build.

```bash
$ pip install --no-binary pymgclient pymgclient

```

--------------------------------

### Install Dynamic OpenSSL Linking (Linux/macOS)

Source: https://memgraph.github.io/pymgclient/introduction.html

Installs pymgclient from source while dynamically linking to the host's OpenSSL library for better security.

```bash
$ PYMGCLIENT_STATIC_OPENSSL=0 \
    pip install --no-binary pymgclient pymgclient

```

--------------------------------

### Install pymgclient from Source Distribution (pip)

Source: https://memgraph.github.io/pymgclient/introduction.html

Installs pymgclient from a source distribution using pip. This is useful if prebuilt binaries are not available or if you need to build from source.

```bash
# with pip install (force source distribution build from PyPI)
pip install --no-binary pymgclient pymgclient

# or from this repo
pip install -e .

# or after building the source distribution
python3 -m build --sdist
pip install dist/*.tar.gz

```

--------------------------------

### Install pymgclient on Windows (Bash)

Source: https://memgraph.github.io/pymgclient/_sources/introduction.rst.txt

Install pymgclient using pip for the current user on Windows systems. Use 'py -3 -m pip' if the 'pip' command is not directly available.

```bash
py -3 -m pip install --user pymgclient
```

```bash
pip install --user pymgclient
```

--------------------------------

### Install pymgclient Binaries (Windows)

Source: https://memgraph.github.io/pymgclient/introduction.html

Installs the pymgclient package using pip for Windows. Use 'py -3 -m pip' if the 'pip3' command is not found.

```bash
$ py -3 -m pip install --user pymgclient

```

--------------------------------

### Install pymgclient with dynamic OpenSSL linking on macOS (Bash)

Source: https://memgraph.github.io/pymgclient/_sources/introduction.rst.txt

Install pymgclient from source on macOS, forcing dynamic linking to the host's OpenSSL library for improved security. This command also ensures a source distribution build and installs for the current user.

```bash
PYMGCLIENT_STATIC_OPENSSL=0 \
    pip3 install --user --no-binary pymgclient pymgclient
```

--------------------------------

### Install pymgclient from Source (macOS via pip)

Source: https://memgraph.github.io/pymgclient/introduction.html

Installs pymgclient from source on macOS using pip, ensuring it builds the binary package locally. Use --no-binary to force source build.

```bash
$ pip3 install --user --no-binary pymgclient pymgclient

```

--------------------------------

### Install MSYS2 Packages for Windows

Source: https://memgraph.github.io/pymgclient/_sources/introduction.rst.txt

Install necessary development tools and libraries using pacman within the MSYS2 environment on Windows.

```bash
pacman -Su
```

```bash
pacman -S --needed base-devel mingw-w64-x86_64-toolchain \
    mingw-w64-x86_64-cmake mingw-w64-x86_64-openssl
```

--------------------------------

### Install pymgclient with dynamic OpenSSL linking (Bash)

Source: https://memgraph.github.io/pymgclient/_sources/introduction.rst.txt

Set environment variables to dynamically link against the host machine's OpenSSL library when building from source. This is recommended for security if you need to use the latest OpenSSL version.

```bash
export PYMGCLIENT_STATIC_OPENSSL=0
export OPENSSL_ROOT_DIR=/
export OPENSSL_CRYPTO_LIBRARY=/lib64/libcrypto.so
```

--------------------------------

### Install Dynamic OpenSSL Linking (macOS)

Source: https://memgraph.github.io/pymgclient/introduction.html

Installs pymgclient from source on macOS, dynamically linking to the host's OpenSSL library for enhanced security.

```bash
$ PYMGCLIENT_STATIC_OPENSSL=0 \
    pip3 install --user --no-binary pymgclient pymgclient

```

--------------------------------

### Install pymgclient Dynamically Linking OpenSSL on Windows

Source: https://memgraph.github.io/pymgclient/_sources/introduction.rst.txt

Install pymgclient while ensuring dynamic linking of OpenSSL for enhanced security by setting the PYMGCLIENT_STATIC_OPENSSL environment variable to 0.

```bash
PYMGCLIENT_STATIC_OPENSSL=0 \
    pip install --user --no-binary pymgclient pymgclient
```

--------------------------------

### Run pymgclient Test Suite

Source: https://memgraph.github.io/pymgclient/_sources/introduction.rst.txt

Execute the test suite from the source directory using pytest to verify the installation. Ensure Memgraph, pytest, and pyopenssl are installed.

```bash
python3 -m pytest
```

--------------------------------

### Install pymgclient with dynamic OpenSSL linking on Linux (Bash)

Source: https://memgraph.github.io/pymgclient/_sources/introduction.rst.txt

Install pymgclient from source, forcing dynamic linking to the host's OpenSSL library for improved security. This command also ensures a source distribution build.

```bash
PYMGCLIENT_STATIC_OPENSSL=0 \
    pip install --no-binary pymgclient pymgclient
```

--------------------------------

### Example Usage of a Lazy Connection

Source: https://memgraph.github.io/pymgclient/connection.html

Demonstrates creating a lazy connection, executing a query, fetching results row by row, and handling the limitation of executing only one query at a time.

```python
>>> import mgclient

>>> conn = mgclient.connect(host="127.0.0.1", port=7687, lazy=True)

>>> cursor = conn.cursor()

>>> cursor.execute("UNWIND range(1, 3) AS n RETURN n * n")

>>> cursor.fetchone()
(1, )

>>> cursor.fetchone()
(4, )

>>> cursor.fetchone()
(9, )

# We still didn't get None from fetchone()
>>> cursor.execute("RETURN 100")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
mgclient.InterfaceError: cannot call execute during execution of a query

>>> cursor.fetchone()
None

# Now we can execute a new query
>>> cursor.execute("RETURN 100")

```

--------------------------------

### Lazy Connection Example

Source: https://memgraph.github.io/pymgclient/_sources/connection.rst.txt

Demonstrates how to create and use a lazy connection with the mgclient library. Lazy connections are useful for processing large result sets row-by-row to conserve memory.

```APIDOC
## Lazy Connection Usage

### Description
This example shows how to establish a lazy connection, execute a query, and fetch results using a cursor. It also illustrates the limitation of executing multiple queries concurrently on a lazy connection.

### Method
`mgclient.connect(host, port, lazy=True)`
`conn.cursor()`
`cursor.execute(query)`
`cursor.fetchone()`

### Parameters
- `host` (string) - The host address for the database connection.
- `port` (integer) - The port number for the database connection.
- `lazy` (boolean) - If True, creates a lazy connection.
- `query` (string) - The Cypher query to execute.

### Request Example
```python
import mgclient

conn = mgclient.connect(host="127.0.0.1", port=7687, lazy=True)
c = conn.cursor()
c.execute("UNWIND range(1, 3) AS n RETURN n * n")
print(c.fetchone())
print(c.fetchone())
print(c.fetchone())

# Example of limitation: trying to execute a new query before fetching all results
try:
    c.execute("RETURN 100")
except mgclient.InterfaceError as e:
    print(e)

# Fetching the remaining results to clear the cursor
while c.fetchone() is not None:
    pass

# Now a new query can be executed
c.execute("RETURN 100")
print(c.fetchone())
```

### Response
#### Success Response (fetchone)
- Returns a tuple representing a single row of the query result, or None if no more rows are available.

#### Response Example (fetchone)
```
(1, )
(4, )
(9, )
cannot call execute during execution of a query
None
(100, )
```

### Limitations of Lazy Connections
1. **Autocommit Mode**: Lazy connections are always in autocommit mode. Transactions must be managed explicitly using `BEGIN`, `COMMIT`, or `ROLLBACK` queries.
2. **Single Query Execution**: Only one query can be executed at a time. All results from the previous query must be fetched before executing a new one. Attempting to execute a new query before fetching all results will raise an `InterfaceError`.
```

--------------------------------

### Lazy Connections

Source: https://memgraph.github.io/pymgclient/connection.html

Explanation and example of using lazy connections for efficient handling of large result sets.

```APIDOC
## Lazy connections

A lazy connection is created by passing `True` for `lazy` parameter when calling `connect()`.

**Limitations:**
1. They are always in autocommit mode.
2. At most one query can execute at a given time.

**Example Usage:**
```python
>>> import mgclient

>>> conn = mgclient.connect(host="127.0.0.1", port=7687, lazy=True)

>>> cursor = conn.cursor()

>>> cursor.execute("UNWIND range(1, 3) AS n RETURN n * n")

>>> cursor.fetchone()
(1, )

>>> cursor.fetchone()
(4, )

>>> cursor.fetchone()
(9, )

# We still didn't get None from fetchone()
>>> cursor.execute("RETURN 100")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
mgclient.InterfaceError: cannot call execute during execution of a query

>>> cursor.fetchone()
None

# Now we can execute a new query
>>> cursor.execute("RETURN 100")
```
```

--------------------------------

### Verify GCC Installation on Windows

Source: https://memgraph.github.io/pymgclient/_sources/introduction.rst.txt

Check if the GCC compiler is accessible after setting up the MSYS2 environment and updating the PATH.

```bash
gcc --version
```

--------------------------------

### Transaction Control with PyMgclient

Source: https://memgraph.github.io/pymgclient/_sources/usage.rst.txt

Explains transaction management in PyMgclient. By default, transactions start automatically and must be committed or rolled back. Autocommit mode can be enabled by setting the connection's `autocommit` property to `True` for commands that require running outside a transaction.

```python
# Example of setting autocommit mode (conceptual, not a full snippet)
# conn.autocommit = True
```

--------------------------------

### Connect and Query with mgclient

Source: https://memgraph.github.io/pymgclient/usage.html

Demonstrates the basic workflow: establishing a connection, creating a cursor, executing a CREATE query, fetching results, and committing the transaction.

```python
>>> import mgclient

# Make a connection to the database
>>> conn = mgclient.connect(host='127.0.0.1', port=7687)

# Create a cursor for query execution
>>> cursor = conn.cursor()

# Execute a query
>>> cursor.execute("""
        CREATE (n:Person {name: 'John'})-[e:KNOWS]->
               (m:Person {name: 'Steve'})
        RETURN n, e, m
    """)

# Fetch one row of query results
>>> row = cursor.fetchone()

>>> print(row[0])
(:Person {'name': 'John'})

>>> print(row[1])
[:KNOWS]

>>> print(row[2])
(:Person {'name': 'Steve'})

# Make database changes persistent
>>> conn.commit()

```

--------------------------------

### Basic PyMgclient Module Usage

Source: https://memgraph.github.io/pymgclient/_sources/usage.rst.txt

Demonstrates the fundamental steps for using the mgclient module: connecting to the database, creating a cursor, executing a query, fetching results, and committing changes. Ensure you have a Memgraph instance running on the specified host and port.

```python
>>> import mgclient

# Make a connection to the database
>>> conn = mgclient.connect(host='127.0.0.1', port=7687)

# Create a cursor for query execution
>>> cursor = conn.cursor()

# Execute a query
>>> cursor.execute("""
        CREATE (n:Person {name: 'John'})-[e:KNOWS]->
               (m:Person {name: 'Steve'})
        RETURN n, e, m
    """)

# Fetch one row of query results
>>> row = cursor.fetchone()

>>> print(row[0])
(:Person {'name': 'John'})

>>> print(row[1])
[:KNOWS]

>>> print(row[2])
(:Person {'name': 'Steve'})

# Make database changes persistent
>>> conn.commit()
```

--------------------------------

### mgclient.connect

Source: https://memgraph.github.io/pymgclient/module.html

Establishes a new connection to the database server and returns a Connection object.

```APIDOC
## mgclient.connect

### Description
Makes a new connection to the database server and returns a `Connection` object.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **host** (string) - Optional - DNS resolvable name of host to connect to. Exactly one of host and address parameters must be specified.
- **address** (string) - Optional - Numeric IP address of host to connect to. This should be in the standard IPv4 address format. You can also use IPv6 if your machine supports it. Exactly one of host and address parameters must be specified.
- **port** (integer) - Optional - Port number to connect to at the server host.
- **username** (string) - Optional - Username to connect as.
- **password** (string) - Optional - Password to be used if the server demands password authentication.
- **client_name** (string) - Optional - Alternate name and version of the client to send to server. Default is set by the underlying mgclient library.
- **sslmode** (integer) - Optional - This option determines whether a secure connection will be negotiated with the server. Possible values: `mgclient.MG_SSLMODE_DISABLE` (Only try a non-SSL connection (default)), `mgclient.MG_SSLMODE_REQUIRE` (Only try an SSL connection).
- **sslcert** (string) - Optional - This parameter specifies the file name of the client SSL certificate. It is ignored in case an SSL connection is not made.
- **sslkey** (string) - Optional - This parameter specifies the location of the secret key used for the client certificate. This parameter is ignored in case an SSL connection is not made.
- **trust_callback** (callable) - Optional - A callable taking four arguments. After performing the SSL handshake, `connect()` will call this callable providing the hostname, IP address, public key type and fingerprint. If the function returns `False` SSL connection will immediately be terminated. This can be used to implement TOFU (trust on first use) mechanism.
- **lazy** (boolean) - Optional - If this is set to `True`, a lazy connection is made. Default is `False`.

### Request Example
```python
import mgclient

conn = mgclient.connect(host='localhost', port=7687, username='neo4j', password='password')
```

### Response
#### Success Response (200)
- **Connection object** - A `Connection` object representing the database connection.
```

--------------------------------

### Execute Query and Fetch Results with Lazy Connection

Source: https://memgraph.github.io/pymgclient/_sources/connection.rst.txt

Demonstrates executing a query and fetching results one by one using `fetchone()` on a lazy connection. Note that attempting to execute a new query before fetching all results from the previous one will raise an `InterfaceError`.

```python
cursor = conn.cursor()

cursor.execute("UNWIND range(1, 3) AS n RETURN n * n")

cursor.fetchone()
# Expected output: (1, )

cursor.fetchone()
# Expected output: (4, )

cursor.fetchone()
# Expected output: (9, )

# The following would raise an InterfaceError because results are not fully fetched:
# cursor.execute("RETURN 100")

cursor.fetchone()
# Expected output: None

# Now a new query can be executed:
cursor.execute("RETURN 100")
```

--------------------------------

### mgclient.connect

Source: https://memgraph.github.io/pymgclient/_sources/module.rst.txt

Establishes a connection to the Memgraph database. Refer to the lazy connections section for details on the 'lazy' parameter.

```APIDOC
## mgclient.connect

### Description
Connects to the Memgraph database.

### Parameters

#### Keyword Arguments
* **lazy** (bool) - Optional - If True, the connection is established lazily.

### Usage
```python
connection = mgclient.connect()
```
```

--------------------------------

### Configure Dynamic OpenSSL Linking (Environment Variables)

Source: https://memgraph.github.io/pymgclient/introduction.html

Set environment variables to dynamically link against the host machine's OpenSSL library during the build process. This is recommended for security updates.

```bash
# set the environment variable to dynamically link
# to the host machine's OpenSSL library
export PYMGCLIENT_STATIC_OPENSSL=0

# some distributions may also need help locating
# the OpenSSL library
export OPENSSL_ROOT_DIR=/ 
export OPENSSL_CRYPTO_LIBRARY=/lib64/libcrypto.so

```

--------------------------------

### setoutputsizes() Method

Source: https://memgraph.github.io/pymgclient/cursor.html

This method does nothing but is required for DB-API 2.0 compatibility.

```APIDOC
def setoutputsizes():
    """This method does nothing, but it is required by the DB-API 2.0 spec."""
    pass
```

--------------------------------

### execute() Method

Source: https://memgraph.github.io/pymgclient/cursor.html

Executes a database operation. Parameters can be provided as a mapping and will be bound to named placeholders ($name). This method always returns None.

```APIDOC
def execute(_params=None):
    """Execute a database operation."""
    pass
```

--------------------------------

### Create a Lazy Connection

Source: https://memgraph.github.io/pymgclient/_sources/connection.rst.txt

Use `mgclient.connect` with `lazy=True` to create a connection that fetches results on demand. This is useful for processing large result sets without loading everything into memory at once.

```python
import mgclient

conn = mgclient.connect(host="127.0.0.1", port=7687, lazy=True)
```

--------------------------------

### mgclient.Connection Methods

Source: https://memgraph.github.io/pymgclient/genindex.html

Methods available on the Connection object for managing database interactions.

```APIDOC
## close()
### Description
Closes the database connection.
### Method
(mgclient.Connection method)
```

```APIDOC
## commit()
### Description
Commits the current transaction.
### Method
(mgclient.Connection method)
```

```APIDOC
## cursor()
### Description
Creates a cursor object for executing commands.
### Method
(mgclient.Connection method)
```

```APIDOC
## rollback()
### Description
Rolls back the current transaction.
### Method
(mgclient.Connection method)
```

--------------------------------

### fetchall() Method

Source: https://memgraph.github.io/pymgclient/cursor.html

Fetches all remaining rows of query results as a list of tuples. Raises InterfaceError if execute() did not produce results or has not been called.

```APIDOC
def fetchall():
    """Fetch all (remaining) rows of query results."""
    pass
```

--------------------------------

### fetchone() Method

Source: https://memgraph.github.io/pymgclient/cursor.html

Fetches the next row of query results as a single tuple, or None if no more data is available. Raises InterfaceError if execute() did not produce results or has not been called.

```APIDOC
def fetchone():
    """Fetch the next row of query results."""
    pass
```

--------------------------------

### Module Constants

Source: https://memgraph.github.io/pymgclient/_sources/module.rst.txt

DB-API 2.0 required constants for the mgclient module.

```APIDOC
## Module Constants

### `mgclient.apilevel`

String constant stating the supported DB API level. For :mod:`mgclient` it is ``2.0``.

### `mgclient.threadsafety`

Integer constant stating the level of thread safety the interface supports. For :mod:`mgclient` it is 1, meaning that threads may share the module, but not connections.

### `mgclient.paramstyle`

String constant stating the type of parameter marker formatting expected by the interface. For :mod:`mgclient` it is ``cypher``, which is not a valid value by DB-API 2.0 specification. See Passing parameters section for more details.
```

--------------------------------

### setinputsizes() Method

Source: https://memgraph.github.io/pymgclient/cursor.html

This method does nothing but is required for DB-API 2.0 compatibility.

```APIDOC
def setinputsizes():
    """This method does nothing, but it is required by the DB-API 2.0 spec."""
    pass
```

--------------------------------

### mgclient.Connection Attributes (continued)

Source: https://memgraph.github.io/pymgclient/genindex.html

Additional attributes for the Connection object.

```APIDOC
## status
### Description
Indicates the status of the connection.
### Attribute
(mgclient.Connection attribute)
```

--------------------------------

### mgclient.Cursor Methods

Source: https://memgraph.github.io/pymgclient/genindex.html

Methods available on the Cursor object for executing queries and fetching results.

```APIDOC
## close()
### Description
Closes the cursor.
### Method
(mgclient.Cursor method)
```

```APIDOC
## execute(operation[, parameters])
### Description
Executes a database operation.
### Method
(mgclient.Cursor method)
```

```APIDOC
## fetchall()
### Description
Fetches all remaining rows of a query result.
### Method
(mgclient.Cursor method)
```

```APIDOC
## fetchmany([size])
### Description
Fetches the next set of rows of a query result.
### Method
(mgclient.Cursor method)
```

```APIDOC
## fetchone()
### Description
Fetches the next row of a query result.
### Method
(mgclient.Cursor method)
```

```APIDOC
## setinputsizes(*args)
### Description
Prepares the cursor for parameterized queries.
### Method
(mgclient.Cursor method)
```

```APIDOC
## setoutputsizes(*args)
### Description
Prepares the cursor for receiving specific output sizes.
### Method
(mgclient.Cursor method)
```

--------------------------------

### Connection Attributes and Methods

Source: https://memgraph.github.io/pymgclient/connection.html

Details on the attributes and methods available for managing a database connection.

```APIDOC
## Connection Class

### `autocommit`

This read/write attribute specifies whether executed statements have immediate effect in the database.
If `True`, every executed statement has immediate effect.
If `False`, a new transaction is started at the execution of the first command. Transactions must be manually terminated using `commit()` or `rollback()` methods.

### `close()`

Close the connection now. The connection will be unusable from this point forward; an `InterfaceError` will be raised if any operation is attempted with the connection. The same applies to all `Cursor` objects trying to use the connection. Note that closing a connection without committing the changes will cause an implicit rollback to be performed.

### `commit()`

Commit any pending transaction to the database. If auto-commit is turned on, this method does nothing.

### `cursor()`

Return a new `Cursor` object using the connection.

### `rollback()`

Roll back to the start of any pending transaction. If auto-commit is turned on, this method does nothing.

### `status`

Status of the connection. It’s value can be one of the following macros: `mgclient.CONN_STATUS_READY`, `mgclient.CONN_STATUS_BAD`, `mgclient.CONN_STATUS_CLOSED`, `mgclient.CONN_STATUS_IN_TRANSACTION`, `mgclient.CONN_STATUS_EXECUTING`.
```

--------------------------------

### mgclient.Cursor Attributes (continued)

Source: https://memgraph.github.io/pymgclient/genindex.html

Additional attributes for the Cursor object.

```APIDOC
## description
### Description
Tuple of 7-element tuples describing columns in the result set.
### Attribute
(mgclient.Cursor attribute)
```

--------------------------------

### fetchmany() Method

Source: https://memgraph.github.io/pymgclient/cursor.html

Fetches the next set of rows, returning a list of tuples. Returns an empty list if no more data is available. The number of rows is determined by arraysize or the provided parameter.

```APIDOC
def fetchmany(size=None):
    """Fetch the next set of rows of query results."""
    pass
```

--------------------------------

### mgclient.Path Attributes (continued)

Source: https://memgraph.github.io/pymgclient/genindex.html

Additional attributes for the Path object.

```APIDOC
## relationships
### Description
A list of relationships in the path.
### Attribute
(mgclient.Path attribute)
```

--------------------------------

### Securely Pass Parameters to openCypher Queries

Source: https://memgraph.github.io/pymgclient/usage.html

Illustrates the secure method for passing Python variables into openCypher queries using named placeholders ($name) and a parameter dictionary, contrasting it with insecure string formatting.

```python
# Don't do this!
server_id = 'srvr-38219012-sw'
c.execute("MATCH (s:Server {id: '%s'}) SET s.hits = s.hits + 1"
          % server_id)

# Instead, do this
c.execute("MATCH (s:Server {id: $sid}) SET s.hits = s.htis + 1",
          {'sid': server_id})

```

--------------------------------

### mgclient.Relationship Attributes (continued)

Source: https://memgraph.github.io/pymgclient/genindex.html

Additional attributes for the Relationship object.

```APIDOC
## id
### Description
The unique identifier of the relationship.
### Attribute
(mgclient.Relationship attribute)
```

--------------------------------

### mgclient.Node Attributes (continued)

Source: https://memgraph.github.io/pymgclient/genindex.html

Additional attributes for the Node object.

```APIDOC
## properties
### Description
A dictionary of properties associated with the node.
### Attribute
(mgclient.Node attribute)
```

--------------------------------

### mgclient.Column Attributes (continued)

Source: https://memgraph.github.io/pymgclient/genindex.html

Additional attributes for the Column object.

```APIDOC
## internal_size
### Description
Database's internal size for the column.
### Attribute
(mgclient.Column attribute)
```

--------------------------------

### mgclient.Cursor Attributes

Source: https://memgraph.github.io/pymgclient/genindex.html

Attributes available on the Cursor object.

```APIDOC
## arraysize
### Description
Determines the number of rows to fetch with fetchmany().
### Attribute
(mgclient.Cursor attribute)
```

```APIDOC
## description
### Description
Tuple of 7-element tuples describing columns in the result set.
### Attribute
(mgclient.Cursor attribute)
```

```APIDOC
## rowcount
### Description
Number of rows affected by the last execute() call.
### Attribute
(mgclient.Cursor attribute)
```

--------------------------------

### mgclient.Connection Attributes

Source: https://memgraph.github.io/pymgclient/genindex.html

Attributes available on the Connection object.

```APIDOC
## autocommit
### Description
Boolean indicating if autocommit is enabled.
### Attribute
(mgclient.Connection attribute)
```

```APIDOC
## status
### Description
Indicates the status of the connection.
### Attribute
(mgclient.Connection attribute)
```

--------------------------------

### Exceptions

Source: https://memgraph.github.io/pymgclient/_sources/module.rst.txt

Exceptions defined by the DB-API 2.0 specification available through the mgclient module.

```APIDOC
## Exceptions

By DB-API 2.0 specification, the module makes all error information available through these exceptions or subclasses thereof:

* `mgclient.Warning`
* `mgclient.Error`
* `mgclient.InterfaceError`
* `mgclient.DatabaseError`
* `mgclient.DataError`
* `mgclient.OperationalError`
* `mgclient.IntegrityError`
* `mgclient.InternalError`
* `mgclient.ProgrammingError`
* `mgclient.NotSupportedError

**Note:** In the current state, :exc:`OperationalError` is raised for all errors obtained from the database. This will probably be improved in the future.
```

--------------------------------

### Path Object

Source: https://memgraph.github.io/pymgclient/module.html

Represents a sequence of alternating nodes and relationships, forming a walk in the graph.

```APIDOC
class mgclient.Path
    nodes: A list of nodes in the order they appear in the path. It has one element more than the `relationships` list.
    relationships: A list of relationships in the order they appear in the path. It has one element less than the `nodes` list.
```

--------------------------------

### mgclient Module Attributes

Source: https://memgraph.github.io/pymgclient/genindex.html

Module-level attributes for the mgclient module.

```APIDOC
## apilevel
### Description
String representing the supported DB API API level.
### Attribute
(in module mgclient)
```

```APIDOC
## paramstyle
### Description
String representing the parameter style for parameterized queries.
### Attribute
(in module mgclient)
```

```APIDOC
## threadsafety
### Description
Integer indicating the thread safety level of the module.
### Attribute
(in module mgclient)
```

--------------------------------

### Cursor Class

Source: https://memgraph.github.io/pymgclient/_sources/cursor.rst.txt

The Cursor class provides an interface for executing queries and fetching results. Its members are detailed below.

```APIDOC
## Class: mgclient.Cursor

### Description
Represents a database cursor for executing queries and fetching results.

### Members
This class has the following members:

- `description`: A list consisting of instances of the :class:`Column` class, providing metadata about the query results.
```

--------------------------------

### mgclient.Node Attributes

Source: https://memgraph.github.io/pymgclient/genindex.html

Attributes of a Node object.

```APIDOC
## id
### Description
The unique identifier of the node.
### Attribute
(mgclient.Node attribute)
```

```APIDOC
## labels
### Description
A list of labels associated with the node.
### Attribute
(mgclient.Node attribute)
```

```APIDOC
## properties
### Description
A dictionary of properties associated with the node.
### Attribute
(mgclient.Node attribute)
```

--------------------------------

### mgclient.Relationship Attributes

Source: https://memgraph.github.io/pymgclient/genindex.html

Attributes of a Relationship object.

```APIDOC
## end_id
### Description
The unique identifier of the node at the end of the relationship.
### Attribute
(mgclient.Relationship attribute)
```

```APIDOC
## id
### Description
The unique identifier of the relationship.
### Attribute
(mgclient.Relationship attribute)
```

```APIDOC
## properties
### Description
A dictionary of properties associated with the relationship.
### Attribute
(mgclient.Relationship attribute)
```

```APIDOC
## start_id
### Description
The unique identifier of the node at the start of the relationship.
### Attribute
(mgclient.Relationship attribute)
```

```APIDOC
## type
### Description
The type of the relationship.
### Attribute
(mgclient.Relationship attribute)
```

--------------------------------

### arraysize Attribute

Source: https://memgraph.github.io/pymgclient/cursor.html

Specifies the number of rows to fetch at a time with fetchmany(). Defaults to 1.

```APIDOC
arraysize (int): The number of rows to fetch with fetchmany(). Defaults to 1.
```

--------------------------------

### Graph Type Objects

Source: https://memgraph.github.io/pymgclient/_sources/module.rst.txt

Classes representing graph data structures within the mgclient module.

```APIDOC
## Graph Type Objects

### `mgclient.Node`

Represents a node in the graph.

* **id**: The unique identifier of the node.
* **labels**: A set of labels associated with the node.
* **properties**: A dictionary of properties of the node.

### `mgclient.Relationship`

Represents a relationship between two nodes in the graph.

* **id**: The unique identifier of the relationship.
* **start_id**: The ID of the starting node of the relationship.
* **end_id**: The ID of the ending node of the relationship.
* **type**: The type of the relationship.
* **properties**: A dictionary of properties of the relationship.

### `mgclient.Path`

Represents a path in the graph, consisting of nodes and relationships.
```

--------------------------------

### Cursor Class Overview

Source: https://memgraph.github.io/pymgclient/cursor.html

The Cursor class is used to execute database operations. Cursors are created via the Connection.cursor() method and are bound to the connection. Changes made by one cursor are visible to others from the same connection. Cursor objects are not thread-safe.

```APIDOC
class mgclient.Cursor:
    """Allows execution of database commands."""
    pass
```

--------------------------------

### close() Method

Source: https://memgraph.github.io/pymgclient/cursor.html

Closes the cursor, making it unusable for further operations. Attempting to use a closed cursor will raise an InterfaceError.

```APIDOC
def close():
    """Close the cursor now."""
    pass
```

--------------------------------

### description Attribute

Source: https://memgraph.github.io/pymgclient/cursor.html

A read-only list of Column objects describing each result column. This attribute is None if no rows were returned or if execute() has not been called.

```APIDOC
description (list[Column] | None): A list of Column objects describing the result set.
```

--------------------------------

### mgclient.Column Attributes

Source: https://memgraph.github.io/pymgclient/genindex.html

Attributes describing a column in a result set.

```APIDOC
## display_size
### Description
Maximum display width for the column.
### Attribute
(mgclient.Column attribute)
```

```APIDOC
## internal_size
### Description
Database's internal size for the column.
### Attribute
(mgclient.Column attribute)
```

```APIDOC
## name
### Description
Name of the column.
### Attribute
(mgclient.Column attribute)
```

```APIDOC
## null_ok
### Description
Boolean indicating if the column can contain NULL values.
### Attribute
(mgclient.Column attribute)
```

```APIDOC
## precision
### Description
Precision of the column for decimal types.
### Attribute
(mgclient.Column attribute)
```

```APIDOC
## scale
### Description
Scale of the column for decimal types.
### Attribute
(mgclient.Column attribute)
```

```APIDOC
## type_code
### Description
DB API type object for the column.
### Attribute
(mgclient.Column attribute)
```

--------------------------------

### Relationship Object

Source: https://memgraph.github.io/pymgclient/module.html

Represents a directed, typed connection between two nodes. It can have properties.

```APIDOC
class mgclient.Relationship
    id: Unique relationship identifier (within the scope of its origin graph).
    start_id: Identifier of relationship start node (or -1 if it was not supplied by the database).
    end_id: Identifier of relationship end node (or -1 if it was not supplied by the database).
    type: Relationship type.
    properties: A dictionary of relationship properties.
```

--------------------------------

### Node Object

Source: https://memgraph.github.io/pymgclient/module.html

Represents a node in the graph. It can have labels and properties.

```APIDOC
class mgclient.Node
    id: Unique node identifier (within the scope of its origin graph).
    labels: A list of node labels.
    properties: A dictionary of node properties.
```

--------------------------------

### Column Class Overview

Source: https://memgraph.github.io/pymgclient/cursor.html

The Column class represents a description of a column returned by a query. Instances of this class are found in the Cursor.description attribute.

```APIDOC
class mgclient.Column:
    """Description of a column returned by the query."""
    pass
```

--------------------------------

### mgclient.Path Attributes

Source: https://memgraph.github.io/pymgclient/genindex.html

Attributes of a Path object, representing a sequence of nodes and relationships.

```APIDOC
## nodes
### Description
A list of nodes in the path.
### Attribute
(mgclient.Path attribute)
```

```APIDOC
## relationships
### Description
A list of relationships in the path.
### Attribute
(mgclient.Path attribute)
```

--------------------------------

### Column Class

Source: https://memgraph.github.io/pymgclient/_sources/cursor.rst.txt

The Column class represents metadata for a column returned by a query.

```APIDOC
## Class: mgclient.Column

### Description
Represents metadata for a column in a query result set.

### Usage
Instances of this class are found in the `description` attribute of the :class:`Cursor` object.
```

--------------------------------

### Column Attributes

Source: https://memgraph.github.io/pymgclient/cursor.html

Attributes of the Column class, providing metadata about a query result column. Note that most attributes are always set to None for compatibility with DB-API 2.0.

```APIDOC
display_size (None): Always set to None.
internal_size (None): Always set to None.
name (str): The name of the returned column.
null_ok (None): Always set to None.
precision (None): Always set to None.
scale (None): Always set to None.
type_code (None): Always set to None.
```

--------------------------------

### rowcount Attribute

Source: https://memgraph.github.io/pymgclient/cursor.html

A read-only attribute specifying the number of rows produced by the last execute() call. It is -1 if execute() has not been performed or the rowcount cannot be determined.

```APIDOC
rowcount (int): The number of rows produced by the last execute() call.
```
Tokens:
Raw