postgres.New - Code Metrics - Inspection of "refactor(database): streamline default query execu..." - Permify/permify - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#1239)

by Tolga

created 2024-05-04 12:33 UTC

postgres.New B

↳ Parent: pkg/database/postgres/postgres.go

Complexity

Conditions

Size

Total Lines	57
Code Lines	37

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	6
eloc	37
nop	2
dl	0
loc	57
rs	8.0586
c	0
b	0
f	0

How to fix Long Method

package postgres

import (
	"context"
	"strings"
	"time"

	"github.com/jackc/pgx/v5"

	"github.com/jackc/pgx/v5/pgxpool"

	"github.com/Masterminds/squirrel"
)

// Postgres - Structure for Postresql instance
type Postgres struct {
	ReadPool  *pgxpool.Pool
	WritePool *pgxpool.Pool

	Builder squirrel.StatementBuilderType
	// options
	maxDataPerWrite       int
	maxRetries            int
	watchBufferSize       int
	maxConnectionLifeTime time.Duration
	maxConnectionIdleTime time.Duration
	maxOpenConnections    int
	maxIdleConnections    int
}

// New - Creates new postgresql db instance
func New(uri string, opts ...Option) (*Postgres, error) {
	pg := &Postgres{
		maxOpenConnections: _defaultMaxOpenConnections,
		maxIdleConnections: _defaultMaxIdleConnections,
		maxDataPerWrite:    _defaultMaxDataPerWrite,
		maxRetries:         _defaultMaxRetries,
		watchBufferSize:    _defaultWatchBufferSize,
	}

	// Custom options
	for _, opt := range opts {
		opt(pg)
	}

	pg.Builder = squirrel.StatementBuilder.PlaceholderFormat(squirrel.Dollar)

	writeConfig, err := pgxpool.ParseConfig(uri)
	if err != nil {
		return nil, err
	}

	readConfig, err := pgxpool.ParseConfig(uri)
	if err != nil {
		return nil, err
	}

	setDefaultQueryExecMode(writeConfig.ConnConfig)
	setDefaultQueryExecMode(readConfig.ConnConfig)

	writeConfig.MinConns = int32(pg.maxIdleConnections)
	readConfig.MinConns = int32(pg.maxIdleConnections)

	writeConfig.MaxConns = int32(pg.maxOpenConnections)
	readConfig.MaxConns = int32(pg.maxOpenConnections)

	writeConfig.MaxConnIdleTime = pg.maxConnectionIdleTime
	readConfig.MaxConnIdleTime = pg.maxConnectionIdleTime

	writeConfig.MaxConnLifetime = pg.maxConnectionLifeTime
	readConfig.MaxConnLifetime = pg.maxConnectionLifeTime

	writeConfig.MaxConnLifetimeJitter = time.Duration(0.2 * float64(pg.maxConnectionLifeTime))
	readConfig.MaxConnLifetimeJitter = time.Duration(0.2 * float64(pg.maxConnectionLifeTime))

	initialContext, cancelInit := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancelInit()

	pg.WritePool, err = pgxpool.NewWithConfig(initialContext, writeConfig)
	if err != nil {
		return nil, err
	}
	pg.ReadPool, err = pgxpool.NewWithConfig(initialContext, readConfig)
	if err != nil {
		return nil, err
	}

	return pg, nil
}

func (p *Postgres) GetMaxDataPerWrite() int {
	return p.maxDataPerWrite
}

func (p *Postgres) GetMaxRetries() int {
	return p.maxRetries
}

func (p *Postgres) GetWatchBufferSize() int {
	return p.watchBufferSize
}

// GetEngineType - Get the engine type which is postgresql in string
func (p *Postgres) GetEngineType() string {
	return "postgres"
}

// Close - Close postgresql instance
func (p *Postgres) Close() error {
	p.ReadPool.Close()
	p.WritePool.Close()
	return nil
}

// IsReady - Check if database is ready
func (p *Postgres) IsReady(ctx context.Context) (bool, error) {
	ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
	defer cancel()
	if err := p.ReadPool.Ping(ctx); err != nil {
		return false, err
	}
	return true, nil
}

var queryExecModes = map[string]pgx.QueryExecMode{
	"cache_statement": pgx.QueryExecModeCacheStatement,
	"cache_describe":  pgx.QueryExecModeCacheDescribe,
	"describe_exec":   pgx.QueryExecModeDescribeExec,
	"mode_exec":       pgx.QueryExecModeExec,
	"simple_protocol": pgx.QueryExecModeSimpleProtocol,
}

func setDefaultQueryExecMode(config *pgx.ConnConfig) {
	// Default mode if no specific mode is found in the connection string
	defaultMode := "cache_statement"

	// Iterate through the map keys to check if any are mentioned in the connection string
	for key := range queryExecModes {
		if strings.Contains(config.ConnString(), "default_query_exec_mode="+key) {
			config.DefaultQueryExecMode = queryExecModes[key]
			return
		}
	}

	// Set to default mode if no matching mode is found
	config.DefaultQueryExecMode = queryExecModes[defaultMode]
}


