1 /*
2 * Copyright (c) 2021 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
16 #include <gtest/gtest.h>
17
18 #include <string>
19
20 #include "common.h"
21 #include "rdb_errno.h"
22 #include "rdb_helper.h"
23 #include "rdb_open_callback.h"
24
25 using namespace testing::ext;
26 using namespace OHOS::NativeRdb;
27
28 class RdbExecuteTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31 static void TearDownTestCase(void);
32 void SetUp();
33 void TearDown();
34
35 static const std::string DATABASE_NAME;
36 static std::shared_ptr<RdbStore> store;
37 };
38
39 const std::string RdbExecuteTest::DATABASE_NAME = RDB_TEST_PATH + "execute_test.db";
40 std::shared_ptr<RdbStore> RdbExecuteTest::store = nullptr;
41
42 class ExecuteTestOpenCallback : public RdbOpenCallback {
43 public:
44 int OnCreate(RdbStore &store) override;
45 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
46 static const std::string CREATE_TABLE_TEST;
47 };
48
49 const std::string ExecuteTestOpenCallback::CREATE_TABLE_TEST = std::string("CREATE TABLE IF NOT EXISTS test ")
50 + std::string("(id INTEGER PRIMARY KEY AUTOINCREMENT, "
51 "name TEXT NOT NULL, age INTEGER, salary "
52 "REAL, blobType BLOB)");
53
OnCreate(RdbStore & store)54 int ExecuteTestOpenCallback::OnCreate(RdbStore &store)
55 {
56 return store.ExecuteSql(CREATE_TABLE_TEST);
57 }
58
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)59 int ExecuteTestOpenCallback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
60 {
61 return E_OK;
62 }
63
SetUpTestCase(void)64 void RdbExecuteTest::SetUpTestCase(void)
65 {
66 int errCode = E_OK;
67 RdbHelper::DeleteRdbStore(RdbExecuteTest::DATABASE_NAME);
68 RdbStoreConfig config(RdbExecuteTest::DATABASE_NAME);
69 ExecuteTestOpenCallback helper;
70 RdbExecuteTest::store = RdbHelper::GetRdbStore(config, 1, helper, errCode);
71 EXPECT_NE(RdbExecuteTest::store, nullptr);
72 EXPECT_EQ(errCode, E_OK);
73 }
74
TearDownTestCase(void)75 void RdbExecuteTest::TearDownTestCase(void)
76 {
77 store = nullptr;
78 RdbHelper::DeleteRdbStore(RdbExecuteTest::DATABASE_NAME);
79 }
80
SetUp(void)81 void RdbExecuteTest::SetUp(void)
82 {
83 store->ExecuteSql("DELETE FROM test");
84 }
85
TearDown(void)86 void RdbExecuteTest::TearDown(void)
87 {
88 }
89
90 /**
91 * @tc.name: RdbStore_Execute_001
92 * @tc.desc: test RdbStore Execute
93 * @tc.type: FUNC
94 */
95 HWTEST_F(RdbExecuteTest, RdbStore_Execute_001, TestSize.Level1)
96 {
97 std::shared_ptr<RdbStore> &store = RdbExecuteTest::store;
98
99 int64_t id;
100 ValuesBucket values;
101
102 values.PutInt("id", 1);
103 values.PutString("name", std::string("zhangsan"));
104 values.PutInt("age", 18);
105 values.PutDouble("salary", 100.5);
106 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
107 int ret = store->Insert(id, "test", values);
108 EXPECT_EQ(ret, E_OK);
109 EXPECT_EQ(1, id);
110
111 values.Clear();
112 values.PutInt("id", 2);
113 values.PutString("name", std::string("lisi"));
114 values.PutInt("age", 19);
115 values.PutDouble("salary", 200.5);
116 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
117 ret = store->Insert(id, "test", values);
118 EXPECT_EQ(ret, E_OK);
119 EXPECT_EQ(2, id);
120
121 values.Clear();
122 values.PutInt("id", 3);
123 values.PutString("name", std::string("wangyjing"));
124 values.PutInt("age", 20);
125 values.PutDouble("salary", 300.5);
126 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
127 ret = store->Insert(id, "test", values);
128 EXPECT_EQ(ret, E_OK);
129 EXPECT_EQ(3, id);
130
131 int64_t count;
132 ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test");
133 EXPECT_EQ(ret, E_OK);
134 EXPECT_EQ(count, 3);
135
136 ret = store->ExecuteSql("DELETE FROM test WHERE age = ? OR age = ?",
137 std::vector<ValueObject>{ ValueObject(std::string("18")), ValueObject(std ::string("20")) });
138 EXPECT_EQ(ret, E_OK);
139
140 ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test where age = 19");
141 EXPECT_EQ(ret, E_OK);
142 EXPECT_EQ(count, 1);
143
144 ret = store->ExecuteSql("DELETE FROM test WHERE age = 19");
145 EXPECT_EQ(ret, E_OK);
146
147 ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test");
148 EXPECT_EQ(ret, E_OK);
149 EXPECT_EQ(count, 0);
150 }
151
152 /**
153 * @tc.name: RdbStore_Execute_002
154 * @tc.desc: test RdbStore Execute
155 * @tc.type: FUNC
156 */
157 HWTEST_F(RdbExecuteTest, RdbStore_Execute_002, TestSize.Level1)
158 {
159 std::shared_ptr<RdbStore> &store = RdbExecuteTest::store;
160
161 int64_t id;
162 ValuesBucket values;
163
164 values.PutInt("id", 1);
165 values.PutString("name", std::string("zhangsan"));
166 values.PutInt("age", 18);
167 values.PutDouble("salary", 100.5);
168 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
169 int ret = store->Insert(id, "test", values);
170 EXPECT_EQ(ret, E_OK);
171 EXPECT_EQ(1, id);
172
173 values.Clear();
174 values.PutInt("id", 2);
175 values.PutString("name", std::string("lisi"));
176 values.PutInt("age", 19);
177 values.PutDouble("salary", 200.5);
178 values.PutBlob("blobType", std::vector<uint8_t>{ 4, 5, 6 });
179 ret = store->Insert(id, "test", values);
180 EXPECT_EQ(ret, E_OK);
181 EXPECT_EQ(2, id);
182
183 values.Clear();
184 values.PutInt("id", 3);
185 values.PutString("name", std::string("wangyjing"));
186 values.PutInt("age", 20);
187 values.PutDouble("salary", 300.5);
188 values.PutBlob("blobType", std::vector<uint8_t>{ 7, 8, 9 });
189 ret = store->Insert(id, "test", values);
190 EXPECT_EQ(ret, E_OK);
191 EXPECT_EQ(3, id);
192
193 int64_t count;
194 ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test", std::vector<ValueObject>());
195 EXPECT_EQ(ret, E_OK);
196 EXPECT_EQ(count, 3);
197
198 ret = store->ExecuteSql("DELETE FROM test WHERE age = ? OR age = ?",
199 std::vector<ValueObject>{ ValueObject(std::string("18")), ValueObject(std ::string("20")) });
200 EXPECT_EQ(ret, E_OK);
201
202 ret = store->ExecuteAndGetLong(
203 count, "SELECT COUNT(*) FROM test where age = ?", std::vector<ValueObject>{ ValueObject(std::string("19")) });
204 EXPECT_EQ(ret, E_OK);
205 EXPECT_EQ(count, 1);
206
207 ret = store->ExecuteSql("DELETE FROM test WHERE age = 19");
208 EXPECT_EQ(ret, E_OK);
209
210 ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test", std::vector<ValueObject>());
211 EXPECT_EQ(ret, E_OK);
212 EXPECT_EQ(count, 0);
213
214 ret = store->ExecuteSql("DROP TABLE IF EXISTS test");
215 EXPECT_EQ(ret, E_OK);
216
217 ret = store->ExecuteAndGetLong(count, "SELECT COUNT(*) FROM test");
218 EXPECT_EQ(ret, -1);
219 }
220
221 /**
222 * @tc.name: RdbStore_Execute_003
223 * @tc.desc: test RdbStore Execute
224 * @tc.type: FUNC
225 */
226 HWTEST_F(RdbExecuteTest, RdbStore_Execute_003, TestSize.Level1)
227 {
228 std::shared_ptr<RdbStore> &store = RdbExecuteTest::store;
229
230 int64_t pageSize;
231 int ret = store->ExecuteAndGetLong(pageSize, "PRAGMA page_size");
232 EXPECT_EQ(ret, E_OK);
233 EXPECT_EQ(pageSize, 4096);
234
235 int64_t journalSize;
236 ret = store->ExecuteAndGetLong(journalSize, "PRAGMA journal_size_limit");
237 EXPECT_EQ(ret, E_OK);
238 EXPECT_EQ(journalSize, 1048576);
239
240 std::string journalMode;
241 ret = store->ExecuteAndGetString(journalMode, "PRAGMA journal_mode");
242 EXPECT_EQ(ret, E_OK);
243 EXPECT_EQ(journalMode, "wal");
244 }
245