MiniOB 1
MiniOB is one mini database, helping developers to learn how database works.
载入中...
搜索中...
未找到
tuple.h
1/* Copyright (c) 2021 OceanBase and/or its affiliates. All rights reserved.
2miniob is licensed under Mulan PSL v2.
3You can use this software according to the terms and conditions of the Mulan PSL v2.
4You may obtain a copy of Mulan PSL v2 at:
5 http://license.coscl.org.cn/MulanPSL2
6THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
7EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
8MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
9See the Mulan PSL v2 for more details. */
10
11//
12// Created by Wangyunlai on 2021/5/14.
13//
14
15#pragma once
16
17#include "common/log/log.h"
18#include "sql/expr/expression.h"
19#include "sql/expr/tuple_cell.h"
20#include "sql/parser/parse.h"
21#include "common/value.h"
22#include "storage/record/record.h"
23
24class Table;
25
48{
49public:
50 void append_cell(const TupleCellSpec &cell) { cells_.push_back(cell); }
51 void append_cell(const char *table, const char *field) { append_cell(TupleCellSpec(table, field)); }
52 void append_cell(const char *alias) { append_cell(TupleCellSpec(alias)); }
53 int cell_num() const { return static_cast<int>(cells_.size()); }
54
55 const TupleCellSpec &cell_at(int i) const { return cells_[i]; }
56
57private:
58 vector<TupleCellSpec> cells_;
59};
60
65class Tuple
66{
67public:
68 Tuple() = default;
69 virtual ~Tuple() = default;
70
75 virtual int cell_num() const = 0;
76
83 virtual RC cell_at(int index, Value &cell) const = 0;
84
85 virtual RC spec_at(int index, TupleCellSpec &spec) const = 0;
86
93 virtual RC find_cell(const TupleCellSpec &spec, Value &cell) const = 0;
94
95 virtual string to_string() const
96 {
97 string str;
98 const int cell_num = this->cell_num();
99 for (int i = 0; i < cell_num - 1; i++) {
100 Value cell;
101 cell_at(i, cell);
102 str += cell.to_string();
103 str += ", ";
104 }
105
106 if (cell_num > 0) {
107 Value cell;
108 cell_at(cell_num - 1, cell);
109 str += cell.to_string();
110 }
111 return str;
112 }
113
114 virtual RC compare(const Tuple &other, int &result) const
115 {
116 RC rc = RC::SUCCESS;
117
118 const int this_cell_num = this->cell_num();
119 const int other_cell_num = other.cell_num();
120 if (this_cell_num < other_cell_num) {
121 result = -1;
122 return rc;
123 }
124 if (this_cell_num > other_cell_num) {
125 result = 1;
126 return rc;
127 }
128
129 Value this_value;
130 Value other_value;
131 for (int i = 0; i < this_cell_num; i++) {
132 rc = this->cell_at(i, this_value);
133 if (OB_FAIL(rc)) {
134 return rc;
135 }
136
137 rc = other.cell_at(i, other_value);
138 if (OB_FAIL(rc)) {
139 return rc;
140 }
141
142 result = this_value.compare(other_value);
143 if (0 != result) {
144 return rc;
145 }
146 }
147
148 result = 0;
149 return rc;
150 }
151};
152
158class RowTuple : public Tuple
159{
160public:
161 RowTuple() = default;
162 virtual ~RowTuple()
163 {
164 for (FieldExpr *spec : speces_) {
165 delete spec;
166 }
167 speces_.clear();
168 }
169
170 void set_record(Record *record) { this->record_ = record; }
171
172 void set_schema(const Table *table, const vector<FieldMeta> *fields)
173 {
174 table_ = table;
175 // fix:join当中会多次调用右表的open,open当中会调用set_scheme,从而导致tuple当中会存储
176 // 很多无意义的field和value,因此需要先clear掉
177 for (FieldExpr *spec : speces_) {
178 delete spec;
179 }
180 this->speces_.clear();
181 this->speces_.reserve(fields->size());
182 for (const FieldMeta &field : *fields) {
183 speces_.push_back(new FieldExpr(table, &field));
184 }
185 }
186
187 int cell_num() const override { return speces_.size(); }
188
189 RC cell_at(int index, Value &cell) const override
190 {
191 if (index < 0 || index >= static_cast<int>(speces_.size())) {
192 LOG_WARN("invalid argument. index=%d", index);
193 return RC::INVALID_ARGUMENT;
194 }
195
196 FieldExpr *field_expr = speces_[index];
197 const FieldMeta *field_meta = field_expr->field().meta();
198 cell.reset();
199 cell.set_type(field_meta->type());
200 cell.set_data(this->record_->data() + field_meta->offset(), field_meta->len());
201 return RC::SUCCESS;
202 }
203
204 RC spec_at(int index, TupleCellSpec &spec) const override
205 {
206 const Field &field = speces_[index]->field();
207 spec = TupleCellSpec(table_->name(), field.field_name());
208 return RC::SUCCESS;
209 }
210
211 RC find_cell(const TupleCellSpec &spec, Value &cell) const override
212 {
213 const char *table_name = spec.table_name();
214 const char *field_name = spec.field_name();
215 if (0 != strcmp(table_name, table_->name())) {
216 return RC::NOTFOUND;
217 }
218
219 for (size_t i = 0; i < speces_.size(); ++i) {
220 const FieldExpr *field_expr = speces_[i];
221 const Field &field = field_expr->field();
222 if (0 == strcmp(field_name, field.field_name())) {
223 return cell_at(i, cell);
224 }
225 }
226 return RC::NOTFOUND;
227 }
228
229#if 0
230 RC cell_spec_at(int index, const TupleCellSpec *&spec) const override
231 {
232 if (index < 0 || index >= static_cast<int>(speces_.size())) {
233 LOG_WARN("invalid argument. index=%d", index);
234 return RC::INVALID_ARGUMENT;
235 }
236 spec = speces_[index];
237 return RC::SUCCESS;
238 }
239#endif
240
241 Record &record() { return *record_; }
242
243 const Record &record() const { return *record_; }
244
245private:
246 Record *record_ = nullptr;
247 const Table *table_ = nullptr;
248 vector<FieldExpr *> speces_;
249};
250
257class ProjectTuple : public Tuple
258{
259public:
260 ProjectTuple() = default;
261 virtual ~ProjectTuple() = default;
262
263 void set_expressions(vector<unique_ptr<Expression>> &&expressions) { expressions_ = std::move(expressions); }
264
265 auto get_expressions() const -> const vector<unique_ptr<Expression>> & { return expressions_; }
266
267 void set_tuple(Tuple *tuple) { this->tuple_ = tuple; }
268
269 int cell_num() const override { return static_cast<int>(expressions_.size()); }
270
271 RC cell_at(int index, Value &cell) const override
272 {
273 if (index < 0 || index >= cell_num()) {
274 return RC::INTERNAL;
275 }
276 if (tuple_ == nullptr) {
277 return RC::INTERNAL;
278 }
279
280 Expression *expr = expressions_[index].get();
281 return expr->get_value(*tuple_, cell);
282 }
283
284 RC spec_at(int index, TupleCellSpec &spec) const override
285 {
286 spec = TupleCellSpec(expressions_[index]->name());
287 return RC::SUCCESS;
288 }
289
290 RC find_cell(const TupleCellSpec &spec, Value &cell) const override { return tuple_->find_cell(spec, cell); }
291
292#if 0
293 RC cell_spec_at(int index, const TupleCellSpec *&spec) const override
294 {
295 if (index < 0 || index >= static_cast<int>(speces_.size())) {
296 return RC::NOTFOUND;
297 }
298 spec = speces_[index];
299 return RC::SUCCESS;
300 }
301#endif
302private:
303 vector<unique_ptr<Expression>> expressions_;
304 Tuple *tuple_ = nullptr;
305};
306
312class ValueListTuple : public Tuple
313{
314public:
315 ValueListTuple() = default;
316 virtual ~ValueListTuple() = default;
317
318 void set_names(const vector<TupleCellSpec> &specs) { specs_ = specs; }
319 void set_cells(const vector<Value> &cells) { cells_ = cells; }
320
321 virtual int cell_num() const override { return static_cast<int>(cells_.size()); }
322
323 virtual RC cell_at(int index, Value &cell) const override
324 {
325 if (index < 0 || index >= cell_num()) {
326 return RC::NOTFOUND;
327 }
328
329 cell = cells_[index];
330 return RC::SUCCESS;
331 }
332
333 RC spec_at(int index, TupleCellSpec &spec) const override
334 {
335 if (index < 0 || index >= cell_num()) {
336 return RC::NOTFOUND;
337 }
338
339 spec = specs_[index];
340 return RC::SUCCESS;
341 }
342
343 virtual RC find_cell(const TupleCellSpec &spec, Value &cell) const override
344 {
345 ASSERT(cells_.size() == specs_.size(), "cells_.size()=%d, specs_.size()=%d", cells_.size(), specs_.size());
346
347 const int size = static_cast<int>(specs_.size());
348 for (int i = 0; i < size; i++) {
349 if (specs_[i].equals(spec)) {
350 cell = cells_[i];
351 return RC::SUCCESS;
352 }
353 }
354 return RC::NOTFOUND;
355 }
356
357 static RC make(const Tuple &tuple, ValueListTuple &value_list)
358 {
359 const int cell_num = tuple.cell_num();
360 for (int i = 0; i < cell_num; i++) {
361 Value cell;
362 RC rc = tuple.cell_at(i, cell);
363 if (OB_FAIL(rc)) {
364 return rc;
365 }
366
367 TupleCellSpec spec;
368 rc = tuple.spec_at(i, spec);
369 if (OB_FAIL(rc)) {
370 return rc;
371 }
372
373 value_list.cells_.push_back(cell);
374 value_list.specs_.push_back(spec);
375 }
376 return RC::SUCCESS;
377 }
378
379private:
380 vector<Value> cells_;
381 vector<TupleCellSpec> specs_;
382};
383
390class JoinedTuple : public Tuple
391{
392public:
393 JoinedTuple() = default;
394 virtual ~JoinedTuple() = default;
395
396 void set_left(Tuple *left) { left_ = left; }
397 void set_right(Tuple *right) { right_ = right; }
398
399 int cell_num() const override { return left_->cell_num() + right_->cell_num(); }
400
401 RC cell_at(int index, Value &value) const override
402 {
403 const int left_cell_num = left_->cell_num();
404 if (index >= 0 && index < left_cell_num) {
405 return left_->cell_at(index, value);
406 }
407
408 if (index >= left_cell_num && index < left_cell_num + right_->cell_num()) {
409 return right_->cell_at(index - left_cell_num, value);
410 }
411
412 return RC::NOTFOUND;
413 }
414
415 RC spec_at(int index, TupleCellSpec &spec) const override
416 {
417 const int left_cell_num = left_->cell_num();
418 if (index >= 0 && index < left_cell_num) {
419 return left_->spec_at(index, spec);
420 }
421
422 if (index >= left_cell_num && index < left_cell_num + right_->cell_num()) {
423 return right_->spec_at(index - left_cell_num, spec);
424 }
425
426 return RC::NOTFOUND;
427 }
428
429 RC find_cell(const TupleCellSpec &spec, Value &value) const override
430 {
431 RC rc = left_->find_cell(spec, value);
432 if (rc == RC::SUCCESS || rc != RC::NOTFOUND) {
433 return rc;
434 }
435
436 return right_->find_cell(spec, value);
437 }
438
439private:
440 Tuple *left_ = nullptr;
441 Tuple *right_ = nullptr;
442};
表达式的抽象描述
Definition: expression.h:66
virtual RC get_value(const Tuple &tuple, Value &value) const =0
根据具体的tuple,来计算当前表达式的值。tuple有可能是一个具体某个表的行数据
字段表达式
Definition: expression.h:193
字段元数据
Definition: field_meta.h:30
字段
Definition: field.h:25
将两个tuple合并为一个tuple
Definition: tuple.h:391
RC cell_at(int index, Value &value) const override
获取指定位置的Cell
Definition: tuple.h:401
int cell_num() const override
获取元组中的Cell的个数
Definition: tuple.h:399
RC find_cell(const TupleCellSpec &spec, Value &value) const override
根据cell的描述,获取cell的值
Definition: tuple.h:429
从一行数据中,选择部分字段组成的元组,也就是投影操作
Definition: tuple.h:258
RC cell_at(int index, Value &cell) const override
获取指定位置的Cell
Definition: tuple.h:271
int cell_num() const override
获取元组中的Cell的个数
Definition: tuple.h:269
RC find_cell(const TupleCellSpec &spec, Value &cell) const override
根据cell的描述,获取cell的值
Definition: tuple.h:290
表示一个记录
Definition: record.h:101
一行数据的元组
Definition: tuple.h:159
int cell_num() const override
获取元组中的Cell的个数
Definition: tuple.h:187
RC cell_at(int index, Value &cell) const override
获取指定位置的Cell
Definition: tuple.h:189
RC find_cell(const TupleCellSpec &spec, Value &cell) const override
根据cell的描述,获取cell的值
Definition: tuple.h:211
Definition: table.h:42
Definition: tuple_cell.h:20
元组的结构,包含哪些字段(这里成为Cell),每个字段的说明
Definition: tuple.h:48
元组的抽象描述
Definition: tuple.h:66
virtual RC find_cell(const TupleCellSpec &spec, Value &cell) const =0
根据cell的描述,获取cell的值
virtual int cell_num() const =0
获取元组中的Cell的个数
virtual RC cell_at(int index, Value &cell) const =0
获取指定位置的Cell
一些常量值组成的TupleTODO 使用单独文件
Definition: tuple.h:313
virtual int cell_num() const override
获取元组中的Cell的个数
Definition: tuple.h:321
virtual RC find_cell(const TupleCellSpec &spec, Value &cell) const override
根据cell的描述,获取cell的值
Definition: tuple.h:343
virtual RC cell_at(int index, Value &cell) const override
获取指定位置的Cell
Definition: tuple.h:323
属性的值
Definition: value.h:30