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