WebCore: Changing SQLiteStatement::prepare() to return an error when it's
[WebKit-https.git] / WebCore / platform / sql / SQLiteStatement.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27 #include "SQLiteStatement.h"
28
29 #include "Logging.h"
30 #include "SQLValue.h"
31 #include <sqlite3.h>
32 #include <wtf/Assertions.h>
33
34 namespace WebCore {
35
36 #if SQLITE_VERSION_NUMBER < 3003009
37
38 // FIXME: This overload helps us compile with older versions of SQLite 3, but things like quotas will not work.
39 static inline int sqlite3_prepare16_v2(sqlite3* db, const void* zSql, int nBytes, sqlite3_stmt** ppStmt, const void** pzTail)
40 {
41     return sqlite3_prepare16(db, zSql, nBytes, ppStmt, pzTail);
42 }
43
44 #endif
45
46 SQLiteStatement::SQLiteStatement(SQLiteDatabase& db, const String& sql)
47     : m_database(db)
48     , m_query(sql)
49     , m_statement(0)
50 #ifndef NDEBUG
51     , m_isPrepared(false)
52 #endif
53 {
54 }
55
56 SQLiteStatement::~SQLiteStatement()
57 {
58     finalize();
59 }
60
61 int SQLiteStatement::prepare()
62 {
63     ASSERT(!m_isPrepared);
64     const void* tail;
65     LOG(SQLDatabase, "SQL - prepare - %s", m_query.ascii().data());
66     int error = sqlite3_prepare16_v2(m_database.sqlite3Handle(), m_query.stripWhiteSpace().charactersWithNullTermination(), -1, &m_statement, &tail);
67     if (error != SQLITE_OK)
68         LOG(SQLDatabase, "sqlite3_prepare16 failed (%i)\n%s\n%s", error, m_query.ascii().data(), sqlite3_errmsg(m_database.sqlite3Handle()));
69     const UChar* ch = static_cast<const UChar*>(tail);
70     if (*ch)
71         error = SQLITE_ERROR;
72 #ifndef NDEBUG
73     m_isPrepared = error == SQLITE_OK;
74 #endif
75     return error;
76 }
77
78 int SQLiteStatement::step()
79 {
80     ASSERT(m_isPrepared);
81     if (!m_statement)
82         return SQLITE_OK;
83     LOG(SQLDatabase, "SQL - step - %s", m_query.ascii().data());
84     int error = sqlite3_step(m_statement);
85     if (error != SQLITE_DONE && error != SQLITE_ROW) {
86         LOG(SQLDatabase, "sqlite3_step failed (%i)\nQuery - %s\nError - %s", 
87             error, m_query.ascii().data(), sqlite3_errmsg(m_database.sqlite3Handle()));
88     }
89     return error;
90 }
91     
92 int SQLiteStatement::finalize()
93 {
94 #ifndef NDEBUG
95     m_isPrepared = false;
96 #endif
97     if (!m_statement)
98         return SQLITE_OK;
99     LOG(SQLDatabase, "SQL - finalize - %s", m_query.ascii().data());
100     int result = sqlite3_finalize(m_statement);
101     m_statement = 0;
102     return result;
103 }
104
105 int SQLiteStatement::reset() 
106 {
107     ASSERT(m_isPrepared);
108     if (!m_statement)
109         return SQLITE_OK;
110     LOG(SQLDatabase, "SQL - reset - %s", m_query.ascii().data());
111     return sqlite3_reset(m_statement);
112 }
113
114 bool SQLiteStatement::executeCommand()
115 {
116     if (!m_statement && prepare() != SQLITE_OK)
117         return false;
118     ASSERT(m_isPrepared);
119     if (step() != SQLITE_DONE) {
120         finalize();
121         return false;
122     }
123     finalize();
124     return true;
125 }
126
127 bool SQLiteStatement::returnsAtLeastOneResult()
128 {
129     if (!m_statement && prepare() != SQLITE_OK)
130         return false;
131     ASSERT(m_isPrepared);
132     if (step() != SQLITE_ROW) {
133         finalize();
134         return false;
135     }
136     finalize();
137     return true;
138
139 }
140
141 int SQLiteStatement::bindBlob(int index, const void* blob, int size)
142 {
143     ASSERT(m_isPrepared);
144     ASSERT(index > 0);
145     ASSERT(static_cast<unsigned>(index) <= bindParameterCount());
146     ASSERT(blob);
147     ASSERT(size >= 0);
148
149     if (!m_statement)
150         return SQLITE_ERROR;
151
152     return sqlite3_bind_blob(m_statement, index, blob, size, SQLITE_TRANSIENT);
153 }
154
155 int SQLiteStatement::bindText(int index, const String& text)
156 {
157     ASSERT(m_isPrepared);
158     ASSERT(index > 0);
159     ASSERT(static_cast<unsigned>(index) <= bindParameterCount());
160
161     // String::characters() returns 0 for the empty string, which SQLite
162     // treats as a null, so we supply a non-null pointer for that case.
163     UChar anyCharacter = 0;
164     const UChar* characters;
165     if (text.isEmpty() && !text.isNull())
166         characters = &anyCharacter;
167     else
168         characters = text.characters();
169
170     return sqlite3_bind_text16(m_statement, index, characters, sizeof(UChar) * text.length(), SQLITE_TRANSIENT);
171 }
172
173
174 int SQLiteStatement::bindInt64(int index, int64_t integer)
175 {
176     ASSERT(m_isPrepared);
177     ASSERT(index > 0);
178     ASSERT(static_cast<unsigned>(index) <= bindParameterCount());
179
180     return sqlite3_bind_int64(m_statement, index, integer);
181 }
182
183 int SQLiteStatement::bindDouble(int index, double number)
184 {
185     ASSERT(m_isPrepared);
186     ASSERT(index > 0);
187     ASSERT(static_cast<unsigned>(index) <= bindParameterCount());
188
189     return sqlite3_bind_double(m_statement, index, number);
190 }
191
192 int SQLiteStatement::bindNull(int index)
193 {
194     ASSERT(m_isPrepared);
195     ASSERT(index > 0);
196     ASSERT(static_cast<unsigned>(index) <= bindParameterCount());
197
198     return sqlite3_bind_null(m_statement, index);
199 }
200
201 int SQLiteStatement::bindValue(int index, const SQLValue& value)
202 {
203     switch (value.type()) {
204         case SQLValue::StringValue:
205             return bindText(index, value.string());
206         case SQLValue::NumberValue:
207             return bindDouble(index, value.number());
208         case SQLValue::NullValue:
209             return bindNull(index);
210     }
211
212     ASSERT_NOT_REACHED();
213     return SQLITE_ERROR;
214 }
215
216 unsigned SQLiteStatement::bindParameterCount() const
217 {
218     ASSERT(m_isPrepared);
219     if (!m_statement)
220         return 0;
221     return sqlite3_bind_parameter_count(m_statement);
222 }
223
224 int SQLiteStatement::columnCount()
225 {
226     ASSERT(m_isPrepared);
227     if (!m_statement)
228         return 0;
229     return sqlite3_data_count(m_statement);
230 }
231
232 String SQLiteStatement::getColumnName(int col)
233 {
234     ASSERT(col >= 0);
235     if (!m_statement)
236         if (prepareAndStep() != SQLITE_ROW)
237             return String();
238     if (columnCount() <= col)
239         return String();
240     return String(reinterpret_cast<const UChar*>(sqlite3_column_name16(m_statement, col)));
241 }
242
243 SQLValue SQLiteStatement::getColumnValue(int col)
244 {
245     ASSERT(col >= 0);
246     if (!m_statement)
247         if (prepareAndStep() != SQLITE_ROW)
248             return SQLValue();
249     if (columnCount() <= col)
250         return SQLValue();
251
252     // SQLite is typed per value. optional column types are
253     // "(mostly) ignored"
254     sqlite3_value* value = sqlite3_column_value(m_statement, col);
255     switch (sqlite3_value_type(value)) {
256         case SQLITE_INTEGER:    // SQLValue and JS don't represent integers, so use FLOAT -case
257         case SQLITE_FLOAT:
258             return SQLValue(sqlite3_value_double(value));
259         case SQLITE_BLOB:       // SQLValue and JS don't represent blobs, so use TEXT -case
260         case SQLITE_TEXT:
261             return SQLValue(String(reinterpret_cast<const UChar*>(sqlite3_value_text16(value))));
262         case SQLITE_NULL:
263             return SQLValue();
264         default:
265             break;
266     }
267     ASSERT_NOT_REACHED();
268     return SQLValue();
269 }
270
271 String SQLiteStatement::getColumnText(int col)
272 {
273     ASSERT(col >= 0);
274     if (!m_statement)
275         if (prepareAndStep() != SQLITE_ROW)
276             return String();
277     if (columnCount() <= col)
278         return String();
279     return String(reinterpret_cast<const UChar*>(sqlite3_column_text16(m_statement, col)));
280 }
281     
282 double SQLiteStatement::getColumnDouble(int col)
283 {
284     ASSERT(col >= 0);
285     if (!m_statement)
286         if (prepareAndStep() != SQLITE_ROW)
287             return 0.0;
288     if (columnCount() <= col)
289         return 0.0;
290     return sqlite3_column_double(m_statement, col);
291 }
292
293 int SQLiteStatement::getColumnInt(int col)
294 {
295     ASSERT(col >= 0);
296     if (!m_statement)
297         if (prepareAndStep() != SQLITE_ROW)
298             return 0;
299     if (columnCount() <= col)
300         return 0;
301     return sqlite3_column_int(m_statement, col);
302 }
303
304 int64_t SQLiteStatement::getColumnInt64(int col)
305 {
306     ASSERT(col >= 0);
307     if (!m_statement)
308         if (prepareAndStep() != SQLITE_ROW)
309             return 0;
310     if (columnCount() <= col)
311         return 0;
312     return sqlite3_column_int64(m_statement, col);
313 }
314     
315 void SQLiteStatement::getColumnBlobAsVector(int col, Vector<char>& result)
316 {
317     ASSERT(col >= 0);
318
319     if (!m_statement && prepareAndStep() != SQLITE_ROW) {
320         result.clear();
321         return;
322     }
323
324     if (columnCount() <= col) {
325         result.clear();
326         return;
327     }
328
329     const void* blob = sqlite3_column_blob(m_statement, col);
330     if (!blob) {
331         result.clear();
332         return;
333     }
334         
335     int size = sqlite3_column_bytes(m_statement, col);
336     result.resize((size_t)size);
337     for (int i = 0; i < size; ++i)
338         result[i] = ((const unsigned char*)blob)[i];
339 }
340
341 const void* SQLiteStatement::getColumnBlob(int col, int& size)
342 {
343     ASSERT(col >= 0);
344
345     size = 0;
346
347     if (finalize() != SQLITE_OK)
348         LOG(SQLDatabase, "Finalize failed");
349     if (prepare() != SQLITE_OK) {
350         LOG(SQLDatabase, "Prepare failed");
351         return 0;
352     }
353     if (step() != SQLITE_ROW) {
354         LOG(SQLDatabase, "Step wasn't a row");
355         return 0;
356     }
357
358     if (columnCount() <= col)
359         return 0;
360         
361     const void* blob = sqlite3_column_blob(m_statement, col);
362     if (!blob)
363         return 0;
364
365     size = sqlite3_column_bytes(m_statement, col);
366     return blob;
367 }
368
369 bool SQLiteStatement::returnTextResults(int col, Vector<String>& v)
370 {
371     ASSERT(col >= 0);
372
373     v.clear();
374
375     if (m_statement)
376         finalize();
377     if (prepare() != SQLITE_OK)
378         return false;
379
380     while (step() == SQLITE_ROW)
381         v.append(getColumnText(col));
382     bool result = true;
383     if (m_database.lastError() != SQLITE_DONE) {
384         result = false;
385         LOG(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
386     }
387     finalize();
388     return result;
389 }
390
391 bool SQLiteStatement::returnIntResults(int col, Vector<int>& v)
392 {
393     v.clear();
394
395     if (m_statement)
396         finalize();
397     if (prepare() != SQLITE_OK)
398         return false;
399         
400     while (step() == SQLITE_ROW)
401         v.append(getColumnInt(col));
402     bool result = true;
403     if (m_database.lastError() != SQLITE_DONE) {
404         result = false;
405         LOG(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
406     }
407     finalize();
408     return result;
409 }
410
411 bool SQLiteStatement::returnInt64Results(int col, Vector<int64_t>& v)
412 {
413     v.clear();
414
415     if (m_statement)
416         finalize();
417     if (prepare() != SQLITE_OK)
418         return false;
419         
420     while (step() == SQLITE_ROW)
421         v.append(getColumnInt64(col));
422     bool result = true;
423     if (m_database.lastError() != SQLITE_DONE) {
424         result = false;
425         LOG(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
426     }
427     finalize();
428     return result;
429 }
430
431 bool SQLiteStatement::returnDoubleResults(int col, Vector<double>& v)
432 {
433     v.clear();
434
435     if (m_statement)
436         finalize();
437     if (prepare() != SQLITE_OK)
438         return false;
439
440     while (step() == SQLITE_ROW)
441         v.append(getColumnDouble(col));
442     bool result = true;
443     if (m_database.lastError() != SQLITE_DONE) {
444         result = false;
445         LOG(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
446     }
447     finalize();
448     return result;
449 }
450
451 bool SQLiteStatement::isExpired()
452 {
453     return !m_statement || sqlite3_expired(m_statement);
454 }
455
456 } // namespace WebCore