CakePHP
  • Documentation
    • Book
    • API
    • Videos
    • Logos & Trademarks
  • Business Solutions
  • Swag
  • Road Trip
  • Team
  • Community
    • Community
    • Team
    • Issues (Github)
    • YouTube Channel
    • Get Involved
    • Bakery
    • Featured Resources
    • Newsletter
    • Certification
    • My CakePHP
    • CakeFest
    • Facebook
    • Twitter
    • Help & Support
    • Forum
    • Stack Overflow
    • IRC
    • Slack
    • Paid Support
CakePHP

C CakePHP 3.8 Red Velvet API

  • Overview
  • Tree
  • Deprecated
  • Version:
    • 3.8
      • 3.8
      • 3.7
      • 3.6
      • 3.5
      • 3.4
      • 3.3
      • 3.2
      • 3.1
      • 3.0
      • 2.10
      • 2.9
      • 2.8
      • 2.7
      • 2.6
      • 2.5
      • 2.4
      • 2.3
      • 2.2
      • 2.1
      • 2.0
      • 1.3
      • 1.2

Namespaces

  • Cake
    • Auth
      • Storage
    • Cache
      • Engine
    • Collection
      • Iterator
    • Command
    • Console
      • Exception
    • Controller
      • Component
      • Exception
    • Core
      • Configure
        • Engine
      • Exception
      • Retry
    • Database
      • Driver
      • Exception
      • Expression
      • Schema
      • Statement
      • Type
    • Datasource
      • Exception
    • Error
      • Middleware
    • Event
      • Decorator
    • Filesystem
    • Form
    • Http
      • Client
        • Adapter
        • Auth
      • Cookie
      • Exception
      • Middleware
      • Session
    • I18n
      • Formatter
      • Middleware
      • Parser
    • Log
      • Engine
    • Mailer
      • Exception
      • Transport
    • Network
      • Exception
    • ORM
      • Association
      • Behavior
        • Translate
      • Exception
      • Locator
      • Rule
    • Routing
      • Exception
      • Filter
      • Middleware
      • Route
    • Shell
      • Helper
      • Task
    • TestSuite
      • Fixture
      • Stub
    • Utility
      • Exception
    • Validation
    • View
      • Exception
      • Form
      • Helper
      • Widget
  • None

Classes

  • BetweenExpression
  • CaseExpression
  • Comparison
  • FunctionExpression
  • IdentifierExpression
  • OrderByExpression
  • OrderClauseExpression
  • QueryExpression
  • TupleComparison
  • UnaryExpression
  • ValuesExpression

Interfaces

  • FieldInterface

