@@ -40,121 +40,132 @@ function promisifyClose(db) {
4040 */
4141module . exports = {
4242 benchmarks : {
43- 'literal file' : {
44- async beforeEach ( ) {
45- // Setup: Create in-memory database - NOT measured
46- this . db = new sqlite3 . Database ( ':memory:' ) ;
47- this . sqlFile = fs . readFileSync ( __dirname + '/insert-transaction.sql' , 'utf8' ) ;
48- } ,
49-
50- async fn ( ) {
51- // Benchmark: Execute SQL file - MEASURED
52- await promisifyExec ( this . db , this . sqlFile ) ;
53- } ,
54-
55- async afterEach ( ) {
56- // Teardown: Close database - NOT measured
57- await promisifyClose ( this . db ) ;
58- } ,
59- } ,
60-
61- 'transaction with two statements' : {
62- async beforeEach ( ) {
63- // Setup: Create database and table - NOT measured
64- this . db = new sqlite3 . Database ( ':memory:' ) ;
65- await promisifyRun ( this . db , 'CREATE TABLE foo (id INT, txt TEXT)' ) ;
66- } ,
67-
68- async fn ( ) {
69- // Benchmark: Insert with transaction and two parallel statements - MEASURED
70- const db = this . db ;
71-
72- await new Promise ( ( resolve , reject ) => {
73- db . serialize ( async ( ) => {
74- await promisifyRun ( db , 'BEGIN' ) ;
75-
76- db . parallelize ( ( ) => {
77- const stmt1 = db . prepare ( 'INSERT INTO foo VALUES (?, ?)' ) ;
78- const stmt2 = db . prepare ( 'INSERT INTO foo VALUES (?, ?)' ) ;
43+ 'literal file' : ( ( ) => {
44+ let db = null ;
45+ let sqlFile = null ;
46+
47+ return {
48+ async beforeEach ( ) {
49+ // Setup: Create in-memory database - NOT measured
50+ db = new sqlite3 . Database ( ':memory:' ) ;
51+ sqlFile = fs . readFileSync ( __dirname + '/insert-transaction.sql' , 'utf8' ) ;
52+ } ,
53+
54+ async fn ( ) {
55+ // Benchmark: Execute SQL file - MEASURED
56+ await promisifyExec ( db , sqlFile ) ;
57+ } ,
58+
59+ async afterEach ( ) {
60+ // Teardown: Close database - NOT measured
61+ await promisifyClose ( db ) ;
62+ } ,
63+ } ;
64+ } ) ( ) ,
65+
66+ 'transaction with two statements' : ( ( ) => {
67+ let db = null ;
68+
69+ return {
70+ async beforeEach ( ) {
71+ // Setup: Create database and table - NOT measured
72+ db = new sqlite3 . Database ( ':memory:' ) ;
73+ await promisifyRun ( db , 'CREATE TABLE foo (id INT, txt TEXT)' ) ;
74+ } ,
75+
76+ async fn ( ) {
77+ // Benchmark: Insert with transaction and two parallel statements - MEASURED
78+ await new Promise ( ( resolve , reject ) => {
79+ db . serialize ( async ( ) => {
80+ await promisifyRun ( db , 'BEGIN' ) ;
81+
82+ db . parallelize ( ( ) => {
83+ const stmt1 = db . prepare ( 'INSERT INTO foo VALUES (?, ?)' ) ;
84+ const stmt2 = db . prepare ( 'INSERT INTO foo VALUES (?, ?)' ) ;
85+ for ( let i = 0 ; i < iterations ; i ++ ) {
86+ stmt1 . run ( i , 'Row ' + i ) ;
87+ i ++ ;
88+ stmt2 . run ( i , 'Row ' + i ) ;
89+ }
90+ stmt1 . finalize ( ) ;
91+ stmt2 . finalize ( ) ;
92+ } ) ;
93+
94+ await promisifyRun ( db , 'COMMIT' ) ;
95+ resolve ( ) ;
96+ } ) ;
97+ } ) ;
98+ } ,
99+
100+ async afterEach ( ) {
101+ // Teardown: Close database - NOT measured
102+ await promisifyClose ( db ) ;
103+ } ,
104+ } ;
105+ } ) ( ) ,
106+
107+ 'with transaction' : ( ( ) => {
108+ let db = null ;
109+
110+ return {
111+ async beforeEach ( ) {
112+ // Setup: Create database and table - NOT measured
113+ db = new sqlite3 . Database ( ':memory:' ) ;
114+ await promisifyRun ( db , 'CREATE TABLE foo (id INT, txt TEXT)' ) ;
115+ } ,
116+
117+ async fn ( ) {
118+ // Benchmark: Insert with transaction - MEASURED
119+ await new Promise ( ( resolve , reject ) => {
120+ db . serialize ( async ( ) => {
121+ await promisifyRun ( db , 'BEGIN' ) ;
122+ const stmt = db . prepare ( 'INSERT INTO foo VALUES (?, ?)' ) ;
79123 for ( let i = 0 ; i < iterations ; i ++ ) {
80- stmt1 . run ( i , 'Row ' + i ) ;
81- i ++ ;
82- stmt2 . run ( i , 'Row ' + i ) ;
124+ stmt . run ( i , 'Row ' + i ) ;
83125 }
84- stmt1 . finalize ( ) ;
85- stmt2 . finalize ( ) ;
126+ stmt . finalize ( ) ;
127+ await promisifyRun ( db , 'COMMIT' ) ;
128+ resolve ( ) ;
86129 } ) ;
87-
88- await promisifyRun ( db , 'COMMIT' ) ;
89- resolve ( ) ;
90- } ) ;
91- } ) ;
92- } ,
93-
94- async afterEach ( ) {
95- // Teardown: Close database - NOT measured
96- await promisifyClose ( this . db ) ;
97- } ,
98- } ,
99-
100- 'with transaction' : {
101- async beforeEach ( ) {
102- // Setup: Create database and table - NOT measured
103- this . db = new sqlite3 . Database ( ':memory:' ) ;
104- await promisifyRun ( this . db , 'CREATE TABLE foo (id INT, txt TEXT)' ) ;
105- } ,
106-
107- async fn ( ) {
108- // Benchmark: Insert with transaction - MEASURED
109- const db = this . db ;
110-
111- await new Promise ( ( resolve , reject ) => {
112- db . serialize ( async ( ) => {
113- await promisifyRun ( db , 'BEGIN' ) ;
114- const stmt = db . prepare ( 'INSERT INTO foo VALUES (?, ?)' ) ;
115- for ( let i = 0 ; i < iterations ; i ++ ) {
116- stmt . run ( i , 'Row ' + i ) ;
117- }
118- stmt . finalize ( ) ;
119- await promisifyRun ( db , 'COMMIT' ) ;
120- resolve ( ) ;
121130 } ) ;
122- } ) ;
123- } ,
124-
125- async afterEach ( ) {
126- // Teardown: Close database - NOT measured
127- await promisifyClose ( this . db ) ;
128- } ,
129- } ,
130-
131- 'without transaction' : {
132- async beforeEach ( ) {
133- // Setup: Create database and table - NOT measured
134- this . db = new sqlite3 . Database ( ':memory:' ) ;
135- await promisifyRun ( this . db , 'CREATE TABLE foo (id INT, txt TEXT)' ) ;
136- } ,
137-
138- async fn ( ) {
139- // Benchmark: Insert without transaction - MEASURED
140- const db = this . db ;
141-
142- await new Promise ( ( resolve , reject ) => {
143- db . serialize ( ( ) => {
144- const stmt = db . prepare ( 'INSERT INTO foo VALUES (?, ?)' ) ;
145- for ( let i = 0 ; i < iterations ; i ++ ) {
146- stmt . run ( i , 'Row ' + i ) ;
147- }
148- stmt . finalize ( ) ;
149- resolve ( ) ;
131+ } ,
132+
133+ async afterEach ( ) {
134+ // Teardown: Close database - NOT measured
135+ await promisifyClose ( db ) ;
136+ } ,
137+ } ;
138+ } ) ( ) ,
139+
140+ 'without transaction' : ( ( ) => {
141+ let db = null ;
142+
143+ return {
144+ async beforeEach ( ) {
145+ // Setup: Create database and table - NOT measured
146+ db = new sqlite3 . Database ( ':memory:' ) ;
147+ await promisifyRun ( db , 'CREATE TABLE foo (id INT, txt TEXT)' ) ;
148+ } ,
149+
150+ async fn ( ) {
151+ // Benchmark: Insert without transaction - MEASURED
152+ await new Promise ( ( resolve , reject ) => {
153+ db . serialize ( ( ) => {
154+ const stmt = db . prepare ( 'INSERT INTO foo VALUES (?, ?)' ) ;
155+ for ( let i = 0 ; i < iterations ; i ++ ) {
156+ stmt . run ( i , 'Row ' + i ) ;
157+ }
158+ stmt . finalize ( ) ;
159+ resolve ( ) ;
160+ } ) ;
150161 } ) ;
151- } ) ;
152- } ,
153-
154- async afterEach ( ) {
155- // Teardown: Close database - NOT measured
156- await promisifyClose ( this . db ) ;
157- } ,
158- } ,
162+ } ,
163+
164+ async afterEach ( ) {
165+ // Teardown: Close database - NOT measured
166+ await promisifyClose ( db ) ;
167+ } ,
168+ } ;
169+ } ) ( ) ,
159170 } ,
160171} ;
0 commit comments