Er is een database fout opgetreden:

Got error 28 from storage engine
Query:
DESCRIBE reflirt_rezanamavar.article
Error
Uncaught exception: Got error 28 from storage engine
At 
#1 php-classes/entities/db/preparedquery.class.php(450):  PreparedQuery.drop(Got error 28 from storage engineDESCRIBE reflirt_rezanamavar.article)
#2 php-classes/entities/db/table.class.php(150): PreparedQuery.execute()
#3 php-classes/entities/db/table.class.php(29): Table.loadColumnData()
#4 php-classes/entities/db/database.class.php(21): Table.Table(reflirt_rezanamavararticle)
#5 php-classes/entities/db/dbinfo.class.php(13): Database.getTable(article)
#6 php-classes/entities/db/databasetablemodel.class.php(18): DBInfo.getTable(reflirt_rezanamavararticle)
#7 php-classes/entities/db/entity.class.php(249): DatabaseTableModel.getTable()
#8 php-classes/searchers/objectquery.class.php(56): Entity.getTable()
#9 php-classes/entities/db/entityfactory.class.php(6): ObjectQuery.buildACS()
#10 web/pages/articlepage.class.php(37): EntityFactory.loadEntity(1)
#11 web/pages/articlepage.class.php(10): ArticlePage.getArticle()
#12 php-classes/core/page.class.php(183): Page.executeAction()
#13 php-classes/core/pageloader.class.php(95): Page.response()
#14 web/index.php(39): PageLoader.go()
PreparedQuery
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
<?php    
include_once PHP_CLASS.'entities/db/DuplicateException.class.php';
include_once 
PHP_CLASS.'io/Logger.class.php';
include_once 
PHP_CLASS.'exception/IllegalStateException.class.php';

