Completed
Push — 4.1 ( 0565a2...a83f91 )
by David
57s
created
src/Mouf/Database/TDBM/InnerResultIterator.php 1 patch
Indentation   +263 added lines, -263 removed lines patch added patch discarded remove patch
@@ -29,267 +29,267 @@
 block discarded – undo
29 29
  */
30 30
 class InnerResultIterator implements \Iterator, \Countable, \ArrayAccess
31 31
 {
32
-    /**
33
-     * @var Statement
34
-     */
35
-    protected $statement;
36
-
37
-    protected $fetchStarted = false;
38
-    private $objectStorage;
39
-    private $className;
40
-
41
-    private $tdbmService;
42
-    private $magicSql;
43
-    private $parameters;
44
-    private $limit;
45
-    private $offset;
46
-    private $columnDescriptors;
47
-    private $magicQuery;
48
-
49
-    /**
50
-     * The key of the current retrieved object.
51
-     *
52
-     * @var int
53
-     */
54
-    protected $key = -1;
55
-
56
-    protected $current = null;
57
-
58
-    private $databasePlatform;
59
-
60
-    /**
61
-     * @var LoggerInterface
62
-     */
63
-    private $logger;
64
-
65
-    public function __construct($magicSql, array $parameters, $limit, $offset, array $columnDescriptors, $objectStorage, $className, TDBMService $tdbmService, MagicQuery $magicQuery, LoggerInterface $logger)
66
-    {
67
-        $this->magicSql = $magicSql;
68
-        $this->objectStorage = $objectStorage;
69
-        $this->className = $className;
70
-        $this->tdbmService = $tdbmService;
71
-        $this->parameters = $parameters;
72
-        $this->limit = $limit;
73
-        $this->offset = $offset;
74
-        $this->columnDescriptors = $columnDescriptors;
75
-        $this->magicQuery = $magicQuery;
76
-        $this->databasePlatform = $this->tdbmService->getConnection()->getDatabasePlatform();
77
-        $this->logger = $logger;
78
-    }
79
-
80
-    protected function executeQuery()
81
-    {
82
-        $sql = $this->magicQuery->build($this->magicSql, $this->parameters);
83
-        $sql = $this->tdbmService->getConnection()->getDatabasePlatform()->modifyLimitQuery($sql, $this->limit, $this->offset);
84
-
85
-        $this->logger->debug('Running SQL request: '.$sql);
86
-
87
-        $this->statement = $this->tdbmService->getConnection()->executeQuery($sql, $this->parameters);
88
-
89
-        $this->fetchStarted = true;
90
-    }
91
-
92
-    /**
93
-     * Counts found records (this is the number of records fetched, taking into account the LIMIT and OFFSET settings).
94
-     *
95
-     * @return int
96
-     */
97
-    public function count()
98
-    {
99
-        if (!$this->fetchStarted) {
100
-            $this->executeQuery();
101
-        }
102
-
103
-        return $this->statement->rowCount();
104
-    }
105
-
106
-    /**
107
-     * Fetches record at current cursor.
108
-     *
109
-     * @return AbstractTDBMObject|null
110
-     */
111
-    public function current()
112
-    {
113
-        return $this->current;
114
-    }
115
-
116
-    /**
117
-     * Returns the current result's key.
118
-     *
119
-     * @return int
120
-     */
121
-    public function key()
122
-    {
123
-        return $this->key;
124
-    }
125
-
126
-    /**
127
-     * Advances the cursor to the next result.
128
-     * Casts the database result into one (or several) beans.
129
-     */
130
-    public function next()
131
-    {
132
-        $row = $this->statement->fetch(\PDO::FETCH_NUM);
133
-        if ($row) {
134
-
135
-            // array<tablegroup, array<table, array<column, value>>>
136
-            $beansData = [];
137
-            foreach ($row as $i => $value) {
138
-                $columnDescriptor = $this->columnDescriptors[$i];
139
-
140
-                if ($columnDescriptor['tableGroup'] === null) {
141
-                    // A column can have no tableGroup (if it comes from an ORDER BY expression)
142
-                    continue;
143
-                }
144
-
145
-                // Let's cast the value according to its type
146
-                $value = $columnDescriptor['type']->convertToPHPValue($value, $this->databasePlatform);
147
-
148
-                $beansData[$columnDescriptor['tableGroup']][$columnDescriptor['table']][$columnDescriptor['column']] = $value;
149
-            }
150
-
151
-            $reflectionClassCache = [];
152
-            $firstBean = true;
153
-            foreach ($beansData as $beanData) {
154
-
155
-                // Let's find the bean class name associated to the bean.
156
-
157
-                list($actualClassName, $mainBeanTableName, $tablesUsed) = $this->tdbmService->_getClassNameFromBeanData($beanData);
158
-
159
-                if ($this->className !== null) {
160
-                    $actualClassName = $this->className;
161
-                }
162
-
163
-                // Let's filter out the beanData that is not used (because it belongs to a part of the hierarchy that is not fetched:
164
-                foreach ($beanData as $tableName => $descriptors) {
165
-                    if (!in_array($tableName, $tablesUsed)) {
166
-                        unset($beanData[$tableName]);
167
-                    }
168
-                }
169
-
170
-                // Must we create the bean? Let's see in the cache if we have a mapping DbRow?
171
-                // Let's get the first object mapping a row:
172
-                // We do this loop only for the first table
173
-
174
-                $primaryKeys = $this->tdbmService->_getPrimaryKeysFromObjectData($mainBeanTableName, $beanData[$mainBeanTableName]);
175
-                $hash = $this->tdbmService->getObjectHash($primaryKeys);
176
-
177
-                if ($this->objectStorage->has($mainBeanTableName, $hash)) {
178
-                    $dbRow = $this->objectStorage->get($mainBeanTableName, $hash);
179
-                    $bean = $dbRow->getTDBMObject();
180
-                } else {
181
-                    // Let's construct the bean
182
-                    if (!isset($reflectionClassCache[$actualClassName])) {
183
-                        $reflectionClassCache[$actualClassName] = new \ReflectionClass($actualClassName);
184
-                    }
185
-                    // Let's bypass the constructor when creating the bean!
186
-                    $bean = $reflectionClassCache[$actualClassName]->newInstanceWithoutConstructor();
187
-                    $bean->_constructFromData($beanData, $this->tdbmService);
188
-                }
189
-
190
-                // The first bean is the one containing the main table.
191
-                if ($firstBean) {
192
-                    $firstBean = false;
193
-                    $this->current = $bean;
194
-                }
195
-            }
196
-
197
-            ++$this->key;
198
-        } else {
199
-            $this->current = null;
200
-        }
201
-    }
202
-
203
-    /**
204
-     * Moves the cursor to the beginning of the result set.
205
-     */
206
-    public function rewind()
207
-    {
208
-        $this->executeQuery();
209
-        $this->key = -1;
210
-        $this->next();
211
-    }
212
-    /**
213
-     * Checks if the cursor is reading a valid result.
214
-     *
215
-     * @return bool
216
-     */
217
-    public function valid()
218
-    {
219
-        return $this->current !== null;
220
-    }
221
-
222
-    /**
223
-     * Whether a offset exists.
224
-     *
225
-     * @link http://php.net/manual/en/arrayaccess.offsetexists.php
226
-     *
227
-     * @param mixed $offset <p>
228
-     *                      An offset to check for.
229
-     *                      </p>
230
-     *
231
-     * @return bool true on success or false on failure.
232
-     *              </p>
233
-     *              <p>
234
-     *              The return value will be casted to boolean if non-boolean was returned
235
-     *
236
-     * @since 5.0.0
237
-     */
238
-    public function offsetExists($offset)
239
-    {
240
-        throw new TDBMInvalidOperationException('You cannot access this result set via index because it was fetched in CURSOR mode. Use ARRAY_MODE instead.');
241
-    }
242
-
243
-    /**
244
-     * Offset to retrieve.
245
-     *
246
-     * @link http://php.net/manual/en/arrayaccess.offsetget.php
247
-     *
248
-     * @param mixed $offset <p>
249
-     *                      The offset to retrieve.
250
-     *                      </p>
251
-     *
252
-     * @return mixed Can return all value types
253
-     *
254
-     * @since 5.0.0
255
-     */
256
-    public function offsetGet($offset)
257
-    {
258
-        throw new TDBMInvalidOperationException('You cannot access this result set via index because it was fetched in CURSOR mode. Use ARRAY_MODE instead.');
259
-    }
260
-
261
-    /**
262
-     * Offset to set.
263
-     *
264
-     * @link http://php.net/manual/en/arrayaccess.offsetset.php
265
-     *
266
-     * @param mixed $offset <p>
267
-     *                      The offset to assign the value to.
268
-     *                      </p>
269
-     * @param mixed $value  <p>
270
-     *                      The value to set.
271
-     *                      </p>
272
-     *
273
-     * @since 5.0.0
274
-     */
275
-    public function offsetSet($offset, $value)
276
-    {
277
-        throw new TDBMInvalidOperationException('You can set values in a TDBM result set.');
278
-    }
279
-
280
-    /**
281
-     * Offset to unset.
282
-     *
283
-     * @link http://php.net/manual/en/arrayaccess.offsetunset.php
284
-     *
285
-     * @param mixed $offset <p>
286
-     *                      The offset to unset.
287
-     *                      </p>
288
-     *
289
-     * @since 5.0.0
290
-     */
291
-    public function offsetUnset($offset)
292
-    {
293
-        throw new TDBMInvalidOperationException('You can unset values in a TDBM result set.');
294
-    }
32
+	/**
33
+	 * @var Statement
34
+	 */
35
+	protected $statement;
36
+
37
+	protected $fetchStarted = false;
38
+	private $objectStorage;
39
+	private $className;
40
+
41
+	private $tdbmService;
42
+	private $magicSql;
43
+	private $parameters;
44
+	private $limit;
45
+	private $offset;
46
+	private $columnDescriptors;
47
+	private $magicQuery;
48
+
49
+	/**
50
+	 * The key of the current retrieved object.
51
+	 *
52
+	 * @var int
53
+	 */
54
+	protected $key = -1;
55
+
56
+	protected $current = null;
57
+
58
+	private $databasePlatform;
59
+
60
+	/**
61
+	 * @var LoggerInterface
62
+	 */
63
+	private $logger;
64
+
65
+	public function __construct($magicSql, array $parameters, $limit, $offset, array $columnDescriptors, $objectStorage, $className, TDBMService $tdbmService, MagicQuery $magicQuery, LoggerInterface $logger)
66
+	{
67
+		$this->magicSql = $magicSql;
68
+		$this->objectStorage = $objectStorage;
69
+		$this->className = $className;
70
+		$this->tdbmService = $tdbmService;
71
+		$this->parameters = $parameters;
72
+		$this->limit = $limit;
73
+		$this->offset = $offset;
74
+		$this->columnDescriptors = $columnDescriptors;
75
+		$this->magicQuery = $magicQuery;
76
+		$this->databasePlatform = $this->tdbmService->getConnection()->getDatabasePlatform();
77
+		$this->logger = $logger;
78
+	}
79
+
80
+	protected function executeQuery()
81
+	{
82
+		$sql = $this->magicQuery->build($this->magicSql, $this->parameters);
83
+		$sql = $this->tdbmService->getConnection()->getDatabasePlatform()->modifyLimitQuery($sql, $this->limit, $this->offset);
84
+
85
+		$this->logger->debug('Running SQL request: '.$sql);
86
+
87
+		$this->statement = $this->tdbmService->getConnection()->executeQuery($sql, $this->parameters);
88
+
89
+		$this->fetchStarted = true;
90
+	}
91
+
92
+	/**
93
+	 * Counts found records (this is the number of records fetched, taking into account the LIMIT and OFFSET settings).
94
+	 *
95
+	 * @return int
96
+	 */
97
+	public function count()
98
+	{
99
+		if (!$this->fetchStarted) {
100
+			$this->executeQuery();
101
+		}
102
+
103
+		return $this->statement->rowCount();
104
+	}
105
+
106
+	/**
107
+	 * Fetches record at current cursor.
108
+	 *
109
+	 * @return AbstractTDBMObject|null
110
+	 */
111
+	public function current()
112
+	{
113
+		return $this->current;
114
+	}
115
+
116
+	/**
117
+	 * Returns the current result's key.
118
+	 *
119
+	 * @return int
120
+	 */
121
+	public function key()
122
+	{
123
+		return $this->key;
124
+	}
125
+
126
+	/**
127
+	 * Advances the cursor to the next result.
128
+	 * Casts the database result into one (or several) beans.
129
+	 */
130
+	public function next()
131
+	{
132
+		$row = $this->statement->fetch(\PDO::FETCH_NUM);
133
+		if ($row) {
134
+
135
+			// array<tablegroup, array<table, array<column, value>>>
136
+			$beansData = [];
137
+			foreach ($row as $i => $value) {
138
+				$columnDescriptor = $this->columnDescriptors[$i];
139
+
140
+				if ($columnDescriptor['tableGroup'] === null) {
141
+					// A column can have no tableGroup (if it comes from an ORDER BY expression)
142
+					continue;
143
+				}
144
+
145
+				// Let's cast the value according to its type
146
+				$value = $columnDescriptor['type']->convertToPHPValue($value, $this->databasePlatform);
147
+
148
+				$beansData[$columnDescriptor['tableGroup']][$columnDescriptor['table']][$columnDescriptor['column']] = $value;
149
+			}
150
+
151
+			$reflectionClassCache = [];
152
+			$firstBean = true;
153
+			foreach ($beansData as $beanData) {
154
+
155
+				// Let's find the bean class name associated to the bean.
156
+
157
+				list($actualClassName, $mainBeanTableName, $tablesUsed) = $this->tdbmService->_getClassNameFromBeanData($beanData);
158
+
159
+				if ($this->className !== null) {
160
+					$actualClassName = $this->className;
161
+				}
162
+
163
+				// Let's filter out the beanData that is not used (because it belongs to a part of the hierarchy that is not fetched:
164
+				foreach ($beanData as $tableName => $descriptors) {
165
+					if (!in_array($tableName, $tablesUsed)) {
166
+						unset($beanData[$tableName]);
167
+					}
168
+				}
169
+
170
+				// Must we create the bean? Let's see in the cache if we have a mapping DbRow?
171
+				// Let's get the first object mapping a row:
172
+				// We do this loop only for the first table
173
+
174
+				$primaryKeys = $this->tdbmService->_getPrimaryKeysFromObjectData($mainBeanTableName, $beanData[$mainBeanTableName]);
175
+				$hash = $this->tdbmService->getObjectHash($primaryKeys);
176
+
177
+				if ($this->objectStorage->has($mainBeanTableName, $hash)) {
178
+					$dbRow = $this->objectStorage->get($mainBeanTableName, $hash);
179
+					$bean = $dbRow->getTDBMObject();
180
+				} else {
181
+					// Let's construct the bean
182
+					if (!isset($reflectionClassCache[$actualClassName])) {
183
+						$reflectionClassCache[$actualClassName] = new \ReflectionClass($actualClassName);
184
+					}
185
+					// Let's bypass the constructor when creating the bean!
186
+					$bean = $reflectionClassCache[$actualClassName]->newInstanceWithoutConstructor();
187
+					$bean->_constructFromData($beanData, $this->tdbmService);
188
+				}
189
+
190
+				// The first bean is the one containing the main table.
191
+				if ($firstBean) {
192
+					$firstBean = false;
193
+					$this->current = $bean;
194
+				}
195
+			}
196
+
197
+			++$this->key;
198
+		} else {
199
+			$this->current = null;
200
+		}
201
+	}
202
+
203
+	/**
204
+	 * Moves the cursor to the beginning of the result set.
205
+	 */
206
+	public function rewind()
207
+	{
208
+		$this->executeQuery();
209
+		$this->key = -1;
210
+		$this->next();
211
+	}
212
+	/**
213
+	 * Checks if the cursor is reading a valid result.
214
+	 *
215
+	 * @return bool
216
+	 */
217
+	public function valid()
218
+	{
219
+		return $this->current !== null;
220
+	}
221
+
222
+	/**
223
+	 * Whether a offset exists.
224
+	 *
225
+	 * @link http://php.net/manual/en/arrayaccess.offsetexists.php
226
+	 *
227
+	 * @param mixed $offset <p>
228
+	 *                      An offset to check for.
229
+	 *                      </p>
230
+	 *
231
+	 * @return bool true on success or false on failure.
232
+	 *              </p>
233
+	 *              <p>
234
+	 *              The return value will be casted to boolean if non-boolean was returned
235
+	 *
236
+	 * @since 5.0.0
237
+	 */
238
+	public function offsetExists($offset)
239
+	{
240
+		throw new TDBMInvalidOperationException('You cannot access this result set via index because it was fetched in CURSOR mode. Use ARRAY_MODE instead.');
241
+	}
242
+
243
+	/**
244
+	 * Offset to retrieve.
245
+	 *
246
+	 * @link http://php.net/manual/en/arrayaccess.offsetget.php
247
+	 *
248
+	 * @param mixed $offset <p>
249
+	 *                      The offset to retrieve.
250
+	 *                      </p>
251
+	 *
252
+	 * @return mixed Can return all value types
253
+	 *
254
+	 * @since 5.0.0
255
+	 */
256
+	public function offsetGet($offset)
257
+	{
258
+		throw new TDBMInvalidOperationException('You cannot access this result set via index because it was fetched in CURSOR mode. Use ARRAY_MODE instead.');
259
+	}
260
+
261
+	/**
262
+	 * Offset to set.
263
+	 *
264
+	 * @link http://php.net/manual/en/arrayaccess.offsetset.php
265
+	 *
266
+	 * @param mixed $offset <p>
267
+	 *                      The offset to assign the value to.
268
+	 *                      </p>
269
+	 * @param mixed $value  <p>
270
+	 *                      The value to set.
271
+	 *                      </p>
272
+	 *
273
+	 * @since 5.0.0
274
+	 */
275
+	public function offsetSet($offset, $value)
276
+	{
277
+		throw new TDBMInvalidOperationException('You can set values in a TDBM result set.');
278
+	}
279
+
280
+	/**
281
+	 * Offset to unset.
282
+	 *
283
+	 * @link http://php.net/manual/en/arrayaccess.offsetunset.php
284
+	 *
285
+	 * @param mixed $offset <p>
286
+	 *                      The offset to unset.
287
+	 *                      </p>
288
+	 *
289
+	 * @since 5.0.0
290
+	 */
291
+	public function offsetUnset($offset)
292
+	{
293
+		throw new TDBMInvalidOperationException('You can unset values in a TDBM result set.');
294
+	}
295 295
 }
Please login to merge, or discard this patch.
src/Mouf/Database/TDBM/AbstractTDBMObject.php 1 patch
Indentation   +595 added lines, -595 removed lines patch added patch discarded remove patch
@@ -31,604 +31,604 @@
 block discarded – undo
31 31
  */
32 32
 abstract class AbstractTDBMObject implements JsonSerializable
