Replace logic from switch with generic code

I have a place in code where database query is performed.<br/>
Code is not mine and I may not make decisions regarding it's architecture.<br/><br/>
Recently, we got a task to perform couple of additional queries.<br/>
My superiors decided to put the additional queries in the same piece of database code.<br/><br/>
Now they want me to optimize somehow that part of the code.<br/>
All those ifs and switches "pierce their eyes".<br/>

We use sqlx for database queries.<br/><br/>
I have decided to make 2 maps with query type as key, and concrete struct/SQL, as data.<br/>
This reduced visual noise significantly, but I came here to ask if there is something else I could do?<br/><br/>
Below is example code, I believe it is self-explanatory, but do ask for clarifications if needed:<br/>

/*
I will use UI windows as an example.
The point is that all window types have some common properties,
and some properties specific to each window type.
*/
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 (
// holds specific SQL query for each window type
queries 		    map[int] string
// each window type has it's own function that returns struct for storing query results
scanStructs  		map[int]func() interface{}
// since Go has no enum type, we have to simulate them like below
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"
}
// I am providing non-refactored version for comparison
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() {
// get required destination struct
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
}

• You can change the window types to const and type it:

type windowType int
const (
progressbar windowType = iota + 1
textbox
calendar
)

• You can change the map init to composite literal

type helperData struct {
query       string
scanStruct  func() interface{}
}
var helperMap = map[windowType]helperData{
progressbar: {
query:       "SELECT * FROM progress_bars",
scanStruct:  func() interface{} { return ProgressBar{} },
},
textbox: {
query:       "SELECT * FROM textboxes",
scanStruct:  func() interface{} { return TextBox{} },
},
calendar: {
query:       "SELECT * FROM calendars",
scanStruct:  func() interface{} { return Calendars{} },
}
}