class 
PreparedQuery {

    public static 
$query_counter 0;

    private 
$db;
    private 
$table;
    
    private static 
$pdo;
    private static 
$dblink;
    
    private static 
$USE_PDO        false;
    
    private 
$fields             "";
    
    private 
$constraints        null;
    
    private 
$updateFields        = array();
    
    private 
$insertFields         = array();
    
    private 
$limit;
    
    private 
$join;
    
    private 
$orderby;
    
    private 
$groupBy;
    
    private 
$countrows false;
    
    private 
$count_column "rows";
    private 
$rows 0;
    
    private 
$type null;
    
    private 
$QUERY_TYPE_SELECT 'SELECT ';
    private 
$QUERY_TYPE_DELETE 'DELETE ';
    private 
$QUERY_TYPE_UPDATE 'UPDATE ';
    private 
$QUERY_TYPE_INSERT 'INSERT ';
    
    
// Voor als je zonder preparedstatements werkt, geen security dus!
    
private $query "";
    
    private 
$psParams    = array();
    private 
$psQuery     "";
    
    
// Toon het aantal resultaten dat gevonden zou worden ZONDER limit
    
public static $COUNT_ROWS_SQL " SQL_CALC_FOUND_ROWS ";
    
    function 
__construct($db) {
           
Utils::assertNotNull("No database specified for Query"$db);
        
$this->db $db;
           
$this->constraints = new QueryConstraintList();
    }

    function 
setTable($table){
        throw new 
IllegalStateException("Use setSelect for specifyng query type");
    }
    
    function 
setSelect($table){
        
$this->type $this->QUERY_TYPE_SELECT;
        
$this->table $table;        
    }

    function 
setDelete($table) {
        
$this->type $this->QUERY_TYPE_DELETE;
        
$this->table $table;
    }

    function 
setUpdate($table) {
        
$this->type $this->QUERY_TYPE_UPDATE;
        
$this->table $table;
    }
    
    function 
setInsert($table) {
        
$this->type $this->QUERY_TYPE_INSERT;
        
$this->table $table;
    }

    function 
setSelectFields($field){
        
Utils::assertTrue("Query must be of type SELECT (first use setTable())"
            
$this->type == $this->QUERY_TYPE_SELECT);
        
$this->fields $field;
    }
    
     public function 
addUpdateField($key$value) {
        
Utils::assertTrue("Query type != UPDATE"$this->type ==
                    
$this->QUERY_TYPE_UPDATE);
        
$this->updateFields[] = array($key$value);
//        if(!empty($this->updateFields)) {
//            $this->updateFields .= ", ";
//        }
//        if ($value == null) {
//            $this->updateFields .= "".$key." = NULL ";
//        } else {
//            $this->updateFields .= "".$key." = '".addslashes($value)."' ";
//        }
    
}
    
    public function 
addInsertField($key$value) {
        
Utils::assertTrue("Query type != INSERT"$this->type ==
                    
$this->QUERY_TYPE_INSERT);
        
$this->insertFields[] = array($key$value);
    }

    function 
addConstraint(QueryConstraint $constraint) {
        
$this->constraints->add($constraint);
    }

    
    function 
addFilter($field$value){
        
$this->constraints->add(Constraint::eq($field$value));
    }

    function 
addFilterGreater($field$value){
        
$this->constraints->add(Constraint::gt($field$value));
    }

    function 
addFilterNotEqual($field$value){
        
$this->constraints->add(Constraint::neq($field$value));
    }
    
    function 
addJoin($table$column){
        
$this->join .= " INNER JOIN ".$table." ON ".$this->table.".".$column.
            
" = ".$table.".systemid ";
    }

    function 
setMatch($keywords){
        
$this->filter .= "WHERE MATCH(f.nick, lokatie, commentaar) against('".$keywords."' IN BOOLEAN MODE)";
//           throw new IllegalStateException("Not yet implemented");
    
}

    function 
addMatchField($field$value /* keywords*/ ){
        
$this->constraints->add(Constraint::match($field$value));
//        throw new IllegalStateException("Not yet implemented");
//           $field = "MATCH(f.nick, lokatie, commentaar) against('".DBUtils::dbEscape($keywords)."'" .
//                   " IN BOOLEAN MODE) as ".$columnName." ";
//           $this->addField($field);
    
}

    function 
setLimit($limit_start$limit_end null){
        
$this->limit $limit_start;
        if(!empty(
$limit_end)) {
            
$this->limit .= ", ".$limit_end." ";
        }
    }

    function 
setOrderBy($orderby){
        
$this->orderby $orderby;
    }

    function 
setGroupBy($groupby){
        
$this->groupBy $groupby;
    }
    
    function 
setCountRows($count){
        
$this->countrows $count;
    }

    function 
setCountRowsColumn($column){
        
$this->count_column $column;
    }
    
    
    
    
    
    
    
    
    
    
    
    
    private function 
getTablePart() {
//        $query_part = "";
//        $table = $this->table;
//        switch($this->type) {
//            case $this->QUERY_TYPE_SELECT:
//
//                // Splitten voor als je een alias voor een table gebruikt
//                $table = split(' ', $table); 
//
//                if(count($table) == 2){
//                    $query_part = "FROM ".$table[0]." ". $table[1];
//                } else if(count($table == 1)){
//                    $query_part = "FROM ".$table[0]." ";
//                } else{
//                    throw new IllegalStateException(
//                        "Can't read table info (1) (too many spaces?):".$table);
//                }
//                break;
//                
//            case $this->QUERY_TYPE_DELETE:                        
//                $query_part = ' FROM '.$table." ";
//                break;
//                
//            case $this->QUERY_TYPE_UPDATE:
//                $query_part = ' UPDATE '.$table." SET ";
//                break;
//            case $this->QUERY_TYPE_INSERT:
//                $query_part = ' INSERT INTO '.$table." ";
//                break;
//            default:
//                die("Can't read table info (2) (too many spaces?):".$table);
//        }
//        return $query_part;    
    
}

    private function 
getPreparedQuery(){
        
$query "";
        
$query .= $this->type;
        switch(
$this->type) {
            
            case 
$this->QUERY_TYPE_SELECT:
                return 
$this->prepareSelect();
            
            case 
$this->QUERY_TYPE_INSERT:
                return 
$this->prepareInsert();
                
            case 
$this->QUERY_TYPE_UPDATE:
                return 
$this->prepareUpdate();
            
            case 
$this->QUERY_TYPE_DELETE:
                return 
$this->prepareDelete();
                
            default: 
                throw new 
IllegalStateException("Query type not implemented: " $this->type);
        }
    }
    
     private function 
prepareSelect() {
        
Utils::assertTrue("Query is niet van het type SELECT"
            
$this->type == $this->QUERY_TYPE_SELECT);
            
        
$this->psQuery "SELECT " $this->fields " " $this->table;
                
        
$this->prepareFilter();
        
        if(
$this->groupBy) {
            
$this->prepareGroupBy();
        }
        if(
$this->orderby) {
            
$this->prepareOrderBy();
        }
        if(
$this->limit) {
            
$this->prepareLimit();
        }
    }
    
    private function 
prepareInsert() {
        
        
$fields "";
        
$values "";
        
        
$first true;
        
        foreach(
$this->insertFields as $tuple) {
            
$key $tuple[0];
            
$value $tuple[1];
            if(!
$first) {
                
$values .= ", ";    
                
$fields .= ", ";    
            }
            
$fields .= $key " ";
            
$values .= "? ";
            
$this->addParameter($value);
            
$first false;
        }

        
$this->psQuery "INSERT INTO " $this->table "(" $fields 
            
") VALUES(" $values")";
    }
    
    private function 
prepareUpdate() {
        
Utils::assertTrue("Query is niet van het type UPDATE"
            
$this->type == $this->QUERY_TYPE_UPDATE);
            
        
$updateFields = array();
        
        
Utils::assertTrue("Specify at least one field to update"
            
count($this->updateFields) > 0);
        
        foreach(
$this->updateFields as $tuple) {
            
$field $tuple[0];
            
$value $tuple[1];
            
$updateFields[] = $field " = ?";
            
$this->addParameter($value);
        }
        
        
// Maakt iets als "field_1 = ?, field_2 = ?"
        
$sFields join(", "$updateFields);
         
        
$this->psQuery "UPDATE " $this->table " SET " $sFields;
                
        
$this->prepareFilter();
    }
    
    private function 
prepareDelete() {
        
Utils::assertTrue("Query is niet van het type DELETE"
            
$this->type == $this->QUERY_TYPE_DELETE);
            
        
$this->psQuery "DELETE FROM " $this->table;
                
        
$this->prepareFilter();
    }
    
    private function 
prepareGroupBy() {
        
$this->psQuery .= " GROUP BY " $this->groupBy;
    }

    private function 
prepareOrderBy() {
        
$this->psQuery .= " ORDER BY " $this->orderby;
    }
    
    private function 
prepareLimit() {
        
$this->psQuery .= " LIMIT " $this->limit;
    }

  
    
    
/**
     * Voegt een parameter toe aan de PDO params, uiteindelijk komt dat terecht
     * bij $pdo->addParam($field, $param);
     *
     * @param Object Waarde van het veld wat vervangen is door een '?'
     */
    
private function addParameter($param) {
        
//DebugUtils::debug("Parameter toevoegen: " . $param); 
        
$this->psParams[] = $param;
    }
    
    private function 
prepareFilter() {
        
$wherePart $this->constraints->toString();
        
$params $this->constraints->getValues();
        
        if(!empty(
$wherePart)) {
            
$this->psQuery .= " WHERE " $wherePart;
        }
        foreach (
$params as $param) {
            
$this->addParameter($param);
        }
    }
    
    function 
setQuery($query){
        
$this->query $query;
    }

    function 
checkConfig() {
        if(
DB_USER == '') {
            throw new 
Exception('config.php niet geconfigureerd');
        }
    }
    
    function 
connect() {
        if(
self::$USE_PDO) {
            if(!
self::$pdo) {
                
self::$pdo = new PDO("mysql:host=".DB_SERVER.";dbname=".$this->dbDB_USERDB_PASSWORD
                    array(
PDO::ATTR_PERSISTENT => true));
                
self::$pdo->setAttribute(PDO::ATTR_ERRMODEPDO::ERRMODE_EXCEPTION);
            }
            return 
true;    
        } else {
            if(
self::$dblink == null) {
                
$this->checkConfig();
                
self::$dblink mysql_connect(DB_SERVERDB_USERDB_PASSWORD);
            }
            return 
mysql_select_db($this->db) or die("Kan geen verbinding maken met database: '".$this->db."' > ".mysql_error());
        }
        
    }
    
    function 
prepare(){
        
$this->connect();
        
        if(!empty(
$this->query)) {
            
$this->psQuery $this->query
        } else {
            
$this->getPreparedQuery();
        }
    }

    private function 
setNoFoundRows($rows){
        
$this->rows $rows;
    }
    
    
/**
     * Als setCountRows(true) dan kun je met deze methode het aantal resultaten
     * ophalen dat er ZONDER een limit zou zijn. Handig voor pagination.
     */
    
public function getNoFoundRows() {
        return 
$this->rows;
    }

    public function 
execute($file null$line null$fetch_array true){
        if(!
$fetch_array) {
            throw new 
IllegalStateException("fetch_array moet niet meer gebruikt worden");
        }
        
self::$query_counter++;
        
$this->prepare();
            
        if(
self::$USE_PDO) {
            if(
DEBUG_QUERY && !IS_PRODUCTION) {
                
DebugUtils::debug("[query] " $this->getDebugQuery(), 0);
            }
            
            
$statement self::$pdo->prepare($this->psQuery);
    
            
//DebugUtils::debug($this->psParams);
            
            
for ($i 0$i count($this->psParams); $i++) {
                
// Kan hier geen foreach loop gebruiken want de value MOET via 
                // $this->psParams[] toegewezen worden op een of ander emanier
                
$statement->bindParam($i 1$this->psParams[$i]);
            }
            
$statement->execute(); //or $this->drop(mysql_error(), $this->psQuery, $file, $line);;
            
if($this->type == $this->QUERY_TYPE_INSERT) {
                
$systemid self::$pdo->lastInsertId();
                return 
$systemid;
            }
                
            if(
$this->countrows) {
                
$pq = new PreparedQuery(DEFAULT_DATABASE);
                
$pq->setQuery("SELECT FOUND_ROWS() AS rows;");
                
$cr $pq->execute();
                
$this->setNoFoundRows($cr[0]['rows']);
            }
            
/* fetchen naar array, niet bij delete en update queries */
            
if($fetch_array 
                    
&& $this->type != $this->QUERY_TYPE_DELETE
                    
&& $this->type != $this->QUERY_TYPE_UPDATE){
                return 
$statement->fetchAll();
            }
            else{
                
//return $statement->fetchAll();
                
return null;
            }
        } else {
            
            
$query $this->getDebugQuery();
            if(
DEBUG_QUERY && !IS_PRODUCTION) {
                
DebugUtils::debug("[query] " $query0);
            }
            
            $rs mysql_query($query) or $this->drop(mysql_error(), $query$file$line);
            if(
$this->type == $this->QUERY_TYPE_INSERT) {
                
$systemid mysql_insert_id();
                return 
$systemid;
            }
                
            if(
$this->countrows) {
                
$pq = new PreparedQuery(DEFAULT_DATABASE);
                
$pq->setQuery("SELECT FOUND_ROWS() AS rows;");
                
$cr $pq->execute();
                
$this->setNoFoundRows($cr[0]['rows']);
            }
            
/* fetchen naar array, niet bij delete en update queries */
            
if($fetch_array 
                    
&& $this->type != $this->QUERY_TYPE_DELETE
                    
&& $this->type != $this->QUERY_TYPE_UPDATE){
                
$lines = array();
                while(
$line mysql_fetch_array($rsMYSQL_ASSOC)) {
                    
$lines[] = $line
                }
                return 
$lines;
            }
            else{
                
//return $statement->fetchAll();
                
return $rs;
            }
        }
        
        return 
null;
    }
    
    public function 
getDebugQuery() {
        
$split explode("?"$this->psQuery);
        if(
count($split) - != count($this->psParams)) {
            throw new 
IllegalStateException("Wrong parameter count"); 
        }
        
$query "";
        foreach(
$this->psParams as $key=>$value) {
            if(
$value == null && $value != "0") {
                
$query .= $split[$key] . "NULL";
            } else {
                
$query .= $split[$key] . "'" mysql_escape_string($value) . "'";
            }
        }
        
        
$query .= $split[count($split) - 1];
        return 
$query;
    }

    function 
drop($exception$query$file$line){
        
//DebugUtils::debug("doe hier wat mee: ".mysql_errno());
        
if(strstr($exception"Duplicate entry")) {
//            if(preg_match('/^\d+: Duplicate entry \'(.*)\' for key \d+$/i', $exception, $matches)) {
            
if(preg_match('/^Duplicate entry \'(.*)\' for key \'(.*)\'$/i'$exception$matches)) {
                
$field $matches[2];
                
$value $matches[1];
                throw new 
DuplicateException($exception$field$value);
            }
            
        }
        
Logger::error("Er is een database fout opgetreden:<br/><br/> :".@query.
            
" ".$exception$file$line);        
        if(
_DEBUG) {
            
DebugUtils::debug("Er is een database fout opgetreden:<br/><br/> ".$exception);
            
DebugUtils::debug("Query:<br/>".$query);
            
DebugUtils::printException(new Exception($exception));
        }
//        global $smarty;
//        $smarty->assign('page', 'error');
//        $smarty->display('main.tpl');
//        exit();
//        throw new RuntimeException($exception);
    
}
}


