git.sesse.net Git - ccbs/blob - sql/ccbs.sql

   1 -- vim:set tw=0:
   2
   3 CREATE TABLE machines (
   4         machine SERIAL PRIMARY KEY,
   5         machinename VARCHAR NOT NULL,
   6
   7         UNIQUE ( machinename )
   8 );
   9
  10 CREATE TABLE countries (
  11         country SERIAL PRIMARY KEY,
  12         countryname VARCHAR NOT NULL,
  13         countrycode CHAR(3) NOT NULL,   -- IOC country code
  14
  15         UNIQUE ( countryname ),
  16         UNIQUE ( countrycode )
  17 );
  18
  19 CREATE TABLE clubs (
  20         club SERIAL PRIMARY KEY,
  21         clubname VARCHAR NOT NULL,
  22         clubcode CHAR(3) NOT NULL,
  23
  24         UNIQUE ( clubname ),
  25         UNIQUE ( clubcode )
  26 );
  27
  28 CREATE TABLE songs (
  29         song SERIAL PRIMARY KEY,
  30         title VARCHAR NOT NULL,
  31         artist VARCHAR NOT NULL,
  32         minbpm INTEGER NOT NULL,
  33         maxbpm INTEGER NOT NULL,
  34
  35         UNIQUE ( title )
  36 );
  37
  38 CREATE TABLE songshorttitles (
  39         song INTEGER NOT NULL REFERENCES songs,
  40         shorttitle VARCHAR NOT NULL,
  41
  42         PRIMARY KEY ( song, shorttitle ),
  43         UNIQUE ( shorttitle )
  44 );
  45
  46 CREATE TABLE machinesongs (
  47         song INTEGER NOT NULL REFERENCES songs,
  48         machine INTEGER NOT NULL REFERENCES machines,
  49
  50         PRIMARY KEY ( song, machine )
  51 );
  52
  53 CREATE TABLE scoringsystems (
  54         scoringsystem SERIAL PRIMARY KEY,
  55         scoringsystemname VARCHAR NOT NULL,
  56
  57         UNIQUE ( scoringsystemname )
  58 );
  59
  60 CREATE TABLE songratings (
  61         song INTEGER NOT NULL REFERENCES songs,
  62         machine INTEGER NOT NULL REFERENCES machines,
  63         playmode VARCHAR NOT NULL CHECK (playmode IN ('single','double')),
  64         difficulty VARCHAR NOT NULL CHECK (difficulty IN ('beginner','standard','difficult','expert','challenge')),
  65         feetrating INTEGER NOT NULL CHECK (feetrating >= 0 AND feetrating <= 10),
  66
  67         PRIMARY KEY (song, machine, playmode, difficulty)
  68 );
  69 CREATE INDEX songratings_feetrating ON songratings ( feetrating );
  70
  71 CREATE VIEW max_single_feetrating AS SELECT machine,song,MAX(feetrating) AS feetrating FROM songratings WHERE playmode='single' GROUP BY machine,song;
  72
  73 CREATE TABLE players (
  74         player SERIAL PRIMARY KEY,
  75         nick VARCHAR NOT NULL,
  76         country INTEGER NOT NULL REFERENCES countries,
  77         club INTEGER REFERENCES clubs,
  78
  79         UNIQUE ( nick )
  80 );
  81
  82 CREATE TABLE seasons (
  83         season SERIAL PRIMARY KEY,
  84         seasonname VARCHAR NOT NULL,
  85
  86         UNIQUE ( seasonname )
  87 );
  88
  89 CREATE TABLE tournaments (
  90         tournament SERIAL PRIMARY KEY,
  91         season INTEGER NOT NULL REFERENCES seasons,
  92         tournamentname VARCHAR NOT NULL,
  93         country INTEGER NOT NULL REFERENCES countries,
  94         location VARCHAR NOT NULL,
  95         "date" DATE NOT NULL,
  96         machine INTEGER NOT NULL REFERENCES machines,
  97         scoringsystem INTEGER NOT NULL REFERENCES scoringsystems,
  98
  99         UNIQUE ( season, tournamentname )
 100 );
 101
 102 CREATE TABLE tournamentparticipation (
 103         tournament INTEGER NOT NULL REFERENCES tournaments,
 104         player INTEGER NOT NULL REFERENCES players,
 105         paid BOOLEAN NOT NULL,
 106
 107         PRIMARY KEY ( tournament, player )
 108 );
 109
 110 CREATE TABLE tournamentrankings (
 111         tournament INTEGER NOT NULL REFERENCES tournaments,
 112         ranking INTEGER NOT NULL,
 113         player INTEGER NOT NULL REFERENCES players,
 114         points INTEGER,
 115
 116         PRIMARY KEY (tournament, player)
 117 );
 118
 119 CREATE TABLE rounds (
 120         tournament INTEGER NOT NULL REFERENCES tournaments,
 121         round INTEGER NOT NULL,
 122         randomsongs INTEGER NOT NULL,
 123         chosensongs INTEGER NOT NULL,
 124         numqualifying INTEGER,
 125
 126         UNIQUE (tournament, player),
 127         PRIMARY KEY (tournament, round)
 128 );
 129
 130 CREATE TABLE groups (
 131         tournament INTEGER NOT NULL REFERENCES tournaments,
 132         round INTEGER NOT NULL,
 133         parallel INTEGER NOT NULL,
 134
 135         FOREIGN KEY (tournament, round) REFERENCES rounds (tournament, round),
 136         PRIMARY KEY (tournament, round, parallel)
 137 );
 138
 139 CREATE TABLE roundrandomsongs (
 140         tournament INTEGER NOT NULL,
 141         round INTEGER NOT NULL,
 142         parallel INTEGER NOT NULL,
 143         song INTEGER NOT NULL REFERENCES songs,
 144
 145         FOREIGN KEY (tournament, round, parallel) REFERENCES groups (tournament, round, parallel),
 146         PRIMARY KEY (tournament, round, parallel, song)
 147 );
 148
 149 CREATE TABLE roundparticipation (
 150         tournament INTEGER NOT NULL,
 151         round INTEGER NOT NULL,
 152         parallel INTEGER NOT NULL,
 153         player INTEGER NOT NULL REFERENCES players,
 154         position INTEGER NOT NULL,
 155
 156         UNIQUE (tournament, round, player),
 157         UNIQUE (tournament, round, parallel, position),
 158         FOREIGN KEY (tournament, round, parallel) REFERENCES groups (tournament, round, parallel),
 159         PRIMARY KEY (tournament, round, parallel, player)
 160 );
 161
 162 CREATE TABLE scores (
 163         tournament INTEGER NOT NULL,
 164         round INTEGER NOT NULL,
 165         parallel INTEGER NOT NULL,
 166         player INTEGER NOT NULL REFERENCES players,
 167         songnumber INTEGER NOT NULL,
 168
 169         song INTEGER REFERENCES songs,
 170         playmode VARCHAR CHECK (playmode IS NULL OR playmode IN ('single','double')),
 171         difficulty VARCHAR CHECK (difficulty IS NULL OR difficulty IN ('beginner','standard','difficult','expert','challenge')),
 172
 173         chosen BOOLEAN,
 174         score INTEGER CHECK (score IS NULL OR (score >= 0 AND score <= 10000)),
 175
 176         -- FOREIGN KEY (song, playmode, difficulty) REFERENCES songratings (song, playmode, difficulty),
 177         FOREIGN KEY (tournament, round, parallel, player) REFERENCES roundparticipation (tournament, round, parallel, player),
 178         PRIMARY KEY (tournament, round, parallel, player, songnumber)
 179 );
 180
 181 CREATE TABLE randomsongsused (
 182         song INTEGER NOT NULL PRIMARY KEY REFERENCES songs
 183 );
 184
 185 CREATE SCHEMA bigscreen;
 186
 187 CREATE TABLE bigscreen.active_tournament (
 188         tournament INTEGER NOT NULL PRIMARY KEY REFERENCES tournaments
 189 );
 190 CREATE TABLE bigscreen.active_groups (
 191         tournament INTEGER NOT NULL REFERENCES bigscreen.active_tournament,
 192         round INTEGER NOT NULL,
 193         parallel INTEGER NOT NULL,
 194         num_machines INTEGER NOT NULL,
 195         players_per_machine INTEGER NOT NULL CHECK ( players_per_machine IN (1, 2) ),
 196         last_updated TIMESTAMP NOT NULL,
 197
 198         PRIMARY KEY ( tournament, round, parallel ),
 199         FOREIGN KEY ( tournament, round, parallel ) REFERENCES groups
 200 );
 201 CREATE TABLE bigscreen.active_screens (
 202         id VARCHAR NOT NULL PRIMARY KEY
 203 );
 204
 205 -- get_max_score_for_songs(tournament, playmode)
 206 CREATE TYPE max_score AS (
 207         song INTEGER,
 208         max_score INTEGER
 209 );
 210
 211 CREATE FUNCTION get_max_score_for_songs(integer, varchar) RETURNS SETOF max_score
 212     AS $$
 213         SELECT
 214             song,
 215             MAX(feetrating)*1000 AS max_score
 216         FROM songratings
 217         WHERE
 218             machine=(
 219                 SELECT machine FROM tournaments WHERE tournament=$1
 220             )
 221             AND playmode=$2
 222         GROUP BY song
 223         ;
 224 $$
 225     LANGUAGE SQL
 226     STABLE
 227     RETURNS NULL ON NULL INPUT;
 228
 229 -- get_max_score_for_players(tournament, round, playmode)
 230 CREATE FUNCTION get_max_score_for_players(integer, integer, varchar) RETURNS SETOF max_score
 231     AS $$
 232         SELECT player,
 233           (
 234              SELECT feetrating
 235              FROM songratings
 236              WHERE machine=(         -- only find songs on the machine we use
 237                SELECT machine FROM tournaments WHERE tournament=$1
 238              )
 239              AND song NOT IN (       -- not a song that has been in elimination or seeding
 240                SELECT song FROM scores
 241                WHERE tournament=$1
 242                  AND song IS NOT NULL
 243                  AND parallel=0
 244                  AND chosen='f'
 245              )
 246              AND (player,song) NOT IN (  -- not a song the player has chosen before, or is a random song in this round
 247                SELECT player,song FROM scores
 248                WHERE tournament=$1
 249                  AND song IS NOT NULL
 250                  AND ( chosen='t' OR round=$2 )
 251              )
 252              AND playmode=$3
 253              ORDER BY feetrating DESC LIMIT 1
 254           ) * 1000 AS max_score FROM tournamentparticipation WHERE tournament=$1;
 255 $$
 256     LANGUAGE SQL
 257     STABLE
 258     RETURNS NULL ON NULL INPUT;
 259
 260 -- Find out, for each player in the group, what the maximum remaining score
 261 -- possibly can be, using get_max_score_for_{songs,players} (the first for
 262 -- selected but not played songs, the second for random songs that have not
 263 -- been chosen yet).
 264 --
 265 -- This doesn't solve problems we'd face with more than one chosen song, but it
 266 -- should be good enough.
 267
 268 CREATE TYPE minmax_score AS (
 269         player INTEGER,
 270         min_score INTEGER,
 271         max_score INTEGER
 272 );
 273
 274 -- get_minmax_score_for_players(tournament, round, parallel, playmode)
 275 CREATE FUNCTION get_minmax_score_for_players(integer, integer, integer, varchar) RETURNS SETOF minmax_score
 276     AS $$
 277 DECLARE
 278         ret minmax_score;
 279         tp RECORD;
 280         ts RECORD;
 281 BEGIN
 282         FOR tp IN SELECT player FROM roundparticipation WHERE tournament=$1 AND round=$2 AND parallel=$3 LOOP
 283                 ret.player := tp.player;
 284                 ret.min_score := 0;
 285                 ret.max_score := 0;
 286
 287                 FOR ts IN SELECT song,score FROM scores WHERE tournament=$1 AND round=$2 AND parallel=$3 AND player=tp.player LOOP
 288                         IF ts.score IS NOT NULL THEN
 289                                 -- score is already given
 290                                 ret.min_score := ret.min_score + ts.score;
 291                                 ret.max_score := ret.max_score + ts.score;
 292                         ELSE
 293                                 IF ts.song IS NOT NULL THEN
 294                                         ret.max_score := ret.max_score + ( SELECT max_score FROM get_max_score_for_songs($1, $4) WHERE song=ts.song );
 295                                 ELSE
 296                                         ret.max_score := ret.max_score + ( SELECT max_score FROM get_max_score_for_players($1, $2, $4) WHERE song=tp.player );
 297                                 END IF;
 298                         END IF;
 299                 END LOOP;
 300
 301                 RETURN NEXT ret;
 302         END LOOP;
 303         RETURN;
 304 END;
 305 $$
 306     LANGUAGE plpgsql
 307     STABLE
 308     RETURNS NULL ON NULL INPUT;
 309
 310 -- use the minmax_score as a basis for finding best and worst possible ranks
 311 CREATE TYPE minmax_rank AS (
 312         player INTEGER,
 313         best_rank INTEGER,
 314         worst_rank INTEGER
 315 );
 316
 317 -- get_minmax_score_for_players(tournament, round, parallel, playmode)
 318 CREATE TABLE temp_minmax (
 319         player INTEGER,
 320         min_score INTEGER,
 321         max_score INTEGER
 322 );
 323
 324 CREATE FUNCTION get_minmax_rank_for_players(integer, integer, integer, varchar) RETURNS SETOF minmax_rank
 325     AS $$
 326 DECLARE
 327         ret minmax_rank;
 328         tp RECORD;
 329 BEGIN
 330         INSERT INTO temp_minmax SELECT * FROM get_minmax_score_for_players($1, $2, $3, $4);
 331
 332         FOR tp IN SELECT * FROM temp_minmax LOOP
 333                 ret.player = tp.player;
 334                 ret.best_rank = 1 + ( SELECT COUNT(*) FROM temp_minmax WHERE min_score > tp.max_score AND player<>tp.player);
 335                 ret.worst_rank = 1 + ( SELECT COUNT(*) FROM temp_minmax WHERE max_score >= tp.min_score AND player<>tp.player );
 336
 337                 RETURN NEXT ret;
 338         END LOOP;
 339         TRUNCATE temp_minmax;
 340         RETURN;
 341 END;
 342     $$
 343     LANGUAGE plpgsql
 344     VOLATILE    -- not really, but needed for the TEMPORARY TABLE
 345     RETURNS NULL ON NULL INPUT;
 346
 347 -- get_minmax_score_for_players(tournament, playmode)
 348 CREATE TYPE minmax_rank_entire_tournament AS (
 349         round INTEGER,
 350         parallel INTEGER,
 351         player INTEGER,
 352         best_rank INTEGER,
 353         worst_rank INTEGER
 354 );
 355 CREATE FUNCTION get_minmax_rank_for_players(integer, varchar) RETURNS SETOF minmax_rank_entire_tournament
 356     AS $$
 357 DECLARE
 358         ret minmax_rank_entire_tournament;
 359         tr record;
 360         tp record;
 361 BEGIN
 362         FOR tr IN SELECT * FROM groups WHERE tournament=$1 LOOP
 363                 ret.round = tr.round;
 364                 ret.parallel = tr.parallel;
 365
 366                 FOR tp IN SELECT * FROM get_minmax_rank_for_players($1, tr.round, tr.parallel, $2) LOOP
 367                         ret.player = tp.player;
 368                         ret.best_rank = tp.best_rank;
 369                         ret.worst_rank = tp.worst_rank;
 370                         RETURN NEXT ret;
 371                 END LOOP;
 372         END LOOP;
 373         RETURN;
 374 END;
 375     $$
 376     LANGUAGE plpgsql
 377     STABLE
 378     RETURNS NULL ON NULL INPUT;