mozilla-central/storage
Name Description Size
build 3
FileSystemModule.cpp 7065
FileSystemModule.h 652
IStorageBindingParamsInternal.h Implementation-only interface for mozIStorageBindingParams. This defines the set of methods required by the asynchronous execution code in order to consume the contents stored in mozIStorageBindingParams instances. 1872
moz.build 3266
mozIStorageAggregateFunction.idl mozIStorageAggregateFunction represents aggregate SQL function. Common examples of aggregate functions are SUM() and COUNT(). An aggregate function calculates one result for a given set of data, where a set of data is a group of tuples. There can be one group per request or many of them, if GROUP BY clause is used or not. 1324
mozIStorageAsyncConnection.idl mozIStorageAsyncConnection represents an asynchronous database connection attached to a specific file or to an in-memory data storage. It is the primary interface for interacting with a database from the main thread, including creating prepared statements, executing SQL, and examining database errors. 10673
mozIStorageAsyncStatement.idl An asynchronous SQL statement. This differs from mozIStorageStatement by only being usable for asynchronous execution. (mozIStorageStatement can be used for both synchronous and asynchronous purposes.) This specialization for asynchronous operation allows us to avoid needing to acquire synchronization primitives also used by the asynchronous execution thread. In contrast, mozIStorageStatement may need to acquire the primitives and consequently can cause the main thread to lock for extended intervals while the asynchronous thread performs some long-running operation. 1581
mozIStorageBaseStatement.idl The base interface for both pure asynchronous storage statements (mozIStorageAsyncStatement) and 'classic' storage statements (mozIStorageStatement) that can be used for both synchronous and asynchronous purposes. 4608
mozIStorageBindingParams.idl Binds aValue to the parameter with the name aName. @param aName The name of the parameter to bind aValue to. @param aValue The value to bind. 3902
mozIStorageBindingParamsArray.idl Creates a new mozIStorageBindingParams object that can be added to this array. @return a mozIStorageBindingParams object that can be used to specify parameters that need to be bound. 1089
mozIStorageCompletionCallback.idl Indicates that the event this callback was passed in for has completed. @param status The status of the call. Generally NS_OK if the operation completed successfully. @param value If the operation produces a result, the result. Otherwise, |null|. @see The calling method for expected values. 932
mozIStorageConnection.idl mozIStorageConnection represents a database connection attached to a specific file or to the in-memory data storage. It is the primary interface for interacting with a database, including creating prepared statements, executing SQL, and examining database errors. @note From the main thread, you should rather use mozIStorageAsyncConnection. @threadsafe 8826
mozIStorageError.idl General SQL error or missing database. 2622
mozIStorageFunction.idl mozIStorageFunction is to be implemented by storage consumers that wish to receive callbacks during the request execution. SQL can apply functions to values from tables. Examples of such functions are MIN(a1,a2) or SQRT(num). Many functions are implemented in SQL engine. This interface allows consumers to implement their own, problem-specific functions. These functions can be called from triggers, too. 1347
mozIStoragePendingStatement.idl Cancels a pending statement, if possible. This will only fail if you try cancel more than once. @note For read statements (such as SELECT), you will no longer receive any notifications about results once cancel is called. 745
mozIStorageProgressHandler.idl mozIProgressHandler is to be implemented by storage consumers that wish to receive callbacks during the request execution. 914
mozIStorageResultSet.idl Obtains the next row from the result set from the statement that was executed. @returns the next row from the result set. This will be null when there are no more results. 730
mozIStorageRow.idl Obtains the result of a given column specified by aIndex. @param aIndex Zero-based index of the result to get from the tuple. @returns the result of the specified column. 1239
mozIStorageService.idl The mozIStorageService interface is intended to be implemented by a service that can create storage connections (mozIStorageConnection) to either a well-known profile database or to a specific database file. This is the only way to open a database connection. @note The first reference to mozIStorageService must be made on the main thread. 8083
mozIStorageStatement.idl A SQL statement that can be used for both synchronous and asynchronous purposes. 10182
mozIStorageStatementCallback.idl Called when some result is obtained from the database. This function can be called more than once with a different storageIResultSet each time for any given asynchronous statement. @param aResultSet The result set containing the data from the database. 1792
mozIStorageVacuumParticipant.idl This interface contains the information that the Storage service needs to vacuum a database. This interface is created as a service through the category manager with the category "vacuum-participant". Please see https://developer.mozilla.org/en/mozIStorageVacuumParticipant for more information. 2282
mozIStorageValueArray.idl mozIStorageValueArray wraps an array of SQL values, such as a single database row. 5270
mozStorageArgValueArray.cpp 5062
mozStorageArgValueArray.h 870
mozStorageAsyncStatement.cpp 11274
mozStorageAsyncStatement.h Initializes the object on aDBConnection by preparing the SQL statement given by aSQLStatement. @param aDBConnection The Connection object this statement is associated with. @param aNativeConnection The native Sqlite connection this statement is associated with. @param aSQLStatement The SQL statement to prepare that this object will represent. 2952
mozStorageAsyncStatementExecution.cpp The following constants help batch rows into result sets. MAX_MILLISECONDS_BETWEEN_RESULTS was chosen because any user-based task that takes less than 200 milliseconds is considered to feel instantaneous to end users. MAX_ROWS_PER_RESULT was arbitrarily chosen to reduce the number of dispatches to calling thread, while also providing reasonably-sized sets of data for consumers. Both of these constants are used because we assume that consumers are trying to avoid blocking their execution thread for long periods of time, and dispatching many small events to the calling thread will end up blocking it. 18835
mozStorageAsyncStatementExecution.h Describes the state of execution. 7944
mozStorageAsyncStatementJSHelper.cpp 4599
mozStorageAsyncStatementJSHelper.h A modified version of StatementJSHelper that only exposes the async-specific 'params' helper. We do not expose 'row' or 'step' as they do not apply to us. 1659
mozStorageAsyncStatementParams.cpp 3767
mozStorageAsyncStatementParams.h 2315
mozStorageBindingParams.cpp 14012
mozStorageBindingParams.h Locks the parameters and prevents further modification to it (such as binding more elements to it). 3758
mozStorageBindingParamsArray.cpp 2282
mozStorageBindingParamsArray.h Locks the array and prevents further modification to it (such as adding more elements to it). 2760
mozStorageConnection.cpp Nothing 74504
mozStorageConnection.h Indicates if a database operation is synchronous or asynchronous. - Async operations may be called from any thread for all connections. - Sync operations may be called from any thread for sync connections, and from background threads for async connections. 16431
mozStorageError.cpp Note: This object is only ever accessed on one thread at a time. It it not threadsafe, but it does need threadsafe AddRef and Release. 1130
mozStorageError.h 809
mozStorageHelper.h This class wraps a transaction inside a given C++ scope, guaranteeing that the transaction will be completed even if you have an exception or return early. A common use is to create an instance with aCommitOnComplete = false (rollback), then call Commit() on this object manually when your function completes successfully. @note nested transactions are not supported by Sqlite, so if a transaction is already in progress, this object does nothing. Note that in this case, you may not get the transaction type you asked for, and you won't be able to rollback. @param aConnection The connection to create the transaction on. @param aCommitOnComplete Controls whether the transaction is committed or rolled back when this object goes out of scope. @param aType [optional] The transaction type, as defined in mozIStorageConnection. Uses the default transaction behavior for the connection if unspecified. @param aAsyncCommit [optional] Whether commit should be executed asynchronously on the helper thread. This is a special option introduced as an interim solution to reduce main-thread fsyncs in Places. Can only be used on main-thread. WARNING: YOU SHOULD _NOT_ WRITE NEW MAIN-THREAD CODE USING THIS! Notice that async commit might cause synchronous statements to fail with SQLITE_BUSY. A possible mitigation strategy is to use PRAGMA busy_timeout, but notice that might cause main-thread jank. Finally, if the database is using WAL journaling mode, other connections won't see the changes done in async committed transactions until commit is complete. For all of the above reasons, this should only be used as an interim solution and avoided completely if possible. 7254
mozStoragePrivateHelpers.cpp 7557
mozStoragePrivateHelpers.h This file contains convenience methods for mozStorage. 4446
mozStorageResultSet.cpp Note: This object is only ever accessed on one thread at a time. It it not threadsafe, but it does need threadsafe AddRef and Release. 1359
mozStorageResultSet.h Adds a tuple to this result set. 1172
mozStorageRow.cpp Note: This object is only ever accessed on one thread at a time. It it not threadsafe, but it does need threadsafe AddRef and Release. 5987
mozStorageRow.h Initializes the object with the given statement. Copies the values from the statement. @param aStatement The sqlite statement to pull results from. 1354
mozStorageService.cpp Passes a single SQLite memory statistic to a memory reporter callback. @param aHandleReport The callback. @param aData The data for the callback. @param aConn The SQLite connection. @param aPathHead Head of the path for the memory report. @param aKind The memory report statistic kind, one of "stmt", "cache" or "schema". @param aDesc The memory report description. @param aOption The SQLite constant for getting the measurement. @param aTotal The accumulator for the measurement. 26498
mozStorageService.h Initializes the service. This must be called before any other function! 5332
mozStorageSQLFunctions.cpp Performs the LIKE comparison of a string against a pattern. For more detail see http://www.sqlite.org/lang_expr.html#like. @param aPatternItr An iterator at the start of the pattern to check for. @param aPatternEnd An iterator at the end of the pattern to check for. @param aStringItr An iterator at the start of the string to check for the pattern. @param aStringEnd An iterator at the end of the string to check for the pattern. @param aEscapeChar The character to use for escaping symbols in the pattern. @return 1 if the pattern is found, 0 otherwise. 12701
mozStorageSQLFunctions.h Registers the functions declared here with the specified database. @param aDB The database we'll be registering the functions with. @return the SQLite status code indicating success or failure. 2859
mozStorageStatement.cpp 24653
mozStorageStatement.h Initializes the object on aDBConnection by preparing the SQL statement given by aSQLStatement. @param aDBConnection The Connection object this statement is associated with. @param aNativeConnection The native Sqlite connection this statement is associated with. @param aSQLStatement The SQL statement to prepare that this object will represent. 3465
mozStorageStatementData.h Return the sqlite statement, fetching it from the storage statement. In the case of AsyncStatements this may actually create the statement 4291
mozStorageStatementJSHelper.cpp 7744
mozStorageStatementJSHelper.h Wrappers used to clean up the references JS helpers hold to the statement. For cycle-avoidance reasons they do not hold reference-counted references, so it is important we do this. 1759
mozStorageStatementParams.cpp 3992
mozStorageStatementParams.h MOZSTORAGESTATEMENTPARAMS_H 2010
mozStorageStatementRow.cpp 4347
mozStorageStatementRow.h MOZSTORAGESTATEMENTROW_H 1462
rust 2
SQLCollations.cpp Helper function for the UTF-8 locale collations. @param aService The Service that owns the nsICollation used by this collation. @param aLen1 The number of bytes in aStr1. @param aStr1 The string to be compared against aStr2 as provided by SQLite. It must be a non-null-terminated char* buffer. @param aLen2 The number of bytes in aStr2. @param aStr2 The string to be compared against aStr1 as provided by SQLite. It must be a non-null-terminated char* buffer. @param aComparisonStrength The sorting strength, one of the nsICollation constants. @return aStr1 - aStr2. That is, if aStr1 < aStr2, returns a negative number. If aStr1 > aStr2, returns a positive number. If aStr1 == aStr2, returns 0. 7670
SQLCollations.h Registers the collating sequences declared here with the specified database and Service. @param aDB The database we'll be registering the collations with. @param aService The Service that owns the nsICollation used by our collations. @return the SQLite status code indicating success or failure. 9483
SQLiteMutex.h Wrapper class for sqlite3_mutexes. To be used whenever we want to use a sqlite3_mutex. @warning Never EVER wrap the same sqlite3_mutex with a different SQLiteMutex. If you do this, you void the deadlock detector's warranty! 4067
StatementCache.h Class used to cache statements (mozIStorageStatement or mozIStorageAsyncStatement). 3938
storage.h 1404
StorageBaseStatementInternal.cpp Used to finalize an asynchronous statement on the background thread. 7481
StorageBaseStatementInternal.h Implementation-only interface and shared logix mix-in corresponding to mozIStorageBaseStatement. Both Statement and AsyncStatement inherit from this. The interface aspect makes them look the same to implementation innards that aren't publicly accessible. The mix-in avoids code duplication in common implementations of mozIStorageBaseStatement, albeit with some minor performance/space overhead because we have to use defines to officially implement the methods on Statement/AsyncStatement (and proxy to this base class.) 13460
style.txt 4303
TelemetryVFS.cpp By default use the unix-excl VFS, for the following reasons: 1. It improves compatibility with NFS shares, whose implementation is incompatible with SQLite's locking requirements. Bug 433129 attempted to automatically identify such file-systems, but a reliable way was not found and the fallback locking is slower than POSIX locking, so we do not want to do it by default. 2. It allows wal mode to avoid the memory mapped -shm file, reducing the likelihood of SIGBUS failures when disk space is exhausted. 3. It provides some protection from third party database tampering while a connection is open. This preference allows to revert to the "unix" VFS, that is not exclusive, thus it can be used by developers to query a database through the Sqlite command line while it's already in use. 27391
test 3
VacuumManager.cpp 11470
VacuumManager.h Obtains the VacuumManager object. 1141
variant 2
Variant_inl.h Note: This file is included by Variant.h. 3742
Variant.cpp Return the data type of the given variant. This method used to be exposed to XPCOM, but since bug 1507540 it's marked [notxpcom] in the interface definition, so we need this C function to access it from Rust. 1799
Variant.h 78888042-0fa3-4f7a-8b19-7996f99bf1aa 13432
variantToSQLiteT_impl.h 4309