d66c817fa8732e4d151893914578fa3ce8fc176d
[WebKit-https.git] / Source / 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 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 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 #include <wtf/text/StringView.h>
34
35 // SQLite 3.6.16 makes sqlite3_prepare_v2 automatically retry preparing the statement
36 // once if the database scheme has changed. We rely on this behavior.
37 #if SQLITE_VERSION_NUMBER < 3006016
38 #error SQLite version 3.6.16 or newer is required
39 #endif
40
41 namespace WebCore {
42
43 SQLiteStatement::SQLiteStatement(SQLiteDatabase& db, const String& sql)
44     : m_database(db)
45     , m_query(sql)
46     , m_statement(0)
47 #ifndef NDEBUG
48     , m_isPrepared(false)
49 #endif
50 {
51 }
52
53 SQLiteStatement::~SQLiteStatement()
54 {
55     finalize();
56 }
57
58 int SQLiteStatement::prepare()
59 {
60     ASSERT(!m_isPrepared);
61
62     LockHolder databaseLock(m_database.databaseMutex());
63
64     CString query = m_query.stripWhiteSpace().utf8();
65     
66     LOG(SQLDatabase, "SQL - prepare - %s", query.data());
67
68     // Pass the length of the string including the null character to sqlite3_prepare_v2;
69     // this lets SQLite avoid an extra string copy.
70     size_t lengthIncludingNullCharacter = query.length() + 1;
71
72     const char* tail = nullptr;
73     int error = sqlite3_prepare_v2(m_database.sqlite3Handle(), query.data(), lengthIncludingNullCharacter, &m_statement, &tail);
74
75     if (error != SQLITE_OK)
76         LOG(SQLDatabase, "sqlite3_prepare16 failed (%i)\n%s\n%s", error, query.data(), sqlite3_errmsg(m_database.sqlite3Handle()));
77
78     if (tail && *tail)
79         error = SQLITE_ERROR;
80
81 #ifndef NDEBUG
82     m_isPrepared = error == SQLITE_OK;
83 #endif
84     return error;
85 }
86
87 int SQLiteStatement::step()
88 {
89     LockHolder databaseLock(m_database.databaseMutex());
90
91     if (!m_statement)
92         return SQLITE_OK;
93
94     // The database needs to update its last changes count before each statement
95     // in order to compute properly the lastChanges() return value.
96     m_database.updateLastChangesCount();
97
98     LOG(SQLDatabase, "SQL - step - %s", m_query.ascii().data());
99     int error = sqlite3_step(m_statement);
100     if (error != SQLITE_DONE && error != SQLITE_ROW) {
101         LOG(SQLDatabase, "sqlite3_step failed (%i)\nQuery - %s\nError - %s", 
102             error, m_query.ascii().data(), sqlite3_errmsg(m_database.sqlite3Handle()));
103     }
104
105     return error;
106 }
107     
108 int SQLiteStatement::finalize()
109 {
110 #ifndef NDEBUG
111     m_isPrepared = false;
112 #endif
113     if (!m_statement)
114         return SQLITE_OK;
115     LOG(SQLDatabase, "SQL - finalize - %s", m_query.ascii().data());
116     int result = sqlite3_finalize(m_statement);
117     m_statement = 0;
118     return result;
119 }
120
121 int SQLiteStatement::reset() 
122 {
123     ASSERT(m_isPrepared);
124     if (!m_statement)
125         return SQLITE_OK;
126     LOG(SQLDatabase, "SQL - reset - %s", m_query.ascii().data());
127     return sqlite3_reset(m_statement);
128 }
129
130 bool SQLiteStatement::executeCommand()
131 {
132     if (!m_statement && prepare() != SQLITE_OK)
133         return false;
134     ASSERT(m_isPrepared);
135     if (step() != SQLITE_DONE) {
136         finalize();
137         return false;
138     }
139     finalize();
140     return true;
141 }
142
143 bool SQLiteStatement::returnsAtLeastOneResult()
144 {
145     if (!m_statement && prepare() != SQLITE_OK)
146         return false;
147     ASSERT(m_isPrepared);
148     if (step() != SQLITE_ROW) {
149         finalize();
150         return false;
151     }
152     finalize();
153     return true;
154
155 }
156
157 int SQLiteStatement::bindBlob(int index, const void* blob, int size)
158 {
159     ASSERT(m_isPrepared);
160     ASSERT(index > 0);
161     ASSERT(static_cast<unsigned>(index) <= bindParameterCount());
162     ASSERT(blob);
163     ASSERT(size >= 0);
164
165     if (!m_statement)
166         return SQLITE_ERROR;
167
168     return sqlite3_bind_blob(m_statement, index, blob, size, SQLITE_TRANSIENT);
169 }
170
171 int SQLiteStatement::bindBlob(int index, const String& text)
172 {
173     // String::characters() returns 0 for the empty string, which SQLite
174     // treats as a null, so we supply a non-null pointer for that case.
175     auto upconvertedCharacters = StringView(text).upconvertedCharacters();
176     UChar anyCharacter = 0;
177     const UChar* characters;
178     if (text.isEmpty() && !text.isNull())
179         characters = &anyCharacter;
180     else
181         characters = upconvertedCharacters;
182
183     return bindBlob(index, characters, text.length() * sizeof(UChar));
184 }
185
186 int SQLiteStatement::bindText(int index, const String& text)
187 {
188     ASSERT(m_isPrepared);
189     ASSERT(index > 0);
190     ASSERT(static_cast<unsigned>(index) <= bindParameterCount());
191
192     // String::characters() returns 0 for the empty string, which SQLite
193     // treats as a null, so we supply a non-null pointer for that case.
194     auto upconvertedCharacters = StringView(text).upconvertedCharacters();
195     UChar anyCharacter = 0;
196     const UChar* characters;
197     if (text.isEmpty() && !text.isNull())
198         characters = &anyCharacter;
199     else
200         characters = upconvertedCharacters;
201
202     return sqlite3_bind_text16(m_statement, index, characters, sizeof(UChar) * text.length(), SQLITE_TRANSIENT);
203 }
204
205 int SQLiteStatement::bindInt(int index, int integer)
206 {
207     ASSERT(m_isPrepared);
208     ASSERT(index > 0);
209     ASSERT(static_cast<unsigned>(index) <= bindParameterCount());
210
211     return sqlite3_bind_int(m_statement, index, integer);
212 }
213
214 int SQLiteStatement::bindInt64(int index, int64_t integer)
215 {
216     ASSERT(m_isPrepared);
217     ASSERT(index > 0);
218     ASSERT(static_cast<unsigned>(index) <= bindParameterCount());
219
220     return sqlite3_bind_int64(m_statement, index, integer);
221 }
222
223 int SQLiteStatement::bindDouble(int index, double number)
224 {
225     ASSERT(m_isPrepared);
226     ASSERT(index > 0);
227     ASSERT(static_cast<unsigned>(index) <= bindParameterCount());
228
229     return sqlite3_bind_double(m_statement, index, number);
230 }
231
232 int SQLiteStatement::bindNull(int index)
233 {
234     ASSERT(m_isPrepared);
235     ASSERT(index > 0);
236     ASSERT(static_cast<unsigned>(index) <= bindParameterCount());
237
238     return sqlite3_bind_null(m_statement, index);
239 }
240
241 int SQLiteStatement::bindValue(int index, const SQLValue& value)
242 {
243     switch (value.type()) {
244         case SQLValue::StringValue:
245             return bindText(index, value.string());
246         case SQLValue::NumberValue:
247             return bindDouble(index, value.number());
248         case SQLValue::NullValue:
249             return bindNull(index);
250     }
251
252     ASSERT_NOT_REACHED();
253     return SQLITE_ERROR;
254 }
255
256 unsigned SQLiteStatement::bindParameterCount() const
257 {
258     ASSERT(m_isPrepared);
259     if (!m_statement)
260         return 0;
261     return sqlite3_bind_parameter_count(m_statement);
262 }
263
264 int SQLiteStatement::columnCount()
265 {
266     ASSERT(m_isPrepared);
267     if (!m_statement)
268         return 0;
269     return sqlite3_data_count(m_statement);
270 }
271
272 bool SQLiteStatement::isColumnNull(int col)
273 {
274     ASSERT(col >= 0);
275     if (!m_statement)
276         if (prepareAndStep() != SQLITE_ROW)
277             return false;
278     if (columnCount() <= col)
279         return false;
280
281     return sqlite3_column_type(m_statement, col) == SQLITE_NULL;
282 }
283
284 bool SQLiteStatement::isColumnDeclaredAsBlob(int col)
285 {
286     ASSERT(col >= 0);
287     if (!m_statement) {
288         if (prepare() != SQLITE_OK)
289             return false;
290     }
291     return equalLettersIgnoringASCIICase(StringView(reinterpret_cast<const UChar*>(sqlite3_column_decltype16(m_statement, col))), "blob");
292 }
293
294 String SQLiteStatement::getColumnName(int col)
295 {
296     ASSERT(col >= 0);
297     if (!m_statement)
298         if (prepareAndStep() != SQLITE_ROW)
299             return String();
300     if (columnCount() <= col)
301         return String();
302     return String(reinterpret_cast<const UChar*>(sqlite3_column_name16(m_statement, col)));
303 }
304
305 SQLValue SQLiteStatement::getColumnValue(int col)
306 {
307     ASSERT(col >= 0);
308     if (!m_statement)
309         if (prepareAndStep() != SQLITE_ROW)
310             return SQLValue();
311     if (columnCount() <= col)
312         return SQLValue();
313
314     // SQLite is typed per value. optional column types are
315     // "(mostly) ignored"
316     sqlite3_value* value = sqlite3_column_value(m_statement, col);
317     switch (sqlite3_value_type(value)) {
318         case SQLITE_INTEGER:    // SQLValue and JS don't represent integers, so use FLOAT -case
319         case SQLITE_FLOAT:
320             return SQLValue(sqlite3_value_double(value));
321         case SQLITE_BLOB:       // SQLValue and JS don't represent blobs, so use TEXT -case
322         case SQLITE_TEXT: {
323             const UChar* string = reinterpret_cast<const UChar*>(sqlite3_value_text16(value));
324             return SQLValue(StringImpl::create8BitIfPossible(string));
325         }
326         case SQLITE_NULL:
327             return SQLValue();
328         default:
329             break;
330     }
331     ASSERT_NOT_REACHED();
332     return SQLValue();
333 }
334
335 String SQLiteStatement::getColumnText(int col)
336 {
337     ASSERT(col >= 0);
338     if (!m_statement)
339         if (prepareAndStep() != SQLITE_ROW)
340             return String();
341     if (columnCount() <= col)
342         return String();
343     return String(reinterpret_cast<const UChar*>(sqlite3_column_text16(m_statement, col)), sqlite3_column_bytes16(m_statement, col) / sizeof(UChar));
344 }
345     
346 double SQLiteStatement::getColumnDouble(int col)
347 {
348     ASSERT(col >= 0);
349     if (!m_statement)
350         if (prepareAndStep() != SQLITE_ROW)
351             return 0.0;
352     if (columnCount() <= col)
353         return 0.0;
354     return sqlite3_column_double(m_statement, col);
355 }
356
357 int SQLiteStatement::getColumnInt(int col)
358 {
359     ASSERT(col >= 0);
360     if (!m_statement)
361         if (prepareAndStep() != SQLITE_ROW)
362             return 0;
363     if (columnCount() <= col)
364         return 0;
365     return sqlite3_column_int(m_statement, col);
366 }
367
368 int64_t SQLiteStatement::getColumnInt64(int col)
369 {
370     ASSERT(col >= 0);
371     if (!m_statement)
372         if (prepareAndStep() != SQLITE_ROW)
373             return 0;
374     if (columnCount() <= col)
375         return 0;
376     return sqlite3_column_int64(m_statement, col);
377 }
378
379 String SQLiteStatement::getColumnBlobAsString(int col)
380 {
381     ASSERT(col >= 0);
382
383     if (!m_statement && prepareAndStep() != SQLITE_ROW)
384         return String();
385
386     if (columnCount() <= col)
387         return String();
388
389     const void* blob = sqlite3_column_blob(m_statement, col);
390     if (!blob)
391         return String();
392
393     int size = sqlite3_column_bytes(m_statement, col);
394     if (size < 0)
395         return String();
396
397     ASSERT(!(size % sizeof(UChar)));
398     return String(static_cast<const UChar*>(blob), size / sizeof(UChar));
399 }
400
401 void SQLiteStatement::getColumnBlobAsVector(int col, Vector<char>& result)
402 {
403     ASSERT(col >= 0);
404
405     if (!m_statement && prepareAndStep() != SQLITE_ROW) {
406         result.clear();
407         return;
408     }
409
410     if (columnCount() <= col) {
411         result.clear();
412         return;
413     }
414
415     const void* blob = sqlite3_column_blob(m_statement, col);
416     if (!blob) {
417         result.clear();
418         return;
419     }
420         
421     int size = sqlite3_column_bytes(m_statement, col);
422     result.resize((size_t)size);
423     for (int i = 0; i < size; ++i)
424         result[i] = (static_cast<const unsigned char*>(blob))[i];
425 }
426
427 void SQLiteStatement::getColumnBlobAsVector(int col, Vector<uint8_t>& result)
428 {
429     ASSERT(col >= 0);
430
431     if (!m_statement && prepareAndStep() != SQLITE_ROW) {
432         result.clear();
433         return;
434     }
435
436     if (columnCount() <= col) {
437         result.clear();
438         return;
439     }
440
441     const void* blob = sqlite3_column_blob(m_statement, col);
442     if (!blob) {
443         result.clear();
444         return;
445     }
446         
447     int size = sqlite3_column_bytes(m_statement, col);
448     result.resize((size_t)size);
449     for (int i = 0; i < size; ++i)
450         result[i] = (static_cast<const uint8_t*>(blob))[i];
451 }
452
453 bool SQLiteStatement::returnTextResults(int col, Vector<String>& v)
454 {
455     ASSERT(col >= 0);
456
457     v.clear();
458
459     if (m_statement)
460         finalize();
461     if (prepare() != SQLITE_OK)
462         return false;
463
464     while (step() == SQLITE_ROW)
465         v.append(getColumnText(col));
466     bool result = true;
467     if (m_database.lastError() != SQLITE_DONE) {
468         result = false;
469         LOG(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
470     }
471     finalize();
472     return result;
473 }
474
475 bool SQLiteStatement::returnIntResults(int col, Vector<int>& v)
476 {
477     v.clear();
478
479     if (m_statement)
480         finalize();
481     if (prepare() != SQLITE_OK)
482         return false;
483
484     while (step() == SQLITE_ROW)
485         v.append(getColumnInt(col));
486     bool result = true;
487     if (m_database.lastError() != SQLITE_DONE) {
488         result = false;
489         LOG(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
490     }
491     finalize();
492     return result;
493 }
494
495 bool SQLiteStatement::returnInt64Results(int col, Vector<int64_t>& v)
496 {
497     v.clear();
498
499     if (m_statement)
500         finalize();
501     if (prepare() != SQLITE_OK)
502         return false;
503
504     while (step() == SQLITE_ROW)
505         v.append(getColumnInt64(col));
506     bool result = true;
507     if (m_database.lastError() != SQLITE_DONE) {
508         result = false;
509         LOG(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
510     }
511     finalize();
512     return result;
513 }
514
515 bool SQLiteStatement::returnDoubleResults(int col, Vector<double>& v)
516 {
517     v.clear();
518
519     if (m_statement)
520         finalize();
521     if (prepare() != SQLITE_OK)
522         return false;
523
524     while (step() == SQLITE_ROW)
525         v.append(getColumnDouble(col));
526     bool result = true;
527     if (m_database.lastError() != SQLITE_DONE) {
528         result = false;
529         LOG(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
530     }
531     finalize();
532     return result;
533 }
534
535 bool SQLiteStatement::isExpired()
536 {
537     return !m_statement;
538 }
539
540 } // namespace WebCore