Code refactor and improvements in Go/atreugo (#5466)

frameworks/Go/atreugo/src/handlers/handlers.go

@@ -58,14 +58,13 @@ func QueriesHandler(db storage.DB) atreugo.View {
 
 		worlds := storage.AcquireWorlds()[:queries]
 
-		var err error
 		for i := 0; i < queries; i++ {
-			if err = db.GetOneRandomWorld(&worlds[i]); err != nil {
+			if err := db.GetOneRandomWorld(&worlds[i]); err != nil {
 				return err
 			}
 		}
 
-		err = ctx.JSONResponse(worlds)
+		err := ctx.JSONResponse(worlds)
 
 		storage.ReleaseWorlds(worlds)
 
@@ -134,22 +133,21 @@ func FortuneQuickHandler(db storage.DB) atreugo.View {
 func UpdateHandler(db storage.DB) atreugo.View {
 	return func(ctx *atreugo.RequestCtx) error {
 		queries := queriesParam(ctx)
-
-		var err error
-
 		worlds := storage.AcquireWorlds()[:queries]
 
 		for i := 0; i < queries; i++ {
-			if err = db.GetOneRandomWorld(&worlds[i]); err != nil {
+			w := &worlds[i]
+			if err := db.GetOneRandomWorld(w); err != nil {
 				return err
 			}
+			w.RandomNumber = int32(storage.RandomWorldNum())
 		}
 
-		if err = db.UpdateWorlds(worlds); err != nil {
+		if err := db.UpdateWorlds(worlds); err != nil {
 			return err
 		}
 
-		err = ctx.JSONResponse(worlds)
+		err := ctx.JSONResponse(worlds)
 
 		storage.ReleaseWorlds(worlds)
 

frameworks/Go/atreugo/src/handlers/handlers_easyjson.go

@@ -1,8 +1,6 @@
 package handlers
 
 import (
-	"log"
-
 	"atreugo/src/storage"
 
 	"github.com/savsgio/atreugo/v10"
@@ -10,17 +8,16 @@ import (
 
 // JSONHandlerEasyJSON . Test 1: JSON serialization
 func JSONHandlerEasyJSON(ctx *atreugo.RequestCtx) error {
-	ctx.SetContentType("application/json")
-
 	message := AcquireMessage()
-	message.Message = "Hello, World!"
+	message.Message = helloWorldStr
 
 	messageBytes, err := message.MarshalJSON()
 	if err != nil {
 		return err
 	}
 
-	_, err = ctx.Write(messageBytes)
+	ctx.SetContentType("application/json")
+	ctx.Write(messageBytes)
 
 	ReleaseMessage(message)
 
@@ -28,7 +25,7 @@ func JSONHandlerEasyJSON(ctx *atreugo.RequestCtx) error {
 }
 
 // DBHandlerEasyJSON . Test 2: Single database query
-func DBHandlerEasyJSON(db storage.DB) func(ctx *atreugo.RequestCtx) error {
+func DBHandlerEasyJSON(db storage.DB) atreugo.View {
 	return func(ctx *atreugo.RequestCtx) error {
 		world := storage.AcquireWorld()
 
@@ -42,7 +39,7 @@ func DBHandlerEasyJSON(db storage.DB) func(ctx *atreugo.RequestCtx) error {
 		}
 
 		ctx.SetContentType("application/json")
-		_, err = ctx.Write(worldBytes)
+		ctx.Write(worldBytes)
 
 		storage.ReleaseWorld(world)
 
@@ -51,15 +48,14 @@ func DBHandlerEasyJSON(db storage.DB) func(ctx *atreugo.RequestCtx) error {
 }
 
 // QueriesHandlerEasyJSON . Test 3: Multiple database queries
-func QueriesHandlerEasyJSON(db storage.DB) func(ctx *atreugo.RequestCtx) error {
+func QueriesHandlerEasyJSON(db storage.DB) atreugo.View {
 	return func(ctx *atreugo.RequestCtx) error {
 		queries := queriesParam(ctx)
 		worlds := storage.AcquireWorlds()[:queries]
 
-		var err error
 		for i := 0; i < queries; i++ {
-			if err = db.GetOneRandomWorld(&worlds[i]); err != nil {
-				log.Println(err)
+			if err := db.GetOneRandomWorld(&worlds[i]); err != nil {
+				return err
 			}
 		}
 
@@ -69,7 +65,7 @@ func QueriesHandlerEasyJSON(db storage.DB) func(ctx *atreugo.RequestCtx) error {
 		}
 
 		ctx.SetContentType("application/json")
-		_, err = ctx.Write(worldsBytes)
+		ctx.Write(worldsBytes)
 
 		storage.ReleaseWorlds(worlds)
 
@@ -78,19 +74,20 @@ func QueriesHandlerEasyJSON(db storage.DB) func(ctx *atreugo.RequestCtx) error {
 }
 
 // UpdateHandlerEasyJSON . Test 5: Database updates
-func UpdateHandlerEasyJSON(db storage.DB) func(ctx *atreugo.RequestCtx) error {
+func UpdateHandlerEasyJSON(db storage.DB) atreugo.View {
 	return func(ctx *atreugo.RequestCtx) error {
 		queries := queriesParam(ctx)
 		worlds := storage.AcquireWorlds()[:queries]
 
-		var err error
 		for i := 0; i < queries; i++ {
-			if err = db.GetOneRandomWorld(&worlds[i]); err != nil {
-				log.Println(err)
+			w := &worlds[i]
+			if err := db.GetOneRandomWorld(w); err != nil {
+				return err
 			}
+			w.RandomNumber = int32(storage.RandomWorldNum())
 		}
 
-		if err = db.UpdateWorlds(worlds); err != nil {
+		if err := db.UpdateWorlds(worlds); err != nil {
 			return err
 		}
 
@@ -100,7 +97,7 @@ func UpdateHandlerEasyJSON(db storage.DB) func(ctx *atreugo.RequestCtx) error {
 		}
 
 		ctx.SetContentType("application/json")
-		_, err = ctx.Write(worldsBytes)
+		ctx.Write(worldsBytes)
 
 		storage.ReleaseWorlds(worlds)
 

frameworks/Go/atreugo/src/handlers/handlers_gojay.go

@@ -1,8 +1,6 @@
 package handlers
 
 import (
-	"log"
-
 	"atreugo/src/storage"
 
 	"github.com/francoispqt/gojay"
@@ -12,7 +10,7 @@ import (
 // JSONHandlerGoJay . Test 1: JSON serialization
 func JSONHandlerGoJay(ctx *atreugo.RequestCtx) error {
 	message := AcquireMessage()
-	message.Message = "Hello, World!"
+	message.Message = helloWorldStr
 
 	ctx.SetContentType("application/json")
 	err := gojay.NewEncoder(ctx).Encode(message)
@@ -23,7 +21,7 @@ func JSONHandlerGoJay(ctx *atreugo.RequestCtx) error {
 }
 
 // DBHandlerGoJay . Test 2: Single database query
-func DBHandlerGoJay(db storage.DB) func(ctx *atreugo.RequestCtx) error {
+func DBHandlerGoJay(db storage.DB) atreugo.View {
 	return func(ctx *atreugo.RequestCtx) error {
 		world := storage.AcquireWorld()
 
@@ -41,20 +39,19 @@ func DBHandlerGoJay(db storage.DB) func(ctx *atreugo.RequestCtx) error {
 }
 
 // QueriesHandlerGoJay . Test 3: Multiple database queries
-func QueriesHandlerGoJay(db storage.DB) func(ctx *atreugo.RequestCtx) error {
+func QueriesHandlerGoJay(db storage.DB) atreugo.View {
 	return func(ctx *atreugo.RequestCtx) error {
 		queries := queriesParam(ctx)
 		worlds := storage.AcquireWorlds()[:queries]
 
-		var err error
 		for i := 0; i < queries; i++ {
-			if err = db.GetOneRandomWorld(&worlds[i]); err != nil {
-				log.Println(err)
+			if err := db.GetOneRandomWorld(&worlds[i]); err != nil {
+				return err
 			}
 		}
 
 		ctx.SetContentType("application/json")
-		err = gojay.NewEncoder(ctx).EncodeArray(worlds)
+		err := gojay.NewEncoder(ctx).EncodeArray(worlds)
 
 		storage.ReleaseWorlds(worlds)
 
@@ -63,24 +60,25 @@ func QueriesHandlerGoJay(db storage.DB) func(ctx *atreugo.RequestCtx) error {
 }
 
 // UpdateHandlerGoJay . Test 5: Database updates
-func UpdateHandlerGoJay(db storage.DB) func(ctx *atreugo.RequestCtx) error {
+func UpdateHandlerGoJay(db storage.DB) atreugo.View {
 	return func(ctx *atreugo.RequestCtx) error {
 		queries := queriesParam(ctx)
 		worlds := storage.AcquireWorlds()[:queries]
 
-		var err error
 		for i := 0; i < queries; i++ {
-			if err = db.GetOneRandomWorld(&worlds[i]); err != nil {
-				log.Println(err)
+			w := &worlds[i]
+			if err := db.GetOneRandomWorld(w); err != nil {
+				return err
 			}
+			w.RandomNumber = int32(storage.RandomWorldNum())
 		}
 
-		if err = db.UpdateWorlds(worlds); err != nil {
+		if err := db.UpdateWorlds(worlds); err != nil {
 			return err
 		}
 
 		ctx.SetContentType("application/json")
-		err = gojay.NewEncoder(ctx).EncodeArray(worlds)
+		err := gojay.NewEncoder(ctx).EncodeArray(worlds)
 
 		storage.ReleaseWorlds(worlds)
 

frameworks/Go/atreugo/src/handlers/handlers_sjson.go

@@ -1,32 +1,31 @@
 package handlers
 
 import (
-	"log"
-
 	"atreugo/src/storage"
 
 	"github.com/savsgio/atreugo/v10"
 )
 
-
 // JSONHandlerSJson . Test 1: JSON serialization
 func JSONHandlerSJson(ctx *atreugo.RequestCtx) error {
 	message := AcquireMessage()
-	message.Message = "Hello, World!"
+	message.Message = helloWorldStr
 
-	ctx.SetContentType("application/json")
 	data, err := message.MarshalSJSON()
-	if err == nil {
-		_, err = ctx.Write(data)
+	if err != nil {
+		return err
 	}
 
+	ctx.SetContentType("application/json")
+	ctx.Write(data)
+
 	ReleaseMessage(message)
 
-	return err
+	return nil
 }
 
 // DBHandlerSJson . Test 2: Single database query
-func DBHandlerSJson(db storage.DB) func(ctx *atreugo.RequestCtx) error {
+func DBHandlerSJson(db storage.DB) atreugo.View {
 	return func(ctx *atreugo.RequestCtx) error {
 		world := storage.AcquireWorld()
 
@@ -34,66 +33,72 @@ func DBHandlerSJson(db storage.DB) func(ctx *atreugo.RequestCtx) error {
 			return err
 		}
 
-		ctx.SetContentType("application/json")
 		data, err := world.MarshalSJSON()
-		if err == nil {
-			_, err = ctx.Write(data)
+		if err != nil {
+			return err
 		}
 
+		ctx.SetContentType("application/json")
+		ctx.Write(data)
+
 		storage.ReleaseWorld(world)
 
-		return err
+		return nil
 	}
 }
 
 // QueriesHandlerSJson . Test 3: Multiple database queries
-func QueriesHandlerSJson(db storage.DB) func(ctx *atreugo.RequestCtx) error {
+func QueriesHandlerSJson(db storage.DB) atreugo.View {
 	return func(ctx *atreugo.RequestCtx) error {
 		queries := queriesParam(ctx)
 		worlds := storage.AcquireWorlds()[:queries]
 
-		var err error
 		for i := 0; i < queries; i++ {
-			if err = db.GetOneRandomWorld(&worlds[i]); err != nil {
-				log.Println(err)
+			if err := db.GetOneRandomWorld(&worlds[i]); err != nil {
+				return err
 			}
 		}
 
-		ctx.SetContentType("application/json")
 		data, err := worlds.MarshalSJSON()
-		if err == nil {
-			_, err = ctx.Write(data)
+		if err != nil {
+			return err
 		}
 
+		ctx.SetContentType("application/json")
+		ctx.Write(data)
+
 		storage.ReleaseWorlds(worlds)
 
-		return err
+		return nil
 	}
 }
 
 // UpdateHandlerSJson . Test 5: Database updates
-func UpdateHandlerSJson(db storage.DB) func(ctx *atreugo.RequestCtx) error {
+func UpdateHandlerSJson(db storage.DB) atreugo.View {
 	return func(ctx *atreugo.RequestCtx) error {
 		queries := queriesParam(ctx)
 		worlds := storage.AcquireWorlds()[:queries]
 
-		var err error
 		for i := 0; i < queries; i++ {
-			if err = db.GetOneRandomWorld(&worlds[i]); err != nil {
-				log.Println(err)
+			w := &worlds[i]
+			if err := db.GetOneRandomWorld(w); err != nil {
+				return err
 			}
+			w.RandomNumber = int32(storage.RandomWorldNum())
 		}
 
-		if err = db.UpdateWorlds(worlds); err != nil {
+		if err := db.UpdateWorlds(worlds); err != nil {
 			return err
 		}
 
-		ctx.SetContentType("application/json")
 		data, err := worlds.MarshalSJSON()
-		if err == nil {
-			_, err = ctx.Write(data)
+		if err != nil {
+			return err
 		}
 
+		ctx.SetContentType("application/json")
+		ctx.Write(data)
+
 		storage.ReleaseWorlds(worlds)
 
 		return err

frameworks/Go/atreugo/src/main.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"flag"
+	"fmt"
 	"log"
 	"net"
 	"os"
@@ -18,26 +19,37 @@ var prefork, child bool
 
 func init() {
 	// init flags
-	flag.StringVar(&bindHost, "bind", "0.0.0.0:8080", "set bind host")
+	flag.StringVar(&bindHost, "bind", ":8080", "set bind host")
 	flag.BoolVar(&prefork, "prefork", false, "use prefork")
 	flag.BoolVar(&child, "child", false, "is child proc")
 	flag.StringVar(&jsonEncoder, "json_encoder", "none", "json encoder: none or easyjson or gojay or sjson")
 	flag.StringVar(&dbDriver, "db", "none", "db connection driver [values: none or pgx or mongo]")
-	flag.StringVar(&dbConnectionString, "db_connection_string",
-		"host=tfb-database user=benchmarkdbuser password=benchmarkdbpass dbname=hello_world sslmode=disable",
-		"db connection string")
+	flag.StringVar(&dbConnectionString, "db_connection_string", "", "db connection string")
 
 	flag.Parse()
 }
 
+func numCPU() int {
+	n := runtime.NumCPU()
+	if n == 0 {
+		n = 8
+	}
+
+	return n
+}
+
 func main() {
-	// init database with appropriate driver
-	dbMaxConnectionCount := runtime.NumCPU() * 4
+	maxConn := numCPU() * 4
 	if child {
-		dbMaxConnectionCount = runtime.NumCPU()
+		maxConn = numCPU()
 	}
 
-	db, err := storage.InitDB(dbDriver, dbConnectionString, dbMaxConnectionCount)
+	if dbConnectionString == "" {
+		dbConnectionString = fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s pool_max_conns=%d", "tfb-database", 5432, "benchmarkdbuser", "benchmarkdbpass", "hello_world", maxConn)
+	}
+
+	// init database with appropriate driver
+	db, err := storage.InitDB(dbDriver, dbConnectionString, maxConn)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -74,6 +86,7 @@ func main() {
 	// init atreugo server
 	server := atreugo.New(&atreugo.Config{
 		Addr: bindHost,
+		Name: "Go",
 	})
 
 	// init handlers
@@ -81,6 +94,7 @@ func main() {
 	server.GET("/json", jsonHandler)
 	if db != nil {
 		defer db.Close()
+
 		server.GET("/fortune", handlers.FortuneHandler(db))
 		server.GET("/fortune-quick", handlers.FortuneQuickHandler(db))
 		server.GET("/db", dbHandler)

frameworks/Go/atreugo/src/storage/db.go

@@ -2,19 +2,17 @@ package storage
 
 import (
 	"errors"
-	"fmt"
+	"math/rand"
 
 	"atreugo/src/templates"
 )
 
-const (
-	selectQueryStrPostgre  = "SELECT id, randomNumber FROM World WHERE id = $1"
-	updateQueryStrPostgre  = "UPDATE World SET randomNumber = $1 WHERE id = $2"
-	fortuneQueryStrPostgre = "SELECT id, message FROM Fortune"
-)
-
 const (
 	worldsCount = 10000
+
+	worldSelectSQL   = "SELECT id, randomNumber FROM World WHERE id = $1"
+	worldUpdateSQL   = "UPDATE World SET randomNumber = $1 WHERE id = $2"
+	fortuneSelectSQL = "SELECT id, message FROM Fortune"
 )
 
 // DB is interface for
@@ -26,26 +24,20 @@ type DB interface {
 	Close()
 }
 
+func RandomWorldNum() int {
+	return rand.Intn(worldsCount) + 1
+}
+
 // InitDB with appropriate driver
 func InitDB(dbDriver, dbConnectionString string, maxConnectionCount int) (DB, error) {
-	var err error
-	var db DB
-
-	if dbDriver == "pgx" {
-		db, err = NewPgxDB(dbConnectionString, maxConnectionCount)
-		if err != nil {
-			return nil, fmt.Errorf("Error opening postgresql database with pgx driver: %s", err)
-		}
-	} else if dbDriver == "mongo" {
-		db, err = NewMongoDB(dbConnectionString, maxConnectionCount)
-		if err != nil {
-			return nil, fmt.Errorf("Error opening postgresql database with official mongo driver: %s", err)
-		}
-	} else if dbDriver == "none" {
-		db = nil
-	} else {
-		return nil, errors.New("Can't recognize DB driver type")
+	switch dbDriver {
+	case "pgx":
+		return NewPgxDB(dbConnectionString)
+	case "mongo":
+		return NewMongoDB(dbConnectionString, maxConnectionCount)
+	case "none":
+		return nil, nil
 	}
 
-	return db, nil
+	return nil, errors.New("can not recognize DB driver type")
 }

frameworks/Go/atreugo/src/storage/mongo.go

@@ -2,9 +2,6 @@ package storage
 
 import (
 	"context"
-	"fmt"
-	"log"
-	"math/rand"
 	"time"
 
 	"atreugo/src/templates"
@@ -24,14 +21,27 @@ type Mongo struct {
 	fortunes *mongo.Collection
 }
 
+// NewMongoDB creates new connection to postgres db with official mongo driver
+func NewMongoDB(dbConnectionString string, maxConnectionsInPool int) (DB, error) {
+	m := new(Mongo)
+
+	if err := m.Connect(dbConnectionString, maxConnectionsInPool); err != nil {
+		return nil, err
+	}
+
+	return m, nil
+}
+
 // Connect create connection and ping db
 func (m *Mongo) Connect(dbConnectionString string, maxConnectionsInPool int) error {
 	var err error
 
 	opts := options.Client()
-	// opts.SetMaxPoolSize(uint16(maxConnectionsInPool))
+	opts.SetMaxPoolSize(uint64(maxConnectionsInPool))
+
 	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
 	defer cancel()
+
 	m.db, err = mongo.Connect(ctx, opts.ApplyURI(dbConnectionString))
 	if err != nil {
 		return err
@@ -39,6 +49,7 @@ func (m *Mongo) Connect(dbConnectionString string, maxConnectionsInPool int) err
 
 	ctx, cancel = context.WithTimeout(context.Background(), 2*time.Second)
 	defer cancel()
+
 	err = m.db.Ping(ctx, readpref.Primary())
 	if err != nil {
 		return err
@@ -55,38 +66,43 @@ func (m *Mongo) Connect(dbConnectionString string, maxConnectionsInPool int) err
 func (m *Mongo) Close() {
 	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
 	defer cancel()
-	m.db.Disconnect(ctx)
+
+	if err := m.db.Disconnect(ctx); err != nil {
+		panic(err)
+	}
 }
 
 // GetOneRandomWorld return one random World struct
 func (m Mongo) GetOneRandomWorld(w *World) error {
 	var err error
-	queryID := rand.Intn(worldsCount) + 1
 
-	filter := bson.M{"_id": queryID}
+	id := RandomWorldNum()
+	filter := bson.M{"_id": id}
+
 	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 	defer cancel()
 
 	if err = m.worlds.FindOne(ctx, filter).Decode(w); err != nil {
-		err = fmt.Errorf("error scanning world row with ID %d: %s", queryID, err)
+		return err
 	}
 
 	return err
 }
 
 // UpdateWorlds updates some number of worlds entries, passed as arg
-func (m Mongo) UpdateWorlds(selectedWorlds Worlds) error {
-	for _, selectedWorld := range selectedWorlds {
+func (m Mongo) UpdateWorlds(worlds Worlds) error {
+	for _, w := range worlds {
 		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
 		defer cancel()
 
-		selectedWorld.RandomNumber = rand.Intn(worldsCount) + 1
+		w.RandomNumber = int32(RandomWorldNum())
+
 		if _, err := m.worlds.UpdateOne(
 			ctx,
-			bson.M{"_id": selectedWorld.ID},
-			bson.M{"$set": bson.M{"randomNumber": selectedWorld.RandomNumber}},
+			bson.M{"_id": w.ID},
+			bson.M{"$set": bson.M{"randomNumber": w.RandomNumber}},
 		); err != nil {
-			log.Fatalf("Error updating world with id: %s", err.Error())
+			return err
 		}
 	}
 
@@ -111,25 +127,13 @@ func (m Mongo) GetFortunes() (templates.Fortunes, error) {
 	for cur.Next(context.Background()) {
 		err = cur.Decode(fortune)
 		if err != nil {
-			return fortunes, err
+			return nil, err
 		}
+
 		fortunes = append(fortunes, *fortune)
 	}
 
 	templates.ReleaseFortune(fortune)
 
-	if err := cur.Err(); err != nil {
-		return fortunes, err
-	}
-
-	return fortunes, nil
-}
-
-// NewMongoDB creates new connection to postgres db with official mongo driver
-func NewMongoDB(dbConnectionString string, maxConnectionsInPool int) (DB, error) {
-	var m Mongo
-	if err := m.Connect(dbConnectionString, maxConnectionsInPool); err != nil {
-		return nil, err
-	}
-	return &m, nil
+	return fortunes, cur.Err()
 }

frameworks/Go/atreugo/src/storage/pgx.go

@@ -2,9 +2,6 @@ package storage
 
 import (
 	"context"
-	"fmt"
-	"log"
-	"math/rand"
 	"sort"
 
 	"atreugo/src/templates"
@@ -18,8 +15,18 @@ type PGX struct {
 	db *pgxpool.Pool
 }
 
+// NewPgxDB creates new connection to postgres db with pgx driver
+func NewPgxDB(dbConnectionString string) (DB, error) {
+	psql := new(PGX)
+	if err := psql.Connect(dbConnectionString); err != nil {
+		return nil, err
+	}
+
+	return psql, nil
+}
+
 // Connect create connection and ping db
-func (psql *PGX) Connect(dbConnectionString string, maxConnectionsInPool int) error {
+func (psql *PGX) Connect(dbConnectionString string) error {
 	var err error
 
 	if psql.db, err = pgxpool.Connect(context.Background(), dbConnectionString); err != nil {
@@ -35,51 +42,44 @@ func (psql *PGX) Close() {
 }
 
 // GetOneRandomWorld return one random World struct
-func (psql PGX) GetOneRandomWorld(w *World) error {
-	var err error
-	queryID := rand.Intn(worldsCount) + 1
-	if err = psql.db.QueryRow(context.Background(), selectQueryStrPostgre, queryID).Scan(&w.ID, &w.RandomNumber); err != nil {
-		err = fmt.Errorf("error scanning world row with ID %d: %s", queryID, err)
-	}
-	return err
+func (psql *PGX) GetOneRandomWorld(w *World) error {
+	id := RandomWorldNum()
+
+	return psql.db.QueryRow(context.Background(), worldSelectSQL, id).Scan(&w.ID, &w.RandomNumber)
 }
 
 // UpdateWorlds updates some number of worlds entries, passed as arg
-func (psql PGX) UpdateWorlds(selectedWorlds Worlds) error {
+func (psql *PGX) UpdateWorlds(worlds Worlds) error {
 	// against deadlocks
-	sort.Slice(selectedWorlds, func(i, j int) bool {
-		return selectedWorlds[i].ID < selectedWorlds[j].ID
+	sort.Slice(worlds, func(i, j int) bool {
+		return worlds[i].ID < worlds[j].ID
 	})
 
 	batch := pgx.Batch{}
 
-	for _, selectedWorld := range selectedWorlds {
-		selectedWorld.RandomNumber = rand.Intn(worldsCount) + 1
-		batch.Queue(updateQueryStrPostgre, selectedWorld.RandomNumber, selectedWorld.ID)
-	}
-
-	if err := psql.db.SendBatch(context.Background(), &batch).Close(); err != nil {
-		return fmt.Errorf("Error when closing a batch: %s", err)
+	for _, w := range worlds {
+		batch.Queue(worldUpdateSQL, w.RandomNumber, w.ID)
 	}
 
-	return nil
+	return psql.db.SendBatch(context.Background(), &batch).Close()
 }
 
 // GetFortunes selects all fortunes from table
-func (psql PGX) GetFortunes() (templates.Fortunes, error) {
-	rows, err := psql.db.Query(context.Background(), fortuneQueryStrPostgre)
-	defer rows.Close()
+func (psql *PGX) GetFortunes() (templates.Fortunes, error) {
+	rows, err := psql.db.Query(context.Background(), fortuneSelectSQL)
 	if err != nil {
-		return nil, fmt.Errorf("can't query fortunes: %s", err)
+		return nil, err
 	}
+	defer rows.Close()
 
 	fortunes := templates.AcquireFortunes()
 	fortune := templates.AcquireFortune()
 
 	for rows.Next() {
 		if err = rows.Scan(&fortune.ID, &fortune.Message); err != nil {
-			log.Printf("Can't scan fortune: %s\n", err)
+			return nil, err
 		}
+
 		fortunes = append(fortunes, *fortune)
 	}
 
@@ -87,13 +87,3 @@ func (psql PGX) GetFortunes() (templates.Fortunes, error) {
 
 	return fortunes, nil
 }
-
-// NewPgxDB creates new connection to postgres db with pgx driver
-func NewPgxDB(dbConnectionString string, maxConnectionsInPool int) (DB, error) {
-	psql := new(PGX)
-	if err := psql.Connect(dbConnectionString, maxConnectionsInPool); err != nil {
-		return nil, err
-	}
-
-	return psql, nil
-}

frameworks/Go/atreugo/src/storage/world.go

@@ -11,8 +11,8 @@ var worldJSONStr = []byte(`{"id": 0, "randomNumber": 0}`)
 
 //easyjson:json
 type World struct {
-	ID           int `json:"id"`
-	RandomNumber int `json:"randomnumber"`
+	ID           int32 `json:"id"`
+	RandomNumber int32 `json:"randomnumber"`
 }
 
 // WorldPool ...
@@ -36,9 +36,8 @@ func ReleaseWorld(w *World) {
 
 // MarshalJSONObject encodes the world as JSON
 func (w *World) MarshalJSONObject(dec *gojay.Encoder) {
-	dec.AddIntKey("id", w.ID)
-	dec.AddIntKey("randomnumber", w.RandomNumber)
-
+	dec.AddInt32Key("id", w.ID)
+	dec.AddInt32Key("randomnumber", w.RandomNumber)
 }
 
 // IsNil returns true if the object is nil
@@ -49,7 +48,10 @@ func (w *World) IsNil() bool {
 // MarshalSJSON marshals the object as json
 func (w World) MarshalSJSON() ([]byte, error) {
 	data, _ := sjson.SetBytesOptions(worldJSONStr, "id", w.ID, &sjson.Options{Optimistic: true})
-	return sjson.SetBytesOptions(data, "randomNumber", w.RandomNumber, &sjson.Options{Optimistic: true, ReplaceInPlace: true})
+
+	return sjson.SetBytesOptions(
+		data, "randomNumber", w.RandomNumber, &sjson.Options{Optimistic: true, ReplaceInPlace: true},
+	)
 }
 
 //easyjson:json

frameworks/Go/atreugo/src/storage/world_easyjson.go

@@ -26,7 +26,7 @@ func easyjson4da0dabeDecodeAtreugoSrcStorage(in *jlexer.Lexer, out *Worlds) {
 		in.Delim('[')
 		if *out == nil {
 			if !in.IsDelim(']') {
-				*out = make(Worlds, 0, 4)
+				*out = make(Worlds, 0, 8)
 			} else {
 				*out = Worlds{}
 			}
@@ -103,9 +103,9 @@ func easyjson4da0dabeDecodeAtreugoSrcStorage1(in *jlexer.Lexer, out *World) {
 		}
 		switch key {
 		case "id":
-			out.ID = int(in.Int())
+			out.ID = int32(in.Int32())
 		case "randomnumber":
-			out.RandomNumber = int(in.Int())
+			out.RandomNumber = int32(in.Int32())
 		default:
 			in.SkipRecursive()
 		}
@@ -123,12 +123,12 @@ func easyjson4da0dabeEncodeAtreugoSrcStorage1(out *jwriter.Writer, in World) {
 	{
 		const prefix string = ",\"id\":"
 		out.RawString(prefix[1:])
-		out.Int(int(in.ID))
+		out.Int32(int32(in.ID))
 	}
 	{
 		const prefix string = ",\"randomnumber\":"
 		out.RawString(prefix)
-		out.Int(int(in.RandomNumber))
+		out.Int32(int32(in.RandomNumber))
 	}
 	out.RawByte('}')
 }