1/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package android.database.sqlite;
18
19import java.util.ArrayList;
20
21import android.util.Log;
22
23/**
24 * Provides debugging info about all SQLite databases running in the current process.
25 *
26 * {@hide}
27 */
28public final class SQLiteDebug {
29    /**
30     * Controls the printing of SQL statements as they are executed.
31     */
32    public static final boolean DEBUG_SQL_STATEMENTS =
33            Log.isLoggable("SQLiteStatements", Log.VERBOSE);
34
35    /**
36     * Controls the printing of wall-clock time taken to execute SQL statements
37     * as they are executed.
38     */
39    public static final boolean DEBUG_SQL_TIME =
40            Log.isLoggable("SQLiteTime", Log.VERBOSE);
41
42    /**
43     * Controls the printing of compiled-sql-statement cache stats.
44     */
45    public static final boolean DEBUG_SQL_CACHE =
46            Log.isLoggable("SQLiteCompiledSql", Log.VERBOSE);
47
48    /**
49     * Controls the stack trace reporting of active cursors being
50     * finalized.
51     */
52    public static final boolean DEBUG_ACTIVE_CURSOR_FINALIZATION =
53            Log.isLoggable("SQLiteCursorClosing", Log.VERBOSE);
54
55    /**
56     * Controls the tracking of time spent holding the database lock.
57     */
58    public static final boolean DEBUG_LOCK_TIME_TRACKING =
59            Log.isLoggable("SQLiteLockTime", Log.VERBOSE);
60
61    /**
62     * Controls the printing of stack traces when tracking the time spent holding the database lock.
63     */
64    public static final boolean DEBUG_LOCK_TIME_TRACKING_STACK_TRACE =
65            Log.isLoggable("SQLiteLockStackTrace", Log.VERBOSE);
66
67    /**
68     * Contains statistics about the active pagers in the current process.
69     *
70     * @see #getPagerStats(PagerStats)
71     */
72    public static class PagerStats {
73        /** The total number of bytes in all pagers in the current process
74         * @deprecated not used any longer
75         */
76        @Deprecated
77        public long totalBytes;
78        /** The number of bytes in referenced pages in all pagers in the current process
79         * @deprecated not used any longer
80         * */
81        @Deprecated
82        public long referencedBytes;
83        /** The number of bytes in all database files opened in the current process
84         * @deprecated not used any longer
85         */
86        @Deprecated
87        public long databaseBytes;
88        /** The number of pagers opened in the current process
89         * @deprecated not used any longer
90         */
91        @Deprecated
92        public int numPagers;
93
94        /** the current amount of memory checked out by sqlite using sqlite3_malloc().
95         * documented at http://www.sqlite.org/c3ref/c_status_malloc_size.html
96         */
97        public int memoryUsed;
98
99        /** the number of bytes of page cache allocation which could not be sattisfied by the
100         * SQLITE_CONFIG_PAGECACHE buffer and where forced to overflow to sqlite3_malloc().
101         * The returned value includes allocations that overflowed because they where too large
102         * (they were larger than the "sz" parameter to SQLITE_CONFIG_PAGECACHE) and allocations
103         * that overflowed because no space was left in the page cache.
104         * documented at http://www.sqlite.org/c3ref/c_status_malloc_size.html
105         */
106        public int pageCacheOverflo;
107
108        /** records the largest memory allocation request handed to sqlite3.
109         * documented at http://www.sqlite.org/c3ref/c_status_malloc_size.html
110         */
111        public int largestMemAlloc;
112
113        /** a list of {@link DbStats} - one for each main database opened by the applications
114         * running on the android device
115         */
116        public ArrayList<DbStats> dbStats;
117    }
118
119    /**
120     * contains statistics about a database
121     */
122    public static class DbStats {
123        /** name of the database */
124        public String dbName;
125
126        /** the page size for the database */
127        public long pageSize;
128
129        /** the database size */
130        public long dbSize;
131
132        /** documented here http://www.sqlite.org/c3ref/c_dbstatus_lookaside_used.html */
133        public int lookaside;
134
135        public DbStats(String dbName, long pageCount, long pageSize, int lookaside) {
136            this.dbName = dbName;
137            this.pageSize = pageSize / 1024;
138            dbSize = (pageCount * pageSize) / 1024;
139            this.lookaside = lookaside;
140        }
141    }
142
143    /**
144     * return all pager and database stats for the current process.
145     * @return {@link PagerStats}
146     */
147    public static PagerStats getDatabaseInfo() {
148        PagerStats stats = new PagerStats();
149        getPagerStats(stats);
150        stats.dbStats = SQLiteDatabase.getDbStats();
151        return stats;
152    }
153
154    /**
155     * Gathers statistics about all pagers in the current process.
156     */
157    public static native void getPagerStats(PagerStats stats);
158
159    /**
160     * Returns the size of the SQLite heap.
161     * @return The size of the SQLite heap in bytes.
162     */
163    public static native long getHeapSize();
164
165    /**
166     * Returns the amount of allocated memory in the SQLite heap.
167     * @return The allocated size in bytes.
168     */
169    public static native long getHeapAllocatedSize();
170
171    /**
172     * Returns the amount of free memory in the SQLite heap.
173     * @return The freed size in bytes.
174     */
175    public static native long getHeapFreeSize();
176
177    /**
178     * Determines the number of dirty belonging to the SQLite
179     * heap segments of this process.  pages[0] returns the number of
180     * shared pages, pages[1] returns the number of private pages
181     */
182    public static native void getHeapDirtyPages(int[] pages);
183
184    private static int sNumActiveCursorsFinalized = 0;
185
186    /**
187     * Returns the number of active cursors that have been finalized. This depends on the GC having
188     * run but is still useful for tests.
189     */
190    public static int getNumActiveCursorsFinalized() {
191        return sNumActiveCursorsFinalized;
192    }
193
194    static synchronized void notifyActiveCursorFinalized() {
195        sNumActiveCursorsFinalized++;
196    }
197}
198