0

Ich implementiere IndexedDB in AngularJS 2 mit TypeScript und Observables. Ich fand, dass das Öffnen der--Datenbank und das Abrufen von 500 Datensätzen weniger als eine Sekunde dauerte. Bei dieser noch offenen Datenbankverbindung dauerte das erneute Abrufen der gleichen Daten jedoch etwa 110 Sekunden. Ich habe verschiedene Optionen einschließlich Cursors ausprobiert, um die Daten alle mit den gleichen Ergebnissen abzurufen. Es gibt nur ungefähr 4000 Aufzeichnungen in diesem Geschäft auch.IndexedDB langsam, wenn die gleiche Anfrage wiederholt wird

Ich habe einen Beispielcode unten eingefügt, um zu veranschaulichen, was ich versuche zu tun. Ausführen von OfflineService.test() als Einstiegspunkt.

export class OfflineService { 
    constructor(private indexedDbService: IndexedDbService) { 
    } 

    test(): void { 
     this.indexedDbService.openDb() 
      .subscribe((open: boolean) => { 
       if (!open) { 
        // IndexedDB not supported 
        return; 
       } 
       this.indexedDbService.getObjectsById("items", 1, 500) 
        .subscribe((results: any[]) => { 
         // results returned in < 1 second 

         // retrieve again 
         this.indexedDbService.getObjectsById("items", 1, 500) 
          .subscribe((results: any[]) => { 
           // results returned in around 110 seconds 
          }); 
        }); 
      }); 
    } 
} 

export class IndexedDbService { 
    private db: any; 

    openDb(): Observable<boolean> { 
     return Observable.create((observer: any) => { 
      try { 
       if (this.db) { 
        observer.next(true); 
        observer.complete(); 
        return; 
       } 

       const request = indexedDB.open("testDb", 1); 
       request.onupgradeneeded = (event: any) => { 
        event.currentTarget.result.createObjectStore("items", { keyPath: "Id", autoIncrement: false }); 
       }; 
       request.onsuccess =() => { 
        this.db = request.result; 
        observer.next(true); 
        observer.complete(); 
       }; 
       request.onerror =() => { 
        observer.next(false); 
        observer.complete(); 
       }; 
      } catch (err) { 
       observer.next(false); 
       observer.complete(); 
      } 
     }); 
    } 

    getObjectsById(storeName: string, lowerId: number, upperId: number): Observable<any> { 
     return Observable.create((observer: any) => { 
      try { 
       const results: any[] = []; 
       const store = this.getObjectStore(storeName, false); 
       const request = store.openCursor(IDBKeyRange.bound(lowerId, upperId)); 
       request.onsuccess =() => { 
        var cursor = request.result; 
        if (cursor) { 
         results.push(cursor.value); 
         cursor.continue(); 
        } else { 
         observer.next(results); 
         observer.complete(); 
        } 
       }; 
       request.onerror = (event) => { 
        observer.error(Error(event.target.errorCode)); 
       }; 
      } catch (err) { 
       observer.error(err); 
      } 
     }); 
    } 

    private getObjectStore(storeName: string, writable: boolean): any { 
     const transaction = this.db.transaction(storeName, writable ? "readwrite" : "readonly"); 
     return transaction.objectStore(storeName); 
    } 
} 
+0

Das klingt nicht normal. Sie erhalten jedoch eher Hilfe, wenn Ihr Code ein minimales Beispiel für das Problem ist. Wie, versuche, die Observablen loszuwerden und zu sehen, ob das behebt. Wenn nicht, fügen Sie den Code zum Einrichten Ihrer Datenbank hinzu und führen Sie das Beispiel tatsächlich aus. – dumbmatter

+0

@dumbmatter Ich habe den obigen Code eingefügt, weil ich nicht sicher war, ob Observables oder IndexedDB das Problem verursacht haben. Es stellte sich heraus, es war weder. Siehe meine Antwort unten. Ich stimme Ihnen jedoch zu, dass minimaler Code oder mehr Code, der ausgeführt werden kann, immer der beste ist. –

Antwort

0

ich endlich herausgefunden, dass es mit IndexedDB oder Observables nichts zu tun. Es war nur so, dass nach dem Laden der ersten Ergebnisse der zweite Aufruf der IndexedDB langsamer war, einfach weil mehr Speicher verwendet wurde. Durch das Löschen der ursprünglichen Ergebnisse vor dem zweiten Aufruf wurde das Leistungsproblem behoben.

Verwandte Themen