Traits

  • FieldTrait
  1: <?php
  2: /**
  3:  * CakePHP(tm) : Rapid Development Framework (https://cakephp.org)
  4:  * Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
  5:  *
  6:  * Licensed under The MIT License
  7:  * For full copyright and license information, please see the LICENSE.txt
  8:  * Redistributions of files must retain the above copyright notice.
  9:  *
 10:  * @copyright     Copyright (c) Cake Software Foundation, Inc. (https://cakefoundation.org)
 11:  * @link          https://cakephp.org CakePHP(tm) Project
 12:  * @since         3.0.0
 13:  * @license       https://opensource.org/licenses/mit-license.php MIT License
 14:  */
 15: namespace Cake\Database\Expression;
 16: 
 17: use Cake\Database\Exception;
 18: use Cake\Database\ExpressionInterface;
 19: use Cake\Database\Query;
 20: use Cake\Database\TypeMapTrait;
 21: use Cake\Database\Type\ExpressionTypeCasterTrait;
 22: use Cake\Database\ValueBinder;
 23: 
 24: /**
 25:  * An expression object to contain values being inserted.
 26:  *
 27:  * Helps generate SQL with the correct number of placeholders and bind
 28:  * values correctly into the statement.
 29:  */
 30: class ValuesExpression implements ExpressionInterface
 31: {
 32:     use ExpressionTypeCasterTrait;
 33:     use TypeMapTrait;
 34: 
 35:     /**
 36:      * Array of values to insert.
 37:      *
 38:      * @var array
 39:      */
 40:     protected $_values = [];
 41: 
 42:     /**
 43:      * List of columns to ensure are part of the insert.
 44:      *
 45:      * @var array
 46:      */
 47:     protected $_columns = [];
 48: 
 49:     /**
 50:      * The Query object to use as a values expression
 51:      *
 52:      * @var \Cake\Database\Query|null
 53:      */
 54:     protected $_query;
 55: 
 56:     /**
 57:      * Whether or not values have been casted to expressions
 58:      * already.
 59:      *
 60:      * @var bool
 61:      */
 62:     protected $_castedExpressions = false;
 63: 
 64:     /**
 65:      * Constructor
 66:      *
 67:      * @param array $columns The list of columns that are going to be part of the values.
 68:      * @param \Cake\Database\TypeMap $typeMap A dictionary of column -> type names
 69:      */
 70:     public function __construct(array $columns, $typeMap)
 71:     {
 72:         $this->_columns = $columns;
 73:         $this->setTypeMap($typeMap);
 74:     }
 75: 
 76:     /**
 77:      * Add a row of data to be inserted.
 78:      *
 79:      * @param array|\Cake\Database\Query $data Array of data to append into the insert, or
 80:      *   a query for doing INSERT INTO .. SELECT style commands
 81:      * @return void
 82:      * @throws \Cake\Database\Exception When mixing array + Query data types.
 83:      */
 84:     public function add($data)
 85:     {
 86:         if (
 87:             (count($this->_values) && $data instanceof Query) ||
 88:             ($this->_query && is_array($data))
 89:         ) {
 90:             throw new Exception(
 91:                 'You cannot mix subqueries and array data in inserts.'
 92:             );
 93:         }
 94:         if ($data instanceof Query) {
 95:             $this->setQuery($data);
 96: 
 97:             return;
 98:         }
 99:         $this->_values[] = $data;
100:         $this->_castedExpressions = false;
101:     }
102: 
103:     /**
104:      * Sets the columns to be inserted.
105:      *
106:      * @param array $cols Array with columns to be inserted.
107:      * @return $this
108:      */
109:     public function setColumns($cols)
110:     {
111:         $this->_columns = $cols;
112:         $this->_castedExpressions = false;
113: 
114:         return $this;
115:     }
116: 
117:     /**
118:      * Gets the columns to be inserted.
119:      *
120:      * @return array
121:      */
122:     public function getColumns()
123:     {
124:         return $this->_columns;
125:     }
126: 
127:     /**
128:      * Sets the columns to be inserted. If no params are passed, then it returns
129:      * the currently stored columns.
130:      *
131:      * @deprecated 3.4.0 Use setColumns()/getColumns() instead.
132:      * @param array|null $cols Array with columns to be inserted.
133:      * @return array|$this
134:      */
135:     public function columns($cols = null)
136:     {
137:         deprecationWarning(
138:             'ValuesExpression::columns() is deprecated. ' .
139:             'Use ValuesExpression::setColumns()/getColumns() instead.'
140:         );
141:         if ($cols !== null) {
142:             return $this->setColumns($cols);
143:         }
144: 
145:         return $this->getColumns();
146:     }
147: 
148:     /**
149:      * Get the bare column names.
150:      *
151:      * Because column names could be identifier quoted, we
152:      * need to strip the identifiers off of the columns.
153:      *
154:      * @return array
155:      */
156:     protected function _columnNames()
157:     {
158:         $columns = [];
159:         foreach ($this->_columns as $col) {
160:             if (is_string($col)) {
161:                 $col = trim($col, '`[]"');
162:             }
163:             $columns[] = $col;
164:         }
165: 
166:         return $columns;
167:     }
168: 
169:     /**
170:      * Sets the values to be inserted.
171:      *
172:      * @param array $values Array with values to be inserted.
173:      * @return $this
174:      */
175:     public function setValues($values)
176:     {
177:         $this->_values = $values;
178:         $this->_castedExpressions = false;
179: 
180:         return $this;
181:     }
182: 
183:     /**
184:      * Gets the values to be inserted.
185:      *
186:      * @return array
187:      */
188:     public function getValues()
189:     {
190:         if (!$this->_castedExpressions) {
191:             $this->_processExpressions();
192:         }
193: 
194:         return $this->_values;
195:     }
196: 
197:     /**
198:      * Sets the values to be inserted. If no params are passed, then it returns
199:      * the currently stored values
200:      *
201:      * @deprecated 3.4.0 Use setValues()/getValues() instead.
202:      * @param array|null $values Array with values to be inserted.
203:      * @return array|$this
204:      */
205:     public function values($values = null)
206:     {
207:         deprecationWarning(
208:             'ValuesExpression::values() is deprecated. ' .
209:             'Use ValuesExpression::setValues()/getValues() instead.'
210:         );
211:         if ($values !== null) {
212:             return $this->setValues($values);
213:         }
214: 
215:         return $this->getValues();
216:     }
217: 
218:     /**
219:      * Sets the query object to be used as the values expression to be evaluated
220:      * to insert records in the table.
221:      *
222:      * @param \Cake\Database\Query $query The query to set
223:      * @return $this
224:      */
225:     public function setQuery(Query $query)
226:     {
227:         $this->_query = $query;
228: 
229:         return $this;
230:     }
231: 
232:     /**
233:      * Gets the query object to be used as the values expression to be evaluated
234:      * to insert records in the table.
235:      *
236:      * @return \Cake\Database\Query|null
237:      */
238:     public function getQuery()
239:     {
240:         return $this->_query;
241:     }
242: 
243:     /**
244:      * Sets the query object to be used as the values expression to be evaluated
245:      * to insert records in the table. If no params are passed, then it returns
246:      * the currently stored query
247:      *
248:      * @deprecated 3.4.0 Use setQuery()/getQuery() instead.
249:      * @param \Cake\Database\Query|null $query The query to set
250:      * @return \Cake\Database\Query|null|$this
251:      */
252:     public function query(Query $query = null)
253:     {
254:         deprecationWarning(
255:             'ValuesExpression::query() is deprecated. ' .
256:             'Use ValuesExpression::setQuery()/getQuery() instead.'
257:         );
258:         if ($query !== null) {
259:             return $this->setQuery($query);
260:         }
261: 
262:         return $this->getQuery();
263:     }
264: 
265:     /**
266:      * Convert the values into a SQL string with placeholders.
267:      *
268:      * @param \Cake\Database\ValueBinder $generator Placeholder generator object
269:      * @return string
270:      */
271:     public function sql(ValueBinder $generator)
272:     {
273:         if (empty($this->_values) && empty($this->_query)) {
274:             return '';
275:         }
276: 
277:         if (!$this->_castedExpressions) {
278:             $this->_processExpressions();
279:         }
280: 
281:         $columns = $this->_columnNames();
282:         $defaults = array_fill_keys($columns, null);
283:         $placeholders = [];
284: 
285:         $types = [];
286:         $typeMap = $this->getTypeMap();
287:         foreach ($defaults as $col => $v) {
288:             $types[$col] = $typeMap->type($col);
289:         }
290: 
291:         foreach ($this->_values as $row) {
292:             $row += $defaults;
293:             $rowPlaceholders = [];
294: 
295:             foreach ($columns as $column) {
296:                 $value = $row[$column];
297: 
298:                 if ($value instanceof ExpressionInterface) {
299:                     $rowPlaceholders[] = '(' . $value->sql($generator) . ')';
300:                     continue;
301:                 }
302: 
303:                 $placeholder = $generator->placeholder('c');
304:                 $rowPlaceholders[] = $placeholder;
305:                 $generator->bind($placeholder, $value, $types[$column]);
306:             }
307: 
308:             $placeholders[] = implode(', ', $rowPlaceholders);
309:         }
310: 
311:         if ($this->getQuery()) {
312:             return ' ' . $this->getQuery()->sql($generator);
313:         }
314: 
315:         return sprintf(' VALUES (%s)', implode('), (', $placeholders));
316:     }
317: 
318:     /**
319:      * Traverse the values expression.
320:      *
321:      * This method will also traverse any queries that are to be used in the INSERT
322:      * values.
323:      *
324:      * @param callable $visitor The visitor to traverse the expression with.
325:      * @return void
326:      */
327:     public function traverse(callable $visitor)
328:     {
329:         if ($this->_query) {
330:             return;
331:         }
332: 
333:         if (!$this->_castedExpressions) {
334:             $this->_processExpressions();
335:         }
336: 
337:         foreach ($this->_values as $v) {
338:             if ($v instanceof ExpressionInterface) {
339:                 $v->traverse($visitor);
340:             }
341:             if (!is_array($v)) {
342:                 continue;
343:             }
344:             foreach ($v as $column => $field) {
345:                 if ($field instanceof ExpressionInterface) {
346:                     $visitor($field);
347:                     $field->traverse($visitor);
348:                 }
349:             }
350:         }
351:     }
352: 
353:     /**
354:      * Converts values that need to be casted to expressions
355:      *
356:      * @return void
357:      */
358:     protected function _processExpressions()
359:     {
360:         $types = [];
361:         $typeMap = $this->getTypeMap();
362: 
363:         $columns = $this->_columnNames();
364:         foreach ($columns as $c) {
365:             if (!is_scalar($c)) {
366:                 continue;
367:             }
368:             $types[$c] = $typeMap->type($c);
369:         }
370: 
371:         $types = $this->_requiresToExpressionCasting($types);
372: 
373:         if (empty($types)) {
374:             return;
375:         }
376: 
377:         foreach ($this->_values as $row => $values) {
378:             foreach ($types as $col => $type) {
379:                 /** @var \Cake\Database\Type\ExpressionTypeInterface $type */
380:                 $this->_values[$row][$col] = $type->toExpression($values[$col]);
381:             }
382:         }
383:         $this->_castedExpressions = true;
384:     }
385: }
386: 
Follow @CakePHP
#IRC
OpenHub
Rackspace
  • Business Solutions
  • Showcase
  • Documentation
  • Book
  • API
  • Videos
  • Logos & Trademarks
  • Community
  • Team
  • Issues (Github)
  • YouTube Channel
  • Get Involved
  • Bakery
  • Featured Resources
  • Newsletter
  • Certification
  • My CakePHP
  • CakeFest
  • Facebook
  • Twitter
  • Help & Support
  • Forum
  • Stack Overflow
  • IRC
  • Slack
  • Paid Support

Generated using CakePHP API Docs