Example #1
0
  /**
   * Generates a QuestionSetWrapper containing valid question, answer pairs Skip elements introduces
   * randomness to the result query but at the cost of perhaps not having enough elements in the
   * result query if the ResultSet was small to begin with
   *
   * @param difficulty
   * @return
   * @throws SQLException
   */
  @SuppressWarnings("unchecked")
  private static Question generateQuestion(int difficulty, int choiceSize, boolean skipElements)
      throws SQLException {

    // Question parameters
    int answer = 0, indexSelected = 0;
    String question = null;
    List<String> choices = new ArrayList<>(choiceLimit);
    ArrayList<SQLGenreSet> genres = null;
    ArrayList<String> movies = null;
    ArrayList<Integer> years = null;
    ArrayList<Integer> aids = null;
    ArrayList<Integer> mids = null;
    boolean dbConnect = false;
    switch ((int) (Math.random() * questionTypeN)) {
      case 0:
        // what year is this movie released?
        if (!questionCache.containsKey(getCacheKey(0, difficulty))
            || Math.random() <= refreshThreshold) {
          dbConnect = true;
          loadIndex(0, difficulty, choiceSize, skipElements);
        }

        movies =
            (ArrayList<String>) questionCache.get(getCacheKey(0, difficulty)).getPropertyList();
        years = (ArrayList<Integer>) questionCache.get(getCacheKey(0, difficulty)).getAnswerList();
        //
        if (movies.size() < resultThreshold) {
          System.out.println(
              "Insufficient amount of elements for question type: (" + movies.size() + ", 0)");
          System.out.println("Re-generating question without skipping");
          return generateQuestion(difficulty, choiceSize, false);
        } else {
          System.out.println("Valid result set, proceeding with computations");
          if (!questionCache.containsKey(getCacheKey(0, difficulty)) || dbConnect) {
            questionCache.put(
                getCacheKey(0, difficulty), new QuestionSetWrapper<String, Integer>(movies, years));
          }
        }
        indexSelected = (int) (Math.random() * movies.size());
        question = "What year was " + movies.get(indexSelected) + " first released?";
        int yearSelected = years.get(indexSelected);
        String yearStr = Integer.toString(yearSelected);
        // populate choices with (choiceLimit - 1) elements
        for (int i = 0; i < choiceLimit - 1; ++i) {

          if (Math.random() > 0.70) {
            int randomCloseYear = yearSelected;
            if (yearSelected < 2000 && Math.random() > 0.50) {
              randomCloseYear += 1 + ((int) (10 * Math.random()));
            } else {
              randomCloseYear -= 1 + ((int) (10 * Math.random()));
            }
            String randomCloseYearString = Integer.toString(randomCloseYear);
            if (!choices.contains(randomCloseYearString)) {
              choices.add(randomCloseYearString);
            } else {
              --i;
            }
          } else {
            // random number from 1900 to 2015
            int randomYear = 1900 + ((int) (Math.random() * 116));
            String randomYearString = Integer.toString(randomYear);
            if (randomYear != yearSelected && !choices.contains(randomYearString)) {
              choices.add(randomYearString);
            } else {
              // just redo calculation
              --i;
            }
          }
        }
        answer = (int) (Math.random() * (choices.size() + 1));
        choices.add(answer, yearStr);
        return new Question(question, choices, answer);
      case 1:
        // what set of genres best matches this movie?
        if (!questionCache.containsKey(getCacheKey(1, difficulty))
            || Math.random() <= refreshThreshold) {
          dbConnect = true;
          loadIndex(1, difficulty, choiceSize, skipElements);
        }
        movies =
            (ArrayList<String>) questionCache.get(getCacheKey(1, difficulty)).getPropertyList();
        genres =
            (ArrayList<SQLGenreSet>) questionCache.get(getCacheKey(1, difficulty)).getAnswerList();

        if (movies.size() < resultThreshold) {
          System.out.println(
              "Insufficient amount of elements for question type: (" + movies.size() + ", 1)");
          System.out.println("Re-generating question without skipping");
          return generateQuestion(difficulty, choiceSize, false);
        } else {
          System.out.println("Valid result set, proceeding with computations");
        }
        indexSelected = (int) (Math.random() * movies.size());
        String movieSelected = movies.get(indexSelected);
        question = "What set of genres best matches the movie " + movieSelected + "?";
        SQLGenreSet genreSetSelected = genres.get(indexSelected);
        HashSet<SQLGenreSet> genresChosen = new HashSet<>();
        for (int i = 0; i < choiceLimit - 1; ++i) {
          int index = (int) (Math.random() * movies.size());
          SQLGenreSet genreSet = genres.get(index);
          if (index != indexSelected
              && !genresChosen.contains(genreSet)
              && !genreSet.equals(genreSetSelected)) {
            choices.add(genreSet.toString());
            genresChosen.add(genreSet);
          } else if (Math.random() > 0.10) {
            --i;
          }
        }
        answer = (int) (Math.random() * (choices.size() + 1));
        choices.add(answer, genreSetSelected.toString());
        return new Question(question, choices, answer);
      case 2:
        // which of these movies is the oldest?
        movies = null;
        years = null;
        if (!questionCache.containsKey(getCacheKey(0, difficulty))
            || Math.random() <= refreshThreshold) {
          dbConnect = true;
          loadIndex(0, difficulty, choiceSize, skipElements);
        }

        movies =
            (ArrayList<String>) questionCache.get(getCacheKey(0, difficulty)).getPropertyList();
        years = (ArrayList<Integer>) questionCache.get(getCacheKey(0, difficulty)).getAnswerList();

        if (movies.size() < resultThreshold) {
          System.out.println(
              "Insufficient amount of elements for question type: (" + movies.size() + ", 3)");
          System.out.println("Re-generating question without skipping");
          return generateQuestion(difficulty, choiceSize, false);
        } else {
          System.out.println("Valid result set, proceeding with computations");
        }
        // randomly generate 5 movies that were made in different years
        TreeMap<Integer, String> movieYearPair = new TreeMap<>();
        for (int i = 0; i < choiceLimit; ++i) {
          indexSelected = (int) (Math.random() * movies.size());
          if (movieYearPair.containsKey(years.get(indexSelected))) {
            --i;
            continue;
          }
          movieYearPair.put(years.get(indexSelected), movies.get(indexSelected));
        }
        movies = new ArrayList<String>(movieYearPair.values());
        years = new ArrayList<Integer>(movieYearPair.keySet());
        years.remove(0);
        String lowestYearString = movies.remove(0);
        int iter_size = movies.size();
        for (int i = 0; i < iter_size; ++i) {
          int random_index = (int) (movies.size() * Math.random());
          choices.add(movies.remove(random_index));
          years.remove(random_index);
        }
        answer = (int) (Math.random() * (choices.size() + 1));
        choices.add(answer, lowestYearString);
        question = "Which of these movies (";
        for (int i = 0; i < choices.size(); ++i) {
          question = question + choices.get(i) + ((i == choices.size() - 1) ? "" : ", ");
        }
        question = question + ") was made the earliest?";
        return new Question(question, choices, answer);
      case 3:
        /*
        // which movie has actor X acted in
        if (!cacheContainsKey(3, difficulty) || Math.random() <= refreshThreshold) {
        	loadIndex(3, difficulty, choiceSize, skipElements);
        }
        // Instead of movies and genres, they are actors and movies but
        // that's good enough
        movies = (ArrayList<String>) questionCache.get(getCacheKey(3, difficulty)).getPropertyList();
        genres = (ArrayList<SQLGenreSet>) questionCache.get(getCacheKey(3, difficulty)).getAnswerList();

        if (movies.size() < resultThreshold) {
        	System.out.println("Insufficient amount of elements for question type: (" + movies.size() + ", 1)");
        	System.out.println("Re-generating question without skipping");
        	return generateQuestion(difficulty, choiceSize, false);
        } else {
        	System.out.println("Valid result set, proceeding with computations");
        }
        indexSelected = (int) (Math.random() * movies.size());
        movieSelected = movies.get(indexSelected);
        question = "What movie has " + movieSelected + " acted in?";
        genreSetSelected = genres.get(indexSelected);
        HashSet<String> chosen3 = new HashSet<>();
        String answer3 = genreSetSelected.getList().remove(0);
        genreSetSelected.addGenre(answer3);
        chosen3.add(answer3);

        for (int i = 0; i < choiceLimit - 1; ++i) {
        	int index = (int) (Math.random() * movies.size());
        	SQLGenreSet genreSet = genres.get(index);
        	if (index != indexSelected) {
        		if (genreSet.getList().size() == 0) {
        			--i;
        			continue;
        		}
        		String movanswer = genreSet.getList().remove(0);
        		if (!genreSetSelected.contains(movanswer) && !chosen3.contains(movanswer)) {
        			choices.add(movanswer);
        			chosen3.add(movanswer);
        		} else {
        			--i;
        		}
        	} else if (Math.random() > 0.10) {
        		--i;
        	}
        }
        answer = (int) (Math.random() * (choices.size() + 1));
        choices.add(answer, answer3);
        return new Question(question, choices, answer);*/

      case 4:

        /*// which movie has actor X not acted in
        	if (!cacheContainsKey(3, difficulty) || Math.random() <= refreshThreshold) {
        		loadIndex(3, difficulty, choiceSize, skipElements);
        	}
        	// Instead of movies and genres, they are actors and movies but
        	// that's good enough
        	movies = (ArrayList<String>) questionCache.get(getCacheKey(3, difficulty)).getPropertyList();
        	genres = (ArrayList<SQLGenreSet>) questionCache.get(getCacheKey(3, difficulty)).getAnswerList();

        	if (movies.size() < resultThreshold) {
        		System.out.println("Insufficient amount of elements for question type: (" + movies.size() + ", 1)");
        		System.out.println("Re-generating question without skipping");
        		return generateQuestion(difficulty, choiceSize, false);
        	} else {
        		System.out.println("Valid result set, proceeding with computations");
        	}
        	indexSelected = (int) (Math.random() * movies.size());
        	movieSelected = movies.get(indexSelected);
        	question = "What movie has " + movieSelected + " NOT acted in?";
        	genreSetSelected = genres.get(indexSelected);
        	HashSet<String> chosen4 = new HashSet<>();
        	for (int i = 0; i < choiceLimit - 1 && i < genreSetSelected.getList().size(); ++i) {
        		chosen4.add(genreSetSelected.getList().get(i));
        	}
        	String answer4 = null;
        	while (answer4 == null) {
        		int index = (int) (Math.random() * movies.size());
        		SQLGenreSet genreSet = genres.get(index);
        		if (index != indexSelected) {
        			if (genreSet.getList().size() == 0) {
        				continue;
        			}
        			String movanswer = genreSet.getList().remove(0);
        			if (!genreSetSelected.contains(movanswer) && !chosen4.contains(movanswer)) {
        				choices.add(movanswer);
        				answer4 = movanswer;
        			}
        		}
        	}
        	answer = (int) (Math.random() * (choices.size() + 1));
        	choices.add(answer, answer4);
        	return new Question(question, choices, answer);
        */
      case 5:
      case 6:
        // just re-generate question since incomplete code
        return generateQuestion(difficulty, choiceSize, skipElements);
      case 7:
        // has actor X acted in same movie as actor Y?
        if (!cacheContainsKey(7, difficulty) || Math.random() <= refreshThreshold) {
          loadIndex(7, difficulty, choiceSize, skipElements);
        }
        mids = (ArrayList<Integer>) questionCache.get(getCacheKey(7, difficulty)).getPropertyList();
        aids = (ArrayList<Integer>) questionCache.get(getCacheKey(7, difficulty)).getAnswerList();
        int actor1 = -1, actor2 = -1;
        for (int i = 0; i < choiceSize * 2 && (actor1 == -1 || actor2 == -1); i++) {
          int randomVal = aids.get((int) (Math.random() * mids.size()));
          if (actor1 == -1) {
            actor1 = randomVal;
          } else if (randomVal == actor1) {
            continue;
          } else {
            actor2 = randomVal;
            break;
          }
        }
        Connection conn = DBConnect.getConnection();
        HashSet<Integer> actor1MovieSet = new HashSet<>();
        HashSet<Integer> actor2MovieSet = new HashSet<>();
        String a1Name = "", a2Name = "";
        try {
          Statement statement = conn.createStatement();
          ResultSet rs =
              statement.executeQuery("select mid as mid from movie.acts where aid = " + actor1);
          while (rs.next()) {
            int movieID = rs.getInt("mid");
            actor1MovieSet.add(movieID);
          }
          statement = conn.createStatement();
          rs = statement.executeQuery("select mid as mid from movie.acts where aid = " + actor1);
          while (rs.next()) {
            int movieID = rs.getInt("mid");
            actor2MovieSet.add(movieID);
          }
          statement = conn.createStatement();
          rs =
              statement.executeQuery("select name as name from movie.actors where aid = " + actor1);
          if (rs.next()) {
            a1Name = rs.getString("name");
          } else {
            System.out.println("actor id " + actor1 + " does not have a name");
          }
          statement = conn.createStatement();
          rs =
              statement.executeQuery("select name as name from movie.actors where aid = " + actor2);
          if (rs.next()) {
            a2Name = rs.getString("name");
          } else {
            System.out.println("actor id " + actor2 + " does not have a name");
          }
        } finally {
          if (conn != null) {
            conn.close();
          }
        }
        answer = 1;
        for (int mid : actor1MovieSet) {
          if (actor2MovieSet.contains(mid)) {
            answer = 0;
            break;
          }
        }
        question = "Have " + a1Name + " and " + a2Name + " acted in the same movie?";
        choices.add("True");
        choices.add("False");
        return new Question(question, choices, answer);
      case 8:
        // which set of genres is movie X NOT about?
        if (!questionCache.containsKey(getCacheKey(1, difficulty))
            || Math.random() <= refreshThreshold) {
          dbConnect = true;
          loadIndex(1, difficulty, choiceSize, skipElements);
        }
        movies =
            (ArrayList<String>) questionCache.get(getCacheKey(1, difficulty)).getPropertyList();
        genres =
            (ArrayList<SQLGenreSet>) questionCache.get(getCacheKey(1, difficulty)).getAnswerList();
        if (movies.size() < resultThreshold) {
          System.out.println(
              "Insufficient amount of elements for question type: (" + movies.size() + ", 8)");
          System.out.println("Re-generating question without skipping");
          return generateQuestion(difficulty, choiceSize, false);
        } else {
          System.out.println("Valid result set, proceeding with computations");
        }
        indexSelected = (int) (Math.random() * movies.size());
        movieSelected = movies.get(indexSelected);
        question = "Which of these genres does not match the genre of " + movieSelected + "?";
        genreSetSelected = genres.get(indexSelected);
        if (genreSetSelected.size() == 0) {
          return generateQuestion(difficulty, choiceSize, skipElements);
          // just redo, we selected bad data on random
        }
        ArrayList<String> choiceCandidates = genreSetSelected.getScrambledList();
        for (int i = 0; i < choiceLimit - 1 && i < choiceCandidates.size(); ++i) {
          choices.add(choiceCandidates.get(i));
        }
        answer = (int) (Math.random() * (choices.size() + 1));
        ArrayList<String> genresSetComplement = new ArrayList<>();
        for (String s : ALL_GENRES) {
          if (!genreSetSelected.contains(s)) {
            genresSetComplement.add(s);
          }
        }
        if (genresSetComplement.isEmpty()) {
          System.out.println("Genres set complement is empty, re-generating question.");
          System.out.println("Genres set was " + genreSetSelected.toString());
          return generateQuestion(difficulty, choiceSize, skipElements);
        }
        choices.add(
            answer, genresSetComplement.get((int) (Math.random() * genresSetComplement.size())));
        return new Question(question, choices, answer);
      case 9:

      case 10:
        // which actor is associated with date of birth x?
        ArrayList<String> aName = null;
        ArrayList<String> aDOB = null;
        if (!questionCache.containsKey(getCacheKey(10, difficulty))
            || Math.random() <= refreshThreshold) {
          dbConnect = true;
          loadIndex(10, difficulty, choiceSize, skipElements);
        }
        aName =
            (ArrayList<String>) questionCache.get(getCacheKey(10, difficulty)).getPropertyList();
        aDOB = (ArrayList<String>) questionCache.get(getCacheKey(10, difficulty)).getAnswerList();
        if (aName.size() < resultThreshold) {
          System.out.println(
              "Insufficient amount of elements for question type: (" + aName.size() + ", 10)");
          System.out.println("Re-generating question without skipping");
          return generateQuestion(difficulty, choiceSize, false);
        } else {
          System.out.println("Valid result set, proceeding with computations");
        }
        ArrayList<Integer> randomSelects = new ArrayList<>();
        for (int i = 0; i < choiceLimit; ++i) {
          int randomIndex = (int) (Math.random() * aName.size());
          if (!randomSelects.contains(randomIndex) && !choices.contains(aDOB.get(randomIndex))) {
            randomSelects.add(randomIndex);
            choices.add(aDOB.get(randomIndex));
          } else {
            --i;
          }
        }
        // randomSelects now contains 5 random indices to (actor, DOB) pair
        answer = (int) (Math.random() * randomSelects.size());
        question =
            "On which day was actor "
                + aName.get(randomSelects.get(answer))
                + " born? (YYYY-MM-DD)";
        return new Question(question, choices, answer);
      default:
    }
    return null;
  }
