#pragma once
#if ENABLE(INDEXED_DATABASE)
#include "IDBCursorRecord.h"
#include "IDBIndexInfo.h"
#include "IDBKeyData.h"
#include "IDBKeyRangeData.h"
#include "IDBResourceIdentifier.h"
#include "IDBValue.h"
#include "SQLiteStatement.h"
#include <wtf/Deque.h>
#include <wtf/Noncopyable.h>
namespace WebCore {
class IDBCursorInfo;
class IDBGetResult;
namespace IDBServer {
class SQLiteIDBTransaction;
class SQLiteIDBCursor {
WTF_MAKE_FAST_ALLOCATED;
WTF_MAKE_NONCOPYABLE(SQLiteIDBCursor);
public:
static std::unique_ptr<SQLiteIDBCursor> maybeCreate(SQLiteIDBTransaction&, const IDBCursorInfo&);
static std::unique_ptr<SQLiteIDBCursor> maybeCreateBackingStoreCursor(SQLiteIDBTransaction&, const uint64_t objectStoreIdentifier, const uint64_t indexIdentifier, const IDBKeyRangeData&);
SQLiteIDBCursor(SQLiteIDBTransaction&, const IDBCursorInfo&);
SQLiteIDBCursor(SQLiteIDBTransaction&, uint64_t objectStoreID, uint64_t indexID, const IDBKeyRangeData&);
~SQLiteIDBCursor();
const IDBResourceIdentifier& identifier() const { return m_cursorIdentifier; }
SQLiteIDBTransaction* transaction() const { return m_transaction; }
int64_t objectStoreID() const { return m_objectStoreID; }
int64_t currentRecordRowID() const;
const IDBKeyData& currentKey() const;
const IDBKeyData& currentPrimaryKey() const;
const IDBValue& currentValue() const;
bool advance(uint64_t count);
bool iterate(const IDBKeyData& targetKey, const IDBKeyData& targetPrimaryKey);
bool prefetchOneRecord();
bool prefetch();
bool didComplete() const;
bool didError() const;
void objectStoreRecordsChanged();
enum class ShouldIncludePrefetchedRecords { No, Yes };
void currentData(IDBGetResult&, const Optional<IDBKeyPath>&, ShouldIncludePrefetchedRecords = ShouldIncludePrefetchedRecords::No);
private:
bool establishStatement();
bool createSQLiteStatement(const String& sql);
bool bindArguments();
bool resetAndRebindPreIndexStatementIfNecessary();
void resetAndRebindStatement();
enum class FetchResult {
Success,
Failure,
ShouldFetchAgain
};
bool fetch();
struct SQLiteCursorRecord {
IDBCursorRecord record;
bool completed { false };
bool errored { false };
int64_t rowID { 0 };
bool isTerminalRecord() const { return completed || errored; }
};
bool fetchNextRecord(SQLiteCursorRecord&);
FetchResult internalFetchNextRecord(SQLiteCursorRecord&);
void markAsErrored(SQLiteCursorRecord&);
bool isDirectionNext() const { return m_cursorDirection == IndexedDB::CursorDirection::Next || m_cursorDirection == IndexedDB::CursorDirection::Nextunique; }
void increaseCountToPrefetch();
SQLiteIDBTransaction* m_transaction;
IDBResourceIdentifier m_cursorIdentifier;
int64_t m_objectStoreID;
int64_t m_indexID { IDBIndexInfo::InvalidId };
IndexedDB::CursorDirection m_cursorDirection { IndexedDB::CursorDirection::Next };
IndexedDB::CursorType m_cursorType;
IDBKeyRangeData m_keyRange;
IDBKeyData m_currentLowerKey;
IDBKeyData m_currentUpperKey;
IDBKeyData m_currentIndexRecordValue;
Deque<SQLiteCursorRecord> m_fetchedRecords;
uint64_t m_fetchedRecordsSize { 0 };
IDBKeyData m_currentKeyForUniqueness;
std::unique_ptr<SQLiteStatement> m_preIndexStatement;
std::unique_ptr<SQLiteStatement> m_statement;
std::unique_ptr<SQLiteStatement> m_cachedObjectStoreStatement;
bool m_statementNeedsReset { true };
int64_t m_boundID { 0 };
bool m_backingStoreCursor { false };
unsigned m_prefetchCount { 0 };
};
} }
#endif // ENABLE(INDEXED_DATABASE)