]> jaekl.net Git - quanweb.git/blob - main/db.go
809634a24eb371680ab6ec55f3b64a3d3820477f
[quanweb.git] / main / db.go
1 package main
2
3 import (
4   "database/sql"
5   "fmt"
6   _ "github.com/lib/pq"
7   "strings"
8   "strconv"
9   "sync"
10 )
11
12 // ---------------------------------------------------------------------------
13 type Book struct {
14   Id             int
15   Age            string  // recommended age, e.g. "beginner", "junior", "ya" (Young Adult), "adult"
16   AuthorGrouping string  // unique rendering of the author's name, used for internal grouping 
17   AuthorReading  string  // reading order of author's name, e.g. "Charles Dickens"
18   AuthorSort     string  // sort order of author's name, e.g. "Dickens, Charles"
19   CoverId        int     // index into EFS table for cover, if there is one
20   DDC            string  // Dewey Decimal Classification
21   Description    string  // Back cover / inside flap blurb, describing the book
22   Genre          string  // e.g. "adventure", "historical", "mystery", "romance", "sf" (Science Fiction)
23   LCC            string  // Library of Congress Classification
24   SeriesName     string  
25   Title          string
26   Volume         string
27 }
28
29 // ---------------------------------------------------------------------------
30 type Field string
31 const (
32   Author, Series, Title Field = "aut", "ser", "tit"
33 )
34
35 func (f Field) String() string {
36   return string(f)
37 }
38
39 // ---------------------------------------------------------------------------
40 type SearchTerm struct {
41   Attribute Field
42   Text      string
43 }
44
45 var g_db *sql.DB = nil
46 var g_mutex = &sync.Mutex{}
47
48 // ============================================================================
49 func dbShutdown() {
50   if nil != g_db {
51     g_db.Close()
52   }
53 }
54
55 func getDb() (*sql.DB) {
56   if nil == g_db {
57     g_mutex.Lock()
58     defer g_mutex.Unlock()
59     if nil == g_db {
60       config := GetConfig()
61       g_db = openDb(config.user, config.pass, config.dbName)
62     }
63   }
64
65   return g_db
66 }
67
68 func niVal(ni sql.NullInt64) int {
69   if ni.Valid {
70     return int(ni.Int64)
71   }
72   return 0
73 }
74
75 func nsVal(ns sql.NullString) string {
76   if ns.Valid {
77     return ns.String
78   }
79   return ""
80 }
81
82 func openDb(user, pass, dbName string) (*sql.DB) {
83   db, err := sql.Open("postgres","user=" + user + " password=" + pass + " dbname=" + dbName + " sslmode=disable")
84   if nil != err {
85     report("Error:  DB arguments incorrect?", err)
86     return nil
87   }
88
89   err = db.Ping()
90   if nil != err {
91     report("Error:  could not connect to DB.", err)
92     db.Close()
93     return nil
94   }
95
96   return db
97 }
98
99 func queryBooksByIds(ids []int) []Book {
100   query := `SELECT s.age,a.grouping,a.reading,a.sort,b.cover,c.ddc,b.description,s.genre,c.lcc,s.descr,b.title,b.volume
101             FROM Authors a 
102             INNER JOIN Books b ON a.id=b.author
103             LEFT OUTER JOIN Classifications c ON c.id=b.classification
104             LEFT OUTER JOIN Series s ON s.id=b.series
105             WHERE b.id=$1`
106
107   ps, err := getDb().Prepare(query)
108   if nil != err {
109     report("Error:  failed to prepare statement:  " + query, err)
110     return nil
111   }
112   defer ps.Close()
113
114   var count int = 0
115   for _, id := range ids {
116     if 0 != id {
117       count++
118     }
119   }
120     
121   res := make([]Book, count)
122   
123   count = 0
124   for _, id := range ids {
125     if 0 == id {
126       continue
127     }
128
129     row := ps.QueryRow(id)
130
131     var age, grouping, reading, sort, ddc, description, genre, lcc, name, title, volume sql.NullString
132     var cover sql.NullInt64
133
134     err = row.Scan(&age, &grouping, &reading, &sort, &cover, &ddc, &description, &genre, &lcc, &name, &title, &volume)
135     if err != nil {
136       report("Error:  Failed to read book:" + strconv.Itoa(id) + ":", err)
137     } else {
138       var b Book
139       b.Id = id
140       b.Age = nsVal(age)
141       b.AuthorGrouping = nsVal(grouping)
142       b.AuthorReading = nsVal(reading)
143       b.AuthorSort = nsVal(sort)
144       b.CoverId = niVal(cover)
145       b.DDC = nsVal(ddc)
146       b.Description = nsVal(description)
147       b.Genre = nsVal(genre)
148       b.LCC = nsVal(lcc)
149       b.SeriesName = nsVal(name)
150       b.Title = nsVal(title)
151       b.Volume = nsVal(volume)
152
153       res[count] = b
154       count++
155     }
156   }
157
158   if count < len(res) {
159     res = res[:count]
160   }
161
162   return res
163 }
164
165 func queryBookPathById(id int) (string) {
166   query := "SELECT b.path FROM Books b WHERE b.id=$1"
167
168   ps, err := getDb().Prepare(query)
169   if nil != err {
170     report("Failed to Prepare query:  " + query, err)
171     return ""
172   }
173   defer ps.Close()
174
175   row := ps.QueryRow(id)
176   var path sql.NullString
177   err = row.Scan(&path)
178   if nil != err {
179     report(fmt.Sprintf("Failed to retrieve path for book id %v: ", id), err)
180     return ""
181   }
182
183   return nsVal(path)
184 }
185
186 func queryIds(criteria []SearchTerm) []int {
187   query := "SELECT b.id FROM Books b" +
188            " INNER JOIN Authors a ON a.id=b.author" +
189            " LEFT OUTER JOIN Series s ON s.id=b.series" 
190
191   args := make([]interface{}, len(criteria))
192
193   for i, criterion := range criteria {
194     if 0 == i {
195       query += " WHERE "
196     } else {
197       query += " AND "
198     }
199
200     text := criterion.Text
201
202     switch criterion.Attribute {
203     case Author:
204       query += " UPPER(a.grouping) LIKE UPPER($" + strconv.Itoa(i + 1) + ")"
205       text = strings.Replace(text, " ", "", -1) // Remove spaces
206     case Series:
207       query += " UPPER(s.descr) LIKE UPPER($" + strconv.Itoa(i + 1) + ")"
208     case Title:
209       query += " UPPER(b.title) LIKE UPPER($" + strconv.Itoa(i + 1) + ")"
210     default:
211       report("Error:  unrecognized search field in queryIds():  " + criterion.Attribute.String(), nil)
212       return nil
213     }
214     args[i] = text
215   }
216
217   query += " ORDER BY b.path"
218
219   res := []int{}
220
221   ps, err := getDb().Prepare(query)
222   if nil != err {
223     report("Failed to Prepare query:  " + query, err)
224     return nil
225   }
226   defer ps.Close()
227
228   var rows *sql.Rows
229   rows, err = ps.Query(args...)
230   if nil != err {
231     report("Failed to execute query:  " + query, err)
232     return nil
233   }
234   defer rows.Close()
235
236   for rows.Next() {
237     var id int
238     rows.Scan(&id)
239     res = append(res, id)
240   }
241
242   return res
243 }
244
245 func queryMimeTypeByEfsId(efsId int) string {
246   const query = "SELECT mimeType FROM Efs WHERE id=$1"
247
248   ps, err := getDb().Prepare(query)
249   if nil != err {
250     report("Failed to Prepare query:  " + query, err)
251     return ""
252   }
253   defer ps.Close()
254
255   row := ps.QueryRow(efsId)
256   var mimeType sql.NullString
257   err = row.Scan(&mimeType)
258   if nil != err {
259     report(fmt.Sprintf("Failed to retrieve mimeType for id %v: ", efsId), err)
260     return ""
261   }
262   
263   return nsVal(mimeType)
264 }
265
266 func report(msg string, err error) {
267   fmt.Println("Error:  " + msg, err)
268 }