dyna: advanced searches, move course_info into course and add like_ratio, boo_ratio and clear_rate

db/dyna/course_info.go

···
 		clears = 1
 	}
 	_, err := s.Conn.Exec(context.Background(), `
-		INSERT INTO course_info (id, data_id, plays, tries, deaths, clears, likes, boos) VALUES (DEFAULT, $1, 1, $2, $3, $4, 0, 0)
-		ON CONFLICT (data_id) DO UPDATE SET plays = course_info.plays + 1, tries = course_info.tries + $2, deaths = course_info.deaths + $3, clears = course_info.clears + $4
+		INSERT INTO course (id, data_id, plays, tries, deaths, clears) VALUES (DEFAULT, $1, 1, $2, $3, $4)
+		ON CONFLICT (data_id) DO UPDATE SET plays = course.plays + 1, tries = course.tries + $2, deaths = course.deaths + $3, clears = course.clears + $4, clear_rate = (course.clears::float / COALESCE(NULLIF(course.tries,0), 1)::float)
 	`, result.DataId, result.Tries, result.Deaths, clears)
 	return err
 }
···
 	}
 
 	_, err := s.Conn.Exec(context.Background(), `
-		INSERT INTO course_info (id, data_id, plays, tries, deaths, clears, likes, boos) VALUES (DEFAULT, $1, 0, 0, 0, 0, $2, $3)
-		ON CONFLICT (data_id) DO UPDATE SET likes = course_info.likes + $2, boos = course_info.boos + $3
+		INSERT INTO course (id, data_id, likes, boos) VALUES (DEFAULT, $1, $2, $3)
+		ON CONFLICT (data_id) DO UPDATE SET likes = course.likes + $2, boos = course.boos + $3, like_ratio = (course.likes::float / COALESCE(NULLIF(course.plays,0), 1)::float), boo_ratio = (course.boos::float / COALESCE(NULLIF(course.plays,0), 1)::float)
 	`, dataId, like, boo)
 	return err
 }
 
 func (s *DB) GetCourseInfoPlayStatsAndRatings(dataId int64) (int, int, int, int, int, int, error) {
-	row := s.Conn.QueryRow(context.Background(), `SELECT plays, tries, deaths, clears, likes, boos FROM course_info WHERE data_id = $1`, dataId)
+	row := s.Conn.QueryRow(context.Background(), `SELECT plays, tries, deaths, clears, likes, boos FROM course WHERE data_id = $1`, dataId)
 	var plays int
 	var tries int
 	var deaths int

db/dyna/dyna.go

···
 func (s *DB) SearchCoursesAdvanced(current_pid datastore.Pid, dumpView *dump_view.DumpView, param view.SearchCoursesParam) ([]datastore.CourseInfo, []uint32, bool, error) {
 	infos := []datastore.CourseInfo{}
 
-	sortBy := "ORDER BY time_uploaded DESC"
+	sortBy := ""
 	//sortBy := "ORDER BY id DESC"
 	switch param.Advanced.SortType {
 	case 0:
 		// by popularity
-		// TODO
-	case 1:
-		// by clear rate
-		// TODO
+		sortBy = "ORDER BY likes DESC, plays DESC"
 	case 2:
 		// by popularity in multiplayer versus
-		// TODO
+		// but use its as by time_uploaded
+		sortBy = "ORDER BY time_uploaded DESC"
+	case 1:
+		// by clear rate
+		sortBy = "ORDER BY clear_rate ASC, time_uploaded DESC"
+	case 10:
+		// popular tab
+		sortBy = "ORDER BY like_ratio DESC"
+	case 11:
+		// hot tab
+		sortBy = "ORDER BY boo_ratio ASC, plays DESC"
 	}
 
 	limitUploadDate := "AND time_uploaded IS NOT NULL"
···
 		limitUploadDate = fmt.Sprintf("AND time_uploaded > (CURRENT_DATE - INTERVAL '365 days')")
 	case 3:
 		// ALL
+	case 10:
+		// weekly
+		limitUploadDate = fmt.Sprintf("AND time_uploaded > (CURRENT_DATE - INTERVAL '7 days')")
+	case 11:
+		// monthly
+		limitUploadDate = fmt.Sprintf("AND time_uploaded > (CURRENT_DATE - INTERVAL '30 days')")
 	}
 
 	limitPlays := ""
···
 	case 3:
 		// ALL
 	}
