MATCH (u:User {user_id: $userId})<-[:Owned_by]-(q:Post_question)<-[:Tag_to]-(t:Tag)
RETURN DISTINCT t.tag_id AS tagId, t.tag_name AS tagName, t.count AS globalQuestionCount
ORDER BY globalQuestionCount DESC
LIMIT $limit;

MATCH (u:User {user_id: $userId})<-[:Owned_by]-(q:Post_question)<-[:Tag_to]-(t:Tag)
RETURN DISTINCT t.tag_id AS tagId, t.tag_name AS tagName, t.count AS globalQuestionCount
ORDER BY globalQuestionCount DESC
LIMIT $limit;

MATCH (owner:User {user_id: $userId})<-[:Owned_by]-(q:Post_question)<-[:Answers_to]-(a:Post_answer)-[:Answers_by]->(answerer:User)
WHERE answerer.user_id <> owner.user_id
RETURN DISTINCT answerer.user_id AS answererId, answerer.display_name AS answererName
ORDER BY answererId
LIMIT $limit;

MATCH (owner:User {user_id: $userId})<-[:Owned_by]-(q:Post_question)<-[:Answers_to]-(a:Post_answer)-[:Answers_by]->(answerer:User)
WHERE answerer.user_id <> owner.user_id
RETURN DISTINCT answerer.user_id AS answererId, answerer.display_name AS answererName
ORDER BY answererId
LIMIT $limit;

MATCH (u:User {user_id: $userId})<-[:Answers_by]-(a:Post_answer)
WHERE a.score >= $minScore
RETURN a.post_id AS answerId, a.score AS score, a.creation_date AS creationDate
ORDER BY score DESC, answerId
LIMIT $limit;

MATCH (u:User {user_id: $userId})<-[:Answers_by]-(a:Post_answer)
WHERE a.score >= $minScore
RETURN a.post_id AS answerId, a.score AS score, a.creation_date AS creationDate
ORDER BY score DESC, answerId
LIMIT $limit;

MATCH (q:Post_question)
WHERE (q.accepted_answer_id IS NULL
    OR q.accepted_answer_id = ''
    OR q.accepted_answer_id = '0'
    OR q.accepted_answer_id = 'None')
RETURN q.id                                  AS question_id,
       toInteger(q.view_count)                AS view_count,
       toInteger(q.answer_count)              AS answer_count
ORDER BY toInteger(q.view_count) DESC
LIMIT 200;

MATCH (q:Post_question)
WHERE (q.accepted_answer_id IS NULL
    OR q.accepted_answer_id = ''
    OR q.accepted_answer_id = '0'
    OR q.accepted_answer_id = 'None')
RETURN q.id AS question_id,
    toInteger(q.view_count) AS view_count,
    toInteger(q.answer_count) AS answer_count
ORDER BY toInteger(q.view_count) DESC
LIMIT 200;

MATCH (v:Vote)-[:Vote_on]->(p)
WHERE v.vote_type_id = $voteTypeId
RETURN v.vote_id AS voteId, labels(p) AS postLabels,
       coalesce(p.post_id, p.comment_id) AS targetId,
       v.creation_date AS voteDate
ORDER BY voteDate DESC
LIMIT $limit;

MATCH (v:Vote)-[:Vote_on]->(p)
WHERE v.vote_type_id = $voteTypeId
RETURN v.vote_id AS voteId, labels(p) AS postLabels,
       coalesce(p.post_id, p.comment_id) AS targetId,
       v.creation_date AS voteDate
ORDER BY voteDate DESC
LIMIT $limit;

MATCH p = (:Post_question {post_id: $sourceQuestionId})-[:Link_to*1..4]->(:Post_question {post_id: $targetQuestionId})
RETURN count(p) > 0 AS reachable
LIMIT 1;

MATCH p = ANY (:Post_question {post_id: $sourceQuestionId})-[:Link_to]->{1,4}(:Post_question {post_id: $targetQuestionId})
RETURN true AS reachable;

MATCH p = shortestPath((src:Post_question {post_id: $sourceQuestionId})-[:Link_to*1..6]->(dst:Post_question {post_id: $targetQuestionId}))
RETURN [n IN nodes(p) | n.post_id] AS questionPath, length(p) AS hopCount;

