select optimizations

build.maple

···
 task:run.real = {
 	description = 'Run beep using config.real.maple'
 	category = 'run'
-	run = '${v} -d veb_livereload run ${v_main} config.real.maple'
+	run = '${v} run ${v_main} config.real.maple'
 }
 
 task:cloc = {

doc/todo.md

···
 		created-before:<date>
 		is:admin
 		```
-- [ ] misc:replace `SEARCH *` with `SEARCH <column>`
 
 ## planing
 
···
 	discord, and other common links. we want those ones to look fancy!
 - [x] post:saving (add the post to a list of saved posts that a user can view later)
 - [x] site:message of the day (admins can add a welcome message displayed on index.html)
+- [x] misc:replace `SELECT *` with `SELECT <column>`
 
 ## graveyard
 

src/database/like.v

···
 module database
 
 import entity { Like, LikeCache }
+import util
 
 // add_like adds a like to the database, returns true if this succeeds and false
 // otherwise.
···
 // get_net_likes_for_post returns the net likes of the given post.
 pub fn (app &DatabaseAccess) get_net_likes_for_post(post_id int) int {
 	// check cache
-	cache := sql app.db {
-		select from LikeCache where post_id == post_id limit 1
-	} or { [] }
+	cache := app.db.exec_param('SELECT likes FROM "LikeCache" WHERE post_id = $1 LIMIT 1', post_id.str()) or { [] }
 
 	mut likes := 0
 
 	if cache.len != 1 {
 		println('calculating net likes for post: ${post_id}')
 		// calculate
-		db_likes := sql app.db {
-			select from Like where post_id == post_id
-		} or { [] }
-
+		db_likes := app.db.exec_param('SELECT is_like FROM "Like" WHERE post_id = $1', post_id.str()) or { [] }
 		for like in db_likes {
-			if like.is_like {
+			if util.or_throw(like.vals[0]).bool() {
 				likes++
 			} else {
 				likes--
···
 			return likes
 		}
 	} else {
-		likes = cache.first().likes
+		likes = util.or_throw(cache.first().vals[0]).int()
 	}
 
 	return likes

src/database/notification.v

···
 // get_notification_count gets the amount of notifications a user has, with a
 // given limit.
 pub fn (app &DatabaseAccess) get_notification_count(user_id int, limit int) int {
-	notifications := sql app.db {
-		select from Notification where user_id == user_id limit limit
-	} or { [] }
+	notifications := app.db.exec_param2('SELECT id FROM "Notification" WHERE user_id = $1 LIMIT $2', user_id.str(), limit.str()) or { [] }
 	return notifications.len
 }
 

src/database/post.v

···
 module database
 
 import time
+import db.pg
 import entity { Post, User, Like, LikeCache }
+import util
 
 // add_post adds a new post to the database, returns true if this succeeded and
 // false otherwise.
···
 // get_popular_posts returns a list of the ten most liked posts.
 // TODO: make this time-gated (i.e, top ten liked posts of the day)
 pub fn (app &DatabaseAccess) get_popular_posts() []Post {
-	cached_likes := sql app.db {
-		select from LikeCache order by likes desc limit 10
-	} or { [] }
-	posts := cached_likes.map(fn [app] (it LikeCache) Post {
-		return app.get_post_by_id(it.post_id) or {
+	cached_likes := app.db.exec('SELECT post_id FROM "LikeCache" ORDER BY likes DESC LIMIT 10') or { [] }
+	posts := cached_likes.map(fn [app] (it pg.Row) Post {
+		return app.get_post_by_id(util.or_throw(it.vals[0]).int()) or {
 			eprintln('cached like ${it} does not have a post related to it (from get_popular_posts)')
 			return Post{}
 		}

src/database/saved_post.v

···
 module database
 
+import db.pg
 import entity { SavedPost, Post }
+import util
 
 // get_saved_posts_for gets all SavedPost objects for a given user.
 pub fn (app &DatabaseAccess) get_saved_posts_for(user_id int) []SavedPost {
···
 // get_saved_posts_as_post_for gets all saved posts for a given user converted
 // to Post objects.
 pub fn (app &DatabaseAccess) get_saved_posts_as_post_for(user_id int) []Post {
-	saved_posts := sql app.db {
-		select from SavedPost where user_id == user_id && saved == true
-	} or { [] }
-	posts := saved_posts.map(fn [app] (it SavedPost) Post {
-		return app.get_post_by_id(it.post_id) or {
+	saved_posts := app.db.exec_param('SELECT id, post_id FROM "SavedPost" WHERE user_id = $1 AND saved = TRUE', user_id.str()) or { [] }
+	posts := saved_posts.map(fn [app] (it pg.Row) Post {
+		return app.get_post_by_id(util.or_throw(it.vals[1]).int()) or {
 			// if the post does not exist, we will remove it now
+			id := util.or_throw(it.vals[0]).int()
 			sql app.db {
-				delete from SavedPost where id == it.id
+				delete from SavedPost where id == id
 			} or {
 				eprintln('get_saved_posts_as_post_for: failed to remove non-existent post from saved post: ${it}')
 			}

src/database/user.v

···
 module database
 
 import entity { User, Notification, Like, LikeCache, Post }
+import util
 
 // new_user creates a new user and returns their struct after creation.
 pub fn (app &DatabaseAccess) new_user(user User) ?User {
···
 
 // does_user_like_post returns true if a user likes the given post.
 pub fn (app &DatabaseAccess) does_user_like_post(user_id int, post_id int) bool {
-	likes := sql app.db {
-		select from Like where user_id == user_id && post_id == post_id
-	} or { [] }
+	likes := app.db.exec_param2('SELECT id, is_like FROM "Like" WHERE user_id = $1 AND post_id = $2', user_id.str(), post_id.str()) or { [] }
 	if likes.len > 1 {
 		// something is very wrong lol
-		eprintln('a user somehow got two or more likes on the same post (user: ${user_id}, post: ${post_id})')
+		eprintln('does_user_like_post: a user somehow got two or more likes on the same post (user: ${user_id}, post: ${post_id})')
 	} else if likes.len == 0 {
 		return false
 	}
-	return likes.first().is_like
+	return util.or_throw(likes.first().vals[1]).bool()
 }
 
 // does_user_dislike_post returns true if a user dislikes the given post.
 pub fn (app &DatabaseAccess) does_user_dislike_post(user_id int, post_id int) bool {
-	likes := sql app.db {
-		select from Like where user_id == user_id && post_id == post_id
-	} or { [] }
+	likes := app.db.exec_param2('SELECT id, is_like FROM "Like" WHERE user_id = $1 AND post_id = $2', user_id.str(), post_id.str()) or { [] }
 	if likes.len > 1 {
 		// something is very wrong lol
-		eprintln('a user somehow got two or more likes on the same post (user: ${user_id}, post: ${post_id})')
+		eprintln('does_user_dislike_post: a user somehow got two or more likes on the same post (user: ${user_id}, post: ${post_id})')
 	} else if likes.len == 0 {
 		return false
 	}
-	return !likes.first().is_like
+	return !util.or_throw(likes.first().vals[1]).bool()
 }
 
 // does_user_like_or_dislike_post returns true if a user likes *or* dislikes the
 // given post.
 pub fn (app &DatabaseAccess) does_user_like_or_dislike_post(user_id int, post_id int) bool {
-	likes := sql app.db {
-		select from Like where user_id == user_id && post_id == post_id
-	} or { [] }
+	likes := app.db.exec_param2('SELECT id FROM "Like" WHERE user_id = $1 AND post_id = $2', user_id.str(), post_id.str()) or { [] }
 	if likes.len > 1 {
 		// something is very wrong lol
-		eprintln('a user somehow got two or more likes on the same post (user: ${user_id}, post: ${post_id})')
+		eprintln('does_user_like_or_dislike_post: a user somehow got two or more likes on the same post (user: ${user_id}, post: ${post_id})')
 	}
 	return likes.len == 1
 }
···
 	}
 
 	// delete posts and their likes
-	posts_from_this_user := sql app.db {
-		select from Post where author_id == user_id
-	} or { [] }
+	posts_from_this_user := app.db.exec_param('SELECT id FROM "Post" WHERE author_id = $1', user_id.str()) or { [] }
 
 	for post in posts_from_this_user {
+		id := util.or_throw(post.vals[0]).int()
 		sql app.db {
-			delete from Like where post_id == post.id
-			delete from LikeCache where post_id == post.id
+			delete from Like where post_id == id
+			delete from LikeCache where post_id == id
 		} or {
-			eprintln('failed to delete like cache for post during user deletion: ${post.id}')
+			eprintln('failed to delete like cache for post during user deletion: ${id}')
 		}
 	}
 

src/entity/likes.v

···
 pub struct LikeCache {
 pub mut:
 	id      int @[primary; sql: serial]
-	post_id int
+	post_id int @[unique]
 	likes   int
 }