-	limitPlays = "" // TODO: we don't have plays field on course yet
 
 	courseTheme := ""
 	if param.Advanced.CourseTheme != 0xff {
···
 	}
 
 	difficulty := ""
-	if param.Advanced.Difficulty != 4 {
-		difficulty = fmt.Sprintf("difficulty = %d AND ", param.Advanced.Difficulty)
+	/*
+		// ignore for now and just use clear_rate
+		if param.Advanced.Difficulty != 4 {
+			difficulty = fmt.Sprintf("difficulty = %d AND ", param.Advanced.Difficulty)
+		}
+	*/
+	switch param.Advanced.Difficulty {
+	case 0:
+		// easy
+		difficulty = "clear_rate > 0.8 AND "
+	case 1:
+		// normal
+		difficulty = "clear_rate > 0.4 AND clear_rate < 0.81 AND "
+	case 2:
+		// expert
+		difficulty = "clear_rate > 0.2 AND clear_rate < 0.41 AND "
+	case 3:
+		// super expert
+		//difficulty = "plays > 20 AND clear_rate < 0.2 AND "
+		difficulty = "clear_rate < 0.2 AND "
+	case 4:
+		// ALL
 	}
 
 	byTags := ""
-	if len(param.Advanced.Tags) != 16 {
+	if len(param.Advanced.Tags) != 16 && len(param.Advanced.Tags) < 16 {
 		list := []string{}
 		for _, tagId := range param.Advanced.Tags {
 			list = append(list, strconv.Itoa(int(tagId)))
···
 	}
 
 	rejectRegions := ""
-	if len(param.Advanced.RejectRegions) != 0 {
+	if len(param.Advanced.RejectRegions) != 0 && len(param.Advanced.RejectRegions) < 10 {
 		list := []string{}
 		for _, _id := range param.Advanced.RejectRegions {
 			list = append(list, strconv.Itoa(int(_id)))
···
 }
 
 func (s *DB) GetCoursesLatest(offset, size int) ([]datastore.CourseInfo, error) {
-	rows, err := s.Conn.Query(context.Background(), "SELECT data_id FROM course WHERE deleted = False AND time_uploaded IS NOT NULL ORDER BY id DESC LIMIT $1 OFFSET $2", size, offset)
+	rows, err := s.Conn.Query(context.Background(), "SELECT data_id FROM course WHERE deleted = False AND time_uploaded IS NOT NULL ORDER BY time_uploaded DESC LIMIT $1 OFFSET $2", size, offset)
 	if err == pgx.ErrNoRows {
 		return []datastore.CourseInfo{}, nil
 	} else if err != nil {

db/migrations/000003_course_searches.down.sql

···
+ALTER TABLE IF EXISTS course DROP COLUMN plays;
+ALTER TABLE IF EXISTS course DROP COLUMN tries;
+ALTER TABLE IF EXISTS course DROP COLUMN deaths;
+ALTER TABLE IF EXISTS course DROP COLUMN clears;
+ALTER TABLE IF EXISTS course DROP COLUMN likes;
+ALTER TABLE IF EXISTS course DROP COLUMN boos;
+ALTER TABLE IF EXISTS course DROP COLUMN like_ratio;
+ALTER TABLE IF EXISTS course DROP COLUMN boo_ratio;
+ALTER TABLE IF EXISTS course DROP COLUMN clear_rate;
+
+CREATE TABLE IF NOT EXISTS course_info (
+	id BIGSERIAL primary key,
+	data_id BIGINT,
+	plays INTEGER,
+	tries INTEGER,
+	deaths INTEGER,
+	clears INTEGER,
+	likes INTEGER,
+	boos INTEGER,
+	UNIQUE (data_id)
+);

db/migrations/000003_course_searches.up.sql

···
+DROP TABLE IF EXISTS course_info;
+ALTER TABLE IF EXISTS course ADD COLUMN plays INTEGER DEFAULT 0;
+ALTER TABLE IF EXISTS course ADD COLUMN tries INTEGER DEFAULT 0;
+ALTER TABLE IF EXISTS course ADD COLUMN deaths INTEGER DEFAULT 0;
+ALTER TABLE IF EXISTS course ADD COLUMN clears INTEGER DEFAULT 0;
+ALTER TABLE IF EXISTS course ADD COLUMN likes INTEGER DEFAULT 0;
+ALTER TABLE IF EXISTS course ADD COLUMN boos INTEGER DEFAULT 0;
+ALTER TABLE IF EXISTS course ADD COLUMN like_ratio FLOAT DEFAULT 0;
+ALTER TABLE IF EXISTS course ADD COLUMN boo_ratio FLOAT DEFAULT 0;
+ALTER TABLE IF EXISTS course ADD COLUMN clear_rate FLOAT DEFAULT 0;

db/view/combined_view/view.go

···
 		return s.DB.SearchCourses(state, datastore.Pid(state.Pid), s.DumpView, param)
 	case "advanced":
 		return s.DB.SearchCourses(state, datastore.Pid(state.Pid), s.DumpView, param)
+	case "hot":
+		return s.DB.SearchCourses(state, datastore.Pid(state.Pid), s.DumpView, param)
+	case "popular_weekly":
+		return s.DB.SearchCourses(state, datastore.Pid(state.Pid), s.DumpView, param)
+	case "popular_all_time":
+		return s.DB.SearchCourses(state, datastore.Pid(state.Pid), s.DumpView, param)
 	case "latest":
 		courses, err := s.DB.GetCoursesLatest(int(param.Offset), int(param.Size))
 		restSize := param.Size - uint32(len(courses))

nex/rmc/server/smm2/search_courses.go

···
 func (s *Server) SearchCoursesPickUp(param datastore.SearchCoursesPickUpParam) ([]datastore.CourseInfo, error) {
 	fmt.Printf("param %#v\n", param)
 	p := view.SearchCoursesParam{
-		Type:       "hot",
-		Offset:     0,
-		Size:       10,
-		Difficulty: param.Difficulty,
+		Type: "hot",
+		Advanced: datastore.SearchCoursesAdvancedParam{
+			Difficulty:   param.Difficulty,
+			Range:        datastore.ResultRange{Size: 50, Offset: 0},
+			SortType:     11, // hot
+			DateUploaded: 3,  // all time
+		},
 	}
 
 	courses, _, _, err := s.View.SearchCourses(s.State, p)
···
 func (s *Server) SearchCoursesTermsRanking(param datastore.SearchCoursesTermsRankingParam) ([]datastore.CourseInfo, []uint32, bool, error) {
 	fmt.Printf("param %#v\n", param)
 	p := view.SearchCoursesParam{
-		Type:       "popular_weekly",
-		Offset:     param.Range.Offset,
-		Size:       param.Range.Size,
-		Difficulty: param.Difficulty,
+		Type: "popular_weekly",
+		Advanced: datastore.SearchCoursesAdvancedParam{
+			Difficulty:   param.Difficulty,
+			Range:        param.Range,
+			SortType:     10, // popular
+			DateUploaded: 10, // weekly
+		},
 	}
 
 	courses, ranks, _, err := s.View.SearchCourses(s.State, p)
···
 func (s *Server) SearchCoursesPointRanking(param datastore.SearchCoursesPointRankingParam) ([]datastore.CourseInfo, []uint32, bool, error) {
 	fmt.Printf("param %#v\n", param)
 	p := view.SearchCoursesParam{
-		Type:       "popular_all_time",
-		Offset:     param.Range.Offset,
-		Size:       param.Range.Size,
-		Difficulty: param.Difficulty,
+		Type: "popular_all_time",
+		Advanced: datastore.SearchCoursesAdvancedParam{
+			Difficulty:   param.Difficulty,
+			Range:        param.Range,
+			SortType:     10, // popular
+			DateUploaded: 3,  // all time
+		},
 	}
 
 	courses, ranks, _, err := s.View.SearchCourses(s.State, p)