MATCH p = SHORTEST (:Post_question {post_id: $sourceQuestionId})-[:Link_to]->{1,6}(:Post_question {post_id: $targetQuestionId})
RETURN p;

MATCH p = (src:Post_question {post_id: $sourceQuestionId})-[:Link_to*1..3]->(dst:Post_question {post_id: $targetQuestionId})
WHERE all(n IN nodes(p) WHERE single(m IN nodes(p) WHERE m = n))
RETURN [n IN nodes(p) | n.post_id] AS questionPath, length(p) AS hopCount
ORDER BY hopCount
LIMIT $limit;

MATCH p = ACYCLIC (:Post_question {post_id: $sourceQuestionId})-[:Link_to]->{1,3}(:Post_question {post_id: $targetQuestionId})
RETURN p
LIMIT $limit;

MATCH p = (src:Post_question {post_id: $sourceQuestionId})-[:Link_to*1..3]->(dst:Post_question {post_id: $targetQuestionId})
WHERE all(n IN nodes(p) WHERE single(m IN nodes(p) WHERE m = n))
WITH p, reduce(pathScore = 0, n IN nodes(p) | pathScore + coalesce(n.score, 0)) AS totalScore
RETURN [n IN nodes(p) | n.post_id] AS questionPath, length(p) AS hopCount, totalScore
ORDER BY totalScore DESC, hopCount ASC
LIMIT $limit;

MATCH p = ACYCLIC (:Post_question {post_id: $sourceQuestionId})-[:Link_to]->{1,3}(:Post_question {post_id: $targetQuestionId})
RETURN p
ORDER BY length(p) ASC
LIMIT $limit;

MATCH (q1:Post_question)-[:Link_to]->(q2:Post_question)-[:Link_to]->(q3:Post_question)-[:Link_to]->(q1)
WHERE q1.post_id < q2.post_id AND q2.post_id < q3.post_id
RETURN q1.post_id AS question1, q2.post_id AS question2, q3.post_id AS question3
LIMIT $limit;

MATCH (q1:Post_question)-[:Link_to]->(q2:Post_question)-[:Link_to]->(q3:Post_question)-[:Link_to]->(q1)
WHERE q1.post_id < q2.post_id AND q2.post_id < q3.post_id
RETURN q1.post_id AS question1, q2.post_id AS question2, q3.post_id AS question3
LIMIT $limit;

MATCH (q1:Post_question)-[:Link_to]->(q2:Post_question)-[:Link_to]->(q3:Post_question)-[:Link_to]->(q4:Post_question)-[:Link_to]->(q1)
WHERE q1.post_id < q2.post_id AND q1.post_id < q3.post_id AND q1.post_id < q4.post_id
  AND q2 <> q4
RETURN q1.post_id AS question1, q2.post_id AS question2, q3.post_id AS question3, q4.post_id AS question4
LIMIT $limit;

MATCH (q1:Post_question)-[:Link_to]->(q2:Post_question)-[:Link_to]->(q3:Post_question)-[:Link_to]->(q4:Post_question)-[:Link_to]->(q1)
WHERE q1.post_id < q2.post_id AND q1.post_id < q3.post_id AND q1.post_id < q4.post_id
  AND q2 <> q4
RETURN q1.post_id AS question1, q2.post_id AS question2, q3.post_id AS question3, q4.post_id AS question4
LIMIT $limit;

MATCH (q1:Post_question)-[:Link_to]-(q2:Post_question),
      (q1)-[:Link_to]-(q3:Post_question),
      (q1)-[:Link_to]-(q4:Post_question),
      (q2)-[:Link_to]-(q3),
      (q2)-[:Link_to]-(q4),
      (q3)-[:Link_to]-(q4)
WHERE q1.post_id < q2.post_id AND q2.post_id < q3.post_id AND q3.post_id < q4.post_id
RETURN q1.post_id AS question1, q2.post_id AS question2, q3.post_id AS question3, q4.post_id AS question4
LIMIT $limit;

MATCH (q1:Post_question)-[:Link_to]-(q2:Post_question),
      (q1)-[:Link_to]-(q3:Post_question),
      (q1)-[:Link_to]-(q4:Post_question),
      (q2)-[:Link_to]-(q3),
      (q2)-[:Link_to]-(q4),
      (q3)-[:Link_to]-(q4)
WHERE q1.post_id < q2.post_id AND q2.post_id < q3.post_id AND q3.post_id < q4.post_id
RETURN q1.post_id AS question1, q2.post_id AS question2, q3.post_id AS question3, q4.post_id AS question4
LIMIT $limit;

MATCH (questioner:User)<-[:Owned_by]-(q:Post_question)<-[:Answers_to]-(a:Post_answer)<-[:On_answer]-(c:Comment)-[:Commented_by]->(commenter:User)
WHERE questioner.user_id <> commenter.user_id
RETURN questioner.user_id AS questionerId, q.post_id AS questionId, a.post_id AS answerId,
       c.comment_id AS commentId, commenter.user_id AS commenterId
LIMIT $limit;

MATCH (questioner:User)<-[:Owned_by]-(q:Post_question)<-[:Answers_to]-(a:Post_answer)<-[:On_answer]-(c:Comment)-[:Commented_by]->(commenter:User)
WHERE questioner.user_id <> commenter.user_id
RETURN questioner.user_id AS questionerId, q.post_id AS questionId, a.post_id AS answerId,
       c.comment_id AS commentId, commenter.user_id AS commenterId
LIMIT $limit;

MATCH (q:Post_question)
OPTIONAL MATCH (q)<-[:Answers_to]-(a:Post_answer)
WITH q, count(DISTINCT a) AS answerDegree
RETURN count(q) AS questionCount,
       avg(answerDegree) AS avgAnswerDegree,
       min(answerDegree) AS minAnswerDegree,
       max(answerDegree) AS maxAnswerDegree;

MATCH (q:Post_question)
OPTIONAL MATCH (q)<-[:Answers_to]-(a:Post_answer)
WITH q, count(DISTINCT a) AS answerDegree
RETURN count(q) AS questionCount,
       avg(answerDegree) AS avgAnswerDegree,
       min(answerDegree) AS minAnswerDegree,
       max(answerDegree) AS maxAnswerDegree;

MATCH (src:Post_question)-[:Link_to]->(target:Post_question)
WITH target.id   AS question_id,
     COUNT(src)  AS link_count
WHERE link_count > 0
RETURN question_id, link_count
ORDER BY link_count DESC
LIMIT 20;

MATCH (src:Post_question)-[:Link_to]->(target:Post_question)
WITH target.id AS question_id,
     count(src) AS link_count
WHERE link_count > 0
RETURN question_id, link_count
ORDER BY link_count DESC
LIMIT 20;

MATCH (c:Comment)-[:Commented_by]->(u:User)
WITH u.id AS user_id,
     u.display_name AS display_name,
     COUNT(c) AS total_comments
WHERE total_comments > 0
RETURN user_id, display_name, total_comments
ORDER BY total_comments DESC
LIMIT 20;

MATCH (c:Comment)-[:Commented_by]->(u:User)
WITH u.id AS user_id,
     u.display_name AS display_name,
     count(c) AS total_comments
WHERE total_comments > 0
RETURN user_id, display_name, total_comments
ORDER BY total_comments DESC
LIMIT 20;

MATCH (t:Tag)-[:Tag_to]->(q:Post_question)
OPTIONAL MATCH (q)<-[:Answers_to]-(a:Post_answer)
RETURN t.tag_name AS tagName,
       count(DISTINCT q) AS questionCount,
       count(a) AS answerCount,
       avg(coalesce(q.score, 0)) AS avgQuestionScore
ORDER BY questionCount DESC
LIMIT $limit;

MATCH (t:Tag)-[:Tag_to]->(q:Post_question)
OPTIONAL MATCH (q)<-[:Answers_to]-(a:Post_answer)
RETURN t.tag_name AS tagName,
       count(DISTINCT q) AS questionCount,
       count(a) AS answerCount,
       avg(coalesce(q.score, 0)) AS avgQuestionScore
ORDER BY questionCount DESC
LIMIT $limit;

MATCH (v:Vote)-[:Vote_on]->(target)
UNWIND labels(target) AS targetLabel
RETURN v.vote_type_id AS voteTypeId,
       targetLabel,
       count(v) AS voteCount,
       min(v.creation_date) AS firstVoteDate,
       max(v.creation_date) AS lastVoteDate
ORDER BY voteCount DESC
LIMIT $limit;