33 33
 {
34
-    /**
35
-     * The service this object is bound to.
36
-     *
37
-     * @var TDBMService
38
-     */
39
-    protected $tdbmService;
40
-
41
-    /**
42
-     * An array of DbRow, indexed by table name.
43
-     *
44
-     * @var DbRow[]
45
-     */
46
-    protected $dbRows = array();
47
-
48
-    /**
49
-     * One of TDBMObjectStateEnum::STATE_NEW, TDBMObjectStateEnum::STATE_NOT_LOADED, TDBMObjectStateEnum::STATE_LOADED, TDBMObjectStateEnum::STATE_DELETED.
50
-     * $status = TDBMObjectStateEnum::STATE_NEW when a new object is created with DBMObject:getNewObject.
51
-     * $status = TDBMObjectStateEnum::STATE_NOT_LOADED when the object has been retrieved with getObject but when no data has been accessed in it yet.
52
-     * $status = TDBMObjectStateEnum::STATE_LOADED when the object is cached in memory.
53
-     *
54
-     * @var string
55
-     */
56
-    private $status;
57
-
58
-    /**
59
-     * Array storing beans related via many to many relationships (pivot tables).
60
-     *
61
-     * @var \SplObjectStorage[] Key: pivot table name, value: SplObjectStorage
62
-     */
63
-    private $relationships = [];
64
-
65
-    /**
66
-     * @var bool[] Key: pivot table name, value: whether a query was performed to load the data
67
-     */
68
-    private $loadedRelationships = [];
69
-
70
-    /**
71
-     * Array storing beans related via many to one relationships (this bean is pointed by external beans).
72
-     *
73
-     * @var AlterableResultIterator[] Key: [external_table]___[external_column], value: SplObjectStorage
74
-     */
75
-    private $manyToOneRelationships = [];
76
-
77
-    /**
78
-     * Used with $primaryKeys when we want to retrieve an existing object
79
-     * and $primaryKeys=[] if we want a new object.
80
-     *
81
-     * @param string      $tableName
82
-     * @param array       $primaryKeys
83
-     * @param TDBMService $tdbmService
84
-     *
85
-     * @throws TDBMException
86
-     * @throws TDBMInvalidOperationException
87
-     */
88
-    public function __construct($tableName = null, array $primaryKeys = array(), TDBMService $tdbmService = null)
89
-    {
90
-        // FIXME: lazy loading should be forbidden on tables with inheritance and dynamic type assignation...
91
-        if (!empty($tableName)) {
92
-            $this->dbRows[$tableName] = new DbRow($this, $tableName, $primaryKeys, $tdbmService);
93
-        }
94
-
95
-        if ($tdbmService === null) {
96
-            $this->_setStatus(TDBMObjectStateEnum::STATE_DETACHED);
97
-        } else {
98
-            $this->_attach($tdbmService);
99
-            if (!empty($primaryKeys)) {
100
-                $this->_setStatus(TDBMObjectStateEnum::STATE_NOT_LOADED);
101
-            } else {
102
-                $this->_setStatus(TDBMObjectStateEnum::STATE_NEW);
103
-            }
104
-        }
105
-    }
106
-
107
-    /**
108
-     * Alternative constructor called when data is fetched from database via a SELECT.
109
-     *
110
-     * @param array       $beanData    array<table, array<column, value>>
111
-     * @param TDBMService $tdbmService
112
-     */
113
-    public function _constructFromData(array $beanData, TDBMService $tdbmService)
114
-    {
115
-        $this->tdbmService = $tdbmService;
116
-
117
-        foreach ($beanData as $table => $columns) {
118
-            $this->dbRows[$table] = new DbRow($this, $table, $tdbmService->_getPrimaryKeysFromObjectData($table, $columns), $tdbmService, $columns);
119
-        }
120
-
121
-        $this->status = TDBMObjectStateEnum::STATE_LOADED;
122
-    }
123
-
124
-    /**
125
-     * Alternative constructor called when bean is lazily loaded.
126
-     *
127
-     * @param string      $tableName
128
-     * @param array       $primaryKeys
129
-     * @param TDBMService $tdbmService
130
-     */
131
-    public function _constructLazy($tableName, array $primaryKeys, TDBMService $tdbmService)
132
-    {
133
-        $this->tdbmService = $tdbmService;
134
-
135
-        $this->dbRows[$tableName] = new DbRow($this, $tableName, $primaryKeys, $tdbmService);
136
-
137
-        $this->status = TDBMObjectStateEnum::STATE_NOT_LOADED;
138
-    }
139
-
140
-    public function _attach(TDBMService $tdbmService)
141
-    {
142
-        if ($this->status !== TDBMObjectStateEnum::STATE_DETACHED) {
143
-            throw new TDBMInvalidOperationException('Cannot attach an object that is already attached to TDBM.');
144
-        }
145
-        $this->tdbmService = $tdbmService;
146
-
147
-        // If we attach this object, we must work to make sure the tables are in ascending order (from low level to top level)
148
-        $tableNames = $this->getUsedTables();
149
-
150
-        $newDbRows = [];
151
-
152
-        foreach ($tableNames as $table) {
153
-            if (!isset($this->dbRows[$table])) {
154
-                $this->registerTable($table);
155
-            }
156
-            $newDbRows[$table] = $this->dbRows[$table];
157
-        }
158
-        $this->dbRows = $newDbRows;
159
-
160
-        $this->status = TDBMObjectStateEnum::STATE_NEW;
161
-        foreach ($this->dbRows as $dbRow) {
162
-            $dbRow->_attach($tdbmService);
163
-        }
164
-    }
165
-
166
-    /**
167
-     * Sets the state of the TDBM Object
168
-     * One of TDBMObjectStateEnum::STATE_NEW, TDBMObjectStateEnum::STATE_NOT_LOADED, TDBMObjectStateEnum::STATE_LOADED, TDBMObjectStateEnum::STATE_DELETED.
169
-     * $status = TDBMObjectStateEnum::STATE_NEW when a new object is created with DBMObject:getNewObject.
170
-     * $status = TDBMObjectStateEnum::STATE_NOT_LOADED when the object has been retrieved with getObject but when no data has been accessed in it yet.
171
-     * $status = TDBMObjectStateEnum::STATE_LOADED when the object is cached in memory.
172
-     *
173
-     * @param string $state
174
-     */
175
-    public function _setStatus($state)
176
-    {
177
-        $this->status = $state;
178
-
179
-        // TODO: we might ignore the loaded => dirty state here! dirty status comes from the db_row itself.
180
-        foreach ($this->dbRows as $dbRow) {
181
-            $dbRow->_setStatus($state);
182
-        }
183
-    }
184
-
185
-    /**
186
-     * Checks that $tableName is ok, or returns the only possible table name if "$tableName = null"
187
-     * or throws an error.
188
-     *
189
-     * @param string $tableName
190
-     *
191
-     * @return string
192
-     */
193
-    private function checkTableName($tableName = null)
194
-    {
195
-        if ($tableName === null) {
196
-            if (count($this->dbRows) > 1) {
197
-                throw new TDBMException('This object is based on several tables. You must specify which table you are retrieving data from.');
198
-            } elseif (count($this->dbRows) === 1) {
199
-                $tableName = array_keys($this->dbRows)[0];
200
-            }
201
-        }
202
-
203
-        if (!isset($this->dbRows[$tableName])) {
204
-            if (count($this->dbRows === 0)) {
205
-                throw new TDBMException('Object is not yet bound to any table.');
206
-            } else {
207
-                throw new TDBMException('Unknown table "'.$tableName.'"" in object.');
208
-            }
209
-        }
210
-
211
-        return $tableName;
212
-    }
213
-
214
-    protected function get($var, $tableName = null)
215
-    {
216
-        $tableName = $this->checkTableName($tableName);
217
-
218
-        return $this->dbRows[$tableName]->get($var);
219
-    }
220
-
221
-    protected function set($var, $value, $tableName = null)
222
-    {
223
-        if ($tableName === null) {
224
-            if (count($this->dbRows) > 1) {
225
-                throw new TDBMException('This object is based on several tables. You must specify which table you are retrieving data from.');
226
-            } elseif (count($this->dbRows) === 1) {
227
-                $tableName = array_keys($this->dbRows)[0];
228
-            } else {
229
-                throw new TDBMException('Please specify a table for this object.');
230
-            }
231
-        }
232
-
233
-        if (!isset($this->dbRows[$tableName])) {
234
-            $this->registerTable($tableName);
235
-        }
236
-
237
-        $this->dbRows[$tableName]->set($var, $value);
238
-        if ($this->dbRows[$tableName]->_getStatus() === TDBMObjectStateEnum::STATE_DIRTY) {
239
-            $this->status = TDBMObjectStateEnum::STATE_DIRTY;
240
-        }
241
-    }
242
-
243
-    /**
244
-     * @param string             $foreignKeyName
245
-     * @param AbstractTDBMObject $bean
246
-     */
247
-    protected function setRef($foreignKeyName, AbstractTDBMObject $bean = null, $tableName = null)
248
-    {
249
-        if ($tableName === null) {
250
-            if (count($this->dbRows) > 1) {
251
-                throw new TDBMException('This object is based on several tables. You must specify which table you are retrieving data from.');
252
-            } elseif (count($this->dbRows) === 1) {
253
-                $tableName = array_keys($this->dbRows)[0];
254
-            } else {
255
-                throw new TDBMException('Please specify a table for this object.');
256
-            }
257
-        }
258
-
259
-        if (!isset($this->dbRows[$tableName])) {
260
-            $this->registerTable($tableName);
261
-        }
262
-
263
-        $oldLinkedBean = $this->dbRows[$tableName]->getRef($foreignKeyName);
264
-        if ($oldLinkedBean !== null) {
265
-            $oldLinkedBean->removeManyToOneRelationship($tableName, $foreignKeyName, $this);
266
-        }
267
-
268
-        $this->dbRows[$tableName]->setRef($foreignKeyName, $bean);
269
-        if ($this->dbRows[$tableName]->_getStatus() === TDBMObjectStateEnum::STATE_DIRTY) {
270
-            $this->status = TDBMObjectStateEnum::STATE_DIRTY;
271
-        }
272
-
273
-        if ($bean !== null) {
274
-            $bean->setManyToOneRelationship($tableName, $foreignKeyName, $this);
275
-        }
276
-    }
277
-
278
-    /**
279
-     * @param string $foreignKeyName A unique name for this reference
280
-     *
281
-     * @return AbstractTDBMObject|null
282
-     */
283
-    protected function getRef($foreignKeyName, $tableName = null)
284
-    {
285
-        $tableName = $this->checkTableName($tableName);
286
-
287
-        return $this->dbRows[$tableName]->getRef($foreignKeyName);
288
-    }
289
-
290
-    /**
291
-     * Adds a many to many relationship to this bean.
292
-     *
293
-     * @param string             $pivotTableName
294
-     * @param AbstractTDBMObject $remoteBean
295
-     */
296
-    protected function addRelationship($pivotTableName, AbstractTDBMObject $remoteBean)
297
-    {
298
-        $this->setRelationship($pivotTableName, $remoteBean, 'new');
299
-    }
300
-
301
-    /**
302
-     * Returns true if there is a relationship to this bean.
303
-     *
304
-     * @param string             $pivotTableName
305
-     * @param AbstractTDBMObject $remoteBean
306
-     *
307
-     * @return bool
308
-     */
309
-    protected function hasRelationship($pivotTableName, AbstractTDBMObject $remoteBean)
310
-    {
311
-        $storage = $this->retrieveRelationshipsStorage($pivotTableName);
312
-
313
-        if ($storage->contains($remoteBean)) {
314
-            if ($storage[$remoteBean]['status'] !== 'delete') {
315
-                return true;
316
-            }
317
-        }
318
-
319
-        return false;
320
-    }
321
-
322
-    /**
323
-     * Internal TDBM method. Removes a many to many relationship from this bean.
324
-     *
325
-     * @param string             $pivotTableName
326
-     * @param AbstractTDBMObject $remoteBean
327
-     */
328
-    public function _removeRelationship($pivotTableName, AbstractTDBMObject $remoteBean)
329
-    {
330
-        if (isset($this->relationships[$pivotTableName][$remoteBean]) && $this->relationships[$pivotTableName][$remoteBean]['status'] === 'new') {
331
-            unset($this->relationships[$pivotTableName][$remoteBean]);
332
-            unset($remoteBean->relationships[$pivotTableName][$this]);
333
-        } else {
334
-            $this->setRelationship($pivotTableName, $remoteBean, 'delete');
335
-        }
336
-    }
337
-
338
-    /**
339
-     * Sets many to many relationships for this bean.
340
-     * Adds new relationships and removes unused ones.
341
-     *
342
-     * @param $pivotTableName
343
-     * @param array $remoteBeans
344
-     */
345
-    protected function setRelationships($pivotTableName, array $remoteBeans)
346
-    {
347
-        $storage = $this->retrieveRelationshipsStorage($pivotTableName);
348
-
349
-        foreach ($storage as $oldRemoteBean) {
350
-            if (!in_array($oldRemoteBean, $remoteBeans, true)) {
351
-                // $oldRemoteBean must be removed
352
-                $this->_removeRelationship($pivotTableName, $oldRemoteBean);
353
-            }
354
-        }
355
-
356
-        foreach ($remoteBeans as $remoteBean) {
357
-            if (!$storage->contains($remoteBean) || $storage[$remoteBean]['status'] === 'delete') {
358
-                // $remoteBean must be added
359
-                $this->addRelationship($pivotTableName, $remoteBean);
360
-            }
361
-        }
362
-    }
363
-
364
-    /**
365
-     * Returns the list of objects linked to this bean via $pivotTableName.
366
-     *
367
-     * @param $pivotTableName
368
-     *
369
-     * @return \SplObjectStorage
370
-     */
371
-    private function retrieveRelationshipsStorage($pivotTableName)
372
-    {
373
-        $storage = $this->getRelationshipStorage($pivotTableName);
374
-        if ($this->status === TDBMObjectStateEnum::STATE_DETACHED || $this->status === TDBMObjectStateEnum::STATE_NEW || (isset($this->loadedRelationships[$pivotTableName]) && $this->loadedRelationships[$pivotTableName])) {
375
-            return $storage;
376
-        }
377
-
378
-        $beans = $this->tdbmService->_getRelatedBeans($pivotTableName, $this);
379
-        $this->loadedRelationships[$pivotTableName] = true;
380
-
381
-        foreach ($beans as $bean) {
382
-            if (isset($storage[$bean])) {
383
-                $oldStatus = $storage[$bean]['status'];
384
-                if ($oldStatus === 'delete') {
385
-                    // Keep deleted things deleted
386
-                    continue;
387
-                }
388
-            }
389
-            $this->setRelationship($pivotTableName, $bean, 'loaded');
390
-        }
391
-
392
-        return $storage;
393
-    }
394
-
395
-    /**
396
-     * Internal TDBM method. Returns the list of objects linked to this bean via $pivotTableName.
397
-     *
398
-     * @param $pivotTableName
399
-     *
400
-     * @return AbstractTDBMObject[]
401
-     */
402
-    public function _getRelationships($pivotTableName)
403
-    {
404
-        return $this->relationshipStorageToArray($this->retrieveRelationshipsStorage($pivotTableName));
405
-    }
406
-
407
-    private function relationshipStorageToArray(\SplObjectStorage $storage)
408
-    {
409
-        $beans = [];
410
-        foreach ($storage as $bean) {
411
-            $statusArr = $storage[$bean];
412
-            if ($statusArr['status'] !== 'delete') {
413
-                $beans[] = $bean;
414
-            }
415
-        }
416
-
417
-        return $beans;
418
-    }
419
-
420
-    /**
421
-     * Declares a relationship between.
422
-     *
423
-     * @param string             $pivotTableName
424
-     * @param AbstractTDBMObject $remoteBean
425
-     * @param string             $status
426
-     */
427
-    private function setRelationship($pivotTableName, AbstractTDBMObject $remoteBean, $status)
428
-    {
429
-        $storage = $this->getRelationshipStorage($pivotTableName);
430
-        $storage->attach($remoteBean, ['status' => $status, 'reverse' => false]);
431
-        if ($this->status === TDBMObjectStateEnum::STATE_LOADED) {
432
-            $this->_setStatus(TDBMObjectStateEnum::STATE_DIRTY);
433
-        }
434
-
435
-        $remoteStorage = $remoteBean->getRelationshipStorage($pivotTableName);
436
-        $remoteStorage->attach($this, ['status' => $status, 'reverse' => true]);
437
-    }
438
-
439
-    /**
440
-     * Returns the SplObjectStorage associated to this relationship (creates it if it does not exists).
441
-     *
442
-     * @param string $pivotTableName
443
-     *
444
-     * @return \SplObjectStorage
445
-     */
446
-    private function getRelationshipStorage(string $pivotTableName) : \SplObjectStorage
447
-    {
448
-        return $this->relationships[$pivotTableName] ?? $this->relationships[$pivotTableName] = new \SplObjectStorage();
449
-    }
450
-
451
-    /**
452
-     * Returns the SplObjectStorage associated to this relationship (creates it if it does not exists).
453
-     *
454
-     * @param string $tableName
455
-     * @param string $foreignKeyName
456
-     *
457
-     * @return AlterableResultIterator
458
-     */
459
-    private function getManyToOneAlterableResultIterator(string $tableName, string $foreignKeyName) : AlterableResultIterator
460
-    {
461
-        $key = $tableName.'___'.$foreignKeyName;
462
-
463
-        return $this->manyToOneRelationships[$key] ?? $this->manyToOneRelationships[$key] = new AlterableResultIterator();
464
-    }
465
-
466
-    /**
467
-     * Declares a relationship between this bean and the bean pointing to it.
468
-     *
469
-     * @param string             $tableName
470
-     * @param string             $foreignKeyName
471
-     * @param AbstractTDBMObject $remoteBean
472
-     */
473
-    private function setManyToOneRelationship(string $tableName, string $foreignKeyName, AbstractTDBMObject $remoteBean)
474
-    {
475
-        $alterableResultIterator = $this->getManyToOneAlterableResultIterator($tableName, $foreignKeyName);
476
-        $alterableResultIterator->add($remoteBean);
477
-    }
478
-
479
-    /**
480
-     * Declares a relationship between this bean and the bean pointing to it.
481
-     *
482
-     * @param string             $tableName
483
-     * @param string             $foreignKeyName
484
-     * @param AbstractTDBMObject $remoteBean
485
-     */
486
-    private function removeManyToOneRelationship(string $tableName, string $foreignKeyName, AbstractTDBMObject $remoteBean)
487
-    {
488
-        $alterableResultIterator = $this->getManyToOneAlterableResultIterator($tableName, $foreignKeyName);
489
-        $alterableResultIterator->remove($remoteBean);
490
-    }
491
-
492
-    /**
493
-     * Returns the list of objects linked to this bean via a given foreign key.
494
-     *
495
-     * @param string $tableName
496
-     * @param string $foreignKeyName
497
-     * @param string $searchTableName
498
-     * @param array  $searchFilter
499
-     * @param string $orderString     The ORDER BY part of the query. All columns must be prefixed by the table name (in the form: table.column). WARNING : This parameter is not kept when there is an additionnal or removal object !
500
-     *
501
-     * @return AlterableResultIterator
502
-     */
503
-    protected function retrieveManyToOneRelationshipsStorage(string $tableName, string $foreignKeyName, string $searchTableName, array $searchFilter, $orderString = null) : AlterableResultIterator
504
-    {
505
-        $key = $tableName.'___'.$foreignKeyName;
506
-        $alterableResultIterator = $this->getManyToOneAlterableResultIterator($tableName, $foreignKeyName);
507
-        if ($this->status === TDBMObjectStateEnum::STATE_DETACHED || $this->status === TDBMObjectStateEnum::STATE_NEW || (isset($this->manyToOneRelationships[$key]) && $this->manyToOneRelationships[$key]->getUnderlyingResultIterator() !== null)) {
508
-            return $alterableResultIterator;
509
-        }
510
-
511
-        $unalteredResultIterator = $this->tdbmService->findObjects($searchTableName, $searchFilter, [], $orderString);
512
-
513
-        $alterableResultIterator->setResultIterator($unalteredResultIterator->getIterator());
514
-
515
-        return $alterableResultIterator;
516
-    }
517
-
518
-    /**
519
-     * Reverts any changes made to the object and resumes it to its DB state.
520
-     * This can only be called on objects that come from database and that have not been deleted.
521
-     * Otherwise, this will throw an exception.
522
-     *
523
-     * @throws TDBMException
524
-     */
525
-    public function discardChanges()
526
-    {
527
-        if ($this->status === TDBMObjectStateEnum::STATE_NEW || $this->status === TDBMObjectStateEnum::STATE_DETACHED) {
528
-            throw new TDBMException("You cannot call discardChanges() on an object that has been created with the 'new' keyword and that has not yet been saved.");
529
-        }
530
-
531
-        if ($this->status === TDBMObjectStateEnum::STATE_DELETED) {
532
-            throw new TDBMException('You cannot call discardChanges() on an object that has been deleted.');
533
-        }
534
-
535
-        $this->_setStatus(TDBMObjectStateEnum::STATE_NOT_LOADED);
536
-    }
537
-
538
-    /**
539
-     * Method used internally by TDBM. You should not use it directly.
540
-     * This method returns the status of the TDBMObject.
541
-     * This is one of TDBMObjectStateEnum::STATE_NEW, TDBMObjectStateEnum::STATE_NOT_LOADED, TDBMObjectStateEnum::STATE_LOADED, TDBMObjectStateEnum::STATE_DELETED.
542
-     * $status = TDBMObjectStateEnum::STATE_NEW when a new object is created with DBMObject:getNewObject.
543
-     * $status = TDBMObjectStateEnum::STATE_NOT_LOADED when the object has been retrieved with getObject but when no data has been accessed in it yet.
544
-     * $status = TDBMObjectStateEnum::STATE_LOADED when the object is cached in memory.
545
-     *
546
-     * @return string
547
-     */
548
-    public function _getStatus()
549
-    {
550
-        return $this->status;
551
-    }
552
-
553
-    /**
554
-     * Override the native php clone function for TDBMObjects.
555
-     */
556
-    public function __clone()
557
-    {
558
-        // Let's clone the many to many relationships
559
-        if ($this->status === TDBMObjectStateEnum::STATE_DETACHED) {
560
-            $pivotTableList = array_keys($this->relationships);
561
-        } else {
562
-            $pivotTableList = $this->tdbmService->_getPivotTablesLinkedToBean($this);
563
-        }
564
-
565
-        foreach ($pivotTableList as $pivotTable) {
566
-            $storage = $this->retrieveRelationshipsStorage($pivotTable);
567
-
568
-            // Let's duplicate the reverse side of the relationship // This is useless: already done by "retrieveRelationshipsStorage"!!!
569
-            /*foreach ($storage as $remoteBean) {
34
+	/**
35
+	 * The service this object is bound to.
36
+	 *
37
+	 * @var TDBMService
38
+	 */
39
+	protected $tdbmService;
40
+
41
+	/**
42
+	 * An array of DbRow, indexed by table name.
43
+	 *
44
+	 * @var DbRow[]
45
+	 */
46
+	protected $dbRows = array();
47
+
48
+	/**
49
+	 * One of TDBMObjectStateEnum::STATE_NEW, TDBMObjectStateEnum::STATE_NOT_LOADED, TDBMObjectStateEnum::STATE_LOADED, TDBMObjectStateEnum::STATE_DELETED.
50
+	 * $status = TDBMObjectStateEnum::STATE_NEW when a new object is created with DBMObject:getNewObject.
51
+	 * $status = TDBMObjectStateEnum::STATE_NOT_LOADED when the object has been retrieved with getObject but when no data has been accessed in it yet.
52
+	 * $status = TDBMObjectStateEnum::STATE_LOADED when the object is cached in memory.
53
+	 *
54
+	 * @var string
55
+	 */
56
+	private $status;
57
+
58
+	/**
59
+	 * Array storing beans related via many to many relationships (pivot tables).
60
+	 *
61
+	 * @var \SplObjectStorage[] Key: pivot table name, value: SplObjectStorage
62
+	 */
63
+	private $relationships = [];
64
+
65
+	/**
66
+	 * @var bool[] Key: pivot table name, value: whether a query was performed to load the data
67
+	 */
68
+	private $loadedRelationships = [];
69
+
70
+	/**
71
+	 * Array storing beans related via many to one relationships (this bean is pointed by external beans).
72
+	 *
73
+	 * @var AlterableResultIterator[] Key: [external_table]___[external_column], value: SplObjectStorage
74
+	 */
75
+	private $manyToOneRelationships = [];
76
+
77
+	/**
78
+	 * Used with $primaryKeys when we want to retrieve an existing object
79
+	 * and $primaryKeys=[] if we want a new object.
80
+	 *
81
+	 * @param string      $tableName
82
+	 * @param array       $primaryKeys
83
+	 * @param TDBMService $tdbmService
84
+	 *
85
+	 * @throws TDBMException
86
+	 * @throws TDBMInvalidOperationException
87
+	 */
88
+	public function __construct($tableName = null, array $primaryKeys = array(), TDBMService $tdbmService = null)
89
+	{
90
+		// FIXME: lazy loading should be forbidden on tables with inheritance and dynamic type assignation...
91
+		if (!empty($tableName)) {
92
+			$this->dbRows[$tableName] = new DbRow($this, $tableName, $primaryKeys, $tdbmService);
93
+		}
94
+
95
+		if ($tdbmService === null) {
96
+			$this->_setStatus(TDBMObjectStateEnum::STATE_DETACHED);
97
+		} else {
98
+			$this->_attach($tdbmService);
99
+			if (!empty($primaryKeys)) {
100
+				$this->_setStatus(TDBMObjectStateEnum::STATE_NOT_LOADED);
101
+			} else {
102
+				$this->_setStatus(TDBMObjectStateEnum::STATE_NEW);
103
+			}
104
+		}
105
+	}
106
+
107
+	/**
108
+	 * Alternative constructor called when data is fetched from database via a SELECT.
109
+	 *
110
+	 * @param array       $beanData    array<table, array<column, value>>
111
+	 * @param TDBMService $tdbmService
112
+	 */
113
+	public function _constructFromData(array $beanData, TDBMService $tdbmService)
114
+	{
115
+		$this->tdbmService = $tdbmService;
116
+
117
+		foreach ($beanData as $table => $columns) {
118
+			$this->dbRows[$table] = new DbRow($this, $table, $tdbmService->_getPrimaryKeysFromObjectData($table, $columns), $tdbmService, $columns);
119
+		}
120
+
121
+		$this->status = TDBMObjectStateEnum::STATE_LOADED;
122
+	}
123
+
124
+	/**
125
+	 * Alternative constructor called when bean is lazily loaded.
126
+	 *
127
+	 * @param string      $tableName
128
+	 * @param array       $primaryKeys
129
+	 * @param TDBMService $tdbmService
130
+	 */
131
+	public function _constructLazy($tableName, array $primaryKeys, TDBMService $tdbmService)
132
+	{
133
+		$this->tdbmService = $tdbmService;
134
+
135
+		$this->dbRows[$tableName] = new DbRow($this, $tableName, $primaryKeys, $tdbmService);
136
+
137
+		$this->status = TDBMObjectStateEnum::STATE_NOT_LOADED;
138
+	}
139
+
140
+	public function _attach(TDBMService $tdbmService)
141
+	{
142
+		if ($this->status !== TDBMObjectStateEnum::STATE_DETACHED) {
143
+			throw new TDBMInvalidOperationException('Cannot attach an object that is already attached to TDBM.');
144
+		}
145
+		$this->tdbmService = $tdbmService;
146
+
147
+		// If we attach this object, we must work to make sure the tables are in ascending order (from low level to top level)
148
+		$tableNames = $this->getUsedTables();
149
+
150
+		$newDbRows = [];
151
+
152
+		foreach ($tableNames as $table) {
153
+			if (!isset($this->dbRows[$table])) {
154
+				$this->registerTable($table);
155
+			}
156
+			$newDbRows[$table] = $this->dbRows[$table];
157
+		}
158
+		$this->dbRows = $newDbRows;
159
+
160
+		$this->status = TDBMObjectStateEnum::STATE_NEW;
161
+		foreach ($this->dbRows as $dbRow) {
162
+			$dbRow->_attach($tdbmService);
163
+		}
164
+	}
165
+
166
+	/**
167
+	 * Sets the state of the TDBM Object
168
+	 * One of TDBMObjectStateEnum::STATE_NEW, TDBMObjectStateEnum::STATE_NOT_LOADED, TDBMObjectStateEnum::STATE_LOADED, TDBMObjectStateEnum::STATE_DELETED.
169
+	 * $status = TDBMObjectStateEnum::STATE_NEW when a new object is created with DBMObject:getNewObject.
170
+	 * $status = TDBMObjectStateEnum::STATE_NOT_LOADED when the object has been retrieved with getObject but when no data has been accessed in it yet.
171
+	 * $status = TDBMObjectStateEnum::STATE_LOADED when the object is cached in memory.
172
+	 *
173
+	 * @param string $state
174
+	 */
175
+	public function _setStatus($state)
176
+	{
177
+		$this->status = $state;
178
+
179
+		// TODO: we might ignore the loaded => dirty state here! dirty status comes from the db_row itself.
180
+		foreach ($this->dbRows as $dbRow) {
181
+			$dbRow->_setStatus($state);
182
+		}
183
+	}
184
+
185
+	/**
186
+	 * Checks that $tableName is ok, or returns the only possible table name if "$tableName = null"
187
+	 * or throws an error.
188
+	 *
189
+	 * @param string $tableName
190
+	 *
191
+	 * @return string
192
+	 */
193
+	private function checkTableName($tableName = null)
194
+	{
195
+		if ($tableName === null) {
196
+			if (count($this->dbRows) > 1) {
197
+				throw new TDBMException('This object is based on several tables. You must specify which table you are retrieving data from.');
198
+			} elseif (count($this->dbRows) === 1) {
199
+				$tableName = array_keys($this->dbRows)[0];
200
+			}
201
+		}
202
+
203
+		if (!isset($this->dbRows[$tableName])) {
204
+			if (count($this->dbRows === 0)) {
205
+				throw new TDBMException('Object is not yet bound to any table.');
206
+			} else {
207
+				throw new TDBMException('Unknown table "'.$tableName.'"" in object.');
208
+			}
209
+		}
210
+
211
+		return $tableName;
212
+	}
213
+
214
+	protected function get($var, $tableName = null)
215
+	{
216
+		$tableName = $this->checkTableName($tableName);
217
+
218
+		return $this->dbRows[$tableName]->get($var);
219
+	}
220
+
221
+	protected function set($var, $value, $tableName = null)
222
+	{
223
+		if ($tableName === null) {
224
+			if (count($this->dbRows) > 1) {
225
+				throw new TDBMException('This object is based on several tables. You must specify which table you are retrieving data from.');
226
+			} elseif (count($this->dbRows) === 1) {
227
+				$tableName = array_keys($this->dbRows)[0];
228
+			} else {
229
+				throw new TDBMException('Please specify a table for this object.');
230
+			}
231
+		}
232
+
233
+		if (!isset($this->dbRows[$tableName])) {
234
+			$this->registerTable($tableName);
235
+		}
236
+
237
+		$this->dbRows[$tableName]->set($var, $value);
238
+		if ($this->dbRows[$tableName]->_getStatus() === TDBMObjectStateEnum::STATE_DIRTY) {
239
+			$this->status = TDBMObjectStateEnum::STATE_DIRTY;
240
+		}
241
+	}
242
+
243
+	/**
244
+	 * @param string             $foreignKeyName
245
+	 * @param AbstractTDBMObject $bean
246
+	 */
247
+	protected function setRef($foreignKeyName, AbstractTDBMObject $bean = null, $tableName = null)
248
+	{
249
+		if ($tableName === null) {
250
+			if (count($this->dbRows) > 1) {
251
+				throw new TDBMException('This object is based on several tables. You must specify which table you are retrieving data from.');
252
+			} elseif (count($this->dbRows) === 1) {
253
+				$tableName = array_keys($this->dbRows)[0];
254
+			} else {
255
+				throw new TDBMException('Please specify a table for this object.');
256
+			}
257
+		}
258
+
259
+		if (!isset($this->dbRows[$tableName])) {
260
+			$this->registerTable($tableName);
261
+		}
262
+
263
+		$oldLinkedBean = $this->dbRows[$tableName]->getRef($foreignKeyName);
264
+		if ($oldLinkedBean !== null) {
265
+			$oldLinkedBean->removeManyToOneRelationship($tableName, $foreignKeyName, $this);
266
+		}
267
+
268
+		$this->dbRows[$tableName]->setRef($foreignKeyName, $bean);
269
+		if ($this->dbRows[$tableName]->_getStatus() === TDBMObjectStateEnum::STATE_DIRTY) {
270
+			$this->status = TDBMObjectStateEnum::STATE_DIRTY;
271
+		}
272
+
273
+		if ($bean !== null) {
274
+			$bean->setManyToOneRelationship($tableName, $foreignKeyName, $this);
275
+		}
276
+	}
277
+
278
+	/**
279
+	 * @param string $foreignKeyName A unique name for this reference
280
+	 *
281
+	 * @return AbstractTDBMObject|null
282
+	 */
283
+	protected function getRef($foreignKeyName, $tableName = null)
284
+	{
285
+		$tableName = $this->checkTableName($tableName);
286
+
287
+		return $this->dbRows[$tableName]->getRef($foreignKeyName);
288
+	}
289
+
290
+	/**
291
+	 * Adds a many to many relationship to this bean.
292
+	 *
293
+	 * @param string             $pivotTableName
294
+	 * @param AbstractTDBMObject $remoteBean
295
+	 */
296
+	protected function addRelationship($pivotTableName, AbstractTDBMObject $remoteBean)
297
+	{
298
+		$this->setRelationship($pivotTableName, $remoteBean, 'new');
299
+	}
300
+
301
+	/**
302
+	 * Returns true if there is a relationship to this bean.
303
+	 *
304
+	 * @param string             $pivotTableName
305
+	 * @param AbstractTDBMObject $remoteBean
306
+	 *
307
+	 * @return bool
308
+	 */
309
+	protected function hasRelationship($pivotTableName, AbstractTDBMObject $remoteBean)
310
+	{
311
+		$storage = $this->retrieveRelationshipsStorage($pivotTableName);
312
+
313
+		if ($storage->contains($remoteBean)) {
314
+			if ($storage[$remoteBean]['status'] !== 'delete') {
315
+				return true;
316
+			}
317
+		}
318
+
319
+		return false;
320
+	}
321
+
322
+	/**
323
+	 * Internal TDBM method. Removes a many to many relationship from this bean.
324
+	 *
325
+	 * @param string             $pivotTableName
326
+	 * @param AbstractTDBMObject $remoteBean
327
+	 */
328
+	public function _removeRelationship($pivotTableName, AbstractTDBMObject $remoteBean)
329
+	{
330
+		if (isset($this->relationships[$pivotTableName][$remoteBean]) && $this->relationships[$pivotTableName][$remoteBean]['status'] === 'new') {
331
+			unset($this->relationships[$pivotTableName][$remoteBean]);
332
+			unset($remoteBean->relationships[$pivotTableName][$this]);
333
+		} else {
334
+			$this->setRelationship($pivotTableName, $remoteBean, 'delete');
335
+		}
336
+	}
337
+
338
+	/**
339
+	 * Sets many to many relationships for this bean.
340
+	 * Adds new relationships and removes unused ones.
341
+	 *
342
+	 * @param $pivotTableName
343
+	 * @param array $remoteBeans
344
+	 */
345
+	protected function setRelationships($pivotTableName, array $remoteBeans)
346
+	{
347
+		$storage = $this->retrieveRelationshipsStorage($pivotTableName);
348
+
349
+		foreach ($storage as $oldRemoteBean) {
350
+			if (!in_array($oldRemoteBean, $remoteBeans, true)) {
351
+				// $oldRemoteBean must be removed
352
+				$this->_removeRelationship($pivotTableName, $oldRemoteBean);
353
+			}
354
+		}
355
+
356
+		foreach ($remoteBeans as $remoteBean) {
357
+			if (!$storage->contains($remoteBean) || $storage[$remoteBean]['status'] === 'delete') {
358
+				// $remoteBean must be added
359
+				$this->addRelationship($pivotTableName, $remoteBean);
360
+			}
361
+		}
362
+	}
363
+
364
+	/**
365
+	 * Returns the list of objects linked to this bean via $pivotTableName.
366
+	 *
367
+	 * @param $pivotTableName
368
+	 *
369
+	 * @return \SplObjectStorage
370
+	 */
371
+	private function retrieveRelationshipsStorage($pivotTableName)
372
+	{
373
+		$storage = $this->getRelationshipStorage($pivotTableName);
374
+		if ($this->status === TDBMObjectStateEnum::STATE_DETACHED || $this->status === TDBMObjectStateEnum::STATE_NEW || (isset($this->loadedRelationships[$pivotTableName]) && $this->loadedRelationships[$pivotTableName])) {
375
+			return $storage;
376
+		}
377
+
378
+		$beans = $this->tdbmService->_getRelatedBeans($pivotTableName, $this);
379
+		$this->loadedRelationships[$pivotTableName] = true;
380
+
381
+		foreach ($beans as $bean) {
382
+			if (isset($storage[$bean])) {
383
+				$oldStatus = $storage[$bean]['status'];
384
+				if ($oldStatus === 'delete') {
385
+					// Keep deleted things deleted
386
+					continue;
387
+				}
388
+			}
389
+			$this->setRelationship($pivotTableName, $bean, 'loaded');
390
+		}
391
+
392
+		return $storage;
393
+	}
394
+
395
+	/**
396
+	 * Internal TDBM method. Returns the list of objects linked to this bean via $pivotTableName.
397
+	 *
398
+	 * @param $pivotTableName
399
+	 *
400
+	 * @return AbstractTDBMObject[]
401
+	 */
402
+	public function _getRelationships($pivotTableName)
403
+	{
404
+		return $this->relationshipStorageToArray($this->retrieveRelationshipsStorage($pivotTableName));
405
+	}
406
+
407
+	private function relationshipStorageToArray(\SplObjectStorage $storage)
408
+	{
409
+		$beans = [];
410
+		foreach ($storage as $bean) {
411
+			$statusArr = $storage[$bean];
412
+			if ($statusArr['status'] !== 'delete') {
413
+				$beans[] = $bean;
414
+			}
415
+		}
416
+
417
+		return $beans;
418
+	}
419
+
420
+	/**
421
+	 * Declares a relationship between.
422
+	 *
423
+	 * @param string             $pivotTableName
424
+	 * @param AbstractTDBMObject $remoteBean
425
+	 * @param string             $status
426
+	 */
427
+	private function setRelationship($pivotTableName, AbstractTDBMObject $remoteBean, $status)
428
+	{
429
+		$storage = $this->getRelationshipStorage($pivotTableName);
430
+		$storage->attach($remoteBean, ['status' => $status, 'reverse' => false]);
431
+		if ($this->status === TDBMObjectStateEnum::STATE_LOADED) {
432
+			$this->_setStatus(TDBMObjectStateEnum::STATE_DIRTY);
433
+		}
434
+
435
+		$remoteStorage = $remoteBean->getRelationshipStorage($pivotTableName);
436
+		$remoteStorage->attach($this, ['status' => $status, 'reverse' => true]);
437
+	}
438
+
439
+	/**
440
+	 * Returns the SplObjectStorage associated to this relationship (creates it if it does not exists).
441
+	 *
442
+	 * @param string $pivotTableName
443
+	 *
444
+	 * @return \SplObjectStorage
445
+	 */
446
+	private function getRelationshipStorage(string $pivotTableName) : \SplObjectStorage
447
+	{
448
+		return $this->relationships[$pivotTableName] ?? $this->relationships[$pivotTableName] = new \SplObjectStorage();
449
+	}
450
+
451
+	/**
452
+	 * Returns the SplObjectStorage associated to this relationship (creates it if it does not exists).
453
+	 *
454
+	 * @param string $tableName
455
+	 * @param string $foreignKeyName
456
+	 *
457
+	 * @return AlterableResultIterator
458
+	 */
459
+	private function getManyToOneAlterableResultIterator(string $tableName, string $foreignKeyName) : AlterableResultIterator
460
+	{
461
+		$key = $tableName.'___'.$foreignKeyName;
462
+
463
+		return $this->manyToOneRelationships[$key] ?? $this->manyToOneRelationships[$key] = new AlterableResultIterator();
464
+	}
465
+
466
+	/**
467
+	 * Declares a relationship between this bean and the bean pointing to it.
468
+	 *
469
+	 * @param string             $tableName
470
+	 * @param string             $foreignKeyName
471
+	 * @param AbstractTDBMObject $remoteBean
472
+	 */
473
+	private function setManyToOneRelationship(string $tableName, string $foreignKeyName, AbstractTDBMObject $remoteBean)
474
+	{
475
+		$alterableResultIterator = $this->getManyToOneAlterableResultIterator($tableName, $foreignKeyName);
476
+		$alterableResultIterator->add($remoteBean);
477
+	}
478
+
479
+	/**
480
+	 * Declares a relationship between this bean and the bean pointing to it.
481
+	 *
482
+	 * @param string             $tableName
483
+	 * @param string             $foreignKeyName
484
+	 * @param AbstractTDBMObject $remoteBean
485
+	 */
486
+	private function removeManyToOneRelationship(string $tableName, string $foreignKeyName, AbstractTDBMObject $remoteBean)
487
+	{
488
+		$alterableResultIterator = $this->getManyToOneAlterableResultIterator($tableName, $foreignKeyName);
489
+		$alterableResultIterator->remove($remoteBean);
490
+	}
491
+
492
+	/**
493
+	 * Returns the list of objects linked to this bean via a given foreign key.
494
+	 *
495
+	 * @param string $tableName
496
+	 * @param string $foreignKeyName
497
+	 * @param string $searchTableName
498
+	 * @param array  $searchFilter
499
+	 * @param string $orderString     The ORDER BY part of the query. All columns must be prefixed by the table name (in the form: table.column). WARNING : This parameter is not kept when there is an additionnal or removal object !
500
+	 *
501
+	 * @return AlterableResultIterator
502
+	 */
503
+	protected function retrieveManyToOneRelationshipsStorage(string $tableName, string $foreignKeyName, string $searchTableName, array $searchFilter, $orderString = null) : AlterableResultIterator
504
+	{
505
+		$key = $tableName.'___'.$foreignKeyName;
506
+		$alterableResultIterator = $this->getManyToOneAlterableResultIterator($tableName, $foreignKeyName);
507
+		if ($this->status === TDBMObjectStateEnum::STATE_DETACHED || $this->status === TDBMObjectStateEnum::STATE_NEW || (isset($this->manyToOneRelationships[$key]) && $this->manyToOneRelationships[$key]->getUnderlyingResultIterator() !== null)) {
508
+			return $alterableResultIterator;
509
+		}
510
+
511
+		$unalteredResultIterator = $this->tdbmService->findObjects($searchTableName, $searchFilter, [], $orderString);
512
+
513
+		$alterableResultIterator->setResultIterator($unalteredResultIterator->getIterator());
514
+
515
+		return $alterableResultIterator;
516
+	}
517
+
518
+	/**
519
+	 * Reverts any changes made to the object and resumes it to its DB state.
520
+	 * This can only be called on objects that come from database and that have not been deleted.
521
+	 * Otherwise, this will throw an exception.
522
+	 *
523
+	 * @throws TDBMException
524
+	 */
525
+	public function discardChanges()
526
+	{
527
+		if ($this->status === TDBMObjectStateEnum::STATE_NEW || $this->status === TDBMObjectStateEnum::STATE_DETACHED) {
528
+			throw new TDBMException("You cannot call discardChanges() on an object that has been created with the 'new' keyword and that has not yet been saved.");
529
+		}
530
+
531
+		if ($this->status === TDBMObjectStateEnum::STATE_DELETED) {
532
+			throw new TDBMException('You cannot call discardChanges() on an object that has been deleted.');
533
+		}
534
+
535
+		$this->_setStatus(TDBMObjectStateEnum::STATE_NOT_LOADED);
536
+	}
537
+
538
+	/**
539
+	 * Method used internally by TDBM. You should not use it directly.
540
+	 * This method returns the status of the TDBMObject.
541
+	 * This is one of TDBMObjectStateEnum::STATE_NEW, TDBMObjectStateEnum::STATE_NOT_LOADED, TDBMObjectStateEnum::STATE_LOADED, TDBMObjectStateEnum::STATE_DELETED.
542
+	 * $status = TDBMObjectStateEnum::STATE_NEW when a new object is created with DBMObject:getNewObject.
543
+	 * $status = TDBMObjectStateEnum::STATE_NOT_LOADED when the object has been retrieved with getObject but when no data has been accessed in it yet.
544
+	 * $status = TDBMObjectStateEnum::STATE_LOADED when the object is cached in memory.
545
+	 *
546
+	 * @return string
547
+	 */
548
+	public function _getStatus()
549
+	{
550
+		return $this->status;
551
+	}
552
+
553
+	/**
554
+	 * Override the native php clone function for TDBMObjects.
555
+	 */
556
+	public function __clone()
557
+	{
558
+		// Let's clone the many to many relationships
559
+		if ($this->status === TDBMObjectStateEnum::STATE_DETACHED) {
560
+			$pivotTableList = array_keys($this->relationships);
561
+		} else {
562
+			$pivotTableList = $this->tdbmService->_getPivotTablesLinkedToBean($this);
563
+		}
564
+
565
+		foreach ($pivotTableList as $pivotTable) {
566
+			$storage = $this->retrieveRelationshipsStorage($pivotTable);
567
+
568
+			// Let's duplicate the reverse side of the relationship // This is useless: already done by "retrieveRelationshipsStorage"!!!
569
+			/*foreach ($storage as $remoteBean) {
570 570
                 $metadata = $storage[$remoteBean];
571 571
 
572 572
                 $remoteStorage = $remoteBean->getRelationshipStorage($pivotTable);
573 573
                 $remoteStorage->attach($this, ['status' => $metadata['status'], 'reverse' => !$metadata['reverse']]);
574 574
             }*/
575
-        }
576
-
577
-        // Let's clone each row
578
-        foreach ($this->dbRows as $key => &$dbRow) {
579
-            $dbRow = clone $dbRow;
580
-            $dbRow->setTDBMObject($this);
581
-        }
582
-
583
-        $this->manyToOneRelationships = [];
584
-
585
-        // Let's set the status to new (to enter the save function)
586
-        $this->status = TDBMObjectStateEnum::STATE_DETACHED;
587
-    }
588
-
589
-    /**
590
-     * Returns raw database rows.
591
-     *
592
-     * @return DbRow[] Key: table name, Value: DbRow object
593
-     */
594
-    public function _getDbRows()
595
-    {
596
-        return $this->dbRows;
597
-    }
598
-
599
-    private function registerTable($tableName)
600
-    {
601
-        $dbRow = new DbRow($this, $tableName);
602
-
603
-        if (in_array($this->status, [TDBMObjectStateEnum::STATE_NOT_LOADED, TDBMObjectStateEnum::STATE_LOADED, TDBMObjectStateEnum::STATE_DIRTY])) {
604
-            // Let's get the primary key for the new table
605
-            $anotherDbRow = array_values($this->dbRows)[0];
606
-            /* @var $anotherDbRow DbRow */
607
-            $indexedPrimaryKeys = array_values($anotherDbRow->_getPrimaryKeys());
608
-            $primaryKeys = $this->tdbmService->_getPrimaryKeysFromIndexedPrimaryKeys($tableName, $indexedPrimaryKeys);
609
-            $dbRow->_setPrimaryKeys($primaryKeys);
610
-        }
611
-
612
-        $dbRow->_setStatus($this->status);
613
-
614
-        $this->dbRows[$tableName] = $dbRow;
615
-        // TODO: look at status (if not new)=> get primary key from tdbmservice
616
-    }
617
-
618
-    /**
619
-     * Internal function: return the list of relationships.
620
-     *
621
-     * @return \SplObjectStorage[]
622
-     */
623
-    public function _getCachedRelationships()
624
-    {
625
-        return $this->relationships;
626
-    }
627
-
628
-    /**
629
-     * Returns an array of used tables by this bean (from parent to child relationship).
630
-     *
631
-     * @return string[]
632
-     */
633
-    abstract protected function getUsedTables();
575
+		}
576
+
577
+		// Let's clone each row
578
+		foreach ($this->dbRows as $key => &$dbRow) {
579
+			$dbRow = clone $dbRow;
580
+			$dbRow->setTDBMObject($this);
581
+		}
582
+
583
+		$this->manyToOneRelationships = [];
584
+
585
+		// Let's set the status to new (to enter the save function)
586
+		$this->status = TDBMObjectStateEnum::STATE_DETACHED;
587
+	}
588
+
589
+	/**
590
+	 * Returns raw database rows.
591
+	 *
592
+	 * @return DbRow[] Key: table name, Value: DbRow object
593
+	 */
594
+	public function _getDbRows()
595
+	{
596
+		return $this->dbRows;
597
+	}
598
+
599
+	private function registerTable($tableName)
600
+	{
601
+		$dbRow = new DbRow($this, $tableName);
602
+
603
+		if (in_array($this->status, [TDBMObjectStateEnum::STATE_NOT_LOADED, TDBMObjectStateEnum::STATE_LOADED, TDBMObjectStateEnum::STATE_DIRTY])) {
604
+			// Let's get the primary key for the new table
605
+			$anotherDbRow = array_values($this->dbRows)[0];
606
+			/* @var $anotherDbRow DbRow */
607
+			$indexedPrimaryKeys = array_values($anotherDbRow->_getPrimaryKeys());
608
+			$primaryKeys = $this->tdbmService->_getPrimaryKeysFromIndexedPrimaryKeys($tableName, $indexedPrimaryKeys);
609
+			$dbRow->_setPrimaryKeys($primaryKeys);
610
+		}
611
+
612
+		$dbRow->_setStatus($this->status);
613
+
614
+		$this->dbRows[$tableName] = $dbRow;
615
+		// TODO: look at status (if not new)=> get primary key from tdbmservice
616
+	}
617
+
618
+	/**
619
+	 * Internal function: return the list of relationships.
620
+	 *
621
+	 * @return \SplObjectStorage[]
622
+	 */
623
+	public function _getCachedRelationships()
624
+	{
625
+		return $this->relationships;
626
+	}
627
+
628
+	/**
629
+	 * Returns an array of used tables by this bean (from parent to child relationship).
630
+	 *
631
+	 * @return string[]
632
+	 */
633
+	abstract protected function getUsedTables();
634 634
 }