?>

 
PreparedQuery
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
<?php
include_once PHP_CLASS.'cache/Cache.class.php';
include_once 
PHP_CLASS.'entities/db/PreparedQuery.class.php';
include_once 
PHP_CLASS.'entities/db/TableIndex.class.php';
include_once 
PHP_CLASS.'entities/db/Column.class.php';

class 
Table{
    private 
$table;
    private 
$database;
    private 
$columns = array();
    private 
$indexes = array();
    private 
$keyColumn = -1;

    private 
$ownerColumn null;
    private 
$otherUserColumn null;
    private 
$lastUpdateColumn null;
    private 
$insertDateColumn null;
    private 
$foreignkeys = array();

    const 
OWNER_COLUMN "ownerColumn";
    const 
OTHER_USER_COLUMN "otherUserColumn";
    const 
LASTUPDATE_COLUMN "lastupdateColumn";
    const 
INSERT_DATE_COLUMN "insertDateColumn";

    function 
Table($database$table) {
        
$this->database $database;
        
$this->table $table;
        
$this->loadIndexData();
        
$this->loadColumnData();
        
$this->loadTableInfoFromXML();
        
$this->checkColumns();
    }

    
/**
     * Nu alle velden bekend zijn, kijk dan of de informatie uit database.xml
     * klopt.
     */
    
function checkColumns() {
        if(
$this->ownerColumn != null) {
            
Utils::assertTrue("Invalid column in database.xml: ".$this->table".".$this->ownerColumn,
                
$this->hasColumn($this->ownerColumn));
        }
        if(
$this->lastUpdateColumn != null) {
            
Utils::assertTrue("Invalid column in database.xml: ".$this->table".".$this->lastUpdateColumn,
                
$this->hasColumn($this->lastUpdateColumn));
        }
        if(
$this->insertDateColumn != null) {
            
Utils::assertTrue("Invalid column in database.xml: ".$this->table".".$this->insertDateColumn,
                
$this->hasColumn($this->insertDateColumn));
        }
    }
    
    public function 
getForeignKeys() {
        return 
$this->foreignkeys;
    }

    function 
loadTableInfoFromXML(){
        
$xml= new XMLReader();
        
$xml->open(DATABASE_XML);
         
$xml->read(); // Skip root node
         
         
$current_database "";
         
$current_table "";
         
$found false;
         while(
$xml->read()) {
             switch(
$xml->name) {
                 case 
'database':
                     
$current_database $xml->getAttribute('name');
                     
$xml->read();
                     break;

                 case 
'table':
                     if(
$found) {
                         
$xml->close();
                         return 
true;
                     }
                     
$current_table $xml->getAttribute('name');
                     if(
$current_database == $this->database &&
                         
$current_table == $this->table) {
                             
$this->ownerColumn $xml->getAttribute(self::OWNER_COLUMN);
                             
$this->otherUserColumn $xml->getAttribute(self::OTHER_USER_COLUMN);
                             
$this->lastUpdateColumn $xml->getAttribute(self::LASTUPDATE_COLUMN);
                             
$this->insertDateColumn $xml->getAttribute(self::INSERT_DATE_COLUMN);
                             
$found true;
//                             $xml->close();
//                             return true;
                     
}
                     
$xml->read();
                     
//echo "#".$current_table;
                     
break;
                 
                 case 
'foreignkey':
                     
                     
$key $xml->getAttribute('column');
                     
$table $xml->getAttribute('table');
//                     echo "##FOREIGNKEYS:".$table.".".$key;
                     
$this->foreignkeys[$key] = $table;
                     
$xml->read();
                     break; 
             }
         }

         
$xml->close();
        throw new 
RuntimeException("Tabel '$this->database.$this->table' niet in database.xml");
         return 
true;
    }

    
/**
     * @todo Filecahce gebruiken hier?
     *
     */
    
function loadIndexData() {
        
$db = new PreparedQuery($this->database);
        
$query "SHOW keys FROM ".$this->database.".".$this->table;
        
$db->setQuery($query);
        
$rs $db->execute();

        
Utils::assertTrue("No indexes defined (so no primary?!) on table: "
            
.$this->getDatabaseName().".".$this->getTableName(), count($rs) > 0);
        
$index_type '';
        
$list = array();
        foreach(
$rs as $key=>$index) {
            
$index_name $index['Key_name'];
            if (
$index['Index_type'] == 'FULLTEXT') {
                
$index_type 'FULLTEXT';
            } else if (
$index_name == 'PRIMARY') {
                
$index_type 'PRIMARY';
                
$this->keyColumn $index['Column_name'];
            } else if (
$index['Non_unique'] == '0') {
                
$index_type 'UNIQUE';
            } else {
                
$index_type 'INDEX';
            }
            if(isset(
$list[$index_name])) {
                
$temp = (object)$list[$index_name]; // TableIndex
                
$temp->addColumn($index['Column_name']);
            } else {
                
$temp = new TableIndex($index_name$index_type);
                
$temp->addColumn($index['Column_name']);
                
$list[$index_name] = $temp;
            }
        }
        
$this->indexes $list;
    }

    function 
loadColumnData() {
        
$query "DESCRIBE ".$this->database.".".$this->table;
        
$db = new PreparedQuery($this->database);
        
$db->setQuery($query);
        $rs $db->execute();
        
$index_type '';
        
$list = array();
        foreach(
$rs as $index=>$column) {
            
$this->columns[$column['Field']] = new Column($column['Field'], $column['Type'], $column['Null']);
        }
    }

    function 
getIndexes() {
        return 
$this->indexes;
    }

    function 
getTableName() {
        return 
$this->table;
    }

    function 
getDatabaseName() {
        return 
$this->database;
    }

    function 
getColumns() {
        return 
$this->columns;
    }
    
    function 
getColumn($column) {
        if(!empty(
$this->columns[$column])) {
            return 
$this->columns[$column];
        }
        return 
null;
    }

    function 
getKeyColumn() {
        return 
$this->keyColumn// Primary key
    
}

    function 
hasColumn($columnName) {
        return isset(
$this->columns[$columnName]);
    }

    function 
hasOwnerColumn() {
        return isset(
$this->ownerColumn);
    }
    
    function 
getOwnerColumn() {
//        if(!$this->hasOwnerColumn()) {
//            throw new Exception(
//            'No owner column specified in database.xml on table: '.
//            $this->database.".".$this->table);
//        }
        
return $this->ownerColumn;
    }
    
    function 
hasOtherUserColumn() {
        return isset(
$this->otherUserColumn);
    }
    
    function 
getOtherUserColumn() {
        return 
$this->otherUserColumn;
    }

    function 
getLastUpdateColumn() {
        return 
$this->lastUpdateColumn;
    }

    function 
getInsertDateColumn() {
        return 
$this->insertDateColumn;
    }
}
?>

 
Table
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
<?php
include_once PHP_CLASS.'cache/Cache.class.php';
include_once 
PHP_CLASS.'entities/db/PreparedQuery.class.php';
include_once 
PHP_CLASS.'entities/db/TableIndex.class.php';
include_once 
PHP_CLASS.'entities/db/Column.class.php';

