1. package gosqljson
2.  
3. import (
4.         "database/sql"
5.         "encoding/json"
6.         "fmt"
7.         "strings"
8. )
9.  
10. // QueryDbToArrayJSON - run the sql and return a a JSON string of array
11. func QueryDbToArrayJSON(db *sql.DB, theCase string, sqlStatement string, sqlParams ...interface{}) (string, error) {
12.         headers, data, err := QueryDbToArray(db, theCase, sqlStatement, sqlParams...)
13.         result := map[string]interface{}{
14.                 "headers": headers,
15.                 "data":    data,
16.         }
17.         jsonString, err := json.Marshal(result)
18.         return string(jsonString), err
19. }
20.  
21. // QueryDbToMapJSON - run the sql and return a JSON string of array of objects.
22. func QueryDbToMapJSON(db *sql.DB, theCase string, sqlStatement string, sqlParams ...interface{}) (string, error) {
23.         data, err := QueryDbToMap(db, theCase, sqlStatement, sqlParams...)
24.         jsonString, err := json.Marshal(data)
25.         return string(jsonString), err
26. }
27.  
28. // QueryDbToArray - headers, data, error
29. func QueryDbToArray(db *sql.DB, theCase string, sqlStatement string, sqlParams ...interface{}) ([]string, [][]string, error) {
30.         defer func() {
31.                 if err := recover(); err != nil {
32.                         fmt.Println(err)
33.                 }
34.         }()
35.  
36.         data := [][]string{}
37.         headers := []string{}
38.         db.Exec("SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;START TRANSACTION;")
39.         rows, err := db.Query(sqlStatement, sqlParams...)
40.         if err != nil {
41.                 fmt.Println("Error executing: ", sqlStatement)
42.                 return headers, data, err
43.         }
44.         cols, _ := rows.Columns()
45.         if theCase == "lower" {
46.                 colsLower := make([]string, len(cols))
47.                 for i, v := range cols {
48.                         colsLower[i] = strings.ToLower(v)
49.                 }
50.                 headers = colsLower
51.         } else if theCase == "upper" {
52.                 colsUpper := make([]string, len(cols))
53.                 for i, v := range cols {
54.                         colsUpper[i] = strings.ToUpper(v)
55.                 }
56.                 headers = colsUpper
57.         } else if theCase == "camel" {
58.                 colsCamel := make([]string, len(cols))
59.                 for i, v := range cols {
60.                         colsCamel[i] = toCamel(v)
61.                 }
62.                 headers = colsCamel
63.         } else {
64.                 headers = cols
65.         }
66.  
67.         rawResult := make([][]byte, len(cols))
68.  
69.         dest := make([]interface{}, len(cols)) // A temporary interface{} slice
70.         for i := range rawResult {
71.                 dest[i] = &rawResult[i] // Put pointers to each string in the interface slice
72.         }
73.  
74.         for rows.Next() {
75.                 result := make([]string, len(cols))
76.                 rows.Scan(dest...)
77.                 for i, raw := range rawResult {
78.                         if raw == nil {
79.                                 result[i] = ""
80.                         } else {
81.                                 result[i] = string(raw)
82.                         }
83.                 }
84.                 data = append(data, result)
85.         }
86.         defer db.Exec("COMMIT;")
87.         return headers, data, nil
88. }
89.  
90. // QueryTxToArray - headers, data, error
91. func QueryTxToArray(tx *sql.Tx, theCase string, sqlStatement string, sqlParams ...interface{}) ([]string, [][]string, error) {
92.         defer func() {
93.                 if err := recover(); err != nil {
94.                         fmt.Println(err)
95.                 }
96.         }()
97.  
98.         data := [][]string{}
99.         headers := []string{}
100.         rows, err := tx.Query(sqlStatement, sqlParams...)
101.         if err != nil {
102.                 fmt.Println("Error executing: ", sqlStatement)
103.                 return headers, data, err
104.         }
105.         cols, _ := rows.Columns()
106.         if theCase == "lower" {
107.                 colsLower := make([]string, len(cols))
108.                 for i, v := range cols {
109.                         colsLower[i] = strings.ToLower(v)
110.                 }
111.                 headers = colsLower
112.         } else if theCase == "upper" {
113.                 colsUpper := make([]string, len(cols))
114.                 for i, v := range cols {
115.                         colsUpper[i] = strings.ToUpper(v)
116.                 }
117.                 headers = colsUpper
118.         } else if theCase == "camel" {
119.                 colsCamel := make([]string, len(cols))
120.                 for i, v := range cols {
121.                         colsCamel[i] = toCamel(v)
122.                 }
123.                 headers = colsCamel
124.         } else {
125.                 headers = cols
126.         }
127.  
128.         rawResult := make([][]byte, len(cols))
129.  
130.         dest := make([]interface{}, len(cols)) // A temporary interface{} slice
131.         for i := range rawResult {
132.                 dest[i] = &rawResult[i] // Put pointers to each string in the interface slice
133.         }
134.  
135.         for rows.Next() {
136.                 result := make([]string, len(cols))
137.                 rows.Scan(dest...)
138.                 for i, raw := range rawResult {
139.                         if raw == nil {
140.                                 result[i] = ""
141.                         } else {
142.                                 result[i] = string(raw)
143.                         }
144.                 }
145.                 data = append(data, result)
146.         }
147.         return headers, data, nil
148. }
149.  
150. // QueryDbToMap - run sql and return an array of maps
151. func QueryDbToMap(db *sql.DB, theCase string, sqlStatement string, sqlParams ...interface{}) ([]map[string]string, error) {
152.         defer func() {
153.                 if err := recover(); err != nil {
154.                         fmt.Println(err)
155.                 }
156.         }()
157.  
158.         results := []map[string]string{}
159.         rows, err := db.Query(sqlStatement, sqlParams...)
160.         if err != nil {
161.                 fmt.Println("Error executing: ", sqlStatement)
162.                 return results, err
163.         }
164.         cols, _ := rows.Columns()
165.         colsLower := make([]string, len(cols))
166.         colsCamel := make([]string, len(cols))
167.  
168.         if theCase == "lower" {
169.                 for i, v := range cols {
170.                         colsLower[i] = strings.ToLower(v)
171.                 }
172.         } else if theCase == "upper" {
173.                 for i, v := range cols {
174.                         cols[i] = strings.ToUpper(v)
175.                 }
176.         } else if theCase == "camel" {
177.                 for i, v := range cols {
178.                         colsCamel[i] = toCamel(v)
179.                 }
180.         }
181.  
182.         rawResult := make([][]byte, len(cols))
183.  
184.         dest := make([]interface{}, len(cols)) // A temporary interface{} slice
185.         for i := range rawResult {
186.                 dest[i] = &rawResult[i] // Put pointers to each string in the interface slice
187.         }
188.  
189.         for rows.Next() {
190.                 result := make(map[string]string, len(cols))
191.                 rows.Scan(dest...)
192.                 for i, raw := range rawResult {
193.                         if raw == nil {
194.                                 if theCase == "lower" {
195.                                         result[colsLower[i]] = ""
196.                                 } else if theCase == "upper" {
197.                                         result[cols[i]] = ""
198.                                 } else if theCase == "camel" {
199.                                         result[colsCamel[i]] = ""
200.                                 } else {
201.                                         result[cols[i]] = ""
202.                                 }
203.                         } else {
204.                                 if theCase == "lower" {
205.                                         result[colsLower[i]] = string(raw)
206.                                 } else if theCase == "upper" {
207.                                         result[cols[i]] = string(raw)
208.                                 } else if theCase == "camel" {
209.                                         result[colsCamel[i]] = string(raw)
210.                                 } else {
211.                                         result[cols[i]] = string(raw)
212.                                 }
213.                         }
214.                 }
215.                 results = append(results, result)
216.         }
217.         return results, nil
218. }
219.  
220. // QueryTxToMap - run sql and return an array of maps
221. func QueryTxToMap(tx *sql.Tx, theCase string, sqlStatement string, sqlParams ...interface{}) ([]map[string]string, error) {
222.         defer func() {
223.                 if err := recover(); err != nil {
224.                         fmt.Println(err)
225.                 }
226.         }()
227.  
228.         results := []map[string]string{}
229.         rows, err := tx.Query(sqlStatement, sqlParams...)
230.         if err != nil {
231.                 fmt.Println("Error executing: ", sqlStatement)
232.                 return results, err
233.         }
234.         cols, _ := rows.Columns()
235.         colsLower := make([]string, len(cols))
236.         colsCamel := make([]string, len(cols))
237.  
238.         if theCase == "lower" {
239.                 for i, v := range cols {
240.                         colsLower[i] = strings.ToLower(v)
241.                 }
242.         } else if theCase == "upper" {
243.                 for i, v := range cols {
244.                         cols[i] = strings.ToUpper(v)
245.                 }
246.         } else if theCase == "camel" {
247.                 for i, v := range cols {
248.                         colsCamel[i] = toCamel(v)
249.                 }
250.         }
251.  
252.         rawResult := make([][]byte, len(cols))
253.  
254.         dest := make([]interface{}, len(cols)) // A temporary interface{} slice
255.         for i := range rawResult {
256.                 dest[i] = &rawResult[i] // Put pointers to each string in the interface slice
257.         }
258.  
259.         for rows.Next() {
260.                 result := make(map[string]string, len(cols))
261.                 rows.Scan(dest...)
262.                 for i, raw := range rawResult {
263.                         if raw == nil {
264.                                 if theCase == "lower" {
265.                                         result[colsLower[i]] = ""
266.                                 } else if theCase == "upper" {
267.                                         result[cols[i]] = ""
268.                                 } else if theCase == "camel" {
269.                                         result[colsCamel[i]] = ""
270.                                 } else {
271.                                         result[cols[i]] = ""
272.                                 }
273.                         } else {
274.                                 if theCase == "lower" {
275.                                         result[colsLower[i]] = string(raw)
276.                                 } else if theCase == "upper" {
277.                                         result[cols[i]] = string(raw)
278.                                 } else if theCase == "camel" {
279.                                         result[colsCamel[i]] = string(raw)
280.                                 } else {
281.                                         result[cols[i]] = string(raw)
282.                                 }
283.                         }
284.                 }
285.                 results = append(results, result)
286.         }
287.         return results, nil
288. }
289.  
290. // ExecDb - run the sql and returns rows affected.
291. func ExecDb(db *sql.DB, sqlStatement string, sqlParams ...interface{}) (int64, error) {
292.         defer func() {
293.                 if err := recover(); err != nil {
294.                         fmt.Println(err)
295.                 }
296.         }()
297.         result, err := db.Exec(sqlStatement, sqlParams...)
298.         if err != nil {
299.                 fmt.Println("Error executing: ", sqlStatement)
300.                 fmt.Println(err)
301.                 return 0, err
302.         }
303.         return result.RowsAffected()
304. }
305.  
306. // ExecTx - run the sql and returns rows affected.
307. func ExecTx(tx *sql.Tx, sqlStatement string, sqlParams ...interface{}) (int64, error) {
308.         defer func() {
309.                 if err := recover(); err != nil {
310.                         fmt.Println(err)
311.                 }
312.         }()
313.  
314.         result, err := tx.Exec(sqlStatement, sqlParams...)
315.         if err != nil {
316.                 fmt.Println("Error executing: ", sqlStatement)
317.                 fmt.Println(err)
318.                 return 0, err
319.         }
320.         return result.RowsAffected()
321. }
322.  
323. func toCamel(s string) (ret string) {
324.         s = strings.ToLower(s)
325.         a := strings.Split(s, "_")
326.         for i, v := range a {
327.                 if i == 0 {
328.                         ret += v
329.                 } else {
330.                         f := strings.ToUpper(string(v[0]))
331.                         n := string(v[1:])
332.                         ret += fmt.Sprint(f, n)
333.                 }
334.         }
335.         return
336. }
337.