Please login to merge, or discard this patch.
src/Mouf/Database/TDBM/OrderByAnalyzer.php 2 patches
Indentation   +118 added lines, -118 removed lines patch added patch discarded remove patch
@@ -12,122 +12,122 @@
 block discarded – undo
12 12
  */
13 13
 class OrderByAnalyzer
14 14
 {
15
-    /**
16
-     * The content of the cache variable.
17
-     *
18
-     * @var Cache
19
-     */
20
-    private $cache;
21
-
22
-    /**
23
-     * @var string
24
-     */
25
-    private $cachePrefix;
26
-
27
-    /**
28
-     * OrderByAnalyzer constructor.
29
-     *
30
-     * @param Cache       $cache
31
-     * @param string|null $cachePrefix
32
-     */
33
-    public function __construct(Cache $cache, $cachePrefix = null)
34
-    {
35
-        $this->cache = $cache;
36
-        $this->cachePrefix = $cachePrefix;
37
-    }
38
-
39
-    /**
40
-     * Returns an array for each sorted "column" in the form:.
41
-     *
42
-     * [
43
-     *      [
44
-     *          'type' => 'colref',
45
-     *          'table' => null,
46
-     *          'column' => 'a',
47
-     *          'direction' => 'ASC'
48
-     *      ],
49
-     *      [
50
-     *          'type' => 'expr',
51
-     *          'expr' => 'RAND()',
52
-     *          'direction' => 'DESC'
53
-     *      ]
54
-     * ]
55
-     *
56
-     * @param string $orderBy
57
-     *
58
-     * @return array
59
-     */
60
-    public function analyzeOrderBy(string $orderBy) : array
61
-    {
62
-        $key = $this->cachePrefix.'_order_by_analysis_'.$orderBy;
63
-        $results = $this->cache->fetch($key);
64
-        if ($results !== false) {
65
-            return $results;
66
-        }
67
-        $results = $this->analyzeOrderByNoCache($orderBy);
68
-        $this->cache->save($key, $results);
69
-
70
-        return $results;
71
-    }
72
-
73
-    private function analyzeOrderByNoCache(string $orderBy) : array
74
-    {
75
-        $sqlParser = new PHPSQLParser();
76
-        $sql = 'SELECT 1 FROM a ORDER BY '.$orderBy;
77
-        $parsed = $sqlParser->parse($sql, true);
78
-
79
-        $results = [];
80
-
81
-        for ($i = 0, $count = count($parsed['ORDER']); $i < $count; ++$i) {
82
-            $orderItem = $parsed['ORDER'][$i];
83
-            if ($orderItem['expr_type'] === 'colref') {
84
-                $parts = $orderItem['no_quotes']['parts'];
85
-                $columnName = array_pop($parts);
86
-                if (!empty($parts)) {
87
-                    $tableName = array_pop($parts);
88
-                } else {
89
-                    $tableName = null;
90
-                }
91
-
92
-                $results[] = [
93
-                    'type' => 'colref',
94
-                    'table' => $tableName,
95
-                    'column' => $columnName,
96
-                    'direction' => $orderItem['direction'],
97
-                ];
98
-            } else {
99
-                $position = $orderItem['position'];
100
-                if ($i + 1 < $count) {
101
-                    $nextPosition = $parsed['ORDER'][$i + 1]['position'];
102
-                    $str = substr($sql, $position, $nextPosition - $position);
103
-                } else {
104
-                    $str = substr($sql, $position);
105
-                }
106
-
107
-                $str = trim($str, " \t\r\n,");
108
-
109
-                $results[] = [
110
-                    'type' => 'expr',
111
-                    'expr' => $this->trimDirection($str),
112
-                    'direction' => $orderItem['direction'],
113
-                ];
114
-            }
115
-        }
116
-
117
-        return $results;
118
-    }
119
-
120
-    /**
121
-     * Trims the ASC/DESC direction at the end of the string.
122
-     *
123
-     * @param string $sql
124
-     *
125
-     * @return string
126
-     */
127
-    private function trimDirection(string $sql) : string
128
-    {
129
-        preg_match('/^(.*)(\s+(DESC|ASC|))*$/Ui', $sql, $matches);
130
-
131
-        return $matches[1];
132
-    }
15
+	/**
16
+	 * The content of the cache variable.
17
+	 *
18
+	 * @var Cache
19
+	 */
20
+	private $cache;
21
+
22
+	/**
23
+	 * @var string
24
+	 */
25
+	private $cachePrefix;
26
+
27
+	/**
28
+	 * OrderByAnalyzer constructor.
29
+	 *
30
+	 * @param Cache       $cache
31
+	 * @param string|null $cachePrefix
32
+	 */
33
+	public function __construct(Cache $cache, $cachePrefix = null)
34
+	{
35
+		$this->cache = $cache;
36
+		$this->cachePrefix = $cachePrefix;
37
+	}
38
+
39
+	/**
40
+	 * Returns an array for each sorted "column" in the form:.
41
+	 *
42
+	 * [
43
+	 *      [
44
+	 *          'type' => 'colref',
45
+	 *          'table' => null,
46
+	 *          'column' => 'a',
47
+	 *          'direction' => 'ASC'
48
+	 *      ],
49
+	 *      [
50
+	 *          'type' => 'expr',
51
+	 *          'expr' => 'RAND()',
52
+	 *          'direction' => 'DESC'
53
+	 *      ]
54
+	 * ]
55
+	 *
56
+	 * @param string $orderBy
57
+	 *
58
+	 * @return array
59
+	 */
60
+	public function analyzeOrderBy(string $orderBy) : array
61
+	{
62
+		$key = $this->cachePrefix.'_order_by_analysis_'.$orderBy;
63
+		$results = $this->cache->fetch($key);
64
+		if ($results !== false) {
65
+			return $results;
66
+		}
67
+		$results = $this->analyzeOrderByNoCache($orderBy);
68
+		$this->cache->save($key, $results);
69
+
70
+		return $results;
71
+	}
72
+
73
+	private function analyzeOrderByNoCache(string $orderBy) : array
74
+	{
75
+		$sqlParser = new PHPSQLParser();
76
+		$sql = 'SELECT 1 FROM a ORDER BY '.$orderBy;
77
+		$parsed = $sqlParser->parse($sql, true);
78
+
79
+		$results = [];
80
+
81
+		for ($i = 0, $count = count($parsed['ORDER']); $i < $count; ++$i) {
82
+			$orderItem = $parsed['ORDER'][$i];
83
+			if ($orderItem['expr_type'] === 'colref') {
84
+				$parts = $orderItem['no_quotes']['parts'];
85
+				$columnName = array_pop($parts);
86
+				if (!empty($parts)) {
87
+					$tableName = array_pop($parts);
88
+				} else {
89
+					$tableName = null;
90
+				}
91
+
92
+				$results[] = [
93
+					'type' => 'colref',
94
+					'table' => $tableName,
95
+					'column' => $columnName,
96
+					'direction' => $orderItem['direction'],
97
+				];
98
+			} else {
99
+				$position = $orderItem['position'];
100
+				if ($i + 1 < $count) {
101
+					$nextPosition = $parsed['ORDER'][$i + 1]['position'];
102
+					$str = substr($sql, $position, $nextPosition - $position);
103
+				} else {
104
+					$str = substr($sql, $position);
105
+				}
106
+
107
+				$str = trim($str, " \t\r\n,");
108
+
109
+				$results[] = [
110
+					'type' => 'expr',
111
+					'expr' => $this->trimDirection($str),
112
+					'direction' => $orderItem['direction'],
113
+				];
114
+			}
115
+		}
116
+
117
+		return $results;
118
+	}
119
+
120
+	/**
121
+	 * Trims the ASC/DESC direction at the end of the string.
122
+	 *
123
+	 * @param string $sql
124
+	 *
125
+	 * @return string
126
+	 */
127
+	private function trimDirection(string $sql) : string
128
+	{
129
+		preg_match('/^(.*)(\s+(DESC|ASC|))*$/Ui', $sql, $matches);
130
+
131
+		return $matches[1];
132
+	}
133 133
 }
Please login to merge, or discard this patch.
Spacing   +4 added lines, -4 removed lines patch added patch discarded remove patch
@@ -78,7 +78,7 @@  discard block
 block discarded – undo
78 78
 
79 79
         $results = [];
80 80
 
