Question

我正在传输日志文件，当捕获某个日志条目时（让我们调用这些事件A），我将它们写入IndexedDB。当捕获另一个特定日志条目（例如，事件B）时，我在对象库中搜索匹配的事件A条目。

只要事件A和事件B不会连续发生，这种方法就可以正常工作。如果它们连续发生（让我们说事件A写入日志文件，然后事件B立即写入），则找不到事件A中的条目。

我尝试在＆＃34; readwrite＆＃34;中读取事件A.模式，但没有工作 - 这是出乎意料的，因为我认为在readwrite中打开意味着它不会尝试并运行事务直到事件A完成。

我正在考虑实施的一个解决方案是跟踪每个交易，并且只在所有交易完成时才启动搜索 - 但似乎我想象的很多努力相当普遍？

addEntry(store: string, entry: any): Promise<boolean> {
    return new Promise<boolean>((resolve, reject) => {
        this.dbPromise.then(db => {
            let transaction = db.transaction(store, "readwrite");

            transaction.oncomplete = (evt: any) => {
                resolve(true);
            }

            transaction.onerror = (err: any) => {
                this.logger.error({
                    originalError: err,
                    message: 'transaction error',
                    data: {
                        store,
                        entry
                    }
                });
                reject(err);
            }

            transaction.onabort = (evt: any) => {
                this.logger.error({
                    originalError: evt,
                    message: 'transaction aborted',
                    data: {
                        store,
                        entry
                    }
                })
                reject(evt);
            }

            let objectStore = transaction.objectStore(store);

            let request = objectStore.add(entry);

            request.onerror = (err) => {
                console.dir(err);
            }
        })
        .catch(err=>{
            this.logger.error({
                originalError: err,
                message: 'journalDBService.addEntry error',
                data: {
                    store,
                    entry
                }
            });
        })
    })
}

getEntry(store: string, key:any): Promise<any> {
    return new Promise<any>((resolve,reject)=>{
        this.dbPromise.then(db=>{
            let transaction = db.transaction(store, "readonly");
            let objectStore = transaction.objectStore(store);
            let request = objectStore.get(key)

            request.onsuccess = (evt) => {
                resolve((<IDBRequest>evt.target).result);
            }

            request.onerror = (err) => {
                this.logger.error({
                    originalError: err,
                    message: 'journalDBService.getEntry request error',
                    data: {
                        store,
                        key
                    }
                });
            }
        })
        .catch(err=>{
            let report = {
                originalError: err,
                message: 'journalDBService.addEntry error',
                data: {
                    store,
                    key
                }
            };
        })
    })
}

编辑：下面的实际违规代码

this.journalDB.getEntry(journal.JournalEvents.missionAccepted, (<journal.MissionAccepted>data).MissionID).then(result => {
if (!result) {
    this.journalDB.addEntry(journal.JournalEvents.missionAccepted, data)
        .catch(err => {
            let report = {
                originalError: err,
                message: 'journalService.handleEvent error',
                data
            }
            this.logger.error(report);
        })
}

}）

Answer 1

索引数据库要求在具有重叠范围的“读写”事务之后调度的“只读”事务在“readwrite”事务完成之前不会运行，因此会看到写入的结果。所以是的，你的期望是正确的。

所以......可能性是：

你正在处理一个错误的实现（哪个浏览器？你可以重现这个独立的吗？）
交易不按您期望的顺序开始;你能记录db.transaction电话并验证订单吗？（即，dbPromise.then处理程序可能没有按照您期望的顺序运行）
还有一些其他逻辑错误，例如：密钥不正确，因此看不到值

你能缩小它们中的哪一个吗？

IndexedDB在写入完成之前读取完成

1 个答案: