oceanbase

test_table_aggregation.cpp
542 строки · 15.7 Кб
Перенос по словам
1
/**
2
 * Copyright (c) 2023 OceanBase
3
 * OceanBase CE is licensed under Mulan PubL v2.
4
 * You can use this software according to the terms and conditions of the Mulan PubL v2.
5
 * You may obtain a copy of Mulan PubL v2 at:
6
 *          http://license.coscl.org.cn/MulanPubL-2.0
7
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
8
 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
9
 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
10
 * See the Mulan PubL v2 for more details.
11
 */
12

13
#include <gtest/gtest.h>
14
#define private public  // 获取private成员
15
#define protected public  // 获取protect成员
16
#include "common/row/ob_row.h"
17
#include "observer/table/ob_table_aggregation.h"
18

19
using namespace oceanbase::common;
20
using namespace oceanbase::table;
21
using namespace oceanbase::sql;
22
using namespace oceanbase::share;
23
using namespace oceanbase::share::schema;
24
using namespace oceanbase::observer;
25

26
class TestTableAggregation: public ::testing::Test
27
{
28
public:
29
  TestTableAggregation() {}
30
  virtual void SetUp() {}
31
  virtual void TearDown() {}
32
private:
33
  // disallow copy
34
  DISALLOW_COPY_AND_ASSIGN(TestTableAggregation);
35
};
36

37
TEST_F(TestTableAggregation, agg_min_int)
38
{
39
  ObTableAggregation min;
40
  min.type_ = ObTableAggregationType::MIN;
41
  min.column_ = ObString("c1");
42

43
  ObTableQuery query;
44
  ASSERT_EQ(OB_SUCCESS, query.aggregations_.push_back(min));
45
  ASSERT_EQ(OB_SUCCESS, query.select_columns_.push_back("c1"));
46

47
  const uint64_t PROJECT_IDX = 0;
48
  ObSEArray<uint64_t, 4> projs;
49
  ASSERT_EQ(OB_SUCCESS, projs.push_back(PROJECT_IDX));
50

51
  ObTableAggCalculator agg(query);
52
  agg.allocator_.set_tenant_id(OB_SERVER_TENANT_ID);
53
  agg.set_projs(projs);
54
  ASSERT_EQ(OB_SUCCESS, agg.init());
55

56
  oceanbase::common::ObNewRow row;
57
  const int COL_NUM = 3;
58
  ObObj objs[COL_NUM];
59
  row.cells_ = objs;
60
  row.count_ = COL_NUM;
61
  for (int i = 0; i< COL_NUM; ++i) {
62
    row.cells_[i].set_int(1);
63
  }
64

65
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
66
  ASSERT_EQ(1, agg.results_.at(PROJECT_IDX).get_int());
67

68
  for (int i = 0; i< COL_NUM; ++i) {
69
    row.cells_[i].set_int(0);
70
  }
71

72
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
73
  ASSERT_EQ(0, agg.results_.at(PROJECT_IDX).get_int());
74
}
75

76
TEST_F(TestTableAggregation, agg_min_double)
77
{
78
  ObTableAggregation min;
79
  min.type_ = ObTableAggregationType::MIN;
80
  min.column_ = ObString("c1");
81

82
  ObTableQuery query;
83
  ASSERT_EQ(OB_SUCCESS, query.aggregations_.push_back(min));
84
  ASSERT_EQ(OB_SUCCESS, query.select_columns_.push_back("c1"));
85

86
  const uint64_t PROJECT_IDX = 0;
87
  ObSEArray<uint64_t, 4> projs;
88
  ASSERT_EQ(OB_SUCCESS, projs.push_back(PROJECT_IDX));
89

90
  ObTableAggCalculator agg(query);
91
  agg.allocator_.set_tenant_id(OB_SERVER_TENANT_ID);
92
  agg.set_projs(projs);
93
  ASSERT_EQ(OB_SUCCESS, agg.init());
94

95
  oceanbase::common::ObNewRow row;
96
  const int COL_NUM = 3;
97
  ObObj objs[COL_NUM];
98
  row.cells_ = objs;
99
  row.count_ = COL_NUM;
100
  for (int i = 0; i< COL_NUM; ++i) {
101
    row.cells_[i].set_double(1.11);
102
  }
103

104
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
105
  ASSERT_EQ(1.11, agg.results_.at(PROJECT_IDX).get_double());
106

107
  for (int i = 0; i< COL_NUM; ++i) {
108
    row.cells_[i].set_double(1.10009);
109
  }
110

111
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
112
  ASSERT_EQ(1.10009, agg.results_.at(PROJECT_IDX).get_double());
113
}
114

