1/*
2 * Copyright (C) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16import {describe, beforeAll, beforeEach, afterEach, afterAll, it, expect, Assert} from 'deccjsunit/index';
17import dataRdb from '@ohos.data.rdb';
18import featureAbility from '@ohos.ability.featureAbility';
19import deviceInfo from '@ohos.deviceInfo';
20
21const TAG = "[RDB_RESULTSET_PERF]";
22const CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY AUTOINCREMENT, "
23  + "name TEXT, age INTEGER, salary REAL, blobType BLOB)";
24
25const DB_NAME = "resultSetPerf.db";
26const STORE_CONFIG = {
27  name: DB_NAME,
28}
29let context = featureAbility.getContext();
30var rdbStore = undefined;
31const BASE_COUNT = 2000; // loop times
32const SPECIAL_BASE_COUNT = 12000;
33const BASE_LINE_TABLE = 500; // callback tablet base line
34const BASE_LINE_PHONE = 1000; // callback phone base line
35const BASE_LINE = (deviceInfo.deviceType == "tablet" || deviceInfo.deviceType == "2in1") ? BASE_LINE_TABLE : BASE_LINE_PHONE;
36
37describe('resultSetPerf', function () {
38  beforeAll(async function () {
39    console.info(TAG + 'beforeAll');
40    rdbStore = await dataRdb.getRdbStore(context, STORE_CONFIG, 1);
41  })
42  beforeEach(async function () {
43    console.info(TAG + 'beforeEach');
44    await rdbStore.executeSql(CREATE_TABLE_TEST, null);
45    await prepareTestData();
46  })
47  afterEach(async function () {
48    console.info(TAG + 'afterEach');
49    await rdbStore.executeSql("drop table test");
50  })
51  afterAll(async function () {
52    console.info(TAG + 'afterAll');
53    rdbStore = null;
54    await dataRdb.deleteRdbStore(context, DB_NAME);
55  })
56
57  async function prepareTestData() {
58    console.info(TAG + "prepare for query performance test");
59    var valueBuckets = [];
60    var u8 = new Uint8Array([1, 2, 3])
61    var valueBucket = {
62      "name": "zhangsan",
63      "age": 18,
64      "salary": 100.5,
65      "blobType": u8,
66    }
67    for (let i = 0; i < BASE_COUNT; i++) {
68      valueBucket.age += i;
69      valueBuckets.push(valueBucket);
70    }
71    await rdbStore.batchInsert("test", valueBuckets)
72  }
73
74  console.log(TAG + "*************Unit Test Begin*************");
75
76  it('SUB_DDM_PERF_RDB_ResultSet_GetColumnIndex_001', 0, async function (done) {
77    let predicates = new dataRdb.RdbPredicates("test");
78    let resultSet = await rdbStore.query(predicates);
79    resultSet.goToFirstRow();
80    let startTime = new Date().getTime();
81    for (let i = 0; i < BASE_LINE; i++) {
82      resultSet.getColumnIndex("id");
83    }
84    let endTime = new Date().getTime();
85    let averageTime = ((endTime - startTime) * 1000) / BASE_COUNT;
86    console.info(TAG + " the ResultSet_GetColumnIndex average time is: " + averageTime + " μs");
87    resultSet.close();
88    expect(averageTime < BASE_LINE).assertTrue();
89    done();
90  })
91
92  it('SUB_DDM_PERF_RDB_ResultSet_GetColumnName_001', 0, async function (done) {
93    let predicates = new dataRdb.RdbPredicates("test");
94    let resultSet = await rdbStore.query(predicates);
95    resultSet.goToFirstRow();
96    let startTime = new Date().getTime()
97    for (let i = 0; i < BASE_COUNT; i++) {
98      resultSet.getColumnName(0);
99    }
100    let endTime = new Date().getTime();
101    let averageTime = ((endTime - startTime) * 1000) / BASE_COUNT;
102    console.info(TAG + " the ResultSet_GetColumnName average time is: " + averageTime + " μs")
103    resultSet.close();
104    expect(averageTime < BASE_LINE).assertTrue();
105    done();
106  })
107
108  it('SUB_DDM_PERF_RDB_ResultSet_GoTo_001', 0, async function (done) {
109    let predicates = new dataRdb.RdbPredicates("test");
110    let resultSet = await rdbStore.query(predicates);
111    resultSet.goToFirstRow();
112    let startTime = new Date().getTime()
113    for (let i = 0; i < BASE_COUNT; i++) {
114      resultSet.goTo(i % 2);
115    }
116    let endTime = new Date().getTime();
117    let averageTime = ((endTime - startTime) * 1000) / BASE_COUNT;
118    console.info(TAG + " the ResultSet_GoTo average time is: " + averageTime + " μs")
119    resultSet.close();
120    expect(averageTime < BASE_LINE).assertTrue();
121    done();
122  })
123
124  it('SUB_DDM_PERF_RDB_ResultSet_GoToRow_001', 0, async function (done) {
125    let predicates = new dataRdb.RdbPredicates("test");
126    let resultSet = await rdbStore.query(predicates);
127    resultSet.goToFirstRow();
128    let startTime = new Date().getTime();
129    for (let i = 0; i < BASE_COUNT; i++) {
130      resultSet.goToRow(1);
131    }
132    let endTime = new Date().getTime();
133    let averageTime = ((endTime - startTime) * 1000) / BASE_COUNT;
134    console.info(TAG + " the ResultSet_GoToRow average time is: " + averageTime + " μs");
135    resultSet.close();
136    expect(averageTime < BASE_LINE).assertTrue();
137    done();
138  })
139
140  it('SUB_DDM_PERF_RDB_ResultSet_GoToFirstRow_001', 0, async function (done) {
141    let predicates = new dataRdb.RdbPredicates("test");
142    let resultSet = await rdbStore.query(predicates);
143    let startTime = new Date().getTime();
144    for (let i = 0; i < BASE_COUNT; i++) {
145      resultSet.goToFirstRow();
146    }
147    let endTime = new Date().getTime();
148    let averageTime = ((endTime - startTime) * 1000) / BASE_COUNT;
149    console.info(TAG + " the ResultSet_GoToFirstRow average time is: " + averageTime + " μs");
150    resultSet.close();
151    expect(averageTime < BASE_LINE).assertTrue();
152    done();
153  })
154
155  it('SUB_DDM_PERF_RDB_ResultSet_GoToLastRow_001', 0, async function (done) {
156    let predicates = new dataRdb.RdbPredicates("test");
157    let resultSet = await rdbStore.query(predicates);
158    let startTime = new Date().getTime();
159    for (let i = 0; i < BASE_COUNT; i++) {
160      resultSet.goToLastRow();
161    }
162    let endTime = new Date().getTime();
163    let averageTime = ((endTime - startTime) * 1000) / BASE_COUNT;
164    console.info(TAG + " the ResultSet_GoToLastRow average time is: " + averageTime + " μs");
165    resultSet.close();
166    expect(averageTime < BASE_LINE).assertTrue();
167    done();
168  })
169
170  it('SUB_DDM_PERF_RDB_ResultSet_GoToNextRow_001', 0, async function (done) {
171    let predicates = new dataRdb.RdbPredicates("test");
172    let resultSet = await rdbStore.query(predicates);
173    resultSet.goToFirstRow();
174    let startTime = new Date().getTime();
175    for (let i = 0; i < BASE_COUNT; i++) {
176      resultSet.goToNextRow();
177    }
178    let endTime = new Date().getTime();
179    let averageTime = ((endTime - startTime) * 1000) / BASE_COUNT;
180    console.info(TAG + " the ResultSet_GoToNextRow average time is: " + averageTime + " μs")
181    resultSet.close();
182    expect(averageTime < BASE_LINE).assertTrue();
183    done();
184  })
185
186  it('SUB_DDM_PERF_RDB_ResultSet_GoToPreviousRow_001', 0, async function (done) {
187    let predicates = new dataRdb.RdbPredicates("test");
188    let resultSet = await rdbStore.query(predicates);
189    resultSet.goToLastRow();
190    let startTime = new Date().getTime();
191    for (let i = 0; i < BASE_COUNT; i++) {
192      resultSet.goToPreviousRow();
193    }
194    let endTime = new Date().getTime();
195    let averageTime = ((endTime - startTime) * 1000) / BASE_COUNT;
196    console.info(TAG + " the ResultSet_GoToPreviousRow average time is: " + averageTime + " μs");
197    resultSet.close();
198    expect(averageTime < BASE_LINE).assertTrue();
199    done();
200  })
201
202  it('SUB_DDM_PERF_RDB_ResultSet_GetBlob_001', 0, async function (done) {
203    let predicates = new dataRdb.RdbPredicates("test");
204    let resultSet = await rdbStore.query(predicates);
205    let columnIndex = resultSet.getColumnIndex("blobType");
206    resultSet.goToFirstRow();
207    let startTime = new Date().getTime()
208    for (let i = 0; i < BASE_COUNT; i++) {
209      resultSet.getBlob(columnIndex);
210    }
211    let endTime = new Date().getTime();
212    let averageTime = ((endTime - startTime) * 1000) / BASE_COUNT;
213    console.info(TAG + " the ResultSet_GetBlob average time is: " + averageTime + " μs");
214    resultSet.close();
215    expect(averageTime < BASE_LINE).assertTrue();
216    done();
217  })
218
219  it('SUB_DDM_PERF_RDB_ResultSet_GetString_001', 0, async function (done) {
220    let predicates = new dataRdb.RdbPredicates("test");
221    let resultSet = await rdbStore.query(predicates);
222    let columnIndex = resultSet.getColumnIndex("name");
223    let flag = resultSet.goToFirstRow();
224    let startTime = new Date().getTime();
225    for (var i = 0; i < SPECIAL_BASE_COUNT; i++) {
226      resultSet.getString(columnIndex);
227    }
228    let endTime = new Date().getTime();
229    let averageTime = ((endTime - startTime) * 1000) / SPECIAL_BASE_COUNT;
230    console.info(TAG + " the ResultSet_GetString average time is: " + averageTime + " μs");
231    resultSet.close();
232    expect(averageTime < BASE_LINE).assertTrue();
233    done()
234  })
235
236  it('SUB_DDM_PERF_RDB_ResultSet_GetLong_001', 0, async function (done) {
237    let predicates = new dataRdb.RdbPredicates("test");
238    let resultSet = await rdbStore.query(predicates);
239    let columnIndex = resultSet.getColumnIndex("age");
240    resultSet.goToFirstRow();
241    let startTime = new Date().getTime();
242    for (let i = 0; i < BASE_COUNT; i++) {
243      resultSet.getLong(columnIndex);
244    }
245    let endTime = new Date().getTime();
246    let averageTime = ((endTime - startTime) * 1000) / BASE_COUNT;
247    console.info(TAG + " the ResultSet_GetLong average time is: " + averageTime + " μs")
248    resultSet.close();
249    expect(averageTime < BASE_LINE).assertTrue();
250    done();
251  })
252
253  it('SUB_DDM_PERF_RDB_ResultSet_GetDouble_001', 0, async function (done) {
254    let predicates = new dataRdb.RdbPredicates("test");
255    let resultSet = await rdbStore.query(predicates);
256    let columnIndex = resultSet.getColumnIndex("salary");
257    resultSet.goToFirstRow();
258    let startTime = new Date().getTime()
259    for (let i = 0; i < BASE_COUNT; i++) {
260      resultSet.getDouble(columnIndex);
261    }
262    let endTime = new Date().getTime();
263    let averageTime = ((endTime - startTime) * 1000) / BASE_COUNT;
264    console.info(TAG + " the ResultSet_GetDouble average time is: " + averageTime + " μs")
265    resultSet.close();
266    expect(averageTime < BASE_LINE).assertTrue();
267    done();
268  })
269
270  it('SUB_DDM_PERF_RDB_ResultSet_IsColumnNull_001', 0, async function (done) {
271    let predicates = new dataRdb.RdbPredicates("test");
272    let resultSet = await rdbStore.query(predicates);
273    let columnIndex = resultSet.getColumnIndex("salary");
274    resultSet.goToFirstRow();
275    let startTime = new Date().getTime()
276    for (let i = 0; i < BASE_COUNT; i++) {
277      resultSet.isColumnNull(columnIndex);
278    }
279    let endTime = new Date().getTime();
280    let averageTime = ((endTime - startTime) * 1000) / BASE_COUNT;
281    console.info(TAG + " the ResultSet_IsColumnNull average time is: " + averageTime + " μs");
282    resultSet.close();
283    expect(averageTime < BASE_LINE).assertTrue();
284    done();
285  })
286
287  console.info(TAG + "*************Unit Test End*************");
288})