1//
  2// Copyright (c) 2019 Ted Unangst <tedu@tedunangst.com>
  3//
  4// Permission to use, copy, modify, and distribute this software for any
  5// purpose with or without fee is hereby granted, provided that the above
  6// copyright notice and this permission notice appear in all copies.
  7//
  8// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  9// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 10// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 11// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 12// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 13// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 14// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 15
 16package main
 17
 18import (
 19	"database/sql"
 20	"fmt"
 21	"log"
 22	"strconv"
 23	"strings"
 24	"time"
 25	"bytes"
 26	"encoding/json"
 27
 28	"humungus.tedunangst.com/r/webs/login"
 29)
 30
 31func butwhatabout(name string) (*WhatAbout, error) {
 32	row := stmtWhatAbout.QueryRow(name)
 33	var user WhatAbout
 34	var options string
 35	err := row.Scan(&user.ID, &user.Name, &user.Display, &user.About, &user.Key, &options)
 36	user.URL = fmt.Sprintf("https://%s/%s/%s", serverName, userSep, user.Name)
 37	user.SkinnyCSS = strings.Contains(options, " skinny ")
 38	return &user, err
 39}
 40
 41func gethonkers(userid int64) []*Honker {
 42	rows, err := stmtHonkers.Query(userid)
 43	if err != nil {
 44		log.Printf("error querying honkers: %s", err)
 45		return nil
 46	}
 47	defer rows.Close()
 48	var honkers []*Honker
 49	for rows.Next() {
 50		var f Honker
 51		var combos string
 52		err = rows.Scan(&f.ID, &f.UserID, &f.Name, &f.XID, &f.Flavor, &combos)
 53		f.Combos = strings.Split(strings.TrimSpace(combos), " ")
 54		if err != nil {
 55			log.Printf("error scanning honker: %s", err)
 56			return nil
 57		}
 58		honkers = append(honkers, &f)
 59	}
 60	return honkers
 61}
 62
 63func getdubs(userid int64) []*Honker {
 64	rows, err := stmtDubbers.Query(userid)
 65	if err != nil {
 66		log.Printf("error querying dubs: %s", err)
 67		return nil
 68	}
 69	defer rows.Close()
 70	var honkers []*Honker
 71	for rows.Next() {
 72		var f Honker
 73		err = rows.Scan(&f.ID, &f.UserID, &f.Name, &f.XID, &f.Flavor)
 74		if err != nil {
 75			log.Printf("error scanning honker: %s", err)
 76			return nil
 77		}
 78		honkers = append(honkers, &f)
 79	}
 80	return honkers
 81}
 82
 83func allusers() []login.UserInfo {
 84	var users []login.UserInfo
 85	rows, _ := opendatabase().Query("select userid, username from users")
 86	defer rows.Close()
 87	for rows.Next() {
 88		var u login.UserInfo
 89		rows.Scan(&u.UserID, &u.Username)
 90		users = append(users, u)
 91	}
 92	return users
 93}
 94
 95func getxonk(userid int64, xid string) *Honk {
 96	row := stmtOneXonk.QueryRow(userid, xid)
 97	return scanhonk(row)
 98}
 99
