Subversion-Projekte lars-tiefland.ci

Revision

Revision 2257 | Details | Vergleich mit vorheriger | Letzte Änderung | Log anzeigen | RSS feed

Revision Autor Zeilennr. Zeile
68 lars 1 
<?php
2 
/**
3 
 * CodeIgniter
4 
 *
5 
 * An open source application development framework for PHP
6 
 *
7 
 * This content is released under the MIT License (MIT)
8 
 *
2414 lars 9 
 * Copyright (c) 2014 - 2019, British Columbia Institute of Technology
68 lars 10 
 *
11 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
12 
 * of this software and associated documentation files (the "Software"), to deal
13 
 * in the Software without restriction, including without limitation the rights
14 
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
15 
 * copies of the Software, and to permit persons to whom the Software is
16 
 * furnished to do so, subject to the following conditions:
17 
 *
18 
 * The above copyright notice and this permission notice shall be included in
19 
 * all copies or substantial portions of the Software.
20 
 *
21 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22 
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
24 
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25 
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
26 
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
27 
 * THE SOFTWARE.
28 
 *
29 
 * @package	CodeIgniter
30 
 * @author	EllisLab Dev Team
31 
 * @copyright	Copyright (c) 2008 - 2014, EllisLab, Inc. (https://ellislab.com/)
2414 lars 32 
 * @copyright	Copyright (c) 2014 - 2019, British Columbia Institute of Technology (https://bcit.ca/)
33 
 * @license	https://opensource.org/licenses/MIT	MIT License
68 lars 34 
 * @link	https://codeigniter.com
35 
 * @since	Version 1.0.0
36 
 * @filesource
37 
 */
38 
defined('BASEPATH') OR exit('No direct script access allowed');
39 
 
40 
/**
41 
 * Database Forge Class
42 
 *
43 
 * @category	Database
44 
 * @author		EllisLab Dev Team
45 
 * @link		https://codeigniter.com/user_guide/database/
46 
 */
47 
abstract class CI_DB_forge {
48 
 
49 
	/**
50 
	 * Database object
51 
	 *
52 
	 * @var	object
53 
	 */
54 
	protected $db;
55 
 
56 
	/**
57 
	 * Fields data
58 
	 *
59 
	 * @var	array
60 
	 */
61 
	public $fields		= array();
62 
 
63 
	/**
64 
	 * Keys data
65 
	 *
66 
	 * @var	array
67 
	 */
68 
	public $keys		= array();
69 
 
70 
	/**
71 
	 * Primary Keys data
72 
	 *
73 
	 * @var	array
74 
	 */
75 
	public $primary_keys	= array();
76 
 
77 
	/**
78 
	 * Database character set
79 
	 *
80 
	 * @var	string
81 
	 */
82 
	public $db_char_set	= '';
83 
 
84 
	// --------------------------------------------------------------------
85 
 
86 
	/**
87 
	 * CREATE DATABASE statement
88 
	 *
89 
	 * @var	string
90 
	 */
91 
	protected $_create_database	= 'CREATE DATABASE %s';
92 
 
93 
	/**
94 
	 * DROP DATABASE statement
95 
	 *
96 
	 * @var	string
97 
	 */
98 
	protected $_drop_database	= 'DROP DATABASE %s';
99 
 
100 
	/**
101 
	 * CREATE TABLE statement
102 
	 *
103 
	 * @var	string
104 
	 */
105 
	protected $_create_table	= "%s %s (%s\n)";
106 
 
107 
	/**
108 
	 * CREATE TABLE IF statement
109 
	 *
110 
	 * @var	string
111 
	 */
112 
	protected $_create_table_if	= 'CREATE TABLE IF NOT EXISTS';
113 
 
114 
	/**
115 
	 * CREATE TABLE keys flag
116 
	 *
117 
	 * Whether table keys are created from within the
118 
	 * CREATE TABLE statement.
119 
	 *
120 
	 * @var	bool
121 
	 */
122 
	protected $_create_table_keys	= FALSE;
123 
 
124 
	/**
125 
	 * DROP TABLE IF EXISTS statement
126 
	 *
127 
	 * @var	string
128 
	 */
129 
	protected $_drop_table_if	= 'DROP TABLE IF EXISTS';
130 
 
131 
	/**
132 
	 * RENAME TABLE statement
133 
	 *
134 
	 * @var	string
135 
	 */
136 
	protected $_rename_table	= 'ALTER TABLE %s RENAME TO %s;';
137 
 
138 
	/**
139 
	 * UNSIGNED support
140 
	 *
141 
	 * @var	bool|array
142 
	 */
143 
	protected $_unsigned		= TRUE;
144 
 
145 
	/**
146 
	 * NULL value representation in CREATE/ALTER TABLE statements
147 
	 *
148 
	 * @var	string
149 
	 */
150 
	protected $_null		= '';
151 
 
152 
	/**
153 
	 * DEFAULT value representation in CREATE/ALTER TABLE statements
154 
	 *
155 
	 * @var	string
156 
	 */
157 
	protected $_default		= ' DEFAULT ';
158 
 
159 
	// --------------------------------------------------------------------
160 
 
161 
	/**
162 
	 * Class constructor
163 
	 *
164 
	 * @param	object	&$db	Database object
165 
	 * @return	void
166 
	 */
167 
	public function __construct(&$db)
168 
	{
169 
		$this->db =& $db;
170 
		log_message('info', 'Database Forge Class Initialized');
171 
	}
172 
 
173 
	// --------------------------------------------------------------------
174 
 
175 
	/**
176 
	 * Create database
177 
	 *
178 
	 * @param	string	$db_name
179 
	 * @return	bool
180 
	 */
181 
	public function create_database($db_name)
182 
	{
183 
		if ($this->_create_database === FALSE)
184 
		{
185 
			return ($this->db->db_debug) ? $this->db->display_error('db_unsupported_feature') : FALSE;
186 
		}
1257 lars 187 
		elseif ( ! $this->db->query(sprintf($this->_create_database, $this->db->escape_identifiers($db_name), $this->db->char_set, $this->db->dbcollat)))
68 lars 188 
		{
189 
			return ($this->db->db_debug) ? $this->db->display_error('db_unable_to_drop') : FALSE;
190 
		}
191 
 
192 
		if ( ! empty($this->db->data_cache['db_names']))
193 
		{
194 
			$this->db->data_cache['db_names'][] = $db_name;
195 
		}
196 
 
197 
		return TRUE;
198 
	}
199 
 
200 
	// --------------------------------------------------------------------
201 
 
202 
	/**
203 
	 * Drop database
204 
	 *
205 
	 * @param	string	$db_name
206 
	 * @return	bool
207 
	 */
208 
	public function drop_database($db_name)
209 
	{
210 
		if ($this->_drop_database === FALSE)
211 
		{
212 
			return ($this->db->db_debug) ? $this->db->display_error('db_unsupported_feature') : FALSE;
213 
		}
1257 lars 214 
		elseif ( ! $this->db->query(sprintf($this->_drop_database, $this->db->escape_identifiers($db_name))))
68 lars 215 
		{
216 
			return ($this->db->db_debug) ? $this->db->display_error('db_unable_to_drop') : FALSE;
217 
		}
218 
 
219 
		if ( ! empty($this->db->data_cache['db_names']))
220 
		{
221 
			$key = array_search(strtolower($db_name), array_map('strtolower', $this->db->data_cache['db_names']), TRUE);
222 
			if ($key !== FALSE)
223 
			{
224 
				unset($this->db->data_cache['db_names'][$key]);
225 
			}
226 
		}
227 
 
228 
		return TRUE;
229 
	}
230 
 
231 
	// --------------------------------------------------------------------
232 
 
233 
	/**
234 
	 * Add Key
235 
	 *
236 
	 * @param	string	$key
237 
	 * @param	bool	$primary
238 
	 * @return	CI_DB_forge
239 
	 */
240 
	public function add_key($key, $primary = FALSE)
241 
	{
242 
		// DO NOT change this! This condition is only applicable
243 
		// for PRIMARY keys because you can only have one such,
244 
		// and therefore all fields you add to it will be included
245 
		// in the same, composite PRIMARY KEY.
246 
		//
247 
		// It's not the same for regular indexes.
248 
		if ($primary === TRUE && is_array($key))
249 
		{
250 
			foreach ($key as $one)
251 
			{
252 
				$this->add_key($one, $primary);
253 
			}
254 
 
255 
			return $this;
256 
		}
257 
 
258 
		if ($primary === TRUE)
259 
		{
260 
			$this->primary_keys[] = $key;
261 
		}
262 
		else
263 
		{
264 
			$this->keys[] = $key;
265 
		}
266 
 
267 
		return $this;
268 
	}
269 
 
270 
	// --------------------------------------------------------------------
271 
 
272 
	/**
273 
	 * Add Field
274 
	 *
275 
	 * @param	array	$field
276 
	 * @return	CI_DB_forge
277 
	 */
278 
	public function add_field($field)
279 
	{
280 
		if (is_string($field))
281 
		{
282 
			if ($field === 'id')
283 
			{
284 
				$this->add_field(array(
285 
					'id' => array(
286 
						'type' => 'INT',
287 
						'constraint' => 9,
288 
						'auto_increment' => TRUE
289 
					)
290 
				));
291 
				$this->add_key('id', TRUE);
292 
			}
293 
			else
294 
			{
295 
				if (strpos($field, ' ') === FALSE)
296 
				{
297 
					show_error('Field information is required for that operation.');
298 
				}
299 
 
300 
				$this->fields[] = $field;
301 
			}
302 
		}
303 
 
304 
		if (is_array($field))
305 
		{
306 
			$this->fields = array_merge($this->fields, $field);
307 
		}
308 
 
309 
		return $this;
310 
	}
311 
 
312 
	// --------------------------------------------------------------------
313 
 
314 
	/**
315 
	 * Create Table
316 
	 *
317 
	 * @param	string	$table		Table name
318 
	 * @param	bool	$if_not_exists	Whether to add IF NOT EXISTS condition
319 
	 * @param	array	$attributes	Associative array of table attributes
320 
	 * @return	bool
321 
	 */
322 
	public function create_table($table, $if_not_exists = FALSE, array $attributes = array())
323 
	{
324 
		if ($table === '')
325 
		{
326 
			show_error('A table name is required for that operation.');
327 
		}
328 
		else
329 
		{
330 
			$table = $this->db->dbprefix.$table;
331 
		}
332 
 
333 
		if (count($this->fields) === 0)
334 
		{
335 
			show_error('Field information is required.');
336 
		}
337 
 
338 
		$sql = $this->_create_table($table, $if_not_exists, $attributes);
339 
 
340 
		if (is_bool($sql))
341 
		{
342 
			$this->_reset();
343 
			if ($sql === FALSE)
344 
			{
345 
				return ($this->db->db_debug) ? $this->db->display_error('db_unsupported_feature') : FALSE;
346 
			}
347 
		}
348 
 
349 
		if (($result = $this->db->query($sql)) !== FALSE)
350 
		{
2414 lars 351 
			if (isset($this->db->data_cache['table_names']))
352 
			{
353 
				$this->db->data_cache['table_names'][] = $table;
354 
			}
68 lars 355 
 
356 
			// Most databases don't support creating indexes from within the CREATE TABLE statement
357 
			if ( ! empty($this->keys))
358 
			{
359 
				for ($i = 0, $sqls = $this->_process_indexes($table), $c = count($sqls); $i < $c; $i++)
360 
				{
361 
					$this->db->query($sqls[$i]);
362 
				}
363 
			}
364 
		}
365 
 
366 
		$this->_reset();
367 
		return $result;
368 
	}
369 
 
370 
	// --------------------------------------------------------------------
371 
 
372 
	/**
373 
	 * Create Table
374 
	 *
375 
	 * @param	string	$table		Table name
376 
	 * @param	bool	$if_not_exists	Whether to add 'IF NOT EXISTS' condition
377 
	 * @param	array	$attributes	Associative array of table attributes
378 
	 * @return	mixed
379 
	 */
380 
	protected function _create_table($table, $if_not_exists, $attributes)
381 
	{
382 
		if ($if_not_exists === TRUE && $this->_create_table_if === FALSE)
383 
		{
384 
			if ($this->db->table_exists($table))
385 
			{
386 
				return TRUE;
387 
			}
2257 lars 388 
 
389 
			$if_not_exists = FALSE;
68 lars 390 
		}
391 
 
392 
		$sql = ($if_not_exists)
393 
			? sprintf($this->_create_table_if, $this->db->escape_identifiers($table))
394 
			: 'CREATE TABLE';
395 
 
396 
		$columns = $this->_process_fields(TRUE);
397 
		for ($i = 0, $c = count($columns); $i < $c; $i++)
398 
		{
399 
			$columns[$i] = ($columns[$i]['_literal'] !== FALSE)
400 
					? "\n\t".$columns[$i]['_literal']
401 
					: "\n\t".$this->_process_column($columns[$i]);
402 
		}
403 
 
404 
		$columns = implode(',', $columns)
405 
				.$this->_process_primary_keys($table);
406 
 
407 
		// Are indexes created from within the CREATE TABLE statement? (e.g. in MySQL)
408 
		if ($this->_create_table_keys === TRUE)
409 
		{
410 
			$columns .= $this->_process_indexes($table);
411 
		}
412 
 
413 
		// _create_table will usually have the following format: "%s %s (%s\n)"
414 
		$sql = sprintf($this->_create_table.'%s',
415 
			$sql,
416 
			$this->db->escape_identifiers($table),
417 
			$columns,
418 
			$this->_create_table_attr($attributes)
419 
		);
420 
 
421 
		return $sql;
422 
	}
423 
 
424 
	// --------------------------------------------------------------------
425 
 
426 
	/**
427 
	 * CREATE TABLE attributes
428 
	 *
429 
	 * @param	array	$attributes	Associative array of table attributes
430 
	 * @return	string
431 
	 */
432 
	protected function _create_table_attr($attributes)
433 
	{
434 
		$sql = '';
435 
 
436 
		foreach (array_keys($attributes) as $key)
437 
		{
438 
			if (is_string($key))
439 
			{
440 
				$sql .= ' '.strtoupper($key).' '.$attributes[$key];
441 
			}
442 
		}
443 
 
444 
		return $sql;
445 
	}
446 
 
447 
	// --------------------------------------------------------------------
448 
 
449 
	/**
450 
	 * Drop Table
451 
	 *
452 
	 * @param	string	$table_name	Table name
453 
	 * @param	bool	$if_exists	Whether to add an IF EXISTS condition
454 
	 * @return	bool
455 
	 */
456 
	public function drop_table($table_name, $if_exists = FALSE)
457 
	{
458 
		if ($table_name === '')
459 
		{
460 
			return ($this->db->db_debug) ? $this->db->display_error('db_table_name_required') : FALSE;
461 
		}
462 
 
463 
		if (($query = $this->_drop_table($this->db->dbprefix.$table_name, $if_exists)) === TRUE)
464 
		{
465 
			return TRUE;
466 
		}
467 
 
468 
		$query = $this->db->query($query);
469 
 
470 
		// Update table list cache
471 
		if ($query && ! empty($this->db->data_cache['table_names']))
472 
		{
473 
			$key = array_search(strtolower($this->db->dbprefix.$table_name), array_map('strtolower', $this->db->data_cache['table_names']), TRUE);
474 
			if ($key !== FALSE)
475 
			{
476 
				unset($this->db->data_cache['table_names'][$key]);
477 
			}
478 
		}
479 
 
480 
		return $query;
481 
	}
482 
 
483 
	// --------------------------------------------------------------------
484 
 
485 
	/**
486 
	 * Drop Table
487 
	 *
488 
	 * Generates a platform-specific DROP TABLE string
489 
	 *
490 
	 * @param	string	$table		Table name
491 
	 * @param	bool	$if_exists	Whether to add an IF EXISTS condition
2107 lars 492 
	 * @return	mixed	(Returns a platform-specific DROP table string, or TRUE to indicate there's nothing to do)
68 lars 493 
	 */
494 
	protected function _drop_table($table, $if_exists)
495 
	{
496 
		$sql = 'DROP TABLE';
497 
 
498 
		if ($if_exists)
499 
		{
500 
			if ($this->_drop_table_if === FALSE)
501 
			{
502 
				if ( ! $this->db->table_exists($table))
503 
				{
504 
					return TRUE;
505 
				}
506 
			}
507 
			else
508 
			{
509 
				$sql = sprintf($this->_drop_table_if, $this->db->escape_identifiers($table));
510 
			}
511 
		}
512 
 
513 
		return $sql.' '.$this->db->escape_identifiers($table);
514 
	}
515 
 
516 
	// --------------------------------------------------------------------
517 
 
518 
	/**
519 
	 * Rename Table
520 
	 *
521 
	 * @param	string	$table_name	Old table name
522 
	 * @param	string	$new_table_name	New table name
523 
	 * @return	bool
524 
	 */
525 
	public function rename_table($table_name, $new_table_name)
526 
	{
527 
		if ($table_name === '' OR $new_table_name === '')
528 
		{
529 
			show_error('A table name is required for that operation.');
530 
			return FALSE;
531 
		}
532 
		elseif ($this->_rename_table === FALSE)
533 
		{
534 
			return ($this->db->db_debug) ? $this->db->display_error('db_unsupported_feature') : FALSE;
535 
		}
536 
 
537 
		$result = $this->db->query(sprintf($this->_rename_table,
538 
						$this->db->escape_identifiers($this->db->dbprefix.$table_name),
539 
						$this->db->escape_identifiers($this->db->dbprefix.$new_table_name))
540 
					);
541 
 
542 
		if ($result && ! empty($this->db->data_cache['table_names']))
543 
		{
544 
			$key = array_search(strtolower($this->db->dbprefix.$table_name), array_map('strtolower', $this->db->data_cache['table_names']), TRUE);
545 
			if ($key !== FALSE)
546 
			{
547 
				$this->db->data_cache['table_names'][$key] = $this->db->dbprefix.$new_table_name;
548 
			}
549 
		}
550 
 
551 
		return $result;
552 
	}
553 
 
554 
	// --------------------------------------------------------------------
555 
 
556 
	/**
557 
	 * Column Add
558 
	 *
559 
	 * @todo	Remove deprecated $_after option in 3.1+
560 
	 * @param	string	$table	Table name
561 
	 * @param	array	$field	Column definition
562 
	 * @param	string	$_after	Column for AFTER clause (deprecated)
563 
	 * @return	bool
564 
	 */
565 
	public function add_column($table, $field, $_after = NULL)
566 
	{
567 
		// Work-around for literal column definitions
568 
		is_array($field) OR $field = array($field);
569 
 
570 
		foreach (array_keys($field) as $k)
571 
		{
572 
			// Backwards-compatibility work-around for MySQL/CUBRID AFTER clause (remove in 3.1+)
573 
			if ($_after !== NULL && is_array($field[$k]) && ! isset($field[$k]['after']))
574 
			{
575 
				$field[$k]['after'] = $_after;
576 
			}
577 
 
578 
			$this->add_field(array($k => $field[$k]));
579 
		}
580 
 
581 
		$sqls = $this->_alter_table('ADD', $this->db->dbprefix.$table, $this->_process_fields());
582 
		$this->_reset();
583 
		if ($sqls === FALSE)
584 
		{
585 
			return ($this->db->db_debug) ? $this->db->display_error('db_unsupported_feature') : FALSE;
586 
		}
587 
 
588 
		for ($i = 0, $c = count($sqls); $i < $c; $i++)
589 
		{
590 
			if ($this->db->query($sqls[$i]) === FALSE)
591 
			{
592 
				return FALSE;
593 
			}
594 
		}
595 
 
596 
		return TRUE;
597 
	}
598 
 
599 
	// --------------------------------------------------------------------
600 
 
601 
	/**
602 
	 * Column Drop
603 
	 *
604 
	 * @param	string	$table		Table name
605 
	 * @param	string	$column_name	Column name
606 
	 * @return	bool
607 
	 */
608 
	public function drop_column($table, $column_name)
609 
	{
610 
		$sql = $this->_alter_table('DROP', $this->db->dbprefix.$table, $column_name);
611 
		if ($sql === FALSE)
612 
		{
613 
			return ($this->db->db_debug) ? $this->db->display_error('db_unsupported_feature') : FALSE;
614 
		}
615 
 
616 
		return $this->db->query($sql);
617 
	}
618 
 
619 
	// --------------------------------------------------------------------
620 
 
621 
	/**
622 
	 * Column Modify
623 
	 *
624 
	 * @param	string	$table	Table name
625 
	 * @param	string	$field	Column definition
626 
	 * @return	bool
627 
	 */
628 
	public function modify_column($table, $field)
629 
	{
630 
		// Work-around for literal column definitions
631 
		is_array($field) OR $field = array($field);
632 
 
633 
		foreach (array_keys($field) as $k)
634 
		{
635 
			$this->add_field(array($k => $field[$k]));
636 
		}
637 
 
638 
		if (count($this->fields) === 0)
639 
		{
640 
			show_error('Field information is required.');
641 
		}
642 
 
643 
		$sqls = $this->_alter_table('CHANGE', $this->db->dbprefix.$table, $this->_process_fields());
644 
		$this->_reset();
645 
		if ($sqls === FALSE)
646 
		{
647 
			return ($this->db->db_debug) ? $this->db->display_error('db_unsupported_feature') : FALSE;
648 
		}
649 
 
650 
		for ($i = 0, $c = count($sqls); $i < $c; $i++)
651 
		{
652 
			if ($this->db->query($sqls[$i]) === FALSE)
653 
			{
654 
				return FALSE;
655 
			}
656 
		}
657 
 
658 
		return TRUE;
659 
	}
660 
 
661 
	// --------------------------------------------------------------------
662 
 
663 
	/**
664 
	 * ALTER TABLE
665 
	 *
666 
	 * @param	string	$alter_type	ALTER type
667 
	 * @param	string	$table		Table name
668 
	 * @param	mixed	$field		Column definition
669 
	 * @return	string|string[]
670 
	 */
671 
	protected function _alter_table($alter_type, $table, $field)
672 
	{
673 
		$sql = 'ALTER TABLE '.$this->db->escape_identifiers($table).' ';
674 
 
675 
		// DROP has everything it needs now.
676 
		if ($alter_type === 'DROP')
677 
		{
678 
			return $sql.'DROP COLUMN '.$this->db->escape_identifiers($field);
679 
		}
680 
 
681 
		$sql .= ($alter_type === 'ADD')
682 
			? 'ADD '
683 
			: $alter_type.' COLUMN ';
684 
 
685 
		$sqls = array();
686 
		for ($i = 0, $c = count($field); $i < $c; $i++)
687 
		{
688 
			$sqls[] = $sql
689 
				.($field[$i]['_literal'] !== FALSE ? $field[$i]['_literal'] : $this->_process_column($field[$i]));
690 
		}
691 
 
692 
		return $sqls;
693 
	}
694 
 
695 
	// --------------------------------------------------------------------
696 
 
697 
	/**
698 
	 * Process fields
699 
	 *
700 
	 * @param	bool	$create_table
701 
	 * @return	array
702 
	 */
703 
	protected function _process_fields($create_table = FALSE)
704 
	{
705 
		$fields = array();
706 
 
707 
		foreach ($this->fields as $key => $attributes)
708 
		{
709 
			if (is_int($key) && ! is_array($attributes))
710 
			{
711 
				$fields[] = array('_literal' => $attributes);
712 
				continue;
713 
			}
714 
 
715 
			$attributes = array_change_key_case($attributes, CASE_UPPER);
716 
 
717 
			if ($create_table === TRUE && empty($attributes['TYPE']))
718 
			{
719 
				continue;
720 
			}
721 
 
722 
			isset($attributes['TYPE']) && $this->_attr_type($attributes);
723 
 
724 
			$field = array(
725 
				'name'			=> $key,
726 
				'new_name'		=> isset($attributes['NAME']) ? $attributes['NAME'] : NULL,
727 
				'type'			=> isset($attributes['TYPE']) ? $attributes['TYPE'] : NULL,
728 
				'length'		=> '',
729 
				'unsigned'		=> '',
2414 lars 730 
				'null'			=> NULL,
68 lars 731 
				'unique'		=> '',
732 
				'default'		=> '',
733 
				'auto_increment'	=> '',
734 
				'_literal'		=> FALSE
735 
			);
736 
 
737 
			isset($attributes['TYPE']) && $this->_attr_unsigned($attributes, $field);
738 
 
739 
			if ($create_table === FALSE)
740 
			{
741 
				if (isset($attributes['AFTER']))
742 
				{
743 
					$field['after'] = $attributes['AFTER'];
744 
				}
745 
				elseif (isset($attributes['FIRST']))
746 
				{
747 
					$field['first'] = (bool) $attributes['FIRST'];
748 
				}
749 
			}
750 
 
751 
			$this->_attr_default($attributes, $field);
752 
 
753 
			if (isset($attributes['NULL']))
754 
			{
755 
				if ($attributes['NULL'] === TRUE)
756 
				{
757 
					$field['null'] = empty($this->_null) ? '' : ' '.$this->_null;
758 
				}
759 
				else
760 
				{
761 
					$field['null'] = ' NOT NULL';
762 
				}
763 
			}
764 
			elseif ($create_table === TRUE)
765 
			{
766 
				$field['null'] = ' NOT NULL';
767 
			}
768 
 
769 
			$this->_attr_auto_increment($attributes, $field);
770 
			$this->_attr_unique($attributes, $field);
771 
 
772 
			if (isset($attributes['COMMENT']))
773 
			{
774 
				$field['comment'] = $this->db->escape($attributes['COMMENT']);
775 
			}
776 
 
777 
			if (isset($attributes['TYPE']) && ! empty($attributes['CONSTRAINT']))
778 
			{
779 
				switch (strtoupper($attributes['TYPE']))
780 
				{
781 
					case 'ENUM':
782 
					case 'SET':
783 
						$attributes['CONSTRAINT'] = $this->db->escape($attributes['CONSTRAINT']);
784 
					default:
785 
						$field['length'] = is_array($attributes['CONSTRAINT'])
786 
							? '('.implode(',', $attributes['CONSTRAINT']).')'
787 
							: '('.$attributes['CONSTRAINT'].')';
788 
						break;
789 
				}
790 
			}
791 
 
792 
			$fields[] = $field;
793 
		}
794 
 
795 
		return $fields;
796 
	}
797 
 
798 
	// --------------------------------------------------------------------
799 
 
800 
	/**
801 
	 * Process column
802 
	 *
803 
	 * @param	array	$field
804 
	 * @return	string
805 
	 */
806 
	protected function _process_column($field)
807 
	{
808 
		return $this->db->escape_identifiers($field['name'])
809 
			.' '.$field['type'].$field['length']
810 
			.$field['unsigned']
811 
			.$field['default']
812 
			.$field['null']
813 
			.$field['auto_increment']
814 
			.$field['unique'];
815 
	}
816 
 
817 
	// --------------------------------------------------------------------
818 
 
819 
	/**
820 
	 * Field attribute TYPE
821 
	 *
822 
	 * Performs a data type mapping between different databases.
823 
	 *
824 
	 * @param	array	&$attributes
825 
	 * @return	void
826 
	 */
827 
	protected function _attr_type(&$attributes)
828 
	{
829 
		// Usually overridden by drivers
830 
	}
831 
 
832 
	// --------------------------------------------------------------------
833 
 
834 
	/**
835 
	 * Field attribute UNSIGNED
836 
	 *
837 
	 * Depending on the _unsigned property value:
838 
	 *
839 
	 *	- TRUE will always set $field['unsigned'] to 'UNSIGNED'
840 
	 *	- FALSE will always set $field['unsigned'] to ''
841 
	 *	- array(TYPE) will set $field['unsigned'] to 'UNSIGNED',
842 
	 *		if $attributes['TYPE'] is found in the array
843 
	 *	- array(TYPE => UTYPE) will change $field['type'],
844 
	 *		from TYPE to UTYPE in case of a match
845 
	 *
846 
	 * @param	array	&$attributes
847 
	 * @param	array	&$field
848 
	 * @return	void
849 
	 */
850 
	protected function _attr_unsigned(&$attributes, &$field)
851 
	{
852 
		if (empty($attributes['UNSIGNED']) OR $attributes['UNSIGNED'] !== TRUE)
853 
		{
854 
			return;
855 
		}
856 
 
857 
		// Reset the attribute in order to avoid issues if we do type conversion
858 
		$attributes['UNSIGNED'] = FALSE;
859 
 
860 
		if (is_array($this->_unsigned))
861 
		{
862 
			foreach (array_keys($this->_unsigned) as $key)
863 
			{
864 
				if (is_int($key) && strcasecmp($attributes['TYPE'], $this->_unsigned[$key]) === 0)
865 
				{
866 
					$field['unsigned'] = ' UNSIGNED';
867 
					return;
868 
				}
869 
				elseif (is_string($key) && strcasecmp($attributes['TYPE'], $key) === 0)
870 
				{
871 
					$field['type'] = $key;
872 
					return;
873 
				}
874 
			}
875 
 
876 
			return;
877 
		}
878 
 
879 
		$field['unsigned'] = ($this->_unsigned === TRUE) ? ' UNSIGNED' : '';
880 
	}
881 
 
882 
	// --------------------------------------------------------------------
883 
 
884 
	/**
885 
	 * Field attribute DEFAULT
886 
	 *
887 
	 * @param	array	&$attributes
888 
	 * @param	array	&$field
889 
	 * @return	void
890 
	 */
891 
	protected function _attr_default(&$attributes, &$field)
892 
	{
893 
		if ($this->_default === FALSE)
894 
		{
895 
			return;
896 
		}
897 
 
898 
		if (array_key_exists('DEFAULT', $attributes))
899 
		{
900 
			if ($attributes['DEFAULT'] === NULL)
901 
			{
902 
				$field['default'] = empty($this->_null) ? '' : $this->_default.$this->_null;
903 
 
904 
				// Override the NULL attribute if that's our default
905 
				$attributes['NULL'] = TRUE;
906 
				$field['null'] = empty($this->_null) ? '' : ' '.$this->_null;
907 
			}
908 
			else
909 
			{
910 
				$field['default'] = $this->_default.$this->db->escape($attributes['DEFAULT']);
911 
			}
912 
		}
913 
	}
914 
 
915 
	// --------------------------------------------------------------------
916 
 
917 
	/**
918 
	 * Field attribute UNIQUE
919 
	 *
920 
	 * @param	array	&$attributes
921 
	 * @param	array	&$field
922 
	 * @return	void
923 
	 */
924 
	protected function _attr_unique(&$attributes, &$field)
925 
	{
926 
		if ( ! empty($attributes['UNIQUE']) && $attributes['UNIQUE'] === TRUE)
927 
		{
928 
			$field['unique'] = ' UNIQUE';
929 
		}
930 
	}
931 
 
932 
	// --------------------------------------------------------------------
933 
 
934 
	/**
935 
	 * Field attribute AUTO_INCREMENT
936 
	 *
937 
	 * @param	array	&$attributes
938 
	 * @param	array	&$field
939 
	 * @return	void
940 
	 */
941 
	protected function _attr_auto_increment(&$attributes, &$field)
942 
	{
943 
		if ( ! empty($attributes['AUTO_INCREMENT']) && $attributes['AUTO_INCREMENT'] === TRUE && stripos($field['type'], 'int') !== FALSE)
944 
		{
945 
			$field['auto_increment'] = ' AUTO_INCREMENT';
946 
		}
947 
	}
948 
 
949 
	// --------------------------------------------------------------------
950 
 
951 
	/**
952 
	 * Process primary keys
953 
	 *
954 
	 * @param	string	$table	Table name
955 
	 * @return	string
956 
	 */
957 
	protected function _process_primary_keys($table)
958 
	{
959 
		$sql = '';
960 
 
961 
		for ($i = 0, $c = count($this->primary_keys); $i < $c; $i++)
962 
		{
963 
			if ( ! isset($this->fields[$this->primary_keys[$i]]))
964 
			{
965 
				unset($this->primary_keys[$i]);
966 
			}
967 
		}
968 
 
969 
		if (count($this->primary_keys) > 0)
970 
		{
971 
			$sql .= ",\n\tCONSTRAINT ".$this->db->escape_identifiers('pk_'.$table)
972 
				.' PRIMARY KEY('.implode(', ', $this->db->escape_identifiers($this->primary_keys)).')';
973 
		}
974 
 
975 
		return $sql;
976 
	}
977 
 
978 
	// --------------------------------------------------------------------
979 
 
980 
	/**
981 
	 * Process indexes
982 
	 *
2107 lars 983 
	 * @param	string	$table	Table name
984 
	 * @return	string[] list of SQL statements
68 lars 985 
	 */
986 
	protected function _process_indexes($table)
987 
	{
988 
		$sqls = array();
989 
 
990 
		for ($i = 0, $c = count($this->keys); $i < $c; $i++)
991 
		{
992 
			if (is_array($this->keys[$i]))
993 
			{
994 
				for ($i2 = 0, $c2 = count($this->keys[$i]); $i2 < $c2; $i2++)
995 
				{
996 
					if ( ! isset($this->fields[$this->keys[$i][$i2]]))
997 
					{
998 
						unset($this->keys[$i][$i2]);
999 
						continue;
1000 
					}
1001 
				}
1002 
			}
1003 
			elseif ( ! isset($this->fields[$this->keys[$i]]))
1004 
			{
1005 
				unset($this->keys[$i]);
1006 
				continue;
1007 
			}
1008 
 
1009 
			is_array($this->keys[$i]) OR $this->keys[$i] = array($this->keys[$i]);
1010 
 
1011 
			$sqls[] = 'CREATE INDEX '.$this->db->escape_identifiers($table.'_'.implode('_', $this->keys[$i]))
1012 
				.' ON '.$this->db->escape_identifiers($table)
1013 
				.' ('.implode(', ', $this->db->escape_identifiers($this->keys[$i])).');';
1014 
		}
1015 
 
1016 
		return $sqls;
1017 
	}
1018 
 
1019 
	// --------------------------------------------------------------------
1020 
 
1021 
	/**
1022 
	 * Reset
1023 
	 *
1024 
	 * Resets table creation vars
1025 
	 *
1026 
	 * @return	void
1027 
	 */
1028 
	protected function _reset()
1029 
	{
1030 
		$this->fields = $this->keys = $this->primary_keys = array();
1031 
	}
1032 
 
1033 
}