PageRenderTime 66ms CodeModel.GetById 23ms RepoModel.GetById 1ms app.codeStats 0ms

/classes/fSchema.php

https://bitbucket.org/ZilIsiltk/flourish
PHP | 2884 lines | 2110 code | 265 blank | 509 comment | 241 complexity | bb9290edcd4874e69f25c6cf6f09a915 MD5 | raw file
    

  1. <?php
    2. 

  2. /**
    3. 

  3.  * Gets schema information for the selected database
    4. 

  4.  * 
    5. 

  5.  * @copyright  Copyright (c) 2007-2010 Will Bond
    6. 

  6.  * @author     Will Bond [wb] <will@flourishlib.com>
    7. 

  7.  * @license    http://flourishlib.com/license
    8. 

  8.  * 
    9. 

  9.  * @package    Flourish
    10. 

  10.  * @link       http://flourishlib.com/fSchema
    11. 

  11.  * 
    12. 

  12.  * @version    1.0.0b42
    13. 

  13.  * @changes    1.0.0b42  Fixed a bug with MySQL detecting default `ON DELETE` clauses [wb, 2010-10-19]
    14. 

  14.  * @changes    1.0.0b41  Fixed handling MySQL table names that require quoting [wb, 2010-08-24]
    15. 

  15.  * @changes    1.0.0b40  Fixed bugs in the documentation and error message of ::getColumnInfo() about what are valid elements [wb, 2010-07-21]
    16. 

  16.  * @changes    1.0.0b39  Fixed a regression where key detection SQL was not compatible with PostgreSQL 8.1 [wb, 2010-04-13]
    17. 

  17.  * @changes    1.0.0b38  Added Oracle support to ::getDatabases() [wb, 2010-04-13]
    18. 

  18.  * @changes    1.0.0b37  Fixed ::getDatabases() for MSSQL [wb, 2010-04-09]
    19. 

  19.  * @changes    1.0.0b36  Fixed PostgreSQL to properly report explicit `NULL` default values via ::getColumnInfo() [wb, 2010-03-30]
    20. 

  20.  * @changes    1.0.0b35  Added `max_length` values for various text and blob data types across all databases [wb, 2010-03-29]
    21. 

  21.  * @changes    1.0.0b34  Added `min_value` and `max_value` attributes to ::getColumnInfo() to specify the valid range for numeric columns [wb, 2010-03-16]
    22. 

  22.  * @changes    1.0.0b33  Changed it so that PostgreSQL unique indexes containing functions are ignored since they can't be properly detected at this point [wb, 2010-03-14]
    23. 

  23.  * @changes    1.0.0b32  Fixed ::getTables() to not include views for MySQL [wb, 2010-03-14]
    24. 

  24.  * @changes    1.0.0b31  Fixed the creation of the default caching key for ::enableCaching() [wb, 2010-03-02]
    25. 

  25.  * @changes    1.0.0b30  Fixed the class to work with lower privilege Oracle accounts and added detection of Oracle number columns [wb, 2010-01-25]
    26. 

  26.  * @changes    1.0.0b29  Added on_delete and on_update elements to one-to-one relationship info retrieved by ::getRelationships() [wb, 2009-12-16]
    27. 

  27.  * @changes    1.0.0b28  Fixed a bug with detecting some multi-column unique constraints in SQL Server databases [wb, 2009-11-13]
    28. 

  28.  * @changes    1.0.0b27  Added a parameter to ::enableCaching() to provide a key token that will allow cached values to be shared between multiple databases with the same schema [wb, 2009-10-28]
    29. 

  29.  * @changes    1.0.0b26  Added the placeholder element to the output of ::getColumnInfo(), added support for PostgreSQL, MSSQL and Oracle "schemas", added support for parsing quoted SQLite identifiers [wb, 2009-10-22]
    30. 

  30.  * @changes    1.0.0b25  One-to-one relationships utilizing the primary key as a foreign key are now properly detected [wb, 2009-09-22]
    31. 

  31.  * @changes    1.0.0b24  Fixed MSSQL support to work with ODBC database connections [wb, 2009-09-18]
    32. 

  32.  * @changes    1.0.0b23  Fixed a bug where one-to-one relationships were being listed as many-to-one [wb, 2009-07-21]
    33. 

  33.  * @changes    1.0.0b22  PostgreSQL UNIQUE constraints that are created as indexes and not table constraints are now properly detected [wb, 2009-07-08]
    34. 

  34.  * @changes    1.0.0b21  Added support for the UUID data type in PostgreSQL [wb, 2009-06-18]
    35. 

  35.  * @changes    1.0.0b20  Add caching of merged info, improved performance of ::getColumnInfo() [wb, 2009-06-15]
    36. 

  36.  * @changes    1.0.0b19  Fixed a couple of bugs with ::setKeysOverride() [wb, 2009-06-04]
    37. 

  37.  * @changes    1.0.0b18  Added missing support for MySQL mediumint columns [wb, 2009-05-18]
    38. 

  38.  * @changes    1.0.0b17  Fixed a bug with ::clearCache() not properly reseting the tables and databases list [wb, 2009-05-13]
    39. 

  39.  * @changes    1.0.0b16  Backwards Compatibility Break - ::setCacheFile() changed to ::enableCaching() and now requires an fCache object, ::flushInfo() renamed to ::clearCache(), added Oracle support [wb, 2009-05-04]
    40. 

  40.  * @changes    1.0.0b15  Added support for the three different types of identifier quoting in SQLite [wb, 2009-03-28]
    41. 

  41.  * @changes    1.0.0b14  Added support for MySQL column definitions containing the COLLATE keyword [wb, 2009-03-28]
    42. 

  42.  * @changes    1.0.0b13  Fixed a bug with detecting PostgreSQL columns having both a CHECK constraint and a UNIQUE constraint [wb, 2009-02-27]
    43. 

  43.  * @changes    1.0.0b12  Fixed detection of multi-column primary keys in MySQL [wb, 2009-02-27]
    44. 

  44.  * @changes    1.0.0b11  Fixed an issue parsing MySQL tables with comments [wb, 2009-02-25]
    45. 

  45.  * @changes    1.0.0b10  Added the ::getDatabases() method [wb, 2009-02-24]
    46. 

  46.  * @changes    1.0.0b9   Now detects unsigned and zerofill MySQL data types that do not have a parenthetical part [wb, 2009-02-16]
    47. 

  47.  * @changes    1.0.0b8   Mapped the MySQL data type `'set'` to `'varchar'`, however valid values are not implemented yet [wb, 2009-02-01]
    48. 

  48.  * @changes    1.0.0b7   Fixed a bug with detecting MySQL timestamp columns [wb, 2009-01-28]
    49. 

  49.  * @changes    1.0.0b6   Fixed a bug with detecting MySQL columns that accept `NULL` [wb, 2009-01-19]
    50. 

  50.  * @changes    1.0.0b5   ::setColumnInfo(): fixed a bug with not grabbing the real database schema first, made general improvements [wb, 2009-01-19]
    51. 

  51.  * @changes    1.0.0b4   Added support for MySQL binary data types, numeric data type options unsigned and zerofill, and per-column character set definitions [wb, 2009-01-17]
    52. 

  52.  * @changes    1.0.0b3   Fixed detection of the data type of MySQL timestamp columns, added support for dynamic default date/time values [wb, 2009-01-11]
    53. 

  53.  * @changes    1.0.0b2   Fixed a bug with detecting multi-column unique keys in MySQL [wb, 2009-01-03]
    54. 

  54.  * @changes    1.0.0b    The initial implementation [wb, 2007-09-25]
    55. 

  55.  */
    56. 

  56. class fSchema
    57. 

  57. {
    58. 

  58. 	/**
    59. 

  59. 	 * The place to cache to
    60. 

  60. 	 * 
    61. 

  61. 	 * @var fCache
    62. 

  62. 	 */
    63. 

  63. 	private $cache = NULL;
    64. 

  64. 	
    65. 

  65. 	/**
    66. 

  66. 	 * The cache prefix to use for cache entries
    67. 

  67. 	 * 
    68. 

  68. 	 * @var string
    69. 

  69. 	 */
    70. 

  70. 	private $cache_prefix;
    71. 

  71. 	
    72. 

  72. 	/**
    73. 

  73. 	 * The cached column info
    74. 

  74. 	 * 
    75. 

  75. 	 * @var array
    76. 

  76. 	 */
    77. 

  77. 	private $column_info = array();
    78. 

  78. 	
    79. 

  79. 	/**
    80. 

  80. 	 * The column info to override
    81. 

  81. 	 * 
    82. 

  82. 	 * @var array
    83. 

  83. 	 */
    84. 

  84. 	private $column_info_override = array();
    85. 

  85. 	
    86. 

  86. 	/**
    87. 

  87. 	 * A reference to an instance of the fDatabase class
    88. 

  88. 	 * 
    89. 

  89. 	 * @var fDatabase
    90. 

  90. 	 */
    91. 

  91. 	private $database = NULL;
    92. 

  92. 	
    93. 

  93. 	/**
    94. 

  94. 	 * The databases on the current database server
    95. 

  95. 	 * 
    96. 

  96. 	 * @var array
    97. 

  97. 	 */
    98. 

  98. 	private $databases = NULL;
    99. 

  99. 	
    100. 

  100. 	/**
    101. 

  101. 	 * The cached key info
    102. 

  102. 	 * 
    103. 

  103. 	 * @var array
    104. 

  104. 	 */
    105. 

  105. 	private $keys = array();
    106. 

  106. 	
    107. 

  107. 	/**
    108. 

  108. 	 * The key info to override
    109. 

  109. 	 * 
    110. 

  110. 	 * @var array
    111. 

  111. 	 */
    112. 

  112. 	private $keys_override = array();
    113. 

  113. 	
    114. 

  114. 	/**
    115. 

  115. 	 * The merged column info
    116. 

  116. 	 * 
    117. 

  117. 	 * @var array
    118. 

  118. 	 */
    119. 

  119. 	private $merged_column_info = array();
    120. 

  120. 	
    121. 

  121. 	/**
    122. 

  122. 	 * The merged key info
    123. 

  123. 	 * 
    124. 

  124. 	 * @var array
    125. 

  125. 	 */
    126. 

  126. 	private $merged_keys = array();
    127. 

  127. 	
    128. 

  128. 	/**
    129. 

  129. 	 * The relationships in the database
    130. 

  130. 	 * 
    131. 

  131. 	 * @var array
    132. 

  132. 	 */
    133. 

  133. 	private $relationships = array();
    134. 

  134. 	
    135. 

  135. 	/**
    136. 

  136. 	 * The tables in the database
    137. 

  137. 	 * 
    138. 

  138. 	 * @var array
    139. 

  139. 	 */
    140. 

  140. 	private $tables = NULL;
    141. 

  141. 	
    142. 

  142. 	
    143. 

  143. 	/**
    144. 

  144. 	 * Sets the database
    145. 

  145. 	 * 
    146. 

  146. 	 * @param  fDatabase $database  The fDatabase instance
    147. 

  147. 	 * @return fSchema
    148. 

  148. 	 */
    149. 

  149. 	public function __construct($database)
    150. 

  150. 	{
    151. 

  151. 		$this->database = $database;
    152. 

  152. 	}
    153. 

  153. 	
    154. 

  154. 	
    155. 

  155. 	/**
    156. 

  156. 	 * All requests that hit this method should be requests for callbacks
    157. 

  157. 	 * 
    158. 

  158. 	 * @internal
    159. 

  159. 	 * 
    160. 

  160. 	 * @param  string $method  The method to create a callback for
    161. 

  161. 	 * @return callback  The callback for the method requested
    162. 

  162. 	 */
    163. 

  163. 	public function __get($method)
    164. 

  164. 	{
    165. 

  165. 		return array($this, $method);		
    166. 

  166. 	}
    167. 

  167. 	
    168. 

  168. 	
    169. 

  169. 	/**
    170. 

  170. 	 * Checks to see if a column is part of a single-column `UNIQUE` key
    171. 

  171. 	 * 
    172. 

  172. 	 * @param  string $table   The table the column is located in
    173. 

  173. 	 * @param  string $column  The column to check
    174. 

  174. 	 * @return boolean  If the column is part of a single-column unique key
    175. 

  175. 	 */
    176. 

  176. 	private function checkForSingleColumnUniqueKey($table, $column)
    177. 

  177. 	{        
    178. 

  178. 		foreach ($this->merged_keys[$table]['unique'] as $key) {
    179. 

  179. 			if (array($column) == $key) {
    180. 

  180. 				return TRUE;
    181. 

  181. 			}
    182. 

  182. 		}
    183. 

  183. 		if (array($column) == $this->merged_keys[$table]['primary']) {
    184. 

  184. 			return TRUE;
    185. 

  185. 		}
    186. 

  186. 		return FALSE;
    187. 

  187. 	}
    188. 

  188. 	
    189. 

  189. 	
    190. 

  190. 	/**
    191. 

  191. 	 * Clears all of the schema info out of the object and, if set, the fCache object
    192. 

  192. 	 * 
    193. 

  193. 	 * @internal
    194. 

  194. 	 * 
    195. 

  195. 	 * @return void
    196. 

  196. 	 */
    197. 

  197. 	public function clearCache()
    198. 

  198. 	{
    199. 

  199. 		$this->column_info        = array();
    200. 

  200. 		$this->databases          = NULL;
    201. 

  201. 		$this->keys               = array();
    202. 

  202. 		$this->merged_column_info = array();
    203. 

  203. 		$this->merged_keys        = array();
    204. 

  204. 		$this->relationships      = array();
    205. 

  205. 		$this->tables             = NULL;
    206. 

  206. 		if ($this->cache) {
    207. 

  207. 			$prefix = $this->makeCachePrefix();
    208. 

  208. 			$this->cache->delete($prefix . 'column_info');
    209. 

  209. 			$this->cache->delete($prefix . 'databases');
    210. 

  210. 			$this->cache->delete($prefix . 'keys');
    211. 

  211. 			$this->cache->delete($prefix . 'merged_column_info');
    212. 

  212. 			$this->cache->delete($prefix . 'merged_keys');
    213. 

  213. 			$this->cache->delete($prefix . 'relationships');
    214. 

  214. 			$this->cache->delete($prefix . 'tables');
    215. 

  215. 		}
    216. 

  216. 	}
    217. 

  217. 	
    218. 

  218. 	
    219. 

  219. 	/**
    220. 

  220. 	 * Sets the schema to be cached to the fCache object specified
    221. 

  221. 	 * 
    222. 

  222. 	 * @param  fCache $cache      The cache to cache to
    223. 

  223. 	 * @param  string $key_token  Internal use only! (this will be used in the cache key to uniquely identify the cache for this fSchema object) 
    224. 

  224. 	 * @return void
    225. 

  225. 	 */
    226. 

  226. 	public function enableCaching($cache, $key_token=NULL)
    227. 

  227. 	{
    228. 

  228. 		$this->cache = $cache;
    229. 

  229. 		
    230. 

  230. 		if ($key_token !== NULL) {
    231. 

  231. 			$this->cache_prefix = 'fSchema::' . $this->database->getType() . '::' . $key_token . '::';
    232. 

  232. 		}
    233. 

  233. 		$prefix = $this->makeCachePrefix();
    234. 

  234. 		
    235. 

  235. 		$this->column_info        = $this->cache->get($prefix . 'column_info',          array());
    236. 

  236. 		$this->databases          = $this->cache->get($prefix . 'databases',            NULL);
    237. 

  237. 		$this->keys               = $this->cache->get($prefix . 'keys',                 array());
    238. 

  238. 		
    239. 

  239. 		if (!$this->column_info_override && !$this->keys_override) {
    240. 

  240. 			$this->merged_column_info = $this->cache->get($prefix . 'merged_column_info',   array());
    241. 

  241. 			$this->merged_keys        = $this->cache->get($prefix . 'merged_keys',          array());  
    242. 

  242. 			$this->relationships      = $this->cache->get($prefix . 'relationships',        array());
    243. 

  243. 		}
    244. 

  244. 		
    245. 

  245. 		$this->tables             = $this->cache->get($prefix . 'tables',               NULL);   
    246. 

  246. 	}
    247. 

  247. 	
    248. 

  248. 	
    249. 

  249. 	/**
    250. 

  250. 	 * Gets the column info from the database for later access
    251. 

  251. 	 * 
    252. 

  252. 	 * @param  string $table  The table to fetch the column info for
    253. 

  253. 	 * @return void
    254. 

  254. 	 */
    255. 

  255. 	private function fetchColumnInfo($table)
    256. 

  256. 	{
    257. 

  257. 		if (isset($this->column_info[$table])) {
    258. 

  258. 			return;	
    259. 

  259. 		}
    260. 

  260. 		
    261. 

  261. 		switch ($this->database->getType()) {
    262. 

  262. 			case 'db2':
    263. 

  263. 				$column_info = $this->fetchDB2ColumnInfo($table);
    264. 

  264. 				break;
    265. 

  265. 			
    266. 

  266. 			case 'mssql':
    267. 

  267. 				$column_info = $this->fetchMSSQLColumnInfo($table);
    268. 

  268. 				break;
    269. 

  269. 			
    270. 

  270. 			case 'mysql':
    271. 

  271. 				$column_info = $this->fetchMySQLColumnInfo($table);
    272. 

  272. 				break;
    273. 

  273. 				
    274. 

  274. 			case 'oracle':
    275. 

  275. 				$column_info = $this->fetchOracleColumnInfo($table);
    276. 

  276. 				break;
    277. 

  277. 			
    278. 

  278. 			case 'postgresql':
    279. 

  279. 				$column_info = $this->fetchPostgreSQLColumnInfo($table);
    280. 

  280. 				break;
    281. 

  281. 				
    282. 

  282. 			case 'sqlite':
    283. 

  283. 				$column_info = $this->fetchSQLiteColumnInfo($table);
    284. 

  284. 				break;
    285. 

  285. 		}
    286. 

  286. 			
    287. 

  287. 		if (!$column_info) {
    288. 

  288. 			return;	
    289. 

  289. 		}
    290. 

  290. 			
    291. 

  291. 		$this->column_info[$table] = $column_info;
    292. 

  292. 		if ($this->cache) {
    293. 

  293. 			$this->cache->set($this->makeCachePrefix() . 'column_info', $this->column_info);	
    294. 

  294. 		}
    295. 

  295. 	}
    296. 

  296. 	
    297. 

  297. 	
    298. 

  298. 	/**
    299. 

  299. 	 * Gets the column info from a DB2 database
    300. 

  300. 	 * 
    301. 

  301. 	 * @param  string $table  The table to fetch the column info for
    302. 

  302. 	 * @return array  The column info for the table specified - see ::getColumnInfo() for details
    303. 

  303. 	 */
    304. 

  304. 	private function fetchDB2ColumnInfo($table)
    305. 

  305. 	{
    306. 

  306. 		$column_info = array();
    307. 

  307. 		
    308. 

  308. 		$schema = strtolower($this->database->getUsername());
    309. 

  309. 		if (strpos($table, '.') !== FALSE) {
    310. 

  310. 			list ($schema, $table) = explode('.', $table);
    311. 

  311. 		}
    312. 

  312. 		
    313. 

  313. 		$data_type_mapping = array(
    314. 

  314. 			'smallint'          => 'integer',
    315. 

  315. 			'integer'           => 'integer',
    316. 

  316. 			'bigint'            => 'integer',
    317. 

  317. 			'timestamp'         => 'timestamp',
    318. 

  318. 			'date'              => 'date',
    319. 

  319. 			'time'              => 'time',
    320. 

  320. 			'varchar'           => 'varchar',
    321. 

  321. 			'long varchar'      => 'varchar',
    322. 

  322. 			'vargraphic'        => 'varchar',
    323. 

  323. 			'long vargraphic'   => 'varchar',
    324. 

  324. 			'character'         => 'char',
    325. 

  325. 			'graphic'           => 'char',
    326. 

  326. 			'real'              => 'float',
    327. 

  327. 			'decimal'           => 'float',
    328. 

  328. 			'numeric'           => 'float',
    329. 

  329. 			'blob'              => 'blob',
    330. 

  330. 			'clob'              => 'text',
    331. 

  331. 			'dbclob'            => 'text'
    332. 

  332. 		);
    333. 

  333. 		
    334. 

  334. 		$max_min_values = array(
    335. 

  335. 			'smallint'   => array('min' => new fNumber(-32768),                  'max' => new fNumber(32767)),
    336. 

  336. 			'integer'    => array('min' => new fNumber(-2147483648),             'max' => new fNumber(2147483647)),
    337. 

  337. 			'bigint'     => array('min' => new fNumber('-9223372036854775808'),  'max' => new fNumber('9223372036854775807'))
    338. 

  338. 		);
    339. 

  339. 		
    340. 

  340. 		// Get the column info
    341. 

  341. 		$sql = "SELECT
    342. 

  342. 					LOWER(C.COLNAME) AS \"COLUMN\",
    343. 

  343. 					C.TYPENAME AS TYPE,
    344. 

  344. 					C.NULLS AS NULLABLE,
    345. 

  345. 					C.DEFAULT,
    346. 

  346. 					C.LENGTH AS MAX_LENGTH,
    347. 

  347. 					C.SCALE,
    348. 

  348. 					CASE WHEN C.IDENTITY = 'Y' AND (C.GENERATED = 'D' OR C.GENERATED = 'A') THEN '1' ELSE '0' END AS AUTO_INCREMENT,
    349. 

  349. 					CH.TEXT AS \"CONSTRAINT\"
    350. 

  350. 				FROM
    351. 

  351. 					SYSCAT.COLUMNS AS C LEFT JOIN
    352. 

  352. 					SYSCAT.COLCHECKS AS CC ON C.TABSCHEMA = CC.TABSCHEMA AND C.TABNAME = CC.TABNAME AND C.COLNAME = CC.COLNAME AND CC.USAGE = 'R' LEFT JOIN
    353. 

  353. 					SYSCAT.CHECKS AS CH ON C.TABSCHEMA = CH.TABSCHEMA AND C.TABNAME = CH.TABNAME AND CH.TYPE = 'C' AND CH.CONSTNAME = CC.CONSTNAME
    354. 

  354. 				WHERE
    355. 

  355. 					C.TABSCHEMA = %s AND
    356. 

  356. 					C.TABNAME = %s
    357. 

  357. 				ORDER BY
    358. 

  358. 					C.COLNO ASC";
    359. 

  359. 		
    360. 

  360. 		$result = $this->database->query($sql, strtoupper($schema), strtoupper($table));
    361. 

  361. 		
    362. 

  362. 		foreach ($result as $row) {
    363. 

  363. 			
    364. 

  364. 			$info = array();
    365. 

  365. 			
    366. 

  366. 			foreach ($data_type_mapping as $data_type => $mapped_data_type) {
    367. 

  367. 				if (stripos($row['type'], $data_type) === 0) {
    368. 

  368. 					if (isset($max_min_values[$data_type])) {
    369. 

  369. 						$info['min_value'] = $max_min_values[$data_type]['min'];
    370. 

  370. 						$info['max_value'] = $max_min_values[$data_type]['max'];
    371. 

  371. 					}
    372. 

  372. 					$info['type'] = $mapped_data_type;
    373. 

  373. 					break;
    374. 

  374. 				}
    375. 

  375. 			}
    376. 

  376. 			
    377. 

  377. 			// Handle decimal places and min/max for numeric/decimals
    378. 

  378. 			if (in_array(strtolower($row['type']), array('decimal', 'numeric'))) {
    379. 

  379. 				$info['decimal_places'] = $row['scale'];
    380. 

  380. 				$before_digits = str_pad('', $row['max_length'] - $row['scale'], '9');
    381. 

  381. 				$after_digits  = str_pad('', $row['scale'], '9');
    382. 

  382. 				$max_min       = $before_digits . ($after_digits ? '.' : '') . $after_digits;
    383. 

  383. 				$info['min_value'] = new fNumber('-' . $max_min);
    384. 

  384. 				$info['max_value'] = new fNumber($max_min);
    385. 

  385. 			}
    386. 

  386. 			
    387. 

  387. 			if (!isset($info['type'])) {
    388. 

  388. 				$info['type'] = $row['type'];
    389. 

  389. 			}
    390. 

  390. 			
    391. 

  391. 			// Handle the special data for varchar columns
    392. 

  392. 			if (in_array($info['type'], array('char', 'varchar', 'text', 'blob'))) {
    393. 

  393. 				$info['max_length'] = $row['max_length'];
    394. 

  394. 			}
    395. 

  395. 			
    396. 

  396. 			// The generally accepted practice for boolean on DB2 is a CHAR(1) with a CHECK constraint
    397. 

  397. 			if ($info['type'] == 'char' && $info['max_length'] == 1 && !empty($row['constraint'])) {
    398. 

  398. 				if (is_resource($row['constraint'])) {
    399. 

  399. 					$row['constraint'] = stream_get_contents($row['constraint']);
    400. 

  400. 				}
    401. 

  401. 				if (preg_match('/^\s*' . preg_quote($row['column'], '/') . '\s+in\s+\(\s*(\'0\',\s*\'1\'|\'1\',\s*\'0\')\s*\)\s*$/i', $row['constraint'])) {
    402. 

  402. 					$info['type'] = 'boolean';
    403. 

  403. 					$info['max_length'] = NULL;
    404. 

  404. 				}
    405. 

  405. 			}
    406. 

  406. 			
    407. 

  407. 			// If the column has a constraint, look for valid values
    408. 

  408. 			if (in_array($info['type'], array('char', 'varchar')) && !empty($row['constraint'])) {
    409. 

  409. 				if (preg_match('/^\s*' . preg_quote($row['column'], '/') . '\s+in\s+\((.*?)\)\s*$/i', $row['constraint'], $match)) {
    410. 

  410. 					if (preg_match_all("/(?<!')'((''|[^']+)*)'/", $match[1], $matches, PREG_PATTERN_ORDER)) {
    411. 

  411. 						$info['valid_values'] = str_replace("''", "'", $matches[1]);
    412. 

  412. 					}			
    413. 

  413. 				}
    414. 

  414. 			}
    415. 

  415. 			
    416. 

  416. 			// Handle auto increment
    417. 

  417. 			if ($row['auto_increment']) {
    418. 

  418. 				$info['auto_increment'] = TRUE;
    419. 

  419. 			}
    420. 

  420. 			
    421. 

  421. 			// Handle default values
    422. 

  422. 			if ($row['default'] !== NULL) {
    423. 

  423. 				if ($row['default'] == 'NULL') {
    424. 

  424. 					$info['default'] = NULL;
    425. 

  425. 				} elseif (in_array($info['type'], array('char', 'varchar', 'text', 'timestamp')) ) {
    426. 

  426. 					$info['default'] = substr($row['default'], 1, -1);
    427. 

  427. 				} elseif ($info['type'] == 'boolean') {
    428. 

  428. 					$info['default'] = (boolean) substr($row['default'], 1, -1);
    429. 

  429. 				} else {
    430. 

  430. 					$info['default'] = $row['default'];
    431. 

  431. 				}
    432. 

  432. 			}
    433. 

  433. 			
    434. 

  434. 			// Handle not null
    435. 

  435. 			$info['not_null'] = ($row['nullable'] == 'N') ? TRUE : FALSE;
    436. 

  436. 			
    437. 

  437. 			$column_info[$row['column']] = $info;
    438. 

  438. 		}
    439. 

  439. 		
    440. 

  440. 		return $column_info;
    441. 

  441. 	}
    442. 

  442. 	
    443. 

  443. 	
    444. 

  444. 	/**
    445. 

  445. 	 * Fetches the key info for a DB2 database
    446. 

  446. 	 * 
    447. 

  447. 	 * @return array  The keys arrays for every table in the database - see ::getKeys() for details
    448. 

  448. 	 */
    449. 

  449. 	private function fetchDB2Keys()
    450. 

  450. 	{
    451. 

  451. 		$keys = array();
    452. 

  452. 		
    453. 

  453. 		$default_schema = strtolower($this->database->getUsername());
    454. 

  454. 		
    455. 

  455. 		$tables = $this->getTables();
    456. 

  456. 		foreach ($tables as $table) {
    457. 

  457. 			$keys[$table] = array();
    458. 

  458. 			$keys[$table]['primary'] = array();
    459. 

  459. 			$keys[$table]['unique']  = array();
    460. 

  460. 			$keys[$table]['foreign'] = array();
    461. 

  461. 		}
    462. 

  462. 		
    463. 

  463. 		$params  = array();
    464. 

  464. 		
    465. 

  465. 		$sql  = "(SELECT
    466. 

  466. 					 LOWER(RTRIM(R.TABSCHEMA)) AS \"SCHEMA\",
    467. 

  467. 					 LOWER(R.TABNAME) AS \"TABLE\",
    468. 

  468. 					 R.CONSTNAME AS CONSTRAINT_NAME,
    469. 

  469. 					 'foreign' AS \"TYPE\",
    470. 

  470. 					 LOWER(K.COLNAME) AS \"COLUMN\",
    471. 

  471. 					 LOWER(RTRIM(R.REFTABSCHEMA)) AS FOREIGN_SCHEMA,
    472. 

  472. 					 LOWER(R.REFTABNAME) AS FOREIGN_TABLE,
    473. 

  473. 					 LOWER(FK.COLNAME) AS FOREIGN_COLUMN,
    474. 

  474. 					 CASE R.DELETERULE WHEN 'C' THEN 'cascade' WHEN 'A' THEN 'no_action' WHEN 'R' THEN 'restrict' ELSE 'set_null' END AS ON_DELETE,
    475. 

  475. 					 CASE R.UPDATERULE WHEN 'A' THEN 'no_action' WHEN 'R' THEN 'restrict' END AS ON_UPDATE,
    476. 

  476. 					 K.COLSEQ
    477. 

  477. 				 FROM
    478. 

  478. 					 SYSCAT.REFERENCES AS R INNER JOIN 
    479. 

  479. 					 SYSCAT.KEYCOLUSE AS K ON R.CONSTNAME = K.CONSTNAME AND R.TABSCHEMA = K.TABSCHEMA AND R.TABNAME = K.TABNAME INNER JOIN
    480. 

  480. 					 SYSCAT.KEYCOLUSE AS FK ON R.REFKEYNAME = FK.CONSTNAME AND R.REFTABSCHEMA = FK.TABSCHEMA AND R.REFTABNAME = FK.TABNAME
    481. 

  481. 				 WHERE ";
    482. 

  482. 		
    483. 

  483. 		$conditions = array();
    484. 

  484. 		foreach ($tables as $table) {
    485. 

  485. 			if (strpos($table, '.') === FALSE) {
    486. 

  486. 				$table = $default_schema . '.' . $table;
    487. 

  487. 			}	
    488. 

  488. 			list ($schema, $table) = explode('.', strtoupper($table));
    489. 

  489. 			$conditions[] = "R.TABSCHEMA = %s AND R.TABNAME = %s";
    490. 

  490. 			$params[] = $schema;
    491. 

  491. 			$params[] = $table;
    492. 

  492. 		}
    493. 

  493. 		$sql .= '((' . join(') OR( ', $conditions) . '))';
    494. 

  494. 		 
    495. 

  495. 		$sql .= "
    496. 

  496. 				 ) UNION (
    497. 

  497. 				 SELECT
    498. 

  498. 					 LOWER(RTRIM(I.TABSCHEMA)) AS \"SCHEMA\",
    499. 

  499. 					 LOWER(I.TABNAME) AS \"TABLE\",
    500. 

  500. 					 LOWER(I.INDNAME) AS CONSTRAINT_NAME,
    501. 

  501. 					 CASE I.UNIQUERULE WHEN 'U' THEN 'unique' ELSE 'primary' END AS \"TYPE\",
    502. 

  502. 					 LOWER(C.COLNAME) AS \"COLUMN\",
    503. 

  503. 					 NULL AS FOREIGN_SCHEMA,
    504. 

  504. 					 NULL AS FOREIGN_TABLE,
    505. 

  505. 					 NULL AS FOREIGN_COLUMN,
    506. 

  506. 					 NULL AS ON_DELETE,
    507. 

  507. 					 NULL AS ON_UPDATE,
    508. 

  508. 					 C.COLSEQ
    509. 

  509. 				 FROM
    510. 

  510. 					 SYSCAT.INDEXES AS I INNER JOIN
    511. 

  511. 					 SYSCAT.INDEXCOLUSE AS C ON I.INDSCHEMA = C.INDSCHEMA AND I.INDNAME = C.INDNAME
    512. 

  512. 				 WHERE
    513. 

  513. 					 I.UNIQUERULE IN ('U', 'P') AND
    514. 

  514. 					 ";
    515. 

  515. 		
    516. 

  516. 		$conditions = array();
    517. 

  517. 		foreach ($tables as $table) {
    518. 

  518. 			if (strpos($table, '.') === FALSE) {
    519. 

  519. 				$table = $default_schema . '.' . $table;
    520. 

  520. 			}	
    521. 

  521. 			list ($schema, $table) = explode('.', strtoupper($table));
    522. 

  522. 			$conditions[] = "I.TABSCHEMA = %s AND I.TABNAME = %s";
    523. 

  523. 			$params[] = $schema;
    524. 

  524. 			$params[] = $table;
    525. 

  525. 		}
    526. 

  526. 		$sql .= '((' . join(') OR( ', $conditions) . '))';
    527. 

  527. 		
    528. 

  528. 		$sql .= "
    529. 

  529. 				 )
    530. 

  530. 				 ORDER BY 4, 1, 2, 3, 11";
    531. 

  531. 		
    532. 

  532. 		$result = $this->database->query($sql, $params);
    533. 

  533. 		
    534. 

  534. 		$last_name  = '';
    535. 

  535. 		$last_table = '';
    536. 

  536. 		$last_type  = '';
    537. 

  537. 		foreach ($result as $row) {
    538. 

  538. 			
    539. 

  539. 			if ($row['constraint_name'] != $last_name) {
    540. 

  540. 				
    541. 

  541. 				if ($last_name) {
    542. 

  542. 					if ($last_type == 'foreign' || $last_type == 'unique') {
    543. 

  543. 						$keys[$last_table][$last_type][] = $temp;
    544. 

  544. 					} else {
    545. 

  545. 						$keys[$last_table][$last_type] = $temp;
    546. 

  546. 					}
    547. 

  547. 				}
    548. 

  548. 				
    549. 

  549. 				$temp = array();
    550. 

  550. 				if ($row['type'] == 'foreign') {
    551. 

  551. 					
    552. 

  552. 					$temp['column']         = $row['column'];
    553. 

  553. 					$temp['foreign_table']  = $row['foreign_table'];
    554. 

  554. 					if ($row['foreign_schema'] != $default_schema) {
    555. 

  555. 						$temp['foreign_table'] = $row['foreign_schema'] . '.' . $temp['foreign_table'];
    556. 

  556. 					}
    557. 

  557. 					$temp['foreign_column'] = $row['foreign_column'];
    558. 

  558. 					$temp['on_delete']      = 'no_action';
    559. 

  559. 					$temp['on_update']      = 'no_action';
    560. 

  560. 					
    561. 

  561. 					if (!empty($row['on_delete'])) {
    562. 

  562. 						$temp['on_delete'] = $row['on_delete'];
    563. 

  563. 					}
    564. 

  564. 					if (!empty($row['on_update'])) {
    565. 

  565. 						$temp['on_update'] = $row['on_update'];
    566. 

  566. 					}
    567. 

  567. 					
    568. 

  568. 				} else {
    569. 

  569. 					$temp[] = $row['column'];
    570. 

  570. 				}
    571. 

  571. 				
    572. 

  572. 				$last_table = $row['table'];
    573. 

  573. 				if ($row['schema'] != $default_schema) {
    574. 

  574. 					$last_table = $row['schema'] . '.' . $last_table;
    575. 

  575. 				}
    576. 

  576. 				$last_name  = $row['constraint_name'];
    577. 

  577. 				$last_type  = $row['type'];
    578. 

  578. 				
    579. 

  579. 			} else {
    580. 

  580. 				$temp[] = $row['column'];
    581. 

  581. 			}
    582. 

  582. 		}
    583. 

  583. 		
    584. 

  584. 		if (isset($temp)) {
    585. 

  585. 			if ($last_type == 'foreign' || $last_type == 'unique') {
    586. 

  586. 				$keys[$last_table][$last_type][] = $temp;
    587. 

  587. 			} else {
    588. 

  588. 				$keys[$last_table][$last_type] = $temp;
    589. 

  589. 			}
    590. 

  590. 		}
    591. 

  591. 		
    592. 

  592. 		return $keys;
    593. 

  593. 	}
    594. 

  594. 	
    595. 

  595. 	
    596. 

  596. 	/**
    597. 

  597. 	 * Gets the `PRIMARY KEY`, `FOREIGN KEY` and `UNIQUE` key constraints from the database
    598. 

  598. 	 * 
    599. 

  599. 	 * @return void
    600. 

  600. 	 */
    601. 

  601. 	private function fetchKeys()
    602. 

  602. 	{
    603. 

  603. 		if ($this->keys) {
    604. 

  604. 			return;	
    605. 

  605. 		}
    606. 

  606. 		
    607. 

  607. 		switch ($this->database->getType()) {
    608. 

  608. 			case 'db2':
    609. 

  609. 				$keys = $this->fetchDB2Keys();
    610. 

  610. 				break;
    611. 

  611. 			
    612. 

  612. 			case 'mssql':
    613. 

  613. 				$keys = $this->fetchMSSQLKeys();
    614. 

  614. 				break;
    615. 

  615. 				
    616. 

  616. 			case 'mysql':
    617. 

  617. 				$keys = $this->fetchMySQLKeys();
    618. 

  618. 				break;
    619. 

  619. 				
    620. 

  620. 			case 'oracle':
    621. 

  621. 				$keys = $this->fetchOracleKeys();
    622. 

  622. 				break;
    623. 

  623. 			
    624. 

  624. 			case 'postgresql':
    625. 

  625. 				$keys = $this->fetchPostgreSQLKeys();
    626. 

  626. 				break;
    627. 

  627. 			
    628. 

  628. 			case 'sqlite':
    629. 

  629. 				$keys = $this->fetchSQLiteKeys();
    630. 

  630. 				break;
    631. 

  631. 		}
    632. 

  632. 		
    633. 

  633. 		$this->keys = $keys;
    634. 

  634. 		if ($this->cache) {
    635. 

  635. 			$this->cache->set($this->makeCachePrefix() . 'keys', $this->keys);	
    636. 

  636. 		}
    637. 

  637. 	}
    638. 

  638. 	
    639. 

  639. 	
    640. 

  640. 	/**
    641. 

  641. 	 * Gets the column info from a MSSQL database
    642. 

  642. 	 * 
    643. 

  643. 	 * @param  string $table  The table to fetch the column info for
    644. 

  644. 	 * @return array  The column info for the table specified - see ::getColumnInfo() for details
    645. 

  645. 	 */
    646. 

  646. 	private function fetchMSSQLColumnInfo($table)
    647. 

  647. 	{
    648. 

  648. 		$column_info = array();
    649. 

  649. 		
    650. 

  650. 		$schema = 'dbo';
    651. 

  651. 		if (strpos($table, '.') !== FALSE) {
    652. 

  652. 			list ($schema, $table) = explode('.', $table);
    653. 

  653. 		}
    654. 

  654. 		
    655. 

  655. 		$data_type_mapping = array(
    656. 

  656. 			'bit'               => 'boolean',
    657. 

  657. 			'tinyint'           => 'integer',
    658. 

  658. 			'smallint'          => 'integer',
    659. 

  659. 			'int'               => 'integer',
    660. 

  660. 			'bigint'            => 'integer',
    661. 

  661. 			'timestamp'         => 'integer',
    662. 

  662. 			'datetime'          => 'timestamp',
    663. 

  663. 			'smalldatetime'     => 'timestamp',
    664. 

  664. 			'datetime2'         => 'timestamp',
    665. 

  665. 			'date'              => 'date',
    666. 

  666. 			'time'              => 'time',
    667. 

  667. 			'varchar'           => 'varchar',
    668. 

  668. 			'nvarchar'          => 'varchar',
    669. 

  669. 			'uniqueidentifier'  => 'varchar',
    670. 

  670. 			'char'              => 'char',
    671. 

  671. 			'nchar'             => 'char',
    672. 

  672. 			'real'              => 'float',
    673. 

  673. 			'float'             => 'float',
    674. 

  674. 			'money'             => 'float',
    675. 

  675. 			'smallmoney'        => 'float',
    676. 

  676. 			'decimal'           => 'float',
    677. 

  677. 			'numeric'           => 'float',
    678. 

  678. 			'binary'            => 'blob',
    679. 

  679. 			'varbinary'         => 'blob',
    680. 

  680. 			'image'             => 'blob',
    681. 

  681. 			'text'              => 'text',
    682. 

  682. 			'ntext'             => 'text',
    683. 

  683. 			'xml'               => 'text'
    684. 

  684. 		);
    685. 

  685. 		
    686. 

  686. 		$max_min_values = array(
    687. 

  687. 			'tinyint'    => array('min' => new fNumber(0),                       'max' => new fNumber(255)),
    688. 

  688. 			'smallint'   => array('min' => new fNumber(-32768),                  'max' => new fNumber(32767)),
    689. 

  689. 			'int'        => array('min' => new fNumber(-2147483648),             'max' => new fNumber(2147483647)),
    690. 

  690. 			'bigint'     => array('min' => new fNumber('-9223372036854775808'),  'max' => new fNumber('9223372036854775807')),
    691. 

  691. 			'smallmoney' => array('min' => new fNumber('-214748.3648'),          'max' => new fNumber('214748.3647')),
    692. 

  692. 			'money'      => array('min' => new fNumber('-922337203685477.5808'), 'max' => new fNumber('922337203685477.5807'))
    693. 

  693. 		);
    694. 

  694. 		
    695. 

  695. 		// Get the column info
    696. 

  696. 		$sql = "SELECT
    697. 

  697. 						c.column_name              AS 'column',
    698. 

  698. 						c.data_type                AS 'type',
    699. 

  699. 						c.is_nullable              AS nullable,
    700. 

  700. 						c.column_default           AS 'default',
    701. 

  701. 						c.character_maximum_length AS max_length,
    702. 

  702. 						c.numeric_precision        AS precision,
    703. 

  703. 						c.numeric_scale            AS decimal_places,
    704. 

  704. 						CASE
    705. 

  705. 							WHEN
    706. 

  706. 							  COLUMNPROPERTY(OBJECT_ID(QUOTENAME(c.table_schema) + '.' + QUOTENAME(c.table_name)), c.column_name, 'IsIdentity') = 1 AND
    707. 

  707. 							  OBJECTPROPERTY(OBJECT_ID(QUOTENAME(c.table_schema) + '.' + QUOTENAME(c.table_name)), 'IsMSShipped') = 0
    708. 

  708. 							THEN '1'
    709. 

  709. 							ELSE '0'
    710. 

  710. 						  END AS auto_increment,
    711. 

  711. 						cc.check_clause AS 'constraint'
    712. 

  712. 					FROM
    713. 

  713. 						INFORMATION_SCHEMA.COLUMNS AS c LEFT JOIN
    714. 

  714. 						INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE AS ccu ON c.column_name = ccu.column_name AND c.table_name = ccu.table_name AND c.table_catalog = ccu.table_catalog LEFT JOIN
    715. 

  715. 						INFORMATION_SCHEMA.CHECK_CONSTRAINTS AS cc ON ccu.constraint_name = cc.constraint_name AND ccu.constraint_catalog = cc.constraint_catalog
    716. 

  716. 					WHERE
    717. 

  717. 						c.table_name = %s AND
    718. 

  718. 						c.table_schema = %s AND
    719. 

  719. 						c.table_catalog = DB_NAME()";
    720. 

  720. 		
    721. 

  721. 		$result = $this->database->query($sql, $table, $schema);
    722. 

  722. 		
    723. 

  723. 		foreach ($result as $row) {
    724. 

  724. 			
    725. 

  725. 			$info = array();
    726. 

  726. 			
    727. 

  727. 			foreach ($data_type_mapping as $data_type => $mapped_data_type) {
    728. 

  728. 				if (stripos($row['type'], $data_type) === 0) {
    729. 

  729. 					if (isset($max_min_values[$data_type])) {
    730. 

  730. 						$info['min_value'] = $max_min_values[$data_type]['min'];
    731. 

  731. 						$info['max_value'] = $max_min_values[$data_type]['max'];
    732. 

  732. 					}
    733. 

  733. 					$info['type'] = $mapped_data_type;
    734. 

  734. 					break;
    735. 

  735. 				}
    736. 

  736. 			}
    737. 

  737. 			
    738. 

  738. 			// Handle decimal places and min/max for numeric/decimals
    739. 

  739. 			if (in_array(strtolower($row['type']), array('decimal', 'numeric'))) {
    740. 

  740. 				$info['decimal_places'] = $row['decimal_places'];
    741. 

  741. 				$before_digits = str_pad('', $row['precision'] - $row['decimal_places'], '9');
    742. 

  742. 				$after_digits  = str_pad('', $row['decimal_places'], '9');
    743. 

  743. 				$max_min       = $before_digits . ($after_digits ? '.' : '') . $after_digits;
    744. 

  744. 				$info['min_value'] = new fNumber('-' . $max_min);
    745. 

  745. 				$info['max_value'] = new fNumber($max_min);
    746. 

  746. 			}
    747. 

  747. 			
    748. 

  748. 			if (!isset($info['type'])) {
    749. 

  749. 				$info['type'] = $row['type'];
    750. 

  750. 			}
    751. 

  751. 			
    752. 

  752. 			// Handle decimal places for money/smallmoney
    753. 

  753. 			if (in_array($row['type'], array('money', 'smallmoney'))) {
    754. 

  754. 				$info['decimal_places'] = 2;
    755. 

  755. 			}
    756. 

  756. 			
    757. 

  757. 			// Handle the special data for varchar columns
    758. 

  758. 			if (in_array($info['type'], array('char', 'varchar', 'text', 'blob'))) {
    759. 

  759. 				if ($row['type'] == 'uniqueidentifier') {
    760. 

  760. 					$row['max_length'] = 32;
    761. 

  761. 				} elseif ($row['max_length'] == -1) {
    762. 

  762. 					$row['max_length'] = $row['type'] == 'nvarchar' ? 1073741823 : 2147483647;
    763. 

  763. 				}
    764. 

  764. 				$info['max_length'] = $row['max_length'];
    765. 

  765. 			}
    766. 

  766. 			
    767. 

  767. 			// If the column has a constraint, look for valid values
    768. 

  768. 			if (in_array($info['type'], array('char', 'varchar')) && !empty($row['constraint'])) {
    769. 

  769. 				if (preg_match('#^\(((?:(?: OR )?\[[^\]]+\]\s*=\s*\'(?:\'\'|[^\']+)+\')+)\)$#D', $row['constraint'], $matches)) {
    770. 

  770. 					$valid_values = explode(' OR ', $matches[1]);
    771. 

  771. 					foreach ($valid_values as $key => $value) {
    772. 

  772. 						$value = preg_replace('#^\s*\[' . preg_quote($row['column'], '#') . '\]\s*=\s*\'(.*)\'\s*$#', '\1', $value);
    773. 

  773. 						$valid_values[$key] = str_replace("''", "'", $value);
    774. 

  774. 					}
    775. 

  775. 					// SQL Server turns CHECK constraint values into a reversed list, so we fix it here
    776. 

  776. 					$info['valid_values'] = array_reverse($valid_values);
    777. 

  777. 				}
    778. 

  778. 			}
    779. 

  779. 			
    780. 

  780. 			// Handle auto increment
    781. 

  781. 			if ($row['auto_increment']) {
    782. 

  782. 				$info['auto_increment'] = TRUE;
    783. 

  783. 			}
    784. 

  784. 			
    785. 

  785. 			// Handle default values
    786. 

  786. 			if ($row['default'] !== NULL) {
    787. 

  787. 				if ($row['default'] == '(getdate())') {
    788. 

  788. 					$info['default'] = 'CURRENT_TIMESTAMP';
    789. 

  789. 				} elseif (in_array($info['type'], array('char', 'varchar', 'text', 'timestamp')) ) {
    790. 

  790. 					$info['default'] = substr($row['default'], 2, -2);
    791. 

  791. 				} elseif ($info['type'] == 'boolean') {
    792. 

  792. 					$info['default'] = (boolean) substr($row['default'], 2, -2);
    793. 

  793. 				} elseif (in_array($info['type'], array('integer', 'float')) ) {
    794. 

  794. 					$info['default'] = str_replace(array('(', ')'), '', $row['default']);
    795. 

  795. 				} else {
    796. 

  796. 					$info['default'] = pack('H*', substr($row['default'], 3, -1));
    797. 

  797. 				}
    798. 

  798. 			}
    799. 

  799. 			
    800. 

  800. 			// Handle not null
    801. 

  801. 			$info['not_null'] = ($row['nullable'] == 'NO') ? TRUE : FALSE;
    802. 

  802. 			
    803. 

  803. 			$column_info[$row['column']] = $info;
    804. 

  804. 		}
    805. 

  805. 		
    806. 

  806. 		return $column_info;
    807. 

  807. 	}
    808. 

  808. 	
    809. 

  809. 	
    810. 

  810. 	/**
    811. 

  811. 	 * Fetches the key info for an MSSQL database
    812. 

  812. 	 * 
    813. 

  813. 	 * @return array  The key info arrays for every table in the database - see ::getKeys() for details
    814. 

  814. 	 */
    815. 

  815. 	private function fetchMSSQLKeys()
    816. 

  816. 	{
    817. 

  817. 		$keys = array();
    818. 

  818. 		
    819. 

  819. 		$tables   = $this->getTables();
    820. 

  820. 		foreach ($tables as $table) {
    821. 

  821. 			$keys[$table] = array();
    822. 

  822. 			$keys[$table]['primary'] = array();
    823. 

  823. 			$keys[$table]['unique']  = array();
    824. 

  824. 			$keys[$table]['foreign'] = array();
    825. 

  825. 		}
    826. 

  826. 		
    827. 

  827. 		$sql  = "SELECT
    828. 

  828. 						c.table_schema AS \"schema\",
    829. 

  829. 						c.table_name AS \"table\",
    830. 

  830. 						kcu.constraint_name AS constraint_name,
    831. 

  831. 						CASE c.constraint_type
    832. 

  832. 							WHEN 'PRIMARY KEY' THEN 'primary'
    833. 

  833. 							WHEN 'FOREIGN KEY' THEN 'foreign'
    834. 

  834. 							WHEN 'UNIQUE' THEN 'unique'
    835. 

  835. 						END AS 'type',
    836. 

  836. 						kcu.column_name AS 'column',
    837. 

  837. 						ccu.table_schema AS foreign_schema,
    838. 

  838. 						ccu.table_name AS foreign_table,
    839. 

  839. 						ccu.column_name AS foreign_column,
    840. 

  840. 						REPLACE(LOWER(rc.delete_rule), ' ', '_') AS on_delete,
    841. 

  841. 						REPLACE(LOWER(rc.update_rule), ' ', '_') AS on_update
    842. 

  842. 					FROM
    843. 

  843. 						INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS c INNER JOIN
    844. 

  844. 						INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu ON c.table_name = kcu.table_name AND c.constraint_name = kcu.constraint_name LEFT JOIN
    845. 

  845. 						INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS AS rc ON c.constraint_name = rc.constraint_name LEFT JOIN
    846. 

  846. 						INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE AS ccu ON ccu.constraint_name = rc.unique_constraint_name
    847. 

  847. 					WHERE
    848. 

  848. 						c.constraint_catalog = DB_NAME() AND
    849. 

  849. 						c.table_name != 'sysdiagrams'
    850. 

  850. 					ORDER BY
    851. 

  851. 						LOWER(c.table_schema),
    852. 

  852. 						LOWER(c.table_name),
    853. 

  853. 						c.constraint_type,
    854. 

  854. 						LOWER(kcu.constraint_name),
    855. 

  855. 						kcu.ordinal_position,
    856. 

  856. 						LOWER(kcu.column_name)";
    857. 

  857. 		
    858. 

  858. 		$result = $this->database->query($sql);
    859. 

  859. 		
    860. 

  860. 		$last_name  = '';
    861. 

  861. 		$last_table = '';
    862. 

  862. 		$last_type  = '';
    863. 

  863. 		foreach ($result as $row) {
    864. 

  864. 			
    865. 

  865. 			if ($row['constraint_name'] != $last_name) {
    866. 

  866. 				
    867. 

  867. 				if ($last_name) {
    868. 

  868. 					if ($last_type == 'foreign' || $last_type == 'unique') {
    869. 

  869. 						if (!isset($keys[$last_table][$last_type])) {
    870. 

  870. 							$keys[$last_table][$last_type] = array();		
    871. 

  871. 						}
    872. 

  872. 						$keys[$last_table][$last_type][] = $temp;
    873. 

  873. 					} else {
    874. 

  874. 						$keys[$last_table][$last_type] = $temp;
    875. 

  875. 					}
    876. 

  876. 				}
    877. 

  877. 				
    878. 

  878. 				$temp = array();
    879. 

  879. 				if ($row['type'] == 'foreign') {
    880. 

  880. 					
    881. 

  881. 					$temp['column']         = $row['column'];
    882. 

  882. 					$temp['foreign_table']  = $row['foreign_table'];
    883. 

  883. 					if ($row['foreign_schema'] != 'dbo') {
    884. 

  884. 						 $temp['foreign_table'] = $row['foreign_schema'] . '.' . $temp['foreign_table'];	
    885. 

  885. 					}
    886. 

  886. 					$temp['foreign_column'] = $row['foreign_column'];
    887. 

  887. 					$temp['on_delete']      = 'no_action';
    888. 

  888. 					$temp['on_update']      = 'no_action';
    889. 

  889. 					if (!empty($row['on_delete'])) {
    890. 

  890. 						$temp['on_delete'] = $row['on_delete'];
    891. 

  891. 					}
    892. 

  892. 					if (!empty($row['on_update'])) {
    893. 

  893. 						$temp['on_update'] = $row['on_update'];
    894. 

  894. 					}
    895. 

  895. 					
    896. 

  896. 				} else {
    897. 

  897. 					$temp[] = $row['column'];
    898. 

  898. 				}
    899. 

  899. 				
    900. 

  900. 				$last_table = $row['table'];
    901. 

  901. 				if ($row['schema'] != 'dbo') {
    902. 

  902. 					$last_table = $row['schema'] . '.' . $last_table;	
    903. 

  903. 				}
    904. 

  904. 				$last_name  = $row['constraint_name'];
    905. 

  905. 				$last_type  = $row['type'];
    906. 

  906. 				
    907. 

  907. 			} else {
    908. 

  908. 				$temp[] = $row['column'];
    909. 

  909. 			}
    910. 

  910. 		}
    911. 

  911. 		
    912. 

  912. 		if (isset($temp)) {
    913. 

  913. 			if ($last_type == 'foreign' || $last_type == 'unique') {
    914. 

  914. 				if (!isset($keys[$last_table][$last_type])) {
    915. 

  915. 					$keys[$last_table][$last_type] = array();		
    916. 

  916. 				}
    917. 

  917. 				$keys[$last_table][$last_type][] = $temp;
    918. 

  918. 			} else {
    919. 

  919. 				$keys[$last_table][$last_type] = $temp;
    920. 

  920. 			}
    921. 

  921. 		}
    922. 

  922. 		
    923. 

  923. 		return $keys;
    924. 

  924. 	}
    925. 

  925. 	
    926. 

  926. 	
    927. 

  927. 	/**
    928. 

  928. 	 * Gets the column info from a MySQL database
    929. 

  929. 	 * 
    930. 

  930. 	 * @param  string $table  The table to fetch the column info for
    931. 

  931. 	 * @return array  The column info for the table specified - see ::getColumnInfo() for details
    932. 

  932. 	 */
    933. 

  933. 	private function fetchMySQLColumnInfo($table)
    934. 

  934. 	{
    935. 

  935. 		$data_type_mapping = array(
    936. 

  936. 			'tinyint'			=> 'integer',
    937. 

  937. 			'smallint'			=> 'integer',
    938. 

  938. 			'mediumint'         => 'integer',
    939. 

  939. 			'int'				=> 'integer',
    940. 

  940. 			'bigint'			=> 'integer',
    941. 

  941. 			'datetime'			=> 'timestamp',
    942. 

  942. 			'timestamp'			=> 'timestamp',
    943. 

  943. 			'date'				=> 'date',
    944. 

  944. 			'time'				=> 'time',
    945. 

  945. 			'enum'				=> 'varchar',
    946. 

  946. 			'set'               => 'varchar',
    947. 

  947. 			'varchar'			=> 'varchar',
    948. 

  948. 			'char'				=> 'char',
    949. 

  949. 			'float'				=> 'float',
    950. 

  950. 			'double'			=> 'float',
    951. 

  951. 			'decimal'			=> 'float',
    952. 

  952. 			'binary'            => 'blob',
    953. 

  953. 			'varbinary'         => 'blob',
    954. 

  954. 			'tinyblob'			=> 'blob',
    955. 

  955. 			'blob'				=> 'blob',
    956. 

  956. 			'mediumblob'		=> 'blob',
    957. 

  957. 			'longblob'			=> 'blob',
    958. 

  958. 			'tinytext'			=> 'text',
    959. 

  959. 			'text'				=> 'text',
    960. 

  960. 			'mediumtext'		=> 'text',
    961. 

  961. 			'longtext'			=> 'text'
    962. 

  962. 		);
    963. 

  963. 		
    964. 

  964. 		$max_min_values = array(
    965. 

  965. 			'tinyint'             => array('min' => new fNumber(-128),                    'max' => new fNumber(127)),
    966. 

  966. 			'unsigned tinyint'    => array('min' => new fNumber(0),                       'max' => new fNumber(255)),
    967. 

  967. 			'smallint'            => array('min' => new fNumber(-32768),                  'max' => new fNumber(32767)),
    968. 

  968. 			'unsigned smallint'   => array('min' => new fNumber(0),                       'max' => new fNumber(65535)),
    969. 

  969. 			'mediumint'           => array('min' => new fNumber(-8388608),                'max' => new fNumber(8388607)),
    970. 

  970. 			'unsigned mediumint'  => array('min' => new fNumber(0),                       'max' => new fNumber(16777215)),
    971. 

  971. 			'int'                 => array('min' => new fNumber(-2147483648),             'max' => new fNumber(2147483647)),
    972. 

  972. 			'unsigned int'        => array('min' => new fNumber(0),                       'max' => new fNumber('4294967295')),
    973. 

  973. 			'bigint'              => array('min' => new fNumber('-9223372036854775808'),  'max' => new fNumber('9223372036854775807')),
    974. 

  974. 			'unsigned bigint'     => array('min' => new fNumber(0),                       'max' => new fNumber('18446744073709551615'))
    975. 

  975. 		);
    976. 

  976. 		
    977. 

  977. 		$column_info = array();
    978. 

  978. 		
    979. 

  979. 		$result     = $this->database->query('SHOW CREATE TABLE %r', $table);
    980. 

  980. 		
    981. 

  981. 		try {
    982. 

  982. 			$row        = $result->fetchRow();
    983. 

  983. 			$create_sql = $row['Create Table'];
    984. 

  984. 		} catch (fNoRowsException $e) {
    985. 

  985. 			return array();
    986. 

  986. 		}
    987. 

  987. 		
    988. 

  988. 		preg_match_all('#(?<=,|\()\s+(?:"|\`)(\w+)(?:"|\`)\s+(?:([a-z]+)(?:\(([^)]+)\))?( unsigned)?(?: zerofill)?)(?: character set [^ ]+)?(?: collate [^ ]+)?(?: NULL)?( NOT NULL)?(?: DEFAULT ((?:[^, \']*|\'(?:\'\'|[^\']+)*\')))?( auto_increment)?( COMMENT \'(?:\'\'|[^\']+)*\')?( ON UPDATE CURRENT_TIMESTAMP)?\s*(?:,|\s*(?=\)))#mi', $create_sql, $matches, PREG_SET_ORDER);
    989. 

  989. 		
    990. 

  990. 		foreach ($matches as $match) {
    991. 

  991. 			
    992. 

  992. 			$info = array();
    993. 

  993. 			
    994. 

  994. 			foreach ($data_type_mapping as $data_type => $mapped_data_type) {
    995. 

  995. 				if (stripos($match[2], $data_type) === 0) {
    996. 

  996. 					if ($match[2] == 'tinyint' && $match[3] == 1) {
    997. 

  997. 						$mapped_data_type = 'boolean';
    998. 

  998. 					
    999. 

  999. 					} elseif (preg_match('#((?:unsigned )?(?:tiny|small|medium|big)?int)#', (isset($match[4]) ? $match[4] . ' ' : '') . $data_type, $int_match)) {
    1000. 

  1000. 						if (isset($max_min_values[$int_match[1]])) {
    1001. 

  1001. 							$info['min_value'] = $max_min_values[$int_match[1]]['min'];
    1002. 

  1002. 							$info['max_value'] = $max_min_values[$int_match[1]]['max'];	
    1003. 

  1003. 						}
    1004. 

  1004. 					}
    1005. 

  1005. 					
    1006. 

  1006. 					$info['type'] = $mapped_data_type;
    1007. 

  1007. 					break;
    1008. 

  1008. 				}
    1009. 

  1009. 			}
    1010. 

  1010. 			if (!isset($info['type'])) {
    1011. 

  1011. 				$info['type'] = preg_replace('#^([a-z ]+).*$#iD', '\1', $match[2]);
    1012. 

  1012. 			}
    1013. 

  1013. 			
    1014. 

  1014. 			switch ($match[2]) {
    1015. 

  1015. 				case 'tinyblob':
    1016. 

  1016. 				case 'tinytext':
    1017. 

  1017. 					$info['max_length'] = 255;
    1018. 

  1018. 					break;
    1019. 

  1019. 				
    1020. 

  1020. 				case 'blob':
    1021. 

  1021. 				case 'text':
    1022. 

  1022. 					$info['max_length'] = 65535;
    1023. 

  1023. 					break;
    1024. 

  1024. 				
    1025. 

  1025. 				case 'mediumblob':
    1026. 

  1026. 				case 'mediumtext':
    1027. 

  1027. 					$info['max_length'] = 16777215;
    1028. 

  1028. 					break;
    1029. 

  1029. 				
    1030. 

  1030. 				case 'longblob':
    1031. 

  1031. 				case 'longtext':
    1032. 

  1032. 					$info['max_length'] = 4294967295;
    1033. 

  1033. 					break;
    1034. 

  1034. 			}
    1035. 

  1035. 		
    1036. 

  1036. 			if (stripos($match[2], 'enum') === 0) {
    1037. 

  1037. 				$info['valid_values'] = preg_replace("/^'|'\$/D", '', explode(",", $match[3]));
    1038. 

  1038. 				$match[3] = 0;
    1039. 

  1039. 				foreach ($info['valid_values'] as $valid_value) {
    1040. 

  1040. 					if (strlen(utf8_decode($valid_value)) > $match[3]) {
    1041. 

  1041. 						$match[3] = strlen(utf8_decode($valid_value));
    1042. 

  1042. 					}
    1043. 

  1043. 				}
    1044. 

  1044. 			}
    1045. 

  1045. 			
    1046. 

  1046. 			// The set data type is currently only supported as a varchar
    1047. 

  1047. 			// with a max length of all valid values concatenated by ,s
    1048. 

  1048. 			if (stripos($match[2], 'set') === 0) {
    1049. 

  1049. 				$values = preg_replace("/^'|'\$/D", '', explode(",", $match[3]));
    1050. 

  1050. 				$match[3] = strlen(join(',', $values));
    1051. 

  1051. 			}
    1052. 

  1052. 			
    1053. 

  1053. 			// Type specific information
    1054. 

  1054. 			if (in_array($info['type'], array('char', 'varchar'))) {
    1055. 

  1055. 				$info['max_length'] = $match[3];
    1056. 

  1056. 			}
    1057. 

  1057. 			
    1058. 

  1058. 			// Grab the number of decimal places
    1059. 

  1059. 			if (stripos($match[2], 'decimal') === 0) {
    1060. 

  1060. 				if (preg_match('#^\s*(\d+)\s*,\s*(\d+)\s*$#D', $match[3], $data_type_info)) {
    1061. 

  1061. 					$info['decimal_places'] = $data_type_info[2];
    1062. 

  1062. 					$before_digits = str_pad('', $data_type_info[1] - $info['decimal_places'], '9');
    1063. 

  1063. 					$after_digits  = str_pad('', $info['decimal_places'], '9');
    1064. 

  1064. 					$max_min       = $before_digits . ($after_digits ? '.' : '') . $after_digits;
    1065. 

  1065. 					$info['min_value'] = new fNumber('-' . $max_min);
    1066. 

  1066. 					$info['max_value'] = new fNumber($max_min);
    1067. 

  1067. 				}
    1068. 

  1068. 			}
    1069. 

  1069. 			
    1070. 

  1070. 			// Not null
    1071. 

  1071. 			$info['not_null'] = (!empty($match[5])) ? TRUE : FALSE;
    1072. 

  1072. 		
    1073. 

  1073. 			// Default values
    1074. 

  1074. 			if (!empty($match[6]) && $match[6] != 'NULL') {
    1075. 

  1075. 				$info['default'] = preg_replace("/^'|'\$/D", '', $match[6]);
    1076. 

  1076. 			}
    1077. 

  1077. 			
    1078. 

  1078. 			if ($info['type'] == 'boolean' && isset($info['default'])) {
    1079. 

  1079. 				$info['default'] = (boolean) $info['default'];
    1080. 

  1080. 			}
    1081. 

  1081. 		
    1082. 

  1082. 			// Auto increment fields
    1083. 

  1083. 			if (!empty($match[7])) {
    1084. 

  1084. 				$info['auto_increment'] = TRUE;
    1085. 

  1085. 			}
    1086. 

  1086. 		
    1087. 

  1087. 			$column_info[$match[1]] = $info;
    1088. 

  1088. 		}
    1089. 

  1089. 		
    1090. 

  1090. 		return $column_info;
    1091. 

  1091. 	}
    1092. 

  1092. 	
    1093. 

  1093. 	
    1094. 

  1094. 	/**
    1095. 

  1095. 	 * Fetches the keys for a MySQL database
    1096. 

  1096. 	 * 
    1097. 

  1097. 	 * @return array  The keys arrays for every table in the database - see ::getKeys() for details
    1098. 

  1098. 	 */
    1099. 

  1099. 	private function fetchMySQLKeys()
    1100. 

  1100. 	{
    1101. 

  1101. 		$tables   = $this->getTables();
    1102. 

  1102. 		$keys = array();
    1103. 

  1103. 		
    1104. 

  1104. 		foreach ($tables as $table) {
    1105. 

  1105. 			
    1106. 

  1106. 			$keys[$table] = array();
    1107. 

  1107. 			$keys[$table]['primary'] = array();
    1108. 

  1108. 			$keys[$table]['foreign'] = array();
    1109. 

  1109. 			$keys[$table]['unique']  = array();
    1110. 

  1110. 			
    1111. 

  1111. 			$result = $this->database->query('SHOW CREATE TABLE %r', $table);
    1112. 

  1112. 			$row    = $result->fetchRow();
    1113. 

  1113. 			
    1114. 

  1114. 			// Primary keys
    1115. 

  1115. 			preg_match_all('/PRIMARY KEY\s+\("(.*?)"\),?\n/U', $row['Create Table'], $matches, PREG_SET_ORDER);
    1116. 

  1116. 			if (!empty($matches)) {
    1117. 

  1117. 				$keys[$table]['primary'] = explode('","', $matches[0][1]);
    1118. 

  1118. 			}
    1119. 

  1119. 			
    1120. 

  1120. 			// Unique keys
    1121. 

  1121. 			preg_match_all('/UNIQUE KEY\s+"([^"]+)"\s+\("(.*?)"\),?\n/U', $row['Create Table'], $matches, PREG_SET_ORDER);
    1122. 

  1122. 			foreach ($matches as $match) {
    1123. 

  1123. 				$keys[$table]['unique'][] = explode('","', $match[2]);
    1124. 

  1124. 			}
    1125. 

  1125. 			
    1126. 

  1126. 			// Foreign keys
    1127. 

  1127. 			preg_match_all('#FOREIGN KEY \("([^"]+)"\) REFERENCES "([^"]+)" \("([^"]+)"\)(?:\sON\sDELETE\s(SET\sNULL|SET\sDEFAULT|CASCADE|NO\sACTION|RESTRICT))?(?:\sON\sUPDATE\s(SET\sNULL|SET\sDEFAULT|CASCADE|NO\sACTION|RESTRICT))?#', $row['Create Table'], $matches, PREG_SET_ORDER);
    1128. 

  1128. 			foreach ($matches as $match) {
    1129. 

  1129. 				$temp = array('column'         => $match[1],
    1130. 

  1130. 							  'foreign_table'  => $match[2],
    1131. 

  1131. 							  'foreign_column' => $match[3],
    1132. 

  1132. 							  'on_delete'      => 'no_action',
    1133. 

  1133. 							  'on_update'      => 'no_action');
    1134. 

  1134. 				if (!empty($match[4])) {
    1135. 

  1135. 					$temp['on_delete'] = strtolower(str_replace(' ', '_', $match[4]));
    1136. 

  1136. 				}
    1137. 

  1137. 				if (!empty($match[5])) {
    1138. 

  1138. 					$temp['on_update'] = strtolower(str_replace(' ', '_', $match[5]));
    1139. 

  1139. 				}
    1140. 

  1140. 				$keys[$table]['foreign'][] = $temp;
    1141. 

  1141. 			}
    1142. 

  1142. 		}
    1143. 

  1143. 		
    1144. 

  1144. 		return $keys;
    1145. 

  1145. 	}
    1146. 

  1146. 	
    1147. 

  1147. 	
    1148. 

  1148. 	/**
    1149. 

  1149. 	 * Gets the column info from an Oracle database
    1150. 

  1150. 	 * 
    1151. 

  1151. 	 * @param  string $table  The table to fetch the column info for
    1152. 

  1152. 	 * @return array  The column info for the table specified - see ::getColumnInfo() for details
    1153. 

  1153. 	 */
    1154. 

  1154. 	private function fetchOracleColumnInfo($table)
    1155. 

  1155. 	{
    1156. 

  1156. 		$table = strtoupper($table);
    1157. 

  1157. 		
    1158. 

  1158. 		$schema = strtoupper($this->database->getUsername());
    1159. 

  1159. 		if (strpos($table, '.') !== FALSE) {
    1160. 

  1160. 			list ($schema, $table) = explode('.', $table);
    1161. 

  1161. 		}
    1162. 

  1162. 		
    1163. 

  1163. 		$column_info = array();
    1164. 

  1164. 		
    1165. 

  1165. 		$data_type_mapping = array(
    1166. 

  1166. 			'boolean'			=> 'boolean',
    1167. 

  1167. 			'number'            => 'integer',
    1168. 

  1168. 			'integer'			=> 'integer',
    1169. 

  1169. 			'timestamp'			=> 'timestamp',
    1170. 

  1170. 			'date'				=> 'date',
    1171. 

  1171. 			'varchar2'          => 'varchar',
    1172. 

  1172. 			'nvarchar2'			=> 'varchar',
    1173. 

  1173. 			'char'              => 'char',
    1174. 

  1174. 			'nchar'             => 'char',
    1175. 

  1175. 			'float'				=> 'float',
    1176. 

  1176. 			'binary_float'      => 'float',
    1177. 

  1177. 			'binary_double'     => 'float',
    1178. 

  1178. 			'blob'				=> 'blob',
    1179. 

  1179. 			'bfile'             => 'varchar',
    1180. 

  1180. 			'clob'				=> 'text',
    1181. 

  1181. 			'nclob'             => 'text'
    1182. 

  1182. 		);
    1183. 

  1183. 		
    1184. 

  1184. 		$sql = "SELECT
    1185. 

  1185. 						LOWER(ATC.COLUMN_NAME) COLUMN_NAME,
    1186. 

  1186. 						CASE
    1187. 

  1187. 							WHEN
    1188. 

  1188. 								ATC.DATA_TYPE = 'NUMBER' AND
    1189. 

  1189. 								ATC.DATA_PRECISION IS NULL AND
    1190. 

  1190. 								ATC.DATA_SCALE = 0
    1191. 

  1191. 							THEN
    1192. 

  1192. 								'integer'
    1193. 

  1193. 							WHEN
    1194. 

  1194. 								ATC.DATA_TYPE = 'NUMBER' AND
    1195. 

  1195. 								ATC.DATA_PRECISION = 1 AND
    1196. 

  1196. 								ATC.DATA_SCALE = 0
    1197. 

  1197. 							THEN
    1198. 

  1198. 								'boolean'
    1199. 

  1199. 							WHEN
    1200. 

  1200. 								ATC.DATA_TYPE = 'NUMBER' AND
    1201. 

  1201. 								ATC.DATA_PRECISION IS NOT NULL AND
    1202. 

  1202. 								ATC.DATA_SCALE != 0 AND
    1203. 

  1203. 								ATC.DATA_SCALE IS NOT NULL
    1204. 

  1204. 							THEN
    1205. 

  1205. 								'float'
    1206. 

  1206. 							ELSE
    1207. 

  1207. 								LOWER(ATC.DATA_TYPE)
    1208. 

  1208. 							END DATA_TYPE,
    1209. 

  1209. 						CASE
    1210. 

  1210. 							WHEN
    1211. 

  1211. 								ATC.CHAR_LENGTH <> 0
    1212. 

  1212. 							THEN
    1213. 

  1213. 								ATC.CHAR_LENGTH
    1214. 

  1214. 							WHEN
    1215. 

  1215. 								ATC.DATA_TYPE = 'NUMBER' AND
    1216. 

  1216. 								ATC.DATA_PRECISION != 1 AND
    1217. 

  1217. 								ATC.DATA_SCALE != 0	AND
    1218. 

  1218. 								ATC.DATA_PRECISION IS NOT NULL
    1219. 

  1219. 							THEN
    1220. 

  1220. 								ATC.DATA_SCALE
    1221. 

  1221. 							ELSE
    1222. 

  1222. 								NULL
    1223. 

  1223. 							END LENGTH,
    1224. 

  1224. 						ATC.DATA_PRECISION PRECISION,
    1225. 

  1225. 						ATC.NULLABLE,
    1226. 

  1226. 						ATC.DATA_DEFAULT,
    1227. 

  1227. 						AC.SEARCH_CONDITION CHECK_CONSTRAINT
    1228. 

  1228. 					FROM
    1229. 

  1229. 						ALL_TAB_COLUMNS ATC LEFT JOIN
    1230. 

  1230. 						ALL_CONS_COLUMNS ACC ON
    1231. 

  1231. 							ATC.OWNER = ACC.OWNER AND
    1232. 

  1232. 							ATC.COLUMN_NAME = ACC.COLUMN_NAME AND
    1233. 

  1233. 							ATC.TABLE_NAME = ACC.TABLE_NAME AND
    1234. 

  1234. 							ACC.POSITION IS NULL LEFT JOIN
    1235. 

  1235. 						ALL_CONSTRAINTS AC ON
    1236. 

  1236. 							AC.OWNER = ACC.OWNER AND
    1237. 

  1237. 							AC.CONSTRAINT_NAME = ACC.CONSTRAINT_NAME AND
    1238. 

  1238. 							AC.CONSTRAINT_TYPE = 'C' AND
    1239. 

  1239. 							AC.STATUS = 'ENABLED'
    1240. 

  1240. 					WHERE
    1241. 

  1241. 						ATC.TABLE_NAME = %s AND
    1242. 

  1242. 						ATC.OWNER = %s
    1243. 

  1243. 					ORDER BY
    1244. 

  1244. 						ATC.TABLE_NAME ASC,
    1245. 

  1245. 						ATC.COLUMN_ID ASC";
    1246. 

  1246. 		
    1247. 

  1247. 		$result = $this->database->query($sql, $table, $schema);
    1248. 

  1248. 		
    1249. 

  1249. 		foreach ($result as $row) {
    1250. 

  1250. 			
    1251. 

  1251. 			$column = $row['column_name'];
    1252. 

  1252. 			
    1253. 

  1253. 			// Since Oracle stores check constraints in LONG columns, it is
    1254. 

  1254. 			// not possible to check or modify the constraints in SQL which
    1255. 

  1255. 			// ends up causing multiple rows with duplicate data except for
    1256. 

  1256. 			// the check constraint
    1257. 

  1257. 			$duplicate = FALSE;
    1258. 

  1258. 			
    1259. 

  1259. 			if (isset($column_info[$column])) {
    1260. 

  1260. 				$info = $column_info[$column];
    1261. 

  1261. 				$duplicate = TRUE;
    1262. 

  1262. 			} else {
    1263. 

  1263. 				$info = array();
    1264. 

  1264. 			}
    1265. 

  1265. 			
    1266. 

  1266. 			if (!$duplicate) {
    1267. 

  1267. 				// Get the column type
    1268. 

  1268. 				foreach ($data_type_mapping as $data_type => $mapped_data_type) {
    1269. 

  1269. 					if (stripos($row['data_type'], $data_type) === 0) {
    1270. 

  1270. 						$info['type'] = $mapped_data_type;
    1271. 

  1271. 						break;
    1272. 

  1272. 					}
    1273. 

  1273. 				}
    1274. 

  1274. 				
    1275. 

  1275. 				if (!isset($info['type'])) {
    1276. 

  1276. 					$info['type'] = $row['data_type'];
    1277. 

  1277. 				}
    1278. 

  1278. 				
    1279. 

  1279. 				if (in_array($info['type'], array('blob', 'text'))) {
    1280. 

  1280. 					$info['max_length'] = 4294967295;
    1281. 

  1281. 				}
    1282. 

  1282. 				
    1283. 

  1283. 				if ($row['data_type'] == 'float' && $row['precision']) {
    1284. 

  1284. 					$row['length'] = (int) $row['length'];
    1285. 

  1285. 					$before_digits = str_pad('', $row['precision'] - $row['length'], '9');
    1286. 

  1286. 					$after_digits  = str_pad('', $row['length'], '9');
    1287. 

  1287. 					$max_min       = $before_digits . ($after_digits ? '.' : '') . $after_digits;
    1288. 

  1288. 					$info['min_value'] = new fNumber('-' . $max_min);
    1289. 

  1289. 					$info['max_value'] = new fNumber($max_min);	
    1290. 

  1290. 				}
    1291. 

  1291. 				
    1292. 

  1292. 				// Handle the length of decimal/numeric fields
    1293. 

  1293. 				if ($info['type'] == 'float' && $row['length']) {
    1294. 

  1294. 					$info['decimal_places'] = (int) $row['length'];
    1295. 

  1295. 				}
    1296. 

  1296. 				
    1297. 

  1297. 				// Handle the special data for varchar fields
    1298. 

  1298. 				if (in_array($info['type'], array('char', 'varchar'))) {
    1299. 

  1299. 					$info['max_length'] = (int) $row['length'];
    1300. 

  1300. 				}
    1301. 

  1301. 			}
    1302. 

  1302. 			
    1303. 

  1303. 			// Handle check constraints that are just simple lists
    1304. 

  1304. 			if (in_array($info['type'], array('varchar', 'char')) && $row['check_constraint']) {
    1305. 

  1305. 				if (preg_match('/^\s*' . preg_quote($column, '/') . '\s+in\s+\((.*?)\)\s*$/i', $row['check_constraint'], $match)) {
    1306. 

  1306. 					if (preg_match_all("/(?<!')'((''|[^']+)*)'/", $match[1], $matches, PREG_PATTERN_ORDER)) {
    1307. 

  1307. 						$info['valid_values'] = str_replace("''", "'", $matches[1]);
    1308. 

  1308. 					}			
    1309. 

  1309. 				}
    1310. 

  1310. 			}
    1311. 

  1311. 			
    1312. 

  1312. 			if (!$duplicate) {
    1313. 

  1313. 				// Handle default values
    1314. 

  1314. 				if ($row['data_default'] !== NULL) {
    1315. 

  1315. 					if (in_array($info['type'], array('char', 'varchar', 'text'))) {
    1316. 

  1316. 						$info['default'] = str_replace("''", "'", substr(trim($row['data_default']), 1, -1));
    1317. 

  1317. 						
    1318. 

  1318. 					} elseif ($info['type'] == 'boolean') {
    1319. 

  1319. 						$info['default'] = (boolean) trim($row['data_default']);
    1320. 

  1320. 						
    1321. 

  1321. 					} elseif (in_array($info['type'], array('integer', 'float'))) {
    1322. 

  1322. 						$info['default'] = trim($row['data_default']);
    1323. 

  1323. 						
    1324. 

  1324. 					} else {
    1325. 

  1325. 						$info['default'] = $row['data_default'];
    1326. 

  1326. 					}
    1327. 

  1327. 				}
    1328. 

  1328. 			
    1329. 

  1329. 				// Not null values
    1330. 

  1330. 				$info['not_null'] = ($row['nullable'] == 'N') ? TRUE : FALSE;
    1331. 

  1331. 			}
    1332. 

  1332. 			
    1333. 

  1333. 			$column_info[$column] = $info;
    1334. 

  1334. 		}
    1335. 

  1335. 		
    1336. 

  1336. 		$sql = "SELECT
    1337. 

  1337. 						TRIGGER_BODY
    1338. 

  1338. 					FROM
    1339. 

  1339. 						ALL_TRIGGERS
    1340. 

  1340. 					WHERE
    1341. 

  1341. 						TRIGGERING_EVENT = 'INSERT' AND
    1342. 

  1342. 						STATUS = 'ENABLED' AND
    1343. 

  1343. 						TRIGGER_NAME NOT LIKE 'BIN\$%' AND
    1344. 

  1344. 						TABLE_NAME = %s AND
    1345. 

  1345. 						OWNER = %s";
    1346. 

  1346. 						
    1347. 

  1347. 		foreach ($this->database->query($sql, $table, $schema) as $row) {
    1348. 

  1348. 			if (preg_match('#SELECT\s+(["\w.]+).nextval\s+INTO\s+:new\.(\w+)\s+FROM\s+dual#i', $row['trigger_body'], $matches)) {
    1349. 

  1349. 				$column = strtolower($matches[2]);
    1350. 

  1350. 				$column_info[$column]['auto_increment'] = TRUE;
    1351. 

  1351. 			}
    1352. 

  1352. 		}
    1353. 

  1353. 		
    1354. 

  1354. 		return $column_info;
    1355. 

  1355. 	}
    1356. 

  1356. 	
    1357. 

  1357. 	
    1358. 

  1358. 	/**
    1359. 

  1359. 	 * Fetches the key info for an Oracle database
    1360. 

  1360. 	 * 
    1361. 

  1361. 	 * @return array  The keys arrays for every table in the database - see ::getKeys() for details
    1362. 

  1362. 	 */
    1363. 

  1363. 	private function fetchOracleKeys()
    1364. 

  1364. 	{
    1365. 

  1365. 		$keys = array();
    1366. 

  1366. 		
    1367. 

  1367. 		$default_schema = strtolower($this->database->getUsername());
    1368. 

  1368. 		
    1369. 

  1369. 		$tables = $this->getTables();
    1370. 

  1370. 		foreach ($tables as $table) {
    1371. 

  1371. 			$keys[$table] = array();
    1372. 

  1372. 			$keys[$table]['primary'] = array();
    1373. 

  1373. 			$keys[$table]['unique']  = array();
    1374. 

  1374. 			$keys[$table]['foreign'] = array();
    1375. 

  1375. 		}
    1376. 

  1376. 		
    1377. 

  1377. 		$params = array();
    1378. 

  1378. 		
    1379. 

  1379. 		$sql  = "SELECT
    1380. 

  1380. 						 LOWER(AC.OWNER) \"SCHEMA\",
    1381. 

  1381. 						 LOWER(AC.TABLE_NAME) \"TABLE\",
    1382. 

  1382. 						 AC.CONSTRAINT_NAME CONSTRAINT_NAME,
    1383. 

  1383. 						 CASE AC.CONSTRAINT_TYPE
    1384. 

  1384. 							 WHEN 'P' THEN 'primary'
    1385. 

  1385. 							 WHEN 'R' THEN 'foreign'
    1386. 

  1386. 							 WHEN 'U' THEN 'unique'
    1387. 

  1387. 							 END TYPE,
    1388. 

  1388. 						 LOWER(ACC.COLUMN_NAME) \"COLUMN\",
    1389. 

  1389. 						 LOWER(FKC.OWNER) FOREIGN_SCHEMA,
    1390. 

  1390. 						 LOWER(FKC.TABLE_NAME) FOREIGN_TABLE,
    1391. 

  1391. 						 LOWER(FKC.COLUMN_NAME) FOREIGN_COLUMN,
    1392. 

  1392. 						 CASE WHEN FKC.TABLE_NAME IS NOT NULL THEN REPLACE(LOWER(AC.DELETE_RULE), ' ', '_') ELSE NULL END ON_DELETE
    1393. 

  1393. 					 FROM
    1394. 

  1394. 						 ALL_CONSTRAINTS AC INNER JOIN
    1395. 

  1395. 						 ALL_CONS_COLUMNS ACC ON AC.CONSTRAINT_NAME = ACC.CONSTRAINT_NAME AND AC.OWNER = ACC.OWNER LEFT JOIN
    1396. 

  1396. 						 ALL_CONSTRAINTS FK ON AC.R_CONSTRAINT_NAME = FK.CONSTRAINT_NAME AND AC.OWNER = FK.OWNER LEFT JOIN
    1397. 

  1397. 						 ALL_CONS_COLUMNS FKC ON FK.CONSTRAINT_NAME = FKC.CONSTRAINT_NAME AND FK.OWNER = FKC.OWNER
    1398. 

  1398. 					 WHERE
    1399. 

  1399. 						 AC.CONSTRAINT_TYPE IN ('U', 'P', 'R') AND ";
    1400. 

  1400. 		
    1401. 

  1401. 		$conditions = array();
    1402. 

  1402. 		foreach ($tables as $table) {
    1403. 

  1403. 			if (strpos($table, '.') === FALSE) {
    1404. 

  1404. 				$table = $default_schema . '.' . $table;
    1405. 

  1405. 			}	
    1406. 

  1406. 			list ($schema, $table) = explode('.', strtoupper($table));
    1407. 

  1407. 			$conditions[] = "AC.OWNER = %s AND AC.TABLE_NAME = %s";
    1408. 

  1408. 			$params[] = $schema;
    1409. 

  1409. 			$params[] = $table;
    1410. 

  1410. 		}
    1411. 

  1411. 		$sql .= '((' . join(') OR( ', $conditions) . '))';
    1412. 

  1412. 		
    1413. 

  1413. 		$sql .= " ORDER BY
    1414. 

  1414. 						 AC.OWNER ASC,
    1415. 

  1415. 						 AC.TABLE_NAME ASC,
    1416. 

  1416. 						 AC.CONSTRAINT_TYPE ASC,
    1417. 

  1417. 						 AC.CONSTRAINT_NAME ASC,
    1418. 

  1418. 						 ACC.POSITION ASC";
    1419. 

  1419. 		
    1420. 

  1420. 		$result = $this->database->query($sql, $params);
    1421. 

  1421. 		
    1422. 

  1422. 		$last_name  = '';
    1423. 

  1423. 		$last_table = '';
    1424. 

  1424. 		$last_type  = '';
    1425. 

  1425. 		foreach ($result as $row) {
    1426. 

  1426. 			
    1427. 

  1427. 			if ($row['constraint_name'] != $last_name) {
    1428. 

  1428. 				
    1429. 

  1429. 				if ($last_name) {
    1430. 

  1430. 					if ($last_type == 'foreign' || $last_type == 'unique') {
    1431. 

  1431. 						$keys[$last_table][$last_type][] = $temp;
    1432. 

  1432. 					} else {
    1433. 

  1433. 						$keys[$last_table][$last_type] = $temp;
    1434. 

  1434. 					}
    1435. 

  1435. 				}
    1436. 

  1436. 				
    1437. 

  1437. 				$temp = array();
    1438. 

  1438. 				if ($row['type'] == 'foreign') {
    1439. 

  1439. 					
    1440. 

  1440. 					$temp['column']         = $row['column'];
    1441. 

  1441. 					$temp['foreign_table']  = $row['foreign_table'];
    1442. 

  1442. 					if ($row['foreign_schema'] != $default_schema) {
    1443. 

  1443. 						$temp['foreign_table'] = $row['foreign_schema'] . '.' . $temp['foreign_table'];
    1444. 

  1444. 					}
    1445. 

  1445. 					$temp['foreign_column'] = $row['foreign_column'];
    1446. 

  1446. 					$temp['on_delete']      = 'no_action';
    1447. 

  1447. 					$temp['on_update']      = 'no_action';
    1448. 

  1448. 					
    1449. 

  1449. 					if (!empty($row['on_delete'])) {
    1450. 

  1450. 						$temp['on_delete'] = $row['on_delete'];
    1451. 

  1451. 					}
    1452. 

  1452. 					
    1453. 

  1453. 				} else {
    1454. 

  1454. 					$temp[] = $row['column'];
    1455. 

  1455. 				}
    1456. 

  1456. 				
    1457. 

  1457. 				$last_table = $row['table'];
    1458. 

  1458. 				if ($row['schema'] != $default_schema) {
    1459. 

  1459. 					$last_table = $row['schema'] . '.' . $last_table;
    1460. 

  1460. 				}
    1461. 

  1461. 				$last_name  = $row['constraint_name'];
    1462. 

  1462. 				$last_type  = $row['type'];
    1463. 

  1463. 				
    1464. 

  1464. 			} else {
    1465. 

  1465. 				$temp[] = $row['column'];
    1466. 

  1466. 			}
    1467. 

  1467. 		}
    1468. 

  1468. 		
    1469. 

  1469. 		if (isset($temp)) {
    1470. 

  1470. 			if ($last_type == 'foreign' || $last_type == 'unique') {
    1471. 

  1471. 				$keys[$last_table][$last_type][] = $temp;
    1472. 

  1472. 			} else {
    1473. 

  1473. 				$keys[$last_table][$last_type] = $temp;
    1474. 

  1474. 			}
    1475. 

  1475. 		}
    1476. 

  1476. 		
    1477. 

  1477. 		return $keys;
    1478. 

  1478. 	}
    1479. 

  1479. 	
    1480. 

  1480. 	
    1481. 

  1481. 	/**
    1482. 

  1482. 	 * Gets the column info from a PostgreSQL database
    1483. 

  1483. 	 * 
    1484. 

  1484. 	 * @param  string $table  The table to fetch the column info for
    1485. 

  1485. 	 * @return array  The column info for the table specified - see ::getColumnInfo() for details
    1486. 

  1486. 	 */
    1487. 

  1487. 	private function fetchPostgreSQLColumnInfo($table)
    1488. 

  1488. 	{
    1489. 

  1489. 		$column_info = array();
    1490. 

  1490. 		
    1491. 

  1491. 		$schema = 'public';
    1492. 

  1492. 		if (strpos($table, '.') !== FALSE) {
    1493. 

  1493. 			list ($schema, $table) = explode('.', $table);	
    1494. 

  1494. 		}
    1495. 

  1495. 		
    1496. 

  1496. 		$data_type_mapping = array(
    1497. 

  1497. 			'boolean'			=> 'boolean',
    1498. 

  1498. 			'smallint'			=> 'integer',
    1499. 

  1499. 			'int'				=> 'integer',
    1500. 

  1500. 			'bigint'			=> 'integer',
    1501. 

  1501. 			'serial'			=> 'integer',
    1502. 

  1502. 			'bigserial'			=> 'integer',
    1503. 

  1503. 			'timestamp'			=> 'timestamp',
    1504. 

  1504. 			'date'				=> 'date',
    1505. 

  1505. 			'time'				=> 'time',
    1506. 

  1506. 			'uuid'              => 'varchar',
    1507. 

  1507. 			'character varying'	=> 'varchar',
    1508. 

  1508. 			'character'			=> 'char',
    1509. 

  1509. 			'real'				=> 'float',
    1510. 

  1510. 			'double'			=> 'float',
    1511. 

  1511. 			'numeric'			=> 'float',
    1512. 

  1512. 			'bytea'				=> 'blob',
    1513. 

  1513. 			'text'				=> 'text',
    1514. 

  1514. 			'mediumtext'		=> 'text',
    1515. 

  1515. 			'longtext'			=> 'text'
    1516. 

  1516. 		);
    1517. 

  1517. 		
    1518. 

  1518. 		$max_min_values = array(
    1519. 

  1519. 			'smallint'  => array('min' => new fNumber(-32768),                  'max' => new fNumber(32767)),
    1520. 

  1520. 			'int'       => array('min' => new fNumber(-2147483648),             'max' => new fNumber(2147483647)),
    1521. 

  1521. 			'bigint'    => array('min' => new fNumber('-9223372036854775808'),  'max' => new fNumber('9223372036854775807')),
    1522. 

  1522. 			'serial'    => array('min' => new fNumber(-2147483648),             'max' => new fNumber(2147483647)),
    1523. 

  1523. 			'bigserial' => array('min' => new fNumber('-9223372036854775808'),  'max' => new fNumber('9223372036854775807'))
    1524. 

  1524. 		);
    1525. 

  1525. 		
    1526. 

  1526. 		// PgSQL required this complicated SQL to get the column info
    1527. 

  1527. 		$sql = "SELECT
    1528. 

  1528. 						pg_attribute.attname                                        AS column,
    1529. 

  1529. 						format_type(pg_attribute.atttypid, pg_attribute.atttypmod)  AS data_type,
    1530. 

  1530. 						pg_attribute.attnotnull                                     AS not_null,
    1531. 

  1531. 						pg_attrdef.adsrc                                            AS default,
    1532. 

  1532. 						pg_get_constraintdef(pg_constraint.oid)                     AS constraint
    1533. 

  1533. 					FROM
    1534. 

  1534. 						pg_attribute LEFT JOIN
    1535. 

  1535. 						pg_class ON pg_attribute.attrelid = pg_class.oid LEFT JOIN
    1536. 

  1536. 						pg_namespace ON pg_class.relnamespace = pg_namespace.oid LEFT JOIN
    1537. 

  1537. 						pg_type ON pg_type.oid = pg_attribute.atttypid LEFT JOIN
    1538. 

  1538. 						pg_constraint ON pg_constraint.conrelid = pg_class.oid AND
    1539. 

  1539. 										 pg_attribute.attnum = ANY (pg_constraint.conkey) AND
    1540. 

  1540. 										 pg_constraint.contype = 'c' LEFT JOIN
    1541. 

  1541. 						pg_attrdef ON pg_class.oid = pg_attrdef.adrelid AND
    1542. 

  1542. 									  pg_attribute.attnum = pg_attrdef.adnum
    1543. 

  1543. 					WHERE
    1544. 

  1544. 						NOT pg_attribute.attisdropped AND
    1545. 

  1545. 						pg_class.relname = %s AND
    1546. 

  1546. 						pg_namespace.nspname = %s AND
    1547. 

  1547. 						pg_type.typname NOT IN ('oid', 'cid', 'xid', 'cid', 'xid', 'tid')
    1548. 

  1548. 					ORDER BY
    1549. 

  1549. 						pg_attribute.attnum,
    1550. 

  1550. 						pg_constraint.contype";
    1551. 

  1551. 		$result = $this->database->query($sql, $table, $schema);
    1552. 

  1552. 		
    1553. 

  1553. 		foreach ($result as $row) {
    1554. 

  1554. 			
    1555. 

  1555. 			$info = array();
    1556. 

  1556. 			
    1557. 

  1557. 			// Get the column type
    1558. 

  1558. 			preg_match('#([\w ]+)\s*(?:\(\s*(\d+)(?:\s*,\s*(\d+))?\s*\))?#', $row['data_type'], $column_data_type);
    1559. 

  1559. 			
    1560. 

  1560. 			foreach ($data_type_mapping as $data_type => $mapped_data_type) {
    1561. 

  1561. 				if (stripos($column_data_type[1], $data_type) === 0) {
    1562. 

  1562. 					$info['type'] = $mapped_data_type;
    1563. 

  1563. 					if (isset($max_min_values[$data_type])) {
    1564. 

  1564. 						$info['min_value'] = $max_min_values[$data_type]['min'];
    1565. 

  1565. 						$info['max_value'] = $max_min_values[$data_type]['max'];
    1566. 

  1566. 					}
    1567. 

  1567. 					break;
    1568. 

  1568. 				}
    1569. 

  1569. 			}
    1570. 

  1570. 			
    1571. 

  1571. 			if (!isset($info['type'])) {
    1572. 

  1572. 				$info['type'] = $column_data_type[1];
    1573. 

  1573. 			}
    1574. 

  1574. 			
    1575. 

  1575. 			if ($info['type'] == 'blob' || $info['type'] == 'text') {
    1576. 

  1576. 				$info['max_length'] = 1073741824; 
    1577. 

  1577. 			}
    1578. 

  1578. 			
    1579. 

  1579. 			// Handle the length of decimal/numeric fields
    1580. 

  1580. 			if ($info['type'] == 'float' && isset($column_data_type[3]) && strlen($column_data_type[3]) > 0) {
    1581. 

  1581. 				$info['decimal_places'] = (int) $column_data_type[3];
    1582. 

  1582. 				$before_digits = str_pad('', $column_data_type[2] - $info['decimal_places'], '9');
    1583. 

  1583. 				$after_digits  = str_pad('', $info['decimal_places'], '9');
    1584. 

  1584. 				$max_min       = $before_digits . ($after_digits ? '.' : '') . $after_digits;
    1585. 

  1585. 				$info['min_value'] = new fNumber('-' . $max_min);
    1586. 

  1586. 				$info['max_value'] = new fNumber($max_min);
    1587. 

  1587. 			}
    1588. 

  1588. 			
    1589. 

  1589. 			// Handle the special data for varchar fields
    1590. 

  1590. 			if (in_array($info['type'], array('char', 'varchar'))) {
    1591. 

  1591. 				if (!empty($column_data_type[2])) {
    1592. 

  1592. 					$info['max_length'] = $column_data_type[2];
    1593. 

  1593. 				} else {
    1594. 

  1594. 					$info['max_length'] = 1073741824; 
    1595. 

  1595. 				}
    1596. 

  1596. 			}
    1597. 

  1597. 			
    1598. 

  1598. 			// In PostgreSQL, a UUID can be the 32 digits, 32 digits plus 4 hyphens or 32 digits plus 4 hyphens and 2 curly braces
    1599. 

  1599. 			if ($row['data_type'] == 'uuid') {
    1600. 

  1600. 				$info['max_length'] = 38;	
    1601. 

  1601. 			}
    1602. 

  1602. 			
    1603. 

  1603. 			// Handle check constraints that are just simple lists
    1604. 

  1604. 			if (in_array($info['type'], array('varchar', 'char')) && !empty($row['constraint'])) {
    1605. 

  1605. 				if (preg_match('/CHECK[\( "]+' . $row['column'] . '[a-z\) ":]+\s+=\s+/i', $row['constraint'])) {
    1606. 

  1606. 					if (preg_match_all("/(?!').'((''|[^']+)*)'/", $row['constraint'], $matches, PREG_PATTERN_ORDER)) {
    1607. 

  1607. 						$info['valid_values'] = str_replace("''", "'", $matches[1]);
    1608. 

  1608. 					}
    1609. 

  1609. 				}
    1610. 

  1610. 			}
    1611. 

  1611. 			
    1612. 

  1612. 			// Handle default values and serial data types
    1613. 

  1613. 			if ($info['type'] == 'integer' && stripos($row['default'], 'nextval(') !== FALSE) {
    1614. 

  1614. 				$info['auto_increment'] = TRUE;
    1615. 

  1615. 				
    1616. 

  1616. 			} elseif ($row['default'] !== NULL) {
    1617. 

  1617. 				if (preg_match('#^NULL::[\w\s]+$#', $row['default'])) {
    1618. 

  1618. 					$info['default'] = NULL;
    1619. 

  1619. 				} elseif ($row['default'] == 'now()') {
    1620. 

  1620. 					$info['default'] = 'CURRENT_TIMESTAMP';
    1621. 

  1621. 				} elseif ($row['default'] == "('now'::text)::date") {
    1622. 

  1622. 					$info['default'] = 'CURRENT_DATE';
    1623. 

  1623. 				} elseif ($row['default'] == "('now'::text)::time with time zone") {
    1624. 

  1624. 					$info['default'] = 'CURRENT_TIME';	
    1625. 

  1625. 				} else {
    1626. 

  1626. 					$info['default'] = str_replace("''", "'", preg_replace("/^'(.*)'::[a-z ]+\$/iD", '\1', $row['default']));
    1627. 

  1627. 					if ($info['type'] == 'boolean') {
    1628. 

  1628. 						$info['default'] = ($info['default'] == 'false' || !$info['default']) ? FALSE : TRUE;
    1629. 

  1629. 					}
    1630. 

  1630. 				}
    1631. 

  1631. 			}
    1632. 

  1632. 			
    1633. 

  1633. 			// Not null values
    1634. 

  1634. 			$info['not_null'] = ($row['not_null'] == 't') ? TRUE : FALSE;
    1635. 

  1635. 			
    1636. 

  1636. 			$column_info[$row['column']] = $info;
    1637. 

  1637. 		}
    1638. 

  1638. 		
    1639. 

  1639. 		return $column_info;
    1640. 

  1640. 	}
    1641. 

  1641. 	
    1642. 

  1642. 	
    1643. 

  1643. 	/**
    1644. 

  1644. 	 * Fetches the key info for a PostgreSQL database
    1645. 

  1645. 	 * 
    1646. 

  1646. 	 * @return array  The keys arrays for every table in the database - see ::getKeys() for details
    1647. 

  1647. 	 */
    1648. 

  1648. 	private function fetchPostgreSQLKeys()
    1649. 

  1649. 	{
    1650. 

  1650. 		$keys = array();
    1651. 

  1651. 		
    1652. 

  1652. 		$tables   = $this->getTables();
    1653. 

  1653. 		foreach ($tables as $table) {
    1654. 

  1654. 			$keys[$table] = array();
    1655. 

  1655. 			$keys[$table]['primary'] = array();
    1656. 

  1656. 			$keys[$table]['unique']  = array();
    1657. 

  1657. 			$keys[$table]['foreign'] = array();
    1658. 

  1658. 		}
    1659. 

  1659. 		
    1660. 

  1660. 		$sql  = "(
    1661. 

  1661. 				 SELECT
    1662. 

  1662. 						 s.nspname AS \"schema\",
    1663. 

  1663. 						 t.relname AS \"table\",
    1664. 

  1664. 						 con.conname AS constraint_name,
    1665. 

  1665. 						 CASE con.contype
    1666. 

  1666. 							 WHEN 'f' THEN 'foreign'
    1667. 

  1667. 							 WHEN 'p' THEN 'primary'
    1668. 

  1668. 							 WHEN 'u' THEN 'unique'
    1669. 

  1669. 						 END AS type,
    1670. 

  1670. 						 col.attname AS column,
    1671. 

  1671. 						 fs.nspname AS foreign_schema,
    1672. 

  1672. 						 ft.relname AS foreign_table,
    1673. 

  1673. 						 fc.attname AS foreign_column,
    1674. 

  1674. 						 CASE con.confdeltype
    1675. 

  1675. 							 WHEN 'c' THEN 'cascade'
    1676. 

  1676. 							 WHEN 'a' THEN 'no_action'
    1677. 

  1677. 							 WHEN 'r' THEN 'restrict'
    1678. 

  1678. 							 WHEN 'n' THEN 'set_null'
    1679. 

  1679. 							 WHEN 'd' THEN 'set_default'
    1680. 

  1680. 						 END AS on_delete,
    1681. 

  1681. 						 CASE con.confupdtype
    1682. 

  1682. 							 WHEN 'c' THEN 'cascade'
    1683. 

  1683. 							 WHEN 'a' THEN 'no_action'
    1684. 

  1684. 							 WHEN 'r' THEN 'restrict'
    1685. 

  1685. 							 WHEN 'n' THEN 'set_null'
    1686. 

  1686. 							 WHEN 'd' THEN 'set_default'
    1687. 

  1687. 						 END AS on_update,
    1688. 

  1688. 						CASE WHEN con.conkey IS NOT NULL THEN position('-'||col.attnum||'-' in '-'||array_to_string(con.conkey, '-')||'-') ELSE 0 END AS column_order
    1689. 

  1689. 					 FROM
    1690. 

  1690. 						 pg_attribute AS col INNER JOIN
    1691. 

  1691. 						 pg_class AS t ON col.attrelid = t.oid INNER JOIN
    1692. 

  1692. 						 pg_namespace AS s ON t.relnamespace = s.oid INNER JOIN
    1693. 

  1693. 						 pg_constraint AS con ON (col.attnum = ANY (con.conkey) AND
    1694. 

  1694. 												  con.conrelid = t.oid) LEFT JOIN
    1695. 

  1695. 						 pg_class AS ft ON con.confrelid = ft.oid LEFT JOIN
    1696. 

  1696. 						 pg_namespace AS fs ON ft.relnamespace = fs.oid LEFT JOIN
    1697. 

  1697. 						 pg_attribute AS fc ON (fc.attnum = ANY (con.confkey) AND
    1698. 

  1698. 												ft.oid = fc.attrelid)
    1699. 

  1699. 					 WHERE
    1700. 

  1700. 						 NOT col.attisdropped AND
    1701. 

  1701. 						 (con.contype = 'p' OR
    1702. 

  1702. 						  con.contype = 'f' OR
    1703. 

  1703. 						  con.contype = 'u')
    1704. 

  1704. 				) UNION (
    1705. 

  1705. 				SELECT
    1706. 

  1706. 						n.nspname AS \"schema\",
    1707. 

  1707. 						t.relname AS \"table\",
    1708. 

  1708. 						ic.relname AS constraint_name,
    1709. 

  1709. 						'unique' AS type,
    1710. 

  1710. 						col.attname AS column,
    1711. 

  1711. 						NULL AS foreign_schema,
    1712. 

  1712. 						NULL AS foreign_table,
    1713. 

  1713. 						NULL AS foreign_column,
    1714. 

  1714. 						NULL AS on_delete,
    1715. 

  1715. 						NULL AS on_update,
    1716. 

  1716. 						CASE WHEN ind.indkey IS NOT NULL THEN position('-'||col.attnum||'-' in '-'||array_to_string(ind.indkey, '-')||'-') ELSE 0 END AS column_order
    1717. 

  1717. 					FROM
    1718. 

  1718. 						pg_class AS t INNER JOIN
    1719. 

  1719. 						pg_index AS ind ON ind.indrelid = t.oid INNER JOIN
    1720. 

  1720. 						pg_namespace AS n ON t.relnamespace = n.oid INNER JOIN
    1721. 

  1721. 						pg_class AS ic ON ind.indexrelid = ic.oid LEFT JOIN
    1722. 

  1722. 						pg_constraint AS con ON con.conrelid = t.oid AND con.contype = 'u' AND con.conname = ic.relname INNER JOIN
    1723. 

  1723. 						pg_attribute AS col ON col.attrelid = t.oid AND col.attnum = ANY (ind.indkey)  
    1724. 

  1724. 					WHERE
    1725. 

  1725. 						n.nspname NOT IN ('pg_catalog', 'pg_toast') AND
    1726. 

  1726. 						indisunique = TRUE AND
    1727. 

  1727. 						indisprimary = FALSE AND
    1728. 

  1728. 						con.oid IS NULL AND
    1729. 

  1729. 						0 != ALL ((ind.indkey)::int[])
    1730. 

  1730. 				) ORDER BY 1, 2, 4, 3, 11";
    1731. 

  1731. 		
    1732. 

  1732. 		$result = $this->database->query($sql);
    1733. 

  1733. 		
    1734. 

  1734. 		$last_name  = '';
    1735. 

  1735. 		$last_table = '';
    1736. 

  1736. 		$last_type  = '';
    1737. 

  1737. 		foreach ($result as $row) {
    1738. 

  1738. 			
    1739. 

  1739. 			if ($row['constraint_name'] != $last_name) {
    1740. 

  1740. 				
    1741. 

  1741. 				if ($last_name) {
    1742. 

  1742. 					if ($last_type == 'foreign' || $last_type == 'unique') {
    1743. 

  1743. 						$keys[$last_table][$last_type][] = $temp;
    1744. 

  1744. 					} else {
    1745. 

  1745. 						$keys[$last_table][$last_type] = $temp;
    1746. 

  1746. 					}
    1747. 

  1747. 				}
    1748. 

  1748. 				
    1749. 

  1749. 				$temp = array();
    1750. 

  1750. 				if ($row['type'] == 'foreign') {
    1751. 

  1751. 					
    1752. 

  1752. 					$temp['column']         = $row['column'];
    1753. 

  1753. 					$temp['foreign_table']  = $row['foreign_table'];
    1754. 

  1754. 					if ($row['foreign_schema'] != 'public') {
    1755. 

  1755. 						$temp['foreign_table'] = $row['foreign_schema'] . '.' . $temp['foreign_table'];	
    1756. 

  1756. 					}
    1757. 

  1757. 					$temp['foreign_column'] = $row['foreign_column'];
    1758. 

  1758. 					$temp['on_delete']      = 'no_action';
    1759. 

  1759. 					$temp['on_update']      = 'no_action';
    1760. 

  1760. 					
    1761. 

  1761. 					if (!empty($row['on_delete'])) {
    1762. 

  1762. 						$temp['on_delete'] = $row['on_delete'];
    1763. 

  1763. 					}
    1764. 

  1764. 					
    1765. 

  1765. 					if (!empty($row['on_update'])) {
    1766. 

  1766. 						$temp['on_update'] = $row['on_update'];
    1767. 

  1767. 					}
    1768. 

  1768. 					
    1769. 

  1769. 				} else {
    1770. 

  1770. 					$temp[] = $row['column'];
    1771. 

  1771. 				}
    1772. 

  1772. 				
    1773. 

  1773. 				$last_table = $row['table'];
    1774. 

  1774. 				if ($row['schema'] != 'public') {
    1775. 

  1775. 					$last_table = $row['schema'] . '.' . $last_table;	
    1776. 

  1776. 				}
    1777. 

  1777. 				$last_name  = $row['constraint_name'];
    1778. 

  1778. 				$last_type  = $row['type'];
    1779. 

  1779. 				
    1780. 

  1780. 			} else {
    1781. 

  1781. 				$temp[] = $row['column'];
    1782. 

  1782. 			}
    1783. 

  1783. 		}
    1784. 

  1784. 		
    1785. 

  1785. 		if (isset($temp)) {
    1786. 

  1786. 			if ($last_type == 'foreign' || $last_type == 'unique') {
    1787. 

  1787. 				$keys[$last_table][$last_type][] = $temp;
    1788. 

  1788. 			} else {
    1789. 

  1789. 				$keys[$last_table][$last_type] = $temp;
    1790. 

  1790. 			}
    1791. 

  1791. 		}
    1792. 

  1792. 		
    1793. 

  1793. 		return $keys;
    1794. 

  1794. 	}
    1795. 

  1795. 	
    1796. 

  1796. 	
    1797. 

  1797. 	/**
    1798. 

  1798. 	 * Gets the column info from a SQLite database
    1799. 

  1799. 	 * 
    1800. 

  1800. 	 * @param  string $table  The table to fetch the column info for
    1801. 

  1801. 	 * @return array  The column info for the table specified - see ::getColumnInfo() for details
    1802. 

  1802. 	 */
    1803. 

  1803. 	private function fetchSQLiteColumnInfo($table)
    1804. 

  1804. 	{
    1805. 

  1805. 		$column_info = array();
    1806. 

  1806. 		
    1807. 

  1807. 		$data_type_mapping = array(
    1808. 

  1808. 			'boolean'			=> 'boolean',
    1809. 

  1809. 			'serial'            => 'integer',
    1810. 

  1810. 			'smallint'			=> 'integer',
    1811. 

  1811. 			'int'				=> 'integer',
    1812. 

  1812. 			'integer'           => 'integer',
    1813. 

  1813. 			'bigint'			=> 'integer',
    1814. 

  1814. 			'timestamp'			=> 'timestamp',
    1815. 

  1815. 			'date'				=> 'date',
    1816. 

  1816. 			'time'				=> 'time',
    1817. 

  1817. 			'varchar'			=> 'varchar',
    1818. 

  1818. 			'char'				=> 'char',
    1819. 

  1819. 			'real'				=> 'float',
    1820. 

  1820. 			'numeric'           => 'float',
    1821. 

  1821. 			'float'             => 'float',
    1822. 

  1822. 			'double'			=> 'float',
    1823. 

  1823. 			'decimal'			=> 'float',
    1824. 

  1824. 			'blob'				=> 'blob',
    1825. 

  1825. 			'text'				=> 'text'
    1826. 

  1826. 		);
    1827. 

  1827. 		
    1828. 

  1828. 		$result = $this->database->query("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = %s", $table);
    1829. 

  1829. 		
    1830. 

  1830. 		try {
    1831. 

  1831. 			$row        = $result->fetchRow();
    1832. 

  1832. 			$create_sql = $row['sql'];
    1833. 

  1833. 		} catch (fNoRowsException $e) {
    1834. 

  1834. 			return array();			
    1835. 

  1835. 		}
    1836. 

  1836. 		
    1837. 

  1837. 		preg_match_all('#(?<=,|\()\s*(?:`|"|\[)?(\w+)(?:`|"|\])?\s+([a-z]+)(?:\(\s*(\d+)(?:\s*,\s*(\d+))?\s*\))?(?:(\s+NOT\s+NULL)|(?:\s+NULL)|(?:\s+DEFAULT\s+([^, \']*|\'(?:\'\'|[^\']+)*\'))|(\s+UNIQUE)|(\s+PRIMARY\s+KEY(?:\s+AUTOINCREMENT)?)|(\s+CHECK\s*\(\w+\s+IN\s+\(\s*(?:(?:[^, \']+|\'(?:\'\'|[^\']+)*\')\s*,\s*)*\s*(?:[^, \']+|\'(?:\'\'|[^\']+)*\')\)\)))*(\s+REFERENCES\s+["`\[]?\w+["`\]]?\s*\(\s*["`\[]?\w+["`\]]?\s*\)\s*(?:\s+(?:ON\s+DELETE|ON\s+UPDATE)\s+(?:CASCADE|NO\s+ACTION|RESTRICT|SET\s+NULL|SET\s+DEFAULT))*(?:\s+(?:DEFERRABLE|NOT\s+DEFERRABLE))?)?\s*(?:,|\s*(?=\)))#mi', $create_sql, $matches, PREG_SET_ORDER);
    1838. 

  1838. 		
    1839. 

  1839. 		foreach ($matches as $match) {
    1840. 

  1840. 			$info = array();
    1841. 

  1841. 			
    1842. 

  1842. 			foreach ($data_type_mapping as $data_type => $mapped_data_type) {
    1843. 

  1843. 				if (stripos($match[2], $data_type) === 0) {
    1844. 

  1844. 					$info['type'] = $mapped_data_type;
    1845. 

  1845. 					break;
    1846. 

  1846. 				}
    1847. 

  1847. 			}
    1848. 

  1848. 		
    1849. 

  1849. 			// Type specific information
    1850. 

  1850. 			if (in_array($info['type'], array('char', 'varchar'))) {
    1851. 

  1851. 				if (!empty($match[3])) {
    1852. 

  1852. 					$info['max_length'] = $match[3];
    1853. 

  1853. 				} else {
    1854. 

  1854. 					$info['max_length'] = 1000000000;   
    1855. 

  1855. 				}
    1856. 

  1856. 			}
    1857. 

  1857. 			
    1858. 

  1858. 			if ($info['type'] == 'text' || $info['type'] == 'blob') {
    1859. 

  1859. 				$info['max_length'] = 1000000000;   
    1860. 

  1860. 			}
    1861. 

  1861. 			
    1862. 

  1862. 			// Figure out how many decimal places for a decimal
    1863. 

  1863. 			if (in_array(strtolower($match[2]), array('decimal', 'numeric')) && !empty($match[4])) {
    1864. 

  1864. 				$info['decimal_places'] = $match[4];
    1865. 

  1865. 				$before_digits = str_pad('', $match[3] - $match[4], '9');
    1866. 

  1866. 				$after_digits  = str_pad('', $match[4], '9');
    1867. 

  1867. 				$max_min       = $before_digits . ($after_digits ? '.' : '') . $after_digits;
    1868. 

  1868. 				$info['min_value'] = new fNumber('-' . $max_min);
    1869. 

  1869. 				$info['max_value'] = new fNumber($max_min);
    1870. 

  1870. 			}
    1871. 

  1871. 			
    1872. 

  1872. 			// Not null
    1873. 

  1873. 			$info['not_null'] = (!empty($match[5]) || !empty($match[8])) ? TRUE : FALSE;
    1874. 

  1874. 		
    1875. 

  1875. 			// Default values
    1876. 

  1876. 			if (isset($match[6]) && $match[6] != '' && $match[6] != 'NULL') {
    1877. 

  1877. 				$info['default'] = preg_replace("/^'|'\$/D", '', $match[6]);
    1878. 

  1878. 			}
    1879. 

  1879. 			if ($info['type'] == 'boolean' && isset($info['default'])) {
    1880. 

  1880. 				$info['default'] = ($info['default'] == 'f' || $info['default'] == 0 || $info['default'] == 'false') ? FALSE : TRUE;
    1881. 

  1881. 			}
    1882. 

  1882. 		
    1883. 

  1883. 			// Check constraints
    1884. 

  1884. 			if (isset($match[9]) && preg_match('/CHECK\s*\(\s*' . $match[1] . '\s+IN\s+\(\s*((?:(?:[^, \']*|\'(?:\'\'|[^\']+)*\')\s*,\s*)*(?:[^, \']*|\'(?:\'\'|[^\']+)*\'))\s*\)/i', $match[9], $check_match)) {
    1885. 

  1885. 				$info['valid_values'] = str_replace("''", "'", preg_replace("/^'|'\$/D", '', preg_split("#\s*,\s*#", $check_match[1])));
    1886. 

  1886. 			}
    1887. 

  1887. 		
    1888. 

  1888. 			// Auto increment fields
    1889. 

  1889. 			if (!empty($match[8]) && (stripos($match[8], 'autoincrement') !== FALSE || $info['type'] == 'integer')) {
    1890. 

  1890. 				$info['auto_increment'] = TRUE;
    1891. 

  1891. 			}
    1892. 

  1892. 		
    1893. 

  1893. 			$column_info[$match[1]] = $info;
    1894. 

  1894. 		}
    1895. 

  1895. 		
    1896. 

  1896. 		return $column_info;
    1897. 

  1897. 	}
    1898. 

  1898. 	
    1899. 

  1899. 	
    1900. 

  1900. 	/**
    1901. 

  1901. 	 * Fetches the key info for an SQLite database
    1902. 

  1902. 	 * 
    1903. 

  1903. 	 * @return array  The keys arrays for every table in the database - see ::getKeys() for details
    1904. 

  1904. 	 */
    1905. 

  1905. 	private function fetchSQLiteKeys()
    1906. 

  1906. 	{
    1907. 

  1907. 		$tables = $this->getTables();
    1908. 

  1908. 		$keys   = array();
    1909. 

  1909. 		
    1910. 

  1910. 		foreach ($tables as $table) {
    1911. 

  1911. 			$keys[$table] = array();
    1912. 

  1912. 			$keys[$table]['primary'] = array();
    1913. 

  1913. 			$keys[$table]['foreign'] = array();
    1914. 

  1914. 			$keys[$table]['unique']  = array();
    1915. 

  1915. 			
    1916. 

  1916. 			$result     = $this->database->query("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = %s", $table);
    1917. 

  1917. 			$row        = $result->fetchRow();
    1918. 

  1918. 			$create_sql = $row['sql'];
    1919. 

  1919. 			
    1920. 

  1920. 			// Get column level key definitions
    1921. 

  1921. 			preg_match_all('#(?<=,|\()\s*["`\[]?(\w+)["`\]]?\s+(?:[a-z]+)(?:\((?:\d+)\))?(?:(?:\s+NOT\s+NULL)|(?:\s+DEFAULT\s+(?:[^, \']*|\'(?:\'\'|[^\']+)*\'))|(\s+UNIQUE)|(\s+PRIMARY\s+KEY(?:\s+AUTOINCREMENT)?)|(?:\s+CHECK\s*\(\w+\s+IN\s+\(\s*(?:(?:[^, \']+|\'(?:\'\'|[^\']+)*\')\s*,\s*)*\s*(?:[^, \']+|\'(?:\'\'|[^\']+)*\')\)\)))*(\s+REFERENCES\s+["`\[]?(\w+)["`\]]?\s*\(\s*["`\[]?(\w+)["`\]]?\s*\)\s*(?:(?:\s+(?:ON\s+DELETE\s+(CASCADE|NO\s+ACTION|RESTRICT|SET\s+NULL|SET\s+DEFAULT)))|(?:\s+(?:ON\s+UPDATE\s+(CASCADE|NO\s+ACTION|RESTRICT|SET\s+NULL|SET\s+DEFAULT))))*(?:\s+(?:DEFERRABLE|NOT\s+DEFERRABLE))?)?\s*(?:,|\s*(?=\)))#mi', $create_sql, $matches, PREG_SET_ORDER);
    1922. 

  1922. 			
    1923. 

  1923. 			foreach ($matches as $match) {
    1924. 

  1924. 				if (!empty($match[2])) {
    1925. 

  1925. 					$keys[$table]['unique'][] = array($match[1]);
    1926. 

  1926. 				}
    1927. 

  1927. 				
    1928. 

  1928. 				if (!empty($match[3])) {
    1929. 

  1929. 					$keys[$table]['primary'] = array($match[1]);
    1930. 

  1930. 				}
    1931. 

  1931. 				
    1932. 

  1932. 				if (!empty($match[4])) {
    1933. 

  1933. 					$temp = array('column'         => $match[1],
    1934. 

  1934. 								  'foreign_table'  => $match[5],
    1935. 

  1935. 								  'foreign_column' => $match[6],
    1936. 

  1936. 								  'on_delete'      => 'no_action',
    1937. 

  1937. 								  'on_update'      => 'no_action');
    1938. 

  1938. 					if (isset($match[7])) {
    1939. 

  1939. 						$temp['on_delete'] = strtolower(str_replace(' ', '_', $match[7]));
    1940. 

  1940. 					}
    1941. 

  1941. 					if (isset($match[8])) {
    1942. 

  1942. 						$temp['on_update'] = strtolower(str_replace(' ', '_', $match[8]));
    1943. 

  1943. 					}
    1944. 

  1944. 					$keys[$table]['foreign'][] = $temp;
    1945. 

  1945. 				}
    1946. 

  1946. 			}
    1947. 

  1947. 			
    1948. 

  1948. 			// Get table level primary key definitions
    1949. 

  1949. 			preg_match_all('#(?<=,|\()\s*PRIMARY\s+KEY\s*\(\s*((?:\s*["`\[]?\w+["`\]]?\s*,\s*)*["`\[]?\w+["`\]]?)\s*\)\s*(?:,|\s*(?=\)))#mi', $create_sql, $matches, PREG_SET_ORDER);
    1950. 

  1950. 			
    1951. 

  1951. 			foreach ($matches as $match) {
    1952. 

  1952. 				$columns = preg_split('#\s*,\s*#', $match[1]);
    1953. 

  1953. 				foreach ($columns as $column) {
    1954. 

  1954. 					$keys[$table]['primary'][] = str_replace(array('[', '"', '`', ']'), '', $column);	
    1955. 

  1955. 				}
    1956. 

  1956. 			}
    1957. 

  1957. 			
    1958. 

  1958. 			// Get table level foreign key definitions
    1959. 

  1959. 			preg_match_all('#(?<=,|\()\s*FOREIGN\s+KEY\s*(?:["`\[]?(\w+)["`\]]?|\(\s*["`\[]?(\w+)["`\]]?\s*\))\s+REFERENCES\s+["`\[]?(\w+)["`\]]?\s*\(\s*["`\[]?(\w+)["`\]]?\s*\)\s*(?:\s+(?:ON\s+DELETE\s+(CASCADE|NO\s+ACTION|RESTRICT|SET\s+NULL|SET\s+DEFAULT)))?(?:\s+(?:ON\s+UPDATE\s+(CASCADE|NO\s+ACTION|RESTRICT|SET\s+NULL|SET\s+DEFAULT)))?(?:\s+(?:DEFERRABLE|NOT\s+DEFERRABLE))?\s*(?:,|\s*(?=\)))#mi', $create_sql, $matches, PREG_SET_ORDER);
    1960. 

  1960. 			
    1961. 

  1961. 			foreach ($matches as $match) {
    1962. 

  1962. 				if (empty($match[1])) { $match[1] = $match[2]; }
    1963. 

  1963. 				$temp = array('column'         => $match[1],
    1964. 

  1964. 							  'foreign_table'  => $match[3],
    1965. 

  1965. 							  'foreign_column' => $match[4],
    1966. 

  1966. 							  'on_delete'      => 'no_action',
    1967. 

  1967. 							  'on_update'      => 'no_action');
    1968. 

  1968. 				if (isset($match[5])) {
    1969. 

  1969. 					$temp['on_delete'] = strtolower(str_replace(' ', '_', $match[5]));
    1970. 

  1970. 				}
    1971. 

  1971. 				if (isset($match[6])) {
    1972. 

  1972. 					$temp['on_update'] = strtolower(str_replace(' ', '_', $match[6]));
    1973. 

  1973. 				}
    1974. 

  1974. 				$keys[$table]['foreign'][] = $temp;
    1975. 

  1975. 			}
    1976. 

  1976. 			
    1977. 

  1977. 			// Get table level unique key definitions
    1978. 

  1978. 			preg_match_all('#(?<=,|\()\s*UNIQUE\s*\(\s*((?:\s*["`\[]?\w+["`\]]?\s*,\s*)*["`\[]?\w+["`\]]?)\s*\)\s*(?:,|\s*(?=\)))#mi', $create_sql, $matches, PREG_SET_ORDER);
    1979. 

  1979. 			
    1980. 

  1980. 			foreach ($matches as $match) {
    1981. 

  1981. 				$columns = preg_split('#\s*,\s*#', $match[1]);
    1982. 

  1982. 				$key = array();
    1983. 

  1983. 				foreach ($columns as $column) {
    1984. 

  1984. 					$key[] = str_replace(array('[', '"', '`', ']'), '', $column);
    1985. 

  1985. 				}
    1986. 

  1986. 				$keys[$table]['unique'][] = $key;
    1987. 

  1987. 			}
    1988. 

  1988. 		}
    1989. 

  1989. 		
    1990. 

  1990. 		return $keys;
    1991. 

  1991. 	}
    1992. 

  1992. 	
    1993. 

  1993. 	
    1994. 

  1994. 	/**
    1995. 

  1995. 	 * Finds many-to-many relationship for the table specified
    1996. 

  1996. 	 * 
    1997. 

  1997. 	 * @param  string $table  The table to find the relationships on
    1998. 

  1998. 	 * @return void
    1999. 

  1999. 	 */
    2000. 

  2000. 	private function findManyToManyRelationships($table)
    2001. 

  2001. 	{
    2002. 

  2002. 		if (!$this->isJoiningTable($table)) {
    2003. 

  2003. 			return;
    2004. 

  2004. 		}
    2005. 

  2005. 		
    2006. 

  2006. 		list ($key1, $key2) = $this->merged_keys[$table]['foreign'];
    2007. 

  2007. 		
    2008. 

  2008. 		$temp = array();
    2009. 

  2009. 		$temp['table']               = $key1['foreign_table'];
    2010. 

  2010. 		$temp['column']              = $key1['foreign_column'];
    2011. 

  2011. 		$temp['related_table']       = $key2['foreign_table'];
    2012. 

  2012. 		$temp['related_column']      = $key2['foreign_column'];
    2013. 

  2013. 		$temp['join_table']          = $table;
    2014. 

  2014. 		$temp['join_column']         = $key1['column'];
    2015. 

  2015. 		$temp['join_related_column'] = $key2['column'];
    2016. 

  2016. 		$temp['on_update']           = $key1['on_update'];
    2017. 

  2017. 		$temp['on_delete']           = $key1['on_delete'];
    2018. 

  2018. 		$this->relationships[$key1['foreign_table']]['many-to-many'][] = $temp;
    2019. 

  2019. 		
    2020. 

  2020. 		$temp = array();
    2021. 

  2021. 		$temp['table']               = $key2['foreign_table'];
    2022. 

  2022. 		$temp['column']              = $key2['foreign_column'];
    2023. 

  2023. 		$temp['related_table']       = $key1['foreign_table'];
    2024. 

  2024. 		$temp['related_column']      = $key1['foreign_column'];
    2025. 

  2025. 		$temp['join_table']          = $table;
    2026. 

  2026. 		$temp['join_column']         = $key2['column'];
    2027. 

  2027. 		$temp['join_related_column'] = $key1['column'];
    2028. 

  2028. 		$temp['on_update']           = $key2['on_update'];
    2029. 

  2029. 		$temp['on_delete']           = $key2['on_delete'];
    2030. 

  2030. 		$this->relationships[$key2['foreign_table']]['many-to-many'][] = $temp;
    2031. 

  2031. 	}
    2032. 

  2032. 	
    2033. 

  2033. 	
    2034. 

  2034. 	/**
    2035. 

  2035. 	 * Finds one-to-many relationship for the table specified
    2036. 

  2036. 	 * 
    2037. 

  2037. 	 * @param  string $table  The table to find the relationships on
    2038. 

  2038. 	 * @return void
    2039. 

  2039. 	 */
    2040. 

  2040. 	private function findOneToManyRelationships($table)
    2041. 

  2041. 	{
    2042. 

  2042. 		foreach ($this->merged_keys[$table]['foreign'] as $key) {
    2043. 

  2043. 			$type = ($this->checkForSingleColumnUniqueKey($table, $key['column'])) ? 'one-to-one' : 'one-to-many';
    2044. 

  2044. 			$temp = array();
    2045. 

  2045. 			$temp['table']          = $key['foreign_table'];
    2046. 

  2046. 			$temp['column']         = $key['foreign_column'];
    2047. 

  2047. 			$temp['related_table']  = $table;
    2048. 

  2048. 			$temp['related_column'] = $key['column'];
    2049. 

  2049. 			$temp['on_delete']      = $key['on_delete'];
    2050. 

  2050. 			$temp['on_update']      = $key['on_update'];
    2051. 

  2051. 			$this->relationships[$key['foreign_table']][$type][] = $temp;
    2052. 

  2052. 		}
    2053. 

  2053. 	}
    2054. 

  2054. 	
    2055. 

  2055. 	
    2056. 

  2056. 	/**
    2057. 

  2057. 	 * Finds one-to-one and many-to-one relationship for the table specified
    2058. 

  2058. 	 * 
    2059. 

  2059. 	 * @param  string $table  The table to find the relationships on
    2060. 

  2060. 	 * @return void
    2061. 

  2061. 	 */
    2062. 

  2062. 	private function findStarToOneRelationships($table)
    2063. 

  2063. 	{
    2064. 

  2064. 		foreach ($this->merged_keys[$table]['foreign'] as $key) {
    2065. 

  2065. 			$temp = array();
    2066. 

  2066. 			$temp['table']          = $table;
    2067. 

  2067. 			$temp['column']         = $key['column'];
    2068. 

  2068. 			$temp['related_table']  = $key['foreign_table'];
    2069. 

  2069. 			$temp['related_column'] = $key['foreign_column'];
    2070. 

  2070. 			$type = ($this->checkForSingleColumnUniqueKey($table, $key['column'])) ? 'one-to-one' : 'many-to-one';
    2071. 

  2071. 			if ($type == 'one-to-one') {
    2072. 

  2072. 				$temp['on_delete'] = $key['on_delete'];
    2073. 

  2073. 				$temp['on_update'] = $key['on_update'];	
    2074. 

  2074. 			}
    2075. 

  2075. 			$this->relationships[$table][$type][] = $temp;
    2076. 

  2076. 		}
    2077. 

  2077. 	}
    2078. 

  2078. 	
    2079. 

  2079. 	
    2080. 

  2080. 	/**
    2081. 

  2081. 	 * Finds the one-to-one, many-to-one, one-to-many and many-to-many relationships in the database
    2082. 

  2082. 	 * 
    2083. 

  2083. 	 * @return void
    2084. 

  2084. 	 */
    2085. 

  2085. 	private function findRelationships()
    2086. 

  2086. 	{
    2087. 

  2087. 		$this->relationships = array();
    2088. 

  2088. 		$tables = $this->getTables();
    2089. 

  2089. 		
    2090. 

  2090. 		foreach ($tables as $table) {
    2091. 

  2091. 			$this->relationships[$table]['one-to-one']   = array();
    2092. 

  2092. 			$this->relationships[$table]['many-to-one']  = array();
    2093. 

  2093. 			$this->relationships[$table]['one-to-many']  = array();
    2094. 

  2094. 			$this->relationships[$table]['many-to-many'] = array();
    2095. 

  2095. 		}
    2096. 

  2096. 		
    2097. 

  2097. 		// Calculate the relationships
    2098. 

  2098. 		foreach ($this->merged_keys as $table => $keys) {
    2099. 

  2099. 			$this->findManyToManyRelationships($table);
    2100. 

  2100. 			if ($this->isJoiningTable($table)) {
    2101. 

  2101. 				continue;
    2102. 

  2102. 			}
    2103. 

  2103. 			
    2104. 

  2104. 			$this->findStarToOneRelationships($table);
    2105. 

  2105. 			$this->findOneToManyRelationships($table);
    2106. 

  2106. 		}
    2107. 

  2107. 		
    2108. 

  2108. 		if ($this->cache) {
    2109. 

  2109. 			$this->cache->set($this->makeCachePrefix() . 'relationships', $this->relationships);	
    2110. 

  2110. 		}
    2111. 

  2111. 	}
    2112. 

  2112. 	
    2113. 

  2113. 	
    2114. 

  2114. 	/**
    2115. 

  2115. 	 * Returns column information for the table specified
    2116. 

  2116. 	 * 
    2117. 

  2117. 	 * If only a table is specified, column info is in the following format:
    2118. 

  2118. 	 * 
    2119. 

  2119. 	 * {{{
    2120. 

  2120. 	 * array(
    2121. 

  2121. 	 *     (string) {column name} => array(
    2122. 

  2122. 	 *         'type'           => (string)  {data type},
    2123. 

  2123. 	 *         'placeholder'    => (string)  {fDatabase::escape() placeholder for this data type},
    2124. 

  2124. 	 *         'not_null'       => (boolean) {if value can't be null},
    2125. 

  2125. 	 *         'default'        => (mixed)   {the default value},
    2126. 

  2126. 	 *         'valid_values'   => (array)   {the valid values for a varchar field},
    2127. 

  2127. 	 *         'max_length'     => (integer) {the maximum length in a varchar field},
    2128. 

  2128. 	 *         'min_value'      => (numeric) {the minimum value for an integer/float field},
    2129. 

  2129. 	 *         'max_value'      => (numeric) {the maximum value for an integer/float field},
    2130. 

  2130. 	 *         'decimal_places' => (integer) {the number of decimal places for a decimal/numeric/money/smallmoney field},
    2131. 

  2131. 	 *         'auto_increment' => (boolean) {if the integer primary key column is a serial/autoincrement/auto_increment/indentity column}
    2132. 

  2132. 	 *     ), ...
    2133. 

  2133. 	 * )
    2134. 

  2134. 	 * }}}
    2135. 

  2135. 	 * 
    2136. 

  2136. 	 * If a table and column are specified, column info is in the following format:
    2137. 

  2137. 	 * 
    2138. 

  2138. 	 * {{{
    2139. 

  2139. 	 * array(
    2140. 

  2140. 	 *     'type'           => (string)  {data type},
    2141. 

  2141. 	 *     'placeholder'    => (string)  {fDatabase::escape() placeholder for this data type},
    2142. 

  2142. 	 *     'not_null'       => (boolean) {if value can't be null},
    2143. 

  2143. 	 *     'default'        => (mixed)   {the default value-may contain special strings CURRENT_TIMESTAMP, CURRENT_TIME or CURRENT_DATE},
    2144. 

  2144. 	 *     'valid_values'   => (array)   {the valid values for a varchar field},
    2145. 

  2145. 	 *     'max_length'     => (integer) {the maximum length in a char/varchar field},
    2146. 

  2146. 	 *     'min_value'      => (fNumber) {the minimum value for an integer/float field},
    2147. 

  2147. 	 *     'max_value'      => (fNumber) {the maximum value for an integer/float field},
    2148. 

  2148. 	  *    'decimal_places' => (integer) {the number of decimal places for a decimal/numeric/money/smallmoney field},
    2149. 

  2149. 	 *     'auto_increment' => (boolean) {if the integer primary key column is a serial/autoincrement/auto_increment/indentity column}
    2150. 

  2150. 	 * )
    2151. 

  2151. 	 * }}}
    2152. 

  2152. 	 * 
    2153. 

  2153. 	 * If a table, column and element are specified, returned value is the single element specified.
    2154. 

  2154. 	 * 
    2155. 

  2155. 	 * The `'type'` element is homogenized to a value from the following list:
    2156. 

  2156. 	 * 
    2157. 

  2157. 	 *  - `'varchar'`
    2158. 

  2158. 	 *  - `'char'`
    2159. 

  2159. 	 *  - `'text'`
    2160. 

  2160. 	 *  - `'integer'`
    2161. 

  2161. 	 *  - `'float'`
    2162. 

  2162. 	 *  - `'timestamp'`
    2163. 

  2163. 	 *  - `'date'`
    2164. 

  2164. 	 *  - `'time'`
    2165. 

  2165. 	 *  - `'boolean'`
    2166. 

  2166. 	 *  - `'blob'`
    2167. 

  2167. 	 * 
    2168. 

  2168. 	 * @param  string $table    The table to get the column info for
    2169. 

  2169. 	 * @param  string $column   The column to get the info for
    2170. 

  2170. 	 * @param  string $element  The element to return: `'type'`, `'placeholder'`, `'not_null'`, `'default'`, `'valid_values'`, `'max_length'`, `'min_value'`, `'max_value'`, `'decimal_places'`, `'auto_increment'`
    2171. 

  2171. 	 * @return mixed  The column info for the table/column/element specified - see method description for format
    2172. 

  2172. 	 */
    2173. 

  2173. 	public function getColumnInfo($table, $column=NULL, $element=NULL)
    2174. 

  2174. 	{
    2175. 

  2175. 		// Return the saved column info if possible
    2176. 

  2176. 		if (!$column && isset($this->merged_column_info[$table])) {
    2177. 

  2177. 			return $this->merged_column_info[$table];
    2178. 

  2178. 		}
    2179. 

  2179. 		if ($column && isset($this->merged_column_info[$table][$column])) {
    2180. 

  2180. 			if ($element !== NULL) {
    2181. 

  2181. 				if (!isset($this->merged_column_info[$table][$column][$element]) && !array_key_exists($element, $this->merged_column_info[$table][$column])) {
    2182. 

  2182. 					throw new fProgrammerException(
    2183. 

  2183. 						'The element specified, %1$s, is invalid. Must be one of: %2$s.',
    2184. 

  2184. 						$element,
    2185. 

  2185. 						join(', ', array('type', 'placeholder', 'not_null', 'default', 'valid_values', 'max_length', 'min_value', 'max_value', 'decimal_places', 'auto_increment'))
    2186. 

  2186. 					);	
    2187. 

  2187. 				}
    2188. 

  2188. 				return $this->merged_column_info[$table][$column][$element];
    2189. 

  2189. 			}
    2190. 

  2190. 			return $this->merged_column_info[$table][$column];
    2191. 

  2191. 		}
    2192. 

  2192. 		
    2193. 

  2193. 		if (!in_array($table, $this->getTables())) {
    2194. 

  2194. 			throw new fProgrammerException(
    2195. 

  2195. 				'The table specified, %s, does not exist in the database',
    2196. 

  2196. 				$table
    2197. 

  2197. 			);
    2198. 

  2198. 		}
    2199. 

  2199. 		
    2200. 

  2200. 		$this->fetchColumnInfo($table);
    2201. 

  2201. 		$this->mergeColumnInfo();
    2202. 

  2202. 		
    2203. 

  2203. 		if ($column && !isset($this->merged_column_info[$table][$column])) {
    2204. 

  2204. 			throw new fProgrammerException(
    2205. 

  2205. 				'The column specified, %1$s, does not exist in the table %2$s',
    2206. 

  2206. 				$column,
    2207. 

  2207. 				$table
    2208. 

  2208. 			);
    2209. 

  2209. 		}
    2210. 

  2210. 		
    2211. 

  2211. 		if ($column) {
    2212. 

  2212. 			if ($element) {
    2213. 

  2213. 				return $this->merged_column_info[$table][$column][$element];
    2214. 

  2214. 			}
    2215. 

  2215. 			
    2216. 

  2216. 			return $this->merged_column_info[$table][$column];
    2217. 

  2217. 		}
    2218. 

  2218. 		
    2219. 

  2219. 		return $this->merged_column_info[$table];
    2220. 

  2220. 	}
    2221. 

  2221. 	
    2222. 

  2222. 	
    2223. 

  2223. 	/**
    2224. 

  2224. 	 * Returns the databases on the current server
    2225. 

  2225. 	 * 
    2226. 

  2226. 	 * @return array  The databases on the current server
    2227. 

  2227. 	 */
    2228. 

  2228. 	public function getDatabases()
    2229. 

  2229. 	{
    2230. 

  2230. 		if ($this->databases !== NULL) {
    2231. 

  2231. 			return $this->databases;
    2232. 

  2232. 		}
    2233. 

  2233. 		
    2234. 

  2234. 		$this->databases = array();
    2235. 

  2235. 		
    2236. 

  2236. 		switch ($this->database->getType()) {
    2237. 

  2237. 			case 'mssql':
    2238. 

  2238. 				$sql = 'EXECUTE sp_databases';
    2239. 

  2239. 				break;
    2240. 

  2240. 			
    2241. 

  2241. 			case 'mysql':
    2242. 

  2242. 				$sql = 'SHOW DATABASES';
    2243. 

  2243. 				break;
    2244. 

  2244. 				
    2245. 

  2245. 			case 'oracle':
    2246. 

  2246. 				$sql = 'SELECT ora_database_name FROM dual';
    2247. 

  2247. 			
    2248. 

  2248. 			case 'postgresql':
    2249. 

  2249. 				$sql = "SELECT
    2250. 

  2250. 								datname
    2251. 

  2251. 							FROM
    2252. 

  2252. 								pg_database
    2253. 

  2253. 							ORDER BY
    2254. 

  2254. 								LOWER(datname)";
    2255. 

  2255. 				break;
    2256. 

  2256. 								
    2257. 

  2257. 			case 'db2':
    2258. 

  2258. 			case 'sqlite':
    2259. 

  2259. 				$this->databases[] = $this->database->getDatabase();
    2260. 

  2260. 				return $this->databases;
    2261. 

  2261. 		}
    2262. 

  2262. 		
    2263. 

  2263. 		$result = $this->database->query($sql);
    2264. 

  2264. 		
    2265. 

  2265. 		foreach ($result as $row) {
    2266. 

  2266. 			$keys = array_keys($row);
    2267. 

  2267. 			$this->databases[] = $row[$keys[0]];
    2268. 

  2268. 		}
    2269. 

  2269. 		
    2270. 

  2270. 		if ($this->cache) {
    2271. 

  2271. 			$this->cache->set($this->makeCachePrefix() . 'databases', $this->databases);		
    2272. 

  2272. 		}
    2273. 

  2273. 		
    2274. 

  2274. 		return $this->databases;
    2275. 

  2275. 	}
    2276. 

  2276. 	
    2277. 

  2277. 	
    2278. 

  2278. 	/**
    2279. 

  2279. 	 * Returns a list of primary key, foreign key and unique key constraints for the table specified
    2280. 

  2280. 	 * 
    2281. 

  2281. 	 * The structure of the returned array is:
    2282. 

  2282. 	 * 
    2283. 

  2283. 	 * {{{
    2284. 

  2284. 	 * array(
    2285. 

  2285. 	 *      'primary' => array(
    2286. 

  2286. 	 *          {column name}, ...
    2287. 

  2287. 	 *      ),
    2288. 

  2288. 	 *      'unique'  => array(
    2289. 

  2289. 	 *          array(
    2290. 

  2290. 	 *              {column name}, ...
    2291. 

  2291. 	 *          ), ...
    2292. 

  2292. 	 *      ),
    2293. 

  2293. 	 *      'foreign' => array(
    2294. 

  2294. 	 *          array(
    2295. 

  2295. 	 *              'column'         => {column name},
    2296. 

  2296. 	 *              'foreign_table'  => {foreign table name},
    2297. 

  2297. 	 *              'foreign_column' => {foreign column name},
    2298. 

  2298. 	 *              'on_delete'      => {the ON DELETE action: 'no_action', 'restrict', 'cascade', 'set_null', or 'set_default'},
    2299. 

  2299. 	 *              'on_update'      => {the ON UPDATE action: 'no_action', 'restrict', 'cascade', 'set_null', or 'set_default'}
    2300. 

  2300. 	 *          ), ...
    2301. 

  2301. 	 *      )
    2302. 

  2302. 	 * )
    2303. 

  2303. 	 * }}}
    2304. 

  2304. 	 * 
    2305. 

  2305. 	 * @param  string $table     The table to return the keys for
    2306. 

  2306. 	 * @param  string $key_type  The type of key to return: `'primary'`, `'foreign'`, `'unique'`
    2307. 

  2307. 	 * @return array  An array of all keys, or just the type specified - see method description for format
    2308. 

  2308. 	 */
    2309. 

  2309. 	public function getKeys($table, $key_type=NULL)
    2310. 

  2310. 	{
    2311. 

  2311. 		$valid_key_types = array('primary', 'foreign', 'unique');
    2312. 

  2312. 		if ($key_type !== NULL && !in_array($key_type, $valid_key_types)) {
    2313. 

  2313. 			throw new fProgrammerException(
    2314. 

  2314. 				'The key type specified, %1$s, is invalid. Must be one of: %2$s.',
    2315. 

  2315. 				$key_type,
    2316. 

  2316. 				join(', ', $valid_key_types)
    2317. 

  2317. 			);
    2318. 

  2318. 		}
    2319. 

  2319. 		
    2320. 

  2320. 		// Return the saved column info if possible
    2321. 

  2321. 		if (!$key_type && isset($this->merged_keys[$table])) {
    2322. 

  2322. 			return $this->merged_keys[$table];
    2323. 

  2323. 		}
    2324. 

  2324. 		
    2325. 

  2325. 		if ($key_type && isset($this->merged_keys[$table][$key_type])) {
    2326. 

  2326. 			return $this->merged_keys[$table][$key_type];
    2327. 

  2327. 		}
    2328. 

  2328. 		
    2329. 

  2329. 		if (!in_array($table, $this->getTables())) {
    2330. 

  2330. 			throw new fProgrammerException(
    2331. 

  2331. 				'The table specified, %s, does not exist in the database',
    2332. 

  2332. 				$table
    2333. 

  2333. 			);
    2334. 

  2334. 		}
    2335. 

  2335. 		
    2336. 

  2336. 		$this->fetchKeys();
    2337. 

  2337. 		$this->mergeKeys();
    2338. 

  2338. 		
    2339. 

  2339. 		if ($key_type) {
    2340. 

  2340. 			return $this->merged_keys[$table][$key_type];
    2341. 

  2341. 		}
    2342. 

  2342. 		
    2343. 

  2343. 		return $this->merged_keys[$table];
    2344. 

  2344. 	}
    2345. 

  2345. 	
    2346. 

  2346. 	
    2347. 

  2347. 	/**
    2348. 

  2348. 	 * Returns a list of one-to-one, many-to-one, one-to-many and many-to-many relationships for the table specified
    2349. 

  2349. 	 * 
    2350. 

  2350. 	 * The structure of the returned array is:
    2351. 

  2351. 	 * 
    2352. 

  2352. 	 * {{{
    2353. 

  2353. 	 * array(
    2354. 

  2354. 	 *     'one-to-one' => array(
    2355. 

  2355. 	 *         array(
    2356. 

  2356. 	 *             'table'          => (string) {the name of the table this relationship is for},
    2357. 

  2357. 	 *             'column'         => (string) {the column in the specified table},
    2358. 

  2358. 	 *             'related_table'  => (string) {the related table},
    2359. 

  2359. 	 *             'related_column' => (string) {the related column},
    2360. 

  2360. 	 *             'on_delete'      => (string) {the ON DELETE action: 'no_action', 'restrict', 'cascade', 'set_null', or 'set_default'},
    2361. 

  2361. 	 *             'on_update'      => (string) {the ON UPDATE action: 'no_action', 'restrict', 'cascade', 'set_null', or 'set_default'}
    2362. 

  2362. 	 *         ), ...
    2363. 

  2363. 	 *     ),
    2364. 

  2364. 	 *     'many-to-one' => array(
    2365. 

  2365. 	 *         array(
    2366. 

  2366. 	 *             'table'          => (string) {the name of the table this relationship is for},
    2367. 

  2367. 	 *             'column'         => (string) {the column in the specified table},
    2368. 

  2368. 	 *             'related_table'  => (string) {the related table},
    2369. 

  2369. 	 *             'related_column' => (string) {the related column}
    2370. 

  2370. 	 *         ), ...
    2371. 

  2371. 	 *     ),
    2372. 

  2372. 	 *     'one-to-many' => array(
    2373. 

  2373. 	 *         array(
    2374. 

  2374. 	 *             'table'          => (string) {the name of the table this relationship is for},
    2375. 

  2375. 	 *             'column'         => (string) {the column in the specified table},
    2376. 

  2376. 	 *             'related_table'  => (string) {the related table},
    2377. 

  2377. 	 *             'related_column' => (string) {the related column},
    2378. 

  2378. 	 *             'on_delete'      => (string) {the ON DELETE action: 'no_action', 'restrict', 'cascade', 'set_null', or 'set_default'},
    2379. 

  2379. 	 *             'on_update'      => (string) {the ON UPDATE action: 'no_action', 'restrict', 'cascade', 'set_null', or 'set_default'}
    2380. 

  2380. 	 *         ), ...
    2381. 

  2381. 	 *     ),
    2382. 

  2382. 	 *     'many-to-many' => array(
    2383. 

  2383. 	 *         array(
    2384. 

  2384. 	 *             'table'               => (string) {the name of the table this relationship is for},
    2385. 

  2385. 	 *             'column'              => (string) {the column in the specified table},
    2386. 

  2386. 	 *             'related_table'       => (string) {the related table},
    2387. 

  2387. 	 *             'related_column'      => (string) {the related column},
    2388. 

  2388. 	 *             'join_table'          => (string) {the table that joins the specified table to the related table},
    2389. 

  2389. 	 *             'join_column'         => (string) {the column in the join table that references 'column'},
    2390. 

  2390. 	 *             'join_related_column' => (string) {the column in the join table that references 'related_column'},
    2391. 

  2391. 	 *             'on_delete'           => (string) {the ON DELETE action: 'no_action', 'restrict', 'cascade', 'set_null', or 'set_default'},
    2392. 

  2392. 	 *             'on_update'           => (string) {the ON UPDATE action: 'no_action', 'restrict', 'cascade', 'set_null', or 'set_default'}
    2393. 

  2393. 	 *         ), ...
    2394. 

  2394. 	 *     )
    2395. 

  2395. 	 * )
    2396. 

  2396. 	 * }}}
    2397. 

  2397. 	 * 
    2398. 

  2398. 	 * @param  string $table              The table to return the relationships for
    2399. 

  2399. 	 * @param  string $relationship_type  The type of relationship to return: `'one-to-one'`, `'many-to-one'`, `'one-to-many'`, `'many-to-many'`
    2400. 

  2400. 	 * @return array  An array of all relationships, or just the type specified - see method description for format
    2401. 

  2401. 	 */
    2402. 

  2402. 	public function getRelationships($table, $relationship_type=NULL)
    2403. 

  2403. 	{
    2404. 

  2404. 		$valid_relationship_types = array('one-to-one', 'many-to-one', 'one-to-many', 'many-to-many');
    2405. 

  2405. 		if ($relationship_type !== NULL && !in_array($relationship_type, $valid_relationship_types)) {
    2406. 

  2406. 			throw new fProgrammerException(
    2407. 

  2407. 				'The relationship type specified, %1$s, is invalid. Must be one of: %2$s.',
    2408. 

  2408. 				$relationship_type,
    2409. 

  2409. 				join(', ', $valid_relationship_types)
    2410. 

  2410. 			);
    2411. 

  2411. 		}
    2412. 

  2412. 		
    2413. 

  2413. 		// Return the saved column info if possible
    2414. 

  2414. 		if (!$relationship_type && isset($this->relationships[$table])) {
    2415. 

  2415. 			return $this->relationships[$table];
    2416. 

  2416. 		}
    2417. 

  2417. 		
    2418. 

  2418. 		if ($relationship_type && isset($this->relationships[$table][$relationship_type])) {
    2419. 

  2419. 			return $this->relationships[$table][$relationship_type];
    2420. 

  2420. 		}
    2421. 

  2421. 		
    2422. 

  2422. 		if (!in_array($table, $this->getTables())) {
    2423. 

  2423. 			throw new fProgrammerException(
    2424. 

  2424. 				'The table specified, %s, does not exist in the database',
    2425. 

  2425. 				$table
    2426. 

  2426. 			);
    2427. 

  2427. 		}
    2428. 

  2428. 		
    2429. 

  2429. 		$this->fetchKeys();
    2430. 

  2430. 		$this->mergeKeys();
    2431. 

  2431. 		
    2432. 

  2432. 		if ($relationship_type) {
    2433. 

  2433. 			return $this->relationships[$table][$relationship_type];
    2434. 

  2434. 		}
    2435. 

  2435. 		
    2436. 

  2436. 		return $this->relationships[$table];
    2437. 

  2437. 	}
    2438. 

  2438. 	
    2439. 

  2439. 	
    2440. 

  2440. 	/**
    2441. 

  2441. 	 * Returns the tables in the current database
    2442. 

  2442. 	 * 
    2443. 

  2443. 	 * @return array  The tables in the current database
    2444. 

  2444. 	 */
    2445. 

  2445. 	public function getTables()
    2446. 

  2446. 	{
    2447. 

  2447. 		if ($this->tables !== NULL) {
    2448. 

  2448. 			return $this->tables;
    2449. 

  2449. 		}
    2450. 

  2450. 		
    2451. 

  2451. 		switch ($this->database->getType()) {
    2452. 

  2452. 			case 'db2':
    2453. 

  2453. 				$sql = "SELECT
    2454. 

  2454. 								LOWER(RTRIM(TABSCHEMA)) AS \"schema\",
    2455. 

  2455. 								LOWER(TABNAME) AS \"table\"
    2456. 

  2456. 							FROM
    2457. 

  2457. 								SYSCAT.TABLES
    2458. 

  2458. 							WHERE
    2459. 

  2459. 								TYPE = 'T' AND
    2460. 

  2460. 								TABSCHEMA != 'SYSIBM' AND
    2461. 

  2461. 								DEFINER != 'SYSIBM' AND
    2462. 

  2462. 								TABSCHEMA != 'SYSTOOLS' AND
    2463. 

  2463. 								DEFINER != 'SYSTOOLS'
    2464. 

  2464. 							ORDER BY
    2465. 

  2465. 								LOWER(TABNAME)";
    2466. 

  2466. 				break;
    2467. 

  2467. 				
    2468. 

  2468. 			case 'mssql':
    2469. 

  2469. 				$sql = "SELECT
    2470. 

  2470. 								TABLE_SCHEMA AS \"schema\",
    2471. 

  2471. 								TABLE_NAME AS \"table\"
    2472. 

  2472. 							FROM
    2473. 

  2473. 								INFORMATION_SCHEMA.TABLES
    2474. 

  2474. 							WHERE
    2475. 

  2475. 								TABLE_NAME != 'sysdiagrams'
    2476. 

  2476. 							ORDER BY
    2477. 

  2477. 								LOWER(TABLE_NAME)";
    2478. 

  2478. 				break;
    2479. 

  2479. 			
    2480. 

  2480. 			case 'mysql':
    2481. 

  2481. 				$version = $this->database->query("SELECT version()")->fetchScalar();
    2482. 

  2482. 				$version = substr($version, 0, strpos($version, '.'));
    2483. 

  2483. 				if ($version <= 4) {
    2484. 

  2484. 					$sql = 'SHOW TABLES';
    2485. 

  2485. 				} else {
    2486. 

  2486. 					$sql = "SHOW FULL TABLES WHERE table_type = 'BASE TABLE'";	
    2487. 

  2487. 				}
    2488. 

  2488. 				break;
    2489. 

  2489. 			
    2490. 

  2490. 			case 'oracle':
    2491. 

  2491. 				$sql = "SELECT
    2492. 

  2492. 								LOWER(OWNER) AS \"SCHEMA\",
    2493. 

  2493. 								LOWER(TABLE_NAME) AS \"TABLE\"
    2494. 

  2494. 							FROM
    2495. 

  2495. 								ALL_TABLES
    2496. 

  2496. 							WHERE
    2497. 

  2497. 								OWNER NOT IN (
    2498. 

  2498. 									'SYS',
    2499. 

  2499. 									'SYSTEM',
    2500. 

  2500. 									'OUTLN',
    2501. 

  2501. 									'ANONYMOUS',
    2502. 

  2502. 									'AURORA\$ORB\$UNAUTHENTICATED',
    2503. 

  2503. 									'AWR_STAGE',
    2504. 

  2504. 									'CSMIG',
    2505. 

  2505. 									'CTXSYS',
    2506. 

  2506. 									'DBSNMP',
    2507. 

  2507. 									'DIP',
    2508. 

  2508. 									'DMSYS',
    2509. 

  2509. 									'DSSYS',
    2510. 

  2510. 									'EXFSYS',
    2511. 

  2511. 									'FLOWS_020100',
    2512. 

  2512. 									'FLOWS_FILES',
    2513. 

  2513. 									'LBACSYS',
    2514. 

  2514. 									'MDSYS',
    2515. 

  2515. 									'ORACLE_OCM',
    2516. 

  2516. 									'ORDPLUGINS',
    2517. 

  2517. 									'ORDSYS',
    2518. 

  2518. 									'PERFSTAT',
    2519. 

  2519. 									'TRACESVR',
    2520. 

  2520. 									'TSMSYS',
    2521. 

  2521. 									'XDB'
    2522. 

  2522. 								) AND
    2523. 

  2523. 								DROPPED = 'NO' 
    2524. 

  2524. 							ORDER BY
    2525. 

  2525. 								TABLE_NAME ASC";
    2526. 

  2526. 				break;
    2527. 

  2527. 			
    2528. 

  2528. 			case 'postgresql':
    2529. 

  2529. 				$sql = "SELECT
    2530. 

  2530. 								 schemaname AS \"schema\",
    2531. 

  2531. 								 tablename as \"table\"
    2532. 

  2532. 							FROM
    2533. 

  2533. 								 pg_tables
    2534. 

  2534. 							WHERE
    2535. 

  2535. 								 tablename !~ '^(pg|sql)_'
    2536. 

  2536. 							ORDER BY
    2537. 

  2537. 								LOWER(tablename)";
    2538. 

  2538. 				break;
    2539. 

  2539. 								
    2540. 

  2540. 			case 'sqlite':
    2541. 

  2541. 				$sql = "SELECT
    2542. 

  2542. 								name
    2543. 

  2543. 							FROM
    2544. 

  2544. 								sqlite_master
    2545. 

  2545. 							WHERE
    2546. 

  2546. 								type = 'table' AND
    2547. 

  2547. 								name NOT LIKE 'sqlite_%'
    2548. 

  2548. 							ORDER BY
    2549. 

  2549. 								name ASC";
    2550. 

  2550. 				break;
    2551. 

  2551. 		}
    2552. 

  2552. 		
    2553. 

  2553. 		$result = $this->database->query($sql);
    2554. 

  2554. 		
    2555. 

  2555. 		$this->tables = array();
    2556. 

  2556. 		
    2557. 

  2557. 		// For databases with schemas we only include the schema
    2558. 

  2558. 		// name if there are conflicting table names
    2559. 

  2559. 		if (!in_array($this->database->getType(), array('mysql', 'sqlite'))) {
    2560. 

  2560. 			
    2561. 

  2561. 			$default_schema_map = array(
    2562. 

  2562. 				'db2'        => strtolower($this->database->getUsername()),
    2563. 

  2563. 				'mssql'      => 'dbo',
    2564. 

  2564. 				'oracle'     => strtolower($this->database->getUsername()),
    2565. 

  2565. 				'postgresql' => 'public'
    2566. 

  2566. 			);
    2567. 

  2567. 			
    2568. 

  2568. 			$default_schema = $default_schema_map[$this->database->getType()];
    2569. 

  2569. 			
    2570. 

  2570. 			foreach ($result as $row) {
    2571. 

  2571. 				if ($row['schema'] == $default_schema) {
    2572. 

  2572. 					$this->tables[] = $row['table'];	
    2573. 

  2573. 				} else {
    2574. 

  2574. 					$this->tables[] = $row['schema'] . '.' . $row['table'];	
    2575. 

  2575. 				}
    2576. 

  2576. 			}
    2577. 

  2577. 				
    2578. 

  2578. 		// SQLite and MySQL don't support schemas
    2579. 

  2579. 		} else {
    2580. 

  2580. 			foreach ($result as $row) {
    2581. 

  2581. 				$keys = array_keys($row);
    2582. 

  2582. 				$this->tables[] = $row[$keys[0]];
    2583. 

  2583. 			}
    2584. 

  2584. 		}
    2585. 

  2585. 		
    2586. 

  2586. 		sort($this->tables);
    2587. 

  2587. 		
    2588. 

  2588. 		if ($this->cache) {
    2589. 

  2589. 			$this->cache->set($this->makeCachePrefix() . 'tables', $this->tables);
    2590. 

  2590. 		}
    2591. 

  2591. 		
    2592. 

  2592. 		return $this->tables;
    2593. 

  2593. 	}
    2594. 

  2594. 		
    2595. 

  2595. 	
    2596. 

  2596. 	/**
    2597. 

  2597. 	 * Determines if a table is a joining table
    2598. 

  2598. 	 * 
    2599. 

  2599. 	 * @param  string $table  The table to check
    2600. 

  2600. 	 * @return boolean  If the table is a joining table
    2601. 

  2601. 	 */
    2602. 

  2602. 	private function isJoiningTable($table)
    2603. 

  2603. 	{
    2604. 

  2604. 		$primary_key_columns = $this->merged_keys[$table]['primary'];
    2605. 

  2605. 		
    2606. 

  2606. 		if (sizeof($primary_key_columns) != 2) {
    2607. 

  2607. 			return FALSE;	
    2608. 

  2608. 		}
    2609. 

  2609. 		
    2610. 

  2610. 		if (empty($this->merged_column_info[$table])) {
    2611. 

  2611. 			$this->getColumnInfo($table);	
    2612. 

  2612. 		}
    2613. 

  2613. 		if (sizeof($this->merged_column_info[$table]) != 2) {
    2614. 

  2614. 			return FALSE;	
    2615. 

  2615. 		}
    2616. 

  2616. 		
    2617. 

  2617. 		$foreign_key_columns = array();
    2618. 

  2618. 		foreach ($this->merged_keys[$table]['foreign'] as $key) {
    2619. 

  2619. 			$foreign_key_columns[] = $key['column'];
    2620. 

  2620. 		}
    2621. 

  2621. 		
    2622. 

  2622. 		return sizeof($foreign_key_columns) == 2 && !array_diff($foreign_key_columns, $primary_key_columns);
    2623. 

  2623. 	}
    2624. 

  2624. 	
    2625. 

  2625. 	
    2626. 

  2626. 	/**
    2627. 

  2627. 	 * Creates a unique cache prefix to help prevent cache conflicts
    2628. 

  2628. 	 * 
    2629. 

  2629. 	 * @return string  The cache prefix to use
    2630. 

  2630. 	 */
    2631. 

  2631. 	private function makeCachePrefix()
    2632. 

  2632. 	{
    2633. 

  2633. 		if (!$this->cache_prefix) {
    2634. 

  2634. 			$prefix  = 'fSchema::' . $this->database->getType() . '::';
    2635. 

  2635. 			if ($this->database->getHost()) {
    2636. 

  2636. 				$prefix .= $this->database->getHost() . '::';
    2637. 

  2637. 			}
    2638. 

  2638. 			if ($this->database->getPort()) {
    2639. 

  2639. 				$prefix .= $this->database->getPort() . '::';
    2640. 

  2640. 			}
    2641. 

  2641. 			$prefix .= $this->database->getDatabase() . '::';
    2642. 

  2642. 			if ($this->database->getUsername()) {
    2643. 

  2643. 				$prefix .= $this->database->getUsername() . '::';
    2644. 

  2644. 			}
    2645. 

  2645. 			$this->cache_prefix = $prefix;
    2646. 

  2646. 		}
    2647. 

  2647. 		
    2648. 

  2648. 		return $this->cache_prefix;
    2649. 

  2649. 	}
    2650. 

  2650. 	
    2651. 

  2651. 	
    2652. 

  2652. 	/**
    2653. 

  2653. 	 * Merges the column info with the column info override
    2654. 

  2654. 	 * 
    2655. 

  2655. 	 * @return void
    2656. 

  2656. 	 */
    2657. 

  2657. 	private function mergeColumnInfo()
    2658. 

  2658. 	{
    2659. 

  2659. 		$this->merged_column_info = $this->column_info;
    2660. 

  2660. 		
    2661. 

  2661. 		foreach ($this->column_info_override as $table => $columns) {
    2662. 

  2662. 			// Remove a table if the columns are set to NULL
    2663. 

  2663. 			if ($columns === NULL) {
    2664. 

  2664. 				unset($this->merged_column_info[$table]);
    2665. 

  2665. 				continue;	
    2666. 

  2666. 			}
    2667. 

  2667. 			
    2668. 

  2668. 			if (!isset($this->merged_column_info[$table])) {
    2669. 

  2669. 				$this->merged_column_info[$table] = array();
    2670. 

  2670. 			}
    2671. 

  2671. 			
    2672. 

  2672. 			foreach ($columns as $column => $info) {
    2673. 

  2673. 				// Remove a column if it is set to NULL
    2674. 

  2674. 				if ($info === NULL) {
    2675. 

  2675. 					unset($this->merged_column_info[$table][$column]);	
    2676. 

  2676. 					continue;
    2677. 

  2677. 				}
    2678. 

  2678. 				
    2679. 

  2679. 				if (!isset($this->merged_column_info[$table][$column])) {
    2680. 

  2680. 					$this->merged_column_info[$table][$column] = array();
    2681. 

  2681. 				}
    2682. 

  2682. 				
    2683. 

  2683. 				$this->merged_column_info[$table][$column] = array_merge($this->merged_column_info[$table][$column], $info);
    2684. 

  2684. 			}
    2685. 

  2685. 		}
    2686. 

  2686. 		
    2687. 

  2687. 		$optional_elements = array(
    2688. 

  2688. 			'not_null',
    2689. 

  2689. 			'default',
    2690. 

  2690. 			'valid_values',
    2691. 

  2691. 			'max_length',
    2692. 

  2692. 			'max_value',
    2693. 

  2693. 			'min_value',
    2694. 

  2694. 			'decimal_places',
    2695. 

  2695. 			'auto_increment'
    2696. 

  2696. 		);
    2697. 

  2697. 		
    2698. 

  2698. 		foreach ($this->merged_column_info as $table => $column_array) {
    2699. 

  2699. 			foreach ($column_array as $column => $info) {
    2700. 

  2700. 				if (empty($info['type'])) {
    2701. 

  2701. 					throw new fProgrammerException('The data type for the column %1$s is empty', $column);	
    2702. 

  2702. 				}
    2703. 

  2703. 				
    2704. 

  2704. 				if (empty($this->merged_column_info[$table][$column]['placeholder'])) {
    2705. 

  2705. 					$this->merged_column_info[$table][$column]['placeholder'] = strtr(
    2706. 

  2706. 						$info['type'],
    2707. 

  2707. 						array(
    2708. 

  2708. 							'blob'      => '%l',
    2709. 

  2709. 							'boolean'   => '%b',
    2710. 

  2710. 							'date'      => '%d',
    2711. 

  2711. 							'float'     => '%f',
    2712. 

  2712. 							'integer'   => '%i',
    2713. 

  2713. 							'char'      => '%s',
    2714. 

  2714. 							'text'      => '%s',
    2715. 

  2715. 							'varchar'   => '%s',
    2716. 

  2716. 							'time'      => '%t',
    2717. 

  2717. 							'timestamp' => '%p'
    2718. 

  2718. 						)
    2719. 

  2719. 					);
    2720. 

  2720. 				}
    2721. 

  2721. 				
    2722. 

  2722. 				foreach ($optional_elements as $element) {
    2723. 

  2723. 					if (!isset($this->merged_column_info[$table][$column][$element])) {
    2724. 

  2724. 						$this->merged_column_info[$table][$column][$element] = ($element == 'auto_increment') ? FALSE : NULL;
    2725. 

  2725. 					}
    2726. 

  2726. 				}
    2727. 

  2727. 			}
    2728. 

  2728. 		}
    2729. 

  2729. 		
    2730. 

  2730. 		if ($this->cache) {
    2731. 

  2731. 			$this->cache->set($this->makeCachePrefix() . 'merged_column_info', $this->merged_column_info);	
    2732. 

  2732. 		}
    2733. 

  2733. 	}
    2734. 

  2734. 		
    2735. 

  2735. 	
    2736. 

  2736. 	/**
    2737. 

  2737. 	 * Merges the keys with the keys override
    2738. 

  2738. 	 * 
    2739. 

  2739. 	 * @return void
    2740. 

  2740. 	 */
    2741. 

  2741. 	private function mergeKeys()
    2742. 

  2742. 	{
    2743. 

  2743. 		// Handle the database and override key info
    2744. 

  2744. 		$this->merged_keys = $this->keys;
    2745. 

  2745. 		
    2746. 

  2746. 		foreach ($this->keys_override as $table => $info) {
    2747. 

  2747. 			if (!isset($this->merged_keys[$table])) {
    2748. 

  2748. 				$this->merged_keys[$table] = array();
    2749. 

  2749. 			}
    2750. 

  2750. 			$this->merged_keys[$table] = array_merge($this->merged_keys[$table], $info);
    2751. 

  2751. 		}
    2752. 

  2752. 		
    2753. 

  2753. 		if ($this->cache) {
    2754. 

  2754. 			$this->cache->set($this->makeCachePrefix() . 'merged_keys', $this->merged_keys);	
    2755. 

  2755. 		}
    2756. 

  2756. 		
    2757. 

  2757. 		$this->findRelationships();
    2758. 

  2758. 	}
    2759. 

  2759. 	
    2760. 

  2760. 	
    2761. 

  2761. 	/**
    2762. 

  2762. 	 * Allows overriding of column info
    2763. 

  2763. 	 * 
    2764. 

  2764. 	 * Performs an array merge with the column info detected from the database.
    2765. 

  2765. 	 * 
    2766. 

  2766. 	 * To erase a whole table, set the `$column_info` to `NULL`. To erase a
    2767. 

  2767. 	 * column, set the `$column_info` for that column to `NULL`.
    2768. 

  2768. 	 * 
    2769. 

  2769. 	 * If the `$column_info` parameter is not `NULL`, it should be an
    2770. 

  2770. 	 * associative array containing one or more of the following keys. Please
    2771. 

  2771. 	 * see ::getColumnInfo() for a description of each.
    2772. 

  2772. 	 *  - `'type'`
    2773. 

  2773. 	 *  - `'placeholder'`
    2774. 

  2774. 	 *  - `'not_null'`
    2775. 

  2775. 	 *  - `'default'`
    2776. 

  2776. 	 *  - `'valid_values'`
    2777. 

  2777. 	 *  - `'max_length'`
    2778. 

  2778. 	 *  - `'min_value'`
    2779. 

  2779. 	 *  - `'max_value'`
    2780. 

  2780. 	 *  - `'decimal_places'`
    2781. 

  2781. 	 *  - `'auto_increment'`
    2782. 

  2782. 	 * 
    2783. 

  2783. 	 * The following keys may be set to `NULL`:
    2784. 

  2784. 	 *  - `'not_null'`
    2785. 

  2785. 	 *  - `'default'`
    2786. 

  2786. 	 *  - `'valid_values'`
    2787. 

  2787. 	 *  - `'max_length'`
    2788. 

  2788. 	 *  - `'min_value'`
    2789. 

  2789. 	 *  - `'max_value'`
    2790. 

  2790. 	 *  - `'decimal_places'`
    2791. 

  2791. 	 *  
    2792. 

  2792. 	 * The key `'auto_increment'` should be a boolean.
    2793. 

  2793. 	 * 
    2794. 

  2794. 	 * The `'type'` key should be one of:
    2795. 

  2795. 	 *  - `'blob'`
    2796. 

  2796. 	 *  - `'boolean'`
    2797. 

  2797. 	 *  - `'char'`
    2798. 

  2798. 	 *  - `'date'`
    2799. 

  2799. 	 *  - `'float'`
    2800. 

  2800. 	 *  - `'integer'`
    2801. 

  2801. 	 *  - `'text'`
    2802. 

  2802. 	 *  - `'time'`
    2803. 

  2803. 	 *  - `'timestamp'`
    2804. 

  2804. 	 *  - `'varchar'`
    2805. 

  2805. 	 * 
    2806. 

  2806. 	 * @param  array  $column_info  The modified column info - see method description for format
    2807. 

  2807. 	 * @param  string $table        The table to override
    2808. 

  2808. 	 * @param  string $column       The column to override
    2809. 

  2809. 	 * @return void
    2810. 

  2810. 	 */
    2811. 

  2811. 	public function setColumnInfoOverride($column_info, $table, $column=NULL)
    2812. 

  2812. 	{
    2813. 

  2813. 		if (!isset($this->column_info_override[$table])) {
    2814. 

  2814. 			$this->column_info_override[$table] = array();
    2815. 

  2815. 		}
    2816. 

  2816. 		
    2817. 

  2817. 		if (!empty($column)) {
    2818. 

  2818. 			$this->column_info_override[$table][$column] = $column_info;
    2819. 

  2819. 		} else {
    2820. 

  2820. 			$this->column_info_override[$table] = $column_info;
    2821. 

  2821. 		}
    2822. 

  2822. 		
    2823. 

  2823. 		$this->fetchColumnInfo($table);
    2824. 

  2824. 		$this->mergeColumnInfo();
    2825. 

  2825. 	}
    2826. 

  2826. 	
    2827. 

  2827. 	
    2828. 

  2828. 	/**
    2829. 

  2829. 	 * Allows overriding of key info. Replaces existing info, so be sure to provide full key info for type selected or all types.
    2830. 

  2830. 	 * 
    2831. 

  2831. 	 * @param  array  $keys      The modified keys - see ::getKeys() for format
    2832. 

  2832. 	 * @param  string $table     The table to override
    2833. 

  2833. 	 * @param  string $key_type  The key type to override: `'primary'`, `'foreign'`, `'unique'`
    2834. 

  2834. 	 * @return void
    2835. 

  2835. 	 */
    2836. 

  2836. 	public function setKeysOverride($keys, $table, $key_type=NULL)
    2837. 

  2837. 	{
    2838. 

  2838. 		$valid_key_types = array('primary', 'foreign', 'unique');
    2839. 

  2839. 		if (!in_array($key_type, $valid_key_types)) {
    2840. 

  2840. 			throw new fProgrammerException(
    2841. 

  2841. 				'The key type specified, %1$s, is invalid. Must be one of: %2$s.',
    2842. 

  2842. 				$key_type,
    2843. 

  2843. 				join(', ', $valid_key_types)
    2844. 

  2844. 			);
    2845. 

  2845. 		}
    2846. 

  2846. 		
    2847. 

  2847. 		if (!isset($this->keys_override[$table])) {
    2848. 

  2848. 			$this->keys_override[$table] = array();
    2849. 

  2849. 		}
    2850. 

  2850. 		
    2851. 

  2851. 		if (!empty($key_type)) {
    2852. 

  2852. 			$this->keys_override[$table][$key_type] = $keys;
    2853. 

  2853. 		} else {
    2854. 

  2854. 			$this->keys_override[$table] = $keys;
    2855. 

  2855. 		}
    2856. 

  2856. 		
    2857. 

  2857. 		$this->fetchKeys();
    2858. 

  2858. 		$this->mergeKeys();
    2859. 

  2859. 	}
    2860. 

  2860. }
    2861. 

  2861. 

  2862. 

  2863. 

  2864. /**
    2865. 

  2865.  * Copyright (c) 2007-2010 Will Bond <will@flourishlib.com>
    2866. 

  2866.  * 
    2867. 

  2867.  * Permission is hereby granted, free of charge, to any person obtaining a copy
    2868. 

  2868.  * of this software and associated documentation files (the "Software"), to deal
    2869. 

  2869.  * in the Software without restriction, including without limitation the rights
    2870. 

  2870.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    2871. 

  2871.  * copies of the Software, and to permit persons to whom the Software is
    2872. 

  2872.  * furnished to do so, subject to the following conditions:
    2873. 

  2873.  * 
    2874. 

  2874.  * The above copyright notice and this permission notice shall be included in
    2875. 

  2875.  * all copies or substantial portions of the Software.
    2876. 

  2876.  * 
    2877. 

  2877.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    2878. 

  2878.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    2879. 

  2879.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    2880. 

  2880.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    2881. 

  2881.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    2882. 

  2882.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    2883. 

  2883.  * THE SOFTWARE.
    2884. 

  2884.  */
    2885.