Example #2
0
  private static void loadIndex(int qType, int difficulty, int choiceSize, boolean skipElements)
      throws SQLException {
    ArrayList<String> actorNames = new ArrayList<>();
    ArrayList<String> actorDOBs = new ArrayList<>();
    ArrayList<String> movies = new ArrayList<>();
    ArrayList<Integer> years = new ArrayList<>();
    ArrayList<Integer> idList = new ArrayList<>();
    int skip = maxSkipNumber(choiceSize, difficulty) / 2;
    if (!skipElements) {
      skip = 2;
    } else {
      skip += (int) (Math.random() * skip);
      skip = skip * 3 / 4;
    }
    switch (qType) {
      case 0:
        Connection connection = DBConnect.getConnection();

        ResultSet rs = null;
        try {
          String qry =
              "SELECT * from (SELECT @row := @row +1 AS rownum, name, "
                  + "rating FROM (SELECT @row := 0) r, movie.movies offset "
                  + ") ranked WHERE rownum % "
                  + skip
                  + " = 1 AND rating > "
                  + getRating(difficulty);
          qry =
              "select M.name as name from movie.movies as M where M.mid % "
                  + skip
                  + " = 1 and M.rating > "
                  + getRating(difficulty);

          Statement s = connection.createStatement();
          System.out.println("Executing: " + qry);
          rs = s.executeQuery(qry);

          // rs.next() is actually very slow so we would
          // like to minimize the time by caching the results
          while (rs.next() && movies.size() <= choiceSize) {
            String name = "";
            int year = 0;
            String nameYear = rs.getString("name");
            System.out.println("Processing: " + nameYear);
            String tokens[] = nameYear.split("\\s");
            Pattern p = Pattern.compile("\\(\\d\\d\\d\\d\\)");
            for (String token : tokens) {
              Matcher m = p.matcher(token);
              if (m.matches()) {
                token = token.replaceAll("[\\(\\)]", "");
                try {
                  year = Integer.parseInt(token);
                } catch (NumberFormatException e) {
                  e.printStackTrace();
                }
              } else {
                name = name + " " + token;
              }
            }
            if (year > 0 && !name.matches("(\\s)*")) {
              // from this, we guarantee that the indexes will
              // match
              // for (movie, year)
              movies.add(name);
              years.add(year);
            }
          }
          questionCache.put(
              getCacheKey(0, difficulty), new QuestionSetWrapper<String, Integer>(movies, years));
        } finally {
          if (connection != null) {
            connection.close();
          }
        }
        break;
      case 1:
        LinkedHashMap<String, SQLGenreSet> genres = new LinkedHashMap<>();
        connection = DBConnect.getConnection();
        try {
          skip = maxSkipNumber(choiceSize, difficulty) / 2;
          skip += (int) (Math.random() * skip);
          skip = skip * 3 / 4;
          String qry = null;
          // preQuery selects 'choiceSize' number of rows from movies to
          // join into movie_genre
          String preQuery =
              "(SELECT * from (SELECT @row := @row +1 as rownum, name as name, mid as mid, rating as rating FROM (SELECT @row := 0) r, movie.movies) ranked WHERE rownum % "
                  + skip
                  + " = 1 AND rating > "
                  + getRating(difficulty)
                  + ")";

          preQuery =
              "(select M.name as name, M.mid as mid from movie.movies as M where M.mid % "
                  + skip
                  + " = 1 and M.rating > "
                  + getRating(difficulty)
                  + ")";

          qry =
              "select movie.movie_genre.genre as m_genre, T.name as m_name from movie.movie_genre inner join "
                  + preQuery
                  + "as T on T.mid = movie.movie_genre.mid";

          Statement s = connection.createStatement();
          System.out.println("Executing: " + qry);
          rs = s.executeQuery(qry);
          while (rs.next() && genres.size() <= choiceSize) {
            String nameString = rs.getString("m_name");
            String genreString = rs.getString("m_genre");
            if (!genres.containsKey(nameString)) {
              genres.put(nameString, new SQLGenreSet());
            }
            SQLGenreSet sqlGenre = genres.get(nameString);
            sqlGenre.addGenre(genreString);
          }
          questionCache.put(
              getCacheKey(1, difficulty),
              new QuestionSetWrapper<String, SQLGenreSet>(
                  new ArrayList<String>(genres.keySet()),
                  new ArrayList<SQLGenreSet>(genres.values())));
        } finally {
          if (connection != null) {
            connection.close();
          }
        }
        break;
      case 2:
      case 3:
        skip = 10 + (int) (Math.random() * 180000);
        connection = DBConnect.getConnection();
        LinkedHashMap<String, SQLGenreSet> map3 = new LinkedHashMap<>();
        try {
          String qry =
              "SELECT a.name as actor, m.name as movie FROM movie.actors a, movies.movie m "
                  + "INNER JOIN movies.acts act ON m.mid = acts.mid and acts.aid = a.aid "
                  + "WHERE m.mid IN (SELECT mid from (SELECT @row := @row +1 AS rownum, mid as mid"
                  + "rating FROM (SELECT @row := 0) r, movie.movies offset "
                  + ") ranked WHERE rownum % "
                  + skip
                  + " = 1 AND rating > "
                  + getRating(difficulty)
                  + ")";
          qry =
              "select A.name as actor, M.name as movie from movie.actors as A inner join movie.acts as AM on A.aid = AM.aid inner join movie.movies M on AM.mid = M.mid where M.mid % "
                  + skip
                  + " = 1 and M.rating > "
                  + getRating(difficulty);
          Statement s3 = connection.createStatement();
          System.out.println("Executing: " + qry);
          rs = s3.executeQuery(qry);
          while (rs.next() && map3.size() <= choiceSize) {
            String actor = rs.getString("actor");
            String movie = rs.getString("movie");
            if (!map3.containsKey(actor)) {
              map3.put(actor, new SQLGenreSet());
            }
            SQLGenreSet set = map3.get(actor);
            set.addGenre(movie);
          }
          questionCache.put(
              getCacheKey(3, difficulty),
              new QuestionSetWrapper<String, SQLGenreSet>(
                  new ArrayList<String>(map3.keySet()), new ArrayList<SQLGenreSet>(map3.values())));
        } finally {
          if (connection != null) {
            connection.close();
          }
        }
        break;

      case 4:
      case 5:
      case 6:
      case 7:
        if (!cacheContainsKey(9, difficulty)) {
          loadIndex(9, difficulty, choiceSize, skipElements);
        }
        skip = 10 + (int) (Math.random() * 180000);
        connection = DBConnect.getConnection();
        ArrayList<Integer> idList2 = new ArrayList<>(choiceSize * 2);
        try {
          String qry =
              "(SELECT * from (SELECT @row := @row +1 as rownum, aid as aid, "
                  + "mid as mid FROM (SELECT @row := 0) r, movie.acts) "
                  + "ranked WHERE rownum % 1 = 0 order by mid desc limit "
                  + skip
                  + ", 200000)";
          qry = "select A.aid as aid, A.mid as mid from movie.acts as A limit " + skip + ", 200000";
          Statement s = connection.createStatement();
          System.out.println("Executing: " + qry);
          rs = s.executeQuery(qry);

          // rs.next() is actually very slow so we would
          // like to minimize the time by caching the results
          while (rs.next() && actorNames.size() <= choiceSize * 2) {
            int mid = rs.getInt("mid");
            int aid = rs.getInt("aid");
            idList.add(mid);
            idList2.add(aid);
          }
          questionCache.put(
              getCacheKey(7, difficulty),
              new QuestionSetWrapper<Integer, Integer>(idList, idList2));
        } finally {
          if (connection != null) {
            connection.close();
          }
        }
        break;
      case 8:
        // we'll use 8 as a way to load random actors
        skip = Question.maxSkipNumberActorOverall(choiceSize) / 2;
        skip += (int) (Math.random() * skip);
        skip = skip * 3 / 4;
        connection = DBConnect.getConnection();

        try {
          String qry =
              "(SELECT * from (SELECT @row := @row +1 as rownum, name as a_name, aid as a_aid FROM (SELECT @row := 0) r, movie.actors) ranked WHERE rownum % "
                  + skip
                  + " = 0)";
          Statement s = connection.createStatement();
          System.out.println("Executing: " + qry);
          rs = s.executeQuery(qry);

          // rs.next() is actually very slow so we would
          // like to minimize the time by caching the results
          while (rs.next() && actorNames.size() <= choiceSize) {
            String name = rs.getString("a_name");
            int aid = rs.getInt("a_aid");
            if (!name.matches("(\\s)*")) {
              actorNames.add(name);
              idList.add(aid);
            }
          }
          questionCache.put(
              getCacheKey(8, difficulty),
              new QuestionSetWrapper<Integer, String>(idList, actorNames));
        } finally {
          if (connection != null) {
            connection.close();
          }
        }
        break;
      case 9:
        // we'll use 9 as a way to load random movies
        skip = maxSkipNumber(choiceSize, difficulty) / 2;
        skip += (int) (Math.random() * skip);
        skip = skip * 3 / 4;
        connection = DBConnect.getConnection();

        try {
          String qry =
              "(SELECT * from (SELECT @row := @row +1 as rownum, name as m_name, mid as mid FROM (SELECT @row := 0) r, movie.movies) ranked WHERE rownum % "
                  + skip
                  + " = 0)";
          Statement s = connection.createStatement();
          System.out.println("Executing: " + qry);
          rs = s.executeQuery(qry);

          // rs.next() is actually very slow so we would
          // like to minimize the time by caching the results
          while (rs.next() && actorNames.size() <= choiceSize) {
            String name = rs.getString("m_name");
            int mid = rs.getInt("mid");
            if (!name.matches("(\\s)*")) {
              movies.add(name);
              idList.add(mid);
            }
          }
          questionCache.put(
              getCacheKey(9, difficulty), new QuestionSetWrapper<Integer, String>(idList, movies));
        } finally {
          if (connection != null) {
            connection.close();
          }
        }
        break;
      case 10:
        skip = maxSkipNumberActorWithBirthday(choiceSize) / 2;
        skip += (int) (Math.random() * skip);
        skip = skip * 3 / 4;
        connection = DBConnect.getConnection();

        rs = null;
        try {
          String qry =
              "select * from (select @row := @row +1 as rownum, A.name as a_name, A.Date_of_birth as a_DOB from (SELECT @row := 0) r, movie.actors as A where A.Date_of_birth like '%%%%-%%-%%') ranked where rownum % "
                  + skip
                  + " = 1";
          qry =
              "select A.name as a_name, A.Date_of_birth as a_DOB from movie.actors as A where A.Date_of_birth like '%%%%-%%-%%' and aid % "
                  + skip
                  + " = 1";
          Statement s = connection.createStatement();
          System.out.println("Executing: " + qry);
          rs = s.executeQuery(qry);

          // rs.next() is actually very slow so we would
          // like to minimize the time by caching the results
          while (rs.next() && actorNames.size() <= choiceSize) {
            String name = rs.getString("a_name");
            String dob = rs.getString("a_DOB");

            if (!dob.matches("(\\s)*") && !name.matches("(\\s)*")) {
              actorNames.add(name);
              actorDOBs.add(dob);
            }
          }
          questionCache.put(
              getCacheKey(10, difficulty),
              new QuestionSetWrapper<String, String>(actorNames, actorDOBs));
        } finally {
          if (connection != null) {
            connection.close();
          }
        }
        break;
      default:
    }
  }