### Create and Start Test Database Farm

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/development.md

Commands to create a test database farm and a 'demo' database, then start the MonetDB daemon. Assumes no running MonetDB processes.

```bash
$ monetdbd create /tmp/pymonetdbtest
$ monetdbd start /tmp/pymonetdbtest
$ monetdb create demo
$ monetdb release demo
```

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

### Install pymonetdb

Source: https://github.com/monetdb/pymonetdb/blob/master/README.rst

Install the pymonetdb package from PyPI using pip. This is the quickest way to get started.

```bash
pip install pymonetdb
```

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

### Install PyMonetDB from source

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/introduction.md

Install the PyMonetDB library by building it from its source directory. This is useful for development or when a specific version is needed.

```bash
python setup.py install
```

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

### MonetDB SQL PREPARE and EXECUTE Example

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/prepared_statements.md

Demonstrates the SQL syntax for preparing a statement with a placeholder and then executing it with a value.

```sql
> sql>PREPARE SELECT ? + 42;
> execute prepared statement using: EXEC 0(...)
> ...
> sql>EXECUTE 0(100);
> +------+
> | %2   |
> +======+
> |  142 |
> +------+
> 1 tuple
> sql>
```

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

### Example Database Session

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/examples.md

Demonstrates a typical workflow for connecting to a MonetDB database, creating a cursor, executing queries, and fetching results.

```python
> # import the SQL module
> import pymonetdb
>
> # set up a connection. arguments below are the defaults
> connection = pymonetdb.connect(username="monetdb", password="monetdb",
>                                    hostname="localhost", database="demo")
>
> # create a cursor
> cursor = connection.cursor()
>
> # increase the rows fetched to increase performance (optional)
> cursor.arraysize = 100
>
> # execute a query (return the number of rows to fetch)
> cursor.execute('SELECT * FROM tables')
26
>
> # fetch only one row
> cursor.fetchone()
[1062, 'schemas', 1061, None, 0, True, 0, 0]
>
> # fetch the remaining rows
> cursor.fetchall()
[[1067, 'schemas', 1061, None, 0, True, 0, 0],
 [1076, 'types', 1061, None, 0, True, 0, 0],
 [1085, 'args', 1061, None, 0, True, 0, 0],
 [1093, 'sequences', 1061, None, 0, True, 0, 0],
 [1103, 'dependencies', 1061, None, 0, True, 0, 0],
 [1107, 'connections', 1061, None, 0, True, 0, 0],
 [1116, '_tables', 1061, None, 0, True, 0, 0],
 ...
 [4141, 'user_role', 1061, None, 0, True, 0, 0],
 [4144, 'auths', 1061, None, 0, True, 0, 0],
 [4148, 'privileges', 1061, None, 0, True, 0, 0]]
>
> # Show the table meta data
> cursor.description
[('id', 'int', 4, 4, None, None, None),
 ('name', 'varchar', 12, 12, None, None, None),
 ('schema_id', 'int', 4, 4, None, None, None),
 ('query', 'varchar', 168, 168, None, None, None),
 ('type', 'smallint', 1, 1, None, None, None),
 ('system', 'boolean', 5, 5, None, None, None),
 ('commit_action', 'smallint', 1, 1, None, None, None),
 ('temporary', 'tinyint', 1, 1, None, None, None)]
```

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

### Run Tests with Tox

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/development.md

Commands to install tox and run the pymonetdb test suite. Ensure your Python version is listed in tox.ini's envlist.

```bash
$ pip install tox; tox
```

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

### Run Tests with Full Environment

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/development.md

Use this command to run tests that require the full environment setup. Ensure TSTFULL is set to 'true'.

```bash
$ TSTFULL=true python3 -m unittest -v tests/test_control.py
```

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

### Rejecting Legacy URL Formats

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

These examples show URL formats that are rejected by the parser.

```test
REJECT mapi:
REJECT mapi:monetdb
REJECT mapi:monetdb:
REJECT mapi:monetdb:/
```

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

### Run Tests with Make

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/development.md

Command to run the pymonetdb test suite using the 'make test' command. This command creates a virtual environment, installs dependencies, and runs pytest.

```bash
$ make test
```

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

### CSV Upload Script

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/examples.md

An example script that demonstrates uploading CSV data from the local file system to a MonetDB table using pymonetdb's SafeDirectoryHandler.

```python
#!/usr/bin/env python3

import os
import pymonetdb

# Create the data directory and the CSV file
try:
    os.mkdir("datadir")
except FileExistsError:
    pass
with open("datadir/data.csv", "w") as f:
    for i in range(10):
        print(f"{i},item{i + 1}", file=f)

# Connect to MonetDB and register the upload handler
conn = pymonetdb.connect('demo')
handler = pymonetdb.SafeDirectoryHandler("datadir")
conn.set_uploader(handler)
cusor = conn.cursor()

# Set up the table
cursor.execute("DROP TABLE foo")
cursor.execute("CREATE TABLE foo(i INT, t TEXT)")

# Upload the data, this will ask the handler to upload data.csv
cursor.execute("COPY INTO foo FROM 'data.csv' ON CLIENT USING DELIMITERS ','")

# Check that it has loaded
cursor.execute("SELECT t FROM foo WHERE i = 9")
row = cursor.fetchone()
assert row[0] == 'item10'

# Goodbye
conn.commit()
cursor.close()
conn.close()
```

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

### User and Password Rule

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

If a user is set, the password must be explicitly set or cleared. This example shows setting a user, then a password, then changing the user and expecting the password to be cleared.

```test
ACCEPT monetdb:///?user=foo
EXPECT user=foo
EXPECT password=
SET password=banana
EXPECT user=foo
EXPECT password=banana
SET user=bar
EXPECT password=
```

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

