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