Question data structures - Revision history

Mudrd8mz: Text replacement - "" to ""

2021-07-14T20:28:12Z

Text replacement - "</code>" to "</syntaxhighlight>"

← Older revision		Revision as of 20:28, 14 July 2021
Line 8:		Line 8:
	// or		// or
	$questiondata = question_load_questions(array($questionid)); // Defined in lib/questionlib.php		$questiondata = question_load_questions(array($questionid)); // Defined in lib/questionlib.php
	</~~code~~>		</syntaxhighlight>

	For a typical <tt>$qtype</tt>, the structure is something like what you would get by running		For a typical <tt>$qtype</tt>, the structure is something like what you would get by running
Line 20:		Line 20:
	$questiondata->hints = $DB->get_record('question_hints',		$questiondata->hints = $DB->get_record('question_hints',
	array('questionid', $questionid), 'id ASC');		array('questionid', $questionid), 'id ASC');
	</~~code~~>		</syntaxhighlight>

	Some oddities that are worth commenting on there:		Some oddities that are worth commenting on there:
Line 32:		Line 32:
	$questiondata->options->subquestions = $DB->get_records('question_match_sub',		$questiondata->options->subquestions = $DB->get_records('question_match_sub',
	array('question' => $question->id), 'id ASC');		array('question' => $question->id), 'id ASC');
	</~~code~~>		</syntaxhighlight>

	Another interesting example is <tt>qtype_numerical</tt>, which needs extra data for each answer, and so does:		Another interesting example is <tt>qtype_numerical</tt>, which needs extra data for each answer, and so does:
Line 43:		Line 43:
	WHERE qa.question = ?		WHERE qa.question = ?
	ORDER BY qa.id ASC", array($questionid))) {		ORDER BY qa.id ASC", array($questionid))) {
	</~~code~~>		</syntaxhighlight>

	(Again, you can see the age of these tables in several violations of the current coding guidelines.)		(Again, you can see the age of these tables in several violations of the current coding guidelines.)
Line 53:		Line 53:
	<syntaxhighlight lang="php">		<syntaxhighlight lang="php">
	question_bank::get_qtype($qtype)->save_question($fromform);		question_bank::get_qtype($qtype)->save_question($fromform);
	</~~code~~>		</syntaxhighlight>

	This data structure is also used by [[Question formats\|question import formats]]. They parse whatever import file they are processing, and generate this <tt>$fromform</tt> data structure, which it then passed to <tt>save_question</tt>.		This data structure is also used by [[Question formats\|question import formats]]. They parse whatever import file they are processing, and generate this <tt>$fromform</tt> data structure, which it then passed to <tt>save_question</tt>.
Line 70:		Line 70:
	<syntaxhighlight lang="php">		<syntaxhighlight lang="php">
	$question = $qtypeobj->save_question($question, $fromform);		$question = $qtypeobj->save_question($question, $fromform);
	</~~code~~>		</syntaxhighlight>

	Just before the line		Just before the line
Line 76:		Line 76:
	<syntaxhighlight lang="php">		<syntaxhighlight lang="php">
	if (!empty($CFG->usetags) && isset($fromform->tags)) {		if (!empty($CFG->usetags) && isset($fromform->tags)) {
	</~~code~~>		</syntaxhighlight>

	==Representation 3: <tt>question_definition $question</tt>==		==Representation 3: <tt>question_definition $question</tt>==
Line 84:		Line 84:
	<syntaxhighlight lang="php">		<syntaxhighlight lang="php">
	$question = question_bank::make_question($questiondata);		$question = question_bank::make_question($questiondata);
	</~~code~~>		</syntaxhighlight>

	This data structure is actually an instance of a proper class, <tt>question_definition</tt>, or more likely one of its subclasses depending on the question type. Therefore, there is extensive documentation of all the fields on the base class, which is defined in <tt>question/type/questionbase.php</tt>.		This data structure is actually an instance of a proper class, <tt>question_definition</tt>, or more likely one of its subclasses depending on the question type. Therefore, there is extensive documentation of all the fields on the base class, which is defined in <tt>question/type/questionbase.php</tt>.

Mudrd8mz: Text replacement - "`" to ""`


2021-07-14T13:34:24Z
Text replacement - "<code php>" to "<syntaxhighlight lang="php">"

				
				
				
				
				
				← Older revision
				Revision as of 13:34, 14 July 2021
				
Line 4:
Line 4:



This representation is designed to closely mirror the data in the database. This representation is used in most places in the question bank. You can get the question in this form by calling either This representation is designed to closely mirror the data in the database. This representation is used in most places in the question bank. You can get the question in this form by calling either
<code php> <syntaxhighlight lang="php">
$questiondata = question_bank::load_question($questionid); // Defined in question/engine/bank.php $questiondata = question_bank::load_question($questionid); // Defined in question/engine/bank.php
// or // or
Line 12:
Line 12:
For a typical <tt>$qtype</tt>, the structure is something like what you would get by running For a typical <tt>$qtype</tt>, the structure is something like what you would get by running



<code php> <syntaxhighlight lang="php">
$questiondata = $DB->get_record('question', array('id', $questionid)); $questiondata = $DB->get_record('question', array('id', $questionid));
$questiondata->options = $DB->get_record("qtype_{$qtype}_options", $questiondata->options = $DB->get_record("qtype_{$qtype}_options",
Line 29:
Line 29:
Not all question types are exactly like this. For example it is optional whether any question type chooses to use <tt>question_answers</tt> or <tt>question_hints</tt>. It depends on the question type whether they are useful. Other question types may have other data structures. For example <tt>qtype_match</tt> does not use answers. Instead it uses Not all question types are exactly like this. For example it is optional whether any question type chooses to use <tt>question_answers</tt> or <tt>question_hints</tt>. It depends on the question type whether they are useful. Other question types may have other data structures. For example <tt>qtype_match</tt> does not use answers. Instead it uses



<code php> <syntaxhighlight lang="php">
$questiondata->options->subquestions = $DB->get_records('question_match_sub', $questiondata->options->subquestions = $DB->get_records('question_match_sub',
                 array('question' => $question->id), 'id ASC');                    array('question' => $question->id), 'id ASC');  
Line 36:
Line 36:
Another interesting example is <tt>qtype_numerical</tt>, which needs extra data for each answer, and so does: Another interesting example is <tt>qtype_numerical</tt>, which needs extra data for each answer, and so does:



<code php> <syntaxhighlight lang="php">
$questiondata->options->answers = $DB->get_records_sql(" $questiondata->options->answers = $DB->get_records_sql("
         SELECT qa.*, qna.tolerance            SELECT qa.*, qna.tolerance  
Line 51:
Line 51:
This representation closely mirrors the structure of the question editing form for the question type. It is what you get back from calling <tt>$mform->get_data()</tt> on the question editing form for the relevant type. Typically this data gets passed to   This representation closely mirrors the structure of the question editing form for the question type. It is what you get back from calling <tt>$mform->get_data()</tt> on the question editing form for the relevant type. Typically this data gets passed to  



<code php> <syntaxhighlight lang="php">
question_bank::get_qtype($qtype)->save_question($fromform); question_bank::get_qtype($qtype)->save_question($fromform);
</code> </code>
Line 68:
Line 68:
If you want to see what this data structure is for a particular question type, edit question/question.php, and insert the debugging line If you want to see what this data structure is for a particular question type, edit question/question.php, and insert the debugging line



<code php> <syntaxhighlight lang="php">
$question = $qtypeobj->save_question($question, $fromform); $question = $qtypeobj->save_question($question, $fromform);
</code> </code>
Line 74:
Line 74:
Just before the line Just before the line



<code php> <syntaxhighlight lang="php">
if (!empty($CFG->usetags) && isset($fromform->tags)) { if (!empty($CFG->usetags) && isset($fromform->tags)) {
</code> </code>
Line 82:
Line 82:
Finally, there is the data structure used by the question engine, while questions are being attempted. You can get this structure by calling Finally, there is the data structure used by the question engine, while questions are being attempted. You can get this structure by calling



<code php> <syntaxhighlight lang="php">
$question = question_bank::make_question($questiondata); $question = question_bank::make_question($questiondata);
</code> </code>



TimHunt: /* Representation 1: $questiondata */
2018-01-08T17:10:27Z
Representation 1: $questiondata

				
				
				
				
				
				← Older revision
				Revision as of 17:10, 8 January 2018
				
Line 25:
Line 25:
* The columns should really be called <tt>question_answers.questionid</tt>, not <tt>question_answers.question</tt>, at least according to the coding guidelines as they are now, but this table has existed since Moodle 1.1 when the coding guidelines were different. This anomaly will probably be fixed one day. * The columns should really be called <tt>question_answers.questionid</tt>, not <tt>question_answers.question</tt>, at least according to the coding guidelines as they are now, but this table has existed since Moodle 1.1 when the coding guidelines were different. This anomaly will probably be fixed one day.
* It would probably be better if it was <tt>$questiondata->answers</tt> instead of <tt>$questiondata->options->answers</tt>. Again this is historic, which is why when I added <tt>$questiondata->hints</tt> I did it in an inconsistent way. It is not clear whether it is worth fixing this anomaly. * It would probably be better if it was <tt>$questiondata->answers</tt> instead of <tt>$questiondata->options->answers</tt>. Again this is historic, which is why when I added <tt>$questiondata->hints</tt> I did it in an inconsistent way. It is not clear whether it is worth fixing this anomaly.
* Note that, although I have used <tt>$questiondata</tt> as the name for this data structure, in many places in the code, the name <tt>$question</tt> is used instead. Again, this is historic. The intention is to move towards consistently calling variables that hold this data-structure <tt>$questiondata</tt> (or <tt>$qd</tt>). * Note that, although I have used <tt>$questiondata</tt> as the name for this data structure, in many places in the code, the name <tt>$question</tt> is used instead. Again, this is historic. The intention is to move towards consistently calling variables that hold this data-structure <tt>$questiondata</tt>.



Not all question types are exactly like this. For example it is optional whether any question type chooses to use <tt>question_answers</tt> or <tt>question_hints</tt>. It depends on the question type whether they are useful. Other question types may have other data structures. For example <tt>qtype_match</tt> does not use answers. Instead it uses Not all question types are exactly like this. For example it is optional whether any question type chooses to use <tt>question_answers</tt> or <tt>question_hints</tt>. It depends on the question type whether they are useful. Other question types may have other data structures. For example <tt>qtype_match</tt> does not use answers. Instead it uses



TimHunt at 17:07, 8 January 2018
2018-01-08T17:07:32Z


				
				
				
				
				
				← Older revision
				Revision as of 17:07, 8 January 2018
				
Line 103:
Line 103:






[[Category:Questions]] [[Category:Quiz]]



TimHunt: /* Representation 2: $fromform */
2012-11-23T11:11:48Z
Representation 2: $fromform

				
				
				
				
				
				← Older revision
				Revision as of 11:11, 23 November 2012
				
Line 66:
Line 66:
Once again, in the code, variables holding this data structure are often called <tt>$question</tt>. The plan is to gradually rename them all to <tt>$fromform</tt>. Once again, in the code, variables holding this data structure are often called <tt>$question</tt>. The plan is to gradually rename them all to <tt>$fromform</tt>.



If you want to see what this data structure is for a particular question type, edit question/question.php, and insert the debugging line

<code php>
$question = $qtypeobj->save_question($question, $fromform);
</code>

Just before the line

<code php>
if (!empty($CFG->usetags) && isset($fromform->tags)) {
</code>



==Representation 3: <tt>question_definition $question</tt>== ==Representation 3: <tt>question_definition $question</tt>==



TimHunt: /* Representation 1: $questiondata */
2012-02-16T12:25:56Z
Representation 1: $questiondata

				
				
				
				
				
				← Older revision
				Revision as of 12:25, 16 February 2012
				
Line 5:
Line 5:
This representation is designed to closely mirror the data in the database. This representation is used in most places in the question bank. You can get the question in this form by calling either This representation is designed to closely mirror the data in the database. This representation is used in most places in the question bank. You can get the question in this form by calling either
<code php> <code php>
questiondata = question_bank::load_question($questionid); // Defined in question/engine/bank.php $questiondata = question_bank::load_question($questionid); // Defined in question/engine/bank.php
// or // or
questiondata = question_load_questions(array($questionid)); // Defined in lib/questionlib.php $questiondata = question_load_questions(array($questionid)); // Defined in lib/questionlib.php
</code> </code>



Line 46:
Line 46:



(Again, you can see the age of these tables in several violations of the current coding guidelines.) (Again, you can see the age of these tables in several violations of the current coding guidelines.)




==Representation 2: <tt>$fromform</tt>== ==Representation 2: <tt>$fromform</tt>==



TimHunt: /* Summary of the data flows */
2012-02-05T22:16:00Z
Summary of the data flows

				
				
				
				
				
				← Older revision
				Revision as of 22:16, 5 February 2012
				
Line 85:
Line 85:
This diagram should help summarise the various representations of questions, and where they are used. This diagram should help summarise the various representations of questions, and where they are used.



[[Question_data_structures]] [[File:Question data structures.png]]
  



==See also== ==See also==



TimHunt: /* Representation 1: $questiondata */
2012-02-05T22:15:26Z
Representation 1: $questiondata

				
				
				
				
				
				← Older revision
				Revision as of 22:15, 5 February 2012
				
Line 8:
Line 8:
// or // or
questiondata = question_load_questions(array($questionid)); // Defined in lib/questionlib.php questiondata = question_load_questions(array($questionid)); // Defined in lib/questionlib.php
</code php> </code>



For a typical <tt>$qtype</tt>, the structure is something like what you would get by running For a typical <tt>$qtype</tt>, the structure is something like what you would get by running
Line 20:
Line 20:
$questiondata->hints = $DB->get_record('question_hints', $questiondata->hints = $DB->get_record('question_hints',
        array('questionid', $questionid), 'id ASC');         array('questionid', $questionid), 'id ASC');
</code php> </code>



Some oddities that are worth commenting on there: Some oddities that are worth commenting on there:
Line 32:
Line 32:
$questiondata->options->subquestions = $DB->get_records('question_match_sub', $questiondata->options->subquestions = $DB->get_records('question_match_sub',
                 array('question' => $question->id), 'id ASC');                    array('question' => $question->id), 'id ASC');  
</code php> </code>



Another interesting example is <tt>qtype_numerical</tt>, which needs extra data for each answer, and so does: Another interesting example is <tt>qtype_numerical</tt>, which needs extra data for each answer, and so does:
Line 43:
Line 43:
          WHERE qa.question = ?           WHERE qa.question = ?
       ORDER BY qa.id ASC", array($questionid))) {        ORDER BY qa.id ASC", array($questionid))) {
</code php> </code>



(Again, you can see the age of these tables in several violations of the current coding guidelines.) (Again, you can see the age of these tables in several violations of the current coding guidelines.)
Line 54:
Line 54:
<code php> <code php>
question_bank::get_qtype($qtype)->save_question($fromform); question_bank::get_qtype($qtype)->save_question($fromform);
</code php> </code>



This data structure is also used by [[Question formats|question import formats]]. They parse whatever import file they are processing, and generate this <tt>$fromform</tt> data structure, which it then passed to <tt>save_question</tt>. This data structure is also used by [[Question formats|question import formats]]. They parse whatever import file they are processing, and generate this <tt>$fromform</tt> data structure, which it then passed to <tt>save_question</tt>.
Line 74:
Line 74:
<code php> <code php>
$question = question_bank::make_question($questiondata); $question = question_bank::make_question($questiondata);
</code php> </code>



This data structure is actually an instance of a proper class, <tt>question_definition</tt>, or more likely one of its subclasses depending on the question type. Therefore, there is extensive documentation of all the fields on the base class, which is defined in <tt>question/type/questionbase.php</tt>. This data structure is actually an instance of a proper class, <tt>question_definition</tt>, or more likely one of its subclasses depending on the question type. Therefore, there is extensive documentation of all the fields on the base class, which is defined in <tt>question/type/questionbase.php</tt>.



TimHunt: Created page with "There are three different ways that questions get represented in the code. That is rather annoying, and at least one more than really necessary. It is mainly due to the age of th..."
2012-02-05T22:14:25Z
Created page with "There are three different ways that questions get represented in the code. That is rather annoying, and at least one more than really necessary. It is mainly due to the age of th..."
New page
There are three different ways that questions get represented in the code. That is rather annoying, and at least one more than really necessary. It is mainly due to the age of the code, but cleaning things up would break a lot of backwards compatibility, and so probably will not happen. Hopefully this page can explain what is going on, and will help you understand the code. The reason there are three different representations in different places does have a certain logic.



==Representation 1: <tt>$questiondata</tt>==



This representation is designed to closely mirror the data in the database. This representation is used in most places in the question bank. You can get the question in this form by calling either

<code php>

questiondata = question_bank::load_question($questionid); // Defined in question/engine/bank.php

// or

questiondata = question_load_questions(array($questionid)); // Defined in lib/questionlib.php

</code php>



For a typical <tt>$qtype</tt>, the structure is something like what you would get by running



<code php>

$questiondata = $DB->get_record('question', array('id', $questionid));

$questiondata->options = $DB->get_record("qtype_{$qtype}_options",

       array('questionid', $questionid));

$questiondata->options->answers = $DB->get_records('question_answers',

       array('question', $questionid), 'id ASC');

$questiondata->hints = $DB->get_record('question_hints',

       array('questionid', $questionid), 'id ASC');

</code php>



Some oddities that are worth commenting on there:

* The columns should really be called <tt>question_answers.questionid</tt>, not <tt>question_answers.question</tt>, at least according to the coding guidelines as they are now, but this table has existed since Moodle 1.1 when the coding guidelines were different. This anomaly will probably be fixed one day.

* It would probably be better if it was <tt>$questiondata->answers</tt> instead of <tt>$questiondata->options->answers</tt>. Again this is historic, which is why when I added <tt>$questiondata->hints</tt> I did it in an inconsistent way. It is not clear whether it is worth fixing this anomaly.

* Note that, although I have used <tt>$questiondata</tt> as the name for this data structure, in many places in the code, the name <tt>$question</tt> is used instead. Again, this is historic. The intention is to move towards consistently calling variables that hold this data-structure <tt>$questiondata</tt> (or <tt>$qd</tt>).



Not all question types are exactly like this. For example it is optional whether any question type chooses to use <tt>question_answers</tt> or <tt>question_hints</tt>. It depends on the question type whether they are useful. Other question types may have other data structures. For example <tt>qtype_match</tt> does not use answers. Instead it uses



<code php>

$questiondata->options->subquestions = $DB->get_records('question_match_sub',

                array('question' => $question->id), 'id ASC'); 

</code php>



Another interesting example is <tt>qtype_numerical</tt>, which needs extra data for each answer, and so does:



<code php>

$questiondata->options->answers = $DB->get_records_sql("

        SELECT qa.*, qna.tolerance 

          FROM {question_answers} qa

          JOIN {question_numerical} qna on qna.answer = qa.id

         WHERE qa.question = ?

      ORDER BY qa.id ASC", array($questionid))) {

</code php>



(Again, you can see the age of these tables in several violations of the current coding guidelines.)





==Representation 2: <tt>$fromform</tt>==



This representation closely mirrors the structure of the question editing form for the question type. It is what you get back from calling <tt>$mform->get_data()</tt> on the question editing form for the relevant type. Typically this data gets passed to 



<code php>

question_bank::get_qtype($qtype)->save_question($fromform);

</code php>



This data structure is also used by [[Question formats|question import formats]]. They parse whatever import file they are processing, and generate this <tt>$fromform</tt> data structure, which it then passed to <tt>save_question</tt>.



The main differences compared with <tt>$questiondata</tt> are:

* The structure is flattened, so <tt>$questiondata->options->someoption</tt> is the same as <tt>$fromform->someoption</tt>.

* The answer and hints arrays are different, so <tt>$questiondata->options->answers[123]->fraction</tt> may be <tt>$fromform->fraction[1]</tt>

* Data from the HTML editor is different, so, while you have <tt>$questiondata->hints[234]->hint</tt> and <tt>$questiondata->hints[234]->hintformat</tt>, you will have <tt>$fromform->hint[2]['text']</tt>, <tt>$fromform->hint[2]['format']</tt> and <tt>$fromform->hint[2]['itemid']</tt>.



When importing, you may have <tt>$fromform->hint[2]['files']</tt> instead of <tt>$fromform->hint[2]['itemid']</tt>. See <tt>question_type::import_or_save_files</tt> for how this is handled.



Once again, in the code, variables holding this data structure are often called <tt>$question</tt>. The plan is to gradually rename them all to <tt>$fromform</tt>.





==Representation 3: <tt>question_definition $question</tt>==



Finally, there is the data structure used by the question engine, while questions are being attempted. You can get this structure by calling



<code php>

$question = question_bank::make_question($questiondata);

</code php>



This data structure is actually an instance of a proper class, <tt>question_definition</tt>, or more likely one of its subclasses depending on the question type. Therefore, there is extensive documentation of all the fields on the base class, which is defined in <tt>question/type/questionbase.php</tt>.



Although this is a proper class, all the data is still stored in public fields that closely mirror the structure of the question table. The extra options (e.g. <tt>$questiondata->options->someoption</tt>) are flattened out (e.g. <tt>$question->someoption</tt>). <tt>$question->answers</tt> is an array of <tt>question_answer</tt> objects (or a subclass, for example in <tt>qtype_numerical</tt>) and <tt>$question->hints</tt> is an array of <tt>question_hint</tt> objects.





==Summary of the data flows==



This diagram should help summarise the various representations of questions, and where they are used.



[[Question_data_structures]]





==See also==



* [[Question API]]

* [[Question database structure]]





[[Category:Questions]]

← Older revision		Revision as of 13:34, 14 July 2021
Line 4:		Line 4:

	This representation is designed to closely mirror the data in the database. This representation is used in most places in the question bank. You can get the question in this form by calling either		This representation is designed to closely mirror the data in the database. This representation is used in most places in the question bank. You can get the question in this form by calling either
	<~~code~~ php>		<syntaxhighlight lang="php">
	$questiondata = question_bank::load_question($questionid); // Defined in question/engine/bank.php		$questiondata = question_bank::load_question($questionid); // Defined in question/engine/bank.php
	// or		// or
Line 12:		Line 12:
	For a typical <tt>$qtype</tt>, the structure is something like what you would get by running		For a typical <tt>$qtype</tt>, the structure is something like what you would get by running

	<~~code~~ php>		<syntaxhighlight lang="php">
	$questiondata = $DB->get_record('question', array('id', $questionid));		$questiondata = $DB->get_record('question', array('id', $questionid));
	$questiondata->options = $DB->get_record("qtype_{$qtype}_options",		$questiondata->options = $DB->get_record("qtype_{$qtype}_options",
Line 29:		Line 29:
	Not all question types are exactly like this. For example it is optional whether any question type chooses to use <tt>question_answers</tt> or <tt>question_hints</tt>. It depends on the question type whether they are useful. Other question types may have other data structures. For example <tt>qtype_match</tt> does not use answers. Instead it uses		Not all question types are exactly like this. For example it is optional whether any question type chooses to use <tt>question_answers</tt> or <tt>question_hints</tt>. It depends on the question type whether they are useful. Other question types may have other data structures. For example <tt>qtype_match</tt> does not use answers. Instead it uses

	<~~code~~ php>		<syntaxhighlight lang="php">
	$questiondata->options->subquestions = $DB->get_records('question_match_sub',		$questiondata->options->subquestions = $DB->get_records('question_match_sub',
	array('question' => $question->id), 'id ASC');		array('question' => $question->id), 'id ASC');
Line 36:		Line 36:
	Another interesting example is <tt>qtype_numerical</tt>, which needs extra data for each answer, and so does:		Another interesting example is <tt>qtype_numerical</tt>, which needs extra data for each answer, and so does:

	<~~code~~ php>		<syntaxhighlight lang="php">
	$questiondata->options->answers = $DB->get_records_sql("		$questiondata->options->answers = $DB->get_records_sql("
	SELECT qa.*, qna.tolerance		SELECT qa.*, qna.tolerance
Line 51:		Line 51:
	This representation closely mirrors the structure of the question editing form for the question type. It is what you get back from calling <tt>$mform->get_data()</tt> on the question editing form for the relevant type. Typically this data gets passed to		This representation closely mirrors the structure of the question editing form for the question type. It is what you get back from calling <tt>$mform->get_data()</tt> on the question editing form for the relevant type. Typically this data gets passed to

	<~~code~~ php>		<syntaxhighlight lang="php">
	question_bank::get_qtype($qtype)->save_question($fromform);		question_bank::get_qtype($qtype)->save_question($fromform);
	</code>		</code>
Line 68:		Line 68:
	If you want to see what this data structure is for a particular question type, edit question/question.php, and insert the debugging line		If you want to see what this data structure is for a particular question type, edit question/question.php, and insert the debugging line

	<~~code~~ php>		<syntaxhighlight lang="php">
	$question = $qtypeobj->save_question($question, $fromform);		$question = $qtypeobj->save_question($question, $fromform);
	</code>		</code>
Line 74:		Line 74:
	Just before the line		Just before the line

	<~~code~~ php>		<syntaxhighlight lang="php">
	if (!empty($CFG->usetags) && isset($fromform->tags)) {		if (!empty($CFG->usetags) && isset($fromform->tags)) {
	</code>		</code>
Line 82:		Line 82:
	Finally, there is the data structure used by the question engine, while questions are being attempted. You can get this structure by calling		Finally, there is the data structure used by the question engine, while questions are being attempted. You can get this structure by calling

	<~~code~~ php>		<syntaxhighlight lang="php">
	$question = question_bank::make_question($questiondata);		$question = question_bank::make_question($questiondata);
	</code>		</code>

← Older revision		Revision as of 17:10, 8 January 2018
Line 25:		Line 25:
	* The columns should really be called <tt>question_answers.questionid</tt>, not <tt>question_answers.question</tt>, at least according to the coding guidelines as they are now, but this table has existed since Moodle 1.1 when the coding guidelines were different. This anomaly will probably be fixed one day.		* The columns should really be called <tt>question_answers.questionid</tt>, not <tt>question_answers.question</tt>, at least according to the coding guidelines as they are now, but this table has existed since Moodle 1.1 when the coding guidelines were different. This anomaly will probably be fixed one day.
	* It would probably be better if it was <tt>$questiondata->answers</tt> instead of <tt>$questiondata->options->answers</tt>. Again this is historic, which is why when I added <tt>$questiondata->hints</tt> I did it in an inconsistent way. It is not clear whether it is worth fixing this anomaly.		* It would probably be better if it was <tt>$questiondata->answers</tt> instead of <tt>$questiondata->options->answers</tt>. Again this is historic, which is why when I added <tt>$questiondata->hints</tt> I did it in an inconsistent way. It is not clear whether it is worth fixing this anomaly.
	* Note that, although I have used <tt>$questiondata</tt> as the name for this data structure, in many places in the code, the name <tt>$question</tt> is used instead. Again, this is historic. The intention is to move towards consistently calling variables that hold this data-structure <tt>$questiondata</tt> ~~(or <tt>$qd</tt>)~~.		* Note that, although I have used <tt>$questiondata</tt> as the name for this data structure, in many places in the code, the name <tt>$question</tt> is used instead. Again, this is historic. The intention is to move towards consistently calling variables that hold this data-structure <tt>$questiondata</tt>.

	Not all question types are exactly like this. For example it is optional whether any question type chooses to use <tt>question_answers</tt> or <tt>question_hints</tt>. It depends on the question type whether they are useful. Other question types may have other data structures. For example <tt>qtype_match</tt> does not use answers. Instead it uses		Not all question types are exactly like this. For example it is optional whether any question type chooses to use <tt>question_answers</tt> or <tt>question_hints</tt>. It depends on the question type whether they are useful. Other question types may have other data structures. For example <tt>qtype_match</tt> does not use answers. Instead it uses

← Older revision		Revision as of 17:07, 8 January 2018
Line 103:		Line 103:


	[[Category:~~Questions~~]]		[[Category:Quiz]]

← Older revision		Revision as of 11:11, 23 November 2012
Line 66:		Line 66:
	Once again, in the code, variables holding this data structure are often called <tt>$question</tt>. The plan is to gradually rename them all to <tt>$fromform</tt>.		Once again, in the code, variables holding this data structure are often called <tt>$question</tt>. The plan is to gradually rename them all to <tt>$fromform</tt>.

			If you want to see what this data structure is for a particular question type, edit question/question.php, and insert the debugging line

			<code php>
			$question = $qtypeobj->save_question($question, $fromform);
			</code>

			Just before the line

			<code php>
			if (!empty($CFG->usetags) && isset($fromform->tags)) {
			</code>

	==Representation 3: <tt>question_definition $question</tt>==		==Representation 3: <tt>question_definition $question</tt>==

← Older revision		Revision as of 12:25, 16 February 2012
Line 5:		Line 5:
	This representation is designed to closely mirror the data in the database. This representation is used in most places in the question bank. You can get the question in this form by calling either		This representation is designed to closely mirror the data in the database. This representation is used in most places in the question bank. You can get the question in this form by calling either
	<code php>		<code php>
	questiondata = question_bank::load_question($questionid); // Defined in question/engine/bank.php		$questiondata = question_bank::load_question($questionid); // Defined in question/engine/bank.php
	// or		// or
	questiondata = question_load_questions(array($questionid)); // Defined in lib/questionlib.php		$questiondata = question_load_questions(array($questionid)); // Defined in lib/questionlib.php
	</code>		</code>

Line 46:		Line 46:

	(Again, you can see the age of these tables in several violations of the current coding guidelines.)		(Again, you can see the age of these tables in several violations of the current coding guidelines.)


	==Representation 2: <tt>$fromform</tt>==		==Representation 2: <tt>$fromform</tt>==

← Older revision		Revision as of 22:16, 5 February 2012
Line 85:		Line 85:
	This diagram should help summarise the various representations of questions, and where they are used.		This diagram should help summarise the various representations of questions, and where they are used.

	[[~~Question_data_structures~~]]		[[File:Question data structures.png]]


	==See also==		==See also==

← Older revision		Revision as of 22:15, 5 February 2012
Line 8:		Line 8:
	// or		// or
	questiondata = question_load_questions(array($questionid)); // Defined in lib/questionlib.php		questiondata = question_load_questions(array($questionid)); // Defined in lib/questionlib.php
	</code ~~php~~>		</code>

	For a typical <tt>$qtype</tt>, the structure is something like what you would get by running		For a typical <tt>$qtype</tt>, the structure is something like what you would get by running
Line 20:		Line 20:
	$questiondata->hints = $DB->get_record('question_hints',		$questiondata->hints = $DB->get_record('question_hints',
	array('questionid', $questionid), 'id ASC');		array('questionid', $questionid), 'id ASC');
	</code ~~php~~>		</code>

	Some oddities that are worth commenting on there:		Some oddities that are worth commenting on there:
Line 32:		Line 32:
	$questiondata->options->subquestions = $DB->get_records('question_match_sub',		$questiondata->options->subquestions = $DB->get_records('question_match_sub',
	array('question' => $question->id), 'id ASC');		array('question' => $question->id), 'id ASC');
	</code ~~php~~>		</code>

	Another interesting example is <tt>qtype_numerical</tt>, which needs extra data for each answer, and so does:		Another interesting example is <tt>qtype_numerical</tt>, which needs extra data for each answer, and so does:
Line 43:		Line 43:
	WHERE qa.question = ?		WHERE qa.question = ?
	ORDER BY qa.id ASC", array($questionid))) {		ORDER BY qa.id ASC", array($questionid))) {
	</code ~~php~~>		</code>

	(Again, you can see the age of these tables in several violations of the current coding guidelines.)		(Again, you can see the age of these tables in several violations of the current coding guidelines.)
Line 54:		Line 54:
	<code php>		<code php>
	question_bank::get_qtype($qtype)->save_question($fromform);		question_bank::get_qtype($qtype)->save_question($fromform);
	</code ~~php~~>		</code>

	This data structure is also used by [[Question formats\|question import formats]]. They parse whatever import file they are processing, and generate this <tt>$fromform</tt> data structure, which it then passed to <tt>save_question</tt>.		This data structure is also used by [[Question formats\|question import formats]]. They parse whatever import file they are processing, and generate this <tt>$fromform</tt> data structure, which it then passed to <tt>save_question</tt>.
Line 74:		Line 74:
	<code php>		<code php>
	$question = question_bank::make_question($questiondata);		$question = question_bank::make_question($questiondata);
	</code ~~php~~>		</code>

	This data structure is actually an instance of a proper class, <tt>question_definition</tt>, or more likely one of its subclasses depending on the question type. Therefore, there is extensive documentation of all the fields on the base class, which is defined in <tt>question/type/questionbase.php</tt>.		This data structure is actually an instance of a proper class, <tt>question_definition</tt>, or more likely one of its subclasses depending on the question type. Therefore, there is extensive documentation of all the fields on the base class, which is defined in <tt>question/type/questionbase.php</tt>.