### Initialize Demo Database and Test Farm

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/development.md

Shell script to initialize the 'demo' database and the test database farm. WARNING: This script destroys the 'demo' database without confirmation.

```bash
$ tests/initdb.sh demo /tmp/pymonetdbtest
```

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

### Parameter Setting and Expectation

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Demonstrates setting various connection parameters and verifying their expected values.

```test
SET tls=on
EXPECT tls=on
SET host=bananahost
EXPECT host=bananahost
SET port=123
EXPECT port=123
SET database=bananadatabase
EXPECT database=bananadatabase
SET tableschema=bananatableschema
EXPECT tableschema=bananatableschema
SET table=bananatable
EXPECT table=bananatable
SET sock=c:\\foo.txt
EXPECT sock=c:\\foo.txt
SET cert=c:\\foo.txt
EXPECT cert=c:\\foo.txt
SET certhash=bananacerthash
EXPECT certhash=bananacerthash
SET clientkey=c:\\foo.txt
EXPECT clientkey=c:\\foo.txt
SET clientcert=c:\\foo.txt
EXPECT clientcert=c:\\foo.txt
SET user=bananauser
EXPECT user=bananauser
SET password=bananapassword
EXPECT password=bananapassword
SET language=bananalanguage
EXPECT language=bananalanguage
SET autocommit=on
EXPECT autocommit=on
SET schema=bananaschema
EXPECT schema=bananaschema
SET timezone=123
EXPECT timezone=123
SET binary=bananabinary
EXPECT binary=bananabinary
SET replysize=123
EXPECT replysize=123
SET fetchsize=123
EXPECT fetchsize=123
```

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

### Accepting Standard MonetDB URL with Parameters

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Demonstrates a standard MonetDB URL format and its parsed components.

```test
ACCEPT mapi:monetdb://monet.db:12345/demo
EXPECT host=monet.db
EXPECT port=12345
EXPECT database=demo
EXPECT tls=off
EXPECT language=sql
EXPECT connect_scan=off
EXPECT connect_unix=
EXPECT connect_tcp=monet.db
```

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

### Connect to MonetDB database (basic)

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/introduction.md

Establish a connection to a MonetDB database using only the database name. Assumes default host and port.

```python
conn = pymonetdb.connect('demo')
```

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

### MAPI Low-Level Connection

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/examples.md

Demonstrates how to establish a low-level connection to MonetDB using the MAPI library. This is not recommended for general use.

```python
> from pymonetdb import mapi
> server = mapi.Connection()
> server.connect(hostname="localhost", port=50000, username="monetdb",
                 password="monetdb", database="demo", language="sql")
> server.cmd("sSELECT * FROM tables;")
...
```

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

### Connect to MonetDB database (with credentials)

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/introduction.md

Connect to a MonetDB database specifying hostname, port, username, and password for authentication and network configuration.

```python
conn = pymonetdb.connect(
  'demo',
  hostname='dbhost', port=50001,
  username='yours', password='truly')
```

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

### Full URL Parsing with Parameters

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests parsing a complete URL with host, port, database, schema, table, and user credentials.

```test
ACCEPT monetdb://host:12345/db1/schema2/table3?user=mr&password=bean
EXPECT tls=off
EXPECT host=host
EXPECT port=12345
EXPECT database=db1
EXPECT tableschema=schema2
EXPECT table=table3
EXPECT user=mr
EXPECT password=bean
```

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

### MonetDB URL with Only Host and Port

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Demonstrates parsing a MonetDB URL that only specifies host and port.

```test
ACCEPT mapi:monetdb://localhost:12345
EXPECT host=localhost
EXPECT port=12345
EXPECT database=
EXPECT tls=off
EXPECT language=sql
EXPECT connect_scan=off
EXPECT connect_unix=
EXPECT connect_tcp=localhost
```

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

### Enable Binary Connection

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Enables binary connections and sets the binary port. Use 'on', 'yes', or 'true' to enable.

```test
EXPECT binary=on
EXPECT connect_binary=65535
```

```test
ACCEPT monetdb:///?binary=on
EXPECT connect_binary=65535

ACCEPT monetdb:///?binary=yes
EXPECT connect_binary=65535

ACCEPT monetdb:///?binary=true
EXPECT connect_binary=65535

ACCEPT monetdb:///?binary=yEs
EXPECT connect_binary=65535
```

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

### Basic Connection String

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests a basic connection string to a local MonetDB instance.

```test
ACCEPT monetdb:///demo
EXPECT database=demo
EXPECT connect_scan=true
```

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

### MonetDB URL Unknown Parameter Handling

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Illustrates that unknown parameters like 'l%61nguage' are ignored, not rejected.

```test
SET language=sql
ACCEPT mapi:monetdb://localhost:12345/db?l%61nguage=mal
EXPECT language=sql
ACCEPT mapi:monetdb://localhost:12345/db?_l%61nguage=mal
```

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

### Execute queries with named parameters

Source: https://github.com/monetdb/pymonetdb/blob/master/CHANGES.md

Demonstrates how to use the 'named' parameter style for executing SQL queries with named parameters. Ensure the 'named' paramstyle is set before execution.

```python
import pymonetdb

# classic behavior: paramstyle pyformat
assert pymonetdb.paramstyle == 'pyformat'

with pymonetdb.connect('demo') as conn, conn.cursor() as cursor:
    parameters = dict(number=42, fruit="ban'ana")
    cursor.execute("SELECT %(number)s, %(fruit)s", parameters)
    assert cursor.fetchone() == (42, "ban'ana")

# enable named parameters
pymonetdb.paramstyle = 'named'

with pymonetdb.connect('demo') as conn, conn.cursor() as cursor:
    parameters = dict(number=42, fruit="ban'ana")
    cursor.execute("SELECT :number, :fruit", parameters)
    assert cursor.fetchone() == (42, "ban'ana")
```

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

