Code Coverage for /Users/ericduran/Sites/drupal/drupal/core/lib/Drupal/Core/Database/Query/InsertTrait.php

	Code Coverage
	Classes and Traits			Functions and Methods				Lines
Total	0.00% covered (danger)	0.00%	0 / 1	25.00% covered (danger)	25.00%	1 / 4	CRAP	46.88% covered (danger)	46.88%	15 / 32
InsertTrait	0.00% covered (danger)	0.00%	0 / 1	25.00% covered (danger)	25.00%	1 / 4	43.39	46.88% covered (danger)	46.88%	15 / 32
fields				100.00% covered (success)	100.00%	1 / 1	5	100.00% covered (success)	100.00%	9 / 9
values				0.00% covered (danger)	0.00%	0 / 1	4.05	85.71% covered (warning)	85.71%	6 / 7
useDefaults				0.00% covered (danger)	0.00%	0 / 1	2	0.00% covered (danger)	0.00%	0 / 2
getInsertPlaceholderFragment				0.00% covered (danger)	0.00%	0 / 1	20	0.00% covered (danger)	0.00%	0 / 14

1	<?php
2
3	/**
4	* @file
5	* Contains \Drupal\Core\Database\Query\InsertTrait.
6	*/
7
8	namespace Drupal\Core\Database\Query;
9
10	/**
11	* Provides common functionality for INSERT and UPSERT queries.
12	*
13	* @ingroup database
14	*/
15	trait InsertTrait {
16
17	/**
18	* The table on which to insert.
19	*
20	* @var string
21	*/
22	protected $table;
23
24	/**
25	* An array of fields on which to insert.
26	*
27	* @var array
28	*/
29	protected $insertFields = array();
30
31	/**
32	* An array of fields that should be set to their database-defined defaults.
33	*
34	* @var array
35	*/
36	protected $defaultFields = array();
37
38	/**
39	* A nested array of values to insert.
40	*
41	* $insertValues is an array of arrays. Each sub-array is either an
42	* associative array whose keys are field names and whose values are field
43	* values to insert, or a non-associative array of values in the same order
44	* as $insertFields.
45	*
46	* Whether multiple insert sets will be run in a single query or multiple
47	* queries is left to individual drivers to implement in whatever manner is
48	* most appropriate. The order of values in each sub-array must match the
49	* order of fields in $insertFields.
50	*
51	* @var array
52	*/
53	protected $insertValues = array();
54
55	/**
56	* Adds a set of field->value pairs to be inserted.
57	*
58	* This method may only be called once. Calling it a second time will be
59	* ignored. To queue up multiple sets of values to be inserted at once,
60	* use the values() method.
61	*
62	* @param array $fields
63	* An array of fields on which to insert. This array may be indexed or
64	* associative. If indexed, the array is taken to be the list of fields.
65	* If associative, the keys of the array are taken to be the fields and
66	* the values are taken to be corresponding values to insert. If a
67	* $values argument is provided, $fields must be indexed.
68	* @param array $values
69	* (optional) An array of fields to insert into the database. The values
70	* must be specified in the same order as the $fields array.
71	*
72	* @return $this
73	* The called object.
74	*/
75	public function fields(array $fields, array $values = array()) {
76	if (empty($this->insertFields)) {
77	if (empty($values)) {
78	if (!is_numeric(key($fields))) {
79	$values = array_values($fields);
80	$fields = array_keys($fields);
81	}
82	}
83	$this->insertFields = $fields;
84	if (!empty($values)) {
85	$this->insertValues[] = $values;
86	}
87	}
88
89	return $this;
90	}
91
92	/**
93	* Adds another set of values to the query to be inserted.
94	*
95	* If $values is a numeric-keyed array, it will be assumed to be in the same
96	* order as the original fields() call. If it is associative, it may be
97	* in any order as long as the keys of the array match the names of the
98	* fields.
99	*
100	* @param array $values
101	* An array of values to add to the query.
102	*
103	* @return $this
104	* The called object.
105	*/
106	public function values(array $values) {
107	if (is_numeric(key($values))) {
108	$this->insertValues[] = $values;
109	}
110	elseif ($this->insertFields) {
111	// Reorder the submitted values to match the fields array.
112	foreach ($this->insertFields as $key) {
113	$insert_values[$key] = $values[$key];
114	}
115	// For consistency, the values array is always numerically indexed.
116	$this->insertValues[] = array_values($insert_values);
117	}
118	return $this;
119	}
120
121	/**
122	* Specifies fields for which the database defaults should be used.
123	*
124	* If you want to force a given field to use the database-defined default,
125	* not NULL or undefined, use this method to instruct the database to use
126	* default values explicitly. In most cases this will not be necessary
127	* unless you are inserting a row that is all default values, as you cannot
128	* specify no values in an INSERT query.
129	*
130	* Specifying a field both in fields() and in useDefaults() is an error
131	* and will not execute.
132	*
133	* @param array $fields
134	* An array of values for which to use the default values
135	* specified in the table definition.
136	*
137	* @return $this
138	* The called object.
139	*/
140	public function useDefaults(array $fields) {
141	$this->defaultFields = $fields;
142	return $this;
143	}
144
145	/**
146	* Returns the query placeholders for values that will be inserted.
147	*
148	* @param array $nested_insert_values
149	* A nested array of values to insert.
150	* @param array $default_fields
151	* An array of fields that should be set to their database-defined defaults.
152	*
153	* @return array
154	* An array of insert placeholders.
155	*/
156	protected function getInsertPlaceholderFragment(array $nested_insert_values, array $default_fields) {
157	$max_placeholder = 0;
158	$values = array();
159	if ($nested_insert_values) {
160	foreach ($nested_insert_values as $insert_values) {
161	$placeholders = array();
162
163	// Default fields aren't really placeholders, but this is the most convenient
164	// way to handle them.
165	$placeholders = array_pad($placeholders, count($default_fields), 'default');
166
167	$new_placeholder = $max_placeholder + count($insert_values);
168	for ($i = $max_placeholder; $i < $new_placeholder; ++$i) {
169	$placeholders[] = ':db_insert_placeholder_' . $i;
170	}
171	$max_placeholder = $new_placeholder;
172	$values[] = '(' . implode(', ', $placeholders) . ')';
173	}
174	}
175	else {
176	// If there are no values, then this is a default-only query. We still need to handle that.
177	$placeholders = array_fill(0, count($default_fields), 'default');
178	$values[] = '(' . implode(', ', $placeholders) . ')';
179	}
180
181	return $values;
182	}
183
184	}