Home | History | Annotate | Download | only in sqlite 
      1 /*
      2  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
      3  * Copyright (C) 2007 Justin Haygood (jhaygood (at) reaktix.com)
      4  *
      5  * Redistribution and use in source and binary forms, with or without
      6  * modification, are permitted provided that the following conditions
      7  * are met:
      8  * 1. Redistributions of source code must retain the above copyright
      9  *    notice, this list of conditions and the following disclaimer.
     10  * 2. Redistributions in binary form must reproduce the above copyright
     11  *    notice, this list of conditions and the following disclaimer in the
     12  *    documentation and/or other materials provided with the distribution.
     13  *
     14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
     15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
     18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
     22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     25  */
     26 
     27 #ifndef SQLiteDatabase_h
     28 #define SQLiteDatabase_h
     29 
     30 #include "platform/heap/Handle.h"
     31 #include "wtf/Threading.h"
     32 #include "wtf/ThreadingPrimitives.h"
     33 #include "wtf/text/CString.h"
     34 #include "wtf/text/WTFString.h"
     35 
     36 #if COMPILER(MSVC)
     37 #pragma warning(disable: 4800)
     38 #endif
     39 
     40 struct sqlite3;
     41 
     42 namespace blink {
     43 
     44 class DatabaseAuthorizer;
     45 class SQLiteStatement;
     46 class SQLiteTransaction;
     47 
     48 extern const int SQLResultDone;
     49 extern const int SQLResultOk;
     50 extern const int SQLResultRow;
     51 extern const int SQLResultFull;
     52 extern const int SQLResultInterrupt;
     53 extern const int SQLResultConstraint;
     54 
     55 class SQLiteDatabase {
     56     DISALLOW_ALLOCATION();
     57     WTF_MAKE_NONCOPYABLE(SQLiteDatabase);
     58     friend class SQLiteTransaction;
     59 public:
     60     SQLiteDatabase();
     61     ~SQLiteDatabase();
     62 
     63     bool open(const String& filename, bool forWebSQLDatabase = false);
     64     bool isOpen() const { return m_db; }
     65     void close();
     66 
     67     void updateLastChangesCount();
     68 
     69     bool executeCommand(const String&);
     70 
     71     bool tableExists(const String&);
     72     int runVacuumCommand();
     73     int runIncrementalVacuumCommand();
     74 
     75     bool transactionInProgress() const { return m_transactionInProgress; }
     76 
     77     int64_t lastInsertRowID();
     78     int lastChanges();
     79 
     80     void setBusyTimeout(int ms);
     81 
     82     // Sets the maximum size in bytes
     83     // Depending on per-database attributes, the size will only be settable in units that are the page size of the database, which is established at creation
     84     // These chunks will never be anything other than 512, 1024, 2048, 4096, 8192, 16384, or 32768 bytes in size.
     85     // setMaximumSize() will round the size down to the next smallest chunk if the passed size doesn't align.
     86     void setMaximumSize(int64_t);
     87 
     88     // Gets the number of unused bytes in the database file.
     89     int64_t freeSpaceSize();
     90     int64_t totalSize();
     91 
     92     int lastError();
     93     const char* lastErrorMsg();
     94 
     95     sqlite3* sqlite3Handle() const {
     96         ASSERT(m_sharable || currentThread() == m_openingThread || !m_db);
     97         return m_db;
     98     }
     99 
    100     void setAuthorizer(DatabaseAuthorizer*);
    101 
    102     bool isAutoCommitOn() const;
    103 
    104     // The SQLite AUTO_VACUUM pragma can be either NONE, FULL, or INCREMENTAL.
    105     // NONE - SQLite does not do any vacuuming
    106     // FULL - SQLite moves all empty pages to the end of the DB file and truncates
    107     //        the file to remove those pages after every transaction. This option
    108     //        requires SQLite to store additional information about each page in
    109     //        the database file.
    110     // INCREMENTAL - SQLite stores extra information for each page in the database
    111     //               file, but removes the empty pages only when PRAGMA INCREMANTAL_VACUUM
    112     //               is called.
    113     enum AutoVacuumPragma { AutoVacuumNone = 0, AutoVacuumFull = 1, AutoVacuumIncremental = 2 };
    114     bool turnOnIncrementalAutoVacuum();
    115 
    116     void trace(Visitor*);
    117 
    118 private:
    119     static int authorizerFunction(void*, int, const char*, const char*, const char*, const char*);
    120 
    121     void enableAuthorizer(bool enable);
    122 
    123     int pageSize();
    124 
    125     sqlite3* m_db;
    126     int m_pageSize;
    127 
    128     bool m_transactionInProgress;
    129     bool m_sharable;
    130 
    131     Mutex m_authorizerLock;
    132     RefPtrWillBeMember<DatabaseAuthorizer> m_authorizer;
    133 
    134     ThreadIdentifier m_openingThread;
    135 
    136     Mutex m_databaseClosingMutex;
    137 
    138     int m_openError;
    139     CString m_openErrorMessage;
    140 
    141     int m_lastChangesCount;
    142 };
    143 
    144 } // namespace blink
    145 
    146 #endif
    147