SQLalchemy .filter 无法按预期工作

Question

I have the following query:

        question = Questions.query\
        .filter(Questions.quiz_id == quiz.id) \
        .filter(Responses.session_id == session[0].id) \
        .filter(Responses.question_id != Questions.id) \
        .order_by(Questions.category) \
        .order_by(func.rand()) \
        .first()

What it does is this:

1. Get a question from a DB
2. Make sure the question is from the correct quiz
3. Check which already answered questions are linked to this session in the responses table
4. Make sure the next question is still unanswered (eg. the question ID is not yet in the responses table with the associated session_id linked to it)
5. Order it by category (1 to 5)
6. Pick a random question from the first category in the list

This all works fine only when there is already an answer in the responses table. However, when this is the first question to be answered, it returns None. I suspect this is because it can't find the session_id in the responses table. So this line is probably the cause:

.filter(Responses.session_id == session[0].id) \

Unfortunately, I have no clue about the solution here. It's not in the ordering, because when I just comment out those lines, it produces the same result. Secondary, when I produce the raw MySQL query, it works by joining the two tables on question_id == question.id and session_id == session.id . So in MySQL, this problem does not occur. This strengthens my believe the problem is in the .filter option.

The workaround in place right now is first checking whether there is a row in the responses table with the current session_id in it. If not, I know it's the first question and just leave out the .filter on session_id . This works but is an extra call which I assume is unnecessary.

Please help me out, thanks in advance.

Answer 1

Your analysis is correct, the problem is caused by the .filter() clause there. I'd rewrite the query to use a WHERE NOT EXISTS . This means that if there is no response matching the Question, it is still returned.

responses_this_session = Response.query\
    .filter(Responses.session_id == session[0].id)

question = Questions.query\
        .filter(Questions.quiz_id == quiz.id) \
        .filter(~exists(
            responses_this_session
            .filter(Responses.question_id == Questions.id)
        ))
        .order_by(Questions.category) \
        .order_by(func.rand()) \
        .first()

Or equivalently:

question = Questions.query\
        .filter(Questions.quiz_id == quiz.id) \
        .filter(
            ~exists().where(
                and_((Responses.session_id == session[0].id),
                     (Responses.question_id == Questions.id))
            )
        )
        .order_by(Questions.category) \
        .order_by(func.rand()) \
        .first()

The matching SQL:

SELECT questions.*
FROM questions
WHERE quiz_id = 12
AND NOT EXISTS(
  SELECT *
  FROM responses
  WHERE session_id = 'my_session_id'
    AND responses.question_id = questions.id
)
ORDER BY category, RAND()