# Connection Pooling in Turso Language Bindings: Go, Python, and JavaScript

> Discover how Turso language bindings manage connection pooling in Go, Python, and JavaScript. Explore idiomatic implementations for efficient database access with Turso.

- Repository: [Turso Database/turso](https://github.com/tursodatabase/turso)
- Tags: how-to-guide
- Published: 2026-06-22

---

**Turso language bindings implement connection pooling idiomatically for each runtime: Go leverages the standard `database/sql` pool, Python delegates to SQLAlchemy's pool classes, and JavaScript maintains a single connection per `Database` instance that can be scaled horizontally via multiple instances.**

Turso provides official language bindings for Go, Python, and JavaScript that integrate SQLite connection management through native pooling mechanisms. Understanding how connection pooling works in these specific implementations helps developers optimize database performance and resource utilization. This article examines the architectural patterns, source file locations, and configuration options for each binding in the tursodatabase/turso repository.

## Go Connection Pooling via database/sql

The Go binding integrates with the standard library's `database/sql` package, leveraging its mature connection pool rather than implementing a custom solution.

### The tursoSyncConnector Implementation

In [`bindings/go/driver_sync.go`](https://github.com/tursodatabase/turso/blob/main/bindings/go/driver_sync.go), the `tursoSyncConnector` struct implements the `driver.Connector` interface. This design allows the binding to plug directly into Go's standard database tools while managing Turso-specific sync connections.

The `Connect` method creates a raw Turso sync connection, wraps it using `NewConnection`, and returns it as a `driver.Conn` to the `database/sql` pool manager. When you invoke `sql.OpenDB` with the connector, Go automatically manages a pool of these connections based on its internal heuristics.

### Configuring Pool Limits

You tune the pool using the standard `*sql.DB` configuration methods exposed by Go's standard library:

```go
db.SetMaxOpenConns(10)
db.SetMaxIdleConns(5)

```

These settings control the maximum open connections and idle connections maintained by the pool, following Go's standard `database/sql` behavior. The `tursoSyncConnector` supplies connections to this pool but does not implement custom pooling logic itself.

### Go Example

```go
import (
    "context"
    "database/sql"
    "github.com/tursodatabase/turso/bindings/go"
)

func main() {
    cfg := turso.Config{
        AuthToken: "YOUR_TOKEN",
        Namespace: "my-namespace",
    }
    syncDb, _ := turso.NewSyncDatabase(cfg, nil)
    db, _ := syncDb.Connect(context.Background()) // *sql.DB

    // Tune pool (optional)
    db.SetMaxOpenConns(10)
    db.SetMaxIdleConns(5)

    // Use the DB as usual
    rows, _ := db.Query("SELECT * FROM my_table")
    // …
}

```

## Python Connection Pooling with SQLAlchemy

The Python binding defers entirely to SQLAlchemy's pool classes, automatically selecting the appropriate implementation based on your connection URL and async mode.

### Pool Selection Logic

In [`bindings/python/turso/sqlalchemy/dialect.py`](https://github.com/tursodatabase/turso/blob/main/bindings/python/turso/sqlalchemy/dialect.py), the `get_pool_class` function inspects the URL to determine which pool class to instantiate. The dialect automatically selects:

- **SingletonThreadPool** for in-memory databases (`:memory:`)
- **QueuePool** for file-based databases
- **AsyncAdaptedQueuePool** for async engines
- **StaticPool** for memory-only async connections

This mirrors SQLite's standard behavior while adapting to Turso's sync capabilities. The selection logic handles the `async` query parameter and database type to ensure optimal connection management for your specific workload.

### Python Example

```python
from sqlalchemy import create_engine
from turso.sqlalchemy import TursoDialect  # registers itself as "turso"

# File‑based DB – gets a QueuePool

engine = create_engine(
    "turso:///path/to/database.db?authToken=YOUR_TOKEN",
    echo=True,
)

# In‑memory DB – gets a SingletonThreadPool

mem_engine = create_engine(
    "turso:///:memory:?authToken=YOUR_TOKEN",
    echo=True,
)

# Async engine – gets AsyncAdaptedQueuePool

async_engine = create_engine(
    "turso+aiosqlite:///path/to/database.db?authToken=YOUR_TOKEN",
    future=True,
)

# Use the engine

with engine.begin() as conn:
    conn.execute("SELECT * FROM my_table")

```

## JavaScript Connection Management

Unlike Go and Python, the JavaScript binding does not expose an explicit connection pool. Instead, it implements a single-connection-per-instance model that aligns with Node.js's single-threaded event loop architecture.

### Single Connection Architecture

Each `Database` instance created via `@tursodatabase/database` owns exactly one native SQLite connection (`sqlite3*`). This implementation resides in [`bindings/javascript/sync/src/js_protocol_io.rs`](https://github.com/tursodatabase/turso/blob/main/bindings/javascript/sync/src/js_protocol_io.rs), where the `Database` struct holds the connection for its lifetime.

The binding reuses this same connection for repeated statements on the same instance, which serves as a de-facto pool for that specific object. Because Node.js operates on a single-threaded event loop, the typical pattern involves creating a `Database` instance per request or worker for concurrency.

### Horizontal Scaling Pattern

To achieve parallelism, applications instantiate multiple `Database` objects. For serverless sync deployments using `@tursodatabase/serverless`, each `Database` internally holds a sync client that maintains its own HTTP connection pool to Turso Cloud.

### JavaScript Example

```javascript
import { Database } from "@tursodatabase/database";

const db = new Database({
  url: "libsql://my-instance.turso.io",
  authToken: "YOUR_TOKEN",
});

// Each Database instance owns its own connection.
await db.exec("CREATE TABLE IF NOT EXISTS items (id INTEGER PRIMARY KEY, name TEXT)");

// For concurrent work, create additional instances:
const db2 = new Database({ url: db.url, authToken: db.authToken });
await db2.exec("INSERT INTO items (name) VALUES ('second')");

// Close when done
await db.close();
await db2.close();

```

## Summary

- **Go** bindings rely on the standard `database/sql` pool, exposing full tuning capabilities via `SetMaxOpenConns` and `SetMaxIdleConns` through the `tursoSyncConnector` in [`bindings/go/driver_sync.go`](https://github.com/tursodatabase/turso/blob/main/bindings/go/driver_sync.go).
- **Python** bindings delegate pool selection to SQLAlchemy, automatically choosing between `SingletonThreadPool`, `QueuePool`, and `AsyncAdaptedQueuePool` based on the URL parameters defined in [`bindings/python/turso/sqlalchemy/dialect.py`](https://github.com/tursodatabase/turso/blob/main/bindings/python/turso/sqlalchemy/dialect.py).
- **JavaScript** bindings maintain a single `sqlite3*` connection per `Database` instance without configurable pooling, requiring multiple instances for concurrent workloads as implemented in [`bindings/javascript/sync/src/js_protocol_io.rs`](https://github.com/tursodatabase/turso/blob/main/bindings/javascript/sync/src/js_protocol_io.rs).

## Frequently Asked Questions

### How does Turso's Go binding handle connection pool sizing?

The Go binding defers to the standard `database/sql` pool management. After obtaining a `*sql.DB` from `tursoSyncConnector`, you configure pool limits using `SetMaxOpenConns()` and `SetMaxIdleConns()`. The connector in [`bindings/go/driver_sync.go`](https://github.com/tursodatabase/turso/blob/main/bindings/go/driver_sync.go) supplies connections to this pool but does not implement custom pooling logic itself.

### What SQLAlchemy pool class does Turso use for in-memory databases?

For in-memory databases (`:memory:`), the Turso dialect in [`bindings/python/turso/sqlalchemy/dialect.py`](https://github.com/tursodatabase/turso/blob/main/bindings/python/turso/sqlalchemy/dialect.py) selects `SingletonThreadPool`, which maintains a single connection per thread. This matches SQLite's behavior for memory-only databases and prevents unnecessary connection overhead.

### Does the Turso JavaScript SDK support configurable connection pools?

No, the JavaScript SDK does not expose configurable connection pooling. Each `Database` instance maintains exactly one native SQLite connection (`sqlite3*`) as defined in [`bindings/javascript/sync/src/js_protocol_io.rs`](https://github.com/tursodatabase/turso/blob/main/bindings/javascript/sync/src/js_protocol_io.rs). For concurrent workloads, you must create multiple `Database` instances, which scales horizontally rather than using a traditional pool.

### Which source file implements the connector interface in Turso's Go driver?

The `driver.Connector` interface is implemented in [`bindings/go/driver_sync.go`](https://github.com/tursodatabase/turso/blob/main/bindings/go/driver_sync.go) by the `tursoSyncConnector` struct. This file contains the `Connect` method that creates Turso sync connections and integrates with Go's `database/sql` pool.