### Connect to MonetDB database using URL

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/introduction.md

Connect to a MonetDB database by providing a connection URL that includes all necessary parameters like hostname, port, database name, and credentials.

```python
url = 'monetdb://dbhost:50001/demo?autocommit=true&user=yours&password=truly'
conn = pymonetdb.connect(url)
```

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

### Client Key and Certificate Configuration

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Configure client private key and certificate paths for SSL/TLS client authentication. Supports both forward and backward slashes.

```test
EXPECT clientkey=
EXPECT clientcert=
ACCEPT monetdbs:///?clientkey=/tmp/clientkey.pem
EXPECT clientkey=/tmp/clientkey.pem
ACCEPT monetdbs:///?clientkey=C:/TEMP/clientkey.pem
EXPECT clientkey=C:/TEMP/clientkey.pem
NOT jdbc
ACCEPT monetdbs:///?clientkey=C:\\TEMP\\clientkey.pem
EXPECT clientkey=C:\\TEMP\\clientkey.pem
```

```test
EXPECT connect_clientkey=
EXPECT connect_clientcert=
```

```test
SET clientkey=/tmp/key.pem
SET clientcert=/tmp/cert.pem
EXPECT valid=true
EXPECT connect_clientkey=/tmp/key.pem
EXPECT connect_clientcert=/tmp/cert.pem
```

```test
SET clientkey=/tmp/key.pem
EXPECT valid=true
EXPECT connect_clientkey=/tmp/key.pem
EXPECT connect_clientcert=/tmp/key.pem
```

```test
SET clientcert=/tmp/cert.pem
EXPECT valid=false
```

```test
SET clientkey=dummy
EXPECT clientcert=
ACCEPT monetdbs:///?clientcert=/tmp/clientcert.pem
EXPECT clientcert=/tmp/clientcert.pem
ACCEPT monetdbs:///?clientcert=C:/TEMP/clientcert.pem
EXPECT clientcert=C:/TEMP/clientcert.pem
NOT jdbc
ACCEPT monetdbs:///?clientcert=C:\\TEMP\\clientcert.pem
EXPECT clientcert=C:\\TEMP\\clientcert.pem
```

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

### MonetDB URL with Port and Database, No Host

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Shows parsing a MonetDB URL specifying port and database but no explicit host.

```test
ACCEPT mapi:monetdb://:12345/demo
EXPECT host=
EXPECT port=12345
EXPECT database=demo
EXPECT tls=off
EXPECT language=sql
EXPECT connect_scan=off
EXPECT connect_unix=/tmp/.s.monetdb.12345
EXPECT connect_tcp=localhost
```

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

### Run All Python Unit Tests

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/development.md

Commands to execute the pymonetdb test suite using Python's unittest module. Options include stopping on first failure or verbose output.

```bash
$ python -m unittest # to run all tests
$ python -m unittest -f # to run all tests but stop after the first failure
$ python -m unittest -v # to run all tests and get information about individual test
$ python -m unittest -v tests.test_policy # to run all tests of the module "tests.test_policy"
$ python -m unittest -v -k test_fetch # to run the sub-test set "test_fetch*"
```

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

### Precedence of Sources

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Demonstrates that later sources take precedence over earlier ones when combining configurations. This applies to schema, database, and TLS settings.

```test
SET schema=a
ACCEPT monetdb:///db1?schema=b
EXPECT schema=b
EXPECT database=db1
EXPECT tls=off
ACCEPT monetdbs:///db2?schema=c
EXPECT tls=on
EXPECT database=db2
EXPECT schema=c
```

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

### MonetDB URL with Database Override Parameter

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Demonstrates how the 'database' parameter in the URL query string overrides the path.

```test
ACCEPT mapi:monetdb://localhost:12345/demo?database=foo
EXPECT database=foo
```

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

### Unix Socket URL Parsing Differences

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Illustrates parsing differences for Unix socket URLs between libmapi and pymonetdb.

```test
NOT pymonetdb
PARSE mapi:monetdb:///foo:bar@path/to/sock
EXPECT sock=/foo:bar@path/to/sock
REJECT mapi:monetdb://foo:bar@/path/to/sock
```

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

### MonetDB URL Language Parameter Support

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Demonstrates how the 'language' parameter is handled in MonetDB URLs for both TCP and Unix sockets.

```test
SET language=sql
ACCEPT mapi:monetdb://localhost:12345?language=mal
EXPECT host=localhost
EXPECT sock=
EXPECT language=mal
SET language=sql
ACCEPT mapi:monetdb:///path/to/sock?language=mal
EXPECT host=
EXPECT sock=/path/to/sock
EXPECT language=mal
```

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

### Connection String with Hostname

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests a connection string specifying the hostname and database.

```test
ACCEPT monetdb://localhost/demo
EXPECT connect_scan=true
EXPECT database=demo
```

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

### Use Connection and Cursor as context managers

Source: https://github.com/monetdb/pymonetdb/blob/master/CHANGES.md

Shows how to use the Connection and Cursor objects as context managers for automatic resource management. This ensures connections and cursors are properly closed.

```python
with pymonetdb.connect(db') as conn, conn.cursor() as cursor:
    cursor.execute("SELECT 42")
```

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

### Connection String with Hostname, Port, and Unix Socket

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests a connection string with hostname, port, and explicit Unix socket path.

```test
ACCEPT monetdb://localhost:12345/demo
EXPECT connect_scan=false
EXPECT connect_unix=/tmp/.s.monetdb.12345
EXPECT connect_tcp=localhost
EXPECT connect_port=12345
EXPECT tls=off
EXPECT database=demo
```

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

### MonetDB URL with IP Address, Port, and Database

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Parsing a MonetDB URL using an IP address for the host.

