fix linter errors

runtime/caches.go

@@ -5,23 +5,27 @@ import (
 	"fmt"
 	"sync"
 
+
+	"go.uber.org/zap"
+
 	lru "github.com/hashicorp/golang-lru"
 	"github.com/hashicorp/golang-lru/simplelru"
 	"github.com/rilldata/rill/runtime/drivers"
 	"github.com/rilldata/rill/runtime/services/catalog"
 )
 
 type connectionCache struct {
-	cache *simplelru.LRU
-	lock  sync.Mutex
+	cache  *simplelru.LRU
+	lock   sync.Mutex
+	logger *zap.Logger
 }
 
-func newConnectionCache(size int) *connectionCache {
+func newConnectionCache(size int, logger *zap.Logger) *connectionCache {
 	cache, err := simplelru.NewLRU(size, nil)
 	if err != nil {
 		panic(err)
 	}
-	return &connectionCache{cache: cache}
+	return &connectionCache{cache: cache, logger: logger}
 }
 
 func (c *connectionCache) get(ctx context.Context, instanceID, driver, dsn string) (drivers.Connection, error) {
@@ -34,7 +38,7 @@ func (c *connectionCache) get(ctx context.Context, instanceID, driver, dsn strin
 	key := instanceID + driver + dsn
 	val, ok := c.cache.Get(key)
 	if !ok {
-		conn, err := drivers.Open(driver, dsn)
+		conn, err := drivers.Open(driver, dsn, c.logger)
 		if err != nil {
 			return nil, err
 		}

runtime/drivers/drivers.go

@@ -4,6 +4,8 @@ import (
 	"context"
 	"errors"
 	"fmt"
+
+	"go.uber.org/zap"
 )
 
 // ErrClosed indicates the connection is closed.
@@ -24,13 +26,13 @@ func Register(name string, driver Driver) {
 }
 
 // Open opens a new connection
-func Open(driver string, dsn string) (Connection, error) {
+func Open(driver, dsn string, logger *zap.Logger) (Connection, error) {
 	d, ok := Drivers[driver]
 	if !ok {
 		return nil, fmt.Errorf("unknown database driver: %s", driver)
 	}
 
-	conn, err := d.Open(dsn)
+	conn, err := d.Open(dsn, logger)
 	if err != nil {
 		return nil, err
 	}
@@ -40,7 +42,7 @@ func Open(driver string, dsn string) (Connection, error) {
 
 // Driver represents an underlying DB.
 type Driver interface {
-	Open(dsn string) (Connection, error)
+	Open(dsn string, logger *zap.Logger) (Connection, error)
 }
 
 // Connection represents a connection to an underlying DB.

runtime/drivers/druid/druid.go

@@ -3,6 +3,8 @@ package druid
 import (
 	"context"
 
+	"go.uber.org/zap"
+
 	"github.com/jmoiron/sqlx"
 	"github.com/rilldata/rill/runtime/drivers"
 
@@ -18,7 +20,7 @@ type driver struct{}
 
 // Open connects to Druid using Avatica.
 // Note that the Druid connection string must have the form "http://host/druid/v2/sql/avatica-protobuf/".
-func (d driver) Open(dsn string) (drivers.Connection, error) {
+func (d driver) Open(dsn string, logger *zap.Logger) (drivers.Connection, error) {
 	db, err := sqlx.Open("avatica", dsn)
 	if err != nil {
 		return nil, err

runtime/drivers/duckdb/catalog.go

@@ -144,7 +144,7 @@ func (c *connection) UpdateEntry(ctx context.Context, instanceID string, e *driv
 	return nil
 }
 
-func (c *connection) DeleteEntry(ctx context.Context, instanceID string, name string) error {
+func (c *connection) DeleteEntry(ctx context.Context, instanceID, name string) error {
 	conn, release, err := c.getConn(ctx)
 	defer release()
 	if err != nil {

runtime/drivers/duckdb/duckdb.go

@@ -4,8 +4,10 @@ import (
 	"context"
 	"database/sql"
 	"database/sql/driver"
+
 	"github.com/jmoiron/sqlx"
 	"github.com/marcboeker/go-duckdb"
+	"go.uber.org/zap"
 
 	"github.com/rilldata/rill/runtime/drivers"
 
@@ -18,30 +20,32 @@ func init() {
 
 type Driver struct{}
 
-func (d Driver) Open(dsn string) (drivers.Connection, error) {
+func (d Driver) Open(dsn string, logger *zap.Logger) (drivers.Connection, error) {
 	cfg, err := newConfig(dsn)
 	if err != nil {
 		return nil, err
 	}
-	connector, err := duckdb.NewConnector(cfg.DSN, func(execer driver.Execer) error {
-		bootQueries := []string{
-			"INSTALL 'json'",
-			"LOAD 'json'",
-			"INSTALL 'parquet'",
-			"LOAD 'parquet'",
-			"INSTALL 'httpfs'",
-			"LOAD 'httpfs'",
-			"SET max_expression_depth TO 250",
-		}
-
-		for _, qry := range bootQueries {
-			_, err = execer.Exec(qry, nil)
-			if err != nil {
-				return err
+	connector, err := duckdb.NewConnector(cfg.DSN,
+		// nolint:staticcheck // TODO: remove when go-duckdb implements the driver.ExecerContext interface
+		func(execer driver.Execer) error {
+			bootQueries := []string{
+				"INSTALL 'json'",
+				"LOAD 'json'",
+				"INSTALL 'parquet'",
+				"LOAD 'parquet'",
+				"INSTALL 'httpfs'",
+				"LOAD 'httpfs'",
+				"SET max_expression_depth TO 250",
+			}
+
+			for _, qry := range bootQueries {
+				_, err = execer.Exec(qry, nil)
+				if err != nil {
+					return err
+				}
 			}
-		}
-		return nil
-	})
+			return nil
+		})
 	if err != nil {
 		return nil, err
 	}
@@ -51,16 +55,18 @@ func (d Driver) Open(dsn string) (drivers.Connection, error) {
 	db.SetMaxOpenConns(cfg.PoolSize)
 
 	c := &connection{
-		db:  db,
-		sem: priorityqueue.NewSemaphore(cfg.PoolSize),
+		db:     db,
+		sem:    priorityqueue.NewSemaphore(cfg.PoolSize),
+		logger: logger,
 	}
 
 	return c, nil
 }
 
 type connection struct {
-	db  *sqlx.DB
-	sem *priorityqueue.Semaphore
+	db     *sqlx.DB
+	sem    *priorityqueue.Semaphore
+	logger *zap.Logger
 }
 
 // Close implements drivers.Connection.
@@ -90,16 +96,26 @@ func (c *connection) OLAPStore() (drivers.OLAPStore, bool) {
 
 // getConn gets a connection from the pool.
 // It returns a function that puts the connection back in the pool if applicable.
-func (c *connection) getConn(ctx context.Context) (conn *sqlx.Conn, release func() error, err error) {
+func (c *connection) getConn(ctx context.Context) (conn *sqlx.Conn, release func(), err error) {
 	// Try to get conn from context
 	conn = connFromContext(ctx)
 	if conn != nil {
-		return conn, func() error { return nil }, nil
+		return conn, func() {}, nil
 	}
 
 	conn, err = c.db.Connx(ctx)
 	if err != nil {
 		return nil, nil, err
 	}
-	return conn, conn.Close, nil
+	release = func() {
+		// call release in a goroutine as it will block until rows.close() is called so if a method returns rows
+		// and the caller is responsible for closing them, the method will not return and cause deadlock
+		go func() {
+			err := conn.Close()
+			if err != nil {
+				c.logger.Error("error releasing connection", zap.Error(err))
+			}
+		}()
+	}
+	return conn, release, nil
 }

runtime/drivers/duckdb/migrate.go

@@ -121,7 +121,7 @@ func (c *connection) migrateSingle(ctx context.Context, conn *sqlx.Conn, name st
 }
 
 // MigrationStatus implements drivers.Connection.
-func (c *connection) MigrationStatus(ctx context.Context) (current int, desired int, err error) {
+func (c *connection) MigrationStatus(ctx context.Context) (current, desired int, err error) {
 	conn, release, err := c.getConn(ctx)
 	if err != nil {
 		return 0, 0, err

runtime/drivers/duckdb/olap.go

@@ -58,11 +58,7 @@ func (c *connection) Execute(ctx context.Context, stmt *drivers.Statement) (*dri
 		if err != nil {
 			return nil, err
 		}
-		defer func() {
-			// call release in a goroutine as it will block until rows.close() is called
-			// TODO log error
-			go release()
-		}()
+		defer release()
 		conn = connx
 	}
 

runtime/drivers/file/file.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"os"
+	"go.uber.org/zap"
 
 	"github.com/rilldata/rill/runtime/drivers"
 )
@@ -14,7 +15,7 @@ func init() {
 
 type driver struct{}
 
-func (d driver) Open(dsn string) (drivers.Connection, error) {
+func (d driver) Open(dsn string, logger *zap.Logger) (drivers.Connection, error) {
 	c := &connection{root: dsn}
 	if err := c.checkRoot(); err != nil {
 		return nil, err

runtime/drivers/postgres/postgres.go

@@ -3,6 +3,7 @@ package postgres
 import (
 	"github.com/jmoiron/sqlx"
 	"github.com/rilldata/rill/runtime/drivers"
+	"go.uber.org/zap"
 
 	// Load postgres driver
 	_ "github.com/jackc/pgx/v4/stdlib"
@@ -14,7 +15,7 @@ func init() {
 
 type driver struct{}
 
-func (d driver) Open(dsn string) (drivers.Connection, error) {
+func (d driver) Open(dsn string, logger *zap.Logger) (drivers.Connection, error) {
 	db, err := sqlx.Connect("pgx", dsn)
 	if err != nil {
 		return nil, err

runtime/drivers/sqlite/sqlite.go

@@ -3,6 +3,7 @@ package sqlite
 import (
 	"github.com/jmoiron/sqlx"
 	"github.com/rilldata/rill/runtime/drivers"
+	"go.uber.org/zap"
 
 	// Load sqlite driver
 	_ "modernc.org/sqlite"
@@ -14,7 +15,7 @@ func init() {
 
 type driver struct{}
 
-func (d driver) Open(dsn string) (drivers.Connection, error) {
+func (d driver) Open(dsn string, logger *zap.Logger) (drivers.Connection, error) {
 	db, err := sqlx.Connect("sqlite", dsn)
 	if err != nil {
 		return nil, err

runtime/pkg/priorityqueue/semaphore.go

@@ -30,7 +30,7 @@ func NewSemaphore(size int) *Semaphore {
 func (s *Semaphore) Acquire(ctx context.Context, priority int) error {
 	s.mu.Lock()
 	if s.size-s.cur >= 1 && s.pq.Len() == 0 {
-		s.cur += 1
+		s.cur++
 		s.mu.Unlock()
 		return nil
 	}
@@ -61,7 +61,7 @@ func (s *Semaphore) TryAcquire() bool {
 	s.mu.Lock()
 	ok := s.size-s.cur >= 1 && s.pq.Len() == 0
 	if ok {
-		s.cur += 1
+		s.cur++
 	}
 	s.mu.Unlock()
 	return ok
@@ -70,7 +70,7 @@ func (s *Semaphore) TryAcquire() bool {
 // Release releases a semaphore previously acquired with Acquire or TryAcquire.
 func (s *Semaphore) Release() {
 	s.mu.Lock()
-	s.cur -= 1
+	s.cur--
 	if s.cur < 0 {
 		s.mu.Unlock()
 		panic("semaphore released more times than acquired")

runtime/registry.go

@@ -18,7 +18,7 @@ func (r *Runtime) FindInstance(ctx context.Context, instanceID string) (*drivers
 
 func (r *Runtime) CreateInstance(ctx context.Context, inst *drivers.Instance) error {
 	// Check OLAP connection
-	olap, err := drivers.Open(inst.OLAPDriver, inst.OLAPDSN)
+	olap, err := drivers.Open(inst.OLAPDriver, inst.OLAPDSN, r.logger)
 	if err != nil {
 		return err
 	}
@@ -28,7 +28,7 @@ func (r *Runtime) CreateInstance(ctx context.Context, inst *drivers.Instance) er
 	}
 
 	// Check repo connection
-	repo, err := drivers.Open(inst.RepoDriver, inst.RepoDSN)
+	repo, err := drivers.Open(inst.RepoDriver, inst.RepoDSN, r.logger)
 	if err != nil {
 		return err
 	}

runtime/runtime.go

@@ -26,7 +26,7 @@ type Runtime struct {
 
 func New(opts *Options, logger *zap.Logger) (*Runtime, error) {
 	// Open metadata db connection
-	metastore, err := drivers.Open(opts.MetastoreDriver, opts.MetastoreDSN)
+	metastore, err := drivers.Open(opts.MetastoreDriver, opts.MetastoreDSN, logger)
 	if err != nil {
 		return nil, fmt.Errorf("could not connect to metadata db: %w", err)
 	}
@@ -45,7 +45,7 @@ func New(opts *Options, logger *zap.Logger) (*Runtime, error) {
 		opts:         opts,
 		metastore:    metastore,
 		logger:       logger,
-		connCache:    newConnectionCache(opts.ConnectionCacheSize),
+		connCache:    newConnectionCache(opts.ConnectionCacheSize, logger),
 		catalogCache: newCatalogCache(),
 		queryCache:   newQueryCache(opts.QueryCacheSize),
 	}, nil