class 
Table{
    private 
$table;
    private 
$database;
    private 
$columns = array();
    private 
$indexes = array();
    private 
$keyColumn = -1;

    private 
$ownerColumn null;
    private 
$otherUserColumn null;
    private 
$lastUpdateColumn null;
    private 
$insertDateColumn null;
    private 
$foreignkeys = array();

    const 
OWNER_COLUMN "ownerColumn";
    const 
OTHER_USER_COLUMN "otherUserColumn";
    const 
LASTUPDATE_COLUMN "lastupdateColumn";
    const 
INSERT_DATE_COLUMN "insertDateColumn";

    function 
Table($database$table) {
        
$this->database $database;
        
$this->table $table;
        
$this->loadIndexData();
        $this->loadColumnData();
        
$this->loadTableInfoFromXML();
        
$this->checkColumns();
    }

    
/**
     * Nu alle velden bekend zijn, kijk dan of de informatie uit database.xml
     * klopt.
     */
    
function checkColumns() {
        if(
$this->ownerColumn != null) {
            
Utils::assertTrue("Invalid column in database.xml: ".$this->table".".$this->ownerColumn,
                
$this->hasColumn($this->ownerColumn));
        }
        if(
$this->lastUpdateColumn != null) {
            
Utils::assertTrue("Invalid column in database.xml: ".$this->table".".$this->lastUpdateColumn,
                
$this->hasColumn($this->lastUpdateColumn));
        }
        if(
$this->insertDateColumn != null) {
            
Utils::assertTrue("Invalid column in database.xml: ".$this->table".".$this->insertDateColumn,
                
$this->hasColumn($this->insertDateColumn));
        }
    }
    
    public function 
getForeignKeys() {
        return 
$this->foreignkeys;
    }

    function 
loadTableInfoFromXML(){
        
$xml= new XMLReader();
        
$xml->open(DATABASE_XML);
         
$xml->read(); // Skip root node
         
         
$current_database "";
         
$current_table "";
         
$found false;
         while(
$xml->read()) {
             switch(
$xml->name) {
                 case 
'database':
                     
$current_database $xml->getAttribute('name');
                     
$xml->read();
                     break;

                 case 
'table':
                     if(
$found) {
                         
$xml->close();
                         return 
true;
                     }
                     
$current_table $xml->getAttribute('name');
                     if(
$current_database == $this->database &&
                         
$current_table == $this->table) {
                             
$this->ownerColumn $xml->getAttribute(self::OWNER_COLUMN);
                             
$this->otherUserColumn $xml->getAttribute(self::OTHER_USER_COLUMN);
                             
$this->lastUpdateColumn $xml->getAttribute(self::LASTUPDATE_COLUMN);
                             
$this->insertDateColumn $xml->getAttribute(self::INSERT_DATE_COLUMN);
                             
$found true;
//                             $xml->close();
//                             return true;
                     
}
                     
$xml->read();
                     
//echo "#".$current_table;
                     
break;
                 
                 case 
'foreignkey':
                     
                     
$key $xml->getAttribute('column');
                     
$table $xml->getAttribute('table');
//                     echo "##FOREIGNKEYS:".$table.".".$key;
                     
$this->foreignkeys[$key] = $table;
                     
$xml->read();
                     break; 
             }
         }

         
$xml->close();
        throw new 
RuntimeException("Tabel '$this->database.$this->table' niet in database.xml");
         return 
true;
    }

    
/**
     * @todo Filecahce gebruiken hier?
     *
     */
    
function loadIndexData() {
        
$db = new PreparedQuery($this->database);
        
$query "SHOW keys FROM ".$this->database.".".$this->table;
        
$db->setQuery($query);
        
$rs $db->execute();

        
Utils::assertTrue("No indexes defined (so no primary?!) on table: "
            
.$this->getDatabaseName().".".$this->getTableName(), count($rs) > 0);
        
$index_type '';
        
$list = array();
        foreach(
$rs as $key=>$index) {
            
$index_name $index['Key_name'];
            if (
$index['Index_type'] == 'FULLTEXT') {
                
$index_type 'FULLTEXT';
            } else if (
$index_name == 'PRIMARY') {
                
$index_type 'PRIMARY';
                
$this->keyColumn $index['Column_name'];
            } else if (
$index['Non_unique'] == '0') {
                
$index_type 'UNIQUE';
            } else {
                
$index_type 'INDEX';
            }
            if(isset(
$list[$index_name])) {
                
$temp = (object)$list[$index_name]; // TableIndex
                
$temp->addColumn($index['Column_name']);
            } else {
                
$temp = new TableIndex($index_name$index_type);
                
$temp->addColumn($index['Column_name']);
                
$list[$index_name] = $temp;
            }
        }
        
$this->indexes $list;
    }

    function 
loadColumnData() {
        
$query "DESCRIBE ".$this->database.".".$this->table;
        
$db = new PreparedQuery($this->database);
        
$db->setQuery($query);
        
$rs $db->execute();
        
$index_type '';
        
$list = array();
        foreach(
$rs as $index=>$column) {
            
$this->columns[$column['Field']] = new Column($column['Field'], $column['Type'], $column['Null']);
        }
    }

    function 
getIndexes() {
        return 
$this->indexes;
    }

    function 
getTableName() {
        return 
$this->table;
    }

    function 
getDatabaseName() {
        return 
$this->database;
    }

    function 
getColumns() {
        return 
$this->columns;
    }
    
    function 
getColumn($column) {
        if(!empty(
$this->columns[$column])) {
            return 
$this->columns[$column];
        }
        return 
null;
    }

    function 
getKeyColumn() {
        return 
$this->keyColumn// Primary key
    
}

    function 
hasColumn($columnName) {
        return isset(
$this->columns[$columnName]);
    }

    function 
hasOwnerColumn() {
        return isset(
$this->ownerColumn);
    }
    
    function 
getOwnerColumn() {
//        if(!$this->hasOwnerColumn()) {
//            throw new Exception(
//            'No owner column specified in database.xml on table: '.
//            $this->database.".".$this->table);
//        }
        
return $this->ownerColumn;
    }
    
    function 
hasOtherUserColumn() {
        return isset(
$this->otherUserColumn);
    }
    
    function 
getOtherUserColumn() {
        return 
$this->otherUserColumn;
    }

    function 
getLastUpdateColumn() {
        return 
$this->lastUpdateColumn;
    }

    function 
getInsertDateColumn() {
        return 
$this->insertDateColumn;
    }
}
?>

 
Table
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?php

class Database {
    private 
$tables null;        // Table objecten
    
private $database null;    // Database naam
    
    
    
function Database($database) {
        
$this->database $database;
    }
    
    public function 
setTables(array $tables) {
        
$this->tables $tables;
    }
    
    public function 
getTableNames() {
        return 
$this->tables;
    }
    
    public function 
getTable($table) { // cachen..?
        return new Table($this->database$table);
    }
}
?>

 
Database
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<?php
include_once(PHP_CLASS."entities/db/Database.class.php");

/**
 * Deze klasse wordt niet meer gebruikt als het goed is. In DatabaseTableModel
 * wordt direct de tabel uit de cache gehaald.
 */
class DBInfo {
    private static 
$DATABASES = array();
    
    public static function 
getTable($database$table) {
        
$db self::getDatabase($database);
        $table $db->getTable($table); // halt hem uit de cache
        
return $table;
    }
    
    public static function 
getDatabase($database) {
        if (!isset(
self::$DATABASES[$database])) {
            
self::$DATABASES[$database] = new Database($database);
        }
        return 
self::$DATABASES[$database];
    }
}
?>

 
DBInfo
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
<?php
include_once(PHP_CLASS."entities/db/DBInfo.class.php");

