e5e3c07d89aae420f3885b185df1f0064cd59863
[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     DeprecatedMutexLocker 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     DeprecatedMutexLocker 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
292     return equalIgnoringCase(String("BLOB"), String(reinterpret_cast<const UChar*>(sqlite3_column_decltype16(m_statement, col))));
293 }
294
295 String SQLiteStatement::getColumnName(int col)
296 {
297     ASSERT(col >= 0);
298     if (!m_statement)
299         if (prepareAndStep() != SQLITE_ROW)
300             return String();
301     if (columnCount() <= col)
302         return String();
303     return String(reinterpret_cast<const UChar*>(sqlite3_column_name16(m_statement, col)));
304 }
305
306 SQLValue SQLiteStatement::getColumnValue(int col)
307 {
308     ASSERT(col >= 0);
309     if (!m_statement)
310         if (prepareAndStep() != SQLITE_ROW)
311             return SQLValue();
312     if (columnCount() <= col)
313         return SQLValue();
314
315     // SQLite is typed per value. optional column types are
316     // "(mostly) ignored"
317     sqlite3_value* value = sqlite3_column_value(m_statement, col);
318     switch (sqlite3_value_type(value)) {
319         case SQLITE_INTEGER:    // SQLValue and JS don't represent integers, so use FLOAT -case
320         case SQLITE_FLOAT:
321             return SQLValue(sqlite3_value_double(value));
322         case SQLITE_BLOB:       // SQLValue and JS don't represent blobs, so use TEXT -case
323         case SQLITE_TEXT: {
324             const UChar* string = reinterpret_cast<const UChar*>(sqlite3_value_text16(value));
325             return SQLValue(StringImpl::create8BitIfPossible(string));
326         }
327         case SQLITE_NULL:
328             return SQLValue();
329         default:
330             break;
331     }
332     ASSERT_NOT_REACHED();
333     return SQLValue();
334 }
335
336 String SQLiteStatement::getColumnText(int col)
337 {
338     ASSERT(col >= 0);
339     if (!m_statement)
340         if (prepareAndStep() != SQLITE_ROW)
341             return String();
342     if (columnCount() <= col)
343         return String();
344     return String(reinterpret_cast<const UChar*>(sqlite3_column_text16(m_statement, col)), sqlite3_column_bytes16(m_statement, col) / sizeof(UChar));
345 }
346     
347 double SQLiteStatement::getColumnDouble(int col)
348 {
349     ASSERT(col >= 0);
350     if (!m_statement)
351         if (prepareAndStep() != SQLITE_ROW)
352             return 0.0;
353     if (columnCount() <= col)
354         return 0.0;
355     return sqlite3_column_double(m_statement, col);
356 }
357
358 int SQLiteStatement::getColumnInt(int col)
359 {
360     ASSERT(col >= 0);
361     if (!m_statement)
362         if (prepareAndStep() != SQLITE_ROW)
363             return 0;
364     if (columnCount() <= col)
365         return 0;
366     return sqlite3_column_int(m_statement, col);
367 }
368
369 int64_t SQLiteStatement::getColumnInt64(int col)
370 {
371     ASSERT(col >= 0);
372     if (!m_statement)
373         if (prepareAndStep() != SQLITE_ROW)
374             return 0;
375     if (columnCount() <= col)
376         return 0;
377     return sqlite3_column_int64(m_statement, col);
378 }
379
380 String SQLiteStatement::getColumnBlobAsString(int col)
381 {
382     ASSERT(col >= 0);
383
384     if (!m_statement && prepareAndStep() != SQLITE_ROW)
385         return String();
386
387     if (columnCount() <= col)
388         return String();
389
390     const void* blob = sqlite3_column_blob(m_statement, col);
391     if (!blob)
392         return String();
393
394     int size = sqlite3_column_bytes(m_statement, col);
395     if (size < 0)
396         return String();
397
398     ASSERT(!(size % sizeof(UChar)));
399     return String(static_cast<const UChar*>(blob), size / sizeof(UChar));
400 }
401
402 void SQLiteStatement::getColumnBlobAsVector(int col, Vector<char>& result)
403 {
404     ASSERT(col >= 0);
405
406     if (!m_statement && prepareAndStep() != SQLITE_ROW) {
407         result.clear();
408         return;
409     }
410
411     if (columnCount() <= col) {
412         result.clear();
413         return;
414     }
415
416     const void* blob = sqlite3_column_blob(m_statement, col);
417     if (!blob) {
418         result.clear();
419         return;
420     }
421         
422     int size = sqlite3_column_bytes(m_statement, col);
423     result.resize((size_t)size);
424     for (int i = 0; i < size; ++i)
425         result[i] = (static_cast<const unsigned char*>(blob))[i];
426 }
427
428 void SQLiteStatement::getColumnBlobAsVector(int col, Vector<uint8_t>& result)
429 {
430     ASSERT(col >= 0);
431
432     if (!m_statement && prepareAndStep() != SQLITE_ROW) {
433         result.clear();
434         return;
435     }
436
437     if (columnCount() <= col) {
438         result.clear();
439         return;
440     }
441
442     const void* blob = sqlite3_column_blob(m_statement, col);
443     if (!blob) {
444         result.clear();
445         return;
446     }
447         
448     int size = sqlite3_column_bytes(m_statement, col);
449     result.resize((size_t)size);
450     for (int i = 0; i < size; ++i)
451         result[i] = (static_cast<const uint8_t*>(blob))[i];
452 }
453
454 bool SQLiteStatement::returnTextResults(int col, Vector<String>& v)
455 {
456     ASSERT(col >= 0);
457
458     v.clear();
459
460     if (m_statement)
461         finalize();
462     if (prepare() != SQLITE_OK)
463         return false;
464
465     while (step() == SQLITE_ROW)
466         v.append(getColumnText(col));
467     bool result = true;
468     if (m_database.lastError() != SQLITE_DONE) {
469         result = false;
470         LOG(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
471     }
472     finalize();
473     return result;
474 }
475
476 bool SQLiteStatement::returnIntResults(int col, Vector<int>& v)
477 {
478     v.clear();
479
480     if (m_statement)
481         finalize();
482     if (prepare() != SQLITE_OK)
483         return false;
484
485     while (step() == SQLITE_ROW)
486         v.append(getColumnInt(col));
487     bool result = true;
488     if (m_database.lastError() != SQLITE_DONE) {
489         result = false;
490         LOG(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
491     }
492     finalize();
493     return result;
494 }
495
496 bool SQLiteStatement::returnInt64Results(int col, Vector<int64_t>& v)
497 {
498     v.clear();
499
500     if (m_statement)
501         finalize();
502     if (prepare() != SQLITE_OK)
503         return false;
504
505     while (step() == SQLITE_ROW)
506         v.append(getColumnInt64(col));
507     bool result = true;
508     if (m_database.lastError() != SQLITE_DONE) {
509         result = false;
510         LOG(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
511     }
512     finalize();
513     return result;
514 }
515
516 bool SQLiteStatement::returnDoubleResults(int col, Vector<double>& v)
517 {
518     v.clear();
519
520     if (m_statement)
521         finalize();
522     if (prepare() != SQLITE_OK)
523         return false;
524
525     while (step() == SQLITE_ROW)
526         v.append(getColumnDouble(col));
527     bool result = true;
528     if (m_database.lastError() != SQLITE_DONE) {
529         result = false;
530         LOG(SQLDatabase, "Error reading results from database query %s", m_query.ascii().data());
531     }
532     finalize();
533     return result;
534 }
535
536 bool SQLiteStatement::isExpired()
537 {
538     return !m_statement || sqlite3_expired(m_statement);
539 }
540
541 } // namespace WebCore