MATCH (v:Vote)-[:Vote_on]->(target)
UNWIND labels(target) AS targetLabel
RETURN v.vote_type_id AS voteTypeId,
       targetLabel,
       count(v) AS voteCount,
       min(v.creation_date) AS firstVoteDate,
       max(v.creation_date) AS lastVoteDate
ORDER BY voteCount DESC
LIMIT $limit;

MATCH p = (:Post_question {post_id: $questionId})-[:Link_to*1..3]->(target:Post_question)
RETURN length(p) AS pathLength,
       count(p) AS pathCount,
       count(DISTINCT target) AS distinctTargetCount
ORDER BY pathLength;

MATCH p = (:Post_question {post_id: $questionId})-[:Link_to]->{1,3}(target:Post_question)
RETURN length(p) AS pathLength,
       count(p) AS pathCount,
       count(DISTINCT target) AS distinctTargetCount
ORDER BY pathLength;

MATCH p = (:Post_question {post_id: $questionId})-[:Link_to*1..3]->(target:Post_question)
WITH length(p) AS pathLength,
     CASE
       WHEN coalesce(target.answer_count, 0) = 0 THEN 'unanswered'
       WHEN coalesce(target.answer_count, 0) = 1 THEN 'single-answer'
       ELSE 'multi-answer'
     END AS answerBucket,
     p,
     target
RETURN pathLength, answerBucket, count(p) AS pathCount, count(DISTINCT target) AS endpointCount
ORDER BY pathLength, pathCount DESC;

MATCH p = (:Post_question {post_id: $questionId})-[:Link_to]->{1,3}(target:Post_question)
WITH length(p) AS pathLength,
     CASE
       WHEN coalesce(target.answer_count, 0) = 0 THEN 'unanswered'
       WHEN coalesce(target.answer_count, 0) = 1 THEN 'single-answer'
       ELSE 'multi-answer'
     END AS answerBucket,
     p,
     target
RETURN pathLength, answerBucket, count(p) AS pathCount, count(DISTINCT target) AS endpointCount
ORDER BY pathLength, pathCount DESC;

MATCH (q:Post_question)
OPTIONAL MATCH (q)-[:Link_to]-(neighbor:Post_question)
RETURN q.post_id AS questionId,
       q.title AS title,
       count(DISTINCT neighbor) AS linkDegree
ORDER BY linkDegree DESC
LIMIT $limit;

MATCH (q:Post_question)
OPTIONAL MATCH (q)-[:Link_to]-(neighbor:Post_question)
RETURN q.post_id AS questionId,
       q.title AS title,
       count(DISTINCT neighbor) AS linkDegree
ORDER BY linkDegree DESC
LIMIT $limit;

CALL gds.graph.project(
  'StackOverflowQuestionLinksPageRank',
  'Post_question',
  {Link_to: {type: 'Link_to', orientation: 'NATURAL'}}
);

CALL gds.pageRank.stream('StackOverflowQuestionLinksPageRank')
YIELD nodeId, score
RETURN gds.util.asNode(nodeId).post_id AS questionId,
       gds.util.asNode(nodeId).title AS title,
       score
ORDER BY score DESC
LIMIT $limit;

CALL gds.graph.project(
  'StackOverflowQuestionLinksWcc',
  'Post_question',
  {Link_to: {type: 'Link_to', orientation: 'UNDIRECTED'}}
);

CALL gds.wcc.stream('StackOverflowQuestionLinksWcc')
YIELD nodeId, componentId
RETURN componentId, count(*) AS componentSize
ORDER BY componentSize DESC
LIMIT $limit;

CALL gds.graph.project(
  'StackOverflowQuestionLinksScc',
  'Post_question',
  {Link_to: {type: 'Link_to', orientation: 'NATURAL'}}
);

CALL gds.scc.stream('StackOverflowQuestionLinksScc')
YIELD nodeId, componentId
RETURN componentId, count(*) AS componentSize
ORDER BY componentSize DESC
LIMIT $limit;

CALL gds.graph.project(
  'StackOverflowQuestionLinksLouvain',
  'Post_question',
  {Link_to: {type: 'Link_to', orientation: 'UNDIRECTED'}}
);

CALL gds.louvain.stream('StackOverflowQuestionLinksLouvain')
YIELD nodeId, communityId
RETURN communityId, count(*) AS communitySize
ORDER BY communitySize DESC
LIMIT $limit;

