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	if local {
296		_, err = stmtSaveFileData.Exec(xid, media, data)
297		if err != nil {
298			return 0, err
299		}
300	}
301	return fileid, nil
302}
303
304func savehonk(h *Honk) error {
305	dt := h.Date.UTC().Format(dbtimeformat)
306	aud := strings.Join(h.Audience, " ")
307
308	res, err := stmtSaveHonk.Exec(h.UserID, h.What, h.Honker, h.XID, h.RID, dt, h.URL,
309		aud, h.Noise, h.Convoy, h.Whofore, h.Format, h.Precis,
310		h.Oonker, h.Flags)
311	if err != nil {
312		log.Printf("err saving honk: %s", err)
313		return err
314	}
315	h.ID, _ = res.LastInsertId()
316	err = saveextras(h)
317	return err
318}
319
320func saveextras(h *Honk) error {
321	for _, d := range h.Donks {
322		_, err := stmtSaveDonk.Exec(h.ID, d.FileID)
323		if err != nil {
324			log.Printf("err saving donk: %s", err)
325			return err
326		}
327	}
328	for _, o := range h.Onts {
329		_, err := stmtSaveOnt.Exec(strings.ToLower(o), h.ID)
330		if err != nil {
331			log.Printf("error saving ont: %s", err)
332			return err
333		}
334	}
335	if p := h.Place; p != nil {
336		j, err := jsonify(p)
337		if err != nil {
338			_, err = stmtSaveMeta.Exec(h.ID, "genus", j)
339		}
340		if err != nil {
341			log.Printf("error saving place: %s", err)
342			return err
343		}
344	}
345
346	return nil
347}
348
349func deleteextras(honkid int64) {
350	_, err := stmtDeleteDonks.Exec(honkid)
351	if err != nil {
352		log.Printf("error deleting: %s", err)
353	}
354	_, err = stmtDeleteOnts.Exec(honkid)
355	if err != nil {
356		log.Printf("error deleting: %s", err)
357	}
358	_, err = stmtDeleteMeta.Exec(honkid)
359	if err != nil {
360		log.Printf("error deleting: %s", err)
361	}
362}
363
364func deletehonk(honkid int64) {
365	deleteextras(honkid)
366	_, err := stmtDeleteHonk.Exec(honkid)
367	if err != nil {
368		log.Printf("error deleting: %s", err)
369	}
370}
371
372func jsonify(what interface{}) (string, error) {
373	var buf bytes.Buffer
374	e := json.NewEncoder(&buf)
375	e.SetEscapeHTML(false)
376	e.SetIndent("", "")
377	err := e.Encode(what)
378	return buf.String(), err
379}
380
381func unjsonify(s string, dest interface{}) error {
382	d := json.NewDecoder(strings.NewReader(s))
383	err := d.Decode(dest)
384	return err
385}
386
387func updatehonk(h *Honk) {
388	old := getxonk(h.UserID, h.XID)
389	oldrev := OldRevision{Precis: old.Precis, Noise: old.Noise}
390
391	deleteextras(h.ID)
392
393	dt := h.Date.UTC().Format(dbtimeformat)
394	stmtUpdateHonk.Exec(h.Precis, h.Noise, h.Format, dt, h.ID)
395
396	saveextras(h)
397	j, err := jsonify(&oldrev)
398	if err != nil {
399		log.Printf("error jsonify oldrev: %s", err)
400		return
401	}
402	_, err = stmtSaveMeta.Exec(old.ID, "oldrev", j)
403	if err != nil {
404		log.Printf("error saving oldrev: %s", err)
405		return
406	}
407}
408
409func cleanupdb(arg string) {
410	db := opendatabase()
411	days, err := strconv.Atoi(arg)
412	var sqlargs []interface{}
413	var where string
414	if err != nil {
415		honker := arg
416		expdate := time.Now().UTC().Add(-3 * 24 * time.Hour).Format(dbtimeformat)
417		where = "dt < ? and whofore = 0 and honker = ?"
418		sqlargs = append(sqlargs, expdate)
419		sqlargs = append(sqlargs, honker)
420	} else {
421		expdate := time.Now().UTC().Add(-time.Duration(days) * 24 * time.Hour).Format(dbtimeformat)
422		where = "dt < ? and whofore = 0 and convoy not in (select convoy from honks where whofore = 2 or whofore = 3)"
423		sqlargs = append(sqlargs, expdate)
424	}
425	doordie(db, "delete from honks where "+where, sqlargs...)
426	doordie(db, "delete from donks where honkid not in (select honkid from honks)")
427	doordie(db, "delete from onts where honkid not in (select honkid from honks)")
428	doordie(db, "delete from honkmeta where honkid not in (select honkid from honks)")
429
430	doordie(db, "delete from filemeta where fileid not in (select fileid from donks)")
431	for _, u := range allusers() {
432		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)
433	}
434
435	filexids := make(map[string]bool)
436	blobdb := openblobdb()
437	rows, err := blobdb.Query("select xid from filedata")
438	if err != nil {
439		log.Fatal(err)
440	}
441	for rows.Next() {
442		var xid string
443		err = rows.Scan(&xid)
444		if err != nil {
445			log.Fatal(err)
446		}
447		filexids[xid] = true
448	}
449	rows.Close()
450	rows, err = db.Query("select xid from filemeta")
451	for rows.Next() {
452		var xid string
453		err = rows.Scan(&xid)
454		if err != nil {
455			log.Fatal(err)
456		}
457		delete(filexids, xid)
458	}
459	rows.Close()
460	tx, err := blobdb.Begin()
461	if err != nil {
462		log.Fatal(err)
463	}
464	for xid, _ := range filexids {
465		_, err = tx.Exec("delete from filedata where xid = ?", xid)
466		if err != nil {
467			log.Fatal(err)
468		}
469	}
470	err = tx.Commit()
471	if err != nil {
472		log.Fatal(err)
473	}
474}
475
476var stmtHonkers, stmtDubbers, stmtSaveHonker, stmtUpdateFlavor, stmtUpdateCombos *sql.Stmt
477var stmtOneXonk, stmtPublicHonks, stmtUserHonks, stmtHonksByCombo, stmtHonksByConvoy *sql.Stmt
478var stmtHonksByOntology, stmtHonksForUser, stmtHonksForMe, stmtSaveDub, stmtHonksByXonker *sql.Stmt
479var stmtHonksBySearch, stmtHonksByHonker, stmtSaveHonk, stmtWhatAbout *sql.Stmt
480var stmtOneBonk, stmtFindZonk, stmtFindXonk, stmtSaveDonk *sql.Stmt
481var stmtFindFile, stmtGetFileData, stmtSaveFileData, stmtSaveFile *sql.Stmt
482var stmtAddDoover, stmtGetDoovers, stmtLoadDoover, stmtZapDoover, stmtOneHonker *sql.Stmt
483var stmtThumbBiters, stmtDeleteHonk, stmtDeleteDonks, stmtDeleteOnts, stmtSaveZonker *sql.Stmt
484var stmtGetZonkers, stmtRecentHonkers, stmtGetXonker, stmtSaveXonker, stmtDeleteXonker *sql.Stmt
485var stmtSelectOnts, stmtSaveOnt, stmtUpdateFlags, stmtClearFlags *sql.Stmt
486var stmtHonksForUserFirstClass, stmtSaveMeta, stmtDeleteMeta, stmtUpdateHonk *sql.Stmt
487
488func preparetodie(db *sql.DB, s string) *sql.Stmt {
489	stmt, err := db.Prepare(s)
490	if err != nil {
491		log.Fatalf("error %s: %s", err, s)
492	}
493	return stmt
494}
495
496func prepareStatements(db *sql.DB) {
497	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")
498	stmtSaveHonker = preparetodie(db, "insert into honkers (userid, name, xid, flavor, combos) values (?, ?, ?, ?, ?)")
499	stmtUpdateFlavor = preparetodie(db, "update honkers set flavor = ? where userid = ? and xid = ? and flavor = ?")
500	stmtUpdateCombos = preparetodie(db, "update honkers set combos = ? where honkerid = ? and userid = ?")
501	stmtOneHonker = preparetodie(db, "select xid from honkers where name = ? and userid = ?")
502	stmtDubbers = preparetodie(db, "select honkerid, userid, name, xid, flavor from honkers where userid = ? and flavor = 'dub'")
503
504	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 "
505	limit := " order by honks.honkid desc limit 250"
506	butnotthose := " and convoy not in (select name from zonkers where userid = ? and wherefore = 'zonvoy' order by zonkerid desc limit 100)"
507	stmtOneXonk = preparetodie(db, selecthonks+"where honks.userid = ? and xid = ?")
508	stmtOneBonk = preparetodie(db, selecthonks+"where honks.userid = ? and xid = ? and what = 'bonk' and whofore = 2")
509	stmtPublicHonks = preparetodie(db, selecthonks+"where whofore = 2 and dt > ?"+limit)
510	stmtUserHonks = preparetodie(db, selecthonks+"where (whofore = 2 or whofore = ?) and username = ? and dt > ?"+limit)
511	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)
512	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)
513	stmtHonksForMe = preparetodie(db, selecthonks+"where honks.userid = ? and dt > ? and whofore = 1"+butnotthose+limit)
514	stmtHonksByHonker = preparetodie(db, selecthonks+"join honkers on (honkers.xid = honks.honker or honkers.xid = honks.oonker) where honks.userid = ? and honkers.name = ?"+butnotthose+limit)
515	stmtHonksByXonker = preparetodie(db, selecthonks+" where honks.userid = ? and (honker = ? or oonker = ?)"+butnotthose+limit)
516	stmtHonksByCombo = preparetodie(db, selecthonks+"join honkers on honkers.xid = honks.honker where honks.userid = ? and honkers.combos like ?"+butnotthose+limit)
517	stmtHonksBySearch = preparetodie(db, selecthonks+"where honks.userid = ? and noise like ?"+limit)
518	stmtHonksByConvoy = preparetodie(db, selecthonks+"where (honks.userid = ? or (? = -1 and whofore = 2)) and convoy = ?"+limit)
519	stmtHonksByOntology = preparetodie(db, selecthonks+"join onts on honks.honkid = onts.honkid where onts.ontology = ? and (honks.userid = ? or (? = -1 and honks.whofore = 2))"+limit)
520
521	stmtSaveMeta = preparetodie(db, "insert into honkmeta (honkid, genus, json) values (?, ?, ?)")
522	stmtDeleteMeta = preparetodie(db, "delete from honkmeta where honkid = ?")
523	stmtSaveHonk = preparetodie(db, "insert into honks (userid, what, honker, xid, rid, dt, url, audience, noise, convoy, whofore, format, precis, oonker, flags) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
524	stmtDeleteHonk = preparetodie(db, "delete from honks where honkid = ?")
525	stmtUpdateHonk = preparetodie(db, "update honks set precis = ?, noise = ?, format = ?, dt = ? where honkid = ?")
526	stmtSaveOnt = preparetodie(db, "insert into onts (ontology, honkid) values (?, ?)")
527	stmtDeleteOnts = preparetodie(db, "delete from onts where honkid = ?")
528	stmtSaveDonk = preparetodie(db, "insert into donks (honkid, fileid) values (?, ?)")
529	stmtDeleteDonks = preparetodie(db, "delete from donks where honkid = ?")
530	stmtSaveFile = preparetodie(db, "insert into filemeta (xid, name, description, url, media, local) values (?, ?, ?, ?, ?, ?)")
531	blobdb := openblobdb()
532	stmtSaveFileData = preparetodie(blobdb, "insert into filedata (xid, media, content) values (?, ?, ?)")
533	stmtGetFileData = preparetodie(blobdb, "select media, content from filedata where xid = ?")
534	stmtFindXonk = preparetodie(db, "select honkid from honks where userid = ? and xid = ?")
535	stmtFindFile = preparetodie(db, "select fileid from filemeta where url = ? and local = 1")
536	stmtWhatAbout = preparetodie(db, "select userid, username, displayname, about, pubkey, options from users where username = ?")
537	stmtSaveDub = preparetodie(db, "insert into honkers (userid, name, xid, flavor) values (?, ?, ?, ?)")
538	stmtAddDoover = preparetodie(db, "insert into doovers (dt, tries, username, rcpt, msg) values (?, ?, ?, ?, ?)")
539	stmtGetDoovers = preparetodie(db, "select dooverid, dt from doovers")
540	stmtLoadDoover = preparetodie(db, "select tries, username, rcpt, msg from doovers where dooverid = ?")
541	stmtZapDoover = preparetodie(db, "delete from doovers where dooverid = ?")
542	stmtThumbBiters = preparetodie(db, "select userid, name, wherefore from zonkers")
543	stmtFindZonk = preparetodie(db, "select zonkerid from zonkers where userid = ? and name = ? and wherefore = 'zonk'")
544	stmtGetZonkers = preparetodie(db, "select zonkerid, name, wherefore from zonkers where userid = ? and wherefore <> 'zonk'")
545	stmtSaveZonker = preparetodie(db, "insert into zonkers (userid, name, wherefore) values (?, ?, ?)")
546	stmtGetXonker = preparetodie(db, "select info from xonkers where name = ? and flavor = ?")
547	stmtSaveXonker = preparetodie(db, "insert into xonkers (name, info, flavor) values (?, ?, ?)")
548	stmtDeleteXonker = preparetodie(db, "delete from xonkers where name = ? and flavor = ?")
549	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")
550	stmtUpdateFlags = preparetodie(db, "update honks set flags = flags | ? where honkid = ?")
551	stmtClearFlags = preparetodie(db, "update honks set flags = flags & ~ ? where honkid = ?")
552	stmtSelectOnts = preparetodie(db, "select distinct(ontology) from onts join honks on onts.honkid = honks.honkid where (honks.userid = ? or honks.whofore = 2)")
553}