```test
ACCEPT mapi:monetdb://127.0.0.1:12345/demo
EXPECT host=127.0.0.1
EXPECT port=12345
EXPECT database=demo
EXPECT tls=off
EXPECT language=sql
EXPECT connect_scan=off
EXPECT connect_unix=
EXPECT connect_tcp=127.0.0.1
```

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

### MonetDB URL with Host and Database, Default Port

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Parsing a MonetDB URL with host and database, implying the default port.

```test
ACCEPT mapi:monetdb://localhost/demo
EXPECT connect_scan=false
EXPECT connect_unix=
EXPECT connect_tcp=localhost
EXPECT connect_port=50000
```

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

### MonetDB URL Percent Encoding in Parameters

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Demonstrates that percent encoding is allowed in URL parameters like database and language.

```test
PARSE mapi:monetdb://localhost:12345/db?database=b%61r&language=m%61l
EXPECT database=b%61r
EXPECT language=m%61l
EXPECT valid=no
```

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

### Accept Known Unknown Parameters

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Accepts connection URLs with parameters that are not strictly defined but are recognized.

```test
ACCEPT monetdb:///?ban_ana=bla
ACCEPT monetdb:///?hash=sha1
ACCEPT monetdb:///?debug=true
ACCEPT monetdb:///?logfile=banana
```

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

### Connection String with User and Password

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests a connection string including user and password parameters.

```test
ACCEPT monetdb:///demo?user=monetdb&password=monetdb
EXPECT connect_scan=true
EXPECT database=demo
EXPECT user=monetdb
EXPECT password=monetdb
```

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

### Connection String with Default Database

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests a connection string to localhost with a default database, disabling scan.

```test
ACCEPT monetdb://localhost/
EXPECT connect_unix=/tmp/.s.monetdb.50000
EXPECT connect_scan=false
EXPECT connect_tcp=localhost
EXPECT tls=off
EXPECT database=
```

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

### Enable Remote Control for Test Databases

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/development.md

Commands to enable remote control and set a passphrase for the MonetDB daemon, then stop and restart it. Required for control tests.

```bash
$ monetdbd set control=yes /tmp/pymonetdbtest
$ monetdbd set passphrase=testdb /tmp/pymonetdbtest
$ monetdbd stop /tmp/pymonetdbtest
$ monetdbd start /tmp/pymonetdbtest
```

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

### Reply Size and Fetch Size Configuration

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Configure buffer sizes for network communication. 'replysize' controls server-side buffer, while 'fetchsize' is client-side.

```test
ACCEPT monetdb:///?replysize=150
EXPECT replysize=150
ACCEPT monetdb:///?fetchsize=150
EXPECT replysize=150
ACCEPT monetdb:///?fetchsize=100&replysize=200
EXPECT replysize=200
ACCEPT monetdb:///?replysize=100&fetchsize=200
EXPECT replysize=200
REJECT monetdb:///?replysize=
REJECT monetdb:///?fetchsize=
```

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

### Secure Connection String with Local Path

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests a secure connection string (monetdbs) to a local instance, enabling TLS.

```test
ACCEPT monetdbs:///demo
EXPECT connect_scan=false
EXPECT connect_unix=
EXPECT connect_tcp=localhost
EXPECT connect_port=50000
EXPECT tls=on
EXPECT connect_tls_verify=system
EXPECT database=demo
```

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

### MonetDB URL for Unix Domain Sockets with Database

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Parsing a MonetDB URL for Unix domain sockets, including a database name.

```test
ACCEPT mapi:monetdb:///path/to/sock?database=demo
EXPECT host=
EXPECT sock=/path/to/sock
EXPECT port=-1
EXPECT database=demo
EXPECT tls=off
EXPECT language=sql
EXPECT connect_unix=/path/to/sock
EXPECT connect_tcp=
```

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

### Basic Connection Variants

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests different combinations of connection parameters for basic MonetDB connections.

```test
ACCEPT monetdb:///
EXPECT connect_scan=off
EXPECT connect_unix=/tmp/.s.monetdb.50000
EXPECT connect_tcp=localhost
```

```test
ACCEPT monetdb:///?sock=/a/path
EXPECT connect_scan=off
EXPECT connect_unix=/a/path
EXPECT connect_tcp=
```

```test
ACCEPT monetdb://localhost/
EXPECT connect_scan=off
EXPECT connect_unix=/tmp/.s.monetdb.50000
EXPECT connect_tcp=localhost
```

```test
ACCEPT monetdb://localhost/?sock=/a/path
EXPECT connect_scan=off
EXPECT connect_unix=/a/path
EXPECT connect_tcp=
```

```test
ACCEPT monetdb://localhost./
EXPECT connect_scan=off
EXPECT connect_unix=
EXPECT connect_tcp=localhost
```

```test
REJECT monetdb://localhost./?sock=/a/path
```

```test
ACCEPT monetdb://not.localhost/
EXPECT connect_scan=off
EXPECT connect_unix=
EXPECT connect_tcp=not.localhost
```

```test
REJECT monetdb://not.localhost/?sock=/a/path
```

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

### Secure Connection String with Domain

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests a secure connection string (monetdbs) using a domain name and default port, enabling TLS.

```test
ACCEPT monetdbs://mdb.example.com/demo
EXPECT connect_scan=false
EXPECT connect_unix=
EXPECT connect_tcp=mdb.example.com
EXPECT connect_port=50000
EXPECT tls=on
EXPECT connect_tls_verify=system
EXPECT database=demo
```

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

### Socket Directory Configuration

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Specify the directory for socket files. Used for establishing connections via a socket directory.

