Merge branch 'MDL-29668' of git://github.com/stronk7/moodle
[moodle.git] / lib / xmldb / xmldb_key.php
1 <?php
3 ///////////////////////////////////////////////////////////////////////////
4 //                                                                       //
5 // NOTICE OF COPYRIGHT                                                   //
6 //                                                                       //
7 // Moodle - Modular Object-Oriented Dynamic Learning Environment         //
8 //          http://moodle.com                                            //
9 //                                                                       //
10 // Copyright (C) 1999 onwards Martin Dougiamas     http://dougiamas.com  //
11 //           (C) 2001-3001 Eloy Lafuente (stronk7) http://contiento.com  //
12 //                                                                       //
13 // This program is free software; you can redistribute it and/or modify  //
14 // it under the terms of the GNU General Public License as published by  //
15 // the Free Software Foundation; either version 2 of the License, or     //
16 // (at your option) any later version.                                   //
17 //                                                                       //
18 // This program is distributed in the hope that it will be useful,       //
19 // but WITHOUT ANY WARRANTY; without even the implied warranty of        //
20 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         //
21 // GNU General Public License for more details:                          //
22 //                                                                       //
23 //          http://www.gnu.org/copyleft/gpl.html                         //
24 //                                                                       //
25 ///////////////////////////////////////////////////////////////////////////
27 /// This class represent one XMLDB Key
29 class xmldb_key extends xmldb_object {
31     var $type;
32     var $fields;
33     var $reftable;
34     var $reffields;
36     /**
37      * Creates one new xmldb_key
38      */
39     function __construct($name, $type=null, $fields=array(), $reftable=null, $reffields=null) {
40         $this->type = NULL;
41         $this->fields = array();
42         $this->reftable = NULL;
43         $this->reffields = array();
44         parent::__construct($name);
45         $this->set_attributes($type, $fields, $reftable, $reffields);
46     }
48 /// TODO: Delete for 2.1 (deprecated in 2.0).
49 /// Deprecated API starts here
51     function setAttributes($type, $fields, $reftable=null, $reffields=null) {
53         debugging('XMLDBKey->setAttributes() has been deprecated in Moodle 2.0. Will be out in Moodle 2.1. Please use xmldb_key->set_attributes() instead.', DEBUG_DEVELOPER);
55         return $this->set_attributes($type, $fields, $reftable, $reffields);
56     }
57 /// Deprecated API ends here
59     /**
60      * Set all the attributes of one xmldb_key
61      *
62      * @param string type XMLDB_KEY_[PRIMARY|UNIQUE|FOREIGN|FOREIGN_UNIQUE]
63      * @param array fields an array of fieldnames to build the key over
64      * @param string reftable name of the table the FK points to or null
65      * @param array reffields an array of fieldnames in the FK table or null
66      */
67     function set_attributes($type, $fields, $reftable=null, $reffields=null) {
68         $this->type = $type;
69         $this->fields = $fields;
70         $this->reftable = $reftable;
71         $this->reffields = empty($reffields) ? array() : $reffields;
72     }
74     /**
75      * Get the key type
76      */
77     function getType() {
78         return $this->type;
79     }
81     /**
82      * Set the key type
83      */
84     function setType($type) {
85         $this->type = $type;
86     }
88     /**
89      * Set the key fields
90      */
91     function setFields($fields) {
92         $this->fields = $fields;
93     }
95     /**
96      * Set the key reftable
97      */
98     function setRefTable($reftable) {
99         $this->reftable = $reftable;
100     }
102     /**
103      * Set the key reffields
104      */
105     function setRefFields($reffields) {
106         $this->reffields = $reffields;
107     }
109     /**
110      * Get the key fields
111      */
112     function &getFields() {
113         return $this->fields;
114     }
116     /**
117      * Get the key reftable
118      */
119     function &getRefTable() {
120         return $this->reftable;
121     }
123     /**
124      * Get the key reffields
125      */
126     function &getRefFields() {
127         return $this->reffields;
128     }
130     /**
131      * Load data from XML to the key
132      */
133     function arr2xmldb_key($xmlarr) {
135         $result = true;
137     /// Debug the table
138     /// traverse_xmlize($xmlarr);                   //Debug
139     /// print_object ($GLOBALS['traverse_array']);  //Debug
140     /// $GLOBALS['traverse_array']="";              //Debug
142     /// Process key attributes (name, type, fields, reftable,
143     /// reffields, comment, previous, next)
144         if (isset($xmlarr['@']['NAME'])) {
145             $this->name = trim($xmlarr['@']['NAME']);
146         } else {
147             $this->errormsg = 'Missing NAME attribute';
148             $this->debug($this->errormsg);
149             $result = false;
150         }
152         if (isset($xmlarr['@']['TYPE'])) {
153         /// Check for valid type
154             $type = $this->getXMLDBKeyType(trim($xmlarr['@']['TYPE']));
155             if ($type) {
156                 $this->type = $type;
157             } else {
158                 $this->errormsg = 'Invalid TYPE attribute';
159                 $this->debug($this->errormsg);
160                 $result = false;
161             }
162         } else {
163             $this->errormsg = 'Missing TYPE attribute';
164             $this->debug($this->errormsg);
165             $result = false;
166         }
168         if (isset($xmlarr['@']['FIELDS'])) {
169             $fields = strtolower(trim($xmlarr['@']['FIELDS']));
170             if ($fields) {
171                 $fieldsarr = explode(',',$fields);
172                 if ($fieldsarr) {
173                     foreach ($fieldsarr as $key => $element) {
174                         $fieldsarr [$key] = trim($element);
175                     }
176                 } else {
177                     $this->errormsg = 'Incorrect FIELDS attribute (comma separated of fields)';
178                     $this->debug($this->errormsg);
179                     $result = false;
180                 }
181             } else {
182                 $this->errormsg = 'Empty FIELDS attribute';
183                 $this->debug($this->errormsg);
184                 $result = false;
185             }
186         } else {
187             $this->errormsg = 'Missing FIELDS attribute';
188             $this->debug($this->errormsg);
189             $result = false;
190         }
191     /// Finally, set the array of fields
192         $this->fields = $fieldsarr;
194         if (isset($xmlarr['@']['REFTABLE'])) {
195         /// Check we are in a FK
196             if ($this->type == XMLDB_KEY_FOREIGN ||
197                 $this->type == XMLDB_KEY_FOREIGN_UNIQUE) {
198                 $reftable = strtolower(trim($xmlarr['@']['REFTABLE']));
199                 if (!$reftable) {
200                     $this->errormsg = 'Empty REFTABLE attribute';
201                     $this->debug($this->errormsg);
202                     $result = false;
203                 }
204             } else {
205                 $this->errormsg = 'Wrong REFTABLE attribute (only FK can have it)';
206                 $this->debug($this->errormsg);
207                 $result = false;
208             }
209         } else if ($this->type == XMLDB_KEY_FOREIGN ||
210                    $this->type == XMLDB_KEY_FOREIGN_UNIQUE) {
211             $this->errormsg = 'Missing REFTABLE attribute';
212             $this->debug($this->errormsg);
213             $result = false;
214         }
215     /// Finally, set the reftable
216         if ($this->type == XMLDB_KEY_FOREIGN ||
217             $this->type == XMLDB_KEY_FOREIGN_UNIQUE) {
218             $this->reftable = $reftable;
219         }
221         if (isset($xmlarr['@']['REFFIELDS'])) {
222         /// Check we are in a FK
223             if ($this->type == XMLDB_KEY_FOREIGN ||
224                 $this->type == XMLDB_KEY_FOREIGN_UNIQUE) {
225                 $reffields = strtolower(trim($xmlarr['@']['REFFIELDS']));
226                 if ($reffields) {
227                     $reffieldsarr = explode(',',$reffields);
228                     if ($reffieldsarr) {
229                         foreach ($reffieldsarr as $key => $element) {
230                             $reffieldsarr [$key] = trim($element);
231                         }
232                     } else {
233                         $this->errormsg = 'Incorrect REFFIELDS attribute (comma separated of fields)';
234                         $this->debug($this->errormsg);
235                         $result = false;
236                     }
237                 } else {
238                     $this->errormsg = 'Empty REFFIELDS attribute';
239                     $this->debug($this->errormsg);
240                     $result = false;
241                 }
242             } else {
243                 $this->errormsg = 'Wrong REFFIELDS attribute (only FK can have it)';
244                 $this->debug($this->errormsg);
245                 $result = false;
246             }
247         } else if ($this->type == XMLDB_KEY_FOREIGN ||
248                    $this->type == XMLDB_KEY_FOREIGN_UNIQUE) {
249             $this->errormsg = 'Missing REFFIELDS attribute';
250             $this->debug($this->errormsg);
251             $result = false;
252         }
253     /// Finally, set the array of reffields
254         if ($this->type == XMLDB_KEY_FOREIGN ||
255             $this->type == XMLDB_KEY_FOREIGN_UNIQUE) {
256             $this->reffields = $reffieldsarr;
257         }
259         if (isset($xmlarr['@']['COMMENT'])) {
260             $this->comment = trim($xmlarr['@']['COMMENT']);
261         }
263         if (isset($xmlarr['@']['PREVIOUS'])) {
264             $this->previous = trim($xmlarr['@']['PREVIOUS']);
265         }
267         if (isset($xmlarr['@']['NEXT'])) {
268             $this->next = trim($xmlarr['@']['NEXT']);
269         }
271     /// Set some attributes
272         if ($result) {
273             $this->loaded = true;
274         }
275         $this->calculateHash();
276         return $result;
277     }
279     /**
280      * This function returns the correct XMLDB_KEY_XXX value for the
281      * string passed as argument
282      */
283     function getXMLDBKeyType($type) {
285         $result = XMLDB_KEY_INCORRECT;
287         switch (strtolower($type)) {
288             case 'primary':
289                 $result = XMLDB_KEY_PRIMARY;
290                 break;
291             case 'unique':
292                 $result = XMLDB_KEY_UNIQUE;
293                 break;
294             case 'foreign':
295                 $result = XMLDB_KEY_FOREIGN;
296                 break;
297             case 'foreign-unique':
298                 $result = XMLDB_KEY_FOREIGN_UNIQUE;
299                 break;
300         /// case 'check':  //Not supported
301         ///     $result = XMLDB_KEY_CHECK;
302         ///     break;
303         }
304     /// Return the normalized XMLDB_KEY
305         return $result;
306     }
308     /**
309      * This function returns the correct name value for the
310      * XMLDB_KEY_XXX passed as argument
311      */
312     function getXMLDBKeyName($type) {
314         $result = '';
316         switch (strtolower($type)) {
317             case XMLDB_KEY_PRIMARY:
318                 $result = 'primary';
319                 break;
320             case XMLDB_KEY_UNIQUE:
321                 $result = 'unique';
322                 break;
323             case XMLDB_KEY_FOREIGN:
324                 $result = 'foreign';
325                 break;
326             case XMLDB_KEY_FOREIGN_UNIQUE:
327                 $result = 'foreign-unique';
328                 break;
329         /// case XMLDB_KEY_CHECK:  //Not supported
330         ///     $result = 'check';
331         ///     break;
332         }
333     /// Return the normalized name
334         return $result;
335     }
337     /**
338      * This function calculate and set the hash of one xmldb_key
339      */
340      function calculateHash($recursive = false) {
341         if (!$this->loaded) {
342             $this->hash = NULL;
343         } else {
344             $key = $this->type . implode(', ', $this->fields);
345             if ($this->type == XMLDB_KEY_FOREIGN ||
346                 $this->type == XMLDB_KEY_FOREIGN_UNIQUE) {
347                 $key .= $this->reftable . implode(', ', $this->reffields);
348             }
349                     ;
350             $this->hash = md5($key);
351         }
352     }
354     /**
355      *This function will output the XML text for one key
356      */
357     function xmlOutput() {
358         $o = '';
359         $o.= '        <KEY NAME="' . $this->name . '"';
360         $o.= ' TYPE="' . $this->getXMLDBKeyName($this->type) . '"';
361         $o.= ' FIELDS="' . implode(', ', $this->fields) . '"';
362         if ($this->type == XMLDB_KEY_FOREIGN ||
363             $this->type == XMLDB_KEY_FOREIGN_UNIQUE) {
364             $o.= ' REFTABLE="' . $this->reftable . '"';
365             $o.= ' REFFIELDS="' . implode(', ', $this->reffields) . '"';
366         }
367         if ($this->comment) {
368             $o.= ' COMMENT="' . htmlspecialchars($this->comment) . '"';
369         }
370         if ($this->previous) {
371             $o.= ' PREVIOUS="' . $this->previous . '"';
372         }
373         if ($this->next) {
374             $o.= ' NEXT="' . $this->next . '"';
375         }
376         $o.= '/>' . "\n";
378         return $o;
379     }
381     /**
382      * This function will set all the attributes of the xmldb_key object
383      * based on information passed in one ADOkey
384      */
385     function setFromADOKey($adokey) {
387     /// Calculate the XMLDB_KEY
388         switch (strtolower($adokey['name'])) {
389             case 'primary':
390                 $this->type = XMLDB_KEY_PRIMARY;
391                 break;
392             default:
393                 $this->type = XMLDB_KEY_UNIQUE;
394         }
395     /// Set the fields, converting all them to lowercase
396         $fields = array_flip(array_change_key_case(array_flip($adokey['columns'])));
397         $this->fields = $fields;
398     /// Some more fields
399         $this->loaded = true;
400         $this->changed = true;
401     }
403     /**
404      * Returns the PHP code needed to define one xmldb_key
405      */
406     function getPHP() {
408         $result = '';
410     /// The type
411         switch ($this->getType()) {
412             case XMLDB_KEY_PRIMARY:
413                 $result .= 'XMLDB_KEY_PRIMARY' . ', ';
414                 break;
415             case XMLDB_KEY_UNIQUE:
416                 $result .= 'XMLDB_KEY_UNIQUE' . ', ';
417                 break;
418             case XMLDB_KEY_FOREIGN:
419                 $result .= 'XMLDB_KEY_FOREIGN' . ', ';
420                 break;
421             case XMLDB_KEY_FOREIGN_UNIQUE:
422                 $result .= 'XMLDB_KEY_FOREIGN_UNIQUE' . ', ';
423                 break;
424         }
425     /// The fields
426         $keyfields = $this->getFields();
427         if (!empty($keyfields)) {
428             $result .= 'array(' . "'".  implode("', '", $keyfields) . "')";
429         } else {
430             $result .= 'null';
431         }
432     /// The FKs attributes
433         if ($this->getType() == XMLDB_KEY_FOREIGN ||
434             $this->getType() == XMLDB_KEY_FOREIGN_UNIQUE) {
435         /// The reftable
436             $reftable = $this->getRefTable();
437             if (!empty($reftable)) {
438                 $result .= ", '" . $reftable . "', ";
439             } else {
440                 $result .= 'null, ';
441             }
442         /// The reffields
443             $reffields = $this->getRefFields();
444             if (!empty($reffields)) {
445                 $result .= 'array(' . "'".  implode("', '", $reffields) . "')";
446             } else {
447                 $result .= 'null';
448             }
449         }
450     /// Return result
451         return $result;
452     }
454     /**
455      * Shows info in a readable format
456      */
457     function readableInfo() {
458         $o = '';
459     /// type
460         $o .= $this->getXMLDBKeyName($this->type);
461     /// fields
462         $o .= ' (' . implode(', ', $this->fields) . ')';
463     /// foreign key
464         if ($this->type == XMLDB_KEY_FOREIGN ||
465             $this->type == XMLDB_KEY_FOREIGN_UNIQUE) {
466             $o .= ' references ' . $this->reftable . ' (' . implode(', ', $this->reffields) . ')';
467         }
469         return $o;
470     }
473 /// TODO: Delete for 2.1 (deprecated in 2.0).
474 /// Deprecated API starts here
475 class XMLDBKey extends xmldb_key {
477     function __construct($name) {
478         parent::__construct($name);
479     }
482 /// Deprecated API ends here