query.inc 5.47 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
<?php
// $Id$

/**
 * @ingroup database
 * @{
 */

class InsertQuery_mysql extends InsertQuery {

  public function execute() {
12

13
14
15
16
17
    // Confirm that the user did not try to specify an identical
    //  field and default field.
    if (array_intersect($this->insertFields, $this->defaultFields)) {
      throw new PDOException('You may not specify the same field to have a value and a schema-default value.');
    }
18

19
20
21
22
    if (count($this->insertFields) + count($this->defaultFields) == 0) {
      return NULL;
    }

23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
    $last_insert_id = 0;

    $max_placeholder = 0;
    $values = array();
    foreach ($this->insertValues as $insert_values) {
      foreach ($insert_values as $value) {
        $values[':db_insert_placeholder_' . $max_placeholder++] = $value;
      }
    }

    $last_insert_id = $this->connection->query((string)$this, $values, $this->queryOptions);

    // Re-initialize the values array so that we can re-use this query.
    $this->insertValues = array();

    return $last_insert_id;
  }

  public function __toString() {

    $delay = $this->queryOptions['delay'] ? 'DELAYED' : '';
44

45
46
    // Default fields are always placed first for consistency.
    $insert_fields = array_merge($this->defaultFields, $this->insertFields);
47

48
49
50
51
    $query = "INSERT $delay INTO {" . $this->table . '} (' . implode(', ', $insert_fields) . ') VALUES ';

    $max_placeholder = 0;
    $values = array();
52
    if (count($this->insertValues)) {
53
54
      foreach ($this->insertValues as $insert_values) {
        $placeholders = array();
55

56
57
58
        // Default fields aren't really placeholders, but this is the most convenient
        // way to handle them.
        $placeholders = array_pad($placeholders, count($this->defaultFields), 'default');
59

60
61
62
63
64
65
66
67
        $new_placeholder = $max_placeholder + count($insert_values);
        for ($i = $max_placeholder; $i < $new_placeholder; ++$i) {
          $placeholders[] = ':db_insert_placeholder_'. $i;
        }
        $max_placeholder = $new_placeholder;
        $values[] = '('. implode(', ', $placeholders) .')';
      }
    }
68
    else {
69
      // If there are no values, then this is a default-only query. We still need to handle that.
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
      $placeholders = array_fill(0, count($this->defaultFields), 'default');
      $values[] = '(' . implode(', ', $placeholders) .')';
    }

    $query .= implode(', ', $values);

    return $query;
  }
}

class MergeQuery_mysql extends MergeQuery {

  public function execute() {
    // Set defaults.
    if ($this->updateFields) {
      $update_fields = $this->updateFields;
    }
    else {
88
89
90
91
      // When update fields are derived from insert fields, we don't need
      // placeholders since we can tell MySQL to reuse insert supplied
      // values using the VALUES(col_name) function.
      $update_fields = array();
92
    }
93

94
95
96
97
    $insert_fields = $this->insertFields + $this->keyFields;

    $max_placeholder = 0;
    $values = array();
98
    // We assume that the order here is the same as in __toString(). If that's
99
100
101
102
103
104
105
106
107
108
109
110
111
    // not the case, then we have serious problems.
    foreach ($insert_fields as $value) {
      $values[':db_insert_placeholder_' . $max_placeholder++] = $value;
    }

    // Expressions take priority over literal fields, so we process those first
    // and remove any literal fields that conflict.
    foreach ($this->expressionFields as $field => $data) {
      if (!empty($data['arguments'])) {
        $values += $data['arguments'];
      }
      unset($update_fields[$field]);
    }
112

113
114
115
116
117
118
119
120
121
122
123
124
    // Because we filter $fields the same way here and in __toString(), the
    // placeholders will all match up properly.
    $max_placeholder = 0;
    foreach ($update_fields as $field => $value) {
      $values[':db_update_placeholder_' . ($max_placeholder++)] = $value;
    }

    $last_insert_id = $this->connection->query((string)$this, $values, $this->queryOptions);

    return $last_insert_id;
  }

125

126
127
128
129
130
131
132
133
134
135
136
137
138
  public function __toString() {

    // Set defaults.
    if ($this->updateFields) {
      $update_fields = $this->updateFields;
    }
    else {
      $update_fields = $this->insertFields;
      // If there are no exclude fields, this is a no-op.
      foreach ($this->excludeFields as $exclude_field) {
        unset($update_fields[$exclude_field]);
      }
    }
139

140
141
142
143
144
145
146
147
148
149
150
151
    $insert_fields = $this->insertFields + $this->keyFields;

    $query = "INSERT INTO {" . $this->table . '} (' . implode(', ', array_keys($insert_fields)) . ') VALUES ';

    $max_placeholder = 0;
    $values = array();
    // We don't need the $field, but this is a convenient way to count.
    foreach ($insert_fields as $field) {
      $values[] = ':db_insert_placeholder_' . $max_placeholder++;
    }

    $query .= '(' . implode(', ', $values) . ') ON DUPLICATE KEY UPDATE ';
152

153
154
155
156
157
158
159
160
161
    // Expressions take priority over literal fields, so we process those first
    // and remove any literal fields that conflict.
    $max_placeholder = 0;
    $update = array();
    foreach ($this->expressionFields as $field => $data) {
      $update[] = $field . '=' . $data['expression'];
      unset($update_fields[$field]);
    }

162
163
    // Build update fields clauses based on caller supplied list, or derived
    // from insert supplied values using the VALUES(col_name) function.
164
    foreach ($update_fields as $field => $value) {
165
166
167
168
169
170
      if ($this->updateFields) {
        $update[] = ($field . '=:db_update_placeholder_' . $max_placeholder++);
      }
      else {
        $update[] = ($field . '=VALUES(' . $field . ')');
      }
171
    }
172

173
174
175
176
177
178
179
180
181
    $query .= implode(', ', $update);

    return $query;
  }
}

/**
 * @} End of "ingroup database".
 */