```test
EXPECT sockdir=
EXPECT connect_sockdir=/tmp
ACCEPT monetdb:///demo?sockdir=/tmp/nonstandard
EXPECT sockdir=/tmp/nonstandard
EXPECT connect_sockdir=/tmp/nonstandard
EXPECT connect_unix=/tmp/nonstandard/.s.monetdb.50000
```

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

### Connection String with Hostname, Socket Path, and User

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests a connection string with hostname, custom socket path, and user, disabling TLS.

```test
ACCEPT monetdb://localhost/demo?sock=/var/monetdb/_sock&user=dbuser
EXPECT connect_scan=false
EXPECT connect_unix=/var/monetdb/_sock
EXPECT connect_tcp=
EXPECT tls=off
EXPECT database=demo
EXPECT user=dbuser
EXPECT password=
```

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

### Language Setting

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Set the default language for SQL queries. Supports 'msql' and 'sql'.

```test
EXPECT language=sql
ACCEPT monetdb:///?language=msql
EXPECT language=msql
ACCEPT monetdb:///?language=sql
EXPECT language=sql
```

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

### Set Parameters via SET Command

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Sets connection parameters using the SET command. This is used for parameters not directly configurable via URL.

```test
SET ban_ana=bla
SET hash=sha1
SET debug=true
SET logfile=banana
```

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

### Fetchsize and Replysize Alias

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Demonstrates that 'fetchsize' is an alias for 'replysize', and the last occurrence determines the final value.

```test
SET replysize=200
ACCEPT monetdb:///?fetchsize=400
EXPECT replysize=400
ACCEPT monetdb:///?replysize=500&fetchsize=600
EXPECT replysize=600
```

```test
NOT jdbc
SET replysize=200
SET fetchsize=300
EXPECT replysize=300
```

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

### MonetDB URL with Missing Database

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Shows how a MonetDB URL is parsed when the database name is omitted.

```test
ACCEPT mapi:monetdb://localhost:12345/
EXPECT host=localhost
EXPECT port=12345
EXPECT database=
EXPECT tls=off
EXPECT language=sql
EXPECT connect_scan=off
EXPECT connect_unix=
EXPECT connect_tcp=localhost
```

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

### User and Password Configuration

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Specify the username and password for database authentication. The default values are implementation-specific and not tested here.

```test
ACCEPT monetdb:///?user=monetdb
EXPECT user=monetdb
ACCEPT monetdb:///?user=me&password=?
EXPECT user=me
EXPECT password=?
```

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

### TLS On: Both Cert and CertHash Provided

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Covers the valid scenario where TLS is on, and both a certificate path and a certificate hash are supplied. As with connection strings, the hash takes precedence.

```test
SET tls=on
SET cert=/foo
SET certhash=sha256:abcdef
EXPECT valid=yes
EXPECT connect_tls_verify=hash
```

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

### Reject Unknown Parameters

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Rejects connection URLs with unknown parameters.

```test
REJECT monetdb:///?banana=bla
```

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

### Secure Connection String with Certificate Hash

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests a secure connection string (monetdbs) using a certificate hash for verification.

```test
ACCEPT monetdbs://mdb.example.com/demo?certhash=sha256:fb:67:20:aa:00:9f:33:4c
EXPECT connect_scan=false
EXPECT connect_unix=
EXPECT connect_tcp=mdb.example.com
EXPECT connect_port=50000
EXPECT tls=on
EXPECT connect_tls_verify=hash
EXPECT certhash=sha256:fb:67:20:aa:00:9f:33:4c
EXPECT connect_certhash_digits=fb6720aa009f334c
EXPECT database=demo
```

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

### TLS Connection Verification with Cert and CertHash

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Demonstrates how MonetDB connection strings with 'cert' and 'certhash' parameters influence TLS verification. It shows that 'certhash' takes precedence when both are provided.

```test
ACCEPT monetdbs:///?cert=/a/path
EXPECT connect_tls_verify=cert
ACCEPT monetdbs:///?certhash=sha256:aa
EXPECT connect_tls_verify=hash
ACCEPT monetdbs:///?cert=/a/path&certhash=sha256:aa
EXPECT connect_tls_verify=hash
REJECT monetdb:///?cert=/a/path
REJECT monetdb:///?certhash=sha256:aa
```

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

### Socket Path Configuration

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Configure the socket path for Unix domain sockets. Supports both forward and backward slashes for paths.

```test
EXPECT sock=
ACCEPT monetdb:///?sock=/tmp/sock
EXPECT sock=/tmp/sock
ACCEPT monetdb:///?sock=C:/TEMP/sock
EXPECT sock=C:/TEMP/sock
NOT jdbc
ACCEPT monetdb:///?sock=C:\\TEMP\\sock
EXPECT sock=C:\\TEMP\\sock
```

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

### Secure Connection String with Certificate

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests a secure connection string (monetdbs) with a specified server certificate path.

```test
ACCEPT monetdbs://mdb.example.com/demo?cert=/home/user/server.crt
EXPECT connect_scan=false
EXPECT connect_unix=
EXPECT connect_tcp=mdb.example.com
EXPECT connect_port=50000
EXPECT tls=on
EXPECT connect_tls_verify=cert
EXPECT cert=/home/user/server.crt
EXPECT database=demo
```

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

### MonetDB URL with Ignored User/Password Parameters

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Shows that user and password parameters in the URL are ignored when set via SET commands.

```test
SET user=alan
SET password=turing
ACCEPT mapi:monetdb://localhost:12345/demo?user=foo
EXPECT user=alan
EXPECT password=turing
ACCEPT mapi:monetdb://localhost:12345/demo?password=foo
EXPECT user=alan
EXPECT password=turing
```

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

### Connection String with Domain Name

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests a connection string using a domain name, port, and disabling scan.

```test
ACCEPT monetdb://mdb.example.com:12345/demo
EXPECT connect_scan=false
EXPECT connect_unix=
EXPECT connect_tcp=mdb.example.com
EXPECT connect_port=12345
EXPECT tls=off
EXPECT database=demo
```

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

### Sockdir and Host Interaction

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests how 'sockdir' and 'host' settings affect Unix domain socket connections.

```test
EXPECT connect_sockdir=/tmp
EXPECT port=-1
EXPECT host=
EXPECT connect_unix=/tmp/.s.monetdb.50000
SET sockdir=/somewhere/else
EXPECT connect_sockdir=/somewhere/else
EXPECT connect_unix=/somewhere/else/.s.monetdb.50000
SET port=12345
EXPECT connect_unix=/somewhere/else/.s.monetdb.12345
```

```test
EXPECT connect_sockdir=/tmp
SET host=banana
EXPECT connect_sockdir=/tmp
SET host=/somewhere/else
EXPECT connect_sockdir=/somewhere/else
EXPECT connect_tcp=localhost
```

```test
EXPECT connect_sockdir=/tmp
SET sockdir=/xyz
EXPECT connect_sockdir=/xyz
SET host=banana
EXPECT connect_sockdir=/xyz
SET host=/somewhere/else
EXPECT connect_sockdir=/xyz
EXPECT connect_unix=/xyz/.s.monetdb.50000
```

```test
SET host=/somewhere/else
EXPECT connect_unix=/somewhere/else/.s.monetdb.50000
EXPECT connect_tcp=localhost
```

```test
SET host=/somewhere/else
SET sock=/tmp/foo.sock
EXPECT valid=false
```

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

### Schema and Timezone Configuration

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Set the default schema and timezone for the connection. Schema content is unconstrained, while timezone accepts numeric values.

```test
EXPECT schema=
ACCEPT monetdb:///?schema=foo
EXPECT schema=foo
ACCEPT monetdb:///?schema=
EXPECT schema=
ACCEPT monetdb:///?schema=foo
```

```test
ACCEPT monetdb:///?timezone=0
EXPECT timezone=0
ACCEPT monetdb:///?timezone=120
EXPECT timezone=120
ACCEPT monetdb:///?timezone=-120
EXPECT timezone=-120
REJECT monetdb:///?timezone=banana
REJECT monetdb:///?timezone=
```

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

### Pymonetdb URL with User and Password in URL

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

For pymonetdb, user and password in the URL are parsed correctly.

```test
ONLY pymonetdb
SET user=alan
SET password=turing
ACCEPT mapi:monetdb://foo:bar@localhost:12345/demo
EXPECT user=foo
EXPECT password=bar
ACCEPT mapi:monetdb://banana@localhost:12345/demo
EXPECT user=banana
EXPECT password=
```

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

### pymonetdb Prepared Statement Execution

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/prepared_statements.md

Shows how to use prepared statements within a Python script using the pymonetdb library. The prepared statement ID is retrieved via `lastrowid` and then used for execution.

```python
with pymonetdb.connect('demo') as conn, conn.cursor() as c:
    c.execute("PREPARE SELECT ? + 42")
    exec_id = c.lastrowid
    c.execute("EXECUTE %s(%s)", [exec_id, 100])
    result = c.fetchone()[0]
    assert result == 142
```

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

### Connect Scan Behavior with Host and Sockdir

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests how 'connect_scan' behavior is affected by 'host' and 'sockdir' settings.

```test
EXPECT database=
EXPECT connect_scan=off
EXPECT connect_tcp=localhost
SET host=/somewhere/else
EXPECT connect_scan=off
EXPECT connect_tcp=localhost
```

```test
SET database=demo
EXPECT connect_scan=on
EXPECT connect_tcp=localhost
SET host=/somewhere/else
EXPECT connect_scan=on
EXPECT connect_tcp=localhost
```

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

### Run Tests with Pytest

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/development.md

Commands to run the pymonetdb test suite using pytest. Supports verbose output and running specific test files.

```bash
$ pytest # to run all tests
$ pytest -v # to run all tests and get information about individual test
$ pytest -v tests/test_oid.py # to run one test file
```

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

### MonetDB URL for Unix Domain Sockets without Database

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Parsing a MonetDB URL for Unix domain sockets when the database name is omitted.

```test
ACCEPT mapi:monetdb:///path/to/sock
EXPECT host=
EXPECT sock=/path/to/sock
EXPECT port=-1
EXPECT database=
EXPECT tls=off
EXPECT language=sql
EXPECT connect_unix=/path/to/sock
EXPECT connect_tcp=
```

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

### TLS On: Cert Provided

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Examines the valid case where TLS is on and a certificate path is provided. This should enable certificate-based TLS verification.

```test
SET tls=on
SET cert=/foo
SET certhash=
EXPECT valid=yes
EXPECT connect_tls_verify=cert
```

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

### Copy data into a table from a client-side file

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/filetransfers.md

Use this statement to load data from a CSV-like file into a MonetDB table. The `ON CLIENT` modifier specifies that the file should be accessed from the client machine.

```default
COPY INTO mytable FROM 'data.csv' ON CLIENT
USING DELIMITERS ',', E'\n', '"';
```

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

### SSL/TLS Certificate Path Configuration

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Configure the path to an SSL/TLS certificate file for secure connections. Supports both forward and backward slashes.

```test
EXPECT cert=
ACCEPT monetdbs:///?cert=/tmp/cert.pem
EXPECT cert=/tmp/cert.pem
ACCEPT monetdbs:///?cert=C:/TEMP/cert.pem
EXPECT cert=C:/TEMP/cert.pem
NOT jdbc
ACCEPT monetdbs:///?cert=C:\\TEMP\\cert.pem
EXPECT cert=C:\\TEMP\\cert.pem
```

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