100func getbonk(userid int64, xid string) *Honk {
101	row := stmtOneBonk.QueryRow(userid, xid)
102	return scanhonk(row)
103}
104
105func getpublichonks() []*Honk {
106	dt := time.Now().UTC().Add(-7 * 24 * time.Hour).Format(dbtimeformat)
107	rows, err := stmtPublicHonks.Query(dt)
108	return getsomehonks(rows, err)
109}
110func gethonksbyuser(name string, includeprivate bool) []*Honk {
111	dt := time.Now().UTC().Add(-7 * 24 * time.Hour).Format(dbtimeformat)
112	whofore := 2
113	if includeprivate {
114		whofore = 3
115	}
116	rows, err := stmtUserHonks.Query(whofore, name, dt)
117	return getsomehonks(rows, err)
118}
119func gethonksforuser(userid int64) []*Honk {
120	dt := time.Now().UTC().Add(-7 * 24 * time.Hour).Format(dbtimeformat)
121	rows, err := stmtHonksForUser.Query(userid, dt, userid, userid)
122	return getsomehonks(rows, err)
123}
124func gethonksforuserfirstclass(userid int64) []*Honk {
125	dt := time.Now().UTC().Add(-7 * 24 * time.Hour).Format(dbtimeformat)
126	rows, err := stmtHonksForUserFirstClass.Query(userid, dt, userid, userid)
127	return getsomehonks(rows, err)
128}
129func gethonksforme(userid int64) []*Honk {
130	dt := time.Now().UTC().Add(-7 * 24 * time.Hour).Format(dbtimeformat)
131	rows, err := stmtHonksForMe.Query(userid, dt, userid)
132	return getsomehonks(rows, err)
133}
134func gethonksbyhonker(userid int64, honker string) []*Honk {
135	rows, err := stmtHonksByHonker.Query(userid, honker, userid)
136	return getsomehonks(rows, err)
137}
138func gethonksbyxonker(userid int64, xonker string) []*Honk {
139	rows, err := stmtHonksByXonker.Query(userid, xonker, xonker, userid)
140	return getsomehonks(rows, err)
141}
142func gethonksbycombo(userid int64, combo string) []*Honk {
143	combo = "% " + combo + " %"
144	rows, err := stmtHonksByCombo.Query(userid, combo, userid)
145	return getsomehonks(rows, err)
146}
147func gethonksbyconvoy(userid int64, convoy string) []*Honk {
148	rows, err := stmtHonksByConvoy.Query(userid, userid, convoy)
149	honks := getsomehonks(rows, err)
150	for i, j := 0, len(honks)-1; i < j; i, j = i+1, j-1 {
151		honks[i], honks[j] = honks[j], honks[i]
152	}
153	return honks
154}
155func gethonksbysearch(userid int64, q string) []*Honk {
156	q = "%" + q + "%"
157	rows, err := stmtHonksBySearch.Query(userid, q)
158	honks := getsomehonks(rows, err)
159	return honks
160}
161func gethonksbyontology(userid int64, name string) []*Honk {
162	rows, err := stmtHonksByOntology.Query(name, userid, userid)
163	honks := getsomehonks(rows, err)
164	return honks
165}
166
167func getsomehonks(rows *sql.Rows, err error) []*Honk {
168	if err != nil {
169		log.Printf("error querying honks: %s", err)
170		return nil
171	}
172	defer rows.Close()
173	var honks []*Honk
174	for rows.Next() {
175		h := scanhonk(rows)
176		if h != nil {
177			honks = append(honks, h)
178		}
179	}
180	rows.Close()
181	donksforhonks(honks)
182	return honks
183}
184
185type RowLike interface {
186	Scan(dest ...interface{}) error
187}
188
189func scanhonk(row RowLike) *Honk {
190	h := new(Honk)
191	var dt, aud string
192	err := row.Scan(&h.ID, &h.UserID, &h.Username, &h.What, &h.Honker, &h.Oonker, &h.XID, &h.RID,
193		&dt, &h.URL, &aud, &h.Noise, &h.Precis, &h.Format, &h.Convoy, &h.Whofore, &h.Flags)
194	if err != nil {
195		if err != sql.ErrNoRows {
196			log.Printf("error scanning honk: %s", err)
197		}
198		return nil
199	}
200	h.Date, _ = time.Parse(dbtimeformat, dt)
201	h.Audience = strings.Split(aud, " ")
202	h.Public = !keepitquiet(h.Audience)
203	return h
204}
205
206func donksforhonks(honks []*Honk) {
207	db := opendatabase()
208	var ids []string
209	hmap := make(map[int64]*Honk)
210	for _, h := range honks {
211		ids = append(ids, fmt.Sprintf("%d", h.ID))
212		hmap[h.ID] = h
213	}
214	// grab donks
215	q := fmt.Sprintf("select honkid, donks.fileid, xid, name, description, url, media, local from donks join filemeta on donks.fileid = filemeta.fileid where honkid in (%s)", strings.Join(ids, ","))
216	rows, err := db.Query(q)
217	if err != nil {
218		log.Printf("error querying donks: %s", err)
219		return
220	}
221	defer rows.Close()
222	for rows.Next() {
223		var hid int64
224		var d Donk
225		err = rows.Scan(&hid, &d.FileID, &d.XID, &d.Name, &d.Desc, &d.URL, &d.Media, &d.Local)
226		if err != nil {
227			log.Printf("error scanning donk: %s", err)
228			continue
229		}
230		h := hmap[hid]
231		h.Donks = append(h.Donks, &d)
232	}
233	rows.Close()
234
235	// grab onts
236	q = fmt.Sprintf("select honkid, ontology from onts where honkid in (%s)", strings.Join(ids, ","))
237	rows, err = db.Query(q)
238	if err != nil {
239		log.Printf("error querying onts: %s", err)
240		return
241	}
242	defer rows.Close()
243	for rows.Next() {
244		var hid int64
245		var o string
246		err = rows.Scan(&hid, &o)
247		if err != nil {
248			log.Printf("error scanning donk: %s", err)
249			continue
250		}
251		h := hmap[hid]
252		h.Onts = append(h.Onts, o)
253	}
254	rows.Close()
255	// grab meta
256	q = fmt.Sprintf("select honkid, genus, json from honkmeta where honkid in (%s)", strings.Join(ids, ","))
257	rows, err = db.Query(q)
258	if err != nil {
259		log.Printf("error querying honkmeta: %s", err)
260		return
261	}
262	defer rows.Close()
263	for rows.Next() {
264		var hid int64
265		var genus, j string
266		err = rows.Scan(&hid, &genus, &j)
267		if err != nil {
268			log.Printf("error scanning honkmeta: %s", err)
269			continue
270		}
271		h := hmap[hid]
272		switch genus {
273		case "place":
274			p := new(Place)
275			err = unjsonify(j, p)
276			if err != nil {
277				log.Printf("error parsing place: %s", err)
278				continue
279			}
280			h.Place = p
281		case "oldrev":
282		default:
283			log.Printf("unknown meta genus: %s", genus)
284		}
285	}
286	rows.Close()
287}
288
289func savefile(xid string, name string, desc string, url string, media string, local bool, data []byte) (int64, error) {
290	res, err := stmtSaveFile.Exec(xid, name, desc, url, media, local)
291	if err != nil {
292		return 0, err
293	}
294	fileid, _ := res.LastInsertId()
295	_, err = stmtSaveFileData.Exec(xid, media, data)
296	if err != nil {
297		return 0, err
298	}
299	return fileid, nil
300}
301
302func savehonk(h *Honk) error {
303	dt := h.Date.UTC().Format(dbtimeformat)
304	aud := strings.Join(h.Audience, " ")
305
306	res, err := stmtSaveHonk.Exec(h.UserID, h.What, h.Honker, h.XID, h.RID, dt, h.URL,
307		aud, h.Noise, h.Convoy, h.Whofore, h.Format, h.Precis,
308		h.Oonker, h.Flags)
309	if err != nil {
310		log.Printf("err saving honk: %s", err)
311		return err
312	}
313	h.ID, _ = res.LastInsertId()
314	err = saveextras(h)
315	return err
316}
317
318func saveextras(h *Honk) error {
319	for _, d := range h.Donks {
320		_, err := stmtSaveDonk.Exec(h.ID, d.FileID)
321		if err != nil {
322			log.Printf("err saving donk: %s", err)
323			return err
324		}
325	}
326	for _, o := range h.Onts {
327		_, err := stmtSaveOnt.Exec(strings.ToLower(o), h.ID)
328		if err != nil {
329			log.Printf("error saving ont: %s", err)
330			return err
331		}
332	}
333	if p := h.Place; p != nil {
334		j, err := jsonify(p)
335		if err != nil {
336			_, err = stmtSaveMeta.Exec(h.ID, "genus", j)
337		}
338		if err != nil {
339			log.Printf("error saving place: %s", err)
340			return err
341		}
342	}
343
344	return nil
345}
346
347func deleteextras(honkid int64) {
348	_, err := stmtDeleteDonks.Exec(honkid)
349	if err != nil {
350		log.Printf("error deleting: %s", err)
351	}
352	_, err = stmtDeleteOnts.Exec(honkid)
353	if err != nil {
354		log.Printf("error deleting: %s", err)
355	}
356	_, err = stmtDeleteMeta.Exec(honkid)
357	if err != nil {
358		log.Printf("error deleting: %s", err)
359	}
360}
361
362func deletehonk(honkid int64) {
363	deleteextras(honkid)
364	_, err := stmtDeleteHonk.Exec(honkid)
365	if err != nil {
366		log.Printf("error deleting: %s", err)
367	}
368}
369
370func jsonify(what interface{}) (string, error) {
371	var buf bytes.Buffer
372	e := json.NewEncoder(&buf)
373	e.SetEscapeHTML(false)
374	e.SetIndent("", "")
375	err := e.Encode(what)
376	return buf.String(), err
377}
378
379func unjsonify(s string, dest interface{}) error {
380	d := json.NewDecoder(strings.NewReader(s))
381	err := d.Decode(dest)
382	return err
383}
384
385func updatehonk(h *Honk) {
386	old := getxonk(h.UserID, h.XID)
387	oldrev := OldRevision{Precis: old.Precis, Noise: old.Noise}
388
389	deleteextras(h.ID)
390
391	dt := h.Date.UTC().Format(dbtimeformat)
392	stmtUpdateHonk.Exec(h.Precis, h.Noise, h.Format, dt, h.ID)
393
394	saveextras(h)
395	j, err := jsonify(&oldrev)
396	if err != nil {
397		log.Printf("error jsonify oldrev: %s", err)
398		return
399	}
400	_, err = stmtSaveMeta.Exec(old.ID, "oldrev", j)
401	if err != nil {
402		log.Printf("error saving oldrev: %s", err)
403		return
404	}
405}
406
407func cleanupdb(arg string) {
408	db := opendatabase()
409	days, err := strconv.Atoi(arg)
410	var sqlargs []interface{}
411	var where string
412	if err != nil {
413		honker := arg
414		expdate := time.Now().UTC().Add(-3 * 24 * time.Hour).Format(dbtimeformat)
415		where = "dt < ? and whofore = 0 and honker = ?"
416		sqlargs = append(sqlargs, expdate)
417		sqlargs = append(sqlargs, honker)
418	} else {
419		expdate := time.Now().UTC().Add(-time.Duration(days) * 24 * time.Hour).Format(dbtimeformat)
420		where = "dt < ? and whofore = 0 and convoy not in (select convoy from honks where whofore = 2 or whofore = 3)"
421		sqlargs = append(sqlargs, expdate)
422	}
423	doordie(db, "delete from honks where "+where, sqlargs...)
424	doordie(db, "delete from donks where honkid not in (select honkid from honks)")
425	doordie(db, "delete from onts where honkid not in (select honkid from honks)")
426	doordie(db, "delete from honkmeta where honkid not in (select honkid from honks)")
427
428	doordie(db, "delete from filemeta where fileid not in (select fileid from donks)")
429	for _, u := range allusers() {
430		doordie(db, "delete from zonkers where userid = ? and wherefore = 'zonvoy' and zonkerid < (select zonkerid from zonkers where userid = ? and wherefore = 'zonvoy' order by zonkerid desc limit 1 offset 200)", u.UserID, u.UserID)
431	}
432
433	filexids := make(map[string]bool)
434	blobdb := openblobdb()
435	rows, err := blobdb.Query("select xid from filedata")
436	if err != nil {
437		log.Fatal(err)
438	}
439	for rows.Next() {
440		var xid string
441		err = rows.Scan(&xid)
442		if err != nil {
443			log.Fatal(err)
444		}
445		filexids[xid] = true
446	}
447	rows.Close()
448	rows, err = db.Query("select xid from filemeta")
449	for rows.Next() {
450		var xid string
451		err = rows.Scan(&xid)
452		if err != nil {
453			log.Fatal(err)
454		}
455		delete(filexids, xid)
456	}
457	rows.Close()
458	tx, err := blobdb.Begin()
459	if err != nil {
460		log.Fatal(err)
461	}
462	for xid, _ := range filexids {
463		_, err = tx.Exec("delete from filedata where xid = ?", xid)
464		if err != nil {
465			log.Fatal(err)
466		}
467	}
468	err = tx.Commit()
469	if err != nil {
470		log.Fatal(err)
471	}
472}
473
474var stmtHonkers, stmtDubbers, stmtSaveHonker, stmtUpdateFlavor, stmtUpdateCombos *sql.Stmt
475var stmtOneXonk, stmtPublicHonks, stmtUserHonks, stmtHonksByCombo, stmtHonksByConvoy *sql.Stmt
476var stmtHonksByOntology, stmtHonksForUser, stmtHonksForMe, stmtSaveDub, stmtHonksByXonker *sql.Stmt
477var stmtHonksBySearch, stmtHonksByHonker, stmtSaveHonk, stmtWhatAbout *sql.Stmt
478var stmtOneBonk, stmtFindZonk, stmtFindXonk, stmtSaveDonk *sql.Stmt
479var stmtFindFile, stmtGetFileData, stmtSaveFileData, stmtSaveFile *sql.Stmt
480var stmtAddDoover, stmtGetDoovers, stmtLoadDoover, stmtZapDoover, stmtOneHonker *sql.Stmt
481var stmtThumbBiters, stmtDeleteHonk, stmtDeleteDonks, stmtDeleteOnts, stmtSaveZonker *sql.Stmt
482var stmtGetZonkers, stmtRecentHonkers, stmtGetXonker, stmtSaveXonker, stmtDeleteXonker *sql.Stmt
483var stmtSelectOnts, stmtSaveOnt, stmtUpdateFlags, stmtClearFlags *sql.Stmt
484var stmtHonksForUserFirstClass, stmtSaveMeta, stmtDeleteMeta, stmtUpdateHonk *sql.Stmt
485
486func preparetodie(db *sql.DB, s string) *sql.Stmt {
487	stmt, err := db.Prepare(s)
488	if err != nil {
489		log.Fatalf("error %s: %s", err, s)
490	}
491	return stmt
492}
493
494func prepareStatements(db *sql.DB) {
495	stmtHonkers = preparetodie(db, "select honkerid, userid, name, xid, flavor, combos from honkers where userid = ? and (flavor = 'sub' or flavor = 'peep' or flavor = 'unsub') order by name")
496	stmtSaveHonker = preparetodie(db, "insert into honkers (userid, name, xid, flavor, combos) values (?, ?, ?, ?, ?)")
497	stmtUpdateFlavor = preparetodie(db, "update honkers set flavor = ? where userid = ? and xid = ? and flavor = ?")
498	stmtUpdateCombos = preparetodie(db, "update honkers set combos = ? where honkerid = ? and userid = ?")
499	stmtOneHonker = preparetodie(db, "select xid from honkers where name = ? and userid = ?")
500	stmtDubbers = preparetodie(db, "select honkerid, userid, name, xid, flavor from honkers where userid = ? and flavor = 'dub'")
501
502	selecthonks := "select honks.honkid, honks.userid, username, what, honker, oonker, honks.xid, rid, dt, url, audience, noise, precis, format, convoy, whofore, flags from honks join users on honks.userid = users.userid "
503	limit := " order by honks.honkid desc limit 250"
504	butnotthose := " and convoy not in (select name from zonkers where userid = ? and wherefore = 'zonvoy' order by zonkerid desc limit 100)"
505	stmtOneXonk = preparetodie(db, selecthonks+"where honks.userid = ? and xid = ?")
506	stmtOneBonk = preparetodie(db, selecthonks+"where honks.userid = ? and xid = ? and what = 'bonk' and whofore = 2")
507	stmtPublicHonks = preparetodie(db, selecthonks+"where whofore = 2 and dt > ?"+limit)
508	stmtUserHonks = preparetodie(db, selecthonks+"where (whofore = 2 or whofore = ?) and username = ? and dt > ?"+limit)
509	stmtHonksForUser = preparetodie(db, selecthonks+"where honks.userid = ? and dt > ? and honker in (select xid from honkers where userid = ? and flavor = 'sub' and combos not like '% - %')"+butnotthose+limit)
510	stmtHonksForUserFirstClass = preparetodie(db, selecthonks+"where honks.userid = ? and dt > ? and (what <> 'tonk') and honker in (select xid from honkers where userid = ? and flavor = 'sub' and combos not like '% - %')"+butnotthose+limit)
511	stmtHonksForMe = preparetodie(db, selecthonks+"where honks.userid = ? and dt > ? and whofore = 1"+butnotthose+limit)
512	stmtHonksByHonker = preparetodie(db, selecthonks+"join honkers on (honkers.xid = honks.honker or honkers.xid = honks.oonker) where honks.userid = ? and honkers.name = ?"+butnotthose+limit)
513	stmtHonksByXonker = preparetodie(db, selecthonks+" where honks.userid = ? and (honker = ? or oonker = ?)"+butnotthose+limit)
514	stmtHonksByCombo = preparetodie(db, selecthonks+"join honkers on honkers.xid = honks.honker where honks.userid = ? and honkers.combos like ?"+butnotthose+limit)
515	stmtHonksBySearch = preparetodie(db, selecthonks+"where honks.userid = ? and noise like ?"+limit)
516	stmtHonksByConvoy = preparetodie(db, selecthonks+"where (honks.userid = ? or (? = -1 and whofore = 2)) and convoy = ?"+limit)
517	stmtHonksByOntology = preparetodie(db, selecthonks+"join onts on honks.honkid = onts.honkid where onts.ontology = ? and (honks.userid = ? or (? = -1 and honks.whofore = 2))"+limit)
518
519	stmtSaveMeta = preparetodie(db, "insert into honkmeta (honkid, genus, json) values (?, ?, ?)")
520	stmtDeleteMeta = preparetodie(db, "delete from honkmeta where honkid = ?")
521	stmtSaveHonk = preparetodie(db, "insert into honks (userid, what, honker, xid, rid, dt, url, audience, noise, convoy, whofore, format, precis, oonker, flags) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
522	stmtDeleteHonk = preparetodie(db, "delete from honks where honkid = ?")
523	stmtUpdateHonk = preparetodie(db, "update honks set precis = ?, noise = ?, format = ?, dt = ? where honkid = ?")
524	stmtSaveOnt = preparetodie(db, "insert into onts (ontology, honkid) values (?, ?)")
525	stmtDeleteOnts = preparetodie(db, "delete from onts where honkid = ?")
526	stmtSaveDonk = preparetodie(db, "insert into donks (honkid, fileid) values (?, ?)")
527	stmtDeleteDonks = preparetodie(db, "delete from donks where honkid = ?")
528	stmtSaveFile = preparetodie(db, "insert into filemeta (xid, name, description, url, media, local) values (?, ?, ?, ?, ?, ?)")
529	blobdb := openblobdb()
530	stmtSaveFileData = preparetodie(blobdb, "insert into filedata (xid, media, content) values (?, ?, ?)")
531	stmtGetFileData = preparetodie(blobdb, "select media, content from filedata where xid = ?")
532	stmtFindXonk = preparetodie(db, "select honkid from honks where userid = ? and xid = ?")
533	stmtFindFile = preparetodie(db, "select fileid from filemeta where url = ? and local = 1")
534	stmtWhatAbout = preparetodie(db, "select userid, username, displayname, about, pubkey, options from users where username = ?")
535	stmtSaveDub = preparetodie(db, "insert into honkers (userid, name, xid, flavor) values (?, ?, ?, ?)")
536	stmtAddDoover = preparetodie(db, "insert into doovers (dt, tries, username, rcpt, msg) values (?, ?, ?, ?, ?)")
537	stmtGetDoovers = preparetodie(db, "select dooverid, dt from doovers")
538	stmtLoadDoover = preparetodie(db, "select tries, username, rcpt, msg from doovers where dooverid = ?")
539	stmtZapDoover = preparetodie(db, "delete from doovers where dooverid = ?")
540	stmtThumbBiters = preparetodie(db, "select userid, name, wherefore from zonkers")
541	stmtFindZonk = preparetodie(db, "select zonkerid from zonkers where userid = ? and name = ? and wherefore = 'zonk'")
542	stmtGetZonkers = preparetodie(db, "select zonkerid, name, wherefore from zonkers where userid = ? and wherefore <> 'zonk'")
543	stmtSaveZonker = preparetodie(db, "insert into zonkers (userid, name, wherefore) values (?, ?, ?)")
544	stmtGetXonker = preparetodie(db, "select info from xonkers where name = ? and flavor = ?")
545	stmtSaveXonker = preparetodie(db, "insert into xonkers (name, info, flavor) values (?, ?, ?)")
546	stmtDeleteXonker = preparetodie(db, "delete from xonkers where name = ? and flavor = ?")
547	stmtRecentHonkers = preparetodie(db, "select distinct(honker) from honks where userid = ? and honker not in (select xid from honkers where userid = ? and flavor = 'sub') order by honkid desc limit 100")
548	stmtUpdateFlags = preparetodie(db, "update honks set flags = flags | ? where honkid = ?")
549	stmtClearFlags = preparetodie(db, "update honks set flags = flags & ~ ? where honkid = ?")
550	stmtSelectOnts = preparetodie(db, "select distinct(ontology) from onts join honks on onts.honkid = honks.honkid where (honks.userid = ? or honks.whofore = 2)")
551}