1			package postgres
2
3			import (
4			"context"
5			"strings"
6			"time"
7
8			"github.com/jackc/pgx/v5"
9
10			"github.com/jackc/pgx/v5/pgxpool"
11
12			"github.com/Masterminds/squirrel"
13			)
14
15			// Postgres - Structure for Postresql instance
16			type Postgres struct {
17			ReadPool *pgxpool.Pool
18			WritePool *pgxpool.Pool
19
20			Builder squirrel.StatementBuilderType
21			// options
22			maxDataPerWrite int
23			maxRetries int
24			watchBufferSize int
25			maxConnectionLifeTime time.Duration
26			maxConnectionIdleTime time.Duration
27			maxOpenConnections int
28			maxIdleConnections int
29			}
30
31			// New - Creates new postgresql db instance
32			func New(uri string, opts ...Option) (*Postgres, error) {
33			pg := &Postgres{
34			maxOpenConnections: _defaultMaxOpenConnections,
35			maxIdleConnections: _defaultMaxIdleConnections,
36			maxDataPerWrite: _defaultMaxDataPerWrite,
37			maxRetries: _defaultMaxRetries,
38			watchBufferSize: _defaultWatchBufferSize,
39			}
40
41			// Custom options
42			for _, opt := range opts {
43			opt(pg)
44			}
45
46			pg.Builder = squirrel.StatementBuilder.PlaceholderFormat(squirrel.Dollar)
47
48			writeConfig, err := pgxpool.ParseConfig(uri)
49			if err != nil {
50			return nil, err
51			}
52
53			readConfig, err := pgxpool.ParseConfig(uri)
54			if err != nil {
55			return nil, err
56			}
57
58			setDefaultQueryExecMode(writeConfig.ConnConfig)
59			setDefaultQueryExecMode(readConfig.ConnConfig)
60
61			writeConfig.MinConns = int32(pg.maxIdleConnections)
62			readConfig.MinConns = int32(pg.maxIdleConnections)
63
64			writeConfig.MaxConns = int32(pg.maxOpenConnections)
65			readConfig.MaxConns = int32(pg.maxOpenConnections)
66
67			writeConfig.MaxConnIdleTime = pg.maxConnectionIdleTime
68			readConfig.MaxConnIdleTime = pg.maxConnectionIdleTime
69
70			writeConfig.MaxConnLifetime = pg.maxConnectionLifeTime
71			readConfig.MaxConnLifetime = pg.maxConnectionLifeTime
72
73			writeConfig.MaxConnLifetimeJitter = time.Duration(0.2 * float64(pg.maxConnectionLifeTime))
74			readConfig.MaxConnLifetimeJitter = time.Duration(0.2 * float64(pg.maxConnectionLifeTime))
75
76			initialContext, cancelInit := context.WithTimeout(context.Background(), 5*time.Second)
77			defer cancelInit()
78
79			pg.WritePool, err = pgxpool.NewWithConfig(initialContext, writeConfig)
80			if err != nil {
81			return nil, err
82			}
83			pg.ReadPool, err = pgxpool.NewWithConfig(initialContext, readConfig)
84			if err != nil {
85			return nil, err
86			}
87
88			return pg, nil
89			}
90
91			func (p *Postgres) GetMaxDataPerWrite() int {
92			return p.maxDataPerWrite
93			}
94
95			func (p *Postgres) GetMaxRetries() int {
96			return p.maxRetries
97			}
98
99			func (p *Postgres) GetWatchBufferSize() int {
100			return p.watchBufferSize
101			}
102
103			// GetEngineType - Get the engine type which is postgresql in string
104			func (p *Postgres) GetEngineType() string {
105			return "postgres"
106			}
107
108			// Close - Close postgresql instance
109			func (p *Postgres) Close() error {
110			p.ReadPool.Close()
111			p.WritePool.Close()
112			return nil
113			}
114
115			// IsReady - Check if database is ready
116			func (p *Postgres) IsReady(ctx context.Context) (bool, error) {
117			ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
118			defer cancel()
119			if err := p.ReadPool.Ping(ctx); err != nil {
120			return false, err
121			}
122			return true, nil
123			}
124
125			var queryExecModes = map[string]pgx.QueryExecMode{
126			"cache_statement": pgx.QueryExecModeCacheStatement,
127			"cache_describe": pgx.QueryExecModeCacheDescribe,
128			"describe_exec": pgx.QueryExecModeDescribeExec,
129			"mode_exec": pgx.QueryExecModeExec,
130			"simple_protocol": pgx.QueryExecModeSimpleProtocol,
131			}
132
133			func setDefaultQueryExecMode(config *pgx.ConnConfig) {
134			// Default mode if no specific mode is found in the connection string
135			defaultMode := "cache_statement"
136
137			// Iterate through the map keys to check if any are mentioned in the connection string
138			for key := range queryExecModes {
139			if strings.Contains(config.ConnString(), "default_query_exec_mode="+key) {
140			config.DefaultQueryExecMode = queryExecModes[key]
141			return
142			}
143			}
144
145			// Set to default mode if no matching mode is found
146			config.DefaultQueryExecMode = queryExecModes[defaultMode]
147			}
148

Permify / permify

Pull Request — master (#1239)

postgres.New B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like