### Core Default Parameter Values

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests the default values for core connection parameters.

```test
EXPECT tls=false
EXPECT host=
EXPECT port=-1
EXPECT database=
EXPECT tableschema=
EXPECT table=
EXPECT binary=on
```

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

### Custom Uploader with File Copy

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/filetransfers.md

Implement a custom uploader to handle file uploads, utilizing shutil.copyfileobj for efficient data transfer. Ensure proper security checks are in place to validate file paths before accessing the file system.

```python
import pathlib
import shutil

import pymonetdb

class MyUploader(pymonetdb.Uploader):
    def __init__(self, dir):
        self.dir = pathlib.Path(dir)

    def handle_upload(self, upload, filename, text_mode, skip_amount):
        # security check
        path = self.dir.joinpath(filename).resolve()
        if not str(path).startswith(str(self.dir.resolve())):
            return upload.send_error('Forbidden')
        # open
        tw = upload.text_writer()
        with open(path) as f:
            # skip
            for i in range(skip_amount):
                f.readline()
            # bulk upload
            shutil.copyfileobj(f, tw)
```

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

### TLS On: No Cert or CertHash

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Covers the scenario where TLS is enabled, but neither a certificate nor a certificate hash is specified. This should default to system-level verification.

```test
SET tls=on
SET cert=
SET certhash=
EXPECT valid=yes
EXPECT connect_tls_verify=system
```

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

### Connection String with Socket Path and User

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests a connection string specifying a custom socket path and user, disabling TLS.

```test
ACCEPT monetdb:///demo?sock=/var/monetdb/_sock&user=dbuser
EXPECT connect_scan=false
EXPECT connect_unix=/var/monetdb/_sock
EXPECT connect_tcp=
EXPECT tls=off
EXPECT database=demo
EXPECT user=dbuser
EXPECT password=
```

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

### Connection String with IP Address

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests a connection string using an IP address and port, disabling scan.

```test
ACCEPT monetdb://192.168.13.4:12345/demo
EXPECT connect_scan=false
EXPECT connect_unix=
EXPECT connect_tcp=192.168.13.4
EXPECT connect_port=12345
EXPECT tls=off
EXPECT database=demo
```

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

### Password Handling with User Set

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

When a user is set, the password is handled carefully. If the user is the same as previously set, the password is cleared unless explicitly provided.

```test
SET user=alan
SET password=turing
ACCEPT monetdbs:///
EXPECT user=alan
EXPECT password=turing
```

```test
SET user=alan
SET password=turing
ACCEPT monetdbs:///?user=mathison
EXPECT user=mathison
EXPECT password=
```

```test
SET user=alan
SET password=turing
ACCEPT monetdbs:///?user=alan
EXPECT user=alan
EXPECT password=
```

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

### Registering SafeDirectoryHandler for file transfers

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/filetransfers.md

Configure pymonetdb to allow file transfers by registering a `SafeDirectoryHandler`. This handler restricts file access to a specified directory, enhancing security. It can be used for both uploads and downloads.

```default
transfer_handler = pymonetdb.SafeDirectoryHandler(datadir)
conn.set_uploader(transfer_handler)
conn.set_downloader(transfer_handler)
```

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

### MonetDB URL Percent Encoding Rejection

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Shows that percent encoding is rejected for host and port in MonetDB URLs.

```test
REJECT mapi:monetdb://localhost:1234%35/demo
PARSE mapi:monetdb://loc%61lhost:12345/d%61tabase
EXPECT host=loc%61lhost
EXPECT database=d%61tabase
EXPECT valid=no
```

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

### TLS Off: Both Cert and CertHash Provided

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Investigates the invalid configuration where TLS is off, and both a certificate path and a certificate hash are supplied.

```test
SET tls=off
SET cert=/foo
SET certhash=sha256:abcdef
EXPECT valid=no
```

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

### Custom Uploader Handler for dynamic data generation

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/filetransfers.md

Implement a custom `Uploader` to generate data on the fly instead of reading from a file. The `handle_upload` method receives an `upload` object which provides a `text_writer` for writing data.

```default
class MyUploader(pymonetdb.Uploader):
    def handle_upload(self, upload, filename, text_mode, skip_amount):
        tw = upload.text_writer()
        for i in range(skip_amount, 1000):
            print(f'{i},number{i}', file=tw)
```

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

### URL Parsing with TLS and Percent Escapes

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests parsing a TLS-enabled URL with percent-encoded host, database, schema, table, and user credentials.

```test
ACCEPT monetdbs://h%6Fst:12345/db%31/schema%32/table%33?user=%6Dr&p%61ssword=bean
EXPECT tls=on
EXPECT host=host
EXPECT port=12345
EXPECT database=db1
EXPECT tableschema=schema2
EXPECT table=table3
EXPECT user=mr
EXPECT password=bean
```

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

### Autocommit Setting

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Configure the autocommit behavior of the connection. Accepts 'true', 'on', 'yes' for enabling, and 'false', 'off', 'no' for disabling.

```test
ACCEPT monetdb:///?autocommit=true
EXPECT autocommit=true
ACCEPT monetdb:///?autocommit=on
EXPECT autocommit=true
ACCEPT monetdb:///?autocommit=yes
EXPECT autocommit=true
```

```test
ACCEPT monetdb:///?autocommit=false
EXPECT autocommit=false
ACCEPT monetdb:///?autocommit=off
EXPECT autocommit=false
ACCEPT monetdb:///?autocommit=no
EXPECT autocommit=false
```

```test
REJECT monetdb:///?autocommit=
REJECT monetdb:///?autocommit=banana
REJECT monetdb:///?autocommit=0
REJECT monetdb:///?autocommit=1
```

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

### Connection String with IPv6 Address

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests a connection string using an IPv6 address and port, disabling scan.