MATCH (u:User)
OPTIONAL MATCH (q:Post_question)-[:Owned_by]->(u)
OPTIONAL MATCH (vq:Vote)-[:Vote_on_question]->(q)
WITH u, COUNT(vq) AS q_votes
OPTIONAL MATCH (a:Post_answer)-[:Answers_by]->(u)
OPTIONAL MATCH (va:Vote)-[:Vote_on_answer]->(a)
WITH u.id AS user_id,
     u.display_name AS display_name,
     q_votes + COUNT(va) AS total_votes
WHERE total_votes > 0
RETURN user_id, display_name, total_votes
ORDER BY total_votes DESC
LIMIT 20;

MATCH (u:User)
OPTIONAL MATCH (q:Post_question)-[:Owned_by]->(u)
OPTIONAL MATCH (vq:Vote)-[:Vote_on_question]->(q)
WITH u, count(vq) AS q_votes
OPTIONAL MATCH (a:Post_answer)-[:Answers_by]->(u)
OPTIONAL MATCH (va:Vote)-[:Vote_on_answer]->(a)
WITH u.id AS user_id,
     u.display_name AS display_name,
     q_votes + count(va) AS total_votes
WHERE total_votes > 0
RETURN user_id, display_name, total_votes
ORDER BY total_votes DESC
LIMIT 20;

MATCH (q:Post_question)-[:Accepts]->(a:Post_answer)-[:Answers_by]->(u:User)
WITH u.id AS user_id,
     u.display_name AS display_name,
     COUNT(a) AS accepted_count
WHERE accepted_count > 0
RETURN user_id, display_name, accepted_count
ORDER BY accepted_count DESC
LIMIT 20;

MATCH (q:Post_question)-[:Accepts]->(a:Post_answer)-[:Answers_by]->(u:User)
WITH u.id AS user_id,
     u.display_name AS display_name,
     count(a) AS accepted_count
WHERE accepted_count > 0
RETURN user_id, display_name, accepted_count
ORDER BY accepted_count DESC
LIMIT 20;

MATCH (a:Post_answer)-[:Answers_to]->(q:Post_question)
MATCH (a)-[:Answers_by]->(answerer:User)
MATCH (q)-[:Owned_by]->(questioner:User)
WHERE answerer.id <> questioner.id
WITH (answerer.id + ':' + questioner.id) AS pair_key,
    COUNT(*) AS interaction_count
WHERE interaction_count >= 5
RETURN pair_key, interaction_count
ORDER BY interaction_count DESC
LIMIT 100;

MATCH (a:Post_answer)-[:Answers_to]->(q:Post_question)
MATCH (a)-[:Answers_by]->(answerer:User)
MATCH (q)-[:Owned_by]->(questioner:User)
WHERE answerer.id <> questioner.id
WITH (answerer.id + ':' + questioner.id) AS pair_key,
    count(*) AS interaction_count
WHERE interaction_count >= 5
RETURN pair_key, interaction_count
ORDER BY interaction_count DESC
LIMIT 100;

MATCH (t:Tag)-[:Tag_to]->(q:Post_question)
WITH t, COUNT(q) AS question_count
MATCH (t)-[:Tag_to]->(q2:Post_question)<-[:Answers_to]-(a:Post_answer)
WITH t.tag_name AS tag_name,
    question_count,
    COUNT(a) AS answer_count
WHERE answer_count > 0
RETURN tag_name,
    question_count,
    answer_count,
    toFloat(question_count) / toFloat(answer_count) AS ratio
ORDER BY ratio DESC
LIMIT 200;

MATCH (t:Tag)-[:Tag_to]->(q:Post_question)
WITH t, count(q) AS question_count
MATCH (t)-[:Tag_to]->(q2:Post_question)<-[:Answers_to]-(a:Post_answer)
WITH t.tag_name AS tag_name,
    question_count,
    count(a) AS answer_count
WHERE answer_count > 0
RETURN tag_name,
    question_count,
    answer_count,
    toFloat(question_count) / toFloat(answer_count) AS ratio
ORDER BY ratio DESC
LIMIT 200;

MATCH (u:User)-[:Earns]->(b:Badge)
WHERE u.creation_date IS NOT NULL
    AND b.date IS NOT NULL
    AND u.creation_date <> ''
    AND b.date <> ''
