Homec4science
Diffusion SIG-1_Exercices_SQL (master) Browse

R11932/6-Requetes_spatiales_geometriques/SQL_requetes_geometriques.py
9ad571f7ed44master

Last Change
Raw File

SQL_requetes_geometriques.py
View Options

import sqlite3
import pandas
import hashlib
import pickle
from pandas._testing import assert_frame_equal
"""
Utility functions
"""
def run_query(q):
con = sqlite3.connect("india.sqlite")
con.enable_load_extension(True)
con.load_extension("mod_spatialite")
return pandas.read_sql_query(q, con)
def generate_hash(dataframe):
return hashlib.md5(pickle.dumps(dataframe)).hexdigest()
def check_hash(dataframe, dataframehash):
return generate_hash(dataframe) == dataframehash
"""
Validation function for Question 1
=> We compare with the possible mistakes made by students
=> Then we finally compare with the correct answer
# Possible mistakes: we check that the result obtained by the student is different from:
# * the union of 2001 and 2003
"""
def question1_validation(studentquery):
# Misconception: use of UNION
#query = "select name from migration where departureyear=2001 union select name from migration where departureyear=2003"
#if run_query(studentquery).equals(run_query(query)):
# print('You selected the storks who departed in 2001 AS WELL AS the storks who departed in 2003.'
# +'\nYou should get only the storks who departed BOTH in 2001 and in 2003.'
# +'\nHave you drawn a diagram on paper to determine which logical operator to use?')
# Default case that catches all misconceptions (including the mistakes flagged above)
# => we compare with the correct answer
try:
# Compare with the MD5 hash of the result table, which means the student can neither know the correct query nor the correct result table
# (this also means that the error message cannot help students correct their answer)
# NB: the hash of the correct result table has to be generated beforehand (using the utility function)
# generate_hash(run_query(correctquery))
response_hash = 'e9615a5915bb7d1b32f4028c5e4cd977'
assert check_hash(run_query(studentquery), response_hash), "Incorrect query."
except AssertionError as ae:
print("Your query didn't pass the validation tests.")
# We raise the exception here to stop execution and prevent the success message to be printed
raise ae
print("Your query has passed the validation tests and is evaluated as correct, well done!")
"""
Validation function for Question 2
=> We compare with the possible mistakes made by students
=> Then we finally compare with the correct answer
# Possible mistakes: we check that the result obtained by the student is different from:
# * the union of 2001 and 2003
"""
def question2_validation(studentquery):
# Misconception: use of UNION
#query = "select name from migration where departureyear=2001 union select name from migration where departureyear=2003"
#if run_query(studentquery).equals(run_query(query)):
# print('You selected the storks who departed in 2001 AS WELL AS the storks who departed in 2003.'
# +'\nYou should get only the storks who departed BOTH in 2001 and in 2003.'
# +'\nHave you drawn a diagram on paper to determine which logical operator to use?')
# Default case that catches all misconceptions (including the mistakes flagged above)
# => we compare with the correct answer
try:
# Compare with the MD5 hash of the result table, which means the student can neither know the correct query nor the correct result table
# (this also means that the error message cannot help students correct their answer)
# NB: the hash of the correct result table has to be generated beforehand (using the utility function)
# generate_hash(run_query(correctquery))
response_hash = 'db93725980882289f5860ab67d8e834f'
assert check_hash(run_query(studentquery), response_hash), "Incorrect query."
except AssertionError as ae:
print("Your query didn't pass the validation tests.")
# We raise the exception here to stop execution and prevent the success message to be printed
raise ae
print("Your query has passed the validation tests and is evaluated as correct, well done!")
"""
Validation function for Question 3
=> We compare with the possible mistakes made by students
=> Then we finally compare with the correct answer
# Possible mistakes: we check that the result obtained by the student is different from:
# * the union of 2001 and 2003
"""
def question3_validation(studentquery):
# Misconception: use of UNION
#query = "select name from migration where departureyear=2001 union select name from migration where departureyear=2003"
#if run_query(studentquery).equals(run_query(query)):
# print('You selected the storks who departed in 2001 AS WELL AS the storks who departed in 2003.'
# +'\nYou should get only the storks who departed BOTH in 2001 and in 2003.'
# +'\nHave you drawn a diagram on paper to determine which logical operator to use?')
# Default case that catches all misconceptions (including the mistakes flagged above)
# => we compare with the correct answer
try:
# Compare with the MD5 hash of the result table, which means the student can neither know the correct query nor the correct result table
# (this also means that the error message cannot help students correct their answer)
# NB: the hash of the correct result table has to be generated beforehand (using the utility function)
# generate_hash(run_query(correctquery))
response_hash = 'ec83fa5ea746982b4527ef311471e862'
assert check_hash(run_query(studentquery), response_hash), "Incorrect query."
except AssertionError as ae:
print("Your query didn't pass the validation tests.")
# We raise the exception here to stop execution and prevent the success message to be printed
raise ae
print("Your query has passed the validation tests and is evaluated as correct, well done!")
"""
Validation function for Question 4
=> We compare with the possible mistakes made by students
=> Then we finally compare with the correct answer
# Possible mistakes: we check that the result obtained by the student is different from:
# * the union of 2001 and 2003
"""
def question4_validation(studentquery):
# Misconception: use of UNION
#query = "select name from migration where departureyear=2001 union select name from migration where departureyear=2003"
#if run_query(studentquery).equals(run_query(query)):
# print('You selected the storks who departed in 2001 AS WELL AS the storks who departed in 2003.'
# +'\nYou should get only the storks who departed BOTH in 2001 and in 2003.'
# +'\nHave you drawn a diagram on paper to determine which logical operator to use?')
# Default case that catches all misconceptions (including the mistakes flagged above)
# => we compare with the correct answer
try:
# Compare with the MD5 hash of the result table, which means the student can neither know the correct query nor the correct result table
# (this also means that the error message cannot help students correct their answer)
# NB: the hash of the correct result table has to be generated beforehand (using the utility function)
# generate_hash(run_query(correctquery))
response_hash = '78b62222924bd032a5336a349e1db8a6'
assert check_hash(run_query(studentquery), response_hash), "Incorrect query."
except AssertionError as ae:
print("Your query didn't pass the validation tests.")
# We raise the exception here to stop execution and prevent the success message to be printed
raise ae
print("Your query has passed the validation tests and is evaluated as correct, well done!")
"""
Validation function for Question 5
=> We compare with the possible mistakes made by students
=> Then we finally compare with the correct answer
# Possible mistakes: we check that the result obtained by the student is different from:
# * the union of 2001 and 2003
"""
def question5_validation(studentquery):
# Misconception: use of UNION
#query = "select name from migration where departureyear=2001 union select name from migration where departureyear=2003"
#if run_query(studentquery).equals(run_query(query)):
# print('You selected the storks who departed in 2001 AS WELL AS the storks who departed in 2003.'
# +'\nYou should get only the storks who departed BOTH in 2001 and in 2003.'
# +'\nHave you drawn a diagram on paper to determine which logical operator to use?')
# Default case that catches all misconceptions (including the mistakes flagged above)
# => we compare with the correct answer
try:
# Compare with the MD5 hash of the result table, which means the student can neither know the correct query nor the correct result table
# (this also means that the error message cannot help students correct their answer)
# NB: the hash of the correct result table has to be generated beforehand (using the utility function)
# generate_hash(run_query(correctquery))
response_hash = '265f265a18c2cb6bfd9c1c81c1dac805'
assert check_hash(run_query(studentquery), response_hash), "Incorrect query."
except AssertionError as ae:
print("Your query didn't pass the validation tests.")
# We raise the exception here to stop execution and prevent the success message to be printed
raise ae
print("Your query has passed the validation tests and is evaluated as correct, well done!")
"""
Validation function for Question 6
=> We compare with the possible mistakes made by students
=> Then we finally compare with the correct answer
# Possible mistakes: we check that the result obtained by the student is different from:
# * the union of 2001 and 2003
"""
def question6_validation(studentquery):
# Misconception: use of UNION
#query = "select name from migration where departureyear=2001 union select name from migration where departureyear=2003"
#if run_query(studentquery).equals(run_query(query)):
# print('You selected the storks who departed in 2001 AS WELL AS the storks who departed in 2003.'
# +'\nYou should get only the storks who departed BOTH in 2001 and in 2003.'
# +'\nHave you drawn a diagram on paper to determine which logical operator to use?')
# Default case that catches all misconceptions (including the mistakes flagged above)
# => we compare with the correct answer
try:
# Compare with the MD5 hash of the result table, which means the student can neither know the correct query nor the correct result table
# (this also means that the error message cannot help students correct their answer)
# NB: the hash of the correct result table has to be generated beforehand (using the utility function)
# generate_hash(run_query(correctquery))
response_hash = '63a6dc8c30c7e8213f63b240ef9b49b2'
assert check_hash(run_query(studentquery), response_hash), "Incorrect query."
except AssertionError as ae:
print("Your query didn't pass the validation tests.")
# We raise the exception here to stop execution and prevent the success message to be printed
raise ae
print("Your query has passed the validation tests and is evaluated as correct, well done!")
"""
Validation function for Question 7
=> We compare with the possible mistakes made by students
=> Then we finally compare with the correct answer
# Possible mistakes: we check that the result obtained by the student is different from:
# * the union of 2001 and 2003
"""
def question7_validation(studentquery):
# Misconception: use of UNION
#query = "select name from migration where departureyear=2001 union select name from migration where departureyear=2003"
#if run_query(studentquery).equals(run_query(query)):
# print('You selected the storks who departed in 2001 AS WELL AS the storks who departed in 2003.'
# +'\nYou should get only the storks who departed BOTH in 2001 and in 2003.'
# +'\nHave you drawn a diagram on paper to determine which logical operator to use?')
# Default case that catches all misconceptions (including the mistakes flagged above)
# => we compare with the correct answer
try:
# Compare with the MD5 hash of the result table, which means the student can neither know the correct query nor the correct result table
# (this also means that the error message cannot help students correct their answer)
# NB: the hash of the correct result table has to be generated beforehand (using the utility function)
# generate_hash(run_query(correctquery))
response_hash = '1fabe794369f17e66458156b5f71e12b'
assert check_hash(run_query(studentquery), response_hash), "Incorrect query."
except AssertionError as ae:
print("Your query didn't pass the validation tests.")
# We raise the exception here to stop execution and prevent the success message to be printed
raise ae
print("Your query has passed the validation tests and is evaluated as correct, well done!")
c4science · Help