Default values

src/include/catalog/schema.h

@@ -34,22 +34,48 @@ class Schema {
      * @param oid internal unique identifier for this column
      */
     Column(std::string name, const type::TypeId type, const bool nullable, const col_oid_t oid)
+        : name_(std::move(name)),
+          type_(type),
+          attr_size_(type::TypeUtil::GetTypeSize(type_)),
+          nullable_(nullable),
+          inlined_(true),
+          oid_(oid),
+          default_(nullptr) {
+      validateColumn();
+    }
+
+    /**
+     * Instantiates a Column object, primary to be used for building a Schema object
+     * NOTE: Overloaded to avoid changing all Column initializations in the code
+     * @param name column name
+     * @param type SQL type for this column
+     * @param nullable true if the column is nullable, false otherwise
+     * @param oid internal unique identifier for this column
+     * @param default_value default value for this column
+     */
+    Column(std::string name, const type::TypeId type, const bool nullable, const col_oid_t oid, byte *default_value)
         : name_(std::move(name)),
           type_(type),
           attr_size_(type::TypeUtil::GetTypeSize(type_)),
           nullable_(nullable),
           inlined_(true),
           oid_(oid) {
-      if (attr_size_ == VARLEN_COLUMN) {
-        // this is a varlen attribute
-        // attr_size_ is actual size + high bit via GetTypeSize
-        inlined_ = false;
+      // ASSUMPTION: The default_value passed in is of size attr_size_
+      // Copy the passed in default value
+      if (default_value != nullptr) {
+        default_ = new byte[attr_size_];
+        std::memcpy(default_, default_value, attr_size_);
+      } else {
+        default_ = default_value;
       }
-      TERRIER_ASSERT(
-          attr_size_ == 1 || attr_size_ == 2 || attr_size_ == 4 || attr_size_ == 8 || attr_size_ == VARLEN_COLUMN,
-          "Attribute size must be 1, 2, 4, 8 or VARLEN_COLUMN bytes.");
-      TERRIER_ASSERT(type_ != type::TypeId::INVALID, "Attribute type cannot be INVALID.");
+      validateColumn();
     }
+
+    /**
+     * Free the memory allocated to default_ in the destructor
+     */
+    ~Column() = default;
+
     /**
      * @return column name
      */
@@ -74,16 +100,34 @@ class Schema {
      * @return internal unique identifier for this column
      */
     col_oid_t GetOid() const { return oid_; }
+    /**
+     * @return default value for this column
+     */
+    byte *GetDefault() const { return default_; }
 
    private:
+    /**
+     * Validate the attr_size_ and type of the column
+     */
+    void validateColumn() {
+      if (attr_size_ == VARLEN_COLUMN) {
+        // this is a varlen attribute
+        // attr_size_ is actual size + high bit via GetTypeSize
+        inlined_ = false;
+      }
+      TERRIER_ASSERT(
+          attr_size_ == 1 || attr_size_ == 2 || attr_size_ == 4 || attr_size_ == 8 || attr_size_ == VARLEN_COLUMN,
+          "Attribute size must be 1, 2, 4, 8 or VARLEN_COLUMN bytes.");
+      TERRIER_ASSERT(type_ != type::TypeId::INVALID, "Attribute type cannot be INVALID.");
+    }
+
     const std::string name_;
     const type::TypeId type_;
     uint8_t attr_size_;
     const bool nullable_;
     bool inlined_;
     const col_oid_t oid_;
-    // TODO(Matt): default value would go here
-    // Value default_;
+    byte *default_;
   };
 
   /**

src/include/storage/sql_table.h

@@ -32,7 +32,8 @@ class SqlTable {
     BlockLayout layout;
     ColumnMap column_map;
     InverseColumnMap inverse_column_map;
-    // TODO(John): Add 'default_value_map' (dynamic) for col_oid->default_val
+    // TODO(Sai): Do we really need a defaultValueMap for every version? One for SqlTable should work?
+    DefaultValueMap default_value_map;
   };
 
   /**

src/include/storage/storage_defs.h

@@ -168,6 +168,7 @@ using ColumnMap = std::unordered_map<catalog::col_oid_t, col_id_t>;
  */
 using InverseColumnMap = std::unordered_map<col_id_t, catalog::col_oid_t>;
 using ProjectionMap = std::unordered_map<catalog::col_oid_t, uint16_t>;
+using DefaultValueMap = std::unordered_map<catalog::col_oid_t, std::pair<byte *, uint8_t>>;
 
 /**
  * Denote whether a record modifies the logical delete column, used when DataTable inspects deltas

src/storage/sql_table.cpp

@@ -108,6 +108,16 @@ void SqlTable::UpdateSchema(const catalog::Schema &schema) {
     }
   }
 
+  // Populate the default value map
+  DefaultValueMap default_value_map;
+  for (const auto &column : schema.GetColumns()) {
+    byte *default_value = column.GetDefault();
+    uint8_t attr_size = column.GetAttrSize();
+    if (default_value != nullptr) {
+      default_value_map[column.GetOid()] = {default_value, attr_size};
+    }
+  }
+
   BlockLayout layout = storage::BlockLayout(attr_sizes);
 
   auto dt = new DataTable(block_store_, layout, schema.GetVersion());
@@ -117,7 +127,7 @@ void SqlTable::UpdateSchema(const catalog::Schema &schema) {
   // for this allocation is in the destructor for SqlTable.  clang-analyzer-cplusplus.NewDeleteLeaks identifies this
   // as a potential leak and throws an error incorrectly.
   // NOLINTNEXTLINE
-  tables_.Insert(schema.GetVersion(), {dt, layout, col_map, inv_col_map});
+  tables_.Insert(schema.GetVersion(), {dt, layout, col_map, inv_col_map, default_value_map});
 }
 
 bool SqlTable::Select(transaction::TransactionContext *const txn, const TupleSlot slot, ProjectedRow *const out_buffer,
@@ -136,6 +146,7 @@ bool SqlTable::Select(transaction::TransactionContext *const txn, const TupleSlo
   }
 
   auto old_dt_version = tables_.Find(old_version_num)->second;
+  auto curr_dt_version = tables_.Find(version_num)->second;
 
   // The slot version is not the same as the version_num
   col_id_t original_column_ids[out_buffer->NumColumns()];
@@ -145,7 +156,20 @@ bool SqlTable::Select(transaction::TransactionContext *const txn, const TupleSlo
   bool result = old_dt_version.data_table->Select(txn, slot, out_buffer);
   std::memcpy(out_buffer->ColumnIds(), original_column_ids, sizeof(col_id_t) * out_buffer->NumColumns());
 
-  // TODO(Yashwanth): handle default values
+  // Get the DefaultValueMap visible to this transaction
+  DefaultValueMap default_val_map = curr_dt_version.default_value_map;
+
+  // Populate default values into the empty columns of the ProjectedRow (if any)
+  STORAGE_LOG_DEBUG("Loading default values")
+  for (uint16_t i = 0; i < out_buffer->NumColumns(); i++) {
+    catalog::col_oid_t col_oid = curr_dt_version.inverse_column_map.at(out_buffer->ColumnIds()[i]);
+    // Fill in the default value if the entry is not null and the col_oid is in the map
+    if (default_val_map.count(col_oid) > 0 && out_buffer->IsNull(i)) {
+      auto dv_pair = default_val_map.at(col_oid);
+      storage::StorageUtil::CopyWithNullCheck(dv_pair.first, out_buffer, dv_pair.second, i);
+    }
+  }
+
   return result;
 }
 
@@ -287,6 +311,36 @@ void SqlTable::Scan(transaction::TransactionContext *const txn, SqlTable::SlotIt
   uint32_t filled = out_buffer->NumTuples();
   std::memcpy(out_buffer->ColumnIds(), original_column_ids, sizeof(col_id_t) * out_buffer->NumColumns());
   out_buffer->SetNumTuples(filled);
+
+  // Populate the default values
+  if (filled > 0) {
+    // Since we are populating multiple tuples, calculate the columns matching with default value map
+    auto curr_dt_version = tables_.Find(version_num)->second;
+    DefaultValueMap default_val_map = curr_dt_version.default_value_map;
+    // Find out the columns which contain default values and their projection list index
+    std::vector<std::pair<catalog::col_oid_t, uint16_t>> matching_cols;
+    for (uint16_t i = 0; i < out_buffer->NumColumns(); i++) {
+      catalog::col_oid_t col_oid = curr_dt_version.inverse_column_map.at(out_buffer->ColumnIds()[i]);
+      // Fill in the default value if the entry is not null and the col_oid is in the map
+      if (default_val_map.count(col_oid) > 0) {
+        matching_cols.emplace_back(col_oid, i);
+      }
+    }
+
+    // Fill in the matching default values for each of the rows
+    // Since each row could have different columns unfilled, using RowView to iterate over ProjectedColumns
+    for (uint32_t row_idx = 0; row_idx < filled; row_idx++) {
+      ProjectedColumns::RowView row = out_buffer->InterpretAsRow(curr_dt_version.layout, row_idx);
+      for (auto col_oid_idx_pair : matching_cols) {
+        auto col_oid = col_oid_idx_pair.first;
+        auto idx = col_oid_idx_pair.second;
+        if (row.IsNull(idx)) {
+          auto dv_pair = default_val_map.at(col_oid);
+          storage::StorageUtil::CopyWithNullCheck(dv_pair.first, &row, dv_pair.second, idx);
+        }
+      }
+    }
+  }
 }
 
 std::vector<col_id_t> SqlTable::ColIdsForOids(const std::vector<catalog::col_oid_t> &col_oids,

test/storage/sql_table_test.cpp

@@ -38,9 +38,9 @@ class SqlTableTestRW {
   }
 
   void AddColumn(transaction::TransactionContext *txn, std::string name, type::TypeId type, bool nullable,
-                 catalog::col_oid_t oid) {
+                 catalog::col_oid_t oid, byte *default_value) {
     // update columns, schema and layout
-    cols_.emplace_back(name, type, nullable, oid);
+    cols_.emplace_back(name, type, nullable, oid, default_value);
     delete schema_;
     delete layout_;
     schema_ = new catalog::Schema(cols_, next_version_++);
@@ -205,6 +205,17 @@ class SqlTableTestRW {
     }
   }
 
+  /**
+   * Convert an integer to byte array
+   * @param n an integer
+   * @return byte array
+   */
+  byte *intToByteArray(int n) {
+    auto byteArray = new byte[sizeof(n)];
+    memcpy(byteArray, reinterpret_cast<char *>(&n), sizeof(n));
+    return byteArray;
+  }
+
  public:
   // This is a public field that transactions can set and read.
   // The purpose is to record the version for each transaction. In reality this information should be retrieved from
@@ -275,7 +286,10 @@ TEST_F(SqlTableTests, SelectTest) {
 
   // manually set the version of the transaction to be 1
   table.version_ = storage::layout_version_t(1);
-  table.AddColumn(txn, "new_col", type::TypeId::INTEGER, true, catalog::col_oid_t(2));
+  int default_val = 42;
+  // Add a new column with a default value
+  table.AddColumn(txn, "new_col", type::TypeId::INTEGER, true, catalog::col_oid_t(2),
+                  table.intToByteArray(default_val));
 
   id = table.GetIntColInRow(txn, catalog::col_oid_t(0), row1_slot);
   EXPECT_EQ(100, id);
@@ -287,8 +301,11 @@ TEST_F(SqlTableTests, SelectTest) {
   datname = table.GetIntColInRow(txn, catalog::col_oid_t(1), row2_slot);
   EXPECT_EQ(10001, datname);
 
+  // The new_column should return the default_value for the old version slots
   uint32_t new_col = table.GetIntColInRow(txn, catalog::col_oid_t(2), row1_slot);
-  EXPECT_EQ(12345, new_col);
+  EXPECT_EQ(default_val, new_col);
+  new_col = table.GetIntColInRow(txn, catalog::col_oid_t(2), row2_slot);
+  EXPECT_EQ(default_val, new_col);
 
   txn_manager_.Commit(txn, TestCallbacks::EmptyCallback, nullptr);
   delete txn;
@@ -313,7 +330,7 @@ TEST_F(SqlTableTests, InsertTest) {
 
   // manually set the version of the transaction to be 1
   table.version_ = storage::layout_version_t(1);
-  table.AddColumn(txn, "new_col", type::TypeId::INTEGER, true, catalog::col_oid_t(2));
+  table.AddColumn(txn, "new_col", type::TypeId::INTEGER, true, catalog::col_oid_t(2), nullptr);
 
   // insert (300, 10002, null)
   table.StartInsertRow();
@@ -368,7 +385,7 @@ TEST_F(SqlTableTests, DeleteTest) {
 
   // manually set the version of the transaction to be 1
   table.version_ = storage::layout_version_t(1);
-  table.AddColumn(txn, "new_col", type::TypeId::INTEGER, true, catalog::col_oid_t(2));
+  table.AddColumn(txn, "new_col", type::TypeId::INTEGER, true, catalog::col_oid_t(2), nullptr);
 
   // insert (300, 10002, null)
   table.StartInsertRow();
@@ -418,7 +435,7 @@ TEST_F(SqlTableTests, UpdateTest) {
 
   // manually set the version of the transaction to be 1
   table.version_ = storage::layout_version_t(1);
-  table.AddColumn(txn, "new_col", type::TypeId::INTEGER, true, catalog::col_oid_t(2));
+  table.AddColumn(txn, "new_col", type::TypeId::INTEGER, true, catalog::col_oid_t(2), nullptr);
 
   // insert (300, 10002, null)
   table.StartInsertRow();
@@ -489,6 +506,7 @@ TEST_F(SqlTableTests, UpdateTest) {
 TEST_F(SqlTableTests, ScanTest) {
   std::map<uint32_t, uint32_t> datname_map;
   std::map<uint32_t, uint32_t> new_col_map;
+  uint32_t new_col_default_value = 1729;
   std::map<uint32_t, bool> seen_map;
 
   datname_map[100] = 10000;
@@ -526,9 +544,10 @@ TEST_F(SqlTableTests, ScanTest) {
 
   // manually set the version of the transaction to be 1
   table.version_ = storage::layout_version_t(1);
-  table.AddColumn(txn, "new_col", type::TypeId::INTEGER, true, catalog::col_oid_t(2));
+  table.AddColumn(txn, "new_col", type::TypeId::INTEGER, true, catalog::col_oid_t(2),
+                  table.intToByteArray(new_col_default_value));
 
-  // insert (300, 10002, null)
+  // insert (300, 10002, 1729)
   table.StartInsertRow();
   table.SetIntColInRow(catalog::col_oid_t(0), 300);
   table.SetIntColInRow(catalog::col_oid_t(1), datname_map[300]);
@@ -570,10 +589,10 @@ TEST_F(SqlTableTests, ScanTest) {
   uint32_t datname = *reinterpret_cast<uint32_t *>(value);
   EXPECT_EQ(datname, datname_map[id]);
   value = row1.AccessWithNullCheck(pc_pair.second.at(catalog::col_oid_t(2)));
+  uint32_t new_col = *reinterpret_cast<uint32_t *>(value);
   if (id != 400) {
-    EXPECT_EQ(value, nullptr);
+    EXPECT_EQ(new_col, new_col_default_value);
   } else {
-    uint32_t new_col = *reinterpret_cast<uint32_t *>(value);
     EXPECT_EQ(new_col, new_col_map[id]);
   }
 
@@ -589,10 +608,10 @@ TEST_F(SqlTableTests, ScanTest) {
   datname = *reinterpret_cast<uint32_t *>(value);
   EXPECT_EQ(datname, datname_map[id]);
   value = row2.AccessWithNullCheck(pc_pair.second.at(catalog::col_oid_t(2)));
+  new_col = *reinterpret_cast<uint32_t *>(value);
   if (id != 400) {
-    EXPECT_EQ(value, nullptr);
+    EXPECT_EQ(new_col, new_col_default_value);
   } else {
-    uint32_t new_col = *reinterpret_cast<uint32_t *>(value);
     EXPECT_EQ(new_col, new_col_map[id]);
   }
 
@@ -613,10 +632,10 @@ TEST_F(SqlTableTests, ScanTest) {
   datname = *reinterpret_cast<uint32_t *>(value);
   EXPECT_EQ(datname, datname_map[id]);
   value = row3.AccessWithNullCheck(pc_pair.second.at(catalog::col_oid_t(2)));
+  new_col = *reinterpret_cast<uint32_t *>(value);
   if (id != 400) {
-    EXPECT_EQ(value, nullptr);
+    EXPECT_EQ(new_col, new_col_default_value);
   } else {
-    uint32_t new_col = *reinterpret_cast<uint32_t *>(value);
     EXPECT_EQ(new_col, new_col_map[id]);
   }
 
@@ -632,10 +651,10 @@ TEST_F(SqlTableTests, ScanTest) {
   datname = *reinterpret_cast<uint32_t *>(value);
   EXPECT_EQ(datname, datname_map[id]);
   value = row4.AccessWithNullCheck(pc_pair.second.at(catalog::col_oid_t(2)));
+  new_col = *reinterpret_cast<uint32_t *>(value);
   if (id != 400) {
-    EXPECT_EQ(value, nullptr);
+    EXPECT_EQ(new_col, new_col_default_value);
   } else {
-    uint32_t new_col = *reinterpret_cast<uint32_t *>(value);
     EXPECT_EQ(new_col, new_col_map[id]);
   }