WITH u.id AS user_id,
     u.display_name  AS display_name,
     u.creation_date AS creation_date,
     MIN(
        (toInteger(substring(b.date, 0, 4)) - toInteger(substring(u.creation_date, 0, 4))) * 365 +
        (toInteger(substring(b.date, 5, 2)) - toInteger(substring(u.creation_date, 5, 2))) * 30  +
        (toInteger(substring(b.date, 8, 2)) - toInteger(substring(u.creation_date, 8, 2)))
     ) AS min_days
WHERE min_days >= 0
RETURN user_id, display_name, min_days
ORDER BY min_days ASC, user_id ASC
LIMIT 20;

MATCH (u:User)-[:Earns]->(b:Badge)
WHERE u.creation_date IS NOT NULL
    AND b.date IS NOT NULL
    AND u.creation_date <> ''
    AND b.date <> ''
WITH u.id AS user_id,
     u.display_name AS display_name,
     u.creation_date AS creation_date,
     min(
        (toInteger(substring(b.date, 0, 4)) - toInteger(substring(u.creation_date, 0, 4))) * 365 +
        (toInteger(substring(b.date, 5, 2)) - toInteger(substring(u.creation_date, 5, 2))) * 30 +
        (toInteger(substring(b.date, 8, 2)) - toInteger(substring(u.creation_date, 8, 2)))
     ) AS min_days
WHERE min_days >= 0
RETURN user_id, display_name, min_days
ORDER BY min_days ASC, user_id ASC
LIMIT 20;

MATCH (q:Post_question)
WHERE q.creation_date IS NOT NULL
AND q.creation_date <> ''
WITH substring(q.creation_date, 0, 4) AS year_val,
     COUNT(q) AS total_questions,
     SUM(CASE WHEN toInteger(q.answer_count) > 0 THEN 1 ELSE 0 END) AS answered_questions
RETURN year_val,
       total_questions,
       answered_questions,
round(toFloat(answered_questions) * 100.0 / toFloat(total_questions), 5) AS answer_rate
ORDER BY year_val ASC;

MATCH (q:Post_question)
WHERE q.creation_date IS NOT NULL
    AND q.creation_date <> ''
WITH substring(q.creation_date, 0, 4) AS year_val,
     count(q) AS total_questions,
     sum(CASE WHEN toInteger(q.answer_count) > 0 THEN 1 ELSE 0 END) AS answered_questions
RETURN year_val,
    total_questions,
    answered_questions,
    round(toFloat(answered_questions) * 100.0 / toFloat(total_questions), 5) AS answer_rate
ORDER BY year_val ASC;

MATCH (u:User)-[:Earns]->(b:Badge)
WHERE b.class = '1'
AND u.creation_date IS NOT NULL
AND b.date IS NOT NULL
AND u.creation_date <> ''
AND b.date <> ''
WITH b.name AS badge_name,
     COUNT(DISTINCT u.id) AS total_earners,
     MIN(
        (toInteger(substring(b.date, 0, 4)) - toInteger(substring(u.creation_date, 0, 4))) * 365 +
        (toInteger(substring(b.date, 5, 2)) - toInteger(substring(u.creation_date, 5, 2))) * 30  +
        (toInteger(substring(b.date, 8, 2)) - toInteger(substring(u.creation_date, 8, 2)))
     ) AS min_days
WHERE min_days >= 0
RETURN badge_name, total_earners, min_days
ORDER BY total_earners DESC
LIMIT 10;

MATCH (u:User)-[:Earns]->(b:Badge)
WHERE b.class = '1'
    AND u.creation_date IS NOT NULL
    AND b.date IS NOT NULL
    AND u.creation_date <> ''
    AND b.date <> ''
WITH b.name AS badge_name,
     count(DISTINCT u.id) AS total_earners,
     min(
        (toInteger(substring(b.date, 0, 4)) - toInteger(substring(u.creation_date, 0, 4))) * 365 +
        (toInteger(substring(b.date, 5, 2)) - toInteger(substring(u.creation_date, 5, 2))) * 30 +
        (toInteger(substring(b.date, 8, 2)) - toInteger(substring(u.creation_date, 8, 2)))
     ) AS min_days
WHERE min_days >= 0
RETURN badge_name, total_earners, min_days
ORDER BY total_earners DESC
LIMIT 10;