```test
ACCEPT monetdb://[2001:0db8:85a3:0000:0000:8a2e:0370:7334]:12345/demo
EXPECT host=2001:0db8:85a3:0000:0000:8a2e:0370:7334
EXPECT connect_scan=false
EXPECT connect_unix=
EXPECT connect_tcp=2001:0db8:85a3:0000:0000:8a2e:0370:7334
EXPECT connect_port=12345
EXPECT tls=off
EXPECT database=demo
```

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

### Setting Binary Protocol Option via Connection URL

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/batchsize.md

Configure pymonetdb to use the binary result set format by passing the 'binary=0' parameter in the connection URL. This ensures efficient parsing of subsequent batches.

```python
pymonetdb.connect('monetdb://localhost/demo?binary=0')
```

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

### Connection String with Hostname and No Scan

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests a connection string with a hostname, disabling scan, and specifying TCP/port details.

```test
ACCEPT monetdb://localhost./demo
EXPECT connect_scan=false
EXPECT connect_unix=
EXPECT connect_tcp=localhost
EXPECT connect_port=50000
EXPECT tls=off
EXPECT database=demo
```

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

### Database Specific Connection Variants

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests connection parameters when a specific database name is provided.

```test
ACCEPT monetdb:///demo
EXPECT connect_scan=on
```

```test
ACCEPT monetdb:///demo?sock=/a/path
EXPECT connect_scan=off
EXPECT connect_unix=/a/path
EXPECT connect_tcp=
```

```test
ACCEPT monetdb://localhost/demo
EXPECT connect_scan=on
```

```test
ACCEPT monetdb://localhost/demo?sock=/a/path
EXPECT connect_scan=off
EXPECT connect_unix=/a/path
EXPECT connect_tcp=
```

```test
ACCEPT monetdb://localhost./demo
EXPECT connect_scan=off
EXPECT connect_unix=
EXPECT connect_tcp=localhost
```

```test
REJECT monetdb://localhost./?sock=/a/path
```

```test
ACCEPT monetdb://not.localhost/demo
EXPECT connect_scan=off
EXPECT connect_unix=
EXPECT connect_tcp=not.localhost
```

```test
REJECT monetdb://not.localhost/?sock=/a/path
```

```test
ACCEPT monetdbs:///demo
EXPECT connect_scan=off
EXPECT connect_unix=
EXPECT connect_tcp=localhost
```

```test
REJECT monetdbs:///?sock=/a/path
```

```test
ACCEPT monetdbs://localhost/demo
EXPECT connect_scan=off
EXPECT connect_unix=
EXPECT connect_tcp=localhost
```

```test
REJECT monetdbs://localhost/?sock=/a/path
```

```test
ACCEPT monetdbs://localhost./demo
EXPECT connect_scan=off
EXPECT connect_unix=
EXPECT connect_tcp=localhost
```

```test
REJECT monetdbs://localhost./?sock=/a/path
```

```test
ACCEPT monetdbs://not.localhost/demo
EXPECT connect_scan=off
EXPECT connect_unix=
EXPECT connect_tcp=not.localhost
```

```test
REJECT monetdbs://not.localhost/?sock=/a/path
```

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

### Valid Database Name Constraints

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Demonstrates valid characters and formats for MonetDB database names. These include alphanumeric characters, underscores, and hyphens.

```test
SET database=
EXPECT valid=yes
SET database=banana
EXPECT valid=yes
SET database=UPPERCASE
EXPECT valid=yes
SET database=_under_score_
EXPECT valid=yes
SET database=with-dashes
EXPECT valid=yes
```

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

### Disable Binary Connection

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Disables binary connections by setting connect_binary to 0. Use 'off', 'no', or 'false' to disable.

```test
ACCEPT monetdb:///?binary=off
EXPECT connect_binary=0

ACCEPT monetdb:///?binary=no
EXPECT connect_binary=0

ACCEPT monetdb:///?binary=false
EXPECT connect_binary=0
```

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

### Setting Binary Protocol Option via connect() Parameter

Source: https://github.com/monetdb/pymonetdb/blob/master/doc/batchsize.md

Disable the use of the binary result set format by setting the 'binary' parameter to 0 in the pymonetdb.connect() function. This can be useful for specific compatibility or debugging needs.

```python
pymonetdb.connect('demo', binary=0)
```

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

### TLS Connection Variants

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests different combinations of connection parameters for secure (TLS) MonetDB connections.

```test
ACCEPT monetdbs:///
EXPECT connect_scan=off
EXPECT connect_unix=
EXPECT connect_tcp=localhost
```

```test
REJECT monetdbs:///?sock=/a/path
```

```test
ACCEPT monetdbs://localhost/
EXPECT connect_scan=off
EXPECT connect_unix=
EXPECT connect_tcp=localhost
```

```test
REJECT monetdbs://localhost/?sock=/a/path
```

```test
ACCEPT monetdbs://localhost./
EXPECT connect_scan=off
EXPECT connect_unix=
EXPECT connect_tcp=localhost
```

```test
REJECT monetdbs://localhost./?sock=/a/path
```

```test
ACCEPT monetdbs://not.localhost/
EXPECT connect_scan=off
EXPECT connect_unix=
EXPECT connect_tcp=not.localhost
```

```test
REJECT monetdbs://not.localhost/?sock=/a/path
```

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

### Connection String with Hostname, Port, and No Scan

Source: https://github.com/monetdb/pymonetdb/blob/master/tests/tests.md

Tests a connection string with a specific hostname and port, disabling scan.

```test
ACCEPT monetdb://localhost.:12345/demo
EXPECT connect_scan=false
EXPECT connect_unix=
EXPECT connect_tcp=localhost
EXPECT connect_port=12345
EXPECT tls=off
EXPECT database=demo
```