115
TEST_F(TestTableAggregation, agg_min_varchar)
116
{
117
  ObTableAggregation min;
118
  min.type_ = ObTableAggregationType::MIN;
119
  min.column_ = ObString("c1");
120

121
  ObTableQuery query;
122
  ASSERT_EQ(OB_SUCCESS, query.aggregations_.push_back(min));
123
  ASSERT_EQ(OB_SUCCESS, query.select_columns_.push_back("c1"));
124

125
  const uint64_t PROJECT_IDX = 0;
126
  ObSEArray<uint64_t, 4> projs;
127
  ASSERT_EQ(OB_SUCCESS, projs.push_back(PROJECT_IDX));
128

129
  ObTableAggCalculator agg(query);
130
  agg.allocator_.set_tenant_id(OB_SERVER_TENANT_ID);
131
  agg.set_projs(projs);
132
  ASSERT_EQ(OB_SUCCESS, agg.init());
133

134
  oceanbase::common::ObNewRow row;
135
  const int COL_NUM = 3;
136
  ObObj objs[COL_NUM];
137
  row.cells_ = objs;
138
  row.count_ = COL_NUM;
139
  char val1[] = "abcde";
140
  for (int i = 0; i< COL_NUM; ++i) {
141
    row.cells_[i].set_collation_type(CS_TYPE_UTF8MB4_GENERAL_CI);
142
    row.cells_[i].set_varchar(val1);
143
  }
144

145
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
146
  ASSERT_EQ(0, memcmp(val1, agg.results_.at(PROJECT_IDX).get_varchar().ptr(), strlen(val1)));
147

148
  char val2[] = "abcd";
149
  for (int i = 0; i< COL_NUM; ++i) {
150
    row.cells_[i].set_collation_type(CS_TYPE_UTF8MB4_GENERAL_CI);
151
    row.cells_[i].set_varchar(val2);
152
  }
153

154
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
155
  ASSERT_EQ(0, memcmp(val2, agg.results_.at(PROJECT_IDX).get_varchar().ptr(), strlen(val2)));
156

157
  char val3[] = "abcdefg";
158
  for (int i = 0; i< COL_NUM; ++i) {
159
    row.cells_[i].set_collation_type(CS_TYPE_UTF8MB4_GENERAL_CI);
160
    row.cells_[i].set_varchar(val3);
161
  }
162

163
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
164
  ASSERT_EQ(0, memcmp(val2, agg.results_.at(PROJECT_IDX).get_varchar().ptr(), strlen(val2)));
165
}
166

167
TEST_F(TestTableAggregation, agg_max_int)
168
{
169
  ObTableAggregation min;
170
  min.type_ = ObTableAggregationType::MAX;
171
  min.column_ = ObString("c1");
172

173
  ObTableQuery query;
174
  ASSERT_EQ(OB_SUCCESS, query.aggregations_.push_back(min));
175
  ASSERT_EQ(OB_SUCCESS, query.select_columns_.push_back("c1"));
176

177
  const uint64_t PROJECT_IDX = 0;
178
  ObSEArray<uint64_t, 4> projs;
179
  ASSERT_EQ(OB_SUCCESS, projs.push_back(PROJECT_IDX));
180

181
  ObTableAggCalculator agg(query);
182
  agg.allocator_.set_tenant_id(OB_SERVER_TENANT_ID);
183
  agg.set_projs(projs);
184
  ASSERT_EQ(OB_SUCCESS, agg.init());
185

186
  oceanbase::common::ObNewRow row;
187
  const int COL_NUM = 3;
188
  ObObj objs[COL_NUM];
189
  row.cells_ = objs;
190
  row.count_ = COL_NUM;
191
  for (int i = 0; i< COL_NUM; ++i) {
192
    row.cells_[i].set_int(0);
193
  }
194

195
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
196
  ASSERT_EQ(0, agg.results_.at(PROJECT_IDX).get_int());
197

198
  for (int i = 0; i< COL_NUM; ++i) {
199
    row.cells_[i].set_int(1);
200
  }
201

202
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
203
  ASSERT_EQ(1, agg.results_.at(PROJECT_IDX).get_int());
204
}
205

206
TEST_F(TestTableAggregation, agg_max_double)
207
{
208
  ObTableAggregation min;
209
  min.type_ = ObTableAggregationType::MAX;
210
  min.column_ = ObString("c1");
211

212
  ObTableQuery query;
213
  ASSERT_EQ(OB_SUCCESS, query.aggregations_.push_back(min));
214
  ASSERT_EQ(OB_SUCCESS, query.select_columns_.push_back("c1"));
215

216
  const uint64_t PROJECT_IDX = 0;
217
  ObSEArray<uint64_t, 4> projs;
218
  ASSERT_EQ(OB_SUCCESS, projs.push_back(PROJECT_IDX));
219

220
  ObTableAggCalculator agg(query);
221
  agg.allocator_.set_tenant_id(OB_SERVER_TENANT_ID);
222
  agg.set_projs(projs);
223
  ASSERT_EQ(OB_SUCCESS, agg.init());
224

225
  oceanbase::common::ObNewRow row;
226
  const int COL_NUM = 3;
227
  ObObj objs[COL_NUM];
228
  row.cells_ = objs;
229
  row.count_ = COL_NUM;
230
  for (int i = 0; i< COL_NUM; ++i) {
231
    row.cells_[i].set_double(0.001);
232
  }
233

234
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
235
  ASSERT_EQ(0.001, agg.results_.at(PROJECT_IDX).get_double());
236

237
  for (int i = 0; i< COL_NUM; ++i) {
238
    row.cells_[i].set_double(0.01);
239
  }
240

241
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
242
  ASSERT_EQ(0.01, agg.results_.at(PROJECT_IDX).get_double());
243
}
244

245
TEST_F(TestTableAggregation, agg_max_varchar)
246
{
247
  ObTableAggregation min;
248
  min.type_ = ObTableAggregationType::MAX;
249
  min.column_ = ObString("c1");
250

251
  ObTableQuery query;
252
  ASSERT_EQ(OB_SUCCESS, query.aggregations_.push_back(min));
253
  ASSERT_EQ(OB_SUCCESS, query.select_columns_.push_back("c1"));
254

255
  const uint64_t PROJECT_IDX = 0;
256
  ObSEArray<uint64_t, 4> projs;
257
  ASSERT_EQ(OB_SUCCESS, projs.push_back(PROJECT_IDX));
258

259
  ObTableAggCalculator agg(query);
260
  agg.allocator_.set_tenant_id(OB_SERVER_TENANT_ID);
261
  agg.set_projs(projs);
262
  ASSERT_EQ(OB_SUCCESS, agg.init());
263

264
  oceanbase::common::ObNewRow row;
265
  const int COL_NUM = 3;
266
  ObObj objs[COL_NUM];
267
  row.cells_ = objs;
268
  row.count_ = COL_NUM;
269
  char val1[] = "abcde";
270
  for (int i = 0; i< COL_NUM; ++i) {
271
    row.cells_[i].set_collation_type(CS_TYPE_UTF8MB4_GENERAL_CI);
272
    row.cells_[i].set_varchar(val1);
273
  }
274

275
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
276
  ASSERT_EQ(0, memcmp(val1, agg.results_.at(PROJECT_IDX).get_varchar().ptr(), strlen(val1)));
277

278
  char val2[] = "abcd";
279
  for (int i = 0; i< COL_NUM; ++i) {
280
    row.cells_[i].set_collation_type(CS_TYPE_UTF8MB4_GENERAL_CI);
281
    row.cells_[i].set_varchar(val2);
282
  }
283

284
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
285
  ASSERT_EQ(0, memcmp(val1, agg.results_.at(PROJECT_IDX).get_varchar().ptr(), strlen(val1)));
286

287
  char val3[] = "abcdefg";
288
  for (int i = 0; i< COL_NUM; ++i) {
289
    row.cells_[i].set_collation_type(CS_TYPE_UTF8MB4_GENERAL_CI);
290
    row.cells_[i].set_varchar(val3);
291
  }
292

293
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
294
  ASSERT_EQ(0, memcmp(val3, agg.results_.at(PROJECT_IDX).get_varchar().ptr(), strlen(val3)));
295
}
296

297
TEST_F(TestTableAggregation, agg_count_column)
298
{
299
  ObTableAggregation min;
300
  min.type_ = ObTableAggregationType::COUNT;
301
  min.column_ = ObString("c1");
302

303
  ObTableQuery query;
304
  ASSERT_EQ(OB_SUCCESS, query.aggregations_.push_back(min));
305
  ASSERT_EQ(OB_SUCCESS, query.select_columns_.push_back("c1"));
306

307
  const uint64_t PROJECT_IDX = 0;
308
  ObSEArray<uint64_t, 4> projs;
309
  ASSERT_EQ(OB_SUCCESS, projs.push_back(PROJECT_IDX));
310

311
  ObTableAggCalculator agg(query);
312
  agg.allocator_.set_tenant_id(OB_SERVER_TENANT_ID);
313
  agg.set_projs(projs);
314
  ASSERT_EQ(OB_SUCCESS, agg.init());
315

316
  oceanbase::common::ObNewRow row;
317
  const int COL_NUM = 3;
318
  ObObj objs[COL_NUM];
319
  row.cells_ = objs;
320
  row.count_ = COL_NUM;
321
  for (int i = 0; i< COL_NUM; ++i) {
322
    row.cells_[i].set_int(0);
323
  }
324

325
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
326
  ASSERT_EQ(1, agg.results_.at(PROJECT_IDX).get_int());
327
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
328
  ASSERT_EQ(2, agg.results_.at(PROJECT_IDX).get_int());
329
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
330
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
331
  ASSERT_EQ(4, agg.results_.at(PROJECT_IDX).get_int());
332
}
333

334
TEST_F(TestTableAggregation, agg_count_all)
335
{
336
  ObTableAggregation min;
337
  min.type_ = ObTableAggregationType::COUNT;
338
  min.column_ = ObString("*");
339

340
  ObTableQuery query;
341
  ASSERT_EQ(OB_SUCCESS, query.aggregations_.push_back(min));
342
  ASSERT_EQ(OB_SUCCESS, query.select_columns_.push_back("c1"));
343

344
  const uint64_t PROJECT_IDX = 0;
345
  ObSEArray<uint64_t, 4> projs;
346
  ASSERT_EQ(OB_SUCCESS, projs.push_back(PROJECT_IDX));
347

348
  ObTableAggCalculator agg(query);
349
  agg.allocator_.set_tenant_id(OB_SERVER_TENANT_ID);
350
  agg.set_projs(projs);
351
  ASSERT_EQ(OB_SUCCESS, agg.init());
352

353
  oceanbase::common::ObNewRow row;
354
  const int COL_NUM = 3;
355
  ObObj objs[COL_NUM];
356
  row.cells_ = objs;
357
  row.count_ = COL_NUM;
358
  for (int i = 0; i< COL_NUM; ++i) {
359
    row.cells_[i].set_int(0);
360
  }
361

362
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
363
  ASSERT_EQ(1, agg.results_.at(PROJECT_IDX).get_int());
364
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
365
  ASSERT_EQ(2, agg.results_.at(PROJECT_IDX).get_int());
366
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
367
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
368
  ASSERT_EQ(4, agg.results_.at(PROJECT_IDX).get_int());
369
}
370

371
TEST_F(TestTableAggregation, agg_sum_int)
372
{
373
  ObTableAggregation min;
374
  min.type_ = ObTableAggregationType::SUM;
375
  min.column_ = ObString("c1");
376

377
  ObTableQuery query;
378
  ASSERT_EQ(OB_SUCCESS, query.aggregations_.push_back(min));
379
  ASSERT_EQ(OB_SUCCESS, query.select_columns_.push_back("c1"));
380

381
  const uint64_t PROJECT_IDX = 0;
382
  ObSEArray<uint64_t, 4> projs;
383
  ASSERT_EQ(OB_SUCCESS, projs.push_back(PROJECT_IDX));
384

385
  ObTableAggCalculator agg(query);
386
  agg.allocator_.set_tenant_id(OB_SERVER_TENANT_ID);
387
  agg.set_projs(projs);
388
  ASSERT_EQ(OB_SUCCESS, agg.init());
389

390
  oceanbase::common::ObNewRow row;
391
  const int COL_NUM = 3;
392
  ObObj objs[COL_NUM];
393
  row.cells_ = objs;
394
  row.count_ = COL_NUM;
395
  for (int i = 0; i< COL_NUM; ++i) {
396
    row.cells_[i].set_int(1);
397
  }
398

399
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
400
  agg.final_aggregate();
401
  ASSERT_EQ(1, agg.results_.at(PROJECT_IDX).get_int());
402
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
403
  agg.final_aggregate();
404
  ASSERT_EQ(2, agg.results_.at(PROJECT_IDX).get_int());
405
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
406
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
407
  agg.final_aggregate();
408
  ASSERT_EQ(4, agg.results_.at(PROJECT_IDX).get_int());
409
}
410

411
TEST_F(TestTableAggregation, agg_sum_double)
412
{
413
  ObTableAggregation min;
414
  min.type_ = ObTableAggregationType::SUM;
415
  min.column_ = ObString("c1");
416

417
  ObTableQuery query;
418
  ASSERT_EQ(OB_SUCCESS, query.aggregations_.push_back(min));
419
  ASSERT_EQ(OB_SUCCESS, query.select_columns_.push_back("c1"));
420

421
  const uint64_t PROJECT_IDX = 0;
422
  ObSEArray<uint64_t, 4> projs;
423
  ASSERT_EQ(OB_SUCCESS, projs.push_back(PROJECT_IDX));
424

425
  ObTableAggCalculator agg(query);
426
  agg.allocator_.set_tenant_id(OB_SERVER_TENANT_ID);
427
  agg.set_projs(projs);
428
  ASSERT_EQ(OB_SUCCESS, agg.init());
429

430
  oceanbase::common::ObNewRow row;
431
  const int COL_NUM = 3;
432
  ObObj objs[COL_NUM];
433
  row.cells_ = objs;
434
  row.count_ = COL_NUM;
435
  for (int i = 0; i< COL_NUM; ++i) {
436
    row.cells_[i].set_double(0.1);
437
  }
438

439
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
440
  agg.final_aggregate();
441
  ASSERT_EQ(0.1, agg.results_.at(PROJECT_IDX).get_double());
442
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
443
  agg.final_aggregate();
444
  ASSERT_EQ(0.2, agg.results_.at(PROJECT_IDX).get_double());
445
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
446
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
447
  agg.final_aggregate();
448
  ASSERT_EQ(0.4, agg.results_.at(PROJECT_IDX).get_double());
449
}
450

451
TEST_F(TestTableAggregation, agg_avg_int)
452
{
453
  ObTableAggregation min;
454
  min.type_ = ObTableAggregationType::AVG;
455
  min.column_ = ObString("c1");
456

457
  ObTableQuery query;
458
  ASSERT_EQ(OB_SUCCESS, query.aggregations_.push_back(min));
459
  ASSERT_EQ(OB_SUCCESS, query.select_columns_.push_back("c1"));
460

461
  const uint64_t PROJECT_IDX = 0;
462
  ObSEArray<uint64_t, 4> projs;
463
  ASSERT_EQ(OB_SUCCESS, projs.push_back(PROJECT_IDX));
464

465
  ObTableAggCalculator agg(query);
466
  agg.allocator_.set_tenant_id(OB_SERVER_TENANT_ID);
467
  agg.set_projs(projs);
468
  ASSERT_EQ(OB_SUCCESS, agg.init());
469

470
  oceanbase::common::ObNewRow row;
471
  const int COL_NUM = 3;
472
  ObObj objs[COL_NUM];
473
  row.cells_ = objs;
474
  row.count_ = COL_NUM;
475
  for (int i = 0; i< COL_NUM; ++i) {
476
    row.cells_[i].set_int(1);
477
  }
478

479
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
480
  agg.final_aggregate();
481
  ASSERT_EQ(1, agg.results_.at(PROJECT_IDX).get_double());
482
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
483
  agg.final_aggregate();
484
  ASSERT_EQ(1, agg.results_.at(PROJECT_IDX).get_double());
485
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
486
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
487
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
488
  agg.final_aggregate();
489
  ASSERT_EQ(1, agg.results_.at(PROJECT_IDX).get_double());
490
}
491

492
TEST_F(TestTableAggregation, agg_avg_double)
493
{
494
  ObTableAggregation min;
495
  min.type_ = ObTableAggregationType::AVG;
496
  min.column_ = ObString("c1");
497

498
  ObTableQuery query;
499
  ASSERT_EQ(OB_SUCCESS, query.aggregations_.push_back(min));
500
  ASSERT_EQ(OB_SUCCESS, query.select_columns_.push_back("c1"));
501

502
  const uint64_t PROJECT_IDX = 0;
503
  ObSEArray<uint64_t, 4> projs;
504
  ASSERT_EQ(OB_SUCCESS, projs.push_back(PROJECT_IDX));
505

506
  ObTableAggCalculator agg(query);
507
  agg.allocator_.set_tenant_id(OB_SERVER_TENANT_ID);
508
  agg.set_projs(projs);
509
  ASSERT_EQ(OB_SUCCESS, agg.init());
510

511
  oceanbase::common::ObNewRow row;
512
  const int COL_NUM = 3;
513
  ObObj objs[COL_NUM];
514
  row.cells_ = objs;
515
  row.count_ = COL_NUM;
516
  for (int i = 0; i< COL_NUM; ++i) {
517
    row.cells_[i].set_double(0.1);
518
  }
519

520
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
521
  agg.final_aggregate();
522
  ASSERT_EQ(0.1, agg.results_.at(PROJECT_IDX).get_double());
523
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
524
  agg.final_aggregate();
525
  ASSERT_EQ(0.1, agg.results_.at(PROJECT_IDX).get_double());
526
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
527
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
528
  for (int i = 0; i< COL_NUM; ++i) {
529
    row.cells_[i].set_double(0.4);
530
  }
531
  ASSERT_EQ(OB_SUCCESS, agg.aggregate(row));
532
  agg.final_aggregate();
533
  ASSERT_EQ(0.16, agg.results_.at(PROJECT_IDX).get_double());
534
}
535

536
int main(int argc, char **argv)
537
{
538
  OB_LOGGER.set_log_level("INFO");
539
  OB_LOGGER.set_file_name("test_table_aggregation.log", true);
540
  ::testing::InitGoogleTest(&argc,argv);
541
  return RUN_ALL_TESTS();
542
}
543
oceanbase

Использование cookies
