I have a place in code where database query is performed.
Code is not mine and I may not make decisions regarding it's architecture.
Recently, we got a task to perform couple of additional queries.
My superiors decided to put the additional queries in the same piece of database code.
Now they want me to optimize somehow that part of the code.
All those
if
s and
switch
es "pierce their eyes".
We use
sqlx[
^] for database queries.
Below is example code, I believe it is self-explanatory, but do ask for clarifications if needed:
type ProgressBar struct {
X int
Y int
Width int
Height int
LowestValue int
Highestvalue int
CurrentPosition int
}
type TextBox struct {
X int
Y int
Width int
Height int
TextLength int
TextContent string
}
type Calendar struct {
X int
Y int
Width int
Height int
SelectedDate time.Time
}
var (
queries map[int] string
scanStructs map[int]func() interface{}
progressbar = 1
textbox = 2
calendar = 3
)
func init(){
queries = make(map[int]string)
scanStructs = make(map[int]func() interface{})
scanStructs[progressbar] = func() interface{} { return ProgressBar{} }
scanStructs[textbox] = func() interface{} { return TextBox{} }
scanStructs[calendar] = func() interface{} { return Calendar{} }
queries[progressbar] = "SELECT * FROM progress_bars"
queries[textbox] = "SELECT * FROM textboxes"
queries[calendar] = "SELECT * FROM calendars"
}
func OriginalPerformSqlQuery(type int) ([]interface{}, error) {
query := string
switch type {
case progressbar:
query = "SELECT * FROM progress_bars"
case textbox:
query = "SELECT * FROM textboxes"
case calendar:
query = "SELECT * FROM calendars"
default:
return interface{},
fmt.Errorf("unknown window type")
}
rows, err := db.Queryx(query)
if err != nil {
return interface{},
fmt.Errorf("db.Queryx() failed: %v", err)
}
defer func() { _ = rows.Close() }()
result := make([]interface{}, 0)
for rows.Next() {
switch type {
case progressbar:
r := ProgressBar{}
if err := rows.StructScan(&r); err != nil {
return interface{},
fmt.Errorf("rows.StructScan() failed: %v", err)
}
result = append(result, r)
case textbox:
r := TextBox{}
if err := rows.StructScan(&r); err != nil {
return interface{},
fmt.Errorf("rows.StructScan() failed: %v", err)
}
result = append(result, r)
case calendar:
r := Calendar{}
if err := rows.StructScan(&r); err != nil {
return interface{},
fmt.Errorf("rows.StructScan() failed: %v", err)
}
result = append(result, r)
}
}
return result, nil
}
func PerformSqlQuery(type int) ([]interface{}, error) {
query, exists = queries[type]
if !exists {
return interface{},
fmt.Errorf("unknown window type")
}
rows, err := db.Queryx(query)
if err != nil {
return interface{},
fmt.Errorf("db.Queryx() failed: %v", err)
}
defer func() { _ = rows.Close() }()
result := make([]interface{}, 0)
for rows.Next() {
r := scanStructs[type]()
if err := rows.StructScan(&r); err != nil {
return interface{},
fmt.Errorf("rows.StructScan() failed: %v", err)
}
result = append(result, r)
}
return result, nil
}
What I have tried:
I have decided to make 2
map
s with query type as key, and concrete struct/SQL, as data.
This reduced visual noise significantly, but I came here to ask if there is something else I could do?