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


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

class InsertQuery_pgsql extends InsertQuery {

  public function __construct($connection, $table, Array $options = array()) {
    parent::__construct($connection, $table, $options);
    $this->queryOptions['return'] = Database::RETURN_NULL;
  }
16

17
  public function execute() {
18

19
20
21
22
23
24
    // 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.');
    }

25
26
27
28
    if (count($this->insertFields) + count($this->defaultFields) == 0) {
      return NULL;
    }

29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
    $schema = drupal_get_schema($this->table);

    $stmt = $this->connection->prepareQuery((string)$this);

    $max_placeholder = 0;
    $blobs = array();
    $blob_cnt = 0;
    foreach ($this->insertValues as &$insert_values) {
      foreach ($this->insertFields as $idx => $field) {
        switch ($schema['fields'][$field]['type']) {
          case 'blob':
            $blobs[$blob_cnt] = fopen('php://memory', 'a');
            fwrite($blobs[$blob_cnt], $insert_values[$idx]);
            rewind($blobs[$blob_cnt]);

            $stmt->bindParam(':db_insert_placeholder_' . $max_placeholder++, $blobs[$blob_cnt], PDO::PARAM_LOB);

            ++$blob_cnt;

            break;
          default:
            $stmt->bindParam(':db_insert_placeholder_'. $max_placeholder++, $insert_values[$idx]);
            break;
        }
      }
    }

    // PostgreSQL requires the table name to be specified explicitly
    // when requesting the last insert ID, so we pass that in via
    // the options array.
    $options = $this->queryOptions;
60

61
62
63
64
65
    if ($schema['fields'][$schema['primary key'][0]]['type'] == 'serial') {
      $options['sequence_name'] = $this->connection->makeSequenceName($this->table, $schema['primary key'][0]);
      $options['return'] = Database::RETURN_INSERT_ID;
    }
    $last_insert_id = $this->connection->query($stmt, array(), $options);
66

67
68
69
70
71
72
73
    // Re-initialize the values array so that we can re-use this query.
    $this->insertValues = array();

    return $last_insert_id;
  }

  public function __toString() {
74

75
76
77
78
79
80
81
    // Default fields are always placed first for consistency.
    $insert_fields = array_merge($this->defaultFields, $this->insertFields);

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

    $max_placeholder = 0;
    $values = array();
82
      if (count($this->insertValues)) {
83
84
      foreach ($this->insertValues as $insert_values) {
        $placeholders = array();
85

86
87
88
        // Default fields aren't really placeholders, but this is the most convenient
        // way to handle them.
        $placeholders = array_pad($placeholders, count($this->defaultFields), 'default');
89

90
91
92
93
94
95
96
97
        $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) . ')';
      }
    }
98
    else {
99
100
101
102
103
104
105
106
107
108
109
      // If there are no values, then this is a default-only query.  We still need to handle that.
      $placeholders = array_fill(0, count($this->defaultFields), 'default');
      $values[] = '(' . implode(', ', $placeholders) .')';
    }

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

    return $query;
  }
}

110
class UpdateQuery_pgsql extends UpdateQuery {
111
112
113
114
  public function execute() {
    $max_placeholder = 0;
    $blobs = array();
    $blob_count = 0;
115

116
    $schema = drupal_get_schema($this->table);
117

118
119
120
    // Because we filter $fields the same way here and in __toString(), the
    // placeholders will all match up properly.
    $stmt = $this->connection->prepareQuery((string)$this);
121

122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
    // Expressions take priority over literal fields, so we process those first
    // and remove any literal fields that conflict.
    $fields = $this->fields;
    $expression_fields = array();
    foreach ($this->expressionFields as $field => $data) {
      if (!empty($data['arguments'])) {
        foreach ($data['arguments'] as $placeholder => $argument) {
          // We assume that an expression will never happen on a BLOB field,
          // which is a fairly safe assumption to make since in most cases
          // it would be an invalid query anyway.
          $stmt->bindParam($placeholder, $argument);
        }
      }
      unset($fields[$field]);
    }
137

138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
    foreach ($fields as $field => &$value) {
      $placeholder = ':db_update_placeholder_' . ($max_placeholder++);

      switch ($schema['fields'][$field]['type']) {
        case 'blob':
          $blobs[$blob_count] = fopen('php://memory', 'a');
          fwrite($blobs[$blob_count], $value);
          rewind($blobs[$blob_count]);
          $stmt->bindParam($placeholder, $blobs[$blob_count], PDO::PARAM_LOB);
          ++$blob_count;
          break;
        default:
          $stmt->bindParam($placeholder, $value);
          break;
      }
    }

    if (count($this->condition)) {
      $this->condition->compile($this->connection);

      $arguments = $this->condition->arguments();
      foreach ($arguments as $placeholder => &$value) {
        $stmt->bindParam($placeholder, $value);
      }
    }

    $options = $this->queryOptions;
    $options['already_prepared'] = TRUE;
    $this->connection->query($stmt, $options);
167

168
169
170
171
    //$stmt->execute(NULL, $this->queryOptions);
    return $stmt->rowCount();
  }
}