81
-        for ($i = 0, $count = count($parsed['ORDER']); $i < $count; ++$i) {
81
+        for ($i = 0, $count = count($parsed['ORDER']); $i<$count; ++$i) {
82 82
             $orderItem = $parsed['ORDER'][$i];
83 83
             if ($orderItem['expr_type'] === 'colref') {
84 84
                 $parts = $orderItem['no_quotes']['parts'];
@@ -97,9 +97,9 @@  discard block
 block discarded – undo
97 97
                 ];
98 98
             } else {
99 99
                 $position = $orderItem['position'];
100
-                if ($i + 1 < $count) {
101
-                    $nextPosition = $parsed['ORDER'][$i + 1]['position'];
102
-                    $str = substr($sql, $position, $nextPosition - $position);
100
+                if ($i+1<$count) {
101
+                    $nextPosition = $parsed['ORDER'][$i+1]['position'];
102
+                    $str = substr($sql, $position, $nextPosition-$position);
103 103
                 } else {
104 104
                     $str = substr($sql, $position);
105 105
                 }
Please login to merge, or discard this patch.
src/Mouf/Database/TDBM/TDBMService.php 1 patch
Indentation   +1634 added lines, -1634 removed lines patch added patch discarded remove patch
@@ -45,236 +45,236 @@  discard block
 block discarded – undo
45 45
  */
46 46
 class TDBMService
47 47
 {
48
-    const MODE_CURSOR = 1;
49
-    const MODE_ARRAY = 2;
50
-
51
-    /**
52
-     * The database connection.
53
-     *
54
-     * @var Connection
55
-     */
56
-    private $connection;
57
-
58
-    /**
59
-     * @var SchemaAnalyzer
60
-     */
61
-    private $schemaAnalyzer;
62
-
63
-    /**
64
-     * @var MagicQuery
65
-     */
66
-    private $magicQuery;
67
-
68
-    /**
69
-     * @var TDBMSchemaAnalyzer
70
-     */
71
-    private $tdbmSchemaAnalyzer;
72
-
73
-    /**
74
-     * @var string
75
-     */
76
-    private $cachePrefix;
77
-
78
-    /**
79
-     * Cache of table of primary keys.
80
-     * Primary keys are stored by tables, as an array of column.
81
-     * For instance $primary_key['my_table'][0] will return the first column of the primary key of table 'my_table'.
82
-     *
83
-     * @var string[]
84
-     */
85
-    private $primaryKeysColumns;
86
-
87
-    /**
88
-     * Service storing objects in memory.
89
-     * Access is done by table name and then by primary key.
90
-     * If the primary key is split on several columns, access is done by an array of columns, serialized.
91
-     *
92
-     * @var StandardObjectStorage|WeakrefObjectStorage
93
-     */
94
-    private $objectStorage;
95
-
96
-    /**
97
-     * The fetch mode of the result sets returned by `getObjects`.
98
-     * Can be one of: TDBMObjectArray::MODE_CURSOR or TDBMObjectArray::MODE_ARRAY or TDBMObjectArray::MODE_COMPATIBLE_ARRAY.
99
-     *
100
-     * In 'MODE_ARRAY' mode (default), the result is an array. Use this mode by default (unless the list returned is very big).
101
-     * In 'MODE_CURSOR' mode, the result is a Generator which is an iterable collection that can be scanned only once (only one "foreach") on it,
102
-     * and it cannot be accessed via key. Use this mode for large datasets processed by batch.
103
-     * In 'MODE_COMPATIBLE_ARRAY' mode, the result is an old TDBMObjectArray (used up to TDBM 3.2).
104
-     * You can access the array by key, or using foreach, several times.
105
-     *
106
-     * @var int
107
-     */
108
-    private $mode = self::MODE_ARRAY;
109
-
110
-    /**
111
-     * Table of new objects not yet inserted in database or objects modified that must be saved.
112
-     *
113
-     * @var \SplObjectStorage of DbRow objects
114
-     */
115
-    private $toSaveObjects;
116
-
117
-    /**
118
-     * A cache service to be used.
119
-     *
120
-     * @var Cache|null
121
-     */
122
-    private $cache;
123
-
124
-    /**
125
-     * Map associating a table name to a fully qualified Bean class name.
126
-     *
127
-     * @var array
128
-     */
129
-    private $tableToBeanMap = [];
130
-
131
-    /**
132
-     * @var \ReflectionClass[]
133
-     */
134
-    private $reflectionClassCache = array();
135
-
136
-    /**
137
-     * @var LoggerInterface
138
-     */
139
-    private $rootLogger;
140
-
141
-    /**
142
-     * @var MinLogLevelFilter|NullLogger
143
-     */
144
-    private $logger;
145
-
146
-    /**
147
-     * @var OrderByAnalyzer
148
-     */
149
-    private $orderByAnalyzer;
150
-
151
-    /**
152
-     * @param Connection     $connection     The DBAL DB connection to use
153
-     * @param Cache|null     $cache          A cache service to be used
154
-     * @param SchemaAnalyzer $schemaAnalyzer The schema analyzer that will be used to find shortest paths...
155
-     *                                       Will be automatically created if not passed
156
-     */
157
-    public function __construct(Connection $connection, Cache $cache = null, SchemaAnalyzer $schemaAnalyzer = null, LoggerInterface $logger = null)
158
-    {
159
-        if (extension_loaded('weakref')) {
160
-            $this->objectStorage = new WeakrefObjectStorage();
161
-        } else {
162
-            $this->objectStorage = new StandardObjectStorage();
163
-        }
164
-        $this->connection = $connection;
165
-        if ($cache !== null) {
166
-            $this->cache = $cache;
167
-        } else {
168
-            $this->cache = new VoidCache();
169
-        }
170
-        if ($schemaAnalyzer) {
171
-            $this->schemaAnalyzer = $schemaAnalyzer;
172
-        } else {
173
-            $this->schemaAnalyzer = new SchemaAnalyzer($this->connection->getSchemaManager(), $this->cache, $this->getConnectionUniqueId());
174
-        }
175
-
176
-        $this->magicQuery = new MagicQuery($this->connection, $this->cache, $this->schemaAnalyzer);
177
-
178
-        $this->tdbmSchemaAnalyzer = new TDBMSchemaAnalyzer($connection, $this->cache, $this->schemaAnalyzer);
179
-        $this->cachePrefix = $this->tdbmSchemaAnalyzer->getCachePrefix();
180
-
181
-        $this->toSaveObjects = new \SplObjectStorage();
182
-        if ($logger === null) {
183
-            $this->logger = new NullLogger();
184
-            $this->rootLogger = new NullLogger();
185
-        } else {
186
-            $this->rootLogger = $logger;
187
-            $this->setLogLevel(LogLevel::WARNING);
188
-        }
189
-        $this->orderByAnalyzer = new OrderByAnalyzer($this->cache, $this->cachePrefix);
190
-    }
191
-
192
-    /**
193
-     * Returns the object used to connect to the database.
194
-     *
195
-     * @return Connection
196
-     */
197
-    public function getConnection()
198
-    {
199
-        return $this->connection;
200
-    }
201
-
202
-    /**
203
-     * Creates a unique cache key for the current connection.
204
-     *
205
-     * @return string
206
-     */
207
-    private function getConnectionUniqueId()
208
-    {
209
-        return hash('md4', $this->connection->getHost().'-'.$this->connection->getPort().'-'.$this->connection->getDatabase().'-'.$this->connection->getDriver()->getName());
210
-    }
211
-
212
-    /**
213
-     * Sets the default fetch mode of the result sets returned by `findObjects`.
214
-     * Can be one of: TDBMObjectArray::MODE_CURSOR or TDBMObjectArray::MODE_ARRAY.
215
-     *
216
-     * In 'MODE_ARRAY' mode (default), the result is a ResultIterator object that behaves like an array. Use this mode by default (unless the list returned is very big).
217
-     * In 'MODE_CURSOR' mode, the result is a ResultIterator object. If you scan it many times (by calling several time a foreach loop), the query will be run
218
-     * several times. In cursor mode, you cannot access the result set by key. Use this mode for large datasets processed by batch.
219
-     *
220
-     * @param int $mode
221
-     *
222
-     * @return $this
223
-     *
224
-     * @throws TDBMException
225
-     */
226
-    public function setFetchMode($mode)
227
-    {
228
-        if ($mode !== self::MODE_CURSOR && $mode !== self::MODE_ARRAY) {
229
-            throw new TDBMException("Unknown fetch mode: '".$this->mode."'");
230
-        }
231
-        $this->mode = $mode;
232
-
233
-        return $this;
234
-    }
235
-
236
-    /**
237
-     * Returns a TDBMObject associated from table "$table_name".
238
-     * If the $filters parameter is an int/string, the object returned will be the object whose primary key = $filters.
239
-     * $filters can also be a set of TDBM_Filters (see the findObjects method for more details).
240
-     *
241
-     * For instance, if there is a table 'users', with a primary key on column 'user_id' and a column 'user_name', then
242
-     * 			$user = $tdbmService->getObject('users',1);
243
-     * 			echo $user->name;
244
-     * will return the name of the user whose user_id is one.
245
-     *
246
-     * If a table has a primary key over several columns, you should pass to $id an array containing the the value of the various columns.
247
-     * For instance:
248
-     * 			$group = $tdbmService->getObject('groups',array(1,2));
249
-     *
250
-     * Note that TDBMObject performs caching for you. If you get twice the same object, the reference of the object you will get
251
-     * will be the same.
252
-     *
253
-     * For instance:
254
-     * 			$user1 = $tdbmService->getObject('users',1);
255
-     * 			$user2 = $tdbmService->getObject('users',1);
256
-     * 			$user1->name = 'John Doe';
257
-     * 			echo $user2->name;
258
-     * will return 'John Doe'.
259
-     *
260
-     * You can use filters instead of passing the primary key. For instance:
261
-     * 			$user = $tdbmService->getObject('users',new EqualFilter('users', 'login', 'jdoe'));
262
-     * This will return the user whose login is 'jdoe'.
263
-     * Please note that if 2 users have the jdoe login in database, the method will throw a TDBM_DuplicateRowException.
264
-     *
265
-     * Also, you can specify the return class for the object (provided the return class extends TDBMObject).
266
-     * For instance:
267
-     *  	$user = $tdbmService->getObject('users',1,'User');
268
-     * will return an object from the "User" class. The "User" class must extend the "TDBMObject" class.
269
-     * Please be sure not to override any method or any property unless you perfectly know what you are doing!
270
-     *
271
-     * @param string $table_name   The name of the table we retrieve an object from
272
-     * @param mixed  $filters      If the filter is a string/integer, it will be considered as the id of the object (the value of the primary key). Otherwise, it can be a filter bag (see the filterbag parameter of the findObjects method for more details about filter bags)
273
-     * @param string $className    Optional: The name of the class to instanciate. This class must extend the TDBMObject class. If none is specified, a TDBMObject instance will be returned
274
-     * @param bool   $lazy_loading If set to true, and if the primary key is passed in parameter of getObject, the object will not be queried in database. It will be queried when you first try to access a column. If at that time the object cannot be found in database, an exception will be thrown
275
-     *
276
-     * @return TDBMObject
277
-     */
48
+	const MODE_CURSOR = 1;
49
+	const MODE_ARRAY = 2;
50
+
51
+	/**
52
+	 * The database connection.
53
+	 *
54
+	 * @var Connection
55
+	 */
56
+	private $connection;
57
+
58
+	/**
59
+	 * @var SchemaAnalyzer
60
+	 */
61
+	private $schemaAnalyzer;
62
+
63
+	/**
64
+	 * @var MagicQuery
65
+	 */
66
+	private $magicQuery;
67
+
68
+	/**
69
+	 * @var TDBMSchemaAnalyzer
70
+	 */
71
+	private $tdbmSchemaAnalyzer;
72
+
73
+	/**
74
+	 * @var string
75
+	 */
76
+	private $cachePrefix;
77
+
78
+	/**
79
+	 * Cache of table of primary keys.
80
+	 * Primary keys are stored by tables, as an array of column.
81
+	 * For instance $primary_key['my_table'][0] will return the first column of the primary key of table 'my_table'.
82
+	 *
83
+	 * @var string[]
84
+	 */
85
+	private $primaryKeysColumns;
86
+
87
+	/**
88
+	 * Service storing objects in memory.
89
+	 * Access is done by table name and then by primary key.
90
+	 * If the primary key is split on several columns, access is done by an array of columns, serialized.
91
+	 *
92
+	 * @var StandardObjectStorage|WeakrefObjectStorage
93
+	 */
94
+	private $objectStorage;
95
+
96
+	/**
97
+	 * The fetch mode of the result sets returned by `getObjects`.
98
+	 * Can be one of: TDBMObjectArray::MODE_CURSOR or TDBMObjectArray::MODE_ARRAY or TDBMObjectArray::MODE_COMPATIBLE_ARRAY.
99
+	 *
100
+	 * In 'MODE_ARRAY' mode (default), the result is an array. Use this mode by default (unless the list returned is very big).
101
+	 * In 'MODE_CURSOR' mode, the result is a Generator which is an iterable collection that can be scanned only once (only one "foreach") on it,
102
+	 * and it cannot be accessed via key. Use this mode for large datasets processed by batch.
103
+	 * In 'MODE_COMPATIBLE_ARRAY' mode, the result is an old TDBMObjectArray (used up to TDBM 3.2).
104
+	 * You can access the array by key, or using foreach, several times.
105
+	 *
106
+	 * @var int
107
+	 */
108
+	private $mode = self::MODE_ARRAY;
109
+
110
+	/**
111
+	 * Table of new objects not yet inserted in database or objects modified that must be saved.
112
+	 *
113
+	 * @var \SplObjectStorage of DbRow objects
114
+	 */
115
+	private $toSaveObjects;
116
+
117
+	/**
118
+	 * A cache service to be used.
119
+	 *
120
+	 * @var Cache|null
121
+	 */
122
+	private $cache;
123
+
124
+	/**
125
+	 * Map associating a table name to a fully qualified Bean class name.
126
+	 *
127
+	 * @var array
128
+	 */
129
+	private $tableToBeanMap = [];
130
+
131
+	/**
132
+	 * @var \ReflectionClass[]
133
+	 */
134
+	private $reflectionClassCache = array();
135
+
136
+	/**
137
+	 * @var LoggerInterface
138
+	 */
139
+	private $rootLogger;
140
+
141
+	/**
142
+	 * @var MinLogLevelFilter|NullLogger
143
+	 */
144
+	private $logger;
145
+
146
+	/**
147
+	 * @var OrderByAnalyzer
148
+	 */
149
+	private $orderByAnalyzer;
150
+
151
+	/**
152
+	 * @param Connection     $connection     The DBAL DB connection to use
153
+	 * @param Cache|null     $cache          A cache service to be used
154
+	 * @param SchemaAnalyzer $schemaAnalyzer The schema analyzer that will be used to find shortest paths...
155
+	 *                                       Will be automatically created if not passed
156
+	 */
157
+	public function __construct(Connection $connection, Cache $cache = null, SchemaAnalyzer $schemaAnalyzer = null, LoggerInterface $logger = null)
158
+	{
159
+		if (extension_loaded('weakref')) {
160
+			$this->objectStorage = new WeakrefObjectStorage();
161
+		} else {
162
+			$this->objectStorage = new StandardObjectStorage();
163
+		}
164
+		$this->connection = $connection;
165
+		if ($cache !== null) {
166
+			$this->cache = $cache;
167
+		} else {
168
+			$this->cache = new VoidCache();
169
+		}
170
+		if ($schemaAnalyzer) {
171
+			$this->schemaAnalyzer = $schemaAnalyzer;
172
+		} else {
173
+			$this->schemaAnalyzer = new SchemaAnalyzer($this->connection->getSchemaManager(), $this->cache, $this->getConnectionUniqueId());
174
+		}
175
+
176
+		$this->magicQuery = new MagicQuery($this->connection, $this->cache, $this->schemaAnalyzer);
177
+
178
+		$this->tdbmSchemaAnalyzer = new TDBMSchemaAnalyzer($connection, $this->cache, $this->schemaAnalyzer);
179
+		$this->cachePrefix = $this->tdbmSchemaAnalyzer->getCachePrefix();
180
+
181
+		$this->toSaveObjects = new \SplObjectStorage();
182
+		if ($logger === null) {
183
+			$this->logger = new NullLogger();
184
+			$this->rootLogger = new NullLogger();
185
+		} else {
186
+			$this->rootLogger = $logger;
187
+			$this->setLogLevel(LogLevel::WARNING);
188
+		}
189
+		$this->orderByAnalyzer = new OrderByAnalyzer($this->cache, $this->cachePrefix);
190
+	}
191
+
192
+	/**
193
+	 * Returns the object used to connect to the database.
194
+	 *
195
+	 * @return Connection
196
+	 */
197
+	public function getConnection()
198
+	{
199
+		return $this->connection;
200
+	}
201
+
202
+	/**
203
+	 * Creates a unique cache key for the current connection.
204
+	 *
205
+	 * @return string
206
+	 */
207
+	private function getConnectionUniqueId()
208
+	{
209
+		return hash('md4', $this->connection->getHost().'-'.$this->connection->getPort().'-'.$this->connection->getDatabase().'-'.$this->connection->getDriver()->getName());
210
+	}
211
+
212
+	/**
213
+	 * Sets the default fetch mode of the result sets returned by `findObjects`.
214
+	 * Can be one of: TDBMObjectArray::MODE_CURSOR or TDBMObjectArray::MODE_ARRAY.
215
+	 *
216
+	 * In 'MODE_ARRAY' mode (default), the result is a ResultIterator object that behaves like an array. Use this mode by default (unless the list returned is very big).
217
+	 * In 'MODE_CURSOR' mode, the result is a ResultIterator object. If you scan it many times (by calling several time a foreach loop), the query will be run
218
+	 * several times. In cursor mode, you cannot access the result set by key. Use this mode for large datasets processed by batch.
219
+	 *
220
+	 * @param int $mode
221
+	 *
222
+	 * @return $this
223
+	 *
224
+	 * @throws TDBMException
225
+	 */
226
+	public function setFetchMode($mode)
227
+	{
228
+		if ($mode !== self::MODE_CURSOR && $mode !== self::MODE_ARRAY) {
229
+			throw new TDBMException("Unknown fetch mode: '".$this->mode."'");
230
+		}
231
+		$this->mode = $mode;
232
+
233
+		return $this;
234
+	}
235
+
236
+	/**
237
+	 * Returns a TDBMObject associated from table "$table_name".
238
+	 * If the $filters parameter is an int/string, the object returned will be the object whose primary key = $filters.
239
+	 * $filters can also be a set of TDBM_Filters (see the findObjects method for more details).
240
+	 *
241
+	 * For instance, if there is a table 'users', with a primary key on column 'user_id' and a column 'user_name', then
242
+	 * 			$user = $tdbmService->getObject('users',1);
243
+	 * 			echo $user->name;
244
+	 * will return the name of the user whose user_id is one.
245
+	 *
246
+	 * If a table has a primary key over several columns, you should pass to $id an array containing the the value of the various columns.
247
+	 * For instance:
248
+	 * 			$group = $tdbmService->getObject('groups',array(1,2));
249
+	 *
250
+	 * Note that TDBMObject performs caching for you. If you get twice the same object, the reference of the object you will get
251
+	 * will be the same.
252
+	 *
253
+	 * For instance:
254
+	 * 			$user1 = $tdbmService->getObject('users',1);
255
+	 * 			$user2 = $tdbmService->getObject('users',1);
256
+	 * 			$user1->name = 'John Doe';
257
+	 * 			echo $user2->name;
258
+	 * will return 'John Doe'.
259
+	 *
260
+	 * You can use filters instead of passing the primary key. For instance:
261
+	 * 			$user = $tdbmService->getObject('users',new EqualFilter('users', 'login', 'jdoe'));
262
+	 * This will return the user whose login is 'jdoe'.
263
+	 * Please note that if 2 users have the jdoe login in database, the method will throw a TDBM_DuplicateRowException.
264
+	 *
265
+	 * Also, you can specify the return class for the object (provided the return class extends TDBMObject).
266
+	 * For instance:
267
+	 *  	$user = $tdbmService->getObject('users',1,'User');
268
+	 * will return an object from the "User" class. The "User" class must extend the "TDBMObject" class.
269
+	 * Please be sure not to override any method or any property unless you perfectly know what you are doing!
270
+	 *
271
+	 * @param string $table_name   The name of the table we retrieve an object from
272
+	 * @param mixed  $filters      If the filter is a string/integer, it will be considered as the id of the object (the value of the primary key). Otherwise, it can be a filter bag (see the filterbag parameter of the findObjects method for more details about filter bags)
273
+	 * @param string $className    Optional: The name of the class to instanciate. This class must extend the TDBMObject class. If none is specified, a TDBMObject instance will be returned
274
+	 * @param bool   $lazy_loading If set to true, and if the primary key is passed in parameter of getObject, the object will not be queried in database. It will be queried when you first try to access a column. If at that time the object cannot be found in database, an exception will be thrown
275
+	 *
276
+	 * @return TDBMObject
277
+	 */
278 278
 /*	public function getObject($table_name, $filters, $className = null, $lazy_loading = false) {
279 279
 
280 280
         if (is_array($filters) || $filters instanceof FilterInterface) {
@@ -360,199 +360,199 @@  discard block
 block discarded – undo
360 360
         return $obj;
361 361
     }*/
362 362
 
363
-    /**
364
-     * Removes the given object from database.
365
-     * This cannot be called on an object that is not attached to this TDBMService
366
-     * (will throw a TDBMInvalidOperationException).
367
-     *
368
-     * @param AbstractTDBMObject $object the object to delete
369
-     *
370
-     * @throws TDBMException
371
-     * @throws TDBMInvalidOperationException
372
-     */
373
-    public function delete(AbstractTDBMObject $object)
374
-    {
375
-        switch ($object->_getStatus()) {
376
-            case TDBMObjectStateEnum::STATE_DELETED:
377
-                // Nothing to do, object already deleted.
378
-                return;
379
-            case TDBMObjectStateEnum::STATE_DETACHED:
380
-                throw new TDBMInvalidOperationException('Cannot delete a detached object');
381
-            case TDBMObjectStateEnum::STATE_NEW:
382
-                $this->deleteManyToManyRelationships($object);
383
-                foreach ($object->_getDbRows() as $dbRow) {
384
-                    $this->removeFromToSaveObjectList($dbRow);
385
-                }
386
-                break;
387
-            case TDBMObjectStateEnum::STATE_DIRTY:
388
-                foreach ($object->_getDbRows() as $dbRow) {
389
-                    $this->removeFromToSaveObjectList($dbRow);
390
-                }
391
-                // And continue deleting...
392
-            case TDBMObjectStateEnum::STATE_NOT_LOADED:
393
-            case TDBMObjectStateEnum::STATE_LOADED:
394
-                $this->deleteManyToManyRelationships($object);
395
-                // Let's delete db rows, in reverse order.
396
-                foreach (array_reverse($object->_getDbRows()) as $dbRow) {
397
-                    $tableName = $dbRow->_getDbTableName();
398
-                    $primaryKeys = $dbRow->_getPrimaryKeys();
399
-                    $this->connection->delete($tableName, $primaryKeys);
400
-                    $this->objectStorage->remove($dbRow->_getDbTableName(), $this->getObjectHash($primaryKeys));
401
-                }
402
-                break;
403
-            // @codeCoverageIgnoreStart
404
-            default:
405
-                throw new TDBMInvalidOperationException('Unexpected status for bean');
406
-            // @codeCoverageIgnoreEnd
407
-        }
408
-
409
-        $object->_setStatus(TDBMObjectStateEnum::STATE_DELETED);
410
-    }
411
-
412
-    /**
413
-     * Removes all many to many relationships for this object.
414
-     *
415
-     * @param AbstractTDBMObject $object
416
-     */
417
-    private function deleteManyToManyRelationships(AbstractTDBMObject $object)
418
-    {
419
-        foreach ($object->_getDbRows() as $tableName => $dbRow) {
420
-            $pivotTables = $this->tdbmSchemaAnalyzer->getPivotTableLinkedToTable($tableName);
421
-            foreach ($pivotTables as $pivotTable) {
422
-                $remoteBeans = $object->_getRelationships($pivotTable);
423
-                foreach ($remoteBeans as $remoteBean) {
424
-                    $object->_removeRelationship($pivotTable, $remoteBean);
425
-                }
426
-            }
427
-        }
428
-        $this->persistManyToManyRelationships($object);
429
-    }
430
-
431
-    /**
432
-     * This function removes the given object from the database. It will also remove all objects relied to the one given
433
-     * by parameter before all.
434
-     *
435
-     * Notice: if the object has a multiple primary key, the function will not work.
436
-     *
437
-     * @param AbstractTDBMObject $objToDelete
438
-     */
439
-    public function deleteCascade(AbstractTDBMObject $objToDelete)
440
-    {
441
-        $this->deleteAllConstraintWithThisObject($objToDelete);
442
-        $this->delete($objToDelete);
443
-    }
444
-
445
-    /**
446
-     * This function is used only in TDBMService (private function)
447
-     * It will call deleteCascade function foreach object relied with a foreign key to the object given by parameter.
448
-     *
449
-     * @param AbstractTDBMObject $obj
450
-     */
451
-    private function deleteAllConstraintWithThisObject(AbstractTDBMObject $obj)
452
-    {
453
-        $dbRows = $obj->_getDbRows();
454
-        foreach ($dbRows as $dbRow) {
455
-            $tableName = $dbRow->_getDbTableName();
456
-            $pks = array_values($dbRow->_getPrimaryKeys());
457
-            if (!empty($pks)) {
458
-                $incomingFks = $this->tdbmSchemaAnalyzer->getIncomingForeignKeys($tableName);
459
-
460
-                foreach ($incomingFks as $incomingFk) {
461
-                    $filter = array_combine($incomingFk->getLocalColumns(), $pks);
462
-
463
-                    $results = $this->findObjects($incomingFk->getLocalTableName(), $filter);
464
-
465
-                    foreach ($results as $bean) {
466
-                        $this->deleteCascade($bean);
467
-                    }
468
-                }
469
-            }
470
-        }
471
-    }
472
-
473
-    /**
474
-     * This function performs a save() of all the objects that have been modified.
475
-     */
476
-    public function completeSave()
477
-    {
478
-        foreach ($this->toSaveObjects as $dbRow) {
479
-            $this->save($dbRow->getTDBMObject());
480
-        }
481
-    }
482
-
483
-    /**
484
-     * Takes in input a filter_bag (which can be about anything from a string to an array of TDBMObjects... see above from documentation),
485
-     * and gives back a proper Filter object.
486
-     *
487
-     * @param mixed $filter_bag
488
-     * @param int   $counter
489
-     *
490
-     * @return array First item: filter string, second item: parameters
491
-     *
492
-     * @throws TDBMException
493
-     */
494
-    public function buildFilterFromFilterBag($filter_bag, $counter = 1)
495
-    {
496
-        if ($filter_bag === null) {
497
-            return ['', []];
498
-        } elseif (is_string($filter_bag)) {
499
-            return [$filter_bag, []];
500
-        } elseif (is_array($filter_bag)) {
501
-            $sqlParts = [];
502
-            $parameters = [];
503
-            foreach ($filter_bag as $column => $value) {
504
-                if (is_int($column)) {
505
-                    list($subSqlPart, $subParameters) = $this->buildFilterFromFilterBag($value, $counter);
506
-                    $sqlParts[] = $subSqlPart;
507
-                    $parameters += $subParameters;
508
-                } else {
509
-                    $paramName = 'tdbmparam'.$counter;
510
-                    if (is_array($value)) {
511
-                        $sqlParts[] = $this->connection->quoteIdentifier($column).' IN :'.$paramName;
512
-                    } else {
513
-                        $sqlParts[] = $this->connection->quoteIdentifier($column).' = :'.$paramName;
514
-                    }
515
-                    $parameters[$paramName] = $value;
516
-                    ++$counter;
517
-                }
518
-            }
519
-
520
-            return [implode(' AND ', $sqlParts), $parameters];
521
-        } elseif ($filter_bag instanceof AbstractTDBMObject) {
522
-            $sqlParts = [];
523
-            $parameters = [];
524
-            $dbRows = $filter_bag->_getDbRows();
525
-            $dbRow = reset($dbRows);
526
-            $primaryKeys = $dbRow->_getPrimaryKeys();
527
-
528
-            foreach ($primaryKeys as $column => $value) {
529
-                $paramName = 'tdbmparam'.$counter;
530
-                $sqlParts[] = $this->connection->quoteIdentifier($dbRow->_getDbTableName()).'.'.$this->connection->quoteIdentifier($column).' = :'.$paramName;
531
-                $parameters[$paramName] = $value;
532
-                ++$counter;
533
-            }
534
-
535
-            return [implode(' AND ', $sqlParts), $parameters];
536
-        } elseif ($filter_bag instanceof \Iterator) {
537
-            return $this->buildFilterFromFilterBag(iterator_to_array($filter_bag), $counter);
538
-        } else {
539
-            throw new TDBMException('Error in filter. An object has been passed that is neither a SQL string, nor an array, nor a bean, nor null.');
540
-        }
541
-    }
542
-
543
-    /**
544
-     * @param string $table
545
-     *
546
-     * @return string[]
547
-     */
548
-    public function getPrimaryKeyColumns($table)
549
-    {
550
-        if (!isset($this->primaryKeysColumns[$table])) {
551
-            $this->primaryKeysColumns[$table] = $this->tdbmSchemaAnalyzer->getSchema()->getTable($table)->getPrimaryKeyColumns();
552
-
553
-            // TODO TDBM4: See if we need to improve error reporting if table name does not exist.
554
-
555
-            /*$arr = array();
363
+	/**
364
+	 * Removes the given object from database.
365
+	 * This cannot be called on an object that is not attached to this TDBMService
366
+	 * (will throw a TDBMInvalidOperationException).
367
+	 *
368
+	 * @param AbstractTDBMObject $object the object to delete
369
+	 *
370
+	 * @throws TDBMException
371
+	 * @throws TDBMInvalidOperationException
372
+	 */
373
+	public function delete(AbstractTDBMObject $object)
374
+	{
375
+		switch ($object->_getStatus()) {
376
+			case TDBMObjectStateEnum::STATE_DELETED:
377
+				// Nothing to do, object already deleted.
378
+				return;
379
+			case TDBMObjectStateEnum::STATE_DETACHED:
380
+				throw new TDBMInvalidOperationException('Cannot delete a detached object');
381
+			case TDBMObjectStateEnum::STATE_NEW:
382
+				$this->deleteManyToManyRelationships($object);
383
+				foreach ($object->_getDbRows() as $dbRow) {
384
+					$this->removeFromToSaveObjectList($dbRow);
385
+				}
386
+				break;
387
+			case TDBMObjectStateEnum::STATE_DIRTY:
388
+				foreach ($object->_getDbRows() as $dbRow) {
389
+					$this->removeFromToSaveObjectList($dbRow);
390
+				}
391
+				// And continue deleting...
392
+			case TDBMObjectStateEnum::STATE_NOT_LOADED:
393
+			case TDBMObjectStateEnum::STATE_LOADED:
394
+				$this->deleteManyToManyRelationships($object);
395
+				// Let's delete db rows, in reverse order.
396
+				foreach (array_reverse($object->_getDbRows()) as $dbRow) {
397
+					$tableName = $dbRow->_getDbTableName();
398
+					$primaryKeys = $dbRow->_getPrimaryKeys();
399
+					$this->connection->delete($tableName, $primaryKeys);
400
+					$this->objectStorage->remove($dbRow->_getDbTableName(), $this->getObjectHash($primaryKeys));
401
+				}
402
+				break;
403
+			// @codeCoverageIgnoreStart
404
+			default:
405
+				throw new TDBMInvalidOperationException('Unexpected status for bean');
406
+			// @codeCoverageIgnoreEnd
407
+		}
408
+
409
+		$object->_setStatus(TDBMObjectStateEnum::STATE_DELETED);
410
+	}
411
+
412
+	/**
413
+	 * Removes all many to many relationships for this object.
414
+	 *
415
+	 * @param AbstractTDBMObject $object
416
+	 */
417
+	private function deleteManyToManyRelationships(AbstractTDBMObject $object)
418
+	{
419
+		foreach ($object->_getDbRows() as $tableName => $dbRow) {
420
+			$pivotTables = $this->tdbmSchemaAnalyzer->getPivotTableLinkedToTable($tableName);
421
+			foreach ($pivotTables as $pivotTable) {
422
+				$remoteBeans = $object->_getRelationships($pivotTable);
423
+				foreach ($remoteBeans as $remoteBean) {
424
+					$object->_removeRelationship($pivotTable, $remoteBean);
425
+				}
426
+			}
427
+		}
428
+		$this->persistManyToManyRelationships($object);
429
+	}
430
+
431
+	/**
432
+	 * This function removes the given object from the database. It will also remove all objects relied to the one given
433
+	 * by parameter before all.
434
+	 *
435
+	 * Notice: if the object has a multiple primary key, the function will not work.
436
+	 *
437
+	 * @param AbstractTDBMObject $objToDelete
438
+	 */
439
+	public function deleteCascade(AbstractTDBMObject $objToDelete)
440
+	{
441
+		$this->deleteAllConstraintWithThisObject($objToDelete);
442
+		$this->delete($objToDelete);
443
+	}
444
+
445
+	/**
446
+	 * This function is used only in TDBMService (private function)
447
+	 * It will call deleteCascade function foreach object relied with a foreign key to the object given by parameter.
448
+	 *
449
+	 * @param AbstractTDBMObject $obj
450
+	 */
451
+	private function deleteAllConstraintWithThisObject(AbstractTDBMObject $obj)
452
+	{
453
+		$dbRows = $obj->_getDbRows();
454
+		foreach ($dbRows as $dbRow) {
455
+			$tableName = $dbRow->_getDbTableName();
456
+			$pks = array_values($dbRow->_getPrimaryKeys());
457
+			if (!empty($pks)) {
458
+				$incomingFks = $this->tdbmSchemaAnalyzer->getIncomingForeignKeys($tableName);
459
+
460
+				foreach ($incomingFks as $incomingFk) {
461
+					$filter = array_combine($incomingFk->getLocalColumns(), $pks);
462
+
463
+					$results = $this->findObjects($incomingFk->getLocalTableName(), $filter);
464
+
465
+					foreach ($results as $bean) {
466
+						$this->deleteCascade($bean);
467
+					}
468
+				}
469
+			}
470
+		}
471
+	}
472
+
473
+	/**
474
+	 * This function performs a save() of all the objects that have been modified.
475
+	 */
476
+	public function completeSave()
477
+	{
478
+		foreach ($this->toSaveObjects as $dbRow) {
479
+			$this->save($dbRow->getTDBMObject());
480
+		}
481
+	}
482
+
483
+	/**
484
+	 * Takes in input a filter_bag (which can be about anything from a string to an array of TDBMObjects... see above from documentation),
485
+	 * and gives back a proper Filter object.
486
+	 *
487
+	 * @param mixed $filter_bag
488
+	 * @param int   $counter
489
+	 *
490
+	 * @return array First item: filter string, second item: parameters
491
+	 *
492
+	 * @throws TDBMException
493
+	 */
494
+	public function buildFilterFromFilterBag($filter_bag, $counter = 1)
495
+	{
496
+		if ($filter_bag === null) {
497
+			return ['', []];
498
+		} elseif (is_string($filter_bag)) {
499
+			return [$filter_bag, []];
500
+		} elseif (is_array($filter_bag)) {
501
+			$sqlParts = [];
502
+			$parameters = [];
503
+			foreach ($filter_bag as $column => $value) {
504
+				if (is_int($column)) {
505
+					list($subSqlPart, $subParameters) = $this->buildFilterFromFilterBag($value, $counter);
506
+					$sqlParts[] = $subSqlPart;
507
+					$parameters += $subParameters;
508
+				} else {
509
+					$paramName = 'tdbmparam'.$counter;
510
+					if (is_array($value)) {
511
+						$sqlParts[] = $this->connection->quoteIdentifier($column).' IN :'.$paramName;
512
+					} else {
513
+						$sqlParts[] = $this->connection->quoteIdentifier($column).' = :'.$paramName;
514
+					}
515
+					$parameters[$paramName] = $value;
516
+					++$counter;
517
+				}
518
+			}
519
+
520
+			return [implode(' AND ', $sqlParts), $parameters];
521
+		} elseif ($filter_bag instanceof AbstractTDBMObject) {
522
+			$sqlParts = [];
523
+			$parameters = [];
524
+			$dbRows = $filter_bag->_getDbRows();
525
+			$dbRow = reset($dbRows);
526
+			$primaryKeys = $dbRow->_getPrimaryKeys();
527
+
528
+			foreach ($primaryKeys as $column => $value) {
529
+				$paramName = 'tdbmparam'.$counter;
530
+				$sqlParts[] = $this->connection->quoteIdentifier($dbRow->_getDbTableName()).'.'.$this->connection->quoteIdentifier($column).' = :'.$paramName;
531
+				$parameters[$paramName] = $value;
532
+				++$counter;
533
+			}
534
+
535
+			return [implode(' AND ', $sqlParts), $parameters];
536
+		} elseif ($filter_bag instanceof \Iterator) {
537
+			return $this->buildFilterFromFilterBag(iterator_to_array($filter_bag), $counter);
538
+		} else {
539
+			throw new TDBMException('Error in filter. An object has been passed that is neither a SQL string, nor an array, nor a bean, nor null.');
540
+		}
541
+	}
542
+
543
+	/**
544
+	 * @param string $table
545
+	 *
546
+	 * @return string[]
547
+	 */
548
+	public function getPrimaryKeyColumns($table)
549
+	{
550
+		if (!isset($this->primaryKeysColumns[$table])) {
551
+			$this->primaryKeysColumns[$table] = $this->tdbmSchemaAnalyzer->getSchema()->getTable($table)->getPrimaryKeyColumns();
552
+
553
+			// TODO TDBM4: See if we need to improve error reporting if table name does not exist.
554
+
555
+			/*$arr = array();
556 556
             foreach ($this->connection->getPrimaryKey($table) as $col) {
557 557
                 $arr[] = $col->name;
558 558
             }
@@ -573,141 +573,141 @@  discard block
 block discarded – undo
573 573
                     throw new TDBMException($str);
574 574
                 }
575 575
             }*/
576
-        }
577
-
578
-        return $this->primaryKeysColumns[$table];
579
-    }
580
-
581
-    /**
582
-     * This is an internal function, you should not use it in your application.
583
-     * This is used internally by TDBM to add an object to the object cache.
584
-     *
585
-     * @param DbRow $dbRow
586
-     */
587
-    public function _addToCache(DbRow $dbRow)
588
-    {
589
-        $primaryKey = $this->getPrimaryKeysForObjectFromDbRow($dbRow);
590
-        $hash = $this->getObjectHash($primaryKey);
591
-        $this->objectStorage->set($dbRow->_getDbTableName(), $hash, $dbRow);
592
-    }
593
-
594
-    /**
595
-     * This is an internal function, you should not use it in your application.
596
-     * This is used internally by TDBM to remove the object from the list of objects that have been
597
-     * created/updated but not saved yet.
598
-     *
599
-     * @param DbRow $myObject
600
-     */
601
-    private function removeFromToSaveObjectList(DbRow $myObject)
602
-    {
603
-        unset($this->toSaveObjects[$myObject]);
604
-    }
605
-
606
-    /**
607
-     * This is an internal function, you should not use it in your application.
608
-     * This is used internally by TDBM to add an object to the list of objects that have been
609
-     * created/updated but not saved yet.
610
-     *
611
-     * @param AbstractTDBMObject $myObject
612
-     */
613
-    public function _addToToSaveObjectList(DbRow $myObject)
614
-    {
615
-        $this->toSaveObjects[$myObject] = true;
616
-    }
617
-
618
-    /**
619
-     * Generates all the daos and beans.
620
-     *
621
-     * @param string $daoFactoryClassName The classe name of the DAO factory
622
-     * @param string $daonamespace        The namespace for the DAOs, without trailing \
623
-     * @param string $beannamespace       The Namespace for the beans, without trailing \
624
-     * @param bool   $storeInUtc          If the generated daos should store the date in UTC timezone instead of user's timezone
625
-     * @param string $composerFile        If it's set, location of custom Composer file. Relative to project root
626
-     *
627
-     * @return \string[] the list of tables
628
-     */
629
-    public function generateAllDaosAndBeans($daoFactoryClassName, $daonamespace, $beannamespace, $storeInUtc, $composerFile = null)
630
-    {
631
-        // Purge cache before generating anything.
632
-        $this->cache->deleteAll();
633
-
634
-        $tdbmDaoGenerator = new TDBMDaoGenerator($this->schemaAnalyzer, $this->tdbmSchemaAnalyzer->getSchema(), $this->tdbmSchemaAnalyzer);
635
-        if (null !== $composerFile) {
636
-            $tdbmDaoGenerator->setComposerFile(__DIR__.'/../../../../../../../'.$composerFile);
637
-        }
638
-
639
-        return $tdbmDaoGenerator->generateAllDaosAndBeans($daoFactoryClassName, $daonamespace, $beannamespace, $storeInUtc);
640
-    }
641
-
642
-    /**
643
-     * @param array<string, string> $tableToBeanMap
644
-     */
645
-    public function setTableToBeanMap(array $tableToBeanMap)
646
-    {
647
-        $this->tableToBeanMap = $tableToBeanMap;
648
-    }
649
-
650
-    /**
651
-     * Saves $object by INSERTing or UPDAT(E)ing it in the database.
652
-     *
653
-     * @param AbstractTDBMObject $object
654
-     *
655
-     * @throws TDBMException
656
-     */
657
-    public function save(AbstractTDBMObject $object)
658
-    {
659
-        $status = $object->_getStatus();
660
-
661
-        if ($status === null) {
662
-            throw new TDBMException(sprintf('Your bean for class %s has no status. It is likely that you overloaded the __construct method and forgot to call parent::__construct.', get_class($object)));
663
-        }
664
-
665
-        // Let's attach this object if it is in detached state.
666
-        if ($status === TDBMObjectStateEnum::STATE_DETACHED) {
667
-            $object->_attach($this);
668
-            $status = $object->_getStatus();
669
-        }
670
-
671
-        if ($status === TDBMObjectStateEnum::STATE_NEW) {
672
-            $dbRows = $object->_getDbRows();
673
-
674
-            $unindexedPrimaryKeys = array();
675
-
676
-            foreach ($dbRows as $dbRow) {
677
-                $tableName = $dbRow->_getDbTableName();
678
-
679
-                $schema = $this->tdbmSchemaAnalyzer->getSchema();
680
-                $tableDescriptor = $schema->getTable($tableName);
681
-
682
-                $primaryKeyColumns = $this->getPrimaryKeyColumns($tableName);
683
-
684
-                if (empty($unindexedPrimaryKeys)) {
685
-                    $primaryKeys = $this->getPrimaryKeysForObjectFromDbRow($dbRow);
686
-                } else {
687
-                    // First insert, the children must have the same primary key as the parent.
688
-                    $primaryKeys = $this->_getPrimaryKeysFromIndexedPrimaryKeys($tableName, $unindexedPrimaryKeys);
689
-                    $dbRow->_setPrimaryKeys($primaryKeys);
690
-                }
691
-
692
-                $references = $dbRow->_getReferences();
693
-
694
-                // Let's save all references in NEW or DETACHED state (we need their primary key)
695
-                foreach ($references as $fkName => $reference) {
696
-                    if ($reference !== null) {
697
-                        $refStatus = $reference->_getStatus();
698
-                        if ($refStatus === TDBMObjectStateEnum::STATE_NEW || $refStatus === TDBMObjectStateEnum::STATE_DETACHED) {
699
-                            $this->save($reference);
700
-                        }
701
-                    }
702
-                }
703
-
704
-                $dbRowData = $dbRow->_getDbRow();
705
-
706
-                // Let's see if the columns for primary key have been set before inserting.
707
-                // We assume that if one of the value of the PK has been set, the PK is set.
708
-                $isPkSet = !empty($primaryKeys);
709
-
710
-                /*if (!$isPkSet) {
576
+		}
577
+
578
+		return $this->primaryKeysColumns[$table];
579
+	}
580
+
581
+	/**
582
+	 * This is an internal function, you should not use it in your application.
583
+	 * This is used internally by TDBM to add an object to the object cache.
584
+	 *
585
+	 * @param DbRow $dbRow
586
+	 */
587
+	public function _addToCache(DbRow $dbRow)
588
+	{
589
+		$primaryKey = $this->getPrimaryKeysForObjectFromDbRow($dbRow);
590
+		$hash = $this->getObjectHash($primaryKey);
591
+		$this->objectStorage->set($dbRow->_getDbTableName(), $hash, $dbRow);
592
+	}
593
+
594
+	/**
595
+	 * This is an internal function, you should not use it in your application.
596
+	 * This is used internally by TDBM to remove the object from the list of objects that have been
597
+	 * created/updated but not saved yet.
598
+	 *
599
+	 * @param DbRow $myObject
600
+	 */
601
+	private function removeFromToSaveObjectList(DbRow $myObject)
602
+	{
603
+		unset($this->toSaveObjects[$myObject]);
604
+	}
605
+
606
+	/**
607
+	 * This is an internal function, you should not use it in your application.
608
+	 * This is used internally by TDBM to add an object to the list of objects that have been
609
+	 * created/updated but not saved yet.
610
+	 *
611
+	 * @param AbstractTDBMObject $myObject
612
+	 */
613
+	public function _addToToSaveObjectList(DbRow $myObject)
614
+	{
615
+		$this->toSaveObjects[$myObject] = true;
616
+	}
617
+
618
+	/**
619
+	 * Generates all the daos and beans.
620
+	 *
621
+	 * @param string $daoFactoryClassName The classe name of the DAO factory
622
+	 * @param string $daonamespace        The namespace for the DAOs, without trailing \
623
+	 * @param string $beannamespace       The Namespace for the beans, without trailing \
624
+	 * @param bool   $storeInUtc          If the generated daos should store the date in UTC timezone instead of user's timezone
625
+	 * @param string $composerFile        If it's set, location of custom Composer file. Relative to project root
626
+	 *
627
+	 * @return \string[] the list of tables
628
+	 */
629
+	public function generateAllDaosAndBeans($daoFactoryClassName, $daonamespace, $beannamespace, $storeInUtc, $composerFile = null)
630
+	{
631
+		// Purge cache before generating anything.
632
+		$this->cache->deleteAll();
633
+
634
+		$tdbmDaoGenerator = new TDBMDaoGenerator($this->schemaAnalyzer, $this->tdbmSchemaAnalyzer->getSchema(), $this->tdbmSchemaAnalyzer);
635
+		if (null !== $composerFile) {
636
+			$tdbmDaoGenerator->setComposerFile(__DIR__.'/../../../../../../../'.$composerFile);
637
+		}
638
+
639
+		return $tdbmDaoGenerator->generateAllDaosAndBeans($daoFactoryClassName, $daonamespace, $beannamespace, $storeInUtc);
640
+	}
641
+
642
+	/**
643
+	 * @param array<string, string> $tableToBeanMap
644
+	 */
645
+	public function setTableToBeanMap(array $tableToBeanMap)
646
+	{
647
+		$this->tableToBeanMap = $tableToBeanMap;
648
+	}
649
+
650
+	/**
651
+	 * Saves $object by INSERTing or UPDAT(E)ing it in the database.
652
+	 *
653
+	 * @param AbstractTDBMObject $object
654
+	 *
655
+	 * @throws TDBMException
656
+	 */
657
+	public function save(AbstractTDBMObject $object)
658
+	{
659
+		$status = $object->_getStatus();
660
+
661
+		if ($status === null) {
662
+			throw new TDBMException(sprintf('Your bean for class %s has no status. It is likely that you overloaded the __construct method and forgot to call parent::__construct.', get_class($object)));
663
+		}
664
+
665
+		// Let's attach this object if it is in detached state.
666
+		if ($status === TDBMObjectStateEnum::STATE_DETACHED) {
667
+			$object->_attach($this);
668
+			$status = $object->_getStatus();
669
+		}
670
+
671
+		if ($status === TDBMObjectStateEnum::STATE_NEW) {
672
+			$dbRows = $object->_getDbRows();
673
+
674
+			$unindexedPrimaryKeys = array();
675
+
676
+			foreach ($dbRows as $dbRow) {
677
+				$tableName = $dbRow->_getDbTableName();
678
+
679
+				$schema = $this->tdbmSchemaAnalyzer->getSchema();
680
+				$tableDescriptor = $schema->getTable($tableName);
681
+
682
+				$primaryKeyColumns = $this->getPrimaryKeyColumns($tableName);
683
+
684
+				if (empty($unindexedPrimaryKeys)) {
685
+					$primaryKeys = $this->getPrimaryKeysForObjectFromDbRow($dbRow);
686
+				} else {
687
+					// First insert, the children must have the same primary key as the parent.
688
+					$primaryKeys = $this->_getPrimaryKeysFromIndexedPrimaryKeys($tableName, $unindexedPrimaryKeys);
689
+					$dbRow->_setPrimaryKeys($primaryKeys);
690
+				}
691
+
692
+				$references = $dbRow->_getReferences();
693
+
694
+				// Let's save all references in NEW or DETACHED state (we need their primary key)
695
+				foreach ($references as $fkName => $reference) {
696
+					if ($reference !== null) {
697
+						$refStatus = $reference->_getStatus();
698
+						if ($refStatus === TDBMObjectStateEnum::STATE_NEW || $refStatus === TDBMObjectStateEnum::STATE_DETACHED) {
699
+							$this->save($reference);
700
+						}
701
+					}
702
+				}
703
+
704
+				$dbRowData = $dbRow->_getDbRow();
705
+
706
+				// Let's see if the columns for primary key have been set before inserting.
707
+				// We assume that if one of the value of the PK has been set, the PK is set.
708
+				$isPkSet = !empty($primaryKeys);
709
+
710
+				/*if (!$isPkSet) {
711 711
                     // if there is no autoincrement and no pk set, let's go in error.
712 712
                     $isAutoIncrement = true;
713 713
 
@@ -725,27 +725,27 @@  discard block
 block discarded – undo
725 725
 
726 726
                 }*/
727 727
 
728
-                $types = [];
729
-                $escapedDbRowData = [];
728
+				$types = [];
729
+				$escapedDbRowData = [];
730 730
 
731
-                foreach ($dbRowData as $columnName => $value) {
732
-                    $columnDescriptor = $tableDescriptor->getColumn($columnName);
733
-                    $types[] = $columnDescriptor->getType();
734
-                    $escapedDbRowData[$this->connection->quoteIdentifier($columnName)] = $value;
735
-                }
731
+				foreach ($dbRowData as $columnName => $value) {
732
+					$columnDescriptor = $tableDescriptor->getColumn($columnName);
733
+					$types[] = $columnDescriptor->getType();
734
+					$escapedDbRowData[$this->connection->quoteIdentifier($columnName)] = $value;
735
+				}
736 736
 
737
-                $this->connection->insert($tableName, $escapedDbRowData, $types);
737
+				$this->connection->insert($tableName, $escapedDbRowData, $types);
738 738
 
739
-                if (!$isPkSet && count($primaryKeyColumns) == 1) {
740
-                    $id = $this->connection->lastInsertId();
741
-                    $primaryKeys[$primaryKeyColumns[0]] = $id;
742
-                }
739
+				if (!$isPkSet && count($primaryKeyColumns) == 1) {
740
+					$id = $this->connection->lastInsertId();
741
+					$primaryKeys[$primaryKeyColumns[0]] = $id;
742
+				}
743 743
 
744
-                // TODO: change this to some private magic accessor in future
745
-                $dbRow->_setPrimaryKeys($primaryKeys);
746
-                $unindexedPrimaryKeys = array_values($primaryKeys);
744
+				// TODO: change this to some private magic accessor in future
745
+				$dbRow->_setPrimaryKeys($primaryKeys);
746
+				$unindexedPrimaryKeys = array_values($primaryKeys);
747 747
 
748
-                /*
748
+				/*
749 749
                  * When attached, on "save", we check if the column updated is part of a primary key
750 750
                  * If this is part of a primary key, we call the _update_id method that updates the id in the list of known objects.
751 751
                  * This method should first verify that the id is not already used (and is not auto-incremented)
@@ -755,7 +755,7 @@  discard block
 block discarded – undo
755 755
                  *
756 756
                  */
757 757
 
758
-                /*try {
758
+				/*try {
759 759
                     $this->db_connection->exec($sql);
760 760
                 } catch (TDBMException $e) {
761 761
                     $this->db_onerror = true;
@@ -774,468 +774,468 @@  discard block
 block discarded – undo
774 774
                     }
775 775
                 }*/
776 776
 
777
-                // Let's remove this object from the $new_objects static table.
778
-                $this->removeFromToSaveObjectList($dbRow);
779
-
780
-                // TODO: change this behaviour to something more sensible performance-wise
781
-                // Maybe a setting to trigger this globally?
782
-                //$this->status = TDBMObjectStateEnum::STATE_NOT_LOADED;
783
-                //$this->db_modified_state = false;
784
-                //$dbRow = array();
785
-
786
-                // Let's add this object to the list of objects in cache.
787
-                $this->_addToCache($dbRow);
788
-            }
789
-
790
-            $object->_setStatus(TDBMObjectStateEnum::STATE_LOADED);
791
-        } elseif ($status === TDBMObjectStateEnum::STATE_DIRTY) {
792
-            $dbRows = $object->_getDbRows();
793
-
794
-            foreach ($dbRows as $dbRow) {
795
-                $references = $dbRow->_getReferences();
796
-
797
-                // Let's save all references in NEW state (we need their primary key)
798
-                foreach ($references as $fkName => $reference) {
799
-                    if ($reference !== null && $reference->_getStatus() === TDBMObjectStateEnum::STATE_NEW) {
800
-                        $this->save($reference);
801
-                    }
802
-                }
803
-
804
-                // Let's first get the primary keys
805
-                $tableName = $dbRow->_getDbTableName();
806
-                $dbRowData = $dbRow->_getDbRow();
807
-
808
-                $schema = $this->tdbmSchemaAnalyzer->getSchema();
809
-                $tableDescriptor = $schema->getTable($tableName);
810
-
811
-                $primaryKeys = $dbRow->_getPrimaryKeys();
812
-
813
-                $types = [];
814
-                $escapedDbRowData = [];
815
-                $escapedPrimaryKeys = [];
816
-
817
-                foreach ($dbRowData as $columnName => $value) {
818
-                    $columnDescriptor = $tableDescriptor->getColumn($columnName);
819
-                    $types[] = $columnDescriptor->getType();
820
-                    $escapedDbRowData[$this->connection->quoteIdentifier($columnName)] = $value;
821
-                }
822
-                foreach ($primaryKeys as $columnName => $value) {
823
-                    $columnDescriptor = $tableDescriptor->getColumn($columnName);
824
-                    $types[] = $columnDescriptor->getType();
825
-                    $escapedPrimaryKeys[$this->connection->quoteIdentifier($columnName)] = $value;
826
-                }
827
-
828
-                $this->connection->update($tableName, $escapedDbRowData, $escapedPrimaryKeys, $types);
829
-
830
-                // Let's check if the primary key has been updated...
831
-                $needsUpdatePk = false;
832
-                foreach ($primaryKeys as $column => $value) {
833
-                    if (!isset($dbRowData[$column]) || $dbRowData[$column] != $value) {
834
-                        $needsUpdatePk = true;
835
-                        break;
836
-                    }
837
-                }
838
-                if ($needsUpdatePk) {
839
-                    $this->objectStorage->remove($tableName, $this->getObjectHash($primaryKeys));
840
-                    $newPrimaryKeys = $this->getPrimaryKeysForObjectFromDbRow($dbRow);
841
-                    $dbRow->_setPrimaryKeys($newPrimaryKeys);
842
-                    $this->objectStorage->set($tableName, $this->getObjectHash($primaryKeys), $dbRow);
843
-                }
844
-
845
-                // Let's remove this object from the list of objects to save.
846
-                $this->removeFromToSaveObjectList($dbRow);
847
-            }
848
-
849
-            $object->_setStatus(TDBMObjectStateEnum::STATE_LOADED);
850
-        } elseif ($status === TDBMObjectStateEnum::STATE_DELETED) {
851
-            throw new TDBMInvalidOperationException('This object has been deleted. It cannot be saved.');
852
-        }
853
-
854
-        // Finally, let's save all the many to many relationships to this bean.
855
-        $this->persistManyToManyRelationships($object);
856
-    }
857
-
858
-    private function persistManyToManyRelationships(AbstractTDBMObject $object)
859
-    {
860
-        foreach ($object->_getCachedRelationships() as $pivotTableName => $storage) {
861
-            $tableDescriptor = $this->tdbmSchemaAnalyzer->getSchema()->getTable($pivotTableName);
862
-            list($localFk, $remoteFk) = $this->getPivotTableForeignKeys($pivotTableName, $object);
863
-
864
-            $toRemoveFromStorage = [];
865
-
866
-            foreach ($storage as $remoteBean) {
867
-                /* @var $remoteBean AbstractTDBMObject */
868
-                $statusArr = $storage[$remoteBean];
869
-                $status = $statusArr['status'];
870
-                $reverse = $statusArr['reverse'];
871
-                if ($reverse) {
872
-                    continue;
873
-                }
874
-
875
-                if ($status === 'new') {
876
-                    $remoteBeanStatus = $remoteBean->_getStatus();
877
-                    if ($remoteBeanStatus === TDBMObjectStateEnum::STATE_NEW || $remoteBeanStatus === TDBMObjectStateEnum::STATE_DETACHED) {
878
-                        // Let's save remote bean if needed.
879
-                        $this->save($remoteBean);
880
-                    }
881
-
882
-                    $filters = $this->getPivotFilters($object, $remoteBean, $localFk, $remoteFk);
883
-
884
-                    $types = [];
885
-                    $escapedFilters = [];
886
-
887
-                    foreach ($filters as $columnName => $value) {
888
-                        $columnDescriptor = $tableDescriptor->getColumn($columnName);
889
-                        $types[] = $columnDescriptor->getType();
890
-                        $escapedFilters[$this->connection->quoteIdentifier($columnName)] = $value;
891
-                    }
892
-
893
-                    $this->connection->insert($pivotTableName, $escapedFilters, $types);
894
-
895
-                    // Finally, let's mark relationships as saved.
896
-                    $statusArr['status'] = 'loaded';
897
-                    $storage[$remoteBean] = $statusArr;
898
-                    $remoteStorage = $remoteBean->_getCachedRelationships()[$pivotTableName];
899
-                    $remoteStatusArr = $remoteStorage[$object];
900
-                    $remoteStatusArr['status'] = 'loaded';
901
-                    $remoteStorage[$object] = $remoteStatusArr;
902
-                } elseif ($status === 'delete') {
903
-                    $filters = $this->getPivotFilters($object, $remoteBean, $localFk, $remoteFk);
904
-
905
-                    $types = [];
906
-
907
-                    foreach ($filters as $columnName => $value) {
908
-                        $columnDescriptor = $tableDescriptor->getColumn($columnName);
909
-                        $types[] = $columnDescriptor->getType();
910
-                    }
911
-
912
-                    $this->connection->delete($pivotTableName, $filters, $types);
913
-
914
-                    // Finally, let's remove relationships completely from bean.
915
-                    $toRemoveFromStorage[] = $remoteBean;
916
-
917
-                    $remoteBean->_getCachedRelationships()[$pivotTableName]->detach($object);
918
-                }
919
-            }
920
-
921
-            // Note: due to https://bugs.php.net/bug.php?id=65629, we cannot delete an element inside a foreach loop on a SplStorageObject.
922
-            // Therefore, we cache elements in the $toRemoveFromStorage to remove them at a later stage.
923
-            foreach ($toRemoveFromStorage as $remoteBean) {
924
-                $storage->detach($remoteBean);
925
-            }
926
-        }
927
-    }
928
-
929
-    private function getPivotFilters(AbstractTDBMObject $localBean, AbstractTDBMObject $remoteBean, ForeignKeyConstraint $localFk, ForeignKeyConstraint $remoteFk)
930
-    {
931
-        $localBeanPk = $this->getPrimaryKeyValues($localBean);
932
-        $remoteBeanPk = $this->getPrimaryKeyValues($remoteBean);
933
-        $localColumns = $localFk->getLocalColumns();
934
-        $remoteColumns = $remoteFk->getLocalColumns();
935
-
936
-        $localFilters = array_combine($localColumns, $localBeanPk);
937
-        $remoteFilters = array_combine($remoteColumns, $remoteBeanPk);
938
-
939
-        return array_merge($localFilters, $remoteFilters);
940
-    }
941
-
942
-    /**
943
-     * Returns the "values" of the primary key.
944
-     * This returns the primary key from the $primaryKey attribute, not the one stored in the columns.
945
-     *
946
-     * @param AbstractTDBMObject $bean
947
-     *
948
-     * @return array numerically indexed array of values
949
-     */
950
-    private function getPrimaryKeyValues(AbstractTDBMObject $bean)
951
-    {
952
-        $dbRows = $bean->_getDbRows();
953
-        $dbRow = reset($dbRows);
954
-
955
-        return array_values($dbRow->_getPrimaryKeys());
956
-    }
957
-
958
-    /**
959
-     * Returns a unique hash used to store the object based on its primary key.
960
-     * If the array contains only one value, then the value is returned.
961
-     * Otherwise, a hash representing the array is returned.
962
-     *
963
-     * @param array $primaryKeys An array of columns => values forming the primary key
964
-     *
965
-     * @return string
966
-     */
967
-    public function getObjectHash(array $primaryKeys)
968
-    {
969
-        if (count($primaryKeys) === 1) {
970
-            return reset($primaryKeys);
971
-        } else {
972
-            ksort($primaryKeys);
973
-
974
-            return md5(json_encode($primaryKeys));
975
-        }
976
-    }
977
-
978
-    /**
979
-     * Returns an array of primary keys from the object.
980
-     * The primary keys are extracted from the object columns and not from the primary keys stored in the
981
-     * $primaryKeys variable of the object.
982
-     *
983
-     * @param DbRow $dbRow
984
-     *
985
-     * @return array Returns an array of column => value
986
-     */
987
-    public function getPrimaryKeysForObjectFromDbRow(DbRow $dbRow)
988
-    {
989
-        $table = $dbRow->_getDbTableName();
990
-        $dbRowData = $dbRow->_getDbRow();
991
-
992
-        return $this->_getPrimaryKeysFromObjectData($table, $dbRowData);
993
-    }
994
-
995
-    /**
996
-     * Returns an array of primary keys for the given row.
997
-     * The primary keys are extracted from the object columns.
998
-     *
999
-     * @param $table
1000
-     * @param array $columns
1001
-     *
1002
-     * @return array
1003
-     */
1004
-    public function _getPrimaryKeysFromObjectData($table, array $columns)
1005
-    {
1006
-        $primaryKeyColumns = $this->getPrimaryKeyColumns($table);
1007
-        $values = array();
1008
-        foreach ($primaryKeyColumns as $column) {
1009
-            if (isset($columns[$column])) {
1010
-                $values[$column] = $columns[$column];
1011
-            }
1012
-        }
1013
-
1014
-        return $values;
1015
-    }
1016
-
1017
-    /**
1018
-     * Attaches $object to this TDBMService.
1019
-     * The $object must be in DETACHED state and will pass in NEW state.
1020
-     *
1021
-     * @param AbstractTDBMObject $object
1022
-     *
1023
-     * @throws TDBMInvalidOperationException
1024
-     */
1025
-    public function attach(AbstractTDBMObject $object)
1026
-    {
1027
-        $object->_attach($this);
1028
-    }
1029
-
1030
-    /**
1031
-     * Returns an associative array (column => value) for the primary keys from the table name and an
1032
-     * indexed array of primary key values.
1033
-     *
1034
-     * @param string $tableName
1035
-     * @param array  $indexedPrimaryKeys
1036
-     */
1037
-    public function _getPrimaryKeysFromIndexedPrimaryKeys($tableName, array $indexedPrimaryKeys)
1038
-    {
1039
-        $primaryKeyColumns = $this->tdbmSchemaAnalyzer->getSchema()->getTable($tableName)->getPrimaryKeyColumns();
1040
-
1041
-        if (count($primaryKeyColumns) !== count($indexedPrimaryKeys)) {
1042
-            throw new TDBMException(sprintf('Wrong number of columns passed for primary key. Expected %s columns for table "%s",
777
+				// Let's remove this object from the $new_objects static table.
778
+				$this->removeFromToSaveObjectList($dbRow);
779
+
780
+				// TODO: change this behaviour to something more sensible performance-wise
781
+				// Maybe a setting to trigger this globally?
782
+				//$this->status = TDBMObjectStateEnum::STATE_NOT_LOADED;
783
+				//$this->db_modified_state = false;
784
+				//$dbRow = array();
785
+
786
+				// Let's add this object to the list of objects in cache.
787
+				$this->_addToCache($dbRow);
788
+			}
789
+
790
+			$object->_setStatus(TDBMObjectStateEnum::STATE_LOADED);
791
+		} elseif ($status === TDBMObjectStateEnum::STATE_DIRTY) {
792
+			$dbRows = $object->_getDbRows();
793
+
794
+			foreach ($dbRows as $dbRow) {
795
+				$references = $dbRow->_getReferences();
796
+
797
+				// Let's save all references in NEW state (we need their primary key)
798
+				foreach ($references as $fkName => $reference) {
799
+					if ($reference !== null && $reference->_getStatus() === TDBMObjectStateEnum::STATE_NEW) {
800
+						$this->save($reference);
801
+					}
802
+				}
803
+
804
+				// Let's first get the primary keys
805
+				$tableName = $dbRow->_getDbTableName();
806
+				$dbRowData = $dbRow->_getDbRow();
807
+
808
+				$schema = $this->tdbmSchemaAnalyzer->getSchema();
809
+				$tableDescriptor = $schema->getTable($tableName);
810
+
811
+				$primaryKeys = $dbRow->_getPrimaryKeys();
812
+
813
+				$types = [];
814
+				$escapedDbRowData = [];
815
+				$escapedPrimaryKeys = [];
816
+
817
+				foreach ($dbRowData as $columnName => $value) {
818
+					$columnDescriptor = $tableDescriptor->getColumn($columnName);
819
+					$types[] = $columnDescriptor->getType();
820
+					$escapedDbRowData[$this->connection->quoteIdentifier($columnName)] = $value;
821
+				}
822
+				foreach ($primaryKeys as $columnName => $value) {
823
+					$columnDescriptor = $tableDescriptor->getColumn($columnName);
824
+					$types[] = $columnDescriptor->getType();
825
+					$escapedPrimaryKeys[$this->connection->quoteIdentifier($columnName)] = $value;
826
+				}
827
+
828
+				$this->connection->update($tableName, $escapedDbRowData, $escapedPrimaryKeys, $types);
829
+
830
+				// Let's check if the primary key has been updated...
831
+				$needsUpdatePk = false;
832
+				foreach ($primaryKeys as $column => $value) {
833
+					if (!isset($dbRowData[$column]) || $dbRowData[$column] != $value) {
834
+						$needsUpdatePk = true;
835
+						break;
836
+					}
837
+				}
838
+				if ($needsUpdatePk) {
839
+					$this->objectStorage->remove($tableName, $this->getObjectHash($primaryKeys));
840
+					$newPrimaryKeys = $this->getPrimaryKeysForObjectFromDbRow($dbRow);
841
+					$dbRow->_setPrimaryKeys($newPrimaryKeys);
842
+					$this->objectStorage->set($tableName, $this->getObjectHash($primaryKeys), $dbRow);
843
+				}
844
+
845
+				// Let's remove this object from the list of objects to save.
846
+				$this->removeFromToSaveObjectList($dbRow);
847
+			}
848
+
849
+			$object->_setStatus(TDBMObjectStateEnum::STATE_LOADED);
850
+		} elseif ($status === TDBMObjectStateEnum::STATE_DELETED) {
851
+			throw new TDBMInvalidOperationException('This object has been deleted. It cannot be saved.');
852
+		}
853
+
854
+		// Finally, let's save all the many to many relationships to this bean.
855
+		$this->persistManyToManyRelationships($object);
856
+	}
857
+
858
+	private function persistManyToManyRelationships(AbstractTDBMObject $object)
859
+	{
860
+		foreach ($object->_getCachedRelationships() as $pivotTableName => $storage) {
861
+			$tableDescriptor = $this->tdbmSchemaAnalyzer->getSchema()->getTable($pivotTableName);
862
+			list($localFk, $remoteFk) = $this->getPivotTableForeignKeys($pivotTableName, $object);
863
+
864
+			$toRemoveFromStorage = [];
865
+
866
+			foreach ($storage as $remoteBean) {
867
+				/* @var $remoteBean AbstractTDBMObject */
868
+				$statusArr = $storage[$remoteBean];
869
+				$status = $statusArr['status'];
870
+				$reverse = $statusArr['reverse'];
871
+				if ($reverse) {
872
+					continue;
873
+				}
874
+
875
+				if ($status === 'new') {
876
+					$remoteBeanStatus = $remoteBean->_getStatus();
877
+					if ($remoteBeanStatus === TDBMObjectStateEnum::STATE_NEW || $remoteBeanStatus === TDBMObjectStateEnum::STATE_DETACHED) {
878
+						// Let's save remote bean if needed.
879
+						$this->save($remoteBean);
880
+					}
881
+
882
+					$filters = $this->getPivotFilters($object, $remoteBean, $localFk, $remoteFk);
883
+
884
+					$types = [];
885
+					$escapedFilters = [];
886
+
887
+					foreach ($filters as $columnName => $value) {
888
+						$columnDescriptor = $tableDescriptor->getColumn($columnName);
889
+						$types[] = $columnDescriptor->getType();
890
+						$escapedFilters[$this->connection->quoteIdentifier($columnName)] = $value;
891
+					}
892
+
893
+					$this->connection->insert($pivotTableName, $escapedFilters, $types);
894
+
895
+					// Finally, let's mark relationships as saved.
896
+					$statusArr['status'] = 'loaded';
897
+					$storage[$remoteBean] = $statusArr;
898
+					$remoteStorage = $remoteBean->_getCachedRelationships()[$pivotTableName];
899
+					$remoteStatusArr = $remoteStorage[$object];
900
+					$remoteStatusArr['status'] = 'loaded';
901
+					$remoteStorage[$object] = $remoteStatusArr;
902
+				} elseif ($status === 'delete') {
903
+					$filters = $this->getPivotFilters($object, $remoteBean, $localFk, $remoteFk);
904
+
905
+					$types = [];
906
+
907
+					foreach ($filters as $columnName => $value) {
908
+						$columnDescriptor = $tableDescriptor->getColumn($columnName);
909
+						$types[] = $columnDescriptor->getType();
910
+					}
911
+
912
+					$this->connection->delete($pivotTableName, $filters, $types);
913
+
914
+					// Finally, let's remove relationships completely from bean.
915
+					$toRemoveFromStorage[] = $remoteBean;
916
+
917
+					$remoteBean->_getCachedRelationships()[$pivotTableName]->detach($object);
918
+				}
919
+			}
920
+
921
+			// Note: due to https://bugs.php.net/bug.php?id=65629, we cannot delete an element inside a foreach loop on a SplStorageObject.
922
+			// Therefore, we cache elements in the $toRemoveFromStorage to remove them at a later stage.
923
+			foreach ($toRemoveFromStorage as $remoteBean) {
924
+				$storage->detach($remoteBean);
925
+			}
926
+		}
927
+	}
928
+
929
+	private function getPivotFilters(AbstractTDBMObject $localBean, AbstractTDBMObject $remoteBean, ForeignKeyConstraint $localFk, ForeignKeyConstraint $remoteFk)
930
+	{
931
+		$localBeanPk = $this->getPrimaryKeyValues($localBean);
932
+		$remoteBeanPk = $this->getPrimaryKeyValues($remoteBean);
933
+		$localColumns = $localFk->getLocalColumns();
934
+		$remoteColumns = $remoteFk->getLocalColumns();
935
+
936
+		$localFilters = array_combine($localColumns, $localBeanPk);
937
+		$remoteFilters = array_combine($remoteColumns, $remoteBeanPk);
938
+
939
+		return array_merge($localFilters, $remoteFilters);
940
+	}
941
+
942
+	/**
943
+	 * Returns the "values" of the primary key.
944
+	 * This returns the primary key from the $primaryKey attribute, not the one stored in the columns.
945
+	 *
946
+	 * @param AbstractTDBMObject $bean
947
+	 *
948
+	 * @return array numerically indexed array of values
949
+	 */
950
+	private function getPrimaryKeyValues(AbstractTDBMObject $bean)
951
+	{
952
+		$dbRows = $bean->_getDbRows();
953
+		$dbRow = reset($dbRows);
954
+
955
+		return array_values($dbRow->_getPrimaryKeys());
956
+	}
957
+
958
+	/**
959
+	 * Returns a unique hash used to store the object based on its primary key.
960
+	 * If the array contains only one value, then the value is returned.
961
+	 * Otherwise, a hash representing the array is returned.
962
+	 *
963
+	 * @param array $primaryKeys An array of columns => values forming the primary key
964
+	 *
965
+	 * @return string
966
+	 */
967
+	public function getObjectHash(array $primaryKeys)
968
+	{
969
+		if (count($primaryKeys) === 1) {
970
+			return reset($primaryKeys);
971
+		} else {
972
+			ksort($primaryKeys);
973
+
974
+			return md5(json_encode($primaryKeys));
975
+		}
976
+	}
977
+
978
+	/**
979
+	 * Returns an array of primary keys from the object.
980
+	 * The primary keys are extracted from the object columns and not from the primary keys stored in the
981
+	 * $primaryKeys variable of the object.
982
+	 *
983
+	 * @param DbRow $dbRow
984
+	 *
985
+	 * @return array Returns an array of column => value
986
+	 */
987
+	public function getPrimaryKeysForObjectFromDbRow(DbRow $dbRow)
988
+	{
989
+		$table = $dbRow->_getDbTableName();
990
+		$dbRowData = $dbRow->_getDbRow();
991
+
992
+		return $this->_getPrimaryKeysFromObjectData($table, $dbRowData);
993
+	}
994
+
995
+	/**
996
+	 * Returns an array of primary keys for the given row.
997
+	 * The primary keys are extracted from the object columns.
998
+	 *
999
+	 * @param $table
1000
+	 * @param array $columns
1001
+	 *
1002
+	 * @return array
1003
+	 */
1004
+	public function _getPrimaryKeysFromObjectData($table, array $columns)
1005
+	{
1006
+		$primaryKeyColumns = $this->getPrimaryKeyColumns($table);
1007
+		$values = array();
1008
+		foreach ($primaryKeyColumns as $column) {
1009
+			if (isset($columns[$column])) {
1010
+				$values[$column] = $columns[$column];
1011
+			}
1012
+		}
1013
+
1014
+		return $values;
1015
+	}
1016
+
1017
+	/**
1018
+	 * Attaches $object to this TDBMService.
1019
+	 * The $object must be in DETACHED state and will pass in NEW state.
1020
+	 *
1021
+	 * @param AbstractTDBMObject $object
1022
+	 *
1023
+	 * @throws TDBMInvalidOperationException
1024
+	 */
1025
+	public function attach(AbstractTDBMObject $object)
1026
+	{
1027
+		$object->_attach($this);
1028
+	}
1029
+
1030
+	/**
1031
+	 * Returns an associative array (column => value) for the primary keys from the table name and an
1032
+	 * indexed array of primary key values.
1033
+	 *
1034
+	 * @param string $tableName
1035
+	 * @param array  $indexedPrimaryKeys
1036
+	 */
1037
+	public function _getPrimaryKeysFromIndexedPrimaryKeys($tableName, array $indexedPrimaryKeys)
1038
+	{
1039
+		$primaryKeyColumns = $this->tdbmSchemaAnalyzer->getSchema()->getTable($tableName)->getPrimaryKeyColumns();
1040
+
1041
+		if (count($primaryKeyColumns) !== count($indexedPrimaryKeys)) {
1042
+			throw new TDBMException(sprintf('Wrong number of columns passed for primary key. Expected %s columns for table "%s",
1043 1043
 			got %s instead.', count($primaryKeyColumns), $tableName, count($indexedPrimaryKeys)));
1044
-        }
1045
-
1046
-        return array_combine($primaryKeyColumns, $indexedPrimaryKeys);
1047
-    }
1048
-
1049
-    /**
1050
-     * Return the list of tables (from child to parent) joining the tables passed in parameter.
1051
-     * Tables must be in a single line of inheritance. The method will find missing tables.
1052
-     *
1053
-     * Algorithm: one of those tables is the ultimate child. From this child, by recursively getting the parent,
1054
-     * we must be able to find all other tables.
1055
-     *
1056
-     * @param string[] $tables
1057
-     *
1058
-     * @return string[]
1059
-     */
1060
-    public function _getLinkBetweenInheritedTables(array $tables)
1061
-    {
1062
-        sort($tables);
1063
-
1064
-        return $this->fromCache($this->cachePrefix.'_linkbetweeninheritedtables_'.implode('__split__', $tables),
1065
-            function () use ($tables) {
1066
-                return $this->_getLinkBetweenInheritedTablesWithoutCache($tables);
1067
-            });
1068
-    }
1069
-
1070
-    /**
1071
-     * Return the list of tables (from child to parent) joining the tables passed in parameter.
1072
-     * Tables must be in a single line of inheritance. The method will find missing tables.
1073
-     *
1074
-     * Algorithm: one of those tables is the ultimate child. From this child, by recursively getting the parent,
1075
-     * we must be able to find all other tables.
1076
-     *
1077
-     * @param string[] $tables
1078
-     *
1079
-     * @return string[]
1080
-     */
1081
-    private function _getLinkBetweenInheritedTablesWithoutCache(array $tables)
1082
-    {
1083
-        $schemaAnalyzer = $this->schemaAnalyzer;
1084
-
1085
-        foreach ($tables as $currentTable) {
1086
-            $allParents = [$currentTable];
1087
-            while ($currentFk = $schemaAnalyzer->getParentRelationship($currentTable)) {
1088
-                $currentTable = $currentFk->getForeignTableName();
1089
-                $allParents[] = $currentTable;
1090
-            }
1091
-
1092
-            // Now, does the $allParents contain all the tables we want?
1093
-            $notFoundTables = array_diff($tables, $allParents);
1094
-            if (empty($notFoundTables)) {
1095
-                // We have a winner!
1096
-                return $allParents;
1097
-            }
1098
-        }
1099
-
1100
-        throw new TDBMException(sprintf('The tables (%s) cannot be linked by an inheritance relationship.', implode(', ', $tables)));
1101
-    }
1102
-
1103
-    /**
1104
-     * Returns the list of tables related to this table (via a parent or child inheritance relationship).
1105
-     *
1106
-     * @param string $table
1107
-     *
1108
-     * @return string[]
1109
-     */
1110
-    public function _getRelatedTablesByInheritance($table)
1111
-    {
1112
-        return $this->fromCache($this->cachePrefix.'_relatedtables_'.$table, function () use ($table) {
1113
-            return $this->_getRelatedTablesByInheritanceWithoutCache($table);
1114
-        });
1115
-    }
1116
-
1117
-    /**
1118
-     * Returns the list of tables related to this table (via a parent or child inheritance relationship).
1119
-     *
1120
-     * @param string $table
1121
-     *
1122
-     * @return string[]
1123
-     */
1124
-    private function _getRelatedTablesByInheritanceWithoutCache($table)
1125
-    {
1126
-        $schemaAnalyzer = $this->schemaAnalyzer;
1127
-
1128
-        // Let's scan the parent tables
1129
-        $currentTable = $table;
1130
-
1131
-        $parentTables = [];
1132
-
1133
-        // Get parent relationship
1134
-        while ($currentFk = $schemaAnalyzer->getParentRelationship($currentTable)) {
1135
-            $currentTable = $currentFk->getForeignTableName();
1136
-            $parentTables[] = $currentTable;
1137
-        }
1138
-
1139
-        // Let's recurse in children
1140
-        $childrenTables = $this->exploreChildrenTablesRelationships($schemaAnalyzer, $table);
1141
-
1142
-        return array_merge(array_reverse($parentTables), $childrenTables);
1143
-    }
1144
-
1145
-    /**
1146
-     * Explore all the children and descendant of $table and returns ForeignKeyConstraints on those.
1147
-     *
1148
-     * @param string $table
1149
-     *
1150
-     * @return string[]
1151
-     */
1152
-    private function exploreChildrenTablesRelationships(SchemaAnalyzer $schemaAnalyzer, $table)
1153
-    {
1154
-        $tables = [$table];
1155
-        $keys = $schemaAnalyzer->getChildrenRelationships($table);
1156
-
1157
-        foreach ($keys as $key) {
1158
-            $tables = array_merge($tables, $this->exploreChildrenTablesRelationships($schemaAnalyzer, $key->getLocalTableName()));
1159
-        }
1160
-
1161
-        return $tables;
1162
-    }
1163
-
1164
-    /**
1165
-     * @param string $tableName
1166
-     *
1167
-     * @return ForeignKeyConstraint[]
1168
-     */
1169
-    private function getParentRelationshipForeignKeys($tableName)
1170
-    {
1171
-        return $this->fromCache($this->cachePrefix.'_parentrelationshipfks_'.$tableName, function () use ($tableName) {
1172
-            return $this->getParentRelationshipForeignKeysWithoutCache($tableName);
1173
-        });
1174
-    }
1175
-
1176
-    /**
1177
-     * @param string $tableName
1178
-     *
1179
-     * @return ForeignKeyConstraint[]
1180
-     */
1181
-    private function getParentRelationshipForeignKeysWithoutCache($tableName)
1182
-    {
1183
-        $parentFks = [];
1184
-        $currentTable = $tableName;
1185
-        while ($currentFk = $this->schemaAnalyzer->getParentRelationship($currentTable)) {
1186
-            $currentTable = $currentFk->getForeignTableName();
1187
-            $parentFks[] = $currentFk;
1188
-        }
1189
-
1190
-        return $parentFks;
1191
-    }
1192
-
1193
-    /**
1194
-     * @param string $tableName
1195
-     *
1196
-     * @return ForeignKeyConstraint[]
1197
-     */
1198
-    private function getChildrenRelationshipForeignKeys($tableName)
1199
-    {
1200
-        return $this->fromCache($this->cachePrefix.'_childrenrelationshipfks_'.$tableName, function () use ($tableName) {
1201
-            return $this->getChildrenRelationshipForeignKeysWithoutCache($tableName);
1202
-        });
1203
-    }
1204
-
1205
-    /**
1206
-     * @param string $tableName
1207
-     *
1208
-     * @return ForeignKeyConstraint[]
1209
-     */
1210
-    private function getChildrenRelationshipForeignKeysWithoutCache($tableName)
1211
-    {
1212
-        $children = $this->schemaAnalyzer->getChildrenRelationships($tableName);
1213
-
1214
-        if (!empty($children)) {
1215
-            $fksTables = array_map(function (ForeignKeyConstraint $fk) {
1216
-                return $this->getChildrenRelationshipForeignKeys($fk->getLocalTableName());
1217
-            }, $children);
1218
-
1219
-            $fks = array_merge($children, call_user_func_array('array_merge', $fksTables));
1220
-
1221
-            return $fks;
1222
-        } else {
1223
-            return [];
1224
-        }
1225
-    }
1226
-
1227
-    /**
1228
-     * Casts a foreign key into SQL, assuming table name is used with no alias.
1229
-     * The returned value does contain only one table. For instance:.
1230
-     *
1231
-     * " LEFT JOIN table2 ON table1.id = table2.table1_id"
1232
-     *
1233
-     * @param ForeignKeyConstraint $fk
1234
-     * @param bool                 $leftTableIsLocal
1235
-     *
1236
-     * @return string
1237
-     */
1238
-    /*private function foreignKeyToSql(ForeignKeyConstraint $fk, $leftTableIsLocal) {
1044
+		}
1045
+
1046
+		return array_combine($primaryKeyColumns, $indexedPrimaryKeys);
1047
+	}
1048
+
1049
+	/**
1050
+	 * Return the list of tables (from child to parent) joining the tables passed in parameter.
1051
+	 * Tables must be in a single line of inheritance. The method will find missing tables.
1052
+	 *
1053
+	 * Algorithm: one of those tables is the ultimate child. From this child, by recursively getting the parent,
1054
+	 * we must be able to find all other tables.
1055
+	 *
1056
+	 * @param string[] $tables
1057
+	 *
1058
+	 * @return string[]
1059
+	 */
1060
+	public function _getLinkBetweenInheritedTables(array $tables)
1061
+	{
1062
+		sort($tables);
1063
+
1064
+		return $this->fromCache($this->cachePrefix.'_linkbetweeninheritedtables_'.implode('__split__', $tables),
1065
+			function () use ($tables) {
1066
+				return $this->_getLinkBetweenInheritedTablesWithoutCache($tables);
1067
+			});
1068
+	}
1069
+
1070
+	/**
1071
+	 * Return the list of tables (from child to parent) joining the tables passed in parameter.
1072
+	 * Tables must be in a single line of inheritance. The method will find missing tables.
1073
+	 *
1074
+	 * Algorithm: one of those tables is the ultimate child. From this child, by recursively getting the parent,
1075
+	 * we must be able to find all other tables.
1076
+	 *
1077
+	 * @param string[] $tables
1078
+	 *
1079
+	 * @return string[]
1080
+	 */
1081
+	private function _getLinkBetweenInheritedTablesWithoutCache(array $tables)
1082
+	{
1083
+		$schemaAnalyzer = $this->schemaAnalyzer;
1084
+
1085
+		foreach ($tables as $currentTable) {
1086
+			$allParents = [$currentTable];
1087
+			while ($currentFk = $schemaAnalyzer->getParentRelationship($currentTable)) {
1088
+				$currentTable = $currentFk->getForeignTableName();
1089
+				$allParents[] = $currentTable;
1090
+			}
1091
+
1092
+			// Now, does the $allParents contain all the tables we want?
1093
+			$notFoundTables = array_diff($tables, $allParents);
1094
+			if (empty($notFoundTables)) {
1095
+				// We have a winner!
1096
+				return $allParents;
1097
+			}
1098
+		}
1099
+
1100
+		throw new TDBMException(sprintf('The tables (%s) cannot be linked by an inheritance relationship.', implode(', ', $tables)));
1101
+	}
1102
+
1103
+	/**
1104
+	 * Returns the list of tables related to this table (via a parent or child inheritance relationship).
1105
+	 *
1106
+	 * @param string $table
1107
+	 *
1108
+	 * @return string[]
1109
+	 */
1110
+	public function _getRelatedTablesByInheritance($table)
1111
+	{
1112
+		return $this->fromCache($this->cachePrefix.'_relatedtables_'.$table, function () use ($table) {
1113
+			return $this->_getRelatedTablesByInheritanceWithoutCache($table);
1114
+		});
1115
+	}
1116
+
1117
+	/**
1118
+	 * Returns the list of tables related to this table (via a parent or child inheritance relationship).
1119
+	 *
1120
+	 * @param string $table
1121
+	 *
1122
+	 * @return string[]
1123
+	 */
1124
+	private function _getRelatedTablesByInheritanceWithoutCache($table)
1125
+	{
1126
+		$schemaAnalyzer = $this->schemaAnalyzer;
1127
+
1128
+		// Let's scan the parent tables
1129
+		$currentTable = $table;
1130
+
1131
+		$parentTables = [];
1132
+
1133
+		// Get parent relationship
1134
+		while ($currentFk = $schemaAnalyzer->getParentRelationship($currentTable)) {
1135
+			$currentTable = $currentFk->getForeignTableName();
1136
+			$parentTables[] = $currentTable;
1137
+		}
1138
+
1139
+		// Let's recurse in children
1140
+		$childrenTables = $this->exploreChildrenTablesRelationships($schemaAnalyzer, $table);
1141
+
1142
+		return array_merge(array_reverse($parentTables), $childrenTables);
1143
+	}
1144
+
1145
+	/**
1146
+	 * Explore all the children and descendant of $table and returns ForeignKeyConstraints on those.
1147
+	 *
1148
+	 * @param string $table
1149
+	 *
1150
+	 * @return string[]
1151
+	 */
1152
+	private function exploreChildrenTablesRelationships(SchemaAnalyzer $schemaAnalyzer, $table)
1153
+	{
1154
+		$tables = [$table];
1155
+		$keys = $schemaAnalyzer->getChildrenRelationships($table);
1156
+
1157
+		foreach ($keys as $key) {
1158
+			$tables = array_merge($tables, $this->exploreChildrenTablesRelationships($schemaAnalyzer, $key->getLocalTableName()));
1159
+		}
1160
+
1161
+		return $tables;
1162
+	}
1163
+
1164
+	/**
1165
+	 * @param string $tableName
1166
+	 *
1167
+	 * @return ForeignKeyConstraint[]
1168
+	 */
1169
+	private function getParentRelationshipForeignKeys($tableName)
1170
+	{
1171
+		return $this->fromCache($this->cachePrefix.'_parentrelationshipfks_'.$tableName, function () use ($tableName) {
1172
+			return $this->getParentRelationshipForeignKeysWithoutCache($tableName);
1173
+		});
1174
+	}
1175
+
1176
+	/**
1177
+	 * @param string $tableName
1178
+	 *
1179
+	 * @return ForeignKeyConstraint[]
1180
+	 */
1181
+	private function getParentRelationshipForeignKeysWithoutCache($tableName)
1182
+	{
1183
+		$parentFks = [];
1184
+		$currentTable = $tableName;
1185
+		while ($currentFk = $this->schemaAnalyzer->getParentRelationship($currentTable)) {
1186
+			$currentTable = $currentFk->getForeignTableName();
1187
+			$parentFks[] = $currentFk;
1188
+		}
1189
+
1190
+		return $parentFks;
1191
+	}
1192
+
1193
+	/**
1194
+	 * @param string $tableName
1195
+	 *
1196
+	 * @return ForeignKeyConstraint[]
1197
+	 */
1198
+	private function getChildrenRelationshipForeignKeys($tableName)
1199
+	{
1200
+		return $this->fromCache($this->cachePrefix.'_childrenrelationshipfks_'.$tableName, function () use ($tableName) {
1201
+			return $this->getChildrenRelationshipForeignKeysWithoutCache($tableName);
1202
+		});
1203
+	}
1204
+
1205
+	/**
1206
+	 * @param string $tableName
1207
+	 *
1208
+	 * @return ForeignKeyConstraint[]
1209
+	 */
1210
+	private function getChildrenRelationshipForeignKeysWithoutCache($tableName)
1211
+	{
1212
+		$children = $this->schemaAnalyzer->getChildrenRelationships($tableName);
1213
+
1214
+		if (!empty($children)) {
1215
+			$fksTables = array_map(function (ForeignKeyConstraint $fk) {
1216
+				return $this->getChildrenRelationshipForeignKeys($fk->getLocalTableName());
1217
+			}, $children);
1218
+
1219
+			$fks = array_merge($children, call_user_func_array('array_merge', $fksTables));
1220
+
1221
+			return $fks;
1222
+		} else {
1223
+			return [];
1224
+		}
1225
+	}
1226
+
1227
+	/**
1228
+	 * Casts a foreign key into SQL, assuming table name is used with no alias.
1229
+	 * The returned value does contain only one table. For instance:.
1230
+	 *
1231
+	 * " LEFT JOIN table2 ON table1.id = table2.table1_id"
1232
+	 *
1233
+	 * @param ForeignKeyConstraint $fk
1234
+	 * @param bool                 $leftTableIsLocal
1235
+	 *
1236
+	 * @return string
1237
+	 */
1238
+	/*private function foreignKeyToSql(ForeignKeyConstraint $fk, $leftTableIsLocal) {
1239 1239
         $onClauses = [];
1240 1240
         $foreignTableName = $this->connection->quoteIdentifier($fk->getForeignTableName());
1241 1241
         $foreignColumns = $fk->getForeignColumns();
@@ -1261,602 +1261,602 @@  discard block
 block discarded – undo
1261 1261
         }
1262 1262
     }*/
1263 1263
 
1264
-    /**
1265
-     * Returns an identifier for the group of tables passed in parameter.
1266
-     *
1267
-     * @param string[] $relatedTables
1268
-     *
1269
-     * @return string
1270
-     */
1271
-    private function getTableGroupName(array $relatedTables)
1272
-    {
1273
-        sort($relatedTables);
1274
-
1275
-        return implode('_``_', $relatedTables);
1276
-    }
1277
-
1278
-    /**
1279
-     * Returns a `ResultIterator` object representing filtered records of "$mainTable" .
1280
-     *
1281
-     * The findObjects method should be the most used query method in TDBM if you want to query the database for objects.
1282
-     * (Note: if you want to query the database for an object by its primary key, use the findObjectByPk method).
1283
-     *
1284
-     * The findObjects method takes in parameter:
1285
-     * 	- mainTable: the kind of bean you want to retrieve. In TDBM, a bean matches a database row, so the
1286
-     * 			`$mainTable` parameter should be the name of an existing table in database.
1287
-     *  - filter: The filter is a filter bag. It is what you use to filter your request (the WHERE part in SQL).
1288
-     *          It can be a string (SQL Where clause), or even a bean or an associative array (key = column to filter, value = value to find)
1289
-     *  - parameters: The parameters used in the filter. If you pass a SQL string as a filter, be sure to avoid
1290
-     *          concatenating parameters in the string (this leads to SQL injection and also to poor caching performance).
1291
-     *          Instead, please consider passing parameters (see documentation for more details).
1292
-     *  - additionalTablesFetch: An array of SQL tables names. The beans related to those tables will be fetched along
1293
-     *          the main table. This is useful to avoid hitting the database with numerous subqueries.
1294
-     *  - mode: The fetch mode of the result. See `setFetchMode()` method for more details.
1295
-     *
1296
-     * The `findObjects` method will return a `ResultIterator`. A `ResultIterator` is an object that behaves as an array
1297
-     * (in ARRAY mode) at least. It can be iterated using a `foreach` loop.
1298
-     *
1299
-     * Finally, if filter_bag is null, the whole table is returned.
1300
-     *
1301
-     * @param string            $mainTable             The name of the table queried
1302
-     * @param string|array|null $filter                The SQL filters to apply to the query (the WHERE part). All columns must be prefixed by the table name (in the form: table.column)
1303
-     * @param array             $parameters
1304
-     * @param string|null       $orderString           The ORDER BY part of the query. All columns must be prefixed by the table name (in the form: table.column)
1305
-     * @param array             $additionalTablesFetch
1306
-     * @param int               $mode
1307
-     * @param string            $className             Optional: The name of the class to instantiate. This class must extend the TDBMObject class. If none is specified, a TDBMObject instance will be returned
1308
-     *
1309
-     * @return ResultIterator An object representing an array of results
1310
-     *
1311
-     * @throws TDBMException
1312
-     */
1313
-    public function findObjects($mainTable, $filter = null, array $parameters = array(), $orderString = null, array $additionalTablesFetch = array(), $mode = null, $className = null)
1314
-    {
1315
-        // $mainTable is not secured in MagicJoin, let's add a bit of security to avoid SQL injection.
1316
-        if (!preg_match('/^[a-zA-Z_][a-zA-Z0-9_]*$/', $mainTable)) {
1317
-            throw new TDBMException(sprintf("Invalid table name: '%s'", $mainTable));
1318
-        }
1319
-
1320
-        list($filterString, $additionalParameters) = $this->buildFilterFromFilterBag($filter);
1321
-
1322
-        $parameters = array_merge($parameters, $additionalParameters);
1323
-
1324
-        list($columnDescList, $columnsList) = $this->getColumnsList($mainTable, $additionalTablesFetch, $orderString);
1325
-
1326
-        $sql = 'SELECT DISTINCT '.implode(', ', $columnsList).' FROM MAGICJOIN('.$mainTable.')';
1327
-
1328
-        $schema = $this->tdbmSchemaAnalyzer->getSchema();
1329
-        $pkColumnNames = $schema->getTable($mainTable)->getPrimaryKeyColumns();
1330
-        $pkColumnNames = array_map(function ($pkColumn) use ($mainTable) {
1331
-            return $this->connection->quoteIdentifier($mainTable).'.'.$this->connection->quoteIdentifier($pkColumn);
1332
-        }, $pkColumnNames);
1333
-
1334
-        $countSql = 'SELECT COUNT(DISTINCT '.implode(', ', $pkColumnNames).') FROM MAGICJOIN('.$mainTable.')';
1335
-
1336
-        if (!empty($filterString)) {
1337
-            $sql .= ' WHERE '.$filterString;
1338
-            $countSql .= ' WHERE '.$filterString;
1339
-        }
1340
-
1341
-        if (!empty($orderString)) {
1342
-            $sql .= ' ORDER BY '.$orderString;
1343
-        }
1344
-
1345
-        if ($mode !== null && $mode !== self::MODE_CURSOR && $mode !== self::MODE_ARRAY) {
1346
-            throw new TDBMException("Unknown fetch mode: '".$this->mode."'");
1347
-        }
1348
-
1349
-        $mode = $mode ?: $this->mode;
1350
-
1351
-        return new ResultIterator($sql, $countSql, $parameters, $columnDescList, $this->objectStorage, $className, $this, $this->magicQuery, $mode, $this->logger);
1352
-    }
1353
-
1354
-    /**
1355
-     * @param string            $mainTable   The name of the table queried
1356
-     * @param string            $from        The from sql statement
1357
-     * @param string|array|null $filter      The SQL filters to apply to the query (the WHERE part). All columns must be prefixed by the table name (in the form: table.column)
1358
-     * @param array             $parameters
1359
-     * @param string|null       $orderString The ORDER BY part of the query. All columns must be prefixed by the table name (in the form: table.column)
1360
-     * @param int               $mode
1361
-     * @param string            $className   Optional: The name of the class to instantiate. This class must extend the TDBMObject class. If none is specified, a TDBMObject instance will be returned
1362
-     *
1363
-     * @return ResultIterator An object representing an array of results
1364
-     *
1365
-     * @throws TDBMException
1366
-     */
1367
-    public function findObjectsFromSql(string $mainTable, string $from, $filter = null, array $parameters = array(), string $orderString = null, $mode = null, string $className = null)
1368
-    {
1369
-        // $mainTable is not secured in MagicJoin, let's add a bit of security to avoid SQL injection.
1370
-        if (!preg_match('/^[a-zA-Z_][a-zA-Z0-9_]*$/', $mainTable)) {
1371
-            throw new TDBMException(sprintf("Invalid table name: '%s'", $mainTable));
1372
-        }
1373
-
1374
-        $columnsList = null;
1375
-
1376
-        list($filterString, $additionalParameters) = $this->buildFilterFromFilterBag($filter);
1377
-
1378
-        $parameters = array_merge($parameters, $additionalParameters);
1379
-
1380
-        $allFetchedTables = $this->_getRelatedTablesByInheritance($mainTable);
1381
-
1382
-        $columnDescList = [];
1383
-        $schema = $this->tdbmSchemaAnalyzer->getSchema();
1384
-        $tableGroupName = $this->getTableGroupName($allFetchedTables);
1385
-
1386
-        foreach ($schema->getTable($mainTable)->getColumns() as $column) {
1387
-            $columnName = $column->getName();
1388
-            $columnDescList[] = [
1389
-                'as' => $columnName,
1390
-                'table' => $mainTable,
1391
-                'column' => $columnName,
1392
-                'type' => $column->getType(),
1393
-                'tableGroup' => $tableGroupName,
1394
-            ];
1395
-        }
1396
-
1397
-        $sql = 'SELECT DISTINCT '.implode(', ', array_map(function ($columnDesc) use ($mainTable) {
1398
-            return $this->connection->quoteIdentifier($mainTable).'.'.$this->connection->quoteIdentifier($columnDesc['column']);
1399
-        }, $columnDescList)).' FROM '.$from;
1400
-
1401
-        if (count($allFetchedTables) > 1) {
1402
-            list($columnDescList, $columnsList) = $this->getColumnsList($mainTable, [], $orderString);
1403
-        }
1404
-
1405
-        // Let's compute the COUNT.
1406
-        $pkColumnNames = $schema->getTable($mainTable)->getPrimaryKeyColumns();
1407
-        $pkColumnNames = array_map(function ($pkColumn) use ($mainTable) {
1408
-            return $this->connection->quoteIdentifier($mainTable).'.'.$this->connection->quoteIdentifier($pkColumn);
1409
-        }, $pkColumnNames);
1410
-
1411
-        $countSql = 'SELECT COUNT(DISTINCT '.implode(', ', $pkColumnNames).') FROM '.$from;
1412
-
1413
-        if (!empty($filterString)) {
1414
-            $sql .= ' WHERE '.$filterString;
1415
-            $countSql .= ' WHERE '.$filterString;
1416
-        }
1417
-
1418
-        if (!empty($orderString)) {
1419
-            $sql .= ' ORDER BY '.$orderString;
1420
-            $countSql .= ' ORDER BY '.$orderString;
1421
-        }
1422
-
1423
-        if (stripos($countSql, 'GROUP BY') !== false) {
1424
-            throw new TDBMException('Unsupported use of GROUP BY in SQL request.');
1425
-        }
1426
-
1427
-        if ($mode !== null && $mode !== self::MODE_CURSOR && $mode !== self::MODE_ARRAY) {
1428
-            throw new TDBMException("Unknown fetch mode: '".$mode."'");
1429
-        }
1430
-
1431
-        if ($columnsList !== null) {
1432
-            $joinSql = '';
1433
-            $parentFks = $this->getParentRelationshipForeignKeys($mainTable);
1434
-            foreach ($parentFks as $fk) {
1435
-                $joinSql .= sprintf(' JOIN %s ON (%s.%s = %s.%s)',
1436
-                    $this->connection->quoteIdentifier($fk->getForeignTableName()),
1437
-                    $this->connection->quoteIdentifier($fk->getLocalTableName()),
1438
-                    $this->connection->quoteIdentifier($fk->getLocalColumns()[0]),
1439
-                    $this->connection->quoteIdentifier($fk->getForeignTableName()),
1440
-                    $this->connection->quoteIdentifier($fk->getForeignColumns()[0])
1441
-                    );
1442
-            }
1443
-
1444
-            $childrenFks = $this->getChildrenRelationshipForeignKeys($mainTable);
1445
-            foreach ($childrenFks as $fk) {
1446
-                $joinSql .= sprintf(' LEFT JOIN %s ON (%s.%s = %s.%s)',
1447
-                    $this->connection->quoteIdentifier($fk->getLocalTableName()),
1448
-                    $this->connection->quoteIdentifier($fk->getForeignTableName()),
1449
-                    $this->connection->quoteIdentifier($fk->getForeignColumns()[0]),
1450
-                    $this->connection->quoteIdentifier($fk->getLocalTableName()),
1451
-                    $this->connection->quoteIdentifier($fk->getLocalColumns()[0])
1452
-                );
1453
-            }
1454
-
1455
-            $sql = 'SELECT '.implode(', ', $columnsList).' FROM ('.$sql.') AS '.$mainTable.' '.$joinSql;
1456
-        }
1457
-
1458
-        $mode = $mode ?: $this->mode;
1459
-
1460
-        return new ResultIterator($sql, $countSql, $parameters, $columnDescList, $this->objectStorage, $className, $this, $this->magicQuery, $mode, $this->logger);
1461
-    }
1462
-
1463
-    /**
1464
-     * Returns the column list that must be fetched for the SQL request.
1465
-     *
1466
-     * Note: MySQL dictates that ORDER BYed columns should appear in the SELECT clause.
1467
-     *
1468
-     * @param string      $mainTable
1469
-     * @param array       $additionalTablesFetch
1470
-     * @param string|null $orderBy
1471
-     *
1472
-     * @return array
1473
-     *
1474
-     * @throws \Doctrine\DBAL\Schema\SchemaException
1475
-     */
1476
-    private function getColumnsList(string $mainTable, array $additionalTablesFetch = array(), string $orderBy = null)
1477
-    {
1478
-        // From the table name and the additional tables we want to fetch, let's build a list of all tables
1479
-        // that must be part of the select columns.
1480
-
1481
-        $tableGroups = [];
1482
-        $allFetchedTables = $this->_getRelatedTablesByInheritance($mainTable);
1483
-        $tableGroupName = $this->getTableGroupName($allFetchedTables);
1484
-        foreach ($allFetchedTables as $table) {
1485
-            $tableGroups[$table] = $tableGroupName;
1486
-        }
1487
-
1488
-        $columnsList = [];
1489
-        $columnDescList = [];
1490
-        $sortColumn = 0;
1491
-
1492
-        // Now, let's deal with "order by columns"
1493
-        if ($orderBy !== null) {
1494
-            $orderByColumns = $this->orderByAnalyzer->analyzeOrderBy($orderBy);
1495
-
1496
-            // If we sort by a column, there is a high chance we will fetch the bean containing this column.
1497
-            // Hence, we should add the table to the $additionalTablesFetch
1498
-            foreach ($orderByColumns as $orderByColumn) {
1499
-                if ($orderByColumn['type'] === 'colref' && $orderByColumn['table'] !== null) {
1500
-                    $additionalTablesFetch[] = $orderByColumn['table'];
1501
-                } elseif ($orderByColumn['type'] === 'expr') {
1502
-                    $sortColumnName = 'sort_column_'.$sortColumn;
1503
-                    $columnsList[] = $orderByColumn['expr'].' as '.$sortColumnName;
1504
-                    $columnDescList[] = [
1505
-                        'tableGroup' => null,
1506
-                    ];
1507
-                    ++$sortColumn;
1508
-                }
1509
-            }
1510
-        }
1511
-
1512
-        foreach ($additionalTablesFetch as $additionalTable) {
1513
-            $relatedTables = $this->_getRelatedTablesByInheritance($additionalTable);
1514
-            $tableGroupName = $this->getTableGroupName($relatedTables);
1515
-            foreach ($relatedTables as $table) {
1516
-                $tableGroups[$table] = $tableGroupName;
1517
-            }
1518
-            $allFetchedTables = array_merge($allFetchedTables, $relatedTables);
1519
-        }
1520
-
1521
-        // Let's remove any duplicate
1522
-        $allFetchedTables = array_flip(array_flip($allFetchedTables));
1523
-
1524
-        $schema = $this->tdbmSchemaAnalyzer->getSchema();
1525
-
1526
-        // Now, let's build the column list
1527
-        foreach ($allFetchedTables as $table) {
1528
-            foreach ($schema->getTable($table)->getColumns() as $column) {
1529
-                $columnName = $column->getName();
1530
-                $columnDescList[] = [
1531
-                    'as' => $table.'____'.$columnName,
1532
-                    'table' => $table,
1533
-                    'column' => $columnName,
1534
-                    'type' => $column->getType(),
1535
-                    'tableGroup' => $tableGroups[$table],
1536
-                ];
1537
-                $columnsList[] = $this->connection->quoteIdentifier($table).'.'.$this->connection->quoteIdentifier($columnName).' as '.
1538
-                    $this->connection->quoteIdentifier($table.'____'.$columnName);
1539
-            }
1540
-        }
1541
-
1542
-        return [$columnDescList, $columnsList];
1543
-    }
1544
-
1545
-    /**
1546
-     * @param $table
1547
-     * @param array  $primaryKeys
1548
-     * @param array  $additionalTablesFetch
1549
-     * @param bool   $lazy                  Whether to perform lazy loading on this object or not
1550
-     * @param string $className
1551
-     *
1552
-     * @return AbstractTDBMObject
1553
-     *
1554
-     * @throws TDBMException
1555
-     */
1556
-    public function findObjectByPk(string $table, array $primaryKeys, array $additionalTablesFetch = array(), bool $lazy = false, string $className = null)
1557
-    {
1558
-        $primaryKeys = $this->_getPrimaryKeysFromObjectData($table, $primaryKeys);
1559
-        $hash = $this->getObjectHash($primaryKeys);
1560
-
1561
-        if ($this->objectStorage->has($table, $hash)) {
1562
-            $dbRow = $this->objectStorage->get($table, $hash);
1563
-            $bean = $dbRow->getTDBMObject();
1564
-            if ($className !== null && !is_a($bean, $className)) {
1565
-                throw new TDBMException("TDBM cannot create a bean of class '".$className."'. The requested object was already loaded and its class is '".get_class($bean)."'");
1566
-            }
1567
-
1568
-            return $bean;
1569
-        }
1570
-
1571
-        // Are we performing lazy fetching?
1572
-        if ($lazy === true) {
1573
-            // Can we perform lazy fetching?
1574
-            $tables = $this->_getRelatedTablesByInheritance($table);
1575
-            // Only allowed if no inheritance.
1576
-            if (count($tables) === 1) {
1577
-                if ($className === null) {
1578
-                    $className = isset($this->tableToBeanMap[$table]) ? $this->tableToBeanMap[$table] : 'Mouf\\Database\\TDBM\\TDBMObject';
1579
-                }
1580
-
1581
-                // Let's construct the bean
1582
-                if (!isset($this->reflectionClassCache[$className])) {
1583
-                    $this->reflectionClassCache[$className] = new \ReflectionClass($className);
1584
-                }
1585
-                // Let's bypass the constructor when creating the bean!
1586
-                $bean = $this->reflectionClassCache[$className]->newInstanceWithoutConstructor();
1587
-                /* @var $bean AbstractTDBMObject */
1588
-                $bean->_constructLazy($table, $primaryKeys, $this);
1589
-
1590
-                return $bean;
1591
-            }
1592
-        }
1593
-
1594
-        // Did not find the object in cache? Let's query it!
1595
-        return $this->findObjectOrFail($table, $primaryKeys, [], $additionalTablesFetch, $className);
1596
-    }
1597
-
1598
-    /**
1599
-     * Returns a unique bean (or null) according to the filters passed in parameter.
1600
-     *
1601
-     * @param string            $mainTable             The name of the table queried
1602
-     * @param string|array|null $filter                The SQL filters to apply to the query (the WHERE part). All columns must be prefixed by the table name (in the form: table.column)
1603
-     * @param array             $parameters
1604
-     * @param array             $additionalTablesFetch
1605
-     * @param string            $className             Optional: The name of the class to instantiate. This class must extend the TDBMObject class. If none is specified, a TDBMObject instance will be returned
1606
-     *
1607
-     * @return AbstractTDBMObject|null The object we want, or null if no object matches the filters
1608
-     *
1609
-     * @throws TDBMException
1610
-     */
1611
-    public function findObject(string $mainTable, $filter = null, array $parameters = array(), array $additionalTablesFetch = array(), string $className = null)
1612
-    {
1613
-        $objects = $this->findObjects($mainTable, $filter, $parameters, null, $additionalTablesFetch, self::MODE_ARRAY, $className);
1614
-        $page = $objects->take(0, 2);
1615
-        $count = $page->count();
1616
-        if ($count > 1) {
1617
-            throw new DuplicateRowException("Error while querying an object for table '$mainTable': More than 1 row have been returned, but we should have received at most one.");
1618
-        } elseif ($count === 0) {
1619
-            return;
1620
-        }
1621
-
1622
-        return $page[0];
1623
-    }
1624
-
1625
-    /**
1626
-     * Returns a unique bean (or null) according to the filters passed in parameter.
1627
-     *
1628
-     * @param string            $mainTable  The name of the table queried
1629
-     * @param string            $from       The from sql statement
1630
-     * @param string|array|null $filter     The SQL filters to apply to the query (the WHERE part). All columns must be prefixed by the table name (in the form: table.column)
1631
-     * @param array             $parameters
1632
-     * @param string            $className  Optional: The name of the class to instantiate. This class must extend the TDBMObject class. If none is specified, a TDBMObject instance will be returned
1633
-     *
1634
-     * @return AbstractTDBMObject|null The object we want, or null if no object matches the filters
1635
-     *
1636
-     * @throws TDBMException
1637
-     */
1638
-    public function findObjectFromSql($mainTable, $from, $filter = null, array $parameters = array(), $className = null)
1639
-    {
1640
-        $objects = $this->findObjectsFromSql($mainTable, $from, $filter, $parameters, null, self::MODE_ARRAY, $className);
1641
-        $page = $objects->take(0, 2);
1642
-        $count = $page->count();
1643
-        if ($count > 1) {
1644
-            throw new DuplicateRowException("Error while querying an object for table '$mainTable': More than 1 row have been returned, but we should have received at most one.");
1645
-        } elseif ($count === 0) {
1646
-            return;
1647
-        }
1648
-
1649
-        return $page[0];
1650
-    }
1651
-
1652
-    /**
1653
-     * Returns a unique bean according to the filters passed in parameter.
1654
-     * Throws a NoBeanFoundException if no bean was found for the filter passed in parameter.
1655
-     *
1656
-     * @param string            $mainTable             The name of the table queried
1657
-     * @param string|array|null $filter                The SQL filters to apply to the query (the WHERE part). All columns must be prefixed by the table name (in the form: table.column)
1658
-     * @param array             $parameters
1659
-     * @param array             $additionalTablesFetch
1660
-     * @param string            $className             Optional: The name of the class to instantiate. This class must extend the TDBMObject class. If none is specified, a TDBMObject instance will be returned
1661
-     *
1662
-     * @return AbstractTDBMObject The object we want
1663
-     *
1664
-     * @throws TDBMException
1665
-     */
1666
-    public function findObjectOrFail(string $mainTable, $filter = null, array $parameters = array(), array $additionalTablesFetch = array(), string $className = null)
1667
-    {
1668
-        $bean = $this->findObject($mainTable, $filter, $parameters, $additionalTablesFetch, $className);
1669
-        if ($bean === null) {
1670
-            throw new NoBeanFoundException("No result found for query on table '".$mainTable."'");
1671
-        }
1672
-
1673
-        return $bean;
1674
-    }
1675
-
1676
-    /**
1677
-     * @param array $beanData An array of data: array<table, array<column, value>>
1678
-     *
1679
-     * @return array an array with first item = class name, second item = table name and third item = list of tables needed
1680
-     */
1681
-    public function _getClassNameFromBeanData(array $beanData)
1682
-    {
1683
-        if (count($beanData) === 1) {
1684
-            $tableName = array_keys($beanData)[0];
1685
-            $allTables = [$tableName];
1686
-        } else {
1687
-            $tables = [];
1688
-            foreach ($beanData as $table => $row) {
1689
-                $primaryKeyColumns = $this->getPrimaryKeyColumns($table);
1690
-                $pkSet = false;
1691
-                foreach ($primaryKeyColumns as $columnName) {
1692
-                    if ($row[$columnName] !== null) {
1693
-                        $pkSet = true;
1694
-                        break;
1695
-                    }
1696
-                }
1697
-                if ($pkSet) {
1698
-                    $tables[] = $table;
1699
-                }
1700
-            }
1701
-
1702
-            // $tables contains the tables for this bean. Let's view the top most part of the hierarchy
1703
-            $allTables = $this->_getLinkBetweenInheritedTables($tables);
1704
-            $tableName = $allTables[0];
1705
-        }
1706
-
1707
-        // Only one table in this bean. Life is sweat, let's look at its type:
1708
-        if (isset($this->tableToBeanMap[$tableName])) {
1709
-            return [$this->tableToBeanMap[$tableName], $tableName, $allTables];
1710
-        } else {
1711
-            return ['Mouf\\Database\\TDBM\\TDBMObject', $tableName, $allTables];
1712
-        }
1713
-    }
1714
-
1715
-    /**
1716
-     * Returns an item from cache or computes it using $closure and puts it in cache.
1717
-     *
1718
-     * @param string   $key
1719
-     * @param callable $closure
1720
-     *
1721
-     * @return mixed
1722
-     */
1723
-    private function fromCache(string $key, callable $closure)
1724
-    {
1725
-        $item = $this->cache->fetch($key);
1726
-        if ($item === false) {
1727
-            $item = $closure();
1728
-            $this->cache->save($key, $item);
1729
-        }
1730
-
1731
-        return $item;
1732
-    }
1733
-
1734
-    /**
1735
-     * Returns the foreign key object.
1736
-     *
1737
-     * @param string $table
1738
-     * @param string $fkName
1739
-     *
1740
-     * @return ForeignKeyConstraint
1741
-     */
1742
-    public function _getForeignKeyByName(string $table, string $fkName)
1743
-    {
1744
-        return $this->tdbmSchemaAnalyzer->getSchema()->getTable($table)->getForeignKey($fkName);
1745
-    }
1746
-
1747
-    /**
1748
-     * @param $pivotTableName
1749
-     * @param AbstractTDBMObject $bean
1750
-     *
1751
-     * @return AbstractTDBMObject[]
1752
-     */
1753
-    public function _getRelatedBeans(string $pivotTableName, AbstractTDBMObject $bean)
1754
-    {
1755
-        list($localFk, $remoteFk) = $this->getPivotTableForeignKeys($pivotTableName, $bean);
1756
-        /* @var $localFk ForeignKeyConstraint */
1757
-        /* @var $remoteFk ForeignKeyConstraint */
1758
-        $remoteTable = $remoteFk->getForeignTableName();
1759
-
1760
-        $primaryKeys = $this->getPrimaryKeyValues($bean);
1761
-        $columnNames = array_map(function ($name) use ($pivotTableName) {
1762
-            return $pivotTableName.'.'.$name;
1763
-        }, $localFk->getLocalColumns());
1764
-
1765
-        $filter = array_combine($columnNames, $primaryKeys);
1766
-
1767
-        return $this->findObjects($remoteTable, $filter);
1768
-    }
1769
-
1770
-    /**
1771
-     * @param $pivotTableName
1772
-     * @param AbstractTDBMObject $bean The LOCAL bean
1773
-     *
1774
-     * @return ForeignKeyConstraint[] First item: the LOCAL bean, second item: the REMOTE bean
1775
-     *
1776
-     * @throws TDBMException
1777
-     */
1778
-    private function getPivotTableForeignKeys(string $pivotTableName, AbstractTDBMObject $bean)
1779
-    {
1780
-        $fks = array_values($this->tdbmSchemaAnalyzer->getSchema()->getTable($pivotTableName)->getForeignKeys());
1781
-        $table1 = $fks[0]->getForeignTableName();
1782
-        $table2 = $fks[1]->getForeignTableName();
1783
-
1784
-        $beanTables = array_map(function (DbRow $dbRow) {
1785
-            return $dbRow->_getDbTableName();
1786
-        }, $bean->_getDbRows());
1787
-
1788
-        if (in_array($table1, $beanTables)) {
1789
-            return [$fks[0], $fks[1]];
1790
-        } elseif (in_array($table2, $beanTables)) {
1791
-            return [$fks[1], $fks[0]];
1792
-        } else {
1793
-            throw new TDBMException("Unexpected bean type in getPivotTableForeignKeys. Awaiting beans from table {$table1} and {$table2} for pivot table {$pivotTableName}");
1794
-        }
1795
-    }
1796
-
1797
-    /**
1798
-     * Returns a list of pivot tables linked to $bean.
1799
-     *
1800
-     * @param AbstractTDBMObject $bean
1801
-     *
1802
-     * @return string[]
1803
-     */
1804
-    public function _getPivotTablesLinkedToBean(AbstractTDBMObject $bean)
1805
-    {
1806
-        $junctionTables = [];
1807
-        $allJunctionTables = $this->schemaAnalyzer->detectJunctionTables(true);
1808
-        foreach ($bean->_getDbRows() as $dbRow) {
1809
-            foreach ($allJunctionTables as $table) {
1810
-                // There are exactly 2 FKs since this is a pivot table.
1811
-                $fks = array_values($table->getForeignKeys());
1812
-
1813
-                if ($fks[0]->getForeignTableName() === $dbRow->_getDbTableName() || $fks[1]->getForeignTableName() === $dbRow->_getDbTableName()) {
1814
-                    $junctionTables[] = $table->getName();
1815
-                }
1816
-            }
1817
-        }
1818
-
1819
-        return $junctionTables;
1820
-    }
1821
-
1822
-    /**
1823
-     * Array of types for tables.
1824
-     * Key: table name
1825
-     * Value: array of types indexed by column.
1826
-     *
1827
-     * @var array[]
1828
-     */
1829
-    private $typesForTable = [];
1830
-
1831
-    /**
1832
-     * @internal
1833
-     *
1834
-     * @param string $tableName
1835
-     *
1836
-     * @return Type[]
1837
-     */
1838
-    public function _getColumnTypesForTable(string $tableName)
1839
-    {
1840
-        if (!isset($typesForTable[$tableName])) {
1841
-            $columns = $this->tdbmSchemaAnalyzer->getSchema()->getTable($tableName)->getColumns();
1842
-            $typesForTable[$tableName] = array_map(function (Column $column) {
1843
-                return $column->getType();
1844
-            }, $columns);
1845
-        }
1846
-
1847
-        return $typesForTable[$tableName];
1848
-    }
1849
-
1850
-    /**
1851
-     * Sets the minimum log level.
1852
-     * $level must be one of Psr\Log\LogLevel::xxx.
1853
-     *
1854
-     * Defaults to LogLevel::WARNING
1855
-     *
1856
-     * @param string $level
1857
-     */
1858
-    public function setLogLevel(string $level)
1859
-    {
1860
-        $this->logger = new MinLogLevelFilter($this->rootLogger, $level);
1861
-    }
1264
+	/**
1265
+	 * Returns an identifier for the group of tables passed in parameter.
1266
+	 *
1267
+	 * @param string[] $relatedTables
1268
+	 *
1269
+	 * @return string
1270
+	 */
1271
+	private function getTableGroupName(array $relatedTables)
1272
+	{
1273
+		sort($relatedTables);
1274
+
1275
+		return implode('_``_', $relatedTables);
1276
+	}
1277
+
1278
+	/**
1279
+	 * Returns a `ResultIterator` object representing filtered records of "$mainTable" .
1280
+	 *
1281
+	 * The findObjects method should be the most used query method in TDBM if you want to query the database for objects.
1282
+	 * (Note: if you want to query the database for an object by its primary key, use the findObjectByPk method).
1283
+	 *
1284
+	 * The findObjects method takes in parameter:
1285
+	 * 	- mainTable: the kind of bean you want to retrieve. In TDBM, a bean matches a database row, so the
1286
+	 * 			`$mainTable` parameter should be the name of an existing table in database.
1287
+	 *  - filter: The filter is a filter bag. It is what you use to filter your request (the WHERE part in SQL).
1288
+	 *          It can be a string (SQL Where clause), or even a bean or an associative array (key = column to filter, value = value to find)
1289
+	 *  - parameters: The parameters used in the filter. If you pass a SQL string as a filter, be sure to avoid
1290
+	 *          concatenating parameters in the string (this leads to SQL injection and also to poor caching performance).
1291
+	 *          Instead, please consider passing parameters (see documentation for more details).
1292
+	 *  - additionalTablesFetch: An array of SQL tables names. The beans related to those tables will be fetched along
1293
+	 *          the main table. This is useful to avoid hitting the database with numerous subqueries.
1294
+	 *  - mode: The fetch mode of the result. See `setFetchMode()` method for more details.
1295
+	 *
1296
+	 * The `findObjects` method will return a `ResultIterator`. A `ResultIterator` is an object that behaves as an array
1297
+	 * (in ARRAY mode) at least. It can be iterated using a `foreach` loop.
1298
+	 *
1299
+	 * Finally, if filter_bag is null, the whole table is returned.
1300
+	 *
1301
+	 * @param string            $mainTable             The name of the table queried
1302
+	 * @param string|array|null $filter                The SQL filters to apply to the query (the WHERE part). All columns must be prefixed by the table name (in the form: table.column)
1303
+	 * @param array             $parameters
1304
+	 * @param string|null       $orderString           The ORDER BY part of the query. All columns must be prefixed by the table name (in the form: table.column)
1305
+	 * @param array             $additionalTablesFetch
1306
+	 * @param int               $mode
1307
+	 * @param string            $className             Optional: The name of the class to instantiate. This class must extend the TDBMObject class. If none is specified, a TDBMObject instance will be returned
1308
+	 *
1309
+	 * @return ResultIterator An object representing an array of results
1310
+	 *
1311
+	 * @throws TDBMException
1312
+	 */
1313
+	public function findObjects($mainTable, $filter = null, array $parameters = array(), $orderString = null, array $additionalTablesFetch = array(), $mode = null, $className = null)
1314
+	{
1315
+		// $mainTable is not secured in MagicJoin, let's add a bit of security to avoid SQL injection.
1316
+		if (!preg_match('/^[a-zA-Z_][a-zA-Z0-9_]*$/', $mainTable)) {
1317
+			throw new TDBMException(sprintf("Invalid table name: '%s'", $mainTable));
1318
+		}
1319
+
1320
+		list($filterString, $additionalParameters) = $this->buildFilterFromFilterBag($filter);
1321
+
1322
+		$parameters = array_merge($parameters, $additionalParameters);
1323
+
1324
+		list($columnDescList, $columnsList) = $this->getColumnsList($mainTable, $additionalTablesFetch, $orderString);
1325
+
1326
+		$sql = 'SELECT DISTINCT '.implode(', ', $columnsList).' FROM MAGICJOIN('.$mainTable.')';
1327
+
1328
+		$schema = $this->tdbmSchemaAnalyzer->getSchema();
1329
+		$pkColumnNames = $schema->getTable($mainTable)->getPrimaryKeyColumns();
1330
+		$pkColumnNames = array_map(function ($pkColumn) use ($mainTable) {
1331
+			return $this->connection->quoteIdentifier($mainTable).'.'.$this->connection->quoteIdentifier($pkColumn);
1332
+		}, $pkColumnNames);
1333
+
1334
+		$countSql = 'SELECT COUNT(DISTINCT '.implode(', ', $pkColumnNames).') FROM MAGICJOIN('.$mainTable.')';
1335
+
1336
+		if (!empty($filterString)) {
1337
+			$sql .= ' WHERE '.$filterString;
1338
+			$countSql .= ' WHERE '.$filterString;
1339
+		}
1340
+
1341
+		if (!empty($orderString)) {
1342
+			$sql .= ' ORDER BY '.$orderString;
1343
+		}
1344
+
1345
+		if ($mode !== null && $mode !== self::MODE_CURSOR && $mode !== self::MODE_ARRAY) {
1346
+			throw new TDBMException("Unknown fetch mode: '".$this->mode."'");
1347
+		}
1348
+
1349
+		$mode = $mode ?: $this->mode;
1350
+
1351
+		return new ResultIterator($sql, $countSql, $parameters, $columnDescList, $this->objectStorage, $className, $this, $this->magicQuery, $mode, $this->logger);
1352
+	}
1353
+
1354
+	/**
1355
+	 * @param string            $mainTable   The name of the table queried
1356
+	 * @param string            $from        The from sql statement
1357
+	 * @param string|array|null $filter      The SQL filters to apply to the query (the WHERE part). All columns must be prefixed by the table name (in the form: table.column)
1358
+	 * @param array             $parameters
1359
+	 * @param string|null       $orderString The ORDER BY part of the query. All columns must be prefixed by the table name (in the form: table.column)
1360
+	 * @param int               $mode
1361
+	 * @param string            $className   Optional: The name of the class to instantiate. This class must extend the TDBMObject class. If none is specified, a TDBMObject instance will be returned
1362
+	 *
1363
+	 * @return ResultIterator An object representing an array of results
1364
+	 *
1365
+	 * @throws TDBMException
1366
+	 */
1367
+	public function findObjectsFromSql(string $mainTable, string $from, $filter = null, array $parameters = array(), string $orderString = null, $mode = null, string $className = null)
1368
+	{
1369
+		// $mainTable is not secured in MagicJoin, let's add a bit of security to avoid SQL injection.
1370
+		if (!preg_match('/^[a-zA-Z_][a-zA-Z0-9_]*$/', $mainTable)) {
1371
+			throw new TDBMException(sprintf("Invalid table name: '%s'", $mainTable));
1372
+		}
1373
+
1374
+		$columnsList = null;
1375
+
1376
+		list($filterString, $additionalParameters) = $this->buildFilterFromFilterBag($filter);
1377
+
1378
+		$parameters = array_merge($parameters, $additionalParameters);
1379
+
1380
+		$allFetchedTables = $this->_getRelatedTablesByInheritance($mainTable);
1381
+
1382
+		$columnDescList = [];
1383
+		$schema = $this->tdbmSchemaAnalyzer->getSchema();
1384
+		$tableGroupName = $this->getTableGroupName($allFetchedTables);
1385
+
1386
+		foreach ($schema->getTable($mainTable)->getColumns() as $column) {
1387
+			$columnName = $column->getName();
1388
+			$columnDescList[] = [
1389
+				'as' => $columnName,
1390
+				'table' => $mainTable,
1391
+				'column' => $columnName,
1392
+				'type' => $column->getType(),
1393
+				'tableGroup' => $tableGroupName,
1394
+			];
1395
+		}
1396
+
1397
+		$sql = 'SELECT DISTINCT '.implode(', ', array_map(function ($columnDesc) use ($mainTable) {
1398
+			return $this->connection->quoteIdentifier($mainTable).'.'.$this->connection->quoteIdentifier($columnDesc['column']);
1399
+		}, $columnDescList)).' FROM '.$from;
1400
+
1401
+		if (count($allFetchedTables) > 1) {
1402
+			list($columnDescList, $columnsList) = $this->getColumnsList($mainTable, [], $orderString);
1403
+		}
1404
+
1405
+		// Let's compute the COUNT.
1406
+		$pkColumnNames = $schema->getTable($mainTable)->getPrimaryKeyColumns();
1407
+		$pkColumnNames = array_map(function ($pkColumn) use ($mainTable) {
1408
+			return $this->connection->quoteIdentifier($mainTable).'.'.$this->connection->quoteIdentifier($pkColumn);
1409
+		}, $pkColumnNames);
1410
+
1411
+		$countSql = 'SELECT COUNT(DISTINCT '.implode(', ', $pkColumnNames).') FROM '.$from;
1412
+
1413
+		if (!empty($filterString)) {
1414
+			$sql .= ' WHERE '.$filterString;
1415
+			$countSql .= ' WHERE '.$filterString;
1416
+		}
1417
+
1418
+		if (!empty($orderString)) {
1419
+			$sql .= ' ORDER BY '.$orderString;
1420
+			$countSql .= ' ORDER BY '.$orderString;
1421
+		}
1422
+
1423
+		if (stripos($countSql, 'GROUP BY') !== false) {
1424
+			throw new TDBMException('Unsupported use of GROUP BY in SQL request.');
1425
+		}
1426
+
1427
+		if ($mode !== null && $mode !== self::MODE_CURSOR && $mode !== self::MODE_ARRAY) {
1428
+			throw new TDBMException("Unknown fetch mode: '".$mode."'");
1429
+		}
1430
+
1431
+		if ($columnsList !== null) {
1432
+			$joinSql = '';
1433
+			$parentFks = $this->getParentRelationshipForeignKeys($mainTable);
1434
+			foreach ($parentFks as $fk) {
1435
+				$joinSql .= sprintf(' JOIN %s ON (%s.%s = %s.%s)',
1436
+					$this->connection->quoteIdentifier($fk->getForeignTableName()),
1437
+					$this->connection->quoteIdentifier($fk->getLocalTableName()),
1438
+					$this->connection->quoteIdentifier($fk->getLocalColumns()[0]),
1439
+					$this->connection->quoteIdentifier($fk->getForeignTableName()),
1440
+					$this->connection->quoteIdentifier($fk->getForeignColumns()[0])
1441
+					);
1442
+			}
1443
+
1444
+			$childrenFks = $this->getChildrenRelationshipForeignKeys($mainTable);
1445
+			foreach ($childrenFks as $fk) {
1446
+				$joinSql .= sprintf(' LEFT JOIN %s ON (%s.%s = %s.%s)',
1447
+					$this->connection->quoteIdentifier($fk->getLocalTableName()),
1448
+					$this->connection->quoteIdentifier($fk->getForeignTableName()),
1449
+					$this->connection->quoteIdentifier($fk->getForeignColumns()[0]),
1450
+					$this->connection->quoteIdentifier($fk->getLocalTableName()),
1451
+					$this->connection->quoteIdentifier($fk->getLocalColumns()[0])
1452
+				);
1453
+			}
1454
+
1455
+			$sql = 'SELECT '.implode(', ', $columnsList).' FROM ('.$sql.') AS '.$mainTable.' '.$joinSql;
1456
+		}
1457
+
1458
+		$mode = $mode ?: $this->mode;
1459
+
1460
+		return new ResultIterator($sql, $countSql, $parameters, $columnDescList, $this->objectStorage, $className, $this, $this->magicQuery, $mode, $this->logger);
1461
+	}
1462
+
1463
+	/**
1464
+	 * Returns the column list that must be fetched for the SQL request.
1465
+	 *
1466
+	 * Note: MySQL dictates that ORDER BYed columns should appear in the SELECT clause.
1467
+	 *
1468
+	 * @param string      $mainTable
1469
+	 * @param array       $additionalTablesFetch
1470
+	 * @param string|null $orderBy
1471
+	 *
1472
+	 * @return array
1473
+	 *
1474
+	 * @throws \Doctrine\DBAL\Schema\SchemaException
1475
+	 */
1476
+	private function getColumnsList(string $mainTable, array $additionalTablesFetch = array(), string $orderBy = null)
1477
+	{
1478
+		// From the table name and the additional tables we want to fetch, let's build a list of all tables
1479
+		// that must be part of the select columns.
1480
+
1481
+		$tableGroups = [];
1482
+		$allFetchedTables = $this->_getRelatedTablesByInheritance($mainTable);
1483
+		$tableGroupName = $this->getTableGroupName($allFetchedTables);
1484
+		foreach ($allFetchedTables as $table) {
1485
+			$tableGroups[$table] = $tableGroupName;
1486
+		}
1487
+
1488
+		$columnsList = [];
1489
+		$columnDescList = [];
1490
+		$sortColumn = 0;
1491
+
1492
+		// Now, let's deal with "order by columns"
1493
+		if ($orderBy !== null) {
1494
+			$orderByColumns = $this->orderByAnalyzer->analyzeOrderBy($orderBy);
1495
+
1496
+			// If we sort by a column, there is a high chance we will fetch the bean containing this column.
1497
+			// Hence, we should add the table to the $additionalTablesFetch
1498
+			foreach ($orderByColumns as $orderByColumn) {
1499
+				if ($orderByColumn['type'] === 'colref' && $orderByColumn['table'] !== null) {
1500
+					$additionalTablesFetch[] = $orderByColumn['table'];
1501
+				} elseif ($orderByColumn['type'] === 'expr') {
1502
+					$sortColumnName = 'sort_column_'.$sortColumn;
1503
+					$columnsList[] = $orderByColumn['expr'].' as '.$sortColumnName;
1504
+					$columnDescList[] = [
1505
+						'tableGroup' => null,
1506
+					];
1507
+					++$sortColumn;
1508
+				}
1509
+			}
1510
+		}
1511
+
1512
+		foreach ($additionalTablesFetch as $additionalTable) {
1513
+			$relatedTables = $this->_getRelatedTablesByInheritance($additionalTable);
1514
+			$tableGroupName = $this->getTableGroupName($relatedTables);
1515
+			foreach ($relatedTables as $table) {
1516
+				$tableGroups[$table] = $tableGroupName;
1517
+			}
1518
+			$allFetchedTables = array_merge($allFetchedTables, $relatedTables);
1519
+		}
1520
+
1521
+		// Let's remove any duplicate
1522
+		$allFetchedTables = array_flip(array_flip($allFetchedTables));
1523
+
1524
+		$schema = $this->tdbmSchemaAnalyzer->getSchema();
1525
+
1526
+		// Now, let's build the column list
1527
+		foreach ($allFetchedTables as $table) {
1528
+			foreach ($schema->getTable($table)->getColumns() as $column) {
1529
+				$columnName = $column->getName();
1530
+				$columnDescList[] = [
1531
+					'as' => $table.'____'.$columnName,
1532
+					'table' => $table,
1533
+					'column' => $columnName,
1534
+					'type' => $column->getType(),
1535
+					'tableGroup' => $tableGroups[$table],
1536
+				];
1537
+				$columnsList[] = $this->connection->quoteIdentifier($table).'.'.$this->connection->quoteIdentifier($columnName).' as '.
1538
+					$this->connection->quoteIdentifier($table.'____'.$columnName);
1539
+			}
1540
+		}
1541
+
1542
+		return [$columnDescList, $columnsList];
1543
+	}
1544
+
1545
+	/**
1546
+	 * @param $table
1547
+	 * @param array  $primaryKeys
1548
+	 * @param array  $additionalTablesFetch
1549
+	 * @param bool   $lazy                  Whether to perform lazy loading on this object or not
1550
+	 * @param string $className
1551
+	 *
1552
+	 * @return AbstractTDBMObject
1553
+	 *
1554
+	 * @throws TDBMException
1555
+	 */
1556
+	public function findObjectByPk(string $table, array $primaryKeys, array $additionalTablesFetch = array(), bool $lazy = false, string $className = null)
1557
+	{
1558
+		$primaryKeys = $this->_getPrimaryKeysFromObjectData($table, $primaryKeys);
1559
+		$hash = $this->getObjectHash($primaryKeys);
1560
+
1561
+		if ($this->objectStorage->has($table, $hash)) {
1562
+			$dbRow = $this->objectStorage->get($table, $hash);
1563
+			$bean = $dbRow->getTDBMObject();
1564
+			if ($className !== null && !is_a($bean, $className)) {
1565
+				throw new TDBMException("TDBM cannot create a bean of class '".$className."'. The requested object was already loaded and its class is '".get_class($bean)."'");
1566
+			}
1567
+
1568
+			return $bean;
1569
+		}
1570
+
1571
+		// Are we performing lazy fetching?
1572
+		if ($lazy === true) {
1573
+			// Can we perform lazy fetching?
1574
+			$tables = $this->_getRelatedTablesByInheritance($table);
1575
+			// Only allowed if no inheritance.
1576
+			if (count($tables) === 1) {
1577
+				if ($className === null) {
1578
+					$className = isset($this->tableToBeanMap[$table]) ? $this->tableToBeanMap[$table] : 'Mouf\\Database\\TDBM\\TDBMObject';
1579
+				}
1580
+
1581
+				// Let's construct the bean
1582
+				if (!isset($this->reflectionClassCache[$className])) {
1583
+					$this->reflectionClassCache[$className] = new \ReflectionClass($className);
1584
+				}
1585
+				// Let's bypass the constructor when creating the bean!
1586
+				$bean = $this->reflectionClassCache[$className]->newInstanceWithoutConstructor();
1587
+				/* @var $bean AbstractTDBMObject */
1588
+				$bean->_constructLazy($table, $primaryKeys, $this);
1589
+
1590
+				return $bean;
1591
+			}
1592
+		}
1593
+
1594
+		// Did not find the object in cache? Let's query it!
1595
+		return $this->findObjectOrFail($table, $primaryKeys, [], $additionalTablesFetch, $className);
1596
+	}
1597
+
1598
+	/**
1599
+	 * Returns a unique bean (or null) according to the filters passed in parameter.
1600
+	 *
1601
+	 * @param string            $mainTable             The name of the table queried
1602
+	 * @param string|array|null $filter                The SQL filters to apply to the query (the WHERE part). All columns must be prefixed by the table name (in the form: table.column)
1603
+	 * @param array             $parameters
1604
+	 * @param array             $additionalTablesFetch
1605
+	 * @param string            $className             Optional: The name of the class to instantiate. This class must extend the TDBMObject class. If none is specified, a TDBMObject instance will be returned
1606
+	 *
1607
+	 * @return AbstractTDBMObject|null The object we want, or null if no object matches the filters
1608
+	 *
1609
+	 * @throws TDBMException
1610
+	 */
1611
+	public function findObject(string $mainTable, $filter = null, array $parameters = array(), array $additionalTablesFetch = array(), string $className = null)
1612
+	{
1613
+		$objects = $this->findObjects($mainTable, $filter, $parameters, null, $additionalTablesFetch, self::MODE_ARRAY, $className);
1614
+		$page = $objects->take(0, 2);
1615
+		$count = $page->count();
1616
+		if ($count > 1) {
1617
+			throw new DuplicateRowException("Error while querying an object for table '$mainTable': More than 1 row have been returned, but we should have received at most one.");
1618
+		} elseif ($count === 0) {
1619
+			return;
1620
+		}
1621
+
1622
+		return $page[0];
1623
+	}
1624
+
1625
+	/**
1626
+	 * Returns a unique bean (or null) according to the filters passed in parameter.
1627
+	 *
1628
+	 * @param string            $mainTable  The name of the table queried
1629
+	 * @param string            $from       The from sql statement
1630
+	 * @param string|array|null $filter     The SQL filters to apply to the query (the WHERE part). All columns must be prefixed by the table name (in the form: table.column)
1631
+	 * @param array             $parameters
1632
+	 * @param string            $className  Optional: The name of the class to instantiate. This class must extend the TDBMObject class. If none is specified, a TDBMObject instance will be returned
1633
+	 *
1634
+	 * @return AbstractTDBMObject|null The object we want, or null if no object matches the filters
1635
+	 *
1636
+	 * @throws TDBMException
1637
+	 */
1638
+	public function findObjectFromSql($mainTable, $from, $filter = null, array $parameters = array(), $className = null)
1639
+	{
1640
+		$objects = $this->findObjectsFromSql($mainTable, $from, $filter, $parameters, null, self::MODE_ARRAY, $className);
1641
+		$page = $objects->take(0, 2);
1642
+		$count = $page->count();
1643
+		if ($count > 1) {
1644
+			throw new DuplicateRowException("Error while querying an object for table '$mainTable': More than 1 row have been returned, but we should have received at most one.");
1645
+		} elseif ($count === 0) {
1646
+			return;
1647
+		}
1648
+
1649
+		return $page[0];
1650
+	}
1651
+
1652
+	/**
1653
+	 * Returns a unique bean according to the filters passed in parameter.
1654
+	 * Throws a NoBeanFoundException if no bean was found for the filter passed in parameter.
1655
+	 *
1656
+	 * @param string            $mainTable             The name of the table queried
1657
+	 * @param string|array|null $filter                The SQL filters to apply to the query (the WHERE part). All columns must be prefixed by the table name (in the form: table.column)
1658
+	 * @param array             $parameters
1659
+	 * @param array             $additionalTablesFetch
1660
+	 * @param string            $className             Optional: The name of the class to instantiate. This class must extend the TDBMObject class. If none is specified, a TDBMObject instance will be returned
1661
+	 *
1662
+	 * @return AbstractTDBMObject The object we want
1663
+	 *
1664
+	 * @throws TDBMException
1665
+	 */
1666
+	public function findObjectOrFail(string $mainTable, $filter = null, array $parameters = array(), array $additionalTablesFetch = array(), string $className = null)
1667
+	{
1668
+		$bean = $this->findObject($mainTable, $filter, $parameters, $additionalTablesFetch, $className);
1669
+		if ($bean === null) {
1670
+			throw new NoBeanFoundException("No result found for query on table '".$mainTable."'");
1671
+		}
1672
+
1673
+		return $bean;
1674
+	}
1675
+
1676
+	/**
1677
+	 * @param array $beanData An array of data: array<table, array<column, value>>
1678
+	 *
1679
+	 * @return array an array with first item = class name, second item = table name and third item = list of tables needed
1680
+	 */
1681
+	public function _getClassNameFromBeanData(array $beanData)
1682
+	{
1683
+		if (count($beanData) === 1) {
1684
+			$tableName = array_keys($beanData)[0];
1685
+			$allTables = [$tableName];
1686
+		} else {
1687
+			$tables = [];
1688
+			foreach ($beanData as $table => $row) {
1689
+				$primaryKeyColumns = $this->getPrimaryKeyColumns($table);
1690
+				$pkSet = false;
1691
+				foreach ($primaryKeyColumns as $columnName) {
1692
+					if ($row[$columnName] !== null) {
1693
+						$pkSet = true;
1694
+						break;
1695
+					}
1696
+				}
1697
+				if ($pkSet) {
1698
+					$tables[] = $table;
1699
+				}
1700
+			}
1701
+
1702
+			// $tables contains the tables for this bean. Let's view the top most part of the hierarchy
1703
+			$allTables = $this->_getLinkBetweenInheritedTables($tables);
1704
+			$tableName = $allTables[0];
1705
+		}
1706
+
1707
+		// Only one table in this bean. Life is sweat, let's look at its type:
1708
+		if (isset($this->tableToBeanMap[$tableName])) {
1709
+			return [$this->tableToBeanMap[$tableName], $tableName, $allTables];
1710
+		} else {
1711
+			return ['Mouf\\Database\\TDBM\\TDBMObject', $tableName, $allTables];
1712
+		}
1713
+	}
1714
+
1715
+	/**
1716
+	 * Returns an item from cache or computes it using $closure and puts it in cache.
1717
+	 *
1718
+	 * @param string   $key
1719
+	 * @param callable $closure
1720
+	 *
1721
+	 * @return mixed
1722
+	 */
1723
+	private function fromCache(string $key, callable $closure)
1724
+	{
1725
+		$item = $this->cache->fetch($key);
1726
+		if ($item === false) {
1727
+			$item = $closure();
1728
+			$this->cache->save($key, $item);
1729
+		}
1730
+
1731
+		return $item;
1732
+	}
1733
+
1734
+	/**
1735
+	 * Returns the foreign key object.
1736
+	 *
1737
+	 * @param string $table
1738
+	 * @param string $fkName
1739
+	 *
1740
+	 * @return ForeignKeyConstraint
1741
+	 */
1742
+	public function _getForeignKeyByName(string $table, string $fkName)
1743
+	{
1744
+		return $this->tdbmSchemaAnalyzer->getSchema()->getTable($table)->getForeignKey($fkName);
1745
+	}
1746
+
1747
+	/**
1748
+	 * @param $pivotTableName
1749
+	 * @param AbstractTDBMObject $bean
1750
+	 *
1751
+	 * @return AbstractTDBMObject[]
1752
+	 */
1753
+	public function _getRelatedBeans(string $pivotTableName, AbstractTDBMObject $bean)
1754
+	{
1755
+		list($localFk, $remoteFk) = $this->getPivotTableForeignKeys($pivotTableName, $bean);
1756
+		/* @var $localFk ForeignKeyConstraint */
1757
+		/* @var $remoteFk ForeignKeyConstraint */
1758
+		$remoteTable = $remoteFk->getForeignTableName();
1759
+
1760
+		$primaryKeys = $this->getPrimaryKeyValues($bean);
1761
+		$columnNames = array_map(function ($name) use ($pivotTableName) {
1762
+			return $pivotTableName.'.'.$name;
1763
+		}, $localFk->getLocalColumns());
1764
+
1765
+		$filter = array_combine($columnNames, $primaryKeys);
1766
+
1767
+		return $this->findObjects($remoteTable, $filter);
1768
+	}
1769
+
1770
+	/**
1771
+	 * @param $pivotTableName
1772
+	 * @param AbstractTDBMObject $bean The LOCAL bean
1773
+	 *
1774
+	 * @return ForeignKeyConstraint[] First item: the LOCAL bean, second item: the REMOTE bean
1775
+	 *
1776
+	 * @throws TDBMException
1777
+	 */
1778
+	private function getPivotTableForeignKeys(string $pivotTableName, AbstractTDBMObject $bean)
1779
+	{
1780
+		$fks = array_values($this->tdbmSchemaAnalyzer->getSchema()->getTable($pivotTableName)->getForeignKeys());
1781
+		$table1 = $fks[0]->getForeignTableName();
1782
+		$table2 = $fks[1]->getForeignTableName();
1783
+
1784
+		$beanTables = array_map(function (DbRow $dbRow) {
1785
+			return $dbRow->_getDbTableName();
1786
+		}, $bean->_getDbRows());
1787
+
1788
+		if (in_array($table1, $beanTables)) {
1789
+			return [$fks[0], $fks[1]];
1790
+		} elseif (in_array($table2, $beanTables)) {
1791
+			return [$fks[1], $fks[0]];
1792
+		} else {
1793
+			throw new TDBMException("Unexpected bean type in getPivotTableForeignKeys. Awaiting beans from table {$table1} and {$table2} for pivot table {$pivotTableName}");
1794
+		}
1795
+	}
1796
+
1797
+	/**
1798
+	 * Returns a list of pivot tables linked to $bean.
1799
+	 *
1800
+	 * @param AbstractTDBMObject $bean
1801
+	 *
1802
+	 * @return string[]
1803
+	 */
1804
+	public function _getPivotTablesLinkedToBean(AbstractTDBMObject $bean)
1805
+	{
1806
+		$junctionTables = [];
1807
+		$allJunctionTables = $this->schemaAnalyzer->detectJunctionTables(true);
1808
+		foreach ($bean->_getDbRows() as $dbRow) {
1809
+			foreach ($allJunctionTables as $table) {
1810
+				// There are exactly 2 FKs since this is a pivot table.
1811
+				$fks = array_values($table->getForeignKeys());
1812
+
1813
+				if ($fks[0]->getForeignTableName() === $dbRow->_getDbTableName() || $fks[1]->getForeignTableName() === $dbRow->_getDbTableName()) {
1814
+					$junctionTables[] = $table->getName();
1815
+				}
1816
+			}
1817
+		}
1818
+
1819
+		return $junctionTables;
1820
+	}
1821
+
1822
+	/**
1823
+	 * Array of types for tables.
1824
+	 * Key: table name
1825
+	 * Value: array of types indexed by column.
1826
+	 *
1827
+	 * @var array[]
1828
+	 */
1829
+	private $typesForTable = [];
1830
+
1831
+	/**
1832
+	 * @internal
1833
+	 *
1834
+	 * @param string $tableName
1835
+	 *
1836
+	 * @return Type[]
1837
+	 */
1838
+	public function _getColumnTypesForTable(string $tableName)
1839
+	{
1840
+		if (!isset($typesForTable[$tableName])) {
1841
+			$columns = $this->tdbmSchemaAnalyzer->getSchema()->getTable($tableName)->getColumns();
1842
+			$typesForTable[$tableName] = array_map(function (Column $column) {
1843
+				return $column->getType();
1844
+			}, $columns);
1845
+		}
1846
+
1847
+		return $typesForTable[$tableName];
1848
+	}
1849
+
1850
+	/**
1851
+	 * Sets the minimum log level.
1852
+	 * $level must be one of Psr\Log\LogLevel::xxx.
1853
+	 *
1854
+	 * Defaults to LogLevel::WARNING
1855
+	 *
1856
+	 * @param string $level
1857
+	 */
1858
+	public function setLogLevel(string $level)
1859
+	{
1860
+		$this->logger = new MinLogLevelFilter($this->rootLogger, $level);
1861
+	}
1862 1862
 }
Please login to merge, or discard this patch.