update

Author: xuda

deps/3rd/jsoncpp

@@ -0,0 +1,49 @@
+/* Copyright (c) 2021 OceanBase and/or its affiliates. All rights reserved.
+miniob is licensed under Mulan PSL v2.
+*/
+
+#include "sql/executor/drop_table_executor.h"
+
+#include "common/log/log.h"
+#include "event/session_event.h"
+#include "event/sql_event.h"
+#include "sql/stmt/stmt.h"
+#include "sql/stmt/drop_table_stmt.h"
+#include "sql/executor/sql_result.h"
+#include "storage/db/db.h"
+
+RC DropTableExecutor::execute(SQLStageEvent *sql_event)
+{
+  RC rc = RC::SUCCESS;
+
+  SessionEvent *session_event = sql_event->session_event();
+  SqlResult    *sql_result    = session_event->sql_result();
+  Stmt         *stmt          = sql_event->stmt();
+
+  if (stmt == nullptr || stmt->type() != StmtType::DROP_TABLE) {
+    LOG_WARN("invalid stmt for DropTableExecutor");
+    rc = RC::INVALID_ARGUMENT;
+    sql_result->set_return_code(rc);
+    return rc;
+  }
+
+  auto *drop_stmt = static_cast<DropTableStmt *>(stmt);
+  Db   *db        = drop_stmt->db();
+
+  if (db == nullptr) {
+    LOG_WARN("db is null in DropTableStmt");
+    rc = RC::INVALID_ARGUMENT;
+    sql_result->set_return_code(rc);
+    return rc;
+  }
+
+  const std::string &table_name = drop_stmt->table_name();
+
+  rc = db->drop_table(table_name.c_str());
+  if (rc != RC::SUCCESS) {
+    LOG_WARN("failed to drop table %s, rc=%s", table_name.c_str(), strrc(rc));
+  }
+
+  sql_result->set_return_code(rc);
+  return rc;
+}

deps/3rd/libevent

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "common/sys/rc.h"
+
+class SQLStageEvent;
+
+/**
+ * 执行 DROP TABLE 的 executor
+ */
+class DropTableExecutor
+{
+public:
+  static RC execute(SQLStageEvent *sql_event);
+};

src/observer/sql/executor/drop_table_executor.cpp

@@ -38,6 +38,7 @@ enum class LogicalOperatorType
   JOIN,        ///< 连接
   INSERT,      ///< 插入
   DELETE,      ///< 删除，删除可能会有子查询
+  UPDATE,      ///< 更新
   EXPLAIN,     ///< 查看执行计划
   GROUP_BY,    ///< 分组
 };

src/observer/sql/executor/drop_table_executor.h

@@ -25,6 +25,7 @@ string physical_operator_type_name(PhysicalOperatorType type)
     case PhysicalOperatorType::PREDICATE: return "PREDICATE";
     case PhysicalOperatorType::INSERT: return "INSERT";
     case PhysicalOperatorType::DELETE: return "DELETE";
+    case PhysicalOperatorType::UPDATE: return "UPDATE";
     case PhysicalOperatorType::PROJECT: return "PROJECT";
     case PhysicalOperatorType::STRING_LIST: return "STRING_LIST";
     case PhysicalOperatorType::HASH_GROUP_BY: return "HASH_GROUP_BY";

src/observer/sql/operator/logical_operator.h

@@ -48,6 +48,7 @@ enum class PhysicalOperatorType
   STRING_LIST,
   DELETE,
   INSERT,
+  UPDATE,
   SCALAR_GROUP_BY,
   HASH_GROUP_BY,
   GROUP_BY_VEC,

src/observer/sql/operator/physical_operator.cpp

@@ -0,0 +1,43 @@
+/* Copyright (c) 2021 OceanBase and/or its affiliates. All rights reserved.
+miniob is licensed under Mulan PSL v2.
+You can use this software according to the terms and conditions of the Mulan PSL v2.
+You may obtain a copy of Mulan PSL v2 at:
+         http://license.coscl.org.cn/MulanPSL2
+THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+See the Mulan PSL v2 for more details. */
+
+#pragma once
+
+#include "sql/operator/logical_operator.h"
+#include "common/value.h"
+#include "storage/table/table.h"
+#include "storage/field/field_meta.h"
+
+/**
+ * @brief 更新逻辑算子
+ * @ingroup LogicalOperator
+ */
+class UpdateLogicalOperator : public LogicalOperator
+{
+public:
+  UpdateLogicalOperator(Table *table, const FieldMeta *field, Value value)
+      : table_(table), field_(field), value_(std::move(value))
+  {}
+  virtual ~UpdateLogicalOperator() = default;
+
+  LogicalOperatorType type() const override { return LogicalOperatorType::UPDATE; }
+  OpType get_op_type() const override { return OpType::LOGICALUPDATE; }
+
+  Table *table() const { return table_; }
+  const FieldMeta *field_meta() const { return field_; }
+  Value &value() { return value_; }
+
+private:
+  Table *table_ = nullptr;
+  const FieldMeta *field_ = nullptr;
+  Value value_;
+};
+
+

src/observer/sql/operator/physical_operator.h

@@ -0,0 +1,126 @@
+/* Copyright (c) 2021 OceanBase and/or its affiliates. All rights reserved.
+miniob is licensed under Mulan PSL v2.
+You can use this software according to the terms and conditions of the Mulan PSL v2.
+You may obtain a copy of Mulan PSL v2 at:
+         http://license.coscl.org.cn/MulanPSL2
+THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+See the Mulan PSL v2 for more details. */
+
+//
+// Created by MiniOB Update Implementor.
+//
+
+#include "sql/operator/update_physical_operator.h"
+#include "common/log/log.h"
+#include "sql/expr/tuple.h"
+#include "storage/table/table.h"
+#include "storage/table/table_meta.h"
+#include "storage/trx/trx.h"
+#include <string.h>
+
+RC UpdatePhysicalOperator::set_value_to_record(char *record_data, const Value &value, const FieldMeta *field)
+{
+  size_t copy_len = field->len();
+  const size_t data_len = value.length();
+  if (field->type() == AttrType::CHARS) {
+    if (copy_len > data_len) {
+      copy_len = data_len + 1; // include '\0'
+    }
+  }
+  memcpy(record_data + field->offset(), value.data(), copy_len);
+  return RC::SUCCESS;
+}
+
+RC UpdatePhysicalOperator::open(Trx *trx)
+{
+  if (children_.empty()) {
+    return RC::SUCCESS;
+  }
+
+  trx_ = trx;
+
+  unique_ptr<PhysicalOperator> &child = children_[0];
+
+  RC rc = child->open(trx);
+  if (rc != RC::SUCCESS) {
+    LOG_WARN("failed to open child operator: %s", strrc(rc));
+    return rc;
+  }
+
+  while (OB_SUCC(rc = child->next())) {
+    Tuple *tuple = child->current_tuple();
+    if (nullptr == tuple) {
+      LOG_WARN("failed to get current tuple");
+      rc = RC::INTERNAL;
+      break;
+    }
+
+    RowTuple *row_tuple = static_cast<RowTuple *>(tuple);
+    Record   &record    = row_tuple->record();
+    records_.emplace_back(std::move(record));
+  }
+
+  child->close();
+
+  if (rc != RC::SUCCESS && rc != RC::RECORD_EOF) {
+    return rc;
+  }
+
+  const TableMeta &meta = table_->table_meta();
+  const int rec_size = meta.record_size();
+
+  // delete + insert to update rows
+  for (Record &old_rec : records_) {
+    Record new_rec;
+    rc = new_rec.copy_data(old_rec.data(), rec_size);
+    if (OB_FAIL(rc)) {
+      LOG_WARN("failed to copy record. rc=%s", strrc(rc));
+      return rc;
+    }
+
+    Value write_val = value_;
+    if (write_val.attr_type() != field_->type()) {
+      Value casted;
+      rc = Value::cast_to(write_val, field_->type(), casted);
+      if (OB_FAIL(rc)) {
+        LOG_WARN("failed to cast value. rc=%s", strrc(rc));
+        return rc;
+      }
+      write_val = std::move(casted);
+    }
+
+    rc = set_value_to_record(const_cast<char *>(new_rec.data()), write_val, field_);
+    if (OB_FAIL(rc)) {
+      LOG_WARN("failed to set value to record. rc=%s", strrc(rc));
+      return rc;
+    }
+
+    rc = trx_->delete_record(table_, old_rec);
+    if (OB_FAIL(rc)) {
+      LOG_WARN("failed to delete record. rc=%s", strrc(rc));
+      return rc;
+    }
+
+    rc = trx_->insert_record(table_, new_rec);
+    if (OB_FAIL(rc)) {
+      LOG_WARN("failed to insert record. rc=%s", strrc(rc));
+      return rc;
+    }
+  }
+
+  return RC::SUCCESS;
+}
+
+RC UpdatePhysicalOperator::next()
+{
+  return RC::RECORD_EOF;
+}
+
+RC UpdatePhysicalOperator::close()
+{
+  return RC::SUCCESS;
+}
+
+

src/observer/sql/operator/update_logical_operator.h

@@ -0,0 +1,51 @@
+/* Copyright (c) 2021 OceanBase and/or its affiliates. All rights reserved.
+miniob is licensed under Mulan PSL v2.
+You can use this software according to the terms and conditions of the Mulan PSL v2.
+You may obtain a copy of Mulan PSL v2 at:
+         http://license.coscl.org.cn/MulanPSL2
+THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+See the Mulan PSL v2 for more details. */
+
+#pragma once
+
+#include "sql/operator/physical_operator.h"
+#include "common/value.h"
+#include "storage/table/table.h"
+#include "storage/field/field_meta.h"
+
+/**
+ * @brief 物理算子，用于执行update语句
+ * @ingroup PhysicalOperator
+ */
+class UpdatePhysicalOperator : public PhysicalOperator
+{
+public:
+  UpdatePhysicalOperator(Table *table, const FieldMeta *field, Value value)
+      : table_(table), field_(field), value_(std::move(value)) {}
+
+  virtual ~UpdatePhysicalOperator() = default;
+
+  PhysicalOperatorType type() const override { return PhysicalOperatorType::UPDATE; }
+
+  OpType get_op_type() const override { return OpType::UPDATE; }
+
+  RC open(Trx *trx) override;
+  RC next() override;
+  RC close() override;
+
+  Tuple *current_tuple() override { return nullptr; }
+
+private:
+  static RC set_value_to_record(char *record_data, const Value &value, const FieldMeta *field);
+
+private:
+  Table *table_ = nullptr;
+  const FieldMeta *field_ = nullptr;
+  Value value_;
+  Trx *trx_ = nullptr;
+  vector<Record> records_;
+};
+
+