class 
DatabaseTableModel extends DataModel /** was DataSource */{
    
    private 
$database null;
    private 
$table null;
    private 
$cachedTable null;
    
    public function 
__construct($database$table) {
        
$this->database $database;
        
$this->table $table;
    }
    
    public function 
getTable() {
        
// TODO: cache staat nog uit!
        
if(!($this->cachedTable Cache::get("Table.".$this->database.".".$this->table))) {
            $this->cachedTable DBInfo::getTable($this->database$this->table);
            
Cache::store("Table.".$this->database.".".$this->table$this->cachedTable);
        }
        return 
$this->cachedTable;
    }
    
    public function 
getData() {
        return 
$this->getFields();
    }
    
//    public function getTable() {
//        if($this->cachedTable == null) {
//            DebugUtils::debug("getting table");
//            $this->cachedTable = DBInfo::getTable($this->database, $this->table);
//        }
//        return $this->cachedTable;
//    }
    
}
?>

 
DatabaseTableModel
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
<?php
include_once PHP_CLASS.'searchers/Searcher.class.php';
include_once 
PHP_CLASS.'searchers/ObjectQuery.class.php';
include_once 
PHP_CLASS.'searchers/SearchObject.class.php';
include_once 
PHP_CLASS.'entities/db/DataModel.class.php';
include_once 
PHP_CLASS.'core/Map.class.php';
include_once 
PHP_CLASS.'core/DataSource.class.php';
include_once 
PHP_CLASS.'entities/db/AbstractDatabaseTableModel.class.php';
include_once 
PHP_CLASS.'entities/db/DatabaseTableModel.class.php';
include_once 
PHP_CLASS.'format/Format.class.php';
include_once 
PHP_CLASS.'entities/db/Table.class.php';
include_once 
PHP_CLASS.'utils/DateUtils.class.php';
include_once 
PHP_CLASS.'html/HTMLRenderer.class.php';
include_once 
PHP_CLASS.'html/DefaultHTMLRenderer.class.php';
include_once 
PHP_CLASS.'html/hasHtmlRenderer.class.php';
include_once 
PHP_CLASS.'entities/db/PersistentEntity.class.php';

class 
Entity extends AbstractDatabaseTableModel implements hasHtmlRenderer {

    public 
$user;
    public 
$otherUser;
    
    private 
$table null// Table object
    
private $systemid = -1;
    private 
$EMPTY_SYSTEMID = -1;

    private 
$database null;
    private 
$result null;
    private 
$systemidField null// Kolom naam voor systemid
    
private $useridField null// Kolom naam voor userid
    
private $loadSearcher null;
    private 
$htmlRenderer null;
    
    protected 
$skipImportValidation false;

    public 
$ownerColumn null;
    private 
$wasNew true;

    public function 
__construct(DataModel $model) {
        
$this->datamodel $model;
        
$this->loadSearcher = new LoadSearcher($this);
    }
    
    public function 
setSkipImportValidation($bool) {
        
$this->skipImportValidation $bool;
    }
    
    protected function 
getMasks() {
        return array();
    }
    
    public function 
getMask($field) {
        
$mask $this->getMasks();
        if (isset(
$mask[$field])) {
            return 
$mask[$field];
        }
        return 
null;
    }
    
    public function 
getUrl() {
        
//return VisitableUtils::getUrl($this);
        
throw new IllegalStateException("Not yet implemented!");
    }
    
    
/**
     * Voor i18n met Smarty
     */
    
function L($message$params=null){ 
        global 
$smarty;
        
//smarty_gettext_strarg(array("naam"=>"Jantine"), $message, $smarty);
        
return smarty_block_t($params$message$smarty);
    }
    
    public function 
getDefaultSearcher() {
        
//throw new UnsupportedMethodExeption("This method has not been overridden.");
        
return ObjectQuery::buildACS($this$this->getUser());
    }

    public function 
setKey($systemid){
        
$keyColumn $this->getTable()->getKeyColumn();
        
Utils::assertTrue("No keyColumn specified in database.xml"$keyColumn);
        
$this->datamodel->put($keyColumn$systemid);
        
$this->systemid $systemid;
    }

    public function 
getKey(){
        
//return $this->datamodel->get($this->getTable()->getKeyColumn());
        
return $this->systemid;
    }
    
    public function 
getHTML($what) {
        if (
$this->htmlRenderer == null) {
            
$this->htmlRenderer $this->getHtmlRenderer();
        }
        return 
$this->htmlRenderer->get($what);
    }
    
    public function 
getHtmlRenderer() {
         return new 
DefaultHTMLRenderer($this); 
    }
    
    public function 
setFormat($field$format) {
        
$this->formats[$field] = new Format($format);
    }
    
    
/**
     * @todo wordt niet meer gebruit, weghalen
     */
    
public function getKeyColumn() {
        
Utils::assertNotNull("table == null (no database and/or table info specified)",
            
$this->getTable());
        return 
$this->getTable()->getKeyColumn();
    }

    public function 
removeKey() {
        
$this->datamodel->remove($this->getTable()->getKeyColumn());
        
$this->systemid $this->EMPTY_SYSTEMID;
    }

    public function 
putCol($col$value) {
        
Utils::assertTrue("No column '".$col."' in table: ".$this->getTable()->getDatabaseName().".".$this->getTable()->getTableName(), $this->getTable()->hasColumn($col));
        
$this->put($col$value);
    }
    
    function 
getFormat($key) {
        if(!empty(
$this->formats[$key])) {
            return 
$this->formats[$key];
        }
        return 
null;
    } 
    
    function 
put($key$value) {
        
$format $this->getFormat($key);
        if(
$format != null) {
            
$format->setValue($value);
            
$value $format->parse();
        }
        
$this->datamodel->put($key$value);
    }
    
    public function 
getUser() {
        if (
$this->user instanceof SystemUser) {
            
$ownerColumn $this->getTable()->getOwnerColumn();
            if (
$ownerColumn == null) {
                return 
$this->user;
            }
            
$systemid $this->get($ownerColumn);
            
$user UserFactory::getUserBySystemid($systemid);
            
$this->setUser($user);
        }
        return 
$this->user;
    }
    
    public function 
setUser($user) {
        
$this->user $user;
    }
    
    public function 
getOtherUser() {
        
$otherUserColumn $this->getTable()->getOtherUserColumn();
        
$systemid $this->get($otherUserColumn);
        
$user UserFactory::getUserBySystemid($systemid);
        
$this->setOtherUser($user);
    }
    
    public function 
setOtherUser($user) {
        
$this->otherUser $user;
        
$otherUserColumn $this->datamodel->getTable()->getOtherUserColumn();
        if (
$user == null) {
            
$this->datamodel->put($otherUserColumnnull);
        } else {
            
$this->datamodel->put($otherUserColumn$user->getKey());
        }
    }
    
    
/**
     * For example to get spots from a user in User.class you would type: 
     *     return $this->getObjectByForeignKe(new MySpots, "user")   
     */
    
function getObjectsByForeignKey(Entity $type$foreignColumn$extraConstraints null$limitStart null$limitEnd null) {
        if(
$this->isNew()) {
            throw new 
IllegalStateException("Can't get foreign objects of a new instance'");
        }
        
$oq ObjectQuery::buildACS(new $type(), $this->getUser());
        
$oq->addConstraint(Constraint::eq($foreignColumn$this->getKey()));
        if (
$extraConstraints != null) {
            
$oq->addConstraint($extraConstraints);
        }
        if(
$limitStart != null) {
            
$oq->setLimit($limitStart);
            if(
$limitEnd != null) {
                
$oq->setLimit($limitStart$limitEnd);
            }
        }
        return 
SearchObject::search($oq);
    }
    
    function 
loadEntityByForeignKey(Entity $type$column) {
        
$systemid $this->getInt($column, -1);
        if (
$systemid == -1) {
            return 
null;            
        }
        
$systemUser UserFactory::getSystemUser();
        return 
EntityFactory::loadEntity(new $type(), $systemUser$systemid);
        
    }

    
/**
     * Check of er met de huidige data in de entity een unieke index
     * te vinden is. Hiervoor worden de indexes opgehaald en gekeken of
     * er tenminste een van de indexen voldoende data bevat om een
     * unieke index te vinden.
     */
    
private function canLoad() {
        
        if(
$this->getTable()->hasOwnerColumn() && $this->getUser() == null) {
            throw new 
RuntimeException("user == null");
        }
        
$list $this->getTable()->getIndexes();
        
$bCanLoad false;
        foreach(
$list as $index) {
            
$indexCols $index->getIndexColumnNames();

            
$bAllColsFilled false;
            foreach(
$indexCols as $col) {
                if(
$this->datamodel->get($col) != null){
                    
$bAllColsFilled true;
                } else {
                    
$bAllColsFilled false;
                    break;
                }
            }
            if(
$bAllColsFilled) {
                
$bCanLoad true;
                break;
            }
        }
        return 
$bCanLoad;
    }

    function 
getTableName() {
        return 
$this->getTable()->getTableName();
    }

    public function 
getDatabaseName() {
        return 
$this->getTable()->getDatabaseName();
    }
    
    public function 
getTable() {
        return $this->datamodel->getTable();
    }

    private function 
checkKeyColumns() {
        
Utils::assertTrue("Niet genoeg data om een " .
                
"unieke index te vinden bij het laden van entiteit '".
                
$this->getTable()->getDatabaseName().".".$this->getTable()->getTableName()."'"$this->canLoad());
    }

    private function 
loadBySystemid() {
        
$db = new PreparedQuery($this->getTable()->getDatabaseName());
        
$db->setSelect("FROM " $this->getTable()->getTableName());
        
$db->setSelectFields("*");
        
$foreignkeys $this->getTable()->getForeignKeys();        
        if(
count($foreignkeys) > 0) {
            foreach(
$foreignkeys as $column=>$table) {
                
$db->addJoin($table$column);
            }
        }
        
$db->addFilter($this->getTableName().".".$this->getTable()->getKeyColumn(), $this->getKey());
        
$ownerColumn $this->getTable()->getOwnerColumn();
        if(
$ownerColumn != null) {
            
$db->addFilter($ownerColumn$this->getUser()->getKey());
        }
        
$rs $db->execute();
        if(
$rs[0] == null) {
            return 
null;
        }
        
$this->datamodel->putAll($rs[0]);
    }

    
/**
     * load - Een Entity laden.
     * Bij een load moet nog een user opgegevens worden. Of niet? Namelijk bij niet ingelogde gebruikers
     * moet het niet nodig zijn, afhankelijk dus van wat er geladen wordt.
     */
    
public function load(){
        
$oq ObjectQuery::build($this$this->getUser());
        
$oq->addParameters($this->datamodel->getData());
        
$oq->setSearcher($this->getLoadSearcher());
        
$obj SearchObject::select($oq);
        if(
$obj == null) {
            throw new 
RuntimeException("Not able to load entity with systemid:".$this->getKey().
             
"(".$this->getTable()->getDatabaseName().".".$this->getTable()->getTableName().") with userid: " .
             
$this->getUser()->getKey());
        }
        
$this->datamodel->putAll($obj);
        if(
$this->datamodel->get($this->getTable()->getKeyColumn()) != null) {
            
$this->systemid $this->datamodel->get($this->getTable()->getKeyColumn());
        }
        
//Utils::assertNotEmpty($rs[0], " Dit ding bestaat niet en kan niet geladen worden ");
    
}
//    public function load(){
//        if($this->getKey() != -1) {
//            $this->loadBySystemid();
//            return;
//        }
//        $this->checkKeyColumns();
//        $user = $this->getUser();
//        $db = new PreparedQuery($this->getTable()->getDatabaseName());
//        $db->addField("*");
//        $db->setTable($this->getTable()->getTableName());
//        $foreignkeys = $this->getTable()->getForeignKeys();        
//        if(count($foreignkeys) > 0) {
//            //DebugUtils::debug($foreignkeys);
//            foreach($foreignkeys as $column=>$table) {
//                $db->addJoin($table, $column);
//            }
//        }
//        $db->addAllFields($this->datamodel->getAll());
//        $rs = $db->execute();
//        if($rs[0] == null) {
//            $this->systemid = $this->EMPTY_SYSTEMID;
//            //throw new EntityException("No record found!");
//            return null;
//        }
//        $this->datamodel->putAll($rs[0]);
//        if($this->datamodel->get($this->getTable()->getKeyColumn()) != null) {
//            $this->systemid = $this->datamodel->get($this->getTable()->getKeyColumn());
//        }
//        //Utils::assertNotEmpty($rs[0], " Dit ding bestaat niet en kan niet geladen worden ");
//    }

    /**
     * Een entiteit laden aan de hand van gegevens. Dus niet alleen
     * op Index-waardes zoeken.
     *
     */
    
public function find(){
        
$this->load();
        return 
$this->isNew();
    }

    private function 
clear(){
        
$data $this->datamodel->getAll();
        foreach (
$data as $key) {
            
$this->datamodel->remove($key);
        }
    }
    
    public function 
getFields() {
        return 
$this->datamodel->getAll();
    }

    public function 
isNew(){
        
$key $this->datamodel->get($this->getTable()->getKeyColumn());
        return empty(
$key);
    }
    
    public function 
wasNew() {
        return 
$this->wasNew;
    }

    
/**
     * Overriden wanneer nodig
     */
    
public function validate(){}

    
/**
     * @WebAction
     */
    
public function save() {
        
$this->validate();
        
$systemid $this->getKey();
        if(
$systemid != -1) {
            
$this->update();
            
$this->wasNew false;
        } else {
            
$this->insert();
            
$this->wasNew true;
        }
        if (
$this instanceof NotificationEntity ) {
            include_once 
PHP_CLASS.'entities/notification/NotificationExecutor.class.php';
            
NotificationExecutor::handle($this);
        }
        
$this->loadBySystemid();
        
    }
    
    public function 
setLoadSearcher(Searcher $searcher) {
        
$this->loadSearcher $searcher;
    }
    
    public function 
getLoadSearcher() {
        return 
$this->loadSearcher;
    }

    public function 
delete() {
        
$this->checkKeyColumns();
        
$user $this->getUser();
        
$pq = new PreparedQuery($this->getTable()->getDatabaseName());
        
$table $this->getTable();
        
$pq->setDelete($table->getTableName());
        
$pq->addFilter($table->getKeyColumn(), $this->getKey());
        if (
$table->hasOwnerColumn()) {
            
$pq->addFilter($table->getOwnerColumn(), $user->getKey());
        }
        
Utils::assertTrue("Cannot delete entity when systemid == -1"$this->getKey() > $this->EMPTY_SYSTEMID);
//        if ($this->getKey()) {
//            $db->addFilter("systemid", $this->getKey());
//        } else {
//            $db->addAllFields($this->getFields());
//        }
        
$pq->execute();
    }

    
/**
     * Hebben we hier wat aan? In het volgende geval misschien: je maakt een
     * nieuwe entity aan, put wat waardes en dan maakt het je niet uit of
     * je een nieuwe aanmaakt of misschien een bestaande overschrijft.
     * Weghalen?
     */
    
public function replace(){
        throw new 
IllegalStateException("Not implemented");
        if(
count($this->datamodel->getAll()) < 1){
            return 
false;
        }
        if(
$this->find()){
            
$this->insert();
            
$this->load();
        }
        else {
            
$this->update();
        }
    }
    
    private function 
insert(){
        if(
$this->getTable()->hasOwnerColumn()) {
            
Utils::assertNotNull("user == null"$this->user);
        }
        
        
$pq = new PreparedQuery($this->getTable()->getDatabaseName());
        
$pq->setInsert($this->getTable()->getTableName());
        
$data $this->datamodel->getAll();
        foreach(
$data as $key=>$value){
            if(!
$this->getTable()->hasColumn($key)){
                continue;
            }
            
$col $this->getTable()->getColumn($key);
            if(
$key == $this->getTable()->getKeyColumn() ||
                
$key == $this->getTable()->getInsertDateColumn()){
                continue;
            }
            
$colType $col->getType();
            
$fields $this->getFields();
            
$isSet = isset($fields[$key]);
            
$value$this->datamodel->get($key);
            
            if (
$col->isNullable() && Utils::isEmpty($value)) {
//                echo " Leeg, skipping..";
                
$pq->addInsertField($keynull);
            } elseif (
$colType == ColumnType::$TINYINT && is_bool($value)) {
                
$pq->addInsertField($key$value );
            } else {
                
$pq->addInsertField($key$value);
            }
        }
        
$ownerColumn $this->getTable()->getOwnerColumn();
        if(!
Utils::isEmpty($ownerColumn)) {
            
$pq->addInsertField($ownerColumn$this->user->getKey());
        }
        
$insertdateColumn $this->getTable()->getInsertDateColumn();
        if(!
Utils::isEmpty($insertdateColumn)) {
            
$pq->addInsertField($insertdateColumnDateUtils::now());
        }
        
$lastupdateColumn $this->getTable()->getLastUpdateColumn();
        if(!
Utils::isEmpty($lastupdateColumn)) {
            
$pq->addInsertField($lastupdateColumnDateUtils::now());
        }
        
$systemid $pq->execute();
        
$this->setKey($systemid);
    }

    private function 
putIfEmpty($col$value) {
        
$type $col->getType();
        switch (
$type) {
            case 
ColumnType::$INT
            case 
ColumnType::$DECIMAL:
                if (empty(
$value)) {
                    return 
false
                }
                break;
            default:
                return 
true;
        }
    }

    private function 
update(){
        
Utils::assertNotEmpty("systemidField == null"$this->getTable()->getKeyColumn());
        
Utils::assertNotEmpty"systemid == null"$this->getKey());
        
$pq = new PreparedQuery($this->getTable()->getDatabaseName());
        
$pq->setUpdate($this->getTable()->getTableName());
        
$pq->addFilter($this->getTable()->getKeyColumn(), $this->getKey());
        
$data $this->datamodel->getAll();
        foreach(
$data as $key=>$value){
            if(!
$this->getTable()->hasColumn($key)){
                continue;
            }
            
$col $this->getTable()->getColumn($key);
            if(
$key == $this->getTable()->getKeyColumn() ||
                
$key == $this->getTable()->getInsertDateColumn()){
                continue;
            }
            
$colType $col->getType();
            
$fields $this->getFields();
            
$isSet = isset($fields[$key]);
            
$value$this->datamodel->get($key);
            
//if ($isSet && ($value == "" ||  $value == null)) {
            
if ($isSet && (empty($value) &&  $value != 0)) {
                if (
$colType ==  ColumnType::$INT || $colType ==  ColumnType::$DECIMAL || $colType ==  ColumnType::$DATETIME) {
                    if (
$col->isNullable()) {
                        
$value null;
                    }
                }
            }
            
            
            if (
$col->isNullable() && (empty($value) &&  $value != 0)) {
//                echo " Leeg, skipping..";
                
$pq->addUpdateField($keynull);
            }  elseif (
$colType == ColumnType::$TINYINT) {
                if (
is_bool($value)) {
                    
$pq->addUpdateField($key$value );
                } else {
                    
$pq->addUpdateField($key$this->get($key));
                }
            } else {
                
$pq->addUpdateField($key$this->get($key));
                
            }
        }
        
$ownerColumn $this->getTable()->getOwnerColumn();
        if(!
Utils::isEmpty($ownerColumn)) {
            
$pq->addFilter($ownerColumn$this->user->getKey());
        }
        
$lastupdateColumn $this->getTable()->getLastUpdateColumn();
        if(!
Utils::isEmpty($lastupdateColumn)) {
            
$pq->addUpdateField($lastupdateColumnDateUtils::now());
        }
        
$pq->execute();
    }

}

class 
LoadSearcher extends Searcher {
    protected 
$entity null;
    
    public function 
__construct(Entity $ent) {
        
$this->entity $ent;
    }
    
    public function 
getFields(DataSource $ds) {
        
$table $this->entity->getTable()->getTableName();
        return 
"*, ".$table.".systemid AS systemid"// ivm met joines
    
}
    
    public function 
getTables(DataSource $ds) {
        
$table $this->entity->getTable()->getTableName();
        
$select " FROM $table ";
//        DebugUtils::debug("jaaaaaaaaa");
        
return $select;
    }
    
    public function 
getFilter(DataSource $ds) {
        
$table $this->entity->getTable()->getTableName();
        
$list = new QueryConstraintList();
        
Utils::assertTrue("cannot load entity with systemid = -1"$this->entity->getKey() != -1);
        
$list->addKey($table.".systemid"$this->entity->getKey());
        return 
$list;
    }
}
?>

 
Entity
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
<?php
include_once PHP_CLASS.'searchers/ACSearcher.class.php';

class 
ObjectQuery{

/** TODO: implementeren dat ie alleen op de juiste owner zoekt */
    
private $user null;
    private 
$clazz =  null;
    private 
$searcher null// Searcher object
    
private $limit null;
    private 
$constraints = array();
    private 
$parameters;
    private 
$groupBy null;
    private 
$orderBy null;
    private 
$countRows false;
    private 
$noOfResults;
    private 
$joins = array();
    
    private static 
$pq null;

    function 
__construct(User $user null) {
        
$this->user $user;
        
$this->parameters = new DataSource();
    }
    
    function 
setGroupBy($groupBy) {
        
$this->groupBy $groupBy;
    }
    
    public function 
setCountRows($count) {
        
$this->countRows $count;
    }
    
    public function 
getCountRows() {
        return 
$this->noOfResults;
    }
    
    static function 
build(Entity $clazzUser $user null$limit null) {
        
$os = new ObjectQuery($user);
        
$os->setTarget($clazz);
        if(
$limit) {
            
$os->setLimit($limit);
        }
        return 
$os;
    }
    
    public function 
getUser() {
        return 
$this->user;
    }
    
    public function 
addJoin(Join $join) {
        
$this->joins []= $join
    }

    static function 
buildACS(Entity $clazzUser $user$limit null) {
            $searcher = new ACSearcher($clazz->getTable());
            
$os ObjectQuery::build($clazz$user$limit);
            
$os->setSearcher($searcher);
            return 
$os;
    }
    
    static function 
buildDS(Entity $clazzUser $user$limit null) {
            
$searcher $clazz->getDefaultSearcher();
            
$os ObjectQuery::build($clazz$user$limit);
            
$os->setSearcher($searcher);
            return 
$os;
    }

    function 
setLimit($limit$end null) {
        
$this->limit intval($limit);
        if(
$end != null ) {
            
$this->limit .= "," intval($end);
        }
    }

    function 
addConstraint(QueryConstraint $constraint) {
        
$this->constraints[] = $constraint;
    }
    
    function 
addIf(QueryConstraint $constraint$value) {
        if(
$this->ifCondition($value)) {
            
$this->addConstraint($constraint);
        }
    }

    function 
setTarget($clazz) {
        
$this->clazz $clazz;
    }
    
    function 
getTarget() {
        return 
$this->clazz;
    }

    
/**
     * Parameters meegeven. Deze worden niet in de ACSearcher gebruikt, wel in
     * de andere.
     */
    
function addParameter($key$value) {
        
$this->parameters->put($key$value);
    }
    
    function 
setOrderBy($orderby) {
        
$this->orderBy $orderby;
    }
    
    function 
addIfParameter($key$value) {
        if(
$this->ifCondition($value)) {
            
$this->parameters->put($key$value);
        }
    }
    
    function 
addParameters($params) {
        
$this->parameters->putAll($params);
    }

    function 
setSearcher(SearcherInterface $searcher) {
        
Utils::assertTrue("Searcher already set!"$this->searcher == null);
        
$this->searcher $searcher;
    }

    
/**
     * Geef een list met entiteiten terug
     */
    
function execute() {
        
Utils::assertNotNull("No searcher specified"$this->searcher);
        
$dbName $this->clazz->getTable()->getDatabaseName();
        
self::$pq = new PreparedQuery($dbName);

        
$tables $this->searcher->getTables($this->parameters);
        
        
        
//$select = $this->searcher->getFields($this->parameters);
        
        
        
foreach ($this->joins as $join) {
            
$tables .= " LEFT JOIN ".$join->getTable()." ON ".$join->getColumn().
            
" = ".$join->getTable().".systemid ";
        }
        
self::$pq->setSelect($tables);
        
$fields $this->searcher->getFields($this->parameters);
        
self::$pq->setSelectFields($fields);

        
$list = new QueryConstraintList();
        
$c $this->searcher->getFilter($this->parameters);
        
Utils::assertNotNull("no constraints == null! (getFilter == null)"$c);
        if(
$c != null) {
            
$list->add($c);
        }
        foreach (
$this->constraints as $constraint) {
            
$list->add($constraint);
        }

        
$ownerColumn $this->clazz->getTable()->getOwnerColumn();
        if(
$ownerColumn == null) {
            
Utils::assertTrue("No authorisation to load data on a table without usercolumn with this user:".$this->getUser()->getKey(), $this->user instanceof SystemUser);
            if(
defined(DEBUG_QUERY)) {
                
DebugUtils::debug("[query zonder usercolumn]");
            }
        } else {
            
Utils::assertNotEmpty("Geen user geladen"$this->user);
            
Utils::assertNotEmpty("Geen user geladen"$this->user->getKey());
//            if(!UserFactory::isSystemUser($this->user)) {
            
if(!$this->user instanceof SystemUser) {
                
$list->addKey($this->clazz->getTable()->getTableName().".".$ownerColumn$this->user->getKey());
            }
        }
        
        
self::$pq->addConstraint($list);         
        
// Query via PreparedQuery opbouwen
        // Zie PreparedQuery::$COUNT_ROWS_SQL
        
if($this->countRows) {
            
//$query .= PreparedQuery::$COUNT_ROWS_SQL." ";
            
self::$pq->setSelectFields(PreparedQuery::$COUNT_ROWS_SQL " " $fields);
            
self::$pq->setCountRows(true);
        }

        
$groupby ""
        
$searcherGroupBy " ".$this->searcher->getGroupBy($this->parameters);;
        if(
$this->ifCondition($searcherGroupBy)) {
            
$groupby " GROUP BY ".$searcherGroupBy;
        }
        if(
$this->ifCondition($this->groupBy)) {
            if(empty(
$groupby)) {
                
$groupby .= " GROUP BY ".$this->groupBy;
            } else {
                
$groupby $this->groupBy;
            }
        }
        if(!empty(
$groupby)) {
            
self::$pq->setGroupBy($searcherGroupBy);
        }
//        $query .= $groupby;
        
        
$orderby " ".$this->searcher->getOrderBy($this->parameters);;
        if(
$this->ifCondition($orderby)) {
            
self::$pq->setOrderBy($orderby);
//            $orderby = " ORDER BY ".$orderby;
        
}
        if(
$this->ifCondition($this->orderBy)) {
            
self::$pq->setOrderBy($this->orderBy);
//            $orderby = " ORDER BY ".$this->orderBy;
        
}

        if(
$this->ifCondition($this->limit)) {
            
self::$pq->setLimit($this->limit);
            
//$query .= " LIMIT ".$this->limit;
        
}
        
$rs self::$pq->execute(__FILE____LINE__);
        
        if(
$this->countRows) {
            
$this->noOfResults self::$pq->getNoFoundRows();
        }
        
        return 
$rs;
    }

     private function 
ifCondition($s) {
        if(
Utils::isEmpty(trim($s))) {
            return 
false;
        }
        return 
true;
    }
    
    public function 
getLastQuery() {
        return 
self::$pq->getDebugQuery();
    }
}
?>

 
ObjectQuery
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?php

class EntityFactory {

    public static function 
loadEntity(Entity $entUser $user$systemid) {
        $oq ObjectQuery::buildACS($ent$user);
        
$oq->addConstraint(Constraint::eq($ent->getTable()->getKeyColumn(), $systemid));
        return 
SearchObject::select($oq);
    }
    
    public static function 
deleteEntity(Entity $entUser $user$systemid) {
        
$ent->setUser($user);
        
$ent->setKey($systemid);
        
$ent->delete();
    }
}
?>

 
EntityFactory
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
<?php

abstract class ArticlePage extends Page {
    
    
    
/**
     * @WebAction
     */
    
public function overview() {
        
$this->put("article"$this->getArticle());
    }
    
    
/**
     * @WebAction
     */
    
public function saveArticle() {
        
$article $this->getArticle();
        
$article->setBody($article->getDraft());
        
$article->setDraft("");
        
$article->save();
        
        
header("Location: /" $this->get("page"));
    }
    
    
/**
     * @WebAction
     */
    
public function saveDraft() {
        
$article $this->getArticle();
        
$article->setDraft($this->get("body"));
        
$article->save();
        
        
header("Location: /" $this->get("page"));
    }
    
    public final function 
getArticle() {
        return EntityFactory::loadEntity(new ArticleUserFactory::getSystemUser(), $this->getArticleNr());
    }
    
    abstract function 
getArticleNr();
        
    
    
/**
     * @WebAction
     */
    
public function deleteDraft() {
        
$article $this->getArticle();
        
$article->setDraft("");
        
$article->save();
        
        
header("Location: /" $this->get("page"));
    }
    
    
/**
     * @WebAction
     */
    
public function reset() {
        
$article $this->getArticle();
        
$article->setBody($article->getOriginal());
        
$article->save();

        
header("Location: /" $this->get("page"));
    }
}

?>

 
ArticlePage
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
<?php

abstract class ArticlePage extends Page {
    
    
    
/**
     * @WebAction
     */
    
public function overview() {
        $this->put("article"$this->getArticle());
    }
    
    
/**
     * @WebAction
     */
    
public function saveArticle() {
        
$article $this->getArticle();
        
$article->setBody($article->getDraft());
        
$article->setDraft("");
        
$article->save();
        
        
header("Location: /" $this->get("page"));
    }
    
    
/**
     * @WebAction
     */
    
public function saveDraft() {
        
$article $this->getArticle();
        
$article->setDraft($this->get("body"));
        
$article->save();
        
        
header("Location: /" $this->get("page"));
    }
    
    public final function 
getArticle() {
        return 
EntityFactory::loadEntity(new ArticleUserFactory::getSystemUser(), $this->getArticleNr());
    }
    
    abstract function 
getArticleNr();
        
    
    
/**
     * @WebAction
     */
    
public function deleteDraft() {
        
$article $this->getArticle();
        
$article->setDraft("");
        
$article->save();
        
        
header("Location: /" $this->get("page"));
    }
    
    
/**
     * @WebAction
     */
    
public function reset() {
        
$article $this->getArticle();
        
$article->setBody($article->getOriginal());
        
$article->save();

        
header("Location: /" $this->get("page"));
    }
}

?>

 
Notice: Undefined index: file in /var/www/www.rezanamavar.nl/php-classes/utils/DebugUtils.class.php on line 58 Notice: Undefined index: line in /var/www/www.rezanamavar.nl/php-classes/utils/DebugUtils.class.php on line 59 Warning: mysql_fetch_array() expects parameter 1 to be resource, boolean given in /var/www/www.rezanamavar.nl/php-classes/entities/db/PreparedQuery.class.php on line 467 Reza Namavar - Muziek Componist
English | Nederlands | Francais
Home
Composities
CV
Agenda
Links
Contact

Welkom!

De muziek van Namavar kenmerkt zich door het onverwachte. Door het bekende te vervreemden, te laten ontsporen, zet hij vraagtekens bij vastgeroeste ideeën van de luisteraar. Zijn schijnbare lichtvoetigheid is een complexe constructie van verrassende harmonische wendingen en melodische frasen. De grillige ritmiek geeft de muziek vaak een rusteloos karakter, immer op zoek naar nieuwe horizonten, onontdekte eilandjes van nimmer geproefde combinaties.

Namavar gebruikt nooit citaten. Tenzij vermeld.

                   

 

                                                     

                                                                                   (foto: Tobias Allen )