PageRenderTime 74ms CodeModel.GetById 25ms RepoModel.GetById 1ms app.codeStats 0ms

/classes/fSchema.php

https://bitbucket.org/wbond/flourish
PHP | 3157 lines | 2249 code | 319 blank | 589 comment | 318 complexity | c1a92bec7e4ab06e4c8e2ae4f356e0f0 MD5 | raw file
    

  1. <?php
    2. 

  2. /**
    3. 

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

  4.  * 
    5. 

  5.  * @copyright  Copyright (c) 2007-2012 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.0b51
    13. 

  13.  * @changes    1.0.0b51  Fixed handling of getting tables in table creation order when a table references itself, fixed default value detection for the last column in a MySQL table [wb, 2012-01-12]
    14. 

  14.  * @changes    1.0.0b50  Fixed detection of explicitly named SQLite foreign key constraints [wb, 2011-08-23]
    15. 

  15.  * @changes    1.0.0b49  Added support for spatial/geometric data types in MySQL and PostgreSQL [wb, 2011-05-26]
    16. 

  16.  * @changes    1.0.0b48  Fixed a bug with ::getTables() not working on MySQL 4.x, fixed ::getKeys() to always return a reset array [wb, 2011-05-24]
    17. 

  17.  * @changes    1.0.0b47  Backwards Compatibility Break - ::getTables(), ::getColumnInfo(), ::getDatabases(), ::getKeys() and ::getRelationships() now return database, schema, table and column names in lowercase, added the `$creation_order` parameter to ::getTables(), fixed bugs with getting column and key information from MSSQL, Oracle and SQLite [wb, 2011-05-09]
    18. 

  18.  * @changes    1.0.0b46  Enhanced SQLite schema detection to cover situations where `UNIQUE` constraints are defined separately from the table and when comments are used in `CREATE TABLE` statements [wb, 2011-02-06]
    19. 

  19.  * @changes    1.0.0b45  Fixed Oracle auto incrementing detection to work with `INSERT OR UPDATE` triggers, fixed detection of dynamic default date/time/timestamp values for DB2 and Oracle [wb, 2010-12-04]
    20. 

  20.  * @changes    1.0.0b44  Fixed the list of valid elements for ::getColumnInfo() [wb, 2010-11-28]
    21. 

  21.  * @changes    1.0.0b43  Added the `comment` element to the information returned by ::getColumnInfo() [wb, 2010-11-28]
    22. 

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

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

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

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

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

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

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

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

  30.  * @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]
    31. 

  31.  * @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]
    32. 

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

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

  34.  * @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]
    35. 

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

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

  37.  * @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]
    38. 

  38.  * @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]
    39. 

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

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

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

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

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

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

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

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

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

  48.  * @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]
    49. 

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

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

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

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

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

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

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

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

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

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

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

  60.  * @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]
    61. 

  61.  * @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]
    62. 

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

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

  64.  */
    65. 

  65. class fSchema
    66. 

  66. {
    67. 

  67. 	/**
    68. 

  68. 	 * The place to cache to
    69. 

  69. 	 * 
    70. 

  70. 	 * @var fCache
    71. 

  71. 	 */
    72. 

  72. 	private $cache = NULL;
    73. 

  73. 	
    74. 

  74. 	/**
    75. 

  75. 	 * The cache prefix to use for cache entries
    76. 

  76. 	 * 
    77. 

  77. 	 * @var string
    78. 

  78. 	 */
    79. 

  79. 	private $cache_prefix;
    80. 

  80. 	
    81. 

  81. 	/**
    82. 

  82. 	 * The cached column info
    83. 

  83. 	 * 
    84. 

  84. 	 * @var array
    85. 

  85. 	 */
    86. 

  86. 	private $column_info = array();
    87. 

  87. 	
    88. 

  88. 	/**
    89. 

  89. 	 * The column info to override
    90. 

  90. 	 * 
    91. 

  91. 	 * @var array
    92. 

  92. 	 */
    93. 

  93. 	private $column_info_override = array();
    94. 

  94. 	
    95. 

  95. 	/**
    96. 

  96. 	 * A reference to an instance of the fDatabase class
    97. 

  97. 	 * 
    98. 

  98. 	 * @var fDatabase
    99. 

  99. 	 */
    100. 

  100. 	private $database = NULL;
    101. 

  101. 	
    102. 

  102. 	/**
    103. 

  103. 	 * The databases on the current database server
    104. 

  104. 	 * 
    105. 

  105. 	 * @var array
    106. 

  106. 	 */
    107. 

  107. 	private $databases = NULL;
    108. 

  108. 	
    109. 

  109. 	/**
    110. 

  110. 	 * The cached key info
    111. 

  111. 	 * 
    112. 

  112. 	 * @var array
    113. 

  113. 	 */
    114. 

  114. 	private $keys = array();
    115. 

  115. 	
    116. 

  116. 	/**
    117. 

  117. 	 * The key info to override
    118. 

  118. 	 * 
    119. 

  119. 	 * @var array
    120. 

  120. 	 */
    121. 

  121. 	private $keys_override = array();
    122. 

  122. 	
    123. 

  123. 	/**
    124. 

  124. 	 * The merged column info
    125. 

  125. 	 * 
    126. 

  126. 	 * @var array
    127. 

  127. 	 */
    128. 

  128. 	private $merged_column_info = array();
    129. 

  129. 	
    130. 

  130. 	/**
    131. 

  131. 	 * The merged key info
    132. 

  132. 	 * 
    133. 

  133. 	 * @var array
    134. 

  134. 	 */
    135. 

  135. 	private $merged_keys = array();
    136. 

  136. 	
    137. 

  137. 	/**
    138. 

  138. 	 * The relationships in the database
    139. 

  139. 	 * 
    140. 

  140. 	 * @var array
    141. 

  141. 	 */
    142. 

  142. 	private $relationships = array();
    143. 

  143. 	
    144. 

  144. 	/**
    145. 

  145. 	 * The tables in the database
    146. 

  146. 	 * 
    147. 

  147. 	 * @var array
    148. 

  148. 	 */
    149. 

  149. 	private $tables = NULL;
    150. 

  150. 	
    151. 

  151. 	
    152. 

  152. 	/**
    153. 

  153. 	 * Sets the database
    154. 

  154. 	 * 
    155. 

  155. 	 * @param  fDatabase $database  The fDatabase instance
    156. 

  156. 	 * @return fSchema
    157. 

  157. 	 */
    158. 

  158. 	public function __construct($database)
    159. 

  159. 	{
    160. 

  160. 		$this->database = $database;
    161. 

  161. 	}
    162. 

  162. 	
    163. 

  163. 	
    164. 

  164. 	/**
    165. 

  165. 	 * All requests that hit this method should be requests for callbacks
    166. 

  166. 	 * 
    167. 

  167. 	 * @internal
    168. 

  168. 	 * 
    169. 

  169. 	 * @param  string $method  The method to create a callback for
    170. 

  170. 	 * @return callback  The callback for the method requested
    171. 

  171. 	 */
    172. 

  172. 	public function __get($method)
    173. 

  173. 	{
    174. 

  174. 		return array($this, $method);		
    175. 

  175. 	}
    176. 

  176. 	
    177. 

  177. 	
    178. 

  178. 	/**
    179. 

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

  180. 	 * 
    181. 

  181. 	 * @param  string $table   The table the column is located in
    182. 

  182. 	 * @param  string $column  The column to check
    183. 

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

  184. 	 */
    185. 

  185. 	private function checkForSingleColumnUniqueKey($table, $column)
    186. 

  186. 	{        
    187. 

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

  188. 			if (array($column) == $key) {
    189. 

  189. 				return TRUE;
    190. 

  190. 			}
    191. 

  191. 		}
    192. 

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

  193. 			return TRUE;
    194. 

  194. 		}
    195. 

  195. 		return FALSE;
    196. 

  196. 	}
    197. 

  197. 	
    198. 

  198. 	
    199. 

  199. 	/**
    200. 

  200. 	 * Clears all of the schema info out of the object and, if set, the fCache object
    201. 

  201. 	 * 
    202. 

  202. 	 * @internal
    203. 

  203. 	 * 
    204. 

  204. 	 * @return void
    205. 

  205. 	 */
    206. 

  206. 	public function clearCache()
    207. 

  207. 	{
    208. 

  208. 		$this->column_info        = array();
    209. 

  209. 		$this->databases          = NULL;
    210. 

  210. 		$this->keys               = array();
    211. 

  211. 		$this->merged_column_info = array();
    212. 

  212. 		$this->merged_keys        = array();
    213. 

  213. 		$this->relationships      = array();
    214. 

  214. 		$this->tables             = NULL;
    215. 

  215. 		if ($this->cache) {
    216. 

  216. 			$prefix = $this->makeCachePrefix();
    217. 

  217. 			$this->cache->delete($prefix . 'column_info');
    218. 

  218. 			$this->cache->delete($prefix . 'databases');
    219. 

  219. 			$this->cache->delete($prefix . 'keys');
    220. 

  220. 			$this->cache->delete($prefix . 'merged_column_info');
    221. 

  221. 			$this->cache->delete($prefix . 'merged_keys');
    222. 

  222. 			$this->cache->delete($prefix . 'relationships');
    223. 

  223. 			$this->cache->delete($prefix . 'tables');
    224. 

  224. 		}
    225. 

  225. 	}
    226. 

  226. 	
    227. 

  227. 	
    228. 

  228. 	/**
    229. 

  229. 	 * Returns an ordered array of table names, in a valid table creation order
    230. 

  230. 	 * 
    231. 

  231. 	 * @param string  $filter_table  The only return this table and tables that rely on it
    232. 

  232. 	 * @return array  An array of table names
    233. 

  233. 	 */
    234. 

  234. 	private function determineTableCreationOrder($filter_table=NULL)
    235. 

  235. 	{
    236. 

  236. 		$found          = array();
    237. 

  237. 		$ignored_found  = array();
    238. 

  238. 		
    239. 

  239. 		$current_tables = $this->getTables();
    240. 

  240. 		// Prevent an infinite loop
    241. 

  241. 		$last_tables    = array();
    242. 

  242. 		while ($current_tables && $current_tables != $last_tables) {
    243. 

  243. 			$remaining_tables = array();
    244. 

  244. 			foreach ($current_tables as $table) {
    245. 

  245. 				$foreign_keys = $this->getKeys($table, 'foreign');
    246. 

  246. 				if (!$foreign_keys) {
    247. 

  247. 					if ($filter_table !== NULL) {
    248. 

  248. 						if ($table == $filter_table) {
    249. 

  249. 							$found[] = $table;
    250. 

  250. 						} else {
    251. 

  251. 							$ignored_found[] = $table;
    252. 

  252. 						}
    253. 

  253. 					} else {
    254. 

  254. 						$found[] = $table;
    255. 

  255. 					}
    256. 

  256. 					
    257. 

  257. 				} else {
    258. 

  258. 					$all_dependencies_met = TRUE;
    259. 

  259. 					$found_dependencies   = 0;
    260. 

  260. 					foreach ($foreign_keys as $foreign_key) {
    261. 

  261. 						if ($table != $foreign_key['foreign_table'] && !in_array($foreign_key['foreign_table'], $found) && !in_array($foreign_key['foreign_table'], $ignored_found)) {
    262. 

  262. 							$all_dependencies_met = FALSE;
    263. 

  263. 							break;
    264. 

  264. 						} elseif (in_array($foreign_key['foreign_table'], $found)) {
    265. 

  265. 							$found_dependencies++;
    266. 

  266. 						}
    267. 

  267. 					}
    268. 

  268. 					if ($all_dependencies_met) {
    269. 

  269. 						if ($filter_table !== NULL) {
    270. 

  270. 							if ($found_dependencies || $table == $filter_table) {
    271. 

  271. 								$found[] = $table;
    272. 

  272. 							} else {
    273. 

  273. 								$ignored_found[] = $table;
    274. 

  274. 							}
    275. 

  275. 						} else {
    276. 

  276. 							$found[] = $table;
    277. 

  277. 						}
    278. 

  278. 						
    279. 

  279. 					} else {
    280. 

  280. 						$remaining_tables[] = $table;
    281. 

  281. 					}
    282. 

  282. 				}
    283. 

  283. 			}
    284. 

  284. 			$last_tables    = $current_tables;
    285. 

  285. 			$current_tables = $remaining_tables;
    286. 

  286. 		}
    287. 

  287. 		
    288. 

  288. 		return $found;
    289. 

  289. 	}
    290. 

  290. 	
    291. 

  291. 	
    292. 

  292. 	/**
    293. 

  293. 	 * Sets the schema to be cached to the fCache object specified
    294. 

  294. 	 * 
    295. 

  295. 	 * @param  fCache $cache      The cache to cache to
    296. 

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

  297. 	 * @return void
    298. 

  298. 	 */
    299. 

  299. 	public function enableCaching($cache, $key_token=NULL)
    300. 

  300. 	{
    301. 

  301. 		$this->cache = $cache;
    302. 

  302. 		
    303. 

  303. 		if ($key_token !== NULL) {
    304. 

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

  305. 		}
    306. 

  306. 		$prefix = $this->makeCachePrefix();
    307. 

  307. 		
    308. 

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

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

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

  311. 		
    312. 

  312. 		if (!$this->column_info_override && !$this->keys_override) {
    313. 

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

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

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

  316. 		}
    317. 

  317. 		
    318. 

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

  319. 	}
    320. 

  320. 	
    321. 

  321. 	
    322. 

  322. 	/**
    323. 

  323. 	 * Gets the column info from the database for later access
    324. 

  324. 	 * 
    325. 

  325. 	 * @param  string $table  The table to fetch the column info for
    326. 

  326. 	 * @return void
    327. 

  327. 	 */
    328. 

  328. 	private function fetchColumnInfo($table)
    329. 

  329. 	{
    330. 

  330. 		if (isset($this->column_info[$table])) {
    331. 

  331. 			return;	
    332. 

  332. 		}
    333. 

  333. 		
    334. 

  334. 		switch ($this->database->getType()) {
    335. 

  335. 			case 'db2':
    336. 

  336. 				$column_info = $this->fetchDB2ColumnInfo($table);
    337. 

  337. 				break;
    338. 

  338. 			
    339. 

  339. 			case 'mssql':
    340. 

  340. 				$column_info = $this->fetchMSSQLColumnInfo($table);
    341. 

  341. 				break;
    342. 

  342. 			
    343. 

  343. 			case 'mysql':
    344. 

  344. 				$column_info = $this->fetchMySQLColumnInfo($table);
    345. 

  345. 				break;
    346. 

  346. 				
    347. 

  347. 			case 'oracle':
    348. 

  348. 				$column_info = $this->fetchOracleColumnInfo($table);
    349. 

  349. 				break;
    350. 

  350. 			
    351. 

  351. 			case 'postgresql':
    352. 

  352. 				$column_info = $this->fetchPostgreSQLColumnInfo($table);
    353. 

  353. 				break;
    354. 

  354. 				
    355. 

  355. 			case 'sqlite':
    356. 

  356. 				$column_info = $this->fetchSQLiteColumnInfo($table);
    357. 

  357. 				break;
    358. 

  358. 		}
    359. 

  359. 			
    360. 

  360. 		if (!$column_info) {
    361. 

  361. 			return;	
    362. 

  362. 		}
    363. 

  363. 			
    364. 

  364. 		$this->column_info[$table] = $column_info;
    365. 

  365. 		if ($this->cache) {
    366. 

  366. 			$this->cache->set($this->makeCachePrefix() . 'column_info', $this->column_info);	
    367. 

  367. 		}
    368. 

  368. 	}
    369. 

  369. 	
    370. 

  370. 	
    371. 

  371. 	/**
    372. 

  372. 	 * Gets the column info from a DB2 database
    373. 

  373. 	 * 
    374. 

  374. 	 * @param  string $table  The table to fetch the column info for
    375. 

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

  376. 	 */
    377. 

  377. 	private function fetchDB2ColumnInfo($table)
    378. 

  378. 	{
    379. 

  379. 		$column_info = array();
    380. 

  380. 		
    381. 

  381. 		$schema = strtolower($this->database->getUsername());
    382. 

  382. 		if (strpos($table, '.') !== FALSE) {
    383. 

  383. 			list ($schema, $table) = explode('.', $table);
    384. 

  384. 		}
    385. 

  385. 		
    386. 

  386. 		$data_type_mapping = array(
    387. 

  387. 			'smallint'          => 'integer',
    388. 

  388. 			'integer'           => 'integer',
    389. 

  389. 			'bigint'            => 'integer',
    390. 

  390. 			'timestamp'         => 'timestamp',
    391. 

  391. 			'date'              => 'date',
    392. 

  392. 			'time'              => 'time',
    393. 

  393. 			'varchar'           => 'varchar',
    394. 

  394. 			'long varchar'      => 'varchar',
    395. 

  395. 			'vargraphic'        => 'varchar',
    396. 

  396. 			'long vargraphic'   => 'varchar',
    397. 

  397. 			'character'         => 'char',
    398. 

  398. 			'graphic'           => 'char',
    399. 

  399. 			'real'              => 'float',
    400. 

  400. 			'decimal'           => 'float',
    401. 

  401. 			'numeric'           => 'float',
    402. 

  402. 			'blob'              => 'blob',
    403. 

  403. 			'clob'              => 'text',
    404. 

  404. 			'dbclob'            => 'text'
    405. 

  405. 		);
    406. 

  406. 		
    407. 

  407. 		$max_min_values = array(
    408. 

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

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

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

  411. 		);
    412. 

  412. 		
    413. 

  413. 		// Get the column info
    414. 

  414. 		$sql = "SELECT
    415. 

  415. 					LOWER(C.COLNAME) AS \"COLUMN\",
    416. 

  416. 					C.TYPENAME AS TYPE,
    417. 

  417. 					C.NULLS AS NULLABLE,
    418. 

  418. 					C.DEFAULT,
    419. 

  419. 					C.LENGTH AS MAX_LENGTH,
    420. 

  420. 					C.SCALE,
    421. 

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

  422. 					CH.TEXT AS \"CONSTRAINT\",
    423. 

  423. 					C.REMARKS AS \"COMMENT\"
    424. 

  424. 				FROM
    425. 

  425. 					SYSCAT.COLUMNS AS C LEFT JOIN
    426. 

  426. 					SYSCAT.COLCHECKS AS CC ON
    427. 

  427. 						C.TABSCHEMA = CC.TABSCHEMA AND
    428. 

  428. 						C.TABNAME = CC.TABNAME AND
    429. 

  429. 						C.COLNAME = CC.COLNAME AND
    430. 

  430. 						CC.USAGE = 'R' LEFT JOIN
    431. 

  431. 					SYSCAT.CHECKS AS CH ON
    432. 

  432. 						C.TABSCHEMA = CH.TABSCHEMA AND
    433. 

  433. 						C.TABNAME = CH.TABNAME AND
    434. 

  434. 						CH.TYPE = 'C' AND
    435. 

  435. 						CH.CONSTNAME = CC.CONSTNAME
    436. 

  436. 				WHERE
    437. 

  437. 					LOWER(C.TABSCHEMA) = %s AND
    438. 

  438. 					LOWER(C.TABNAME) = %s
    439. 

  439. 				ORDER BY
    440. 

  440. 					C.COLNO ASC";
    441. 

  441. 		
    442. 

  442. 		$result = $this->database->query($sql, strtolower($schema), strtolower($table));
    443. 

  443. 		
    444. 

  444. 		foreach ($result as $row) {
    445. 

  445. 			
    446. 

  446. 			$info = array();
    447. 

  447. 			
    448. 

  448. 			foreach ($data_type_mapping as $data_type => $mapped_data_type) {
    449. 

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

  450. 					if (isset($max_min_values[$data_type])) {
    451. 

  451. 						$info['min_value'] = $max_min_values[$data_type]['min'];
    452. 

  452. 						$info['max_value'] = $max_min_values[$data_type]['max'];
    453. 

  453. 					}
    454. 

  454. 					$info['type'] = $mapped_data_type;
    455. 

  455. 					break;
    456. 

  456. 				}
    457. 

  457. 			}
    458. 

  458. 			
    459. 

  459. 			// Handle decimal places and min/max for numeric/decimals
    460. 

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

  461. 				$info['decimal_places'] = $row['scale'];
    462. 

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

  463. 				$after_digits  = str_pad('', $row['scale'], '9');
    464. 

  464. 				$max_min       = $before_digits . ($after_digits ? '.' : '') . $after_digits;
    465. 

  465. 				$info['min_value'] = new fNumber('-' . $max_min);
    466. 

  466. 				$info['max_value'] = new fNumber($max_min);
    467. 

  467. 			}
    468. 

  468. 			
    469. 

  469. 			if (!isset($info['type'])) {
    470. 

  470. 				$info['type'] = $row['type'];
    471. 

  471. 			}
    472. 

  472. 			
    473. 

  473. 			// Handle the special data for varchar columns
    474. 

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

  475. 				$info['max_length'] = $row['max_length'];
    476. 

  476. 			}
    477. 

  477. 			
    478. 

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

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

  480. 				if (is_resource($row['constraint'])) {
    481. 

  481. 					$row['constraint'] = stream_get_contents($row['constraint']);
    482. 

  482. 				}
    483. 

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

  484. 					$info['type'] = 'boolean';
    485. 

  485. 					$info['max_length'] = NULL;
    486. 

  486. 				}
    487. 

  487. 			}
    488. 

  488. 			
    489. 

  489. 			// If the column has a constraint, look for valid values
    490. 

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

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

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

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

  494. 					}			
    495. 

  495. 				}
    496. 

  496. 			}
    497. 

  497. 			
    498. 

  498. 			// Handle auto increment
    499. 

  499. 			if ($row['auto_increment']) {
    500. 

  500. 				$info['auto_increment'] = TRUE;
    501. 

  501. 			}
    502. 

  502. 			
    503. 

  503. 			// Handle default values
    504. 

  504. 			if ($row['default'] !== NULL) {
    505. 

  505. 				if ($row['default'] == 'NULL') {
    506. 

  506. 					$info['default'] = NULL;
    507. 

  507. 				} elseif (in_array($info['type'], array('timestamp', 'date', 'time')) && $row['default'][0] != "'") {
    508. 

  508. 					$info['default'] = str_replace(' ', '_', $row['default']);
    509. 

  509. 				} elseif (in_array($info['type'], array('char', 'varchar', 'text', 'timestamp', 'date', 'time')) ) {
    510. 

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

  511. 				} elseif ($info['type'] == 'boolean') {
    512. 

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

  513. 				} else {
    514. 

  514. 					$info['default'] = $row['default'];
    515. 

  515. 				}
    516. 

  516. 			}
    517. 

  517. 			
    518. 

  518. 			// Handle not null
    519. 

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

  520. 			
    521. 

  521. 			$info['comment'] = $row['comment'];
    522. 

  522. 			
    523. 

  523. 			$column_info[$row['column']] = $info;
    524. 

  524. 		}
    525. 

  525. 		
    526. 

  526. 		return $column_info;
    527. 

  527. 	}
    528. 

  528. 	
    529. 

  529. 	
    530. 

  530. 	/**
    531. 

  531. 	 * Fetches the key info for a DB2 database
    532. 

  532. 	 * 
    533. 

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

  534. 	 */
    535. 

  535. 	private function fetchDB2Keys()
    536. 

  536. 	{
    537. 

  537. 		$keys = array();
    538. 

  538. 		
    539. 

  539. 		$default_schema = strtolower($this->database->getUsername());
    540. 

  540. 		
    541. 

  541. 		$tables = $this->getTables();
    542. 

  542. 		foreach ($tables as $table) {
    543. 

  543. 			$keys[$table] = array();
    544. 

  544. 			$keys[$table]['primary'] = array();
    545. 

  545. 			$keys[$table]['unique']  = array();
    546. 

  546. 			$keys[$table]['foreign'] = array();
    547. 

  547. 		}
    548. 

  548. 		
    549. 

  549. 		$params  = array();
    550. 

  550. 		
    551. 

  551. 		$sql  = "(SELECT
    552. 

  552. 					LOWER(RTRIM(R.TABSCHEMA)) AS \"SCHEMA\",
    553. 

  553. 					LOWER(R.TABNAME) AS \"TABLE\",
    554. 

  554. 					R.CONSTNAME AS CONSTRAINT_NAME,
    555. 

  555. 					'foreign' AS \"TYPE\",
    556. 

  556. 					LOWER(K.COLNAME) AS \"COLUMN\",
    557. 

  557. 					LOWER(RTRIM(R.REFTABSCHEMA)) AS FOREIGN_SCHEMA,
    558. 

  558. 					LOWER(R.REFTABNAME) AS FOREIGN_TABLE,
    559. 

  559. 					LOWER(FK.COLNAME) AS FOREIGN_COLUMN,
    560. 

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

  561. 					CASE R.UPDATERULE WHEN 'A' THEN 'no_action' WHEN 'R' THEN 'restrict' END AS ON_UPDATE,
    562. 

  562. 					K.COLSEQ
    563. 

  563. 				FROM
    564. 

  564. 					SYSCAT.REFERENCES AS R INNER JOIN 
    565. 

  565. 					SYSCAT.KEYCOLUSE AS K ON
    566. 

  566. 						R.CONSTNAME = K.CONSTNAME AND
    567. 

  567. 						R.TABSCHEMA = K.TABSCHEMA AND
    568. 

  568. 						R.TABNAME = K.TABNAME INNER JOIN
    569. 

  569. 					SYSCAT.KEYCOLUSE AS FK ON
    570. 

  570. 						R.REFKEYNAME = FK.CONSTNAME AND
    571. 

  571. 						R.REFTABSCHEMA = FK.TABSCHEMA AND
    572. 

  572. 						R.REFTABNAME = FK.TABNAME
    573. 

  573. 				WHERE ";
    574. 

  574. 		
    575. 

  575. 		$conditions = array();
    576. 

  576. 		foreach ($tables as $table) {
    577. 

  577. 			if (strpos($table, '.') === FALSE) {
    578. 

  578. 				$table = $default_schema . '.' . $table;
    579. 

  579. 			}	
    580. 

  580. 			list ($schema, $table) = explode('.', strtolower($table));
    581. 

  581. 			$conditions[] = "LOWER(R.TABSCHEMA) = %s AND LOWER(R.TABNAME) = %s";
    582. 

  582. 			$params[] = $schema;
    583. 

  583. 			$params[] = $table;
    584. 

  584. 		}
    585. 

  585. 		$sql .= '((' . join(') OR( ', $conditions) . '))';
    586. 

  586. 		 
    587. 

  587. 		$sql .= "
    588. 

  588. 				) UNION (
    589. 

  589. 				SELECT
    590. 

  590. 					LOWER(RTRIM(I.TABSCHEMA)) AS \"SCHEMA\",
    591. 

  591. 					LOWER(I.TABNAME) AS \"TABLE\",
    592. 

  592. 					LOWER(I.INDNAME) AS CONSTRAINT_NAME,
    593. 

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

  594. 					LOWER(C.COLNAME) AS \"COLUMN\",
    595. 

  595. 					NULL AS FOREIGN_SCHEMA,
    596. 

  596. 					NULL AS FOREIGN_TABLE,
    597. 

  597. 					NULL AS FOREIGN_COLUMN,
    598. 

  598. 					NULL AS ON_DELETE,
    599. 

  599. 					NULL AS ON_UPDATE,
    600. 

  600. 					C.COLSEQ
    601. 

  601. 				FROM
    602. 

  602. 					SYSCAT.INDEXES AS I INNER JOIN
    603. 

  603. 					SYSCAT.INDEXCOLUSE AS C ON I.INDSCHEMA = C.INDSCHEMA AND I.INDNAME = C.INDNAME
    604. 

  604. 				WHERE
    605. 

  605. 					I.UNIQUERULE IN ('U', 'P') AND
    606. 

  606. 					";
    607. 

  607. 		
    608. 

  608. 		$conditions = array();
    609. 

  609. 		foreach ($tables as $table) {
    610. 

  610. 			if (strpos($table, '.') === FALSE) {
    611. 

  611. 				$table = $default_schema . '.' . $table;
    612. 

  612. 			}	
    613. 

  613. 			list ($schema, $table) = explode('.', strtolower($table));
    614. 

  614. 			$conditions[] = "LOWER(I.TABSCHEMA) = %s AND LOWER(I.TABNAME) = %s";
    615. 

  615. 			$params[] = $schema;
    616. 

  616. 			$params[] = $table;
    617. 

  617. 		}
    618. 

  618. 		$sql .= '((' . join(') OR( ', $conditions) . '))';
    619. 

  619. 		
    620. 

  620. 		$sql .= "
    621. 

  621. 				 )
    622. 

  622. 				 ORDER BY 4, 1, 2, 3, 11";
    623. 

  623. 		
    624. 

  624. 		$result = $this->database->query($sql, $params);
    625. 

  625. 		
    626. 

  626. 		$last_name  = '';
    627. 

  627. 		$last_table = '';
    628. 

  628. 		$last_type  = '';
    629. 

  629. 		foreach ($result as $row) {
    630. 

  630. 			
    631. 

  631. 			if ($row['constraint_name'] != $last_name) {
    632. 

  632. 				
    633. 

  633. 				if ($last_name) {
    634. 

  634. 					if ($last_type == 'foreign' || $last_type == 'unique') {
    635. 

  635. 						$keys[$last_table][$last_type][] = $temp;
    636. 

  636. 					} else {
    637. 

  637. 						$keys[$last_table][$last_type] = $temp;
    638. 

  638. 					}
    639. 

  639. 				}
    640. 

  640. 				
    641. 

  641. 				$temp = array();
    642. 

  642. 				if ($row['type'] == 'foreign') {
    643. 

  643. 					
    644. 

  644. 					$temp['column']         = $row['column'];
    645. 

  645. 					$temp['foreign_table']  = $row['foreign_table'];
    646. 

  646. 					if ($row['foreign_schema'] != $default_schema) {
    647. 

  647. 						$temp['foreign_table'] = $row['foreign_schema'] . '.' . $temp['foreign_table'];
    648. 

  648. 					}
    649. 

  649. 					$temp['foreign_column'] = $row['foreign_column'];
    650. 

  650. 					$temp['on_delete']      = 'no_action';
    651. 

  651. 					$temp['on_update']      = 'no_action';
    652. 

  652. 					
    653. 

  653. 					if (!empty($row['on_delete'])) {
    654. 

  654. 						$temp['on_delete'] = $row['on_delete'];
    655. 

  655. 					}
    656. 

  656. 					if (!empty($row['on_update'])) {
    657. 

  657. 						$temp['on_update'] = $row['on_update'];
    658. 

  658. 					}
    659. 

  659. 					
    660. 

  660. 				} else {
    661. 

  661. 					$temp[] = $row['column'];
    662. 

  662. 				}
    663. 

  663. 				
    664. 

  664. 				$last_table = $row['table'];
    665. 

  665. 				if ($row['schema'] != $default_schema) {
    666. 

  666. 					$last_table = $row['schema'] . '.' . $last_table;
    667. 

  667. 				}
    668. 

  668. 				$last_name  = $row['constraint_name'];
    669. 

  669. 				$last_type  = $row['type'];
    670. 

  670. 				
    671. 

  671. 			} else {
    672. 

  672. 				$temp[] = $row['column'];
    673. 

  673. 			}
    674. 

  674. 		}
    675. 

  675. 		
    676. 

  676. 		if (isset($temp)) {
    677. 

  677. 			if ($last_type == 'foreign' || $last_type == 'unique') {
    678. 

  678. 				$keys[$last_table][$last_type][] = $temp;
    679. 

  679. 			} else {
    680. 

  680. 				$keys[$last_table][$last_type] = $temp;
    681. 

  681. 			}
    682. 

  682. 		}
    683. 

  683. 		
    684. 

  684. 		return $keys;
    685. 

  685. 	}
    686. 

  686. 	
    687. 

  687. 	
    688. 

  688. 	/**
    689. 

  689. 	 * Gets the `PRIMARY KEY`, `FOREIGN KEY` and `UNIQUE` key constraints from the database
    690. 

  690. 	 * 
    691. 

  691. 	 * @return void
    692. 

  692. 	 */
    693. 

  693. 	private function fetchKeys()
    694. 

  694. 	{
    695. 

  695. 		if ($this->keys) {
    696. 

  696. 			return;	
    697. 

  697. 		}
    698. 

  698. 		
    699. 

  699. 		switch ($this->database->getType()) {
    700. 

  700. 			case 'db2':
    701. 

  701. 				$keys = $this->fetchDB2Keys();
    702. 

  702. 				break;
    703. 

  703. 			
    704. 

  704. 			case 'mssql':
    705. 

  705. 				$keys = $this->fetchMSSQLKeys();
    706. 

  706. 				break;
    707. 

  707. 				
    708. 

  708. 			case 'mysql':
    709. 

  709. 				$keys = $this->fetchMySQLKeys();
    710. 

  710. 				break;
    711. 

  711. 				
    712. 

  712. 			case 'oracle':
    713. 

  713. 				$keys = $this->fetchOracleKeys();
    714. 

  714. 				break;
    715. 

  715. 			
    716. 

  716. 			case 'postgresql':
    717. 

  717. 				$keys = $this->fetchPostgreSQLKeys();
    718. 

  718. 				break;
    719. 

  719. 			
    720. 

  720. 			case 'sqlite':
    721. 

  721. 				$keys = $this->fetchSQLiteKeys();
    722. 

  722. 				break;
    723. 

  723. 		}
    724. 

  724. 		
    725. 

  725. 		$this->keys = $keys;
    726. 

  726. 		if ($this->cache) {
    727. 

  727. 			$this->cache->set($this->makeCachePrefix() . 'keys', $this->keys);	
    728. 

  728. 		}
    729. 

  729. 	}
    730. 

  730. 	
    731. 

  731. 	
    732. 

  732. 	/**
    733. 

  733. 	 * Gets the column info from a MSSQL database
    734. 

  734. 	 * 
    735. 

  735. 	 * @param  string $table  The table to fetch the column info for
    736. 

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

  737. 	 */
    738. 

  738. 	private function fetchMSSQLColumnInfo($table)
    739. 

  739. 	{
    740. 

  740. 		$column_info = array();
    741. 

  741. 		
    742. 

  742. 		$schema = 'dbo';
    743. 

  743. 		if (strpos($table, '.') !== FALSE) {
    744. 

  744. 			list ($schema, $table) = explode('.', $table);
    745. 

  745. 		}
    746. 

  746. 		
    747. 

  747. 		$data_type_mapping = array(
    748. 

  748. 			'bit'               => 'boolean',
    749. 

  749. 			'tinyint'           => 'integer',
    750. 

  750. 			'smallint'          => 'integer',
    751. 

  751. 			'int'               => 'integer',
    752. 

  752. 			'bigint'            => 'integer',
    753. 

  753. 			'timestamp'         => 'integer',
    754. 

  754. 			'datetime'          => 'timestamp',
    755. 

  755. 			'smalldatetime'     => 'timestamp',
    756. 

  756. 			'datetime2'         => 'timestamp',
    757. 

  757. 			'date'              => 'date',
    758. 

  758. 			'time'              => 'time',
    759. 

  759. 			'varchar'           => 'varchar',
    760. 

  760. 			'nvarchar'          => 'varchar',
    761. 

  761. 			'uniqueidentifier'  => 'varchar',
    762. 

  762. 			'char'              => 'char',
    763. 

  763. 			'nchar'             => 'char',
    764. 

  764. 			'real'              => 'float',
    765. 

  765. 			'float'             => 'float',
    766. 

  766. 			'money'             => 'float',
    767. 

  767. 			'smallmoney'        => 'float',
    768. 

  768. 			'decimal'           => 'float',
    769. 

  769. 			'numeric'           => 'float',
    770. 

  770. 			'binary'            => 'blob',
    771. 

  771. 			'varbinary'         => 'blob',
    772. 

  772. 			'image'             => 'blob',
    773. 

  773. 			'text'              => 'text',
    774. 

  774. 			'ntext'             => 'text',
    775. 

  775. 			'xml'               => 'text'
    776. 

  776. 		);
    777. 

  777. 		
    778. 

  778. 		$max_min_values = array(
    779. 

  779. 			'tinyint'    => array('min' => new fNumber(0),                       'max' => new fNumber(255)),
    780. 

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

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

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

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

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

  785. 		);
    786. 

  786. 		
    787. 

  787. 		// Get the column info
    788. 

  788. 		$sql = "SELECT
    789. 

  789. 					LOWER(c.column_name)       AS 'column',
    790. 

  790. 					c.data_type                AS 'type',
    791. 

  791. 					c.is_nullable              AS nullable,
    792. 

  792. 					c.column_default           AS 'default',
    793. 

  793. 					c.character_maximum_length AS max_length,
    794. 

  794. 					c.numeric_precision        AS precision,
    795. 

  795. 					c.numeric_scale            AS decimal_places,
    796. 

  796. 					CASE
    797. 

  797. 						WHEN
    798. 

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

  799. 							OBJECTPROPERTY(OBJECT_ID(QUOTENAME(c.table_schema) + '.' + QUOTENAME(c.table_name)), 'IsMSShipped') = 0
    800. 

  800. 						THEN '1'
    801. 

  801. 						ELSE '0'
    802. 

  802. 					END AS auto_increment,
    803. 

  803. 					cc.check_clause AS 'constraint',
    804. 

  804. 					CAST(ex.value AS VARCHAR(7500)) AS 'comment'
    805. 

  805. 				FROM
    806. 

  806. 					INFORMATION_SCHEMA.COLUMNS AS c LEFT JOIN
    807. 

  807. 					INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE AS ccu ON
    808. 

  808. 						c.column_name = ccu.column_name AND
    809. 

  809. 						c.table_name = ccu.table_name AND
    810. 

  810. 						c.table_catalog = ccu.table_catalog LEFT JOIN
    811. 

  811. 					INFORMATION_SCHEMA.CHECK_CONSTRAINTS AS cc ON
    812. 

  812. 						ccu.constraint_name = cc.constraint_name AND
    813. 

  813. 						ccu.constraint_catalog = cc.constraint_catalog";
    814. 

  814. 		
    815. 

  815. 		if (version_compare($this->database->getVersion(), 9, '<')) {
    816. 

  816. 			$sql .= " LEFT JOIN sysproperties AS ex ON ex.id = OBJECT_ID(QUOTENAME(c.table_schema) + '.' + QUOTENAME(c.table_name)) AND ex.smallid = COLUMNPROPERTY(OBJECT_ID(QUOTENAME(c.table_schema) + '.' + QUOTENAME(c.table_name)), c.column_name, 'ColumnId') AND ex.name = 'MS_Description' AND OBJECTPROPERTY(OBJECT_ID(QUOTENAME(c.table_schema) + '.' + QUOTENAME(c.table_name)), 'IsMsShipped') = 0 ";
    817. 

  817. 		} else {
    818. 

  818. 			$sql .= " LEFT JOIN SYS.EXTENDED_PROPERTIES AS ex ON ex.major_id = OBJECT_ID(QUOTENAME(c.table_schema) + '.' + QUOTENAME(c.table_name)) AND ex.minor_id = COLUMNPROPERTY(OBJECT_ID(QUOTENAME(c.table_schema) + '.' + QUOTENAME(c.table_name)), c.column_name, 'ColumnId') AND ex.name = 'MS_Description' AND OBJECTPROPERTY(OBJECT_ID(QUOTENAME(c.table_schema) + '.' + QUOTENAME(c.table_name)), 'IsMsShipped') = 0 ";
    819. 

  819. 		}
    820. 

  820. 		
    821. 

  821. 		$sql .= "
    822. 

  822. 					WHERE
    823. 

  823. 						LOWER(c.table_name) = %s AND
    824. 

  824. 						LOWER(c.table_schema) = %s AND
    825. 

  825. 						c.table_catalog = DB_NAME()";
    826. 

  826. 		
    827. 

  827. 		$result = $this->database->query($sql, strtolower($table), strtolower($schema));
    828. 

  828. 		
    829. 

  829. 		foreach ($result as $row) {
    830. 

  830. 			
    831. 

  831. 			$info = array();
    832. 

  832. 			
    833. 

  833. 			foreach ($data_type_mapping as $data_type => $mapped_data_type) {
    834. 

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

  835. 					if (isset($max_min_values[$data_type])) {
    836. 

  836. 						$info['min_value'] = $max_min_values[$data_type]['min'];
    837. 

  837. 						$info['max_value'] = $max_min_values[$data_type]['max'];
    838. 

  838. 					}
    839. 

  839. 					$info['type'] = $mapped_data_type;
    840. 

  840. 					break;
    841. 

  841. 				}
    842. 

  842. 			}
    843. 

  843. 			
    844. 

  844. 			// Handle decimal places and min/max for numeric/decimals
    845. 

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

  846. 				$info['decimal_places'] = $row['decimal_places'];
    847. 

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

  848. 				$after_digits  = str_pad('', $row['decimal_places'], '9');
    849. 

  849. 				$max_min       = $before_digits . ($after_digits ? '.' : '') . $after_digits;
    850. 

  850. 				$info['min_value'] = new fNumber('-' . $max_min);
    851. 

  851. 				$info['max_value'] = new fNumber($max_min);
    852. 

  852. 			}
    853. 

  853. 			
    854. 

  854. 			if (!isset($info['type'])) {
    855. 

  855. 				$info['type'] = $row['type'];
    856. 

  856. 			}
    857. 

  857. 			
    858. 

  858. 			// Handle decimal places for money/smallmoney
    859. 

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

  860. 				$info['decimal_places'] = 2;
    861. 

  861. 			}
    862. 

  862. 			
    863. 

  863. 			// Handle the special data for varchar columns
    864. 

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

  865. 				if ($row['type'] == 'uniqueidentifier') {
    866. 

  866. 					$row['max_length'] = 32;
    867. 

  867. 				} elseif ($row['max_length'] == -1) {
    868. 

  868. 					$row['max_length'] = $row['type'] == 'nvarchar' ? 1073741823 : 2147483647;
    869. 

  869. 				}
    870. 

  870. 				$info['max_length'] = $row['max_length'];
    871. 

  871. 			}
    872. 

  872. 			
    873. 

  873. 			// If the column has a constraint, look for valid values
    874. 

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

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

  876. 					$valid_values = explode(' OR ', $matches[1]);
    877. 

  877. 					foreach ($valid_values as $key => $value) {
    878. 

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

  879. 						$valid_values[$key] = str_replace("''", "'", $value);
    880. 

  880. 					}
    881. 

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

  882. 					$info['valid_values'] = array_reverse($valid_values);
    883. 

  883. 				}
    884. 

  884. 			}
    885. 

  885. 			
    886. 

  886. 			// Handle auto increment
    887. 

  887. 			if ($row['auto_increment']) {
    888. 

  888. 				$info['auto_increment'] = TRUE;
    889. 

  889. 			}
    890. 

  890. 			
    891. 

  891. 			// Handle default values
    892. 

  892. 			if ($row['default'] !== NULL) {
    893. 

  893. 				if ($row['default'] == '(getdate())') {
    894. 

  894. 					$info['default'] = 'CURRENT_TIMESTAMP';
    895. 

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

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

  897. 				} elseif ($info['type'] == 'boolean') {
    898. 

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

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

  900. 					$info['default'] = str_replace(array('(', ')'), '', $row['default']);
    901. 

  901. 				} else {
    902. 

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

  903. 				}
    904. 

  904. 			}
    905. 

  905. 			
    906. 

  906. 			// Handle not null
    907. 

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

  908. 			
    909. 

  909. 			$info['comment'] = $row['comment'];
    910. 

  910. 			
    911. 

  911. 			$column_info[$row['column']] = $info;
    912. 

  912. 		}
    913. 

  913. 		
    914. 

  914. 		return $column_info;
    915. 

  915. 	}
    916. 

  916. 	
    917. 

  917. 	
    918. 

  918. 	/**
    919. 

  919. 	 * Fetches the key info for an MSSQL database
    920. 

  920. 	 * 
    921. 

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

  922. 	 */
    923. 

  923. 	private function fetchMSSQLKeys()
    924. 

  924. 	{
    925. 

  925. 		$keys = array();
    926. 

  926. 		
    927. 

  927. 		$tables   = $this->getTables();
    928. 

  928. 		foreach ($tables as $table) {
    929. 

  929. 			$keys[$table] = array();
    930. 

  930. 			$keys[$table]['primary'] = array();
    931. 

  931. 			$keys[$table]['unique']  = array();
    932. 

  932. 			$keys[$table]['foreign'] = array();
    933. 

  933. 		}
    934. 

  934. 		
    935. 

  935. 		$sql  = "SELECT
    936. 

  936. 					LOWER(c.table_schema) AS \"schema\",
    937. 

  937. 					LOWER(c.table_name) AS \"table\",
    938. 

  938. 					kcu.constraint_name AS constraint_name,
    939. 

  939. 					CASE c.constraint_type
    940. 

  940. 						WHEN 'PRIMARY KEY' THEN 'primary'
    941. 

  941. 						WHEN 'FOREIGN KEY' THEN 'foreign'
    942. 

  942. 						WHEN 'UNIQUE' THEN 'unique'
    943. 

  943. 					END AS 'type',
    944. 

  944. 					LOWER(kcu.column_name) AS 'column',
    945. 

  945. 					LOWER(ccu.table_schema) AS foreign_schema,
    946. 

  946. 					LOWER(ccu.table_name) AS foreign_table,
    947. 

  947. 					LOWER(ccu.column_name) AS foreign_column,
    948. 

  948. 					REPLACE(LOWER(rc.delete_rule), ' ', '_') AS on_delete,
    949. 

  949. 					REPLACE(LOWER(rc.update_rule), ' ', '_') AS on_update
    950. 

  950. 				FROM
    951. 

  951. 					INFORMATION_SCHEMA.TABLE_CONSTRAINTS AS c INNER JOIN
    952. 

  952. 					INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS kcu ON
    953. 

  953. 						c.table_name = kcu.table_name AND
    954. 

  954. 						c.constraint_name = kcu.constraint_name LEFT JOIN
    955. 

  955. 					INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS AS rc ON
    956. 

  956. 						c.constraint_name = rc.constraint_name LEFT JOIN
    957. 

  957. 					INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE AS ccu ON
    958. 

  958. 						ccu.constraint_name = rc.unique_constraint_name
    959. 

  959. 				WHERE
    960. 

  960. 					c.constraint_catalog = DB_NAME() AND
    961. 

  961. 					c.table_name != 'sysdiagrams'
    962. 

  962. 				ORDER BY
    963. 

  963. 					LOWER(c.table_schema),
    964. 

  964. 					LOWER(c.table_name),
    965. 

  965. 					c.constraint_type,
    966. 

  966. 					LOWER(kcu.constraint_name),
    967. 

  967. 					kcu.ordinal_position,
    968. 

  968. 					LOWER(kcu.column_name)";
    969. 

  969. 		
    970. 

  970. 		$result = $this->database->query($sql);
    971. 

  971. 		
    972. 

  972. 		$last_name  = '';
    973. 

  973. 		$last_table = '';
    974. 

  974. 		$last_type  = '';
    975. 

  975. 		foreach ($result as $row) {
    976. 

  976. 			
    977. 

  977. 			if ($row['constraint_name'] != $last_name) {
    978. 

  978. 				
    979. 

  979. 				if ($last_name) {
    980. 

  980. 					if ($last_type == 'foreign' || $last_type == 'unique') {
    981. 

  981. 						if (!isset($keys[$last_table][$last_type])) {
    982. 

  982. 							$keys[$last_table][$last_type] = array();		
    983. 

  983. 						}
    984. 

  984. 						$keys[$last_table][$last_type][] = $temp;
    985. 

  985. 					} else {
    986. 

  986. 						$keys[$last_table][$last_type] = $temp;
    987. 

  987. 					}
    988. 

  988. 				}
    989. 

  989. 				
    990. 

  990. 				$temp = array();
    991. 

  991. 				if ($row['type'] == 'foreign') {
    992. 

  992. 					
    993. 

  993. 					$temp['column']         = $row['column'];
    994. 

  994. 					$temp['foreign_table']  = $row['foreign_table'];
    995. 

  995. 					if ($row['foreign_schema'] != 'dbo') {
    996. 

  996. 						 $temp['foreign_table'] = $row['foreign_schema'] . '.' . $temp['foreign_table'];	
    997. 

  997. 					}
    998. 

  998. 					$temp['foreign_column'] = $row['foreign_column'];
    999. 

  999. 					$temp['on_delete']      = 'no_action';
    1000. 

  1000. 					$temp['on_update']      = 'no_action';
    1001. 

  1001. 					if (!empty($row['on_delete'])) {
    1002. 

  1002. 						$temp['on_delete'] = $row['on_delete'];
    1003. 

  1003. 					}
    1004. 

  1004. 					if (!empty($row['on_update'])) {
    1005. 

  1005. 						$temp['on_update'] = $row['on_update'];
    1006. 

  1006. 					}
    1007. 

  1007. 					
    1008. 

  1008. 				} else {
    1009. 

  1009. 					$temp[] = $row['column'];
    1010. 

  1010. 				}
    1011. 

  1011. 				
    1012. 

  1012. 				$last_table = $row['table'];
    1013. 

  1013. 				if ($row['schema'] != 'dbo') {
    1014. 

  1014. 					$last_table = $row['schema'] . '.' . $last_table;	
    1015. 

  1015. 				}
    1016. 

  1016. 				$last_name  = $row['constraint_name'];
    1017. 

  1017. 				$last_type  = $row['type'];
    1018. 

  1018. 				
    1019. 

  1019. 			} else {
    1020. 

  1020. 				$temp[] = $row['column'];
    1021. 

  1021. 			}
    1022. 

  1022. 		}
    1023. 

  1023. 		
    1024. 

  1024. 		if (isset($temp)) {
    1025. 

  1025. 			if ($last_type == 'foreign' || $last_type == 'unique') {
    1026. 

  1026. 				if (!isset($keys[$last_table][$last_type])) {
    1027. 

  1027. 					$keys[$last_table][$last_type] = array();		
    1028. 

  1028. 				}
    1029. 

  1029. 				$keys[$last_table][$last_type][] = $temp;
    1030. 

  1030. 			} else {
    1031. 

  1031. 				$keys[$last_table][$last_type] = $temp;
    1032. 

  1032. 			}
    1033. 

  1033. 		}
    1034. 

  1034. 		
    1035. 

  1035. 		return $keys;
    1036. 

  1036. 	}
    1037. 

  1037. 	
    1038. 

  1038. 	
    1039. 

  1039. 	/**
    1040. 

  1040. 	 * Gets the column info from a MySQL database
    1041. 

  1041. 	 * 
    1042. 

  1042. 	 * @param  string $table  The table to fetch the column info for
    1043. 

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

  1044. 	 */
    1045. 

  1045. 	private function fetchMySQLColumnInfo($table)
    1046. 

  1046. 	{
    1047. 

  1047. 		$data_type_mapping = array(
    1048. 

  1048. 			'tinyint'			=> 'integer',
    1049. 

  1049. 			'smallint'			=> 'integer',
    1050. 

  1050. 			'mediumint'         => 'integer',
    1051. 

  1051. 			'int'				=> 'integer',
    1052. 

  1052. 			'bigint'			=> 'integer',
    1053. 

  1053. 			'datetime'			=> 'timestamp',
    1054. 

  1054. 			'timestamp'			=> 'timestamp',
    1055. 

  1055. 			'date'				=> 'date',
    1056. 

  1056. 			'time'				=> 'time',
    1057. 

  1057. 			'enum'				=> 'varchar',
    1058. 

  1058. 			'set'               => 'varchar',
    1059. 

  1059. 			'varchar'			=> 'varchar',
    1060. 

  1060. 			'char'				=> 'char',
    1061. 

  1061. 			'float'				=> 'float',
    1062. 

  1062. 			'double'			=> 'float',
    1063. 

  1063. 			'decimal'			=> 'float',
    1064. 

  1064. 			'binary'            => 'blob',
    1065. 

  1065. 			'varbinary'         => 'blob',
    1066. 

  1066. 			'tinyblob'			=> 'blob',
    1067. 

  1067. 			'blob'				=> 'blob',
    1068. 

  1068. 			'mediumblob'		=> 'blob',
    1069. 

  1069. 			'longblob'			=> 'blob',
    1070. 

  1070. 			'tinytext'			=> 'text',
    1071. 

  1071. 			'text'				=> 'text',
    1072. 

  1072. 			'mediumtext'		=> 'text',
    1073. 

  1073. 			'longtext'			=> 'text',
    1074. 

  1074. 			'geometry'          => 'blob',
    1075. 

  1075. 			'point'             => 'blob',
    1076. 

  1076. 			'linestring'        => 'blob',
    1077. 

  1077. 			'polygon'           => 'blob'
    1078. 

  1078. 		);
    1079. 

  1079. 		
    1080. 

  1080. 		$max_min_values = array(
    1081. 

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

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

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

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

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

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

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

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

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

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

  1091. 		);
    1092. 

  1092. 		
    1093. 

  1093. 		$column_info = array();
    1094. 

  1094. 		
    1095. 

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

  1096. 		
    1097. 

  1097. 		try {
    1098. 

  1098. 			$row        = $result->fetchRow();
    1099. 

  1099. 			$create_sql = $row['Create Table'];
    1100. 

  1100. 		} catch (fNoRowsException $e) {
    1101. 

  1101. 			return array();
    1102. 

  1102. 		}
    1103. 

  1103. 		
    1104. 

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

  1105. 		
    1106. 

  1106. 		foreach ($matches as $match) {
    1107. 

  1107. 			
    1108. 

  1108. 			$info = array();
    1109. 

  1109. 			
    1110. 

  1110. 			foreach ($data_type_mapping as $data_type => $mapped_data_type) {
    1111. 

  1111. 				if (stripos($match[2], $data_type) === 0) {
    1112. 

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

  1113. 						$mapped_data_type = 'boolean';
    1114. 

  1114. 					
    1115. 

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

  1116. 						if (isset($max_min_values[$int_match[1]])) {
    1117. 

  1117. 							$info['min_value'] = $max_min_values[$int_match[1]]['min'];
    1118. 

  1118. 							$info['max_value'] = $max_min_values[$int_match[1]]['max'];	
    1119. 

  1119. 						}
    1120. 

  1120. 					}
    1121. 

  1121. 					
    1122. 

  1122. 					$info['type'] = $mapped_data_type;
    1123. 

  1123. 					break;
    1124. 

  1124. 				}
    1125. 

  1125. 			}
    1126. 

  1126. 			if (!isset($info['type'])) {
    1127. 

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

  1128. 			}
    1129. 

  1129. 			
    1130. 

  1130. 			switch ($match[2]) {
    1131. 

  1131. 				case 'tinyblob':
    1132. 

  1132. 				case 'tinytext':
    1133. 

  1133. 					$info['max_length'] = 255;
    1134. 

  1134. 					break;
    1135. 

  1135. 				
    1136. 

  1136. 				case 'blob':
    1137. 

  1137. 				case 'text':
    1138. 

  1138. 					$info['max_length'] = 65535;
    1139. 

  1139. 					break;
    1140. 

  1140. 				
    1141. 

  1141. 				case 'mediumblob':
    1142. 

  1142. 				case 'mediumtext':
    1143. 

  1143. 					$info['max_length'] = 16777215;
    1144. 

  1144. 					break;
    1145. 

  1145. 				
    1146. 

  1146. 				case 'longblob':
    1147. 

  1147. 				case 'longtext':
    1148. 

  1148. 					$info['max_length'] = 4294967295;
    1149. 

  1149. 					break;
    1150. 

  1150. 			}
    1151. 

  1151. 		
    1152. 

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

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

  1154. 				$match[3] = 0;
    1155. 

  1155. 				foreach ($info['valid_values'] as $valid_value) {
    1156. 

  1156. 					if (strlen(utf8_decode($valid_value)) > $match[3]) {
    1157. 

  1157. 						$match[3] = strlen(utf8_decode($valid_value));
    1158. 

  1158. 					}
    1159. 

  1159. 				}
    1160. 

  1160. 			}
    1161. 

  1161. 			
    1162. 

  1162. 			// The set data type is currently only supported as a varchar
    1163. 

  1163. 			// with a max length of all valid values concatenated by ,s
    1164. 

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

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

  1166. 				$match[3] = strlen(join(',', $values));
    1167. 

  1167. 			}
    1168. 

  1168. 			
    1169. 

  1169. 			// Type specific information
    1170. 

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

  1171. 				$info['max_length'] = $match[3];
    1172. 

  1172. 			}
    1173. 

  1173. 			
    1174. 

  1174. 			// Grab the number of decimal places
    1175. 

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

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

  1177. 					$info['decimal_places'] = $data_type_info[2];
    1178. 

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

  1179. 					$after_digits  = str_pad('', $info['decimal_places'], '9');
    1180. 

  1180. 					$max_min       = $before_digits . ($after_digits ? '.' : '') . $after_digits;
    1181. 

  1181. 					$info['min_value'] = new fNumber('-' . $max_min);
    1182. 

  1182. 					$info['max_value'] = new fNumber($max_min);
    1183. 

  1183. 				}
    1184. 

  1184. 			}
    1185. 

  1185. 			
    1186. 

  1186. 			// Not null
    1187. 

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

  1188. 		
    1189. 

  1189. 			// Default values
    1190. 

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

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

  1192. 			}
    1193. 

  1193. 			
    1194. 

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

  1195. 				$info['default'] = (boolean) $info['default'];
    1196. 

  1196. 			}
    1197. 

  1197. 		
    1198. 

  1198. 			// Auto increment fields
    1199. 

  1199. 			if (!empty($match[7])) {
    1200. 

  1200. 				$info['auto_increment'] = TRUE;
    1201. 

  1201. 			}
    1202. 

  1202. 			
    1203. 

  1203. 			// Column comments
    1204. 

  1204. 			if (!empty($match[8])) {
    1205. 

  1205. 				$info['comment'] = str_replace("''", "'", substr($match[8], 10, -1));
    1206. 

  1206. 			}
    1207. 

  1207. 		
    1208. 

  1208. 			$column_info[strtolower($match[1])] = $info;
    1209. 

  1209. 		}
    1210. 

  1210. 		
    1211. 

  1211. 		return $column_info;
    1212. 

  1212. 	}
    1213. 

  1213. 	
    1214. 

  1214. 	
    1215. 

  1215. 	/**
    1216. 

  1216. 	 * Fetches the keys for a MySQL database
    1217. 

  1217. 	 * 
    1218. 

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

  1219. 	 */
    1220. 

  1220. 	private function fetchMySQLKeys()
    1221. 

  1221. 	{
    1222. 

  1222. 		$tables   = $this->getTables();
    1223. 

  1223. 		$keys = array();
    1224. 

  1224. 		
    1225. 

  1225. 		foreach ($tables as $table) {
    1226. 

  1226. 			
    1227. 

  1227. 			$keys[$table] = array();
    1228. 

  1228. 			$keys[$table]['primary'] = array();
    1229. 

  1229. 			$keys[$table]['foreign'] = array();
    1230. 

  1230. 			$keys[$table]['unique']  = array();
    1231. 

  1231. 			
    1232. 

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

  1233. 			$row    = $result->fetchRow();
    1234. 

  1234. 			
    1235. 

  1235. 			// Primary keys
    1236. 

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

  1237. 			if (!empty($matches)) {
    1238. 

  1238. 				$keys[$table]['primary'] = explode('","', strtolower($matches[0][1]));
    1239. 

  1239. 			}
    1240. 

  1240. 			
    1241. 

  1241. 			// Unique keys
    1242. 

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

  1243. 			foreach ($matches as $match) {
    1244. 

  1244. 				$keys[$table]['unique'][] = explode('","', strtolower($match[2]));
    1245. 

  1245. 			}
    1246. 

  1246. 			
    1247. 

  1247. 			// Foreign keys
    1248. 

  1248. 			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);
    1249. 

  1249. 			foreach ($matches as $match) {
    1250. 

  1250. 				$temp = array(
    1251. 

  1251. 					'column'         => strtolower($match[1]),
    1252. 

  1252. 					'foreign_table'  => strtolower($match[2]),
    1253. 

  1253. 					'foreign_column' => strtolower($match[3]),
    1254. 

  1254. 					'on_delete'      => 'no_action',
    1255. 

  1255. 					'on_update'      => 'no_action'
    1256. 

  1256. 				);
    1257. 

  1257. 				if (!empty($match[4])) {
    1258. 

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

  1259. 				}
    1260. 

  1260. 				if (!empty($match[5])) {
    1261. 

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

  1262. 				}
    1263. 

  1263. 				$keys[$table]['foreign'][] = $temp;
    1264. 

  1264. 			}
    1265. 

  1265. 		}
    1266. 

  1266. 		
    1267. 

  1267. 		return $keys;
    1268. 

  1268. 	}
    1269. 

  1269. 	
    1270. 

  1270. 	
    1271. 

  1271. 	/**
    1272. 

  1272. 	 * Gets the column info from an Oracle database
    1273. 

  1273. 	 * 
    1274. 

  1274. 	 * @param  string $table  The table to fetch the column info for
    1275. 

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

  1276. 	 */
    1277. 

  1277. 	private function fetchOracleColumnInfo($table)
    1278. 

  1278. 	{
    1279. 

  1279. 		$table = strtolower($table);
    1280. 

  1280. 		
    1281. 

  1281. 		$schema = strtolower($this->database->getUsername());
    1282. 

  1282. 		if (strpos($table, '.') !== FALSE) {
    1283. 

  1283. 			list ($schema, $table) = explode('.', $table);
    1284. 

  1284. 		}
    1285. 

  1285. 		
    1286. 

  1286. 		$column_info = array();
    1287. 

  1287. 		
    1288. 

  1288. 		$data_type_mapping = array(
    1289. 

  1289. 			'boolean'			=> 'boolean',
    1290. 

  1290. 			'number'            => 'integer',
    1291. 

  1291. 			'integer'			=> 'integer',
    1292. 

  1292. 			'timestamp'			=> 'timestamp',
    1293. 

  1293. 			'date'				=> 'date',
    1294. 

  1294. 			'varchar2'          => 'varchar',
    1295. 

  1295. 			'nvarchar2'			=> 'varchar',
    1296. 

  1296. 			'char'              => 'char',
    1297. 

  1297. 			'nchar'             => 'char',
    1298. 

  1298. 			'float'				=> 'float',
    1299. 

  1299. 			'binary_float'      => 'float',
    1300. 

  1300. 			'binary_double'     => 'float',
    1301. 

  1301. 			'blob'				=> 'blob',
    1302. 

  1302. 			'bfile'             => 'varchar',
    1303. 

  1303. 			'clob'				=> 'text',
    1304. 

  1304. 			'nclob'             => 'text'
    1305. 

  1305. 		);
    1306. 

  1306. 		
    1307. 

  1307. 		$sql = "SELECT
    1308. 

  1308. 					LOWER(ATC.COLUMN_NAME) COLUMN_NAME,
    1309. 

  1309. 					CASE
    1310. 

  1310. 						WHEN
    1311. 

  1311. 							ATC.DATA_TYPE = 'NUMBER' AND
    1312. 

  1312. 							ATC.DATA_PRECISION IS NULL AND
    1313. 

  1313. 							ATC.DATA_SCALE = 0
    1314. 

  1314. 						THEN
    1315. 

  1315. 							'integer'
    1316. 

  1316. 						WHEN
    1317. 

  1317. 							ATC.DATA_TYPE = 'NUMBER' AND
    1318. 

  1318. 							ATC.DATA_PRECISION = 1 AND
    1319. 

  1319. 							ATC.DATA_SCALE = 0
    1320. 

  1320. 						THEN
    1321. 

  1321. 							'boolean'
    1322. 

  1322. 						WHEN
    1323. 

  1323. 							ATC.DATA_TYPE = 'NUMBER' AND
    1324. 

  1324. 							ATC.DATA_PRECISION IS NOT NULL AND
    1325. 

  1325. 							ATC.DATA_SCALE != 0 AND
    1326. 

  1326. 							ATC.DATA_SCALE IS NOT NULL
    1327. 

  1327. 						THEN
    1328. 

  1328. 							'float'
    1329. 

  1329. 						ELSE
    1330. 

  1330. 							LOWER(ATC.DATA_TYPE)
    1331. 

  1331. 						END DATA_TYPE,
    1332. 

  1332. 					CASE
    1333. 

  1333. 						WHEN
    1334. 

  1334. 							ATC.CHAR_LENGTH <> 0
    1335. 

  1335. 						THEN
    1336. 

  1336. 							ATC.CHAR_LENGTH
    1337. 

  1337. 						WHEN
    1338. 

  1338. 							ATC.DATA_TYPE = 'NUMBER' AND
    1339. 

  1339. 							ATC.DATA_PRECISION != 1 AND
    1340. 

  1340. 							ATC.DATA_SCALE != 0	AND
    1341. 

  1341. 							ATC.DATA_PRECISION IS NOT NULL
    1342. 

  1342. 						THEN
    1343. 

  1343. 							ATC.DATA_SCALE
    1344. 

  1344. 						ELSE
    1345. 

  1345. 							NULL
    1346. 

  1346. 						END LENGTH,
    1347. 

  1347. 					ATC.DATA_PRECISION PRECISION,
    1348. 

  1348. 					ATC.NULLABLE,
    1349. 

  1349. 					ATC.DATA_DEFAULT,
    1350. 

  1350. 					AC.SEARCH_CONDITION CHECK_CONSTRAINT,
    1351. 

  1351. 					ACCM.COMMENTS
    1352. 

  1352. 				FROM
    1353. 

  1353. 					ALL_TAB_COLUMNS ATC LEFT JOIN
    1354. 

  1354. 					ALL_CONS_COLUMNS ACC ON
    1355. 

  1355. 						ATC.OWNER = ACC.OWNER AND
    1356. 

  1356. 						ATC.COLUMN_NAME = ACC.COLUMN_NAME AND
    1357. 

  1357. 						ATC.TABLE_NAME = ACC.TABLE_NAME AND
    1358. 

  1358. 						ACC.POSITION IS NULL LEFT JOIN
    1359. 

  1359. 					ALL_CONSTRAINTS AC ON
    1360. 

  1360. 						AC.OWNER = ACC.OWNER AND
    1361. 

  1361. 						AC.CONSTRAINT_NAME = ACC.CONSTRAINT_NAME AND
    1362. 

  1362. 						AC.CONSTRAINT_TYPE = 'C' AND
    1363. 

  1363. 						AC.STATUS = 'ENABLED' LEFT JOIN
    1364. 

  1364. 					ALL_COL_COMMENTS ACCM ON
    1365. 

  1365. 						ATC.OWNER = ACCM.OWNER AND
    1366. 

  1366. 						ATC.COLUMN_NAME = ACCM.COLUMN_NAME AND
    1367. 

  1367. 						ATC.TABLE_NAME = ACCM.TABLE_NAME
    1368. 

  1368. 				WHERE
    1369. 

  1369. 					LOWER(ATC.TABLE_NAME) = %s AND
    1370. 

  1370. 					LOWER(ATC.OWNER) = %s
    1371. 

  1371. 				ORDER BY
    1372. 

  1372. 					ATC.TABLE_NAME ASC,
    1373. 

  1373. 					ATC.COLUMN_ID ASC";
    1374. 

  1374. 		
    1375. 

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

  1376. 		
    1377. 

  1377. 		foreach ($result as $row) {
    1378. 

  1378. 			
    1379. 

  1379. 			$column = $row['column_name'];
    1380. 

  1380. 			
    1381. 

  1381. 			// Since Oracle stores check constraints in LONG columns, it is
    1382. 

  1382. 			// not possible to check or modify the constraints in SQL which
    1383. 

  1383. 			// ends up causing multiple rows with duplicate data except for
    1384. 

  1384. 			// the check constraint
    1385. 

  1385. 			$duplicate = FALSE;
    1386. 

  1386. 			
    1387. 

  1387. 			if (isset($column_info[$column])) {
    1388. 

  1388. 				$info = $column_info[$column];
    1389. 

  1389. 				$duplicate = TRUE;
    1390. 

  1390. 			} else {
    1391. 

  1391. 				$info = array();
    1392. 

  1392. 			}
    1393. 

  1393. 			
    1394. 

  1394. 			if (!$duplicate) {
    1395. 

  1395. 				// Get the column type
    1396. 

  1396. 				foreach ($data_type_mapping as $data_type => $mapped_data_type) {
    1397. 

  1397. 					if (stripos($row['data_type'], $data_type) === 0) {
    1398. 

  1398. 						$info['type'] = $mapped_data_type;
    1399. 

  1399. 						break;
    1400. 

  1400. 					}
    1401. 

  1401. 				}
    1402. 

  1402. 				
    1403. 

  1403. 				if (!isset($info['type'])) {
    1404. 

  1404. 					$info['type'] = $row['data_type'];
    1405. 

  1405. 				}
    1406. 

  1406. 				
    1407. 

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

  1408. 					$info['max_length'] = 4294967295;
    1409. 

  1409. 				}
    1410. 

  1410. 				
    1411. 

  1411. 				if ($row['data_type'] == 'float' && $row['precision']) {
    1412. 

  1412. 					$row['length'] = (int) $row['length'];
    1413. 

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

  1414. 					$after_digits  = str_pad('', $row['length'], '9');
    1415. 

  1415. 					$max_min       = $before_digits . ($after_digits ? '.' : '') . $after_digits;
    1416. 

  1416. 					$info['min_value'] = new fNumber('-' . $max_min);
    1417. 

  1417. 					$info['max_value'] = new fNumber($max_min);	
    1418. 

  1418. 				}
    1419. 

  1419. 				
    1420. 

  1420. 				// Handle the length of decimal/numeric fields
    1421. 

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

  1422. 					$info['decimal_places'] = (int) $row['length'];
    1423. 

  1423. 				}
    1424. 

  1424. 				
    1425. 

  1425. 				// Handle the special data for varchar fields
    1426. 

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

  1427. 					$info['max_length'] = (int) $row['length'];
    1428. 

  1428. 				}
    1429. 

  1429. 			}
    1430. 

  1430. 			
    1431. 

  1431. 			// Handle check constraints that are just simple lists
    1432. 

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

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

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

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

  1436. 					}			
    1437. 

  1437. 				} elseif (preg_match('/^\s*"?' . preg_quote($column, '/') . '"?\s*=\s*\'((\'\'|[^\']+)*)\'(\s+OR\s+"?' . preg_quote($column, '/') . '"?\s*=\s*\'((\'\'|[^\']+)*)\')*\s*$/i', $row['check_constraint'], $match)) {
    1438. 

  1438. 					if (preg_match_all("/(?<!')'((''|[^']+)*)'/", $row['check_constraint'], $matches, PREG_PATTERN_ORDER)) {
    1439. 

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

  1440. 					}			
    1441. 

  1441. 				}
    1442. 

  1442. 			}
    1443. 

  1443. 			
    1444. 

  1444. 			if (!$duplicate) {
    1445. 

  1445. 				// Handle default values
    1446. 

  1446. 				if ($row['data_default'] !== NULL && trim($row['data_default']) != 'NULL') {
    1447. 

  1447. 					if (in_array($info['type'], array('date', 'time', 'timestamp')) && $row['data_default'][0] != "'") {
    1448. 

  1448. 						$info['default'] = trim(preg_replace('#^SYS#', 'CURRENT_', $row['data_default']));
    1449. 

  1449. 						
    1450. 

  1450. 					} elseif (in_array($info['type'], array('char', 'varchar', 'text', 'date', 'time', 'timestamp'))) {
    1451. 

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

  1452. 						
    1453. 

  1453. 					} elseif ($info['type'] == 'boolean') {
    1454. 

  1454. 						$info['default'] = (boolean) trim($row['data_default']);
    1455. 

  1455. 						
    1456. 

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

  1457. 						$info['default'] = trim($row['data_default']);
    1458. 

  1458. 						
    1459. 

  1459. 					} else {
    1460. 

  1460. 						$info['default'] = $row['data_default'];
    1461. 

  1461. 					}
    1462. 

  1462. 				}
    1463. 

  1463. 			
    1464. 

  1464. 				// Not null values
    1465. 

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

  1466. 				
    1467. 

  1467. 				$info['comment'] = $row['comments'];
    1468. 

  1468. 			}
    1469. 

  1469. 			
    1470. 

  1470. 			$column_info[$column] = $info;
    1471. 

  1471. 		}
    1472. 

  1472. 		
    1473. 

  1473. 		$sql = "SELECT
    1474. 

  1474. 					TRIGGER_BODY
    1475. 

  1475. 				FROM
    1476. 

  1476. 					ALL_TRIGGERS
    1477. 

  1477. 				WHERE
    1478. 

  1478. 					TRIGGERING_EVENT LIKE 'INSERT%' AND
    1479. 

  1479. 					STATUS = 'ENABLED' AND
    1480. 

  1480. 					TRIGGER_NAME NOT LIKE 'BIN\$%' AND
    1481. 

  1481. 					LOWER(TABLE_NAME) = %s AND
    1482. 

  1482. 					LOWER(OWNER) = %s";
    1483. 

  1483. 						
    1484. 

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

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

  1486. 				$column = strtolower($matches[2]);
    1487. 

  1487. 				$column_info[$column]['auto_increment'] = TRUE;
    1488. 

  1488. 			}
    1489. 

  1489. 		}
    1490. 

  1490. 		
    1491. 

  1491. 		return $column_info;
    1492. 

  1492. 	}
    1493. 

  1493. 	
    1494. 

  1494. 	
    1495. 

  1495. 	/**
    1496. 

  1496. 	 * Fetches the key info for an Oracle database
    1497. 

  1497. 	 * 
    1498. 

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

  1499. 	 */
    1500. 

  1500. 	private function fetchOracleKeys()
    1501. 

  1501. 	{
    1502. 

  1502. 		$keys = array();
    1503. 

  1503. 		
    1504. 

  1504. 		$default_schema = strtolower($this->database->getUsername());
    1505. 

  1505. 		
    1506. 

  1506. 		$tables = $this->getTables();
    1507. 

  1507. 		foreach ($tables as $table) {
    1508. 

  1508. 			$keys[$table] = array();
    1509. 

  1509. 			$keys[$table]['primary'] = array();
    1510. 

  1510. 			$keys[$table]['unique']  = array();
    1511. 

  1511. 			$keys[$table]['foreign'] = array();
    1512. 

  1512. 		}
    1513. 

  1513. 		
    1514. 

  1514. 		$params = array();
    1515. 

  1515. 		
    1516. 

  1516. 		$sql  = "SELECT
    1517. 

  1517. 					LOWER(AC.OWNER) \"SCHEMA\",
    1518. 

  1518. 					LOWER(AC.TABLE_NAME) \"TABLE\",
    1519. 

  1519. 					AC.CONSTRAINT_NAME CONSTRAINT_NAME,
    1520. 

  1520. 					CASE AC.CONSTRAINT_TYPE
    1521. 

  1521. 						WHEN 'P' THEN 'primary'
    1522. 

  1522. 						WHEN 'R' THEN 'foreign'
    1523. 

  1523. 						WHEN 'U' THEN 'unique'
    1524. 

  1524. 						END TYPE,
    1525. 

  1525. 					LOWER(ACC.COLUMN_NAME) \"COLUMN\",
    1526. 

  1526. 					LOWER(FKC.OWNER) FOREIGN_SCHEMA,
    1527. 

  1527. 					LOWER(FKC.TABLE_NAME) FOREIGN_TABLE,
    1528. 

  1528. 					LOWER(FKC.COLUMN_NAME) FOREIGN_COLUMN,
    1529. 

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

  1530. 				FROM
    1531. 

  1531. 					ALL_CONSTRAINTS AC INNER JOIN
    1532. 

  1532. 					ALL_CONS_COLUMNS ACC ON AC.CONSTRAINT_NAME = ACC.CONSTRAINT_NAME AND AC.OWNER = ACC.OWNER LEFT JOIN
    1533. 

  1533. 					ALL_CONSTRAINTS FK ON AC.R_CONSTRAINT_NAME = FK.CONSTRAINT_NAME AND AC.OWNER = FK.OWNER LEFT JOIN
    1534. 

  1534. 					ALL_CONS_COLUMNS FKC ON FK.CONSTRAINT_NAME = FKC.CONSTRAINT_NAME AND FK.OWNER = FKC.OWNER
    1535. 

  1535. 				WHERE
    1536. 

  1536. 					AC.CONSTRAINT_TYPE IN ('U', 'P', 'R') AND ";
    1537. 

  1537. 		
    1538. 

  1538. 		$conditions = array();
    1539. 

  1539. 		foreach ($tables as $table) {
    1540. 

  1540. 			if (strpos($table, '.') === FALSE) {
    1541. 

  1541. 				$table = $default_schema . '.' . $table;
    1542. 

  1542. 			}	
    1543. 

  1543. 			list ($schema, $table) = explode('.', strtolower($table));
    1544. 

  1544. 			$conditions[] = "LOWER(AC.OWNER) = %s AND LOWER(AC.TABLE_NAME) = %s";
    1545. 

  1545. 			$params[] = $schema;
    1546. 

  1546. 			$params[] = $table;
    1547. 

  1547. 		}
    1548. 

  1548. 		$sql .= '((' . join(') OR( ', $conditions) . '))';
    1549. 

  1549. 		
    1550. 

  1550. 		$sql .= " ORDER BY
    1551. 

  1551. 						 AC.OWNER ASC,
    1552. 

  1552. 						 AC.TABLE_NAME ASC,
    1553. 

  1553. 						 AC.CONSTRAINT_TYPE ASC,
    1554. 

  1554. 						 AC.CONSTRAINT_NAME ASC,
    1555. 

  1555. 						 ACC.POSITION ASC";
    1556. 

  1556. 		
    1557. 

  1557. 		$result = $this->database->query($sql, $params);
    1558. 

  1558. 		
    1559. 

  1559. 		$last_name  = '';
    1560. 

  1560. 		$last_table = '';
    1561. 

  1561. 		$last_type  = '';
    1562. 

  1562. 		foreach ($result as $row) {
    1563. 

  1563. 			
    1564. 

  1564. 			if ($row['constraint_name'] != $last_name) {
    1565. 

  1565. 				
    1566. 

  1566. 				if ($last_name) {
    1567. 

  1567. 					if ($last_type == 'foreign' || $last_type == 'unique') {
    1568. 

  1568. 						$keys[$last_table][$last_type][] = $temp;
    1569. 

  1569. 					} else {
    1570. 

  1570. 						$keys[$last_table][$last_type] = $temp;
    1571. 

  1571. 					}
    1572. 

  1572. 				}
    1573. 

  1573. 				
    1574. 

  1574. 				$temp = array();
    1575. 

  1575. 				if ($row['type'] == 'foreign') {
    1576. 

  1576. 					
    1577. 

  1577. 					$temp['column']         = $row['column'];
    1578. 

  1578. 					$temp['foreign_table']  = $row['foreign_table'];
    1579. 

  1579. 					if ($row['foreign_schema'] != $default_schema) {
    1580. 

  1580. 						$temp['foreign_table'] = $row['foreign_schema'] . '.' . $temp['foreign_table'];
    1581. 

  1581. 					}
    1582. 

  1582. 					$temp['foreign_column'] = $row['foreign_column'];
    1583. 

  1583. 					$temp['on_delete']      = 'no_action';
    1584. 

  1584. 					$temp['on_update']      = 'no_action';
    1585. 

  1585. 					
    1586. 

  1586. 					if (!empty($row['on_delete'])) {
    1587. 

  1587. 						$temp['on_delete'] = $row['on_delete'];
    1588. 

  1588. 					}
    1589. 

  1589. 					
    1590. 

  1590. 				} else {
    1591. 

  1591. 					$temp[] = $row['column'];
    1592. 

  1592. 				}
    1593. 

  1593. 				
    1594. 

  1594. 				$last_table = $row['table'];
    1595. 

  1595. 				if ($row['schema'] != $default_schema) {
    1596. 

  1596. 					$last_table = $row['schema'] . '.' . $last_table;
    1597. 

  1597. 				}
    1598. 

  1598. 				$last_name  = $row['constraint_name'];
    1599. 

  1599. 				$last_type  = $row['type'];
    1600. 

  1600. 				
    1601. 

  1601. 			} else {
    1602. 

  1602. 				$temp[] = $row['column'];
    1603. 

  1603. 			}
    1604. 

  1604. 		}
    1605. 

  1605. 		
    1606. 

  1606. 		if (isset($temp)) {
    1607. 

  1607. 			if ($last_type == 'foreign' || $last_type == 'unique') {
    1608. 

  1608. 				$keys[$last_table][$last_type][] = $temp;
    1609. 

  1609. 			} else {
    1610. 

  1610. 				$keys[$last_table][$last_type] = $temp;
    1611. 

  1611. 			}
    1612. 

  1612. 		}
    1613. 

  1613. 		
    1614. 

  1614. 		return $keys;
    1615. 

  1615. 	}
    1616. 

  1616. 	
    1617. 

  1617. 	
    1618. 

  1618. 	/**
    1619. 

  1619. 	 * Gets the column info from a PostgreSQL database
    1620. 

  1620. 	 * 
    1621. 

  1621. 	 * @param  string $table  The table to fetch the column info for
    1622. 

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

  1623. 	 */
    1624. 

  1624. 	private function fetchPostgreSQLColumnInfo($table)
    1625. 

  1625. 	{
    1626. 

  1626. 		$column_info = array();
    1627. 

  1627. 		
    1628. 

  1628. 		$schema = 'public';
    1629. 

  1629. 		if (strpos($table, '.') !== FALSE) {
    1630. 

  1630. 			list ($schema, $table) = explode('.', $table);	
    1631. 

  1631. 		}
    1632. 

  1632. 		
    1633. 

  1633. 		$data_type_mapping = array(
    1634. 

  1634. 			'boolean'			=> 'boolean',
    1635. 

  1635. 			'smallint'			=> 'integer',
    1636. 

  1636. 			'int'				=> 'integer',
    1637. 

  1637. 			'bigint'			=> 'integer',
    1638. 

  1638. 			'serial'			=> 'integer',
    1639. 

  1639. 			'bigserial'			=> 'integer',
    1640. 

  1640. 			'timestamp'			=> 'timestamp',
    1641. 

  1641. 			'date'				=> 'date',
    1642. 

  1642. 			'time'				=> 'time',
    1643. 

  1643. 			'uuid'              => 'varchar',
    1644. 

  1644. 			'character varying'	=> 'varchar',
    1645. 

  1645. 			'character'			=> 'char',
    1646. 

  1646. 			'real'				=> 'float',
    1647. 

  1647. 			'double'			=> 'float',
    1648. 

  1648. 			'numeric'			=> 'float',
    1649. 

  1649. 			'bytea'				=> 'blob',
    1650. 

  1650. 			'text'				=> 'text',
    1651. 

  1651. 			'mediumtext'		=> 'text',
    1652. 

  1652. 			'longtext'			=> 'text',
    1653. 

  1653. 			'point'             => 'varchar',
    1654. 

  1654. 			'line'              => 'varchar',
    1655. 

  1655. 			'lseg'              => 'varchar',
    1656. 

  1656. 			'box'               => 'varchar',
    1657. 

  1657. 			'path'              => 'varchar',
    1658. 

  1658. 			'polygon'           => 'varchar',
    1659. 

  1659. 			'circle'            => 'varchar'
    1660. 

  1660. 		);
    1661. 

  1661. 		
    1662. 

  1662. 		$max_min_values = array(
    1663. 

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

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

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

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

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

  1668. 		);
    1669. 

  1669. 		
    1670. 

  1670. 		// PgSQL required this complicated SQL to get the column info
    1671. 

  1671. 		$sql = "SELECT
    1672. 

  1672. 						LOWER(pg_attribute.attname)                                 AS column,
    1673. 

  1673. 						format_type(pg_attribute.atttypid, pg_attribute.atttypmod)  AS data_type,
    1674. 

  1674. 						pg_attribute.attnotnull                                     AS not_null,
    1675. 

  1675. 						pg_attrdef.adsrc                                            AS default,
    1676. 

  1676. 						pg_get_constraintdef(pg_constraint.oid)                     AS constraint,
    1677. 

  1677. 						col_description(pg_class.oid, pg_attribute.attnum)          AS comment              
    1678. 

  1678. 					FROM
    1679. 

  1679. 						pg_attribute LEFT JOIN
    1680. 

  1680. 						pg_class ON pg_attribute.attrelid = pg_class.oid LEFT JOIN
    1681. 

  1681. 						pg_namespace ON pg_class.relnamespace = pg_namespace.oid LEFT JOIN
    1682. 

  1682. 						pg_type ON pg_type.oid = pg_attribute.atttypid LEFT JOIN
    1683. 

  1683. 						pg_constraint ON pg_constraint.conrelid = pg_class.oid AND
    1684. 

  1684. 										 pg_attribute.attnum = ANY (pg_constraint.conkey) AND
    1685. 

  1685. 										 pg_constraint.contype = 'c' LEFT JOIN
    1686. 

  1686. 						pg_attrdef ON pg_class.oid = pg_attrdef.adrelid AND
    1687. 

  1687. 									  pg_attribute.attnum = pg_attrdef.adnum
    1688. 

  1688. 					WHERE
    1689. 

  1689. 						NOT pg_attribute.attisdropped AND
    1690. 

  1690. 						LOWER(pg_class.relname) = %s AND
    1691. 

  1691. 						LOWER(pg_namespace.nspname) = %s AND
    1692. 

  1692. 						pg_type.typname NOT IN ('oid', 'cid', 'xid', 'cid', 'xid', 'tid')
    1693. 

  1693. 					ORDER BY
    1694. 

  1694. 						pg_attribute.attnum,
    1695. 

  1695. 						pg_constraint.contype";
    1696. 

  1696. 		$result = $this->database->query($sql, strtolower($table), strtolower($schema));
    1697. 

  1697. 		
    1698. 

  1698. 		foreach ($result as $row) {
    1699. 

  1699. 			
    1700. 

  1700. 			$info = array();
    1701. 

  1701. 			
    1702. 

  1702. 			// Get the column type
    1703. 

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

  1704. 			
    1705. 

  1705. 			foreach ($data_type_mapping as $data_type => $mapped_data_type) {
    1706. 

  1706. 				if (stripos($column_data_type[1], $data_type) === 0) {
    1707. 

  1707. 					$info['type'] = $mapped_data_type;
    1708. 

  1708. 					if (isset($max_min_values[$data_type])) {
    1709. 

  1709. 						$info['min_value'] = $max_min_values[$data_type]['min'];
    1710. 

  1710. 						$info['max_value'] = $max_min_values[$data_type]['max'];
    1711. 

  1711. 					}
    1712. 

  1712. 					break;
    1713. 

  1713. 				}
    1714. 

  1714. 			}
    1715. 

  1715. 			
    1716. 

  1716. 			if (!isset($info['type'])) {
    1717. 

  1717. 				$info['type'] = $column_data_type[1];
    1718. 

  1718. 			}
    1719. 

  1719. 			
    1720. 

  1720. 			if ($info['type'] == 'blob' || $info['type'] == 'text') {
    1721. 

  1721. 				$info['max_length'] = 1073741824; 
    1722. 

  1722. 			}
    1723. 

  1723. 			
    1724. 

  1724. 			// Handle the length of decimal/numeric fields
    1725. 

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

  1726. 				$info['decimal_places'] = (int) $column_data_type[3];
    1727. 

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

  1728. 				$after_digits  = str_pad('', $info['decimal_places'], '9');
    1729. 

  1729. 				$max_min       = $before_digits . ($after_digits ? '.' : '') . $after_digits;
    1730. 

  1730. 				$info['min_value'] = new fNumber('-' . $max_min);
    1731. 

  1731. 				$info['max_value'] = new fNumber($max_min);
    1732. 

  1732. 			}
    1733. 

  1733. 			
    1734. 

  1734. 			// Handle the special data for varchar fields
    1735. 

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

  1736. 				if (!empty($column_data_type[2])) {
    1737. 

  1737. 					$info['max_length'] = $column_data_type[2];
    1738. 

  1738. 				} else {
    1739. 

  1739. 					$info['max_length'] = 1073741824; 
    1740. 

  1740. 				}
    1741. 

  1741. 			}
    1742. 

  1742. 			
    1743. 

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

  1744. 			if ($row['data_type'] == 'uuid') {
    1745. 

  1745. 				$info['max_length'] = 38;	
    1746. 

  1746. 			}
    1747. 

  1747. 			
    1748. 

  1748. 			// Handle check constraints that are just simple lists
    1749. 

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

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

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

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

  1753. 					}
    1754. 

  1754. 				}
    1755. 

  1755. 			}
    1756. 

  1756. 			
    1757. 

  1757. 			// Handle default values and serial data types
    1758. 

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

  1759. 				$info['auto_increment'] = TRUE;
    1760. 

  1760. 				
    1761. 

  1761. 			} elseif ($row['default'] !== NULL) {
    1762. 

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

  1763. 					$info['default'] = NULL;
    1764. 

  1764. 				} elseif ($row['default'] == 'now()') {
    1765. 

  1765. 					$info['default'] = 'CURRENT_TIMESTAMP';
    1766. 

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

  1767. 					$info['default'] = 'CURRENT_DATE';
    1768. 

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

  1769. 					$info['default'] = 'CURRENT_TIME';	
    1770. 

  1770. 				} else {
    1771. 

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

  1772. 					if ($info['type'] == 'boolean') {
    1773. 

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

  1774. 					}
    1775. 

  1775. 				}
    1776. 

  1776. 			}
    1777. 

  1777. 			
    1778. 

  1778. 			// Not null values
    1779. 

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

  1780. 			
    1781. 

  1781. 			$info['comment'] = $row['comment'];
    1782. 

  1782. 			
    1783. 

  1783. 			$column_info[$row['column']] = $info;
    1784. 

  1784. 		}
    1785. 

  1785. 		
    1786. 

  1786. 		return $column_info;
    1787. 

  1787. 	}
    1788. 

  1788. 	
    1789. 

  1789. 	
    1790. 

  1790. 	/**
    1791. 

  1791. 	 * Fetches the key info for a PostgreSQL database
    1792. 

  1792. 	 * 
    1793. 

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

  1794. 	 */
    1795. 

  1795. 	private function fetchPostgreSQLKeys()
    1796. 

  1796. 	{
    1797. 

  1797. 		$keys = array();
    1798. 

  1798. 		
    1799. 

  1799. 		$tables   = $this->getTables();
    1800. 

  1800. 		foreach ($tables as $table) {
    1801. 

  1801. 			$keys[$table] = array();
    1802. 

  1802. 			$keys[$table]['primary'] = array();
    1803. 

  1803. 			$keys[$table]['unique']  = array();
    1804. 

  1804. 			$keys[$table]['foreign'] = array();
    1805. 

  1805. 		}
    1806. 

  1806. 		
    1807. 

  1807. 		$sql  = "(
    1808. 

  1808. 				SELECT
    1809. 

  1809. 					LOWER(s.nspname) AS \"schema\",
    1810. 

  1810. 					LOWER(t.relname) AS \"table\",
    1811. 

  1811. 					con.conname AS constraint_name,
    1812. 

  1812. 					CASE con.contype
    1813. 

  1813. 						WHEN 'f' THEN 'foreign'
    1814. 

  1814. 						WHEN 'p' THEN 'primary'
    1815. 

  1815. 						WHEN 'u' THEN 'unique'
    1816. 

  1816. 					END AS type,
    1817. 

  1817. 					LOWER(col.attname) AS column,
    1818. 

  1818. 					LOWER(fs.nspname) AS foreign_schema,
    1819. 

  1819. 					LOWER(ft.relname) AS foreign_table,
    1820. 

  1820. 					LOWER(fc.attname) AS foreign_column,
    1821. 

  1821. 					CASE con.confdeltype
    1822. 

  1822. 						WHEN 'c' THEN 'cascade'
    1823. 

  1823. 						WHEN 'a' THEN 'no_action'
    1824. 

  1824. 						WHEN 'r' THEN 'restrict'
    1825. 

  1825. 						WHEN 'n' THEN 'set_null'
    1826. 

  1826. 						WHEN 'd' THEN 'set_default'
    1827. 

  1827. 					END AS on_delete,
    1828. 

  1828. 					CASE con.confupdtype
    1829. 

  1829. 						WHEN 'c' THEN 'cascade'
    1830. 

  1830. 						WHEN 'a' THEN 'no_action'
    1831. 

  1831. 						WHEN 'r' THEN 'restrict'
    1832. 

  1832. 						WHEN 'n' THEN 'set_null'
    1833. 

  1833. 						WHEN 'd' THEN 'set_default'
    1834. 

  1834. 					END AS on_update,
    1835. 

  1835. 					CASE WHEN con.conkey IS NOT NULL THEN position('-'||col.attnum||'-' in '-'||array_to_string(con.conkey, '-')||'-') ELSE 0 END AS column_order
    1836. 

  1836. 				FROM
    1837. 

  1837. 					pg_attribute AS col INNER JOIN
    1838. 

  1838. 					pg_class AS t ON
    1839. 

  1839. 						col.attrelid = t.oid INNER JOIN
    1840. 

  1840. 					pg_namespace AS s ON
    1841. 

  1841. 						t.relnamespace = s.oid INNER JOIN
    1842. 

  1842. 					pg_constraint AS con ON
    1843. 

  1843. 						col.attnum = ANY (con.conkey) AND
    1844. 

  1844. 						con.conrelid = t.oid LEFT JOIN
    1845. 

  1845. 					pg_class AS ft ON
    1846. 

  1846. 						con.confrelid = ft.oid LEFT JOIN
    1847. 

  1847. 					pg_namespace AS fs ON
    1848. 

  1848. 						ft.relnamespace = fs.oid LEFT JOIN
    1849. 

  1849. 					pg_attribute AS fc ON
    1850. 

  1850. 						fc.attnum = ANY (con.confkey) AND
    1851. 

  1851. 						ft.oid = fc.attrelid
    1852. 

  1852. 				WHERE
    1853. 

  1853. 					NOT col.attisdropped AND
    1854. 

  1854. 					(con.contype = 'p' OR
    1855. 

  1855. 					con.contype = 'f' OR
    1856. 

  1856. 					con.contype = 'u')
    1857. 

  1857. 				) UNION (
    1858. 

  1858. 				SELECT
    1859. 

  1859. 					LOWER(n.nspname) AS \"schema\",
    1860. 

  1860. 					LOWER(t.relname) AS \"table\",
    1861. 

  1861. 					ic.relname AS constraint_name,
    1862. 

  1862. 					'unique' AS type,
    1863. 

  1863. 					LOWER(col.attname) AS column,
    1864. 

  1864. 					NULL AS foreign_schema,
    1865. 

  1865. 					NULL AS foreign_table,
    1866. 

  1866. 					NULL AS foreign_column,
    1867. 

  1867. 					NULL AS on_delete,
    1868. 

  1868. 					NULL AS on_update,
    1869. 

  1869. 					CASE WHEN ind.indkey IS NOT NULL THEN position('-'||col.attnum||'-' in '-'||array_to_string(ind.indkey, '-')||'-') ELSE 0 END AS column_order
    1870. 

  1870. 				FROM
    1871. 

  1871. 					pg_class AS t INNER JOIN
    1872. 

  1872. 					pg_index AS ind ON
    1873. 

  1873. 						ind.indrelid = t.oid INNER JOIN
    1874. 

  1874. 					pg_namespace AS n ON
    1875. 

  1875. 						t.relnamespace = n.oid INNER JOIN
    1876. 

  1876. 					pg_class AS ic ON
    1877. 

  1877. 						ind.indexrelid = ic.oid LEFT JOIN
    1878. 

  1878. 					pg_constraint AS con ON
    1879. 

  1879. 						con.conrelid = t.oid AND
    1880. 

  1880. 						con.contype = 'u' AND
    1881. 

  1881. 						con.conname = ic.relname INNER JOIN
    1882. 

  1882. 					pg_attribute AS col ON
    1883. 

  1883. 						col.attrelid = t.oid AND
    1884. 

  1884. 						col.attnum = ANY (ind.indkey)  
    1885. 

  1885. 				WHERE
    1886. 

  1886. 					n.nspname NOT IN ('pg_catalog', 'pg_toast') AND
    1887. 

  1887. 					indisunique = TRUE AND
    1888. 

  1888. 					indisprimary = FALSE AND
    1889. 

  1889. 					con.oid IS NULL AND
    1890. 

  1890. 					0 != ALL ((ind.indkey)::int[])
    1891. 

  1891. 			) ORDER BY 1, 2, 4, 3, 11";
    1892. 

  1892. 		
    1893. 

  1893. 		$result = $this->database->query($sql);
    1894. 

  1894. 		
    1895. 

  1895. 		$last_name  = '';
    1896. 

  1896. 		$last_table = '';
    1897. 

  1897. 		$last_type  = '';
    1898. 

  1898. 		foreach ($result as $row) {
    1899. 

  1899. 			
    1900. 

  1900. 			if ($row['constraint_name'] != $last_name) {
    1901. 

  1901. 				
    1902. 

  1902. 				if ($last_name) {
    1903. 

  1903. 					if ($last_type == 'foreign' || $last_type == 'unique') {
    1904. 

  1904. 						$keys[$last_table][$last_type][] = $temp;
    1905. 

  1905. 					} else {
    1906. 

  1906. 						$keys[$last_table][$last_type] = $temp;
    1907. 

  1907. 					}
    1908. 

  1908. 				}
    1909. 

  1909. 				
    1910. 

  1910. 				$temp = array();
    1911. 

  1911. 				if ($row['type'] == 'foreign') {
    1912. 

  1912. 					
    1913. 

  1913. 					$temp['column']         = $row['column'];
    1914. 

  1914. 					$temp['foreign_table']  = $row['foreign_table'];
    1915. 

  1915. 					if ($row['foreign_schema'] != 'public') {
    1916. 

  1916. 						$temp['foreign_table'] = $row['foreign_schema'] . '.' . $temp['foreign_table'];	
    1917. 

  1917. 					}
    1918. 

  1918. 					$temp['foreign_column'] = $row['foreign_column'];
    1919. 

  1919. 					$temp['on_delete']      = 'no_action';
    1920. 

  1920. 					$temp['on_update']      = 'no_action';
    1921. 

  1921. 					
    1922. 

  1922. 					if (!empty($row['on_delete'])) {
    1923. 

  1923. 						$temp['on_delete'] = $row['on_delete'];
    1924. 

  1924. 					}
    1925. 

  1925. 					
    1926. 

  1926. 					if (!empty($row['on_update'])) {
    1927. 

  1927. 						$temp['on_update'] = $row['on_update'];
    1928. 

  1928. 					}
    1929. 

  1929. 					
    1930. 

  1930. 				} else {
    1931. 

  1931. 					$temp[] = $row['column'];
    1932. 

  1932. 				}
    1933. 

  1933. 				
    1934. 

  1934. 				$last_table = $row['table'];
    1935. 

  1935. 				if ($row['schema'] != 'public') {
    1936. 

  1936. 					$last_table = $row['schema'] . '.' . $last_table;	
    1937. 

  1937. 				}
    1938. 

  1938. 				$last_name  = $row['constraint_name'];
    1939. 

  1939. 				$last_type  = $row['type'];
    1940. 

  1940. 				
    1941. 

  1941. 			} else {
    1942. 

  1942. 				$temp[] = $row['column'];
    1943. 

  1943. 			}
    1944. 

  1944. 		}
    1945. 

  1945. 		
    1946. 

  1946. 		if (isset($temp)) {
    1947. 

  1947. 			if ($last_type == 'foreign' || $last_type == 'unique') {
    1948. 

  1948. 				$keys[$last_table][$last_type][] = $temp;
    1949. 

  1949. 			} else {
    1950. 

  1950. 				$keys[$last_table][$last_type] = $temp;
    1951. 

  1951. 			}
    1952. 

  1952. 		}
    1953. 

  1953. 		
    1954. 

  1954. 		return $keys;
    1955. 

  1955. 	}
    1956. 

  1956. 	
    1957. 

  1957. 	
    1958. 

  1958. 	/**
    1959. 

  1959. 	 * Gets the column info from a SQLite database
    1960. 

  1960. 	 * 
    1961. 

  1961. 	 * @param  string $table  The table to fetch the column info for
    1962. 

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

  1963. 	 */
    1964. 

  1964. 	private function fetchSQLiteColumnInfo($table)
    1965. 

  1965. 	{
    1966. 

  1966. 		$column_info = array();
    1967. 

  1967. 		
    1968. 

  1968. 		$data_type_mapping = array(
    1969. 

  1969. 			'boolean'			=> 'boolean',
    1970. 

  1970. 			'serial'            => 'integer',
    1971. 

  1971. 			'smallint'			=> 'integer',
    1972. 

  1972. 			'int'				=> 'integer',
    1973. 

  1973. 			'integer'           => 'integer',
    1974. 

  1974. 			'bigint'			=> 'integer',
    1975. 

  1975. 			'timestamp'			=> 'timestamp',
    1976. 

  1976. 			'date'				=> 'date',
    1977. 

  1977. 			'time'				=> 'time',
    1978. 

  1978. 			'varchar'			=> 'varchar',
    1979. 

  1979. 			'char'				=> 'char',
    1980. 

  1980. 			'real'				=> 'float',
    1981. 

  1981. 			'numeric'           => 'float',
    1982. 

  1982. 			'float'             => 'float',
    1983. 

  1983. 			'double'			=> 'float',
    1984. 

  1984. 			'decimal'			=> 'float',
    1985. 

  1985. 			'blob'				=> 'blob',
    1986. 

  1986. 			'text'				=> 'text'
    1987. 

  1987. 		);
    1988. 

  1988. 		
    1989. 

  1989. 		$result = $this->database->query("SELECT sql FROM sqlite_master WHERE type = 'table' AND LOWER(name) = %s", strtolower($table));
    1990. 

  1990. 		
    1991. 

  1991. 		try {
    1992. 

  1992. 			$row        = $result->fetchRow();
    1993. 

  1993. 			$create_sql = $row['sql'];
    1994. 

  1994. 		} catch (fNoRowsException $e) {
    1995. 

  1995. 			return array();			
    1996. 

  1996. 		}
    1997. 

  1997. 		
    1998. 

  1998. 		preg_match_all('#(?<=,|\(|\*/|\n)\s*(?:`|"|\[)?(\w+)(?:`|"|\])?\s+([a-z]+)(?:\(\s*(\d+)(?:\s*,\s*(\d+))?\s*\))?(?:(\s+NOT\s+NULL)|(?:\s+NULL)|(?:\s+DEFAULT\s+([^, \'\n]*|\'(?:\'\'|[^\']+)*\'))|(\s+UNIQUE)|(\s+PRIMARY\s+KEY(?:\s+AUTOINCREMENT)?)|(\s+CHECK\s*\("?\w+"?\s+IN\s+\(\s*(?:(?:[^, \'\n]+|\'(?:\'\'|[^\']+)*\')\s*,\s*)*\s*(?:[^, \'\n]+|\'(?:\'\'|[^\']+)*\')\)\)))*(\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))?)?([ \t]*(?:/\*(?:(?!\*/).)*\*/))?\s*(?:,([ \t]*--[^\n]*\n)?|(--[^\n]*\n)?\s*(?:/\*(?:(?!\*/).)*\*/)?\s*(?=\)))#msi', $create_sql, $matches, PREG_SET_ORDER);
    1999. 

  1999. 		
    2000. 

  2000. 		foreach ($matches as $match) {
    2001. 

  2001. 			$info = array();
    2002. 

  2002. 			
    2003. 

  2003. 			foreach ($data_type_mapping as $data_type => $mapped_data_type) {
    2004. 

  2004. 				if (stripos($match[2], $data_type) === 0) {
    2005. 

  2005. 					$info['type'] = $mapped_data_type;
    2006. 

  2006. 					break;
    2007. 

  2007. 				}
    2008. 

  2008. 			}
    2009. 

  2009. 		
    2010. 

  2010. 			// Type specific information
    2011. 

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

  2012. 				if (!empty($match[3])) {
    2013. 

  2013. 					$info['max_length'] = $match[3];
    2014. 

  2014. 				} else {
    2015. 

  2015. 					$info['max_length'] = 1000000000;   
    2016. 

  2016. 				}
    2017. 

  2017. 			}
    2018. 

  2018. 			
    2019. 

  2019. 			if ($info['type'] == 'text' || $info['type'] == 'blob') {
    2020. 

  2020. 				$info['max_length'] = 1000000000;   
    2021. 

  2021. 			}
    2022. 

  2022. 			
    2023. 

  2023. 			// Figure out how many decimal places for a decimal
    2024. 

  2024. 			if (in_array(strtolower($match[2]), array('decimal', 'numeric')) && !empty($match[4])) {
    2025. 

  2025. 				$info['decimal_places'] = $match[4];
    2026. 

  2026. 				$before_digits = str_pad('', $match[3] - $match[4], '9');
    2027. 

  2027. 				$after_digits  = str_pad('', $match[4], '9');
    2028. 

  2028. 				$max_min       = $before_digits . ($after_digits ? '.' : '') . $after_digits;
    2029. 

  2029. 				$info['min_value'] = new fNumber('-' . $max_min);
    2030. 

  2030. 				$info['max_value'] = new fNumber($max_min);
    2031. 

  2031. 			}
    2032. 

  2032. 			
    2033. 

  2033. 			// Not null
    2034. 

  2034. 			$info['not_null'] = (!empty($match[5]) || !empty($match[8])) ? TRUE : FALSE;
    2035. 

  2035. 		
    2036. 

  2036. 			// Default values
    2037. 

  2037. 			if (isset($match[6]) && $match[6] != '' && $match[6] != 'NULL') {
    2038. 

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

  2039. 			}
    2040. 

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

  2041. 				$info['default'] = ($info['default'] == 'f' || $info['default'] == 0 || $info['default'] == 'false') ? FALSE : TRUE;
    2042. 

  2042. 			}
    2043. 

  2043. 		
    2044. 

  2044. 			// Check constraints
    2045. 

  2045. 			if (isset($match[9]) && preg_match('/CHECK\s*\(\s*"?' . $match[1] . '"?\s+IN\s+\(\s*((?:(?:[^, \']*|\'(?:\'\'|[^\']+)*\')\s*,\s*)*(?:[^, \']*|\'(?:\'\'|[^\']+)*\'))\s*\)/i', $match[9], $check_match)) {
    2046. 

  2046. 				$info['valid_values'] = str_replace("''", "'", preg_replace("/^'|'\$/D", '', preg_split("#\s*,\s*#", $check_match[1])));
    2047. 

  2047. 			}
    2048. 

  2048. 		
    2049. 

  2049. 			// Auto increment fields
    2050. 

  2050. 			if (!empty($match[8]) && (stripos($match[8], 'autoincrement') !== FALSE || $info['type'] == 'integer')) {
    2051. 

  2051. 				$info['auto_increment'] = TRUE;
    2052. 

  2052. 			}
    2053. 

  2053. 			
    2054. 

  2054. 			// Column comments
    2055. 

  2055. 			if (!empty($match[11]) || !empty($match[12]) || !empty($match[13])) {
    2056. 

  2056. 				if (!empty($match[11])) {
    2057. 

  2057. 					$comment = $match[11];
    2058. 

  2058. 				} elseif (!empty($match[12])) {
    2059. 

  2059. 					$comment = $match[12];
    2060. 

  2060. 				} else {
    2061. 

  2061. 					$comment = $match[13];
    2062. 

  2062. 				}
    2063. 

  2063. 				$comment = trim($comment);
    2064. 

  2064. 				$comment = substr($comment, 0, 2) == '--' ? substr($comment, 2) : substr($comment, 2, -2);
    2065. 

  2065. 				$info['comment'] = trim($comment);
    2066. 

  2066. 			}
    2067. 

  2067. 		
    2068. 

  2068. 			$column_info[strtolower($match[1])] = $info;
    2069. 

  2069. 		}
    2070. 

  2070. 		
    2071. 

  2071. 		return $column_info;
    2072. 

  2072. 	}
    2073. 

  2073. 	
    2074. 

  2074. 	
    2075. 

  2075. 	/**
    2076. 

  2076. 	 * Fetches the key info for an SQLite database
    2077. 

  2077. 	 * 
    2078. 

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

  2079. 	 */
    2080. 

  2080. 	private function fetchSQLiteKeys()
    2081. 

  2081. 	{
    2082. 

  2082. 		$tables = $this->getTables();
    2083. 

  2083. 		$keys   = array();
    2084. 

  2084. 		
    2085. 

  2085. 		foreach ($tables as $table) {
    2086. 

  2086. 			$keys[$table] = array();
    2087. 

  2087. 			$keys[$table]['primary'] = array();
    2088. 

  2088. 			$keys[$table]['foreign'] = array();
    2089. 

  2089. 			$keys[$table]['unique']  = array();
    2090. 

  2090. 			
    2091. 

  2091. 			$result     = $this->database->query("SELECT sql FROM sqlite_master WHERE type = 'table' AND LOWER(name) = %s", strtolower($table));
    2092. 

  2092. 			$row        = $result->fetchRow();
    2093. 

  2093. 			$create_sql = $row['sql'];
    2094. 

  2094. 

  2095. 			// Collapse strings into empty string to make the matching simpler
    2096. 

  2096. 			$create_sql = preg_replace('#\'(?:\'\'|[^\']+)*\'#', "''", $create_sql);
    2097. 

  2097. 			
    2098. 

  2098. 			// Remove single-line comments
    2099. 

  2099. 			$create_sql = preg_replace('#--[^\n]*\n#', "\n", $create_sql);
    2100. 

  2100. 			
    2101. 

  2101. 			// Remove multi-line comments
    2102. 

  2102. 			$create_sql = preg_replace('#/\*((?!\*/).)*\*/#', '', $create_sql);
    2103. 

  2103. 			
    2104. 

  2104. 			// Get column level key definitions
    2105. 

  2105. 			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);
    2106. 

  2106. 			
    2107. 

  2107. 			foreach ($matches as $match) {
    2108. 

  2108. 				if (!empty($match[2])) {
    2109. 

  2109. 					$keys[$table]['unique'][] = array(strtolower($match[1]));
    2110. 

  2110. 				}
    2111. 

  2111. 				
    2112. 

  2112. 				if (!empty($match[3])) {
    2113. 

  2113. 					$keys[$table]['primary'] = array(strtolower($match[1]));
    2114. 

  2114. 				}
    2115. 

  2115. 				
    2116. 

  2116. 				if (!empty($match[4])) {
    2117. 

  2117. 					$temp = array(
    2118. 

  2118. 						'column'         => strtolower($match[1]),
    2119. 

  2119. 						'foreign_table'  => strtolower($match[5]),
    2120. 

  2120. 						'foreign_column' => strtolower($match[6]),
    2121. 

  2121. 						'on_delete'      => 'no_action',
    2122. 

  2122. 						'on_update'      => 'no_action'
    2123. 

  2123. 					);
    2124. 

  2124. 					if (isset($match[7])) {
    2125. 

  2125. 						$temp['on_delete'] = strtolower(str_replace(' ', '_', $match[7]));
    2126. 

  2126. 					}
    2127. 

  2127. 					if (isset($match[8])) {
    2128. 

  2128. 						$temp['on_update'] = strtolower(str_replace(' ', '_', $match[8]));
    2129. 

  2129. 					}
    2130. 

  2130. 					$keys[$table]['foreign'][] = $temp;
    2131. 

  2131. 				}
    2132. 

  2132. 			}
    2133. 

  2133. 			
    2134. 

  2134. 			// Get table level primary key definitions
    2135. 

  2135. 			preg_match_all('#(?<=,|\()\s*(?:CONSTRAINT\s+["`\[]?\w+["`\]]?\s+)?PRIMARY\s+KEY\s*\(\s*((?:\s*["`\[]?\w+["`\]]?\s*,\s*)*["`\[]?\w+["`\]]?)\s*\)\s*(?:,|\s*(?=\)))#mi', $create_sql, $matches, PREG_SET_ORDER);
    2136. 

  2136. 			
    2137. 

  2137. 			foreach ($matches as $match) {
    2138. 

  2138. 				$columns = preg_split('#\s*,\s*#', strtolower($match[1]));
    2139. 

  2139. 				foreach ($columns as $column) {
    2140. 

  2140. 					$keys[$table]['primary'][] = str_replace(array('[', '"', '`', ']'), '', $column);	
    2141. 

  2141. 				}
    2142. 

  2142. 			}
    2143. 

  2143. 			
    2144. 

  2144. 			// Get table level foreign key definitions
    2145. 

  2145. 			preg_match_all('#(?<=,|\()\s*(?:CONSTRAINT\s+["`\[]?\w+["`\]]?\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*(?=\)))#mis', $create_sql, $matches, PREG_SET_ORDER);
    2146. 

  2146. 			
    2147. 

  2147. 			foreach ($matches as $match) {
    2148. 

  2148. 				if (empty($match[1])) { $match[1] = $match[2]; }
    2149. 

  2149. 				$temp = array(
    2150. 

  2150. 					'column'         => strtolower($match[1]),
    2151. 

  2151. 					'foreign_table'  => strtolower($match[3]),
    2152. 

  2152. 					'foreign_column' => strtolower($match[4]),
    2153. 

  2153. 					'on_delete'      => 'no_action',
    2154. 

  2154. 					'on_update'      => 'no_action'
    2155. 

  2155. 				);
    2156. 

  2156. 				if (isset($match[5])) {
    2157. 

  2157. 					$temp['on_delete'] = strtolower(str_replace(' ', '_', $match[5]));
    2158. 

  2158. 				}
    2159. 

  2159. 				if (isset($match[6])) {
    2160. 

  2160. 					$temp['on_update'] = strtolower(str_replace(' ', '_', $match[6]));
    2161. 

  2161. 				}
    2162. 

  2162. 				$keys[$table]['foreign'][] = $temp;
    2163. 

  2163. 			}
    2164. 

  2164. 			
    2165. 

  2165. 			// Get table level unique key definitions
    2166. 

  2166. 			preg_match_all('#(?<=,|\()\s*(?:CONSTRAINT\s+["`\[]?\w+["`\]]?\s+)?UNIQUE\s*\(\s*((?:\s*["`\[]?\w+["`\]]?\s*,\s*)*["`\[]?\w+["`\]]?)\s*\)\s*(?:,|\s*(?=\)))#mi', $create_sql, $matches, PREG_SET_ORDER);
    2167. 

  2167. 			
    2168. 

  2168. 			foreach ($matches as $match) {
    2169. 

  2169. 				$columns = preg_split('#\s*,\s*#', strtolower($match[1]));
    2170. 

  2170. 				$key = array();
    2171. 

  2171. 				foreach ($columns as $column) {
    2172. 

  2172. 					$key[] = str_replace(array('[', '"', '`', ']'), '', $column);
    2173. 

  2173. 				}
    2174. 

  2174. 				$keys[$table]['unique'][] = $key;
    2175. 

  2175. 			}
    2176. 

  2176. 			
    2177. 

  2177. 			// Get all CREATE UNIQUE INDEX statements
    2178. 

  2178. 			$result = $this->database->query("SELECT sql FROM sqlite_master WHERE type = 'index' AND sql <> '' AND LOWER(tbl_name) = %s", strtolower($table));
    2179. 

  2179. 			foreach ($result as $row) {
    2180. 

  2180. 				$create_sql = $row['sql'];
    2181. 

  2181. 				if (!preg_match('#^\s*CREATE\s+UNIQUE\s+INDEX\s+(?:["`\[]?\w+["`\]]?\.)?["`\[]?\w+["`\]]?\s+ON\s+[\'"`\[]?\w+[\'"`\]]?\s*\(\s*((?:\s*["`\[]?\w+["`\]]?\s*,\s*)*["`\[]?\w+["`\]]?)\s*\)\s*$#Di', $create_sql, $match)) {
    2182. 

  2182. 					continue;
    2183. 

  2183. 				}
    2184. 

  2184. 				$columns = preg_split('#\s*,\s*#', strtolower($match[1]));
    2185. 

  2185. 				$key = array();
    2186. 

  2186. 				foreach ($columns as $column) {
    2187. 

  2187. 					$key[] = str_replace(array('[', '"', '`', ']'), '', $column);
    2188. 

  2188. 				}
    2189. 

  2189. 				$keys[$table]['unique'][] = $key;
    2190. 

  2190. 			}
    2191. 

  2191. 		}
    2192. 

  2192. 		
    2193. 

  2193. 		return $keys;
    2194. 

  2194. 	}
    2195. 

  2195. 	
    2196. 

  2196. 	
    2197. 

  2197. 	/**
    2198. 

  2198. 	 * Finds many-to-many relationship for the table specified
    2199. 

  2199. 	 * 
    2200. 

  2200. 	 * @param  string $table  The table to find the relationships on
    2201. 

  2201. 	 * @return void
    2202. 

  2202. 	 */
    2203. 

  2203. 	private function findManyToManyRelationships($table)
    2204. 

  2204. 	{
    2205. 

  2205. 		if (!$this->isJoiningTable($table)) {
    2206. 

  2206. 			return;
    2207. 

  2207. 		}
    2208. 

  2208. 		
    2209. 

  2209. 		list ($key1, $key2) = $this->merged_keys[$table]['foreign'];
    2210. 

  2210. 		
    2211. 

  2211. 		$temp = array();
    2212. 

  2212. 		$temp['table']               = $key1['foreign_table'];
    2213. 

  2213. 		$temp['column']              = $key1['foreign_column'];
    2214. 

  2214. 		$temp['related_table']       = $key2['foreign_table'];
    2215. 

  2215. 		$temp['related_column']      = $key2['foreign_column'];
    2216. 

  2216. 		$temp['join_table']          = $table;
    2217. 

  2217. 		$temp['join_column']         = $key1['column'];
    2218. 

  2218. 		$temp['join_related_column'] = $key2['column'];
    2219. 

  2219. 		$temp['on_update']           = $key1['on_update'];
    2220. 

  2220. 		$temp['on_delete']           = $key1['on_delete'];
    2221. 

  2221. 		$this->relationships[$key1['foreign_table']]['many-to-many'][] = $temp;
    2222. 

  2222. 		
    2223. 

  2223. 		$temp = array();
    2224. 

  2224. 		$temp['table']               = $key2['foreign_table'];
    2225. 

  2225. 		$temp['column']              = $key2['foreign_column'];
    2226. 

  2226. 		$temp['related_table']       = $key1['foreign_table'];
    2227. 

  2227. 		$temp['related_column']      = $key1['foreign_column'];
    2228. 

  2228. 		$temp['join_table']          = $table;
    2229. 

  2229. 		$temp['join_column']         = $key2['column'];
    2230. 

  2230. 		$temp['join_related_column'] = $key1['column'];
    2231. 

  2231. 		$temp['on_update']           = $key2['on_update'];
    2232. 

  2232. 		$temp['on_delete']           = $key2['on_delete'];
    2233. 

  2233. 		$this->relationships[$key2['foreign_table']]['many-to-many'][] = $temp;
    2234. 

  2234. 	}
    2235. 

  2235. 	
    2236. 

  2236. 	
    2237. 

  2237. 	/**
    2238. 

  2238. 	 * Finds one-to-many relationship for the table specified
    2239. 

  2239. 	 * 
    2240. 

  2240. 	 * @param  string $table  The table to find the relationships on
    2241. 

  2241. 	 * @return void
    2242. 

  2242. 	 */
    2243. 

  2243. 	private function findOneToManyRelationships($table)
    2244. 

  2244. 	{
    2245. 

  2245. 		foreach ($this->merged_keys[$table]['foreign'] as $key) {
    2246. 

  2246. 			$type = ($this->checkForSingleColumnUniqueKey($table, $key['column'])) ? 'one-to-one' : 'one-to-many';
    2247. 

  2247. 			$temp = array();
    2248. 

  2248. 			$temp['table']          = $key['foreign_table'];
    2249. 

  2249. 			$temp['column']         = $key['foreign_column'];
    2250. 

  2250. 			$temp['related_table']  = $table;
    2251. 

  2251. 			$temp['related_column'] = $key['column'];
    2252. 

  2252. 			$temp['on_delete']      = $key['on_delete'];
    2253. 

  2253. 			$temp['on_update']      = $key['on_update'];
    2254. 

  2254. 			$this->relationships[$key['foreign_table']][$type][] = $temp;
    2255. 

  2255. 		}
    2256. 

  2256. 	}
    2257. 

  2257. 	
    2258. 

  2258. 	
    2259. 

  2259. 	/**
    2260. 

  2260. 	 * Finds one-to-one and many-to-one relationship for the table specified
    2261. 

  2261. 	 * 
    2262. 

  2262. 	 * @param  string $table  The table to find the relationships on
    2263. 

  2263. 	 * @return void
    2264. 

  2264. 	 */
    2265. 

  2265. 	private function findStarToOneRelationships($table)
    2266. 

  2266. 	{
    2267. 

  2267. 		foreach ($this->merged_keys[$table]['foreign'] as $key) {
    2268. 

  2268. 			$temp = array();
    2269. 

  2269. 			$temp['table']          = $table;
    2270. 

  2270. 			$temp['column']         = $key['column'];
    2271. 

  2271. 			$temp['related_table']  = $key['foreign_table'];
    2272. 

  2272. 			$temp['related_column'] = $key['foreign_column'];
    2273. 

  2273. 			$type = ($this->checkForSingleColumnUniqueKey($table, $key['column'])) ? 'one-to-one' : 'many-to-one';
    2274. 

  2274. 			if ($type == 'one-to-one') {
    2275. 

  2275. 				$temp['on_delete'] = $key['on_delete'];
    2276. 

  2276. 				$temp['on_update'] = $key['on_update'];	
    2277. 

  2277. 			}
    2278. 

  2278. 			$this->relationships[$table][$type][] = $temp;
    2279. 

  2279. 		}
    2280. 

  2280. 	}
    2281. 

  2281. 	
    2282. 

  2282. 	
    2283. 

  2283. 	/**
    2284. 

  2284. 	 * Finds the one-to-one, many-to-one, one-to-many and many-to-many relationships in the database
    2285. 

  2285. 	 * 
    2286. 

  2286. 	 * @return void
    2287. 

  2287. 	 */
    2288. 

  2288. 	private function findRelationships()
    2289. 

  2289. 	{
    2290. 

  2290. 		$this->relationships = array();
    2291. 

  2291. 		$tables = $this->getTables();
    2292. 

  2292. 		
    2293. 

  2293. 		foreach ($tables as $table) {
    2294. 

  2294. 			$this->relationships[$table]['one-to-one']   = array();
    2295. 

  2295. 			$this->relationships[$table]['many-to-one']  = array();
    2296. 

  2296. 			$this->relationships[$table]['one-to-many']  = array();
    2297. 

  2297. 			$this->relationships[$table]['many-to-many'] = array();
    2298. 

  2298. 		}
    2299. 

  2299. 		
    2300. 

  2300. 		// Calculate the relationships
    2301. 

  2301. 		foreach ($this->merged_keys as $table => $keys) {
    2302. 

  2302. 			$this->findManyToManyRelationships($table);
    2303. 

  2303. 			if ($this->isJoiningTable($table)) {
    2304. 

  2304. 				continue;
    2305. 

  2305. 			}
    2306. 

  2306. 			
    2307. 

  2307. 			$this->findStarToOneRelationships($table);
    2308. 

  2308. 			$this->findOneToManyRelationships($table);
    2309. 

  2309. 		}
    2310. 

  2310. 		
    2311. 

  2311. 		if ($this->cache) {
    2312. 

  2312. 			$this->cache->set($this->makeCachePrefix() . 'relationships', $this->relationships);	
    2313. 

  2313. 		}
    2314. 

  2314. 	}
    2315. 

  2315. 	
    2316. 

  2316. 	
    2317. 

  2317. 	/**
    2318. 

  2318. 	 * Returns column information for the table specified
    2319. 

  2319. 	 * 
    2320. 

  2320. 	 * If only a table is specified, column info is in the following format:
    2321. 

  2321. 	 * 
    2322. 

  2322. 	 * {{{
    2323. 

  2323. 	 * array(
    2324. 

  2324. 	 *     (string) {column name} => array(
    2325. 

  2325. 	 *         'type'           => (string)  {data type},
    2326. 

  2326. 	 *         'placeholder'    => (string)  {fDatabase::escape() placeholder for this data type},
    2327. 

  2327. 	 *         'not_null'       => (boolean) {if value can't be null},
    2328. 

  2328. 	 *         'default'        => (mixed)   {the default value},
    2329. 

  2329. 	 *         'valid_values'   => (array)   {the valid values for a varchar field},
    2330. 

  2330. 	 *         'max_length'     => (integer) {the maximum length in a varchar field},
    2331. 

  2331. 	 *         'min_value'      => (numeric) {the minimum value for an integer/float field},
    2332. 

  2332. 	 *         'max_value'      => (numeric) {the maximum value for an integer/float field},
    2333. 

  2333. 	 *         'decimal_places' => (integer) {the number of decimal places for a decimal/numeric/money/smallmoney field},
    2334. 

  2334. 	 *         'auto_increment' => (boolean) {if the integer primary key column is a serial/autoincrement/auto_increment/indentity column},
    2335. 

  2335. 	 *         'comment'        => (string)  {the SQL comment/description for the column}
    2336. 

  2336. 	 *     ), ...
    2337. 

  2337. 	 * )
    2338. 

  2338. 	 * }}}
    2339. 

  2339. 	 * 
    2340. 

  2340. 	 * If a table and column are specified, column info is in the following format:
    2341. 

  2341. 	 * 
    2342. 

  2342. 	 * {{{
    2343. 

  2343. 	 * array(
    2344. 

  2344. 	 *     'type'           => (string)  {data type},
    2345. 

  2345. 	 *     'placeholder'    => (string)  {fDatabase::escape() placeholder for this data type},
    2346. 

  2346. 	 *     'not_null'       => (boolean) {if value can't be null},
    2347. 

  2347. 	 *     'default'        => (mixed)   {the default value-may contain special strings CURRENT_TIMESTAMP, CURRENT_TIME or CURRENT_DATE},
    2348. 

  2348. 	 *     'valid_values'   => (array)   {the valid values for a varchar field},
    2349. 

  2349. 	 *     'max_length'     => (integer) {the maximum length in a char/varchar field},
    2350. 

  2350. 	 *     'min_value'      => (fNumber) {the minimum value for an integer/float field},
    2351. 

  2351. 	 *     'max_value'      => (fNumber) {the maximum value for an integer/float field},
    2352. 

  2352. 	 *     'decimal_places' => (integer) {the number of decimal places for a decimal/numeric/money/smallmoney field},
    2353. 

  2353. 	 *     'auto_increment' => (boolean) {if the integer primary key column is a serial/autoincrement/auto_increment/indentity column},
    2354. 

  2354. 	 *     'comment'        => (string)  {the SQL comment/description for the column}
    2355. 

  2355. 	 * )
    2356. 

  2356. 	 * }}}
    2357. 

  2357. 	 * 
    2358. 

  2358. 	 * If a table, column and element are specified, returned value is the single element specified.
    2359. 

  2359. 	 * 
    2360. 

  2360. 	 * The `'type'` element is homogenized to a value from the following list:
    2361. 

  2361. 	 * 
    2362. 

  2362. 	 *  - `'varchar'`
    2363. 

  2363. 	 *  - `'char'`
    2364. 

  2364. 	 *  - `'text'`
    2365. 

  2365. 	 *  - `'integer'`
    2366. 

  2366. 	 *  - `'float'`
    2367. 

  2367. 	 *  - `'timestamp'`
    2368. 

  2368. 	 *  - `'date'`
    2369. 

  2369. 	 *  - `'time'`
    2370. 

  2370. 	 *  - `'boolean'`
    2371. 

  2371. 	 *  - `'blob'`
    2372. 

  2372. 	 * 
    2373. 

  2373. 	 * Please note that MySQL reports boolean data types as `tinyint(1)`, so
    2374. 

  2374. 	 * all `tinyint(1)` columns will be listed as `boolean`. This can be fixed
    2375. 

  2375. 	 * by calling: 
    2376. 

  2376. 	 * 
    2377. 

  2377. 	 * {{{
    2378. 

  2378. 	 * #!php
    2379. 

  2379. 	 * $schema->setColumnInfoOverride(
    2380. 

  2380. 	 *     array(
    2381. 

  2381. 	 *         'type'        => 'integer',
    2382. 

  2382. 	 *         'placeholder' => '%i',
    2383. 

  2383. 	 *         'default'     => {default integer},
    2384. 

  2384. 	 *         'min_value'   => new fNumber(-128),
    2385. 

  2385. 	 *         'max_value'   => new fNumber(127)
    2386. 

  2386. 	 *     ),
    2387. 

  2387. 	 *     '{table name}',
    2388. 

  2388. 	 *     '{column name}'
    2389. 

  2389. 	 * );
    2390. 

  2390. 	 * }}}
    2391. 

  2391. 	 * 
    2392. 

  2392. 	 * The `'comment'` element pulls from the database's column comment facility
    2393. 

  2393. 	 * with the exception of MSSQL and SQLite.
    2394. 

  2394. 	 * 
    2395. 

  2395. 	 * For MSSQL, the comment is pulled from the `MS_Description` extended
    2396. 

  2396. 	 * property, which can be added via the `Description` field in SQL Server
    2397. 

  2397. 	 * Management Studio, or via the `sp_addextendedproperty` stored procedure.
    2398. 

  2398. 	 * 
    2399. 

  2399. 	 * For SQLite, the comment is extracted from any SQL comment that is placed
    2400. 

  2400. 	 * at the end of the line on which the column is defined:
    2401. 

  2401. 	 * 
    2402. 

  2402. 	 * {{{
    2403. 

  2403. 	 * #!sql
    2404. 

  2404. 	 * CREATE TABLE users (
    2405. 

  2405. 	 *     user_id INTEGER PRIMARY KEY AUTOINCREMENT,
    2406. 

  2406. 	 *     name VARCHAR(200) NOT NULL -- This is the full name
    2407. 

  2407. 	 * );
    2408. 

  2408. 	 * }}}
    2409. 

  2409. 	 * 
    2410. 

  2410. 	 * For the SQLite `users` table defined above, the `name` column will have
    2411. 

  2411. 	 * the comment `This is the full name`.
    2412. 

  2412. 	 * 
    2413. 

  2413. 	 * @param  string $table    The table to get the column info for
    2414. 

  2414. 	 * @param  string $column   The column to get the info for
    2415. 

  2415. 	 * @param  string $element  The element to return: `'type'`, `'placeholder'`, `'not_null'`, `'default'`, `'valid_values'`, `'max_length'`, `'min_value'`, `'max_value'`, `'decimal_places'`, `'auto_increment'`, `'comment'`
    2416. 

  2416. 	 * @return mixed  The column info for the table/column/element specified - see method description for format
    2417. 

  2417. 	 */
    2418. 

  2418. 	public function getColumnInfo($table, $column=NULL, $element=NULL)
    2419. 

  2419. 	{
    2420. 

  2420. 		$table = strtolower($table);
    2421. 

  2421. 		if ($column !== NULL) {
    2422. 

  2422. 			$column = strtolower($column);
    2423. 

  2423. 		}
    2424. 

  2424. 

  2425. 		// Return the saved column info if possible
    2426. 

  2426. 		if (!$column && isset($this->merged_column_info[$table])) {
    2427. 

  2427. 			return $this->merged_column_info[$table];
    2428. 

  2428. 		}
    2429. 

  2429. 		if ($column && isset($this->merged_column_info[$table][$column])) {
    2430. 

  2430. 			if ($element !== NULL) {
    2431. 

  2431. 				if (!isset($this->merged_column_info[$table][$column][$element]) && !array_key_exists($element, $this->merged_column_info[$table][$column])) {
    2432. 

  2432. 					throw new fProgrammerException(
    2433. 

  2433. 						'The element specified, %1$s, is invalid. Must be one of: %2$s.',
    2434. 

  2434. 						$element,
    2435. 

  2435. 						join(', ', array('type', 'placeholder', 'not_null', 'default', 'valid_values', 'max_length', 'min_value', 'max_value', 'decimal_places', 'auto_increment'))
    2436. 

  2436. 					);	
    2437. 

  2437. 				}
    2438. 

  2438. 				return $this->merged_column_info[$table][$column][$element];
    2439. 

  2439. 			}
    2440. 

  2440. 			return $this->merged_column_info[$table][$column];
    2441. 

  2441. 		}
    2442. 

  2442. 		
    2443. 

  2443. 		if (!in_array($table, $this->getTables())) {
    2444. 

  2444. 			throw new fProgrammerException(
    2445. 

  2445. 				'The table specified, %s, does not exist in the database',
    2446. 

  2446. 				$table
    2447. 

  2447. 			);
    2448. 

  2448. 		}
    2449. 

  2449. 		
    2450. 

  2450. 		$this->fetchColumnInfo($table);
    2451. 

  2451. 		$this->mergeColumnInfo();
    2452. 

  2452. 		
    2453. 

  2453. 		if ($column && !isset($this->merged_column_info[$table][$column])) {
    2454. 

  2454. 			throw new fProgrammerException(
    2455. 

  2455. 				'The column specified, %1$s, does not exist in the table %2$s',
    2456. 

  2456. 				$column,
    2457. 

  2457. 				$table
    2458. 

  2458. 			);
    2459. 

  2459. 		}
    2460. 

  2460. 		
    2461. 

  2461. 		if ($column) {
    2462. 

  2462. 			if ($element) {
    2463. 

  2463. 				return $this->merged_column_info[$table][$column][$element];
    2464. 

  2464. 			}
    2465. 

  2465. 			
    2466. 

  2466. 			return $this->merged_column_info[$table][$column];
    2467. 

  2467. 		}
    2468. 

  2468. 		
    2469. 

  2469. 		return $this->merged_column_info[$table];
    2470. 

  2470. 	}
    2471. 

  2471. 	
    2472. 

  2472. 	
    2473. 

  2473. 	/**
    2474. 

  2474. 	 * Returns the databases on the current server
    2475. 

  2475. 	 * 
    2476. 

  2476. 	 * @return array  The databases on the current server
    2477. 

  2477. 	 */
    2478. 

  2478. 	public function getDatabases()
    2479. 

  2479. 	{
    2480. 

  2480. 		if ($this->databases !== NULL) {
    2481. 

  2481. 			return $this->databases;
    2482. 

  2482. 		}
    2483. 

  2483. 		
    2484. 

  2484. 		$this->databases = array();
    2485. 

  2485. 		
    2486. 

  2486. 		switch ($this->database->getType()) {
    2487. 

  2487. 			case 'mssql':
    2488. 

  2488. 				$sql = 'EXECUTE sp_databases';
    2489. 

  2489. 				break;
    2490. 

  2490. 			
    2491. 

  2491. 			case 'mysql':
    2492. 

  2492. 				$sql = 'SHOW DATABASES';
    2493. 

  2493. 				break;
    2494. 

  2494. 				
    2495. 

  2495. 			case 'oracle':
    2496. 

  2496. 				$sql = 'SELECT ora_database_name FROM dual';
    2497. 

  2497. 			
    2498. 

  2498. 			case 'postgresql':
    2499. 

  2499. 				$sql = "SELECT
    2500. 

  2500. 							datname
    2501. 

  2501. 						FROM
    2502. 

  2502. 							pg_database
    2503. 

  2503. 						ORDER BY
    2504. 

  2504. 							LOWER(datname)";
    2505. 

  2505. 				break;
    2506. 

  2506. 								
    2507. 

  2507. 			case 'db2':
    2508. 

  2508. 				$this->databases[] = strtolower($this->database->getDatabase());
    2509. 

  2509. 				return $this->databases;
    2510. 

  2510. 

  2511. 			case 'sqlite':
    2512. 

  2512. 				$this->databases[] = $this->database->getDatabase();
    2513. 

  2513. 				return $this->databases;
    2514. 

  2514. 		}
    2515. 

  2515. 		
    2516. 

  2516. 		$result = $this->database->query($sql);
    2517. 

  2517. 		
    2518. 

  2518. 		foreach ($result as $row) {
    2519. 

  2519. 			$keys = array_keys($row);
    2520. 

  2520. 			$this->databases[] = strtolower($row[$keys[0]]);
    2521. 

  2521. 		}
    2522. 

  2522. 		
    2523. 

  2523. 		if ($this->cache) {
    2524. 

  2524. 			$this->cache->set($this->makeCachePrefix() . 'databases', $this->databases);		
    2525. 

  2525. 		}
    2526. 

  2526. 		
    2527. 

  2527. 		return $this->databases;
    2528. 

  2528. 	}
    2529. 

  2529. 	
    2530. 

  2530. 	
    2531. 

  2531. 	/**
    2532. 

  2532. 	 * Returns a list of primary key, foreign key and unique key constraints for the table specified
    2533. 

  2533. 	 * 
    2534. 

  2534. 	 * The structure of the returned array is:
    2535. 

  2535. 	 * 
    2536. 

  2536. 	 * {{{
    2537. 

  2537. 	 * array(
    2538. 

  2538. 	 *      'primary' => array(
    2539. 

  2539. 	 *          {column name}, ...
    2540. 

  2540. 	 *      ),
    2541. 

  2541. 	 *      'unique'  => array(
    2542. 

  2542. 	 *          array(
    2543. 

  2543. 	 *              {column name}, ...
    2544. 

  2544. 	 *          ), ...
    2545. 

  2545. 	 *      ),
    2546. 

  2546. 	 *      'foreign' => array(
    2547. 

  2547. 	 *          array(
    2548. 

  2548. 	 *              'column'         => {column name},
    2549. 

  2549. 	 *              'foreign_table'  => {foreign table name},
    2550. 

  2550. 	 *              'foreign_column' => {foreign column name},
    2551. 

  2551. 	 *              'on_delete'      => {the ON DELETE action: 'no_action', 'restrict', 'cascade', 'set_null', or 'set_default'},
    2552. 

  2552. 	 *              'on_update'      => {the ON UPDATE action: 'no_action', 'restrict', 'cascade', 'set_null', or 'set_default'}
    2553. 

  2553. 	 *          ), ...
    2554. 

  2554. 	 *      )
    2555. 

  2555. 	 * )
    2556. 

  2556. 	 * }}}
    2557. 

  2557. 	 * 
    2558. 

  2558. 	 * @param  string $table     The table to return the keys for
    2559. 

  2559. 	 * @param  string $key_type  The type of key to return: `'primary'`, `'foreign'`, `'unique'`
    2560. 

  2560. 	 * @return array  An array of all keys, or just the type specified - see method description for format
    2561. 

  2561. 	 */
    2562. 

  2562. 	public function getKeys($table, $key_type=NULL)
    2563. 

  2563. 	{
    2564. 

  2564. 		$table           = strtolower($table);
    2565. 

  2565. 		$valid_key_types = array('primary', 'foreign', 'unique');
    2566. 

  2566. 		if ($key_type !== NULL && !in_array($key_type, $valid_key_types)) {
    2567. 

  2567. 			throw new fProgrammerException(
    2568. 

  2568. 				'The key type specified, %1$s, is invalid. Must be one of: %2$s.',
    2569. 

  2569. 				$key_type,
    2570. 

  2570. 				join(', ', $valid_key_types)
    2571. 

  2571. 			);
    2572. 

  2572. 		}
    2573. 

  2573. 		
    2574. 

  2574. 		// Return the saved column info if possible
    2575. 

  2575. 		if (!$key_type && isset($this->merged_keys[$table])) {
    2576. 

  2576. 			reset($this->merged_keys[$table]);
    2577. 

  2577. 			return $this->merged_keys[$table];
    2578. 

  2578. 		}
    2579. 

  2579. 		
    2580. 

  2580. 		if ($key_type && isset($this->merged_keys[$table][$key_type])) {
    2581. 

  2581. 			reset($this->merged_keys[$table][$key_type]);
    2582. 

  2582. 			return $this->merged_keys[$table][$key_type];
    2583. 

  2583. 		}
    2584. 

  2584. 		
    2585. 

  2585. 		if (!in_array($table, $this->getTables())) {
    2586. 

  2586. 			throw new fProgrammerException(
    2587. 

  2587. 				'The table specified, %s, does not exist in the database',
    2588. 

  2588. 				$table
    2589. 

  2589. 			);
    2590. 

  2590. 		}
    2591. 

  2591. 		
    2592. 

  2592. 		$this->fetchKeys();
    2593. 

  2593. 		$this->mergeKeys();
    2594. 

  2594. 		
    2595. 

  2595. 		if ($key_type) {
    2596. 

  2596. 			reset($this->merged_keys[$table][$key_type]);
    2597. 

  2597. 			return $this->merged_keys[$table][$key_type];
    2598. 

  2598. 		}
    2599. 

  2599. 		
    2600. 

  2600. 		reset($this->merged_keys[$table]);
    2601. 

  2601. 		return $this->merged_keys[$table];
    2602. 

  2602. 	}
    2603. 

  2603. 	
    2604. 

  2604. 	
    2605. 

  2605. 	/**
    2606. 

  2606. 	 * Returns a list of one-to-one, many-to-one, one-to-many and many-to-many relationships for the table specified
    2607. 

  2607. 	 * 
    2608. 

  2608. 	 * The structure of the returned array is:
    2609. 

  2609. 	 * 
    2610. 

  2610. 	 * {{{
    2611. 

  2611. 	 * array(
    2612. 

  2612. 	 *     'one-to-one' => array(
    2613. 

  2613. 	 *         array(
    2614. 

  2614. 	 *             'table'          => (string) {the name of the table this relationship is for},
    2615. 

  2615. 	 *             'column'         => (string) {the column in the specified table},
    2616. 

  2616. 	 *             'related_table'  => (string) {the related table},
    2617. 

  2617. 	 *             'related_column' => (string) {the related column},
    2618. 

  2618. 	 *             'on_delete'      => (string) {the ON DELETE action: 'no_action', 'restrict', 'cascade', 'set_null', or 'set_default'},
    2619. 

  2619. 	 *             'on_update'      => (string) {the ON UPDATE action: 'no_action', 'restrict', 'cascade', 'set_null', or 'set_default'}
    2620. 

  2620. 	 *         ), ...
    2621. 

  2621. 	 *     ),
    2622. 

  2622. 	 *     'many-to-one' => array(
    2623. 

  2623. 	 *         array(
    2624. 

  2624. 	 *             'table'          => (string) {the name of the table this relationship is for},
    2625. 

  2625. 	 *             'column'         => (string) {the column in the specified table},
    2626. 

  2626. 	 *             'related_table'  => (string) {the related table},
    2627. 

  2627. 	 *             'related_column' => (string) {the related column}
    2628. 

  2628. 	 *         ), ...
    2629. 

  2629. 	 *     ),
    2630. 

  2630. 	 *     'one-to-many' => array(
    2631. 

  2631. 	 *         array(
    2632. 

  2632. 	 *             'table'          => (string) {the name of the table this relationship is for},
    2633. 

  2633. 	 *             'column'         => (string) {the column in the specified table},
    2634. 

  2634. 	 *             'related_table'  => (string) {the related table},
    2635. 

  2635. 	 *             'related_column' => (string) {the related column},
    2636. 

  2636. 	 *             'on_delete'      => (string) {the ON DELETE action: 'no_action', 'restrict', 'cascade', 'set_null', or 'set_default'},
    2637. 

  2637. 	 *             'on_update'      => (string) {the ON UPDATE action: 'no_action', 'restrict', 'cascade', 'set_null', or 'set_default'}
    2638. 

  2638. 	 *         ), ...
    2639. 

  2639. 	 *     ),
    2640. 

  2640. 	 *     'many-to-many' => array(
    2641. 

  2641. 	 *         array(
    2642. 

  2642. 	 *             'table'               => (string) {the name of the table this relationship is for},
    2643. 

  2643. 	 *             'column'              => (string) {the column in the specified table},
    2644. 

  2644. 	 *             'related_table'       => (string) {the related table},
    2645. 

  2645. 	 *             'related_column'      => (string) {the related column},
    2646. 

  2646. 	 *             'join_table'          => (string) {the table that joins the specified table to the related table},
    2647. 

  2647. 	 *             'join_column'         => (string) {the column in the join table that references 'column'},
    2648. 

  2648. 	 *             'join_related_column' => (string) {the column in the join table that references 'related_column'},
    2649. 

  2649. 	 *             'on_delete'           => (string) {the ON DELETE action: 'no_action', 'restrict', 'cascade', 'set_null', or 'set_default'},
    2650. 

  2650. 	 *             'on_update'           => (string) {the ON UPDATE action: 'no_action', 'restrict', 'cascade', 'set_null', or 'set_default'}
    2651. 

  2651. 	 *         ), ...
    2652. 

  2652. 	 *     )
    2653. 

  2653. 	 * )
    2654. 

  2654. 	 * }}}
    2655. 

  2655. 	 * 
    2656. 

  2656. 	 * @param  string $table              The table to return the relationships for
    2657. 

  2657. 	 * @param  string $relationship_type  The type of relationship to return: `'one-to-one'`, `'many-to-one'`, `'one-to-many'`, `'many-to-many'`
    2658. 

  2658. 	 * @return array  An array of all relationships, or just the type specified - see method description for format
    2659. 

  2659. 	 */
    2660. 

  2660. 	public function getRelationships($table, $relationship_type=NULL)
    2661. 

  2661. 	{
    2662. 

  2662. 		$table = strtolower($table);
    2663. 

  2663. 

  2664. 		$valid_relationship_types = array('one-to-one', 'many-to-one', 'one-to-many', 'many-to-many');
    2665. 

  2665. 		if ($relationship_type !== NULL && !in_array($relationship_type, $valid_relationship_types)) {
    2666. 

  2666. 			throw new fProgrammerException(
    2667. 

  2667. 				'The relationship type specified, %1$s, is invalid. Must be one of: %2$s.',
    2668. 

  2668. 				$relationship_type,
    2669. 

  2669. 				join(', ', $valid_relationship_types)
    2670. 

  2670. 			);
    2671. 

  2671. 		}
    2672. 

  2672. 		
    2673. 

  2673. 		// Return the saved column info if possible
    2674. 

  2674. 		if (!$relationship_type && isset($this->relationships[$table])) {
    2675. 

  2675. 			return $this->relationships[$table];
    2676. 

  2676. 		}
    2677. 

  2677. 		
    2678. 

  2678. 		if ($relationship_type && isset($this->relationships[$table][$relationship_type])) {
    2679. 

  2679. 			return $this->relationships[$table][$relationship_type];
    2680. 

  2680. 		}
    2681. 

  2681. 		
    2682. 

  2682. 		if (!in_array($table, $this->getTables())) {
    2683. 

  2683. 			throw new fProgrammerException(
    2684. 

  2684. 				'The table specified, %s, does not exist in the database',
    2685. 

  2685. 				$table
    2686. 

  2686. 			);
    2687. 

  2687. 		}
    2688. 

  2688. 		
    2689. 

  2689. 		$this->fetchKeys();
    2690. 

  2690. 		$this->mergeKeys();
    2691. 

  2691. 		
    2692. 

  2692. 		if ($relationship_type) {
    2693. 

  2693. 			return $this->relationships[$table][$relationship_type];
    2694. 

  2694. 		}
    2695. 

  2695. 		
    2696. 

  2696. 		return $this->relationships[$table];
    2697. 

  2697. 	}
    2698. 

  2698. 	
    2699. 

  2699. 	
    2700. 

  2700. 	/**
    2701. 

  2701. 	 * Returns the tables in the current database
    2702. 

  2702. 	 * 
    2703. 

  2703. 	 * @param  boolean|string  $creation_order  `TRUE` to return in a valid table creation order, or a table name to return that table and any tables that depend on it, in table creation order
    2704. 

  2704. 	 * @return array  The tables in the current database, all converted to lowercase
    2705. 

  2705. 	 */
    2706. 

  2706. 	public function getTables($creation_order=NULL)
    2707. 

  2707. 	{
    2708. 

  2708. 		if ($creation_order) {
    2709. 

  2709. 			return $this->determineTableCreationOrder(is_bool($creation_order) ? NULL : $creation_order);
    2710. 

  2710. 		}
    2711. 

  2711. 		
    2712. 

  2712. 		if ($this->tables !== NULL) {
    2713. 

  2713. 			return $this->tables;
    2714. 

  2714. 		}
    2715. 

  2715. 		
    2716. 

  2716. 		switch ($this->database->getType()) {
    2717. 

  2717. 			case 'db2':
    2718. 

  2718. 				$sql = "SELECT
    2719. 

  2719. 							LOWER(RTRIM(TABSCHEMA)) AS \"schema\",
    2720. 

  2720. 							LOWER(TABNAME) AS \"table\"
    2721. 

  2721. 						FROM
    2722. 

  2722. 							SYSCAT.TABLES
    2723. 

  2723. 						WHERE
    2724. 

  2724. 							TYPE = 'T' AND
    2725. 

  2725. 							TABSCHEMA != 'SYSIBM' AND
    2726. 

  2726. 							DEFINER != 'SYSIBM' AND
    2727. 

  2727. 							TABSCHEMA != 'SYSTOOLS' AND
    2728. 

  2728. 							DEFINER != 'SYSTOOLS'
    2729. 

  2729. 						ORDER BY
    2730. 

  2730. 							LOWER(TABNAME)";
    2731. 

  2731. 				break;
    2732. 

  2732. 				
    2733. 

  2733. 			case 'mssql':
    2734. 

  2734. 				$sql = "SELECT
    2735. 

  2735. 							TABLE_SCHEMA AS \"schema\",
    2736. 

  2736. 							TABLE_NAME AS \"table\"
    2737. 

  2737. 						FROM
    2738. 

  2738. 							INFORMATION_SCHEMA.TABLES
    2739. 

  2739. 						WHERE
    2740. 

  2740. 							TABLE_NAME != 'sysdiagrams'
    2741. 

  2741. 						ORDER BY
    2742. 

  2742. 							LOWER(TABLE_NAME)";
    2743. 

  2743. 				break;
    2744. 

  2744. 			
    2745. 

  2745. 			case 'mysql':
    2746. 

  2746. 				if (version_compare($this->database->getVersion(), 5, '<')) {
    2747. 

  2747. 					$sql = 'SHOW TABLES';
    2748. 

  2748. 				} else {
    2749. 

  2749. 					$sql = "SHOW FULL TABLES WHERE table_type = 'BASE TABLE'";	
    2750. 

  2750. 				}
    2751. 

  2751. 				break;
    2752. 

  2752. 			
    2753. 

  2753. 			case 'oracle':
    2754. 

  2754. 				$sql = "SELECT
    2755. 

  2755. 							LOWER(OWNER) AS \"SCHEMA\",
    2756. 

  2756. 							LOWER(TABLE_NAME) AS \"TABLE\"
    2757. 

  2757. 						FROM
    2758. 

  2758. 							ALL_TABLES
    2759. 

  2759. 						WHERE
    2760. 

  2760. 							OWNER NOT IN (
    2761. 

  2761. 								'SYS',
    2762. 

  2762. 								'SYSTEM',
    2763. 

  2763. 								'OUTLN',
    2764. 

  2764. 								'ANONYMOUS',
    2765. 

  2765. 								'AURORA\$ORB\$UNAUTHENTICATED',
    2766. 

  2766. 								'AWR_STAGE',
    2767. 

  2767. 								'CSMIG',
    2768. 

  2768. 								'CTXSYS',
    2769. 

  2769. 								'DBSNMP',
    2770. 

  2770. 								'DIP',
    2771. 

  2771. 								'DMSYS',
    2772. 

  2772. 								'DSSYS',
    2773. 

  2773. 								'EXFSYS',
    2774. 

  2774. 								'FLOWS_020100',
    2775. 

  2775. 								'FLOWS_FILES',
    2776. 

  2776. 								'LBACSYS',
    2777. 

  2777. 								'MDSYS',
    2778. 

  2778. 								'ORACLE_OCM',
    2779. 

  2779. 								'ORDPLUGINS',
    2780. 

  2780. 								'ORDSYS',
    2781. 

  2781. 								'PERFSTAT',
    2782. 

  2782. 								'TRACESVR',
    2783. 

  2783. 								'TSMSYS',
    2784. 

  2784. 								'XDB'
    2785. 

  2785. 							) AND
    2786. 

  2786. 							DROPPED = 'NO' 
    2787. 

  2787. 						ORDER BY
    2788. 

  2788. 							TABLE_NAME ASC";
    2789. 

  2789. 				break;
    2790. 

  2790. 			
    2791. 

  2791. 			case 'postgresql':
    2792. 

  2792. 				$sql = "SELECT
    2793. 

  2793. 							 schemaname AS \"schema\",
    2794. 

  2794. 							 tablename as \"table\"
    2795. 

  2795. 						FROM
    2796. 

  2796. 							 pg_tables
    2797. 

  2797. 						WHERE
    2798. 

  2798. 							 tablename !~ '^(pg|sql)_'
    2799. 

  2799. 						ORDER BY
    2800. 

  2800. 							LOWER(tablename)";
    2801. 

  2801. 				break;
    2802. 

  2802. 								
    2803. 

  2803. 			case 'sqlite':
    2804. 

  2804. 				$sql = "SELECT
    2805. 

  2805. 							name
    2806. 

  2806. 						FROM
    2807. 

  2807. 							sqlite_master
    2808. 

  2808. 						WHERE
    2809. 

  2809. 							type = 'table' AND
    2810. 

  2810. 							name NOT LIKE 'sqlite_%'
    2811. 

  2811. 						ORDER BY
    2812. 

  2812. 							name ASC";
    2813. 

  2813. 				break;
    2814. 

  2814. 		}
    2815. 

  2815. 		
    2816. 

  2816. 		$result = $this->database->query($sql);
    2817. 

  2817. 		
    2818. 

  2818. 		$this->tables = array();
    2819. 

  2819. 		
    2820. 

  2820. 		// For databases with schemas we only include the schema
    2821. 

  2821. 		// name if there are conflicting table names
    2822. 

  2822. 		if (!in_array($this->database->getType(), array('mysql', 'sqlite'))) {
    2823. 

  2823. 			
    2824. 

  2824. 			$default_schema_map = array(
    2825. 

  2825. 				'db2'        => strtolower($this->database->getUsername()),
    2826. 

  2826. 				'mssql'      => 'dbo',
    2827. 

  2827. 				'oracle'     => strtolower($this->database->getUsername()),
    2828. 

  2828. 				'postgresql' => 'public'
    2829. 

  2829. 			);
    2830. 

  2830. 			
    2831. 

  2831. 			$default_schema = $default_schema_map[$this->database->getType()];
    2832. 

  2832. 			
    2833. 

  2833. 			foreach ($result as $row) {
    2834. 

  2834. 				if ($row['schema'] == $default_schema) {
    2835. 

  2835. 					$this->tables[] = strtolower($row['table']);	
    2836. 

  2836. 				} else {
    2837. 

  2837. 					$this->tables[] = strtolower($row['schema'] . '.' . $row['table']);	
    2838. 

  2838. 				}
    2839. 

  2839. 			}
    2840. 

  2840. 				
    2841. 

  2841. 		// SQLite and MySQL don't support schemas
    2842. 

  2842. 		} else {
    2843. 

  2843. 			foreach ($result as $row) {
    2844. 

  2844. 				$keys = array_keys($row);
    2845. 

  2845. 				$this->tables[] = strtolower($row[$keys[0]]);
    2846. 

  2846. 			}
    2847. 

  2847. 		}
    2848. 

  2848. 		
    2849. 

  2849. 		sort($this->tables);
    2850. 

  2850. 		
    2851. 

  2851. 		if ($this->cache) {
    2852. 

  2852. 			$this->cache->set($this->makeCachePrefix() . 'tables', $this->tables);
    2853. 

  2853. 		}
    2854. 

  2854. 		
    2855. 

  2855. 		return $this->tables;
    2856. 

  2856. 	}
    2857. 

  2857. 		
    2858. 

  2858. 	
    2859. 

  2859. 	/**
    2860. 

  2860. 	 * Determines if a table is a joining table
    2861. 

  2861. 	 * 
    2862. 

  2862. 	 * @param  string $table  The table to check
    2863. 

  2863. 	 * @return boolean  If the table is a joining table
    2864. 

  2864. 	 */
    2865. 

  2865. 	private function isJoiningTable($table)
    2866. 

  2866. 	{
    2867. 

  2867. 		$primary_key_columns = $this->merged_keys[$table]['primary'];
    2868. 

  2868. 		
    2869. 

  2869. 		if (sizeof($primary_key_columns) != 2) {
    2870. 

  2870. 			return FALSE;	
    2871. 

  2871. 		}
    2872. 

  2872. 		
    2873. 

  2873. 		if (empty($this->merged_column_info[$table])) {
    2874. 

  2874. 			$this->getColumnInfo($table);	
    2875. 

  2875. 		}
    2876. 

  2876. 		if (sizeof($this->merged_column_info[$table]) != 2) {
    2877. 

  2877. 			return FALSE;	
    2878. 

  2878. 		}
    2879. 

  2879. 		
    2880. 

  2880. 		$foreign_key_columns = array();
    2881. 

  2881. 		foreach ($this->merged_keys[$table]['foreign'] as $key) {
    2882. 

  2882. 			$foreign_key_columns[] = $key['column'];
    2883. 

  2883. 		}
    2884. 

  2884. 		
    2885. 

  2885. 		return sizeof($foreign_key_columns) == 2 && !array_diff($foreign_key_columns, $primary_key_columns);
    2886. 

  2886. 	}
    2887. 

  2887. 	
    2888. 

  2888. 	
    2889. 

  2889. 	/**
    2890. 

  2890. 	 * Creates a unique cache prefix to help prevent cache conflicts
    2891. 

  2891. 	 * 
    2892. 

  2892. 	 * @return string  The cache prefix to use
    2893. 

  2893. 	 */
    2894. 

  2894. 	private function makeCachePrefix()
    2895. 

  2895. 	{
    2896. 

  2896. 		if (!$this->cache_prefix) {
    2897. 

  2897. 			$prefix  = 'fSchema::' . $this->database->getType() . '::';
    2898. 

  2898. 			if ($this->database->getHost()) {
    2899. 

  2899. 				$prefix .= $this->database->getHost() . '::';
    2900. 

  2900. 			}
    2901. 

  2901. 			if ($this->database->getPort()) {
    2902. 

  2902. 				$prefix .= $this->database->getPort() . '::';
    2903. 

  2903. 			}
    2904. 

  2904. 			$prefix .= $this->database->getDatabase() . '::';
    2905. 

  2905. 			if ($this->database->getUsername()) {
    2906. 

  2906. 				$prefix .= $this->database->getUsername() . '::';
    2907. 

  2907. 			}
    2908. 

  2908. 			$this->cache_prefix = $prefix;
    2909. 

  2909. 		}
    2910. 

  2910. 		
    2911. 

  2911. 		return $this->cache_prefix;
    2912. 

  2912. 	}
    2913. 

  2913. 	
    2914. 

  2914. 	
    2915. 

  2915. 	/**
    2916. 

  2916. 	 * Merges the column info with the column info override
    2917. 

  2917. 	 * 
    2918. 

  2918. 	 * @return void
    2919. 

  2919. 	 */
    2920. 

  2920. 	private function mergeColumnInfo()
    2921. 

  2921. 	{
    2922. 

  2922. 		$this->merged_column_info = $this->column_info;
    2923. 

  2923. 		
    2924. 

  2924. 		foreach ($this->column_info_override as $table => $columns) {
    2925. 

  2925. 			// Remove a table if the columns are set to NULL
    2926. 

  2926. 			if ($columns === NULL) {
    2927. 

  2927. 				unset($this->merged_column_info[$table]);
    2928. 

  2928. 				continue;	
    2929. 

  2929. 			}
    2930. 

  2930. 			
    2931. 

  2931. 			if (!isset($this->merged_column_info[$table])) {
    2932. 

  2932. 				$this->merged_column_info[$table] = array();
    2933. 

  2933. 			}
    2934. 

  2934. 			
    2935. 

  2935. 			foreach ($columns as $column => $info) {
    2936. 

  2936. 				// Remove a column if it is set to NULL
    2937. 

  2937. 				if ($info === NULL) {
    2938. 

  2938. 					unset($this->merged_column_info[$table][$column]);	
    2939. 

  2939. 					continue;
    2940. 

  2940. 				}
    2941. 

  2941. 				
    2942. 

  2942. 				if (!isset($this->merged_column_info[$table][$column])) {
    2943. 

  2943. 					$this->merged_column_info[$table][$column] = array();
    2944. 

  2944. 				}
    2945. 

  2945. 				
    2946. 

  2946. 				$this->merged_column_info[$table][$column] = array_merge($this->merged_column_info[$table][$column], $info);
    2947. 

  2947. 			}
    2948. 

  2948. 		}
    2949. 

  2949. 		
    2950. 

  2950. 		$optional_elements = array(
    2951. 

  2951. 			'not_null',
    2952. 

  2952. 			'default',
    2953. 

  2953. 			'valid_values',
    2954. 

  2954. 			'max_length',
    2955. 

  2955. 			'max_value',
    2956. 

  2956. 			'min_value',
    2957. 

  2957. 			'decimal_places',
    2958. 

  2958. 			'auto_increment',
    2959. 

  2959. 			'comment'
    2960. 

  2960. 		);
    2961. 

  2961. 		
    2962. 

  2962. 		foreach ($this->merged_column_info as $table => $column_array) {
    2963. 

  2963. 			foreach ($column_array as $column => $info) {
    2964. 

  2964. 				if (empty($info['type'])) {
    2965. 

  2965. 					throw new fProgrammerException('The data type for the column %1$s is empty', $column);	
    2966. 

  2966. 				}
    2967. 

  2967. 				
    2968. 

  2968. 				if (empty($this->merged_column_info[$table][$column]['placeholder'])) {
    2969. 

  2969. 					$this->merged_column_info[$table][$column]['placeholder'] = strtr(
    2970. 

  2970. 						$info['type'],
    2971. 

  2971. 						array(
    2972. 

  2972. 							'blob'      => '%l',
    2973. 

  2973. 							'boolean'   => '%b',
    2974. 

  2974. 							'date'      => '%d',
    2975. 

  2975. 							'float'     => '%f',
    2976. 

  2976. 							'integer'   => '%i',
    2977. 

  2977. 							'char'      => '%s',
    2978. 

  2978. 							'text'      => '%s',
    2979. 

  2979. 							'varchar'   => '%s',
    2980. 

  2980. 							'time'      => '%t',
    2981. 

  2981. 							'timestamp' => '%p'
    2982. 

  2982. 						)
    2983. 

  2983. 					);
    2984. 

  2984. 				}
    2985. 

  2985. 				
    2986. 

  2986. 				foreach ($optional_elements as $element) {
    2987. 

  2987. 					if (!isset($this->merged_column_info[$table][$column][$element])) {
    2988. 

  2988. 						$this->merged_column_info[$table][$column][$element] = ($element == 'auto_increment') ? FALSE : NULL;
    2989. 

  2989. 					}
    2990. 

  2990. 				}
    2991. 

  2991. 			}
    2992. 

  2992. 		}
    2993. 

  2993. 		
    2994. 

  2994. 		if ($this->cache) {
    2995. 

  2995. 			$this->cache->set($this->makeCachePrefix() . 'merged_column_info', $this->merged_column_info);	
    2996. 

  2996. 		}
    2997. 

  2997. 	}
    2998. 

  2998. 		
    2999. 

  2999. 	
    3000. 

  3000. 	/**
    3001. 

  3001. 	 * Merges the keys with the keys override
    3002. 

  3002. 	 * 
    3003. 

  3003. 	 * @return void
    3004. 

  3004. 	 */
    3005. 

  3005. 	private function mergeKeys()
    3006. 

  3006. 	{
    3007. 

  3007. 		// Handle the database and override key info
    3008. 

  3008. 		$this->merged_keys = $this->keys;
    3009. 

  3009. 		
    3010. 

  3010. 		foreach ($this->keys_override as $table => $info) {
    3011. 

  3011. 			if (!isset($this->merged_keys[$table])) {
    3012. 

  3012. 				$this->merged_keys[$table] = array();
    3013. 

  3013. 			}
    3014. 

  3014. 			$this->merged_keys[$table] = array_merge($this->merged_keys[$table], $info);
    3015. 

  3015. 		}
    3016. 

  3016. 		
    3017. 

  3017. 		if ($this->cache) {
    3018. 

  3018. 			$this->cache->set($this->makeCachePrefix() . 'merged_keys', $this->merged_keys);	
    3019. 

  3019. 		}
    3020. 

  3020. 		
    3021. 

  3021. 		$this->findRelationships();
    3022. 

  3022. 	}
    3023. 

  3023. 	
    3024. 

  3024. 	
    3025. 

  3025. 	/**
    3026. 

  3026. 	 * Allows overriding of column info
    3027. 

  3027. 	 * 
    3028. 

  3028. 	 * Performs an array merge with the column info detected from the database.
    3029. 

  3029. 	 * 
    3030. 

  3030. 	 * To erase a whole table, set the `$column_info` to `NULL`. To erase a
    3031. 

  3031. 	 * column, set the `$column_info` for that column to `NULL`.
    3032. 

  3032. 	 * 
    3033. 

  3033. 	 * If the `$column_info` parameter is not `NULL`, it should be an
    3034. 

  3034. 	 * associative array containing one or more of the following keys. Please
    3035. 

  3035. 	 * see ::getColumnInfo() for a description of each.
    3036. 

  3036. 	 *  - `'type'`
    3037. 

  3037. 	 *  - `'placeholder'`
    3038. 

  3038. 	 *  - `'not_null'`
    3039. 

  3039. 	 *  - `'default'`
    3040. 

  3040. 	 *  - `'valid_values'`
    3041. 

  3041. 	 *  - `'max_length'`
    3042. 

  3042. 	 *  - `'min_value'`
    3043. 

  3043. 	 *  - `'max_value'`
    3044. 

  3044. 	 *  - `'decimal_places'`
    3045. 

  3045. 	 *  - `'auto_increment'`
    3046. 

  3046. 	 *  - `'comment'`
    3047. 

  3047. 	 * 
    3048. 

  3048. 	 * The following keys may be set to `NULL`:
    3049. 

  3049. 	 *  - `'not_null'`
    3050. 

  3050. 	 *  - `'default'`
    3051. 

  3051. 	 *  - `'valid_values'`
    3052. 

  3052. 	 *  - `'max_length'`
    3053. 

  3053. 	 *  - `'min_value'`
    3054. 

  3054. 	 *  - `'max_value'`
    3055. 

  3055. 	 *  - `'decimal_places'`
    3056. 

  3056. 	 *  - `'comment'`
    3057. 

  3057. 	 *  
    3058. 

  3058. 	 * The key `'auto_increment'` should be a boolean.
    3059. 

  3059. 	 * 
    3060. 

  3060. 	 * The `'type'` key should be one of:
    3061. 

  3061. 	 *  - `'blob'`
    3062. 

  3062. 	 *  - `'boolean'`
    3063. 

  3063. 	 *  - `'char'`
    3064. 

  3064. 	 *  - `'date'`
    3065. 

  3065. 	 *  - `'float'`
    3066. 

  3066. 	 *  - `'integer'`
    3067. 

  3067. 	 *  - `'text'`
    3068. 

  3068. 	 *  - `'time'`
    3069. 

  3069. 	 *  - `'timestamp'`
    3070. 

  3070. 	 *  - `'varchar'`
    3071. 

  3071. 	 * 
    3072. 

  3072. 	 * @param  array  $column_info  The modified column info - see method description for format
    3073. 

  3073. 	 * @param  string $table        The table to override
    3074. 

  3074. 	 * @param  string $column       The column to override
    3075. 

  3075. 	 * @return void
    3076. 

  3076. 	 */
    3077. 

  3077. 	public function setColumnInfoOverride($column_info, $table, $column=NULL)
    3078. 

  3078. 	{
    3079. 

  3079. 		$table = strotlower($table);
    3080. 

  3080. 		if ($column !== NULL) {
    3081. 

  3081. 			$column = strtolower($column);
    3082. 

  3082. 		}
    3083. 

  3083. 

  3084. 		if (!isset($this->column_info_override[$table])) {
    3085. 

  3085. 			$this->column_info_override[$table] = array();
    3086. 

  3086. 		}
    3087. 

  3087. 		
    3088. 

  3088. 		if (!empty($column)) {
    3089. 

  3089. 			$this->column_info_override[$table][$column] = $column_info;
    3090. 

  3090. 		} else {
    3091. 

  3091. 			$this->column_info_override[$table] = $column_info;
    3092. 

  3092. 		}
    3093. 

  3093. 		
    3094. 

  3094. 		$this->fetchColumnInfo($table);
    3095. 

  3095. 		$this->mergeColumnInfo();
    3096. 

  3096. 	}
    3097. 

  3097. 	
    3098. 

  3098. 	
    3099. 

  3099. 	/**
    3100. 

  3100. 	 * Allows overriding of key info. Replaces existing info, so be sure to provide full key info for type selected or all types.
    3101. 

  3101. 	 * 
    3102. 

  3102. 	 * @param  array  $keys      The modified keys - see ::getKeys() for format
    3103. 

  3103. 	 * @param  string $table     The table to override
    3104. 

  3104. 	 * @param  string $key_type  The key type to override: `'primary'`, `'foreign'`, `'unique'`
    3105. 

  3105. 	 * @return void
    3106. 

  3106. 	 */
    3107. 

  3107. 	public function setKeysOverride($keys, $table, $key_type=NULL)
    3108. 

  3108. 	{
    3109. 

  3109. 		$table = strtolower($table);
    3110. 

  3110. 

  3111. 		$valid_key_types = array('primary', 'foreign', 'unique');
    3112. 

  3112. 		if (!in_array($key_type, $valid_key_types)) {
    3113. 

  3113. 			throw new fProgrammerException(
    3114. 

  3114. 				'The key type specified, %1$s, is invalid. Must be one of: %2$s.',
    3115. 

  3115. 				$key_type,
    3116. 

  3116. 				join(', ', $valid_key_types)
    3117. 

  3117. 			);
    3118. 

  3118. 		}
    3119. 

  3119. 		
    3120. 

  3120. 		if (!isset($this->keys_override[$table])) {
    3121. 

  3121. 			$this->keys_override[$table] = array();
    3122. 

  3122. 		}
    3123. 

  3123. 		
    3124. 

  3124. 		if (!empty($key_type)) {
    3125. 

  3125. 			$this->keys_override[$table][$key_type] = $keys;
    3126. 

  3126. 		} else {
    3127. 

  3127. 			$this->keys_override[$table] = $keys;
    3128. 

  3128. 		}
    3129. 

  3129. 		
    3130. 

  3130. 		$this->fetchKeys();
    3131. 

  3131. 		$this->mergeKeys();
    3132. 

  3132. 	}
    3133. 

  3133. }
    3134. 

  3134. 

  3135. 

  3136. 

  3137. /**
    3138. 

  3138.  * Copyright (c) 2007-2012 Will Bond <will@flourishlib.com>
    3139. 

  3139.  * 
    3140. 

  3140.  * Permission is hereby granted, free of charge, to any person obtaining a copy
    3141. 

  3141.  * of this software and associated documentation files (the "Software"), to deal
    3142. 

  3142.  * in the Software without restriction, including without limitation the rights
    3143. 

  3143.  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    3144. 

  3144.  * copies of the Software, and to permit persons to whom the Software is
    3145. 

  3145.  * furnished to do so, subject to the following conditions:
    3146. 

  3146.  * 
    3147. 

  3147.  * The above copyright notice and this permission notice shall be included in
    3148. 

  3148.  * all copies or substantial portions of the Software.
    3149. 

  3149.  * 
    3150. 

  3150.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    3151. 

  3151.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    3152. 

  3152.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    3153. 

  3153.  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    3154. 

  3154.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    3155. 

  3155.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
    3156. 

  3156.  * THE SOFTWARE.
    3157. 

  3157.  */
    3158.