._bustub 000755 000765 000024 00000000407 15127067064 013513 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 ATTR S H com.apple.macl com.apple.provenance c@~J gߏiLFJ P̴%Mg__㾟 Gx PaxHeader/bustub 000755 000765 000024 00000000566 15127067064 015255 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665204.429919815
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
133 LIBARCHIVE.xattr.com.apple.macl=BwDAwgFjvPNAfqVKf+joFJqgBwBn349pTEZKH7e/7xvs+fYdBwCrUP7MtCVNZ6ZfG+Ff476fAAAAAAAAAAAAAAAAAAAAAAAA
105 SCHILY.xattr.com.apple.macl= c@~J gߏiLFJ P̴%Mg__㾟
bustub/ 000755 000765 000024 00000000000 15127067064 013347 5 ustar 00yanhuang staff 000000 000000 bustub/._tools 000755 000765 000024 00000000243 15127067037 014651 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/PaxHeader/tools 000755 000765 000024 00000000210 15127067037 016377 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665183.952863311
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/tools/ 000755 000765 000024 00000000000 15127067037 014507 5 ustar 00yanhuang staff 000000 000000 bustub/._CMakeLists.txt 000644 000765 000024 00000000243 15127067037 016323 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/PaxHeader/CMakeLists.txt 000644 000765 000024 00000000210 15127067037 020051 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665183.953659397
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/CMakeLists.txt 000644 000765 000024 00000040762 15127067037 016120 0 ustar 00yanhuang staff 000000 000000 cmake_minimum_required(VERSION 3.10)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON) # For clang-tidy.
set(BUILD_SHARED_LIBS OFF) # We expect external libraries to be linked statically.
set(CMAKE_CXX_STANDARD 17) # Compile as C++17.
set(CMAKE_CXX_STANDARD_REQUIRED ON) # Require C++17 support.
project(BusTub
VERSION 2023.1
DESCRIPTION "The BusTub Relational Database Management System (Educational) @ https://github.com/cmu-db/bustub"
LANGUAGES C CXX
)
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
message(STATUS "Setting build type to `Debug` as none was specified.")
set(CMAKE_BUILD_TYPE "Debug")
endif()
if(EMSCRIPTEN)
add_compile_options(-fexceptions)
add_link_options(-fexceptions)
# Memory configuration
add_compile_options(-sALLOW_MEMORY_GROWTH=1)
add_compile_options(-sMAXIMUM_MEMORY=64MB)
add_link_options(-sALLOW_MEMORY_GROWTH=1)
add_link_options(-sMAXIMUM_MEMORY=64MB)
endif()
# People keep running CMake in the wrong folder, completely nuking their project or creating weird bugs.
# This checks if you're running CMake from a folder that already has CMakeLists.txt.
# Importantly, this catches the common case of running it from the root directory.
file(TO_CMAKE_PATH "${PROJECT_BINARY_DIR}/CMakeLists.txt" PATH_TO_CMAKELISTS_TXT)
if(EXISTS "${PATH_TO_CMAKELISTS_TXT}")
message(FATAL_ERROR "Run CMake from a build subdirectory! \"mkdir build ; cd build ; cmake ..\" \
Some junk files were created in this folder (CMakeCache.txt, CMakeFiles); you should delete those.")
endif()
# Expected directory structure.
set(BUSTUB_BUILD_SUPPORT_DIR "${CMAKE_SOURCE_DIR}/build_support")
set(BUSTUB_CLANG_SEARCH_PATH "/usr/local/bin" "/usr/bin" "/usr/local/opt/llvm/bin" "/usr/local/opt/llvm@14/bin"
"/opt/homebrew/opt/llvm@14/bin/")
if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
if(CMAKE_CXX_COMPILER_VERSION MATCHES "^14.")
message(STATUS "You're using ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}")
else()
message(WARNING "!! We recommend that you use clang-14 for developing BusTub. You're using ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}, a different version.")
endif()
elseif(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
message(STATUS "You're using ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}")
else()
message(WARNING "!! We recommend that you use clang-14 for developing BusTub. You're using ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}, which is not clang.")
endif()
# #####################################################################################################################
# DEPENDENCIES
# #####################################################################################################################
# CTest
enable_testing()
# clang-format
# attempt to find the binary if user did not specify
find_program(CLANG_FORMAT_BIN
NAMES clang-format clang-format-14
HINTS ${BUSTUB_CLANG_SEARCH_PATH})
if("${CLANG_FORMAT_BIN}" STREQUAL "CLANG_FORMAT_BIN-NOTFOUND")
message(WARNING "BusTub/main couldn't find clang-format.")
else()
message(STATUS "BusTub/main found clang-format at ${CLANG_FORMAT_BIN}")
endif()
# attempt to find the binary if user did not specify
find_program(CLANG_TIDY_BIN
NAMES clang-tidy clang-tidy-14
HINTS ${BUSTUB_CLANG_SEARCH_PATH})
if("${CLANG_TIDY_BIN}" STREQUAL "CLANG_TIDY_BIN-NOTFOUND")
message(WARNING "BusTub/main couldn't find clang-tidy.")
else()
# Output compile_commands.json
set(CMAKE_EXPORT_COMPILE_COMMANDS 1)
message(STATUS "BusTub/main found clang-tidy at ${CLANG_TIDY_BIN}")
endif()
find_program(CLANG_APPLY_REPLACEMENTS_BIN
NAMES clang-apply-replacements clang-apply-replacements-14
HINTS ${BUSTUB_CLANG_SEARCH_PATH})
if("${CLANG_APPLY_REPLACEMENTS_BIN}" STREQUAL "CLANG_APPLY_REPLACEMENTS_BIN-NOTFOUND")
message(WARNING "BusTub/main couldn't find clang-apply-replacements.")
else()
# Output compile_commands.json
set(CMAKE_EXPORT_COMPILE_COMMANDS 1)
message(STATUS "BusTub/main found clang-apply-replacements at ${CLANG_APPLY_REPLACEMENTS_BIN}")
endif()
# cpplint
find_program(CPPLINT_BIN
NAMES cpplint cpplint.py
HINTS "${BUSTUB_BUILD_SUPPORT_DIR}")
if("${CPPLINT_BIN}" STREQUAL "CPPLINT_BIN-NOTFOUND")
message(WARNING "BusTub/main couldn't find cpplint.")
else()
message(STATUS "BusTub/main found cpplint at ${CPPLINT_BIN}")
endif()
# #####################################################################################################################
# COMPILER SETUP
# #####################################################################################################################
if(NOT DEFINED BUSTUB_SANITIZER)
set(BUSTUB_SANITIZER address)
endif()
message("Build mode: ${CMAKE_BUILD_TYPE}")
message("${BUSTUB_SANITIZER} sanitizer will be enabled in debug mode.")
# Compiler flags.
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -Wextra -Werror -Wreorder-init-list -Wmissing-field-initializers")
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wno-unused-parameter -Wno-attributes -DDEBUG") # TODO: remove
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -ggdb -fsanitize=${BUSTUB_SANITIZER} -fno-omit-frame-pointer -fno-optimize-sibling-calls")
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
message(STATUS "CMAKE_CXX_FLAGS: ${CMAKE_CXX_FLAGS}")
message(STATUS "CMAKE_CXX_FLAGS_DEBUG: ${CMAKE_CXX_FLAGS_DEBUG}")
message(STATUS "CMAKE_EXE_LINKER_FLAGS: ${CMAKE_EXE_LINKER_FLAGS}")
message(STATUS "CMAKE_SHARED_LINKER_FLAGS: ${CMAKE_SHARED_LINKER_FLAGS}")
# Output directory.
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
# Includes.
set(BUSTUB_SRC_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/src/include)
set(BUSTUB_TEST_INCLUDE_DIR ${PROJECT_SOURCE_DIR}/test/include)
set(BUSTUB_THIRD_PARTY_INCLUDE_DIR
${PROJECT_SOURCE_DIR}/third_party
${PROJECT_SOURCE_DIR}/third_party/fmt/include
${PROJECT_SOURCE_DIR}/third_party/libpg_query/include
${PROJECT_SOURCE_DIR}/third_party/argparse/include
${PROJECT_SOURCE_DIR}/third_party/cpp_random_distributions
${PROJECT_SOURCE_DIR}/third_party/backward-cpp
)
include_directories(${BUSTUB_SRC_INCLUDE_DIR} ${BUSTUB_TEST_INCLUDE_DIR} ${BUSTUB_THIRD_PARTY_INCLUDE_DIR})
include_directories(BEFORE src) # This is needed for gtest.
function(disable_target_warnings NAME)
target_compile_options(${NAME} PRIVATE "-w")
endfunction()
# #####################################################################################################################
# Other CMake modules
# MUST BE ADDED AFTER CONFIGURING COMPILER PARAMETERS
# #####################################################################################################################
set(CMAKE_MODULE_PATH "${BUSTUB_BUILD_SUPPORT_DIR}/cmake;${CMAKE_MODULE_PATH}")
find_package(LibElf)
find_package(LibDwarf)
add_subdirectory(third_party)
add_subdirectory(src)
add_subdirectory(test)
add_subdirectory(tools)
# #####################################################################################################################
# MAKE TARGETS
# #####################################################################################################################
# #########################################
# "make format"
# "make check-format"
# #########################################
string(CONCAT BUSTUB_FORMAT_DIRS
"${CMAKE_CURRENT_SOURCE_DIR}/src,"
"${CMAKE_CURRENT_SOURCE_DIR}/test,"
)
# Runs clang format and updates files in place.
add_custom_target(format ${BUSTUB_BUILD_SUPPORT_DIR}/run_clang_format.py
${CLANG_FORMAT_BIN}
${BUSTUB_BUILD_SUPPORT_DIR}/clang_format_exclusions.txt
--source_dirs
${BUSTUB_FORMAT_DIRS}
--fix
--quiet
)
# Runs clang format and exits with a non-zero exit code if any files need to be reformatted
add_custom_target(check-format ${BUSTUB_BUILD_SUPPORT_DIR}/run_clang_format.py
${CLANG_FORMAT_BIN}
${BUSTUB_BUILD_SUPPORT_DIR}/clang_format_exclusions.txt
--source_dirs
${BUSTUB_FORMAT_DIRS}
--quiet
)
# #########################################
# "make check-lint"
# #########################################
file(GLOB_RECURSE BUSTUB_LINT_FILES
"${CMAKE_CURRENT_SOURCE_DIR}/src/*.h"
"${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/test/*.h"
"${CMAKE_CURRENT_SOURCE_DIR}/test/*.cpp"
)
# Balancing act: cpplint.py takes a non-trivial time to launch,
# so process 12 files per invocation, while still ensuring parallelism
add_custom_target(check-lint echo '${BUSTUB_LINT_FILES}' | xargs -n12 -P8
${CPPLINT_BIN}
--verbose=2 --quiet
--linelength=120
--filter=-legal/copyright,-build/header_guard,-runtime/references # https://github.com/cpplint/cpplint/issues/148
)
# ##########################################################
# "make check-clang-tidy" target
# ##########################################################
# runs clang-tidy and exits with a non-zero exit code if any errors are found.
# note that clang-tidy automatically looks for a .clang-tidy file in parent directories
add_custom_target(check-clang-tidy
${BUSTUB_BUILD_SUPPORT_DIR}/run_clang_tidy.py # run LLVM's clang-tidy script
-clang-tidy-binary ${CLANG_TIDY_BIN} # using our clang-tidy binary
-p ${CMAKE_BINARY_DIR} # using cmake's generated compile commands
)
add_custom_target(fix-clang-tidy
${BUSTUB_BUILD_SUPPORT_DIR}/run_clang_tidy.py # run LLVM's clang-tidy script
-clang-tidy-binary ${CLANG_TIDY_BIN} # using our clang-tidy binary
-p ${CMAKE_BINARY_DIR} # using cmake's generated compile commands
-clang-apply-replacements-binary ${CLANG_APPLY_REPLACEMENTS_BIN} # using our clang-apply-replacements binary
-fix # apply suggested changes generated by clang-tidy
)
add_custom_target(check-clang-tidy-diff
${BUSTUB_BUILD_SUPPORT_DIR}/run_clang_tidy.py # run LLVM's clang-tidy script
-clang-tidy-binary ${CLANG_TIDY_BIN} # using our clang-tidy binary
-p ${CMAKE_BINARY_DIR} # using cmake's generated compile commands
-only-diff # only check diff files to master
)
add_custom_target(fix-clang-tidy-diff
${BUSTUB_BUILD_SUPPORT_DIR}/run_clang_tidy.py # run LLVM's clang-tidy script
-clang-tidy-binary ${CLANG_TIDY_BIN} # using our clang-tidy binary
-p ${CMAKE_BINARY_DIR} # using cmake's generated compile commands
-clang-apply-replacements-binary ${CLANG_APPLY_REPLACEMENTS_BIN} # using our clang-apply-replacements binary
-fix # apply suggested changes generated by clang-tidy
-only-diff # only check diff files to master
)
# ##########################################################
# "make check-clang-tidy" target for projects
# check clang-tidy on the whole projects is slow, so we
# hardcode some files to check here for each project.
# ##########################################################
set(P0_FILES
"src/include/primer/hyperloglog.h"
"src/include/primer/hyperloglog_presto.h"
"src/primer/hyperloglog.cpp"
"src/primer/hyperloglog_presto.cpp"
)
add_custom_target(check-clang-tidy-p0
${BUSTUB_BUILD_SUPPORT_DIR}/run_clang_tidy.py # run LLVM's clang-tidy script
-clang-tidy-binary ${CLANG_TIDY_BIN} # using our clang-tidy binary
-p ${CMAKE_BINARY_DIR} # using cmake's generated compile commands
${P0_FILES}
)
add_custom_target(submit-p0
zip project0-submission.zip
${P0_FILES}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
set(P1_FILES
"src/include/buffer/lru_k_replacer.h"
"src/buffer/lru_k_replacer.cpp"
"src/include/buffer/buffer_pool_manager.h"
"src/buffer/buffer_pool_manager.cpp"
"src/include/storage/disk/disk_scheduler.h"
"src/storage/disk/disk_scheduler.cpp"
"src/storage/page/page_guard.cpp"
"src/include/storage/page/page_guard.h"
)
add_custom_target(check-clang-tidy-p1
${BUSTUB_BUILD_SUPPORT_DIR}/run_clang_tidy.py # run LLVM's clang-tidy script
-clang-tidy-binary ${CLANG_TIDY_BIN} # using our clang-tidy binary
-p ${CMAKE_BINARY_DIR} # using cmake's generated compile commands
${P1_FILES}
)
add_custom_target(submit-p1
zip project1-submission.zip
${P1_FILES}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
set(P2_FILES
"src/include/storage/page/b_plus_tree_page.h"
"src/storage/page/b_plus_tree_page.cpp"
"src/include/storage/page/b_plus_tree_internal_page.h"
"src/storage/page/b_plus_tree_internal_page.cpp"
"src/include/storage/page/b_plus_tree_leaf_page.h"
"src/storage/page/b_plus_tree_leaf_page.cpp"
"src/include/storage/index/index_iterator.h"
"src/storage/index/index_iterator.cpp"
"src/include/storage/index/b_plus_tree.h"
"src/include/storage/index/b_plus_tree_debug.h"
"src/storage/index/b_plus_tree.cpp"
${P1_FILES}
)
add_custom_target(check-clang-tidy-p2
${BUSTUB_BUILD_SUPPORT_DIR}/run_clang_tidy.py # run LLVM's clang-tidy script
-clang-tidy-binary ${CLANG_TIDY_BIN} # using our clang-tidy binary
-p ${CMAKE_BINARY_DIR} # using cmake's generated compile commands
${P2_FILES}
)
add_custom_target(submit-p2
zip project2-submission.zip
${P2_FILES}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
set(P3_FILES
"src/include/execution/executors/aggregation_executor.h"
"src/include/execution/executors/delete_executor.h"
"src/include/execution/executors/filter_executor.h"
"src/include/execution/executors/hash_join_executor.h"
"src/include/execution/executors/index_scan_executor.h"
"src/include/execution/executors/insert_executor.h"
"src/include/execution/executors/limit_executor.h"
"src/include/execution/executors/nested_index_join_executor.h"
"src/include/execution/executors/nested_loop_join_executor.h"
"src/include/execution/executors/seq_scan_executor.h"
"src/include/execution/executors/external_merge_sort_executor.h"
"src/include/execution/executors/update_executor.h"
"src/execution/aggregation_executor.cpp"
"src/execution/delete_executor.cpp"
"src/execution/filter_executor.cpp"
"src/execution/hash_join_executor.cpp"
"src/execution/index_scan_executor.cpp"
"src/execution/insert_executor.cpp"
"src/execution/limit_executor.cpp"
"src/execution/nested_index_join_executor.cpp"
"src/execution/nested_loop_join_executor.cpp"
"src/execution/seq_scan_executor.cpp"
"src/execution/external_merge_sort_executor.cpp"
"src/execution/update_executor.cpp"
"src/include/execution/execution_common.h"
"src/include/optimizer/optimizer.h"
"src/include/optimizer/optimizer_internal.h"
"src/execution/execution_common.cpp"
"src/optimizer/nlj_as_hash_join.cpp"
"src/optimizer/optimizer_custom_rules.cpp"
"src/optimizer/optimizer_internal.cpp"
"src/optimizer/seqscan_as_indexscan.cpp"
"src/optimizer/column_pruning.cpp"
"src/common/bustub_ddl.cpp"
${P2_FILES}
)
add_custom_target(check-clang-tidy-p3
${BUSTUB_BUILD_SUPPORT_DIR}/run_clang_tidy.py # run LLVM's clang-tidy script
-clang-tidy-binary ${CLANG_TIDY_BIN} # using our clang-tidy binary
-p ${CMAKE_BINARY_DIR} # using cmake's generated compile commands
${P3_FILES}
)
add_custom_target(submit-p3
zip project3-submission.zip
${P3_FILES}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
set(P4_FILES
"src/include/concurrency/transaction_manager.h"
"src/concurrency/transaction_manager.cpp"
"src/include/concurrency/watermark.h"
"src/concurrency/watermark.cpp"
${P3_FILES}
)
add_custom_target(check-clang-tidy-p4
${BUSTUB_BUILD_SUPPORT_DIR}/run_clang_tidy.py # run LLVM's clang-tidy script
-clang-tidy-binary ${CLANG_TIDY_BIN} # using our clang-tidy binary
-p ${CMAKE_BINARY_DIR} # using cmake's generated compile commands
${P4_FILES}
)
add_custom_target(submit-p4
zip project4-submission.zip
${P4_FILES}
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
add_dependencies(check-clang-tidy gtest bustub) # needs gtest headers, compile_commands.json
bustub/._LICENSE 000644 000765 000024 00000000243 15127067037 014570 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/PaxHeader/LICENSE 000644 000765 000024 00000000210 15127067037 016316 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665183.954589274
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/LICENSE 000644 000765 000024 00000002063 15127067037 014355 0 ustar 00yanhuang staff 000000 000000 MIT License
Copyright (c) 2019 CMU Database Group
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
bustub/._test 000755 000765 000024 00000000243 15127067037 014470 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/PaxHeader/test 000755 000765 000024 00000000210 15127067037 016216 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665183.976956786
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/test/ 000755 000765 000024 00000000000 15127067037 014326 5 ustar 00yanhuang staff 000000 000000 bustub/._gradescope_sign.py 000755 000765 000024 00000000243 15127067037 017274 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/PaxHeader/gradescope_sign.py 000755 000765 000024 00000000210 15127067037 021022 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665183.989553983
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/gradescope_sign.py 000755 000765 000024 00000006732 15127067037 017070 0 ustar 00yanhuang staff 000000 000000 #!/usr/bin/env python3
from datetime import datetime
from pathlib import Path
import subprocess
def request_yn(buffer, msg):
print(msg, end="")
print(" [y/N] ", end="")
yn = input()
assert yn == "y"
buffer += msg
buffer += "\n"
return buffer
def request_sign(buffer, msg):
print(msg, end="")
print(" ", end="")
data = input()
assert len(data) >= 2
buffer += msg
buffer += " "
buffer += data
buffer += "\n"
return buffer
def request_date(buffer, msg):
print(msg, end="")
buffer += msg
date = datetime.today().strftime("%Y-%m-%d")
print(" " + date)
buffer += " "
buffer += date
buffer += "\n"
return buffer
def add_to_submission():
for item in Path().iterdir():
name = item.name
if name.startswith("project") and name.endswith("-submission.zip"):
print("adding GRADESCOPE.md to", name)
subprocess.run(["zip", name, "GRADESCOPE.md"])
def main():
if Path("GRADESCOPE.md").exists():
print("Found existing signature GRADESCOPE.md, adding to all submissions...")
add_to_submission()
print(
"If you want to make modifications to signed document, run `rm GRADESCOPE.md` and then run this script again."
)
return
buffer = ""
buffer = request_yn(
buffer,
"To create a fair learning environment for all students and avoid potential Academic Integrity Violations within Carnegie Mellon University, we ask you to sign this short agreement before submitting to Gradescope.",
)
buffer += "\n"
buffer = request_yn(
buffer,
"1. I agree NOT to make my solution public. i.e., DO NOT make it public on GitHub or create videos explaining the solution code.",
)
buffer = request_yn(
buffer,
"2. I agree NOT to hack Gradescope. i.e., DO NOT retrieve private test cases from Gradescope, or bypass correctness checks.",
)
buffer = request_yn(
buffer,
"3. I affirm that the work I submit for assessment is my original work. i.e., DO NOT purchase/copy solution from others.",
)
buffer = request_yn(
buffer,
"4. I understand that the course staff does not provide official help for students outside CMU. i.e., DO NOT email the course staff or create GitHub issues for course-related questions. Use the unofficial Discord server.",
)
buffer = request_yn(
buffer,
"I understand that if I violate the rules, I will be banned from using Gradescope.",
)
buffer += "\n"
buffer = request_sign(buffer, "Name:")
buffer = request_sign(buffer, "Affiliation (School/Company):")
buffer = request_sign(buffer, "Email:")
buffer = request_sign(buffer, "GitHub ID:")
buffer = request_date(buffer, "Date:")
buffer += "\n"
buffer = request_yn(
buffer,
"I understand that if I provide a fake signature, I will be banned from using Gradescope.",
)
print()
print("--- THIS IS A COPY OF THE SIGNED DOCUMENT ---")
print(buffer)
print("--- END OF THE SIGNED DOCUMENT ---")
print()
print(
"Saving the signature to GRADESCOPE.md and adding the signed document to submission zips..."
)
Path("GRADESCOPE.md").write_text(buffer)
add_to_submission()
print("Run this script again if you create new submission zips.")
if __name__ == "__main__":
try:
main()
except KeyboardInterrupt:
print("\nthe sign process was aborted")
bustub/._.clang-tidy 000644 000765 000024 00000000243 15127067037 015617 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/PaxHeader/.clang-tidy 000644 000765 000024 00000000210 15127067037 017345 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665183.990901194
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/.clang-tidy 000644 000765 000024 00000012010 15127067037 015375 0 ustar 00yanhuang staff 000000 000000 # Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
#
# Modified from the Apache Arrow project for the Terrier project.
#
---
Checks: '
bugprone-*,
clang-analyzer-*,
google-*,
modernize-*,
performance-*,
portability-*,
readability-*,
-bugprone-easily-swappable-parameters,
-bugprone-implicit-widening-of-multiplication-result,
-bugprone-narrowing-conversions,
-bugprone-reserved-identifier,
-bugprone-signed-char-misuse,
-bugprone-suspicious-include,
-bugprone-unhandled-self-assignment,
-clang-analyzer-cplusplus.NewDelete,
-clang-analyzer-cplusplus.NewDeleteLeaks,
-clang-analyzer-security.insecureAPI.rand,
-clang-diagnostic-implicit-int-float-conversion,
-google-readability-avoid-underscore-in-googletest-name,
-modernize-avoid-c-arrays,
-modernize-use-nodiscard,
-readability-convert-member-functions-to-static,
-readability-identifier-length,
-readability-function-cognitive-complexity,
-readability-magic-numbers,
-readability-make-member-function-const,
-readability-qualified-auto,
-readability-redundant-access-specifiers,
-bugprone-exception-escape,
'
CheckOptions:
- { key: readability-identifier-naming.ClassCase, value: CamelCase }
- { key: readability-identifier-naming.EnumCase, value: CamelCase }
- { key: readability-identifier-naming.FunctionCase, value: CamelCase }
- { key: readability-identifier-naming.GlobalConstantCase, value: UPPER_CASE }
- { key: readability-identifier-naming.MemberCase, value: lower_case }
- { key: readability-identifier-naming.MemberSuffix, value: _ }
- { key: readability-identifier-naming.NamespaceCase, value: lower_case }
- { key: readability-identifier-naming.StructCase, value: CamelCase }
- { key: readability-identifier-naming.UnionCase, value: CamelCase }
- { key: readability-identifier-naming.VariableCase, value: lower_case }
WarningsAsErrors: '*'
HeaderFilterRegex: '/(src|test)/include'
AnalyzeTemporaryDtors: true
#### Disabled checks and why: #####
#
# -readability-convert-member-functions-to-static,
# This check started going off in the upgrade from clang-tidy-8 to clang-tidy-12. It is not always correct because
# we hide the reference implementation in another repository.
# -clang-analyzer-security.insecureAPI.rand, -clang-analyzer-security.insecureAPI.rand, -bugprone-unhandled-self-assignment,
# -bugprone-implicit-widening-of-multiplication-result
# These have not been investigated yet.
# -bugprone-reserved-identifier,
# Fails due to use of some __SHORT_FILE__ symbol, originating from very old code.
# -bugprone-suspicious-include,
# False positive due to GTest code.
# -bugprone-too-small-loop-variable,
# Complains about uint8_t or uint16_t when the limit on the loop is a container's .size() (size_t).
# We usually do this when we know the maximum size of the container though, so propose leaving disabled.
# -clang-analyzer-cplusplus.NewDelete,
# Seems to generate false positives. Suggest relying on ASAN and valgrind for memory stuff.
# -clang-analyzer-cplusplus.NewDeleteLeaks,
# Seems to generate false positives. Suggest relying on ASAN and valgrind for memory stuff.
# -modernize-use-nodiscard,
# New C++17 feature, slightly polarizing. Would clutter codebase.
# -modernize-avoid-c-arrays,
# We use C-style arrays in page.h, type.h and logger.h. They're a little more ergonomic than std::array. Thoughts?
# -readability-magic-numbers,
# Let's not deal with people doing ridiculous things to hack around this. If it bites them, it bites them.
# -bugprone-signed-char-misuse, -clang-diagnostic-implicit-int-float-conversion, -readability-make-member-function-const,
# -readability-qualified-auto, -readability-redundant-access-specifiers
# These were previously disabled for not being available in clang-tidy-8. They are now available on our clang-tidy-12,
# and potentially worth investigating/fixing.
# -bugprone-exception-escape
# Weird. No idea how to resolve.
bustub/._README.md 000644 000765 000024 00000000243 15127067037 015042 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/PaxHeader/README.md 000644 000765 000024 00000000210 15127067037 016570 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665183.991531737
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/README.md 000644 000765 000024 00000013507 15127067037 014634 0 ustar 00yanhuang staff 000000 000000 
-----------------
[](https://github.com/cmu-db/bustub/actions/workflows/cmake.yml)
BusTub is a relational database management system built at [Carnegie Mellon University](https://db.cs.cmu.edu) for the [Introduction to Database Systems](https://15445.courses.cs.cmu.edu) (15-445/645) course. This system was developed for educational purposes and should not be used in production environments.
BusTub supports basic SQL and comes with an interactive shell. You can get it running after finishing all the course projects.
**WARNING: IF YOU ARE A STUDENT IN THE CLASS, DO NOT DIRECTLY FORK THIS REPO. DO NOT PUSH PROJECT SOLUTIONS PUBLICLY. THIS IS AN ACADEMIC INTEGRITY VIOLATION AND CAN LEAD TO GETTING YOUR DEGREE REVOKED, EVEN AFTER YOU GRADUATE.**
We make the autograder for each assignment available to non-CMU students on Gradescope after their due date for CMU students. In exchange for making this available to the public, we ask that you do not make your project implementations public on Github or other source code repositories. Please read the course FAQ on how to use the autograder on Gradescope. Run `python3 gradescope_sign.py` to sign an agreement before submitting to the autograder.
**WARNING: IF YOU ARE A STUDENT OUTSIDE CMU, DO NOT MAKE YOUR SOLUTION PUBLICLY AVAILABLE, AND DO SUBMIT YOUR OWN WORK. OTHERWISE, YOU WILL BE BANNED FROM USING THE AUTOGRADER.** Thank you for creating a fair learning environment.
## Cloning this Repository
The following instructions are adapted from the Github documentation on [duplicating a repository](https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/creating-a-repository-on-github/duplicating-a-repository). The procedure below walks you through creating a private BusTub repository that you can use for development.
1. Go [here](https://github.com/new) to create a new repository under your account. Pick a name (e.g. `bustub-private`) and select **Private** for the repository visibility level.
2. On your development machine, create a bare clone of the public BusTub repository:
```console
$ git clone --bare https://github.com/cmu-db/bustub.git bustub-public
```
3. Next, [mirror](https://git-scm.com/docs/git-push#Documentation/git-push.txt---mirror) the public BusTub repository to your own private BusTub repository. Suppose your GitHub name is `student` and your repository name is `bustub-private`. The procedure for mirroring the repository is then:
```console
$ cd bustub-public
# If you pull / push over HTTPS
$ git push https://github.com/student/bustub-private.git master
# If you pull / push over SSH
$ git push git@github.com:student/bustub-private.git master
```
This copies everything in the public BusTub repository to your own private repository. You can now delete your local clone of the public repository:
```console
$ cd ..
$ rm -rf bustub-public
```
4. Clone your private repository to your development machine:
```console
# If you pull / push over HTTPS
$ git clone https://github.com/student/bustub-private.git
# If you pull / push over SSH
$ git clone git@github.com:student/bustub-private.git
```
5. Add the public BusTub repository as a second remote. This allows you to retrieve changes from the CMU-DB repository and merge them with your solution throughout the semester:
```console
$ git remote add public https://github.com/cmu-db/bustub.git
```
You can verify that the remote was added with the following command:
```console
$ git remote -v
origin https://github.com/student/bustub-private.git (fetch)
origin https://github.com/student/bustub-private.git (push)
public https://github.com/cmu-db/bustub.git (fetch)
public https://github.com/cmu-db/bustub.git (push)
```
6. You can now pull in changes from the public BusTub repository as needed with:
```console
$ git pull public master
```
7. **Disable GitHub Actions** from the project settings of your private repository, otherwise you may run out of GitHub Actions quota.
```
Settings > Actions > General > Actions permissions > Disable actions.
```
We suggest working on your projects in separate branches. If you do not understand how Git branches work, [learn how](https://git-scm.com/book/en/v2/Git-Branching-Basic-Branching-and-Merging). If you fail to do this, you might lose all your work at some point in the semester, and nobody will be able to help you.
## Build
We recommend developing BusTub on Ubuntu 22.04, or macOS (M1/M2/Intel). We do not support any other environments (i.e., do not open issues or come to office hours to debug them). We do not support WSL. The grading environment runs
Ubuntu 22.04.
### Linux (Recommended) / macOS (Development Only)
To ensure that you have the proper packages on your machine, run the following script to automatically install them:
```console
# Linux
$ sudo build_support/packages.sh
# macOS
$ build_support/packages.sh
```
Then run the following commands to build the system:
```console
$ mkdir build
$ cd build
$ cmake ..
$ make
```
If you want to compile the system in debug mode, pass in the following flag to cmake:
Debug mode:
```console
$ cmake -DCMAKE_BUILD_TYPE=Debug ..
$ make -j`nproc`
```
This enables [AddressSanitizer](https://github.com/google/sanitizers) by default.
If you want to use other sanitizers,
```console
$ cmake -DCMAKE_BUILD_TYPE=Debug -DBUSTUB_SANITIZER=thread ..
$ make -j`nproc`
```
There are some differences between macOS and Linux (i.e., mutex behavior) that might cause test cases
to produce different results in different platforms. We recommend students to use a Linux VM for running
test cases and reproducing errors whenever possible.
bustub/._.dockerignore 000644 000765 000024 00000000243 15127067037 016237 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/PaxHeader/.dockerignore 000644 000765 000024 00000000207 15127067037 017773 x ustar 00yanhuang staff 000000 000000 29 mtime=1767665183.99180153
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/.dockerignore 000644 000765 000024 00000000054 15127067037 016022 0 ustar 00yanhuang staff 000000 000000 # Don't send any build context to Docker.
** bustub/._third_party 000755 000765 000024 00000000243 15127067040 016034 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/PaxHeader/third_party 000755 000765 000024 00000000210 15127067040 017562 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665184.251041275
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/third_party/ 000755 000765 000024 00000000000 15127067040 015672 5 ustar 00yanhuang staff 000000 000000 bustub/._logo 000755 000765 000024 00000000243 15127067040 014443 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/PaxHeader/logo 000755 000765 000024 00000000210 15127067040 016171 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665184.253107155
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/logo/ 000755 000765 000024 00000000000 15127067040 014301 5 ustar 00yanhuang staff 000000 000000 bustub/._.gitignore 000644 000765 000024 00000000243 15127067040 015545 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/PaxHeader/.gitignore 000644 000765 000024 00000000210 15127067040 017273 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665184.253630615
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/.gitignore 000644 000765 000024 00000010410 15127067040 015325 0 ustar 00yanhuang staff 000000 000000 #==============================================================================#
# This file specifies intentionally untracked files that git should ignore.
#==============================================================================#
/GRADESCOPE.md
#==============================================================================#
# File extensions to be ignored anywhere in the tree.
#==============================================================================#
# Temp files created by most text editors.
*~
# Merge files created by git.
*.orig
# Java bytecode
*.class
# Byte compiled python modules.
*.pyc
# vim swap files
.*.sw?
.sw?
# vscode settings directory
.vscode
#OS X specific files.
.DS_store
# Core files
#core
#==============================================================================#
# Explicit files to ignore (only matches one).
#==============================================================================#
# Various tag programs
/tags
/TAGS
/GPATH
/GRTAGS
/GSYMS
/GTAGS
.gitusers
autom4te.cache
cscope.files
cscope.out
autoconf/aclocal.m4
autoconf/autom4te.cache
/compile_commands.json
#==============================================================================#
# Build artifacts
#==============================================================================#
#m4/
build/
#*.m4
*.o
*.lo
*.la
*~
*.pdf
*.swp
a.out
#==============================================================================#
# Kate Swap Files
#==============================================================================#
*.kate-swp
.#kate-*
#==============================================================================#
# Backup artifacts
#==============================================================================#
~*
*~
tmp/
#==============================================================================#
# KDevelop files
#==============================================================================#
.kdev4
*.kdev4
.dirstamp
.deps
.libs
#==============================================================================#
# Eclipse files
#==============================================================================#
.wtpmodules
.classpath
.project
.cproject
.pydevproject
.settings
.autotools
/Debug/
/misc/
#==============================================================================#
# Intellij files
#==============================================================================#
.idea
*.iml
#==============================================================================#
# Code Coverage files
#==============================================================================#
*.gcno
*.gcda
#==============================================================================#
# Eclipse
#==============================================================================#
.metadata
bin/
tmp/
*.tmp
*.bak
*.swp
*~.nib
local.properties
.settings/
.loadpath
.recommenders
# Eclipse Core
.project
# External tool builders
.externalToolBuilders/
# Locally stored "Eclipse launch configurations"
*.launch
# PyDev specific (Python IDE for Eclipse)
*.pydevproject
# CDT-specific (C/C++ Development Tooling)
.cproject
# JDT-specific (Eclipse Java Development Tools)
.classpath
# Java annotation processor (APT)
.factorypath
# PDT-specific (PHP Development Tools)
.buildpath
# sbteclipse plugin
.target
# Tern plugin
.tern-project
# TeXlipse plugin
.texlipse
# STS (Spring Tool Suite)
.springBeans
# Code Recommenders
.recommenders/
io_file
## General
# Compiled Object files
*.slo
*.lo
*.o
*.cuo
# Compiled Dynamic libraries
*.so
*.dylib
# Compiled Static libraries
*.lai
*.la
*.a
# Compiled python
*.pyc
# Compiled MATLAB
*.mex*
# IPython notebook checkpoints
.ipynb_checkpoints
# Editor temporaries
*.swp
*~
# Sublime Text settings
*.sublime-workspace
*.sublime-project
# Eclipse Project settings
*.*project
.settings
# Visual Studio
.vs
# QtCreator files
*.user
# PyCharm files
.idea
# OSX dir files
.DS_Store
# User's build configuration
Makefile.config
# build, distribute, and bins (+ python proto bindings)
build
.build_debug/*
.build_release/*
distribute/*
*.testbin
*.bin
cmake_build
.cmake_build
cmake-build-*
# Generated documentation
apidoc/doc
docs/_site
docs/gathered
_site
doxygen
docs/dev
# Config files
*.conf
# Vagrant
.vagrant
# Clangd cache index
.cache
# Submission zip files
*.zip
bustub/._build_support 000755 000765 000024 00000000243 15127067052 016401 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/PaxHeader/build_support 000755 000765 000024 00000000210 15127067052 020127 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665194.061195293
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/build_support/ 000755 000765 000024 00000000000 15127067052 016237 5 ustar 00yanhuang staff 000000 000000 bustub/._.clang-format 000644 000765 000024 00000000243 15127067040 016130 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/PaxHeader/.clang-format 000644 000765 000024 00000000210 15127067040 017656 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665184.258221501
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/.clang-format 000644 000765 000024 00000000361 15127067040 015714 0 ustar 00yanhuang staff 000000 000000 BasedOnStyle: Google
DerivePointerAlignment: false
PointerAlignment: Right
ColumnLimit: 120
# Default for clang-8, changed in later clangs. Set explicitly for forwards
# compatibility for students with modern clangs
IncludeBlocks: Preserve
bustub/._.github 000755 000765 000024 00000000243 15127067051 015045 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/PaxHeader/.github 000755 000765 000024 00000000210 15127067051 016573 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665193.957149544
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/.github/ 000755 000765 000024 00000000000 15127067051 014703 5 ustar 00yanhuang staff 000000 000000 bustub/._.gitattributes 000644 000765 000024 00000000243 15127067040 016450 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/PaxHeader/.gitattributes 000644 000765 000024 00000000210 15127067040 020176 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665184.259576129
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/.gitattributes 000644 000765 000024 00000000022 15127067040 016226 0 ustar 00yanhuang staff 000000 000000 *.slt text eol=lf
bustub/._GRADESCOPE.md.template 000644 000765 000024 00000000243 15127067040 017325 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/PaxHeader/GRADESCOPE.md.template 000644 000765 000024 00000000210 15127067040 021053 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665184.260270255
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/GRADESCOPE.md.template 000644 000765 000024 00000002241 15127067040 017110 0 ustar 00yanhuang staff 000000 000000 To create a fair learning environment for all students and avoid potential Academic Integrity Violations within Carnegie Mellon University, we ask you to sign this short agreement before submitting to Gradescope.
1. I agree NOT to make my solution public. i.e., DO NOT make it public on GitHub or create videos explaining the solution code.
2. I agree NOT to hack Gradescope. i.e., DO NOT retrieve private test cases from Gradescope, or bypass correctness checks.
3. I affirm that the work I submit for assessment is my original work. i.e., DO NOT purchase/copy solution from others.
4. I understand that the course staff does not provide official help for students outside CMU. i.e., DO NOT email the course staff or create GitHub issues for course-related questions. Use the unofficial Discord server.
I understand that if I violate the rules, I will be banned from using Gradescope.
Name:
Affiliation (School/Company):
Email:
GitHub ID:
Date:
I understand that if I provide a fake signature, I will be banned from using Gradescope.
[id]: bustub-non-cmu-gradescope-23333
bustub/._src 000755 000765 000024 00000000243 15127067042 014274 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/PaxHeader/src 000755 000765 000024 00000000210 15127067042 016022 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.742815655
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/ 000755 000765 000024 00000000000 15127067042 014132 5 ustar 00yanhuang staff 000000 000000 bustub/src/._primer 000755 000765 000024 00000000243 15127067042 015572 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/PaxHeader/primer 000755 000765 000024 00000000210 15127067042 017320 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.664846676
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/primer/ 000755 000765 000024 00000000000 15127067042 015430 5 ustar 00yanhuang staff 000000 000000 bustub/src/._CMakeLists.txt 000644 000765 000024 00000000243 15127067042 017106 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/PaxHeader/CMakeLists.txt 000644 000765 000024 00000000210 15127067042 020634 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.665142135
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/CMakeLists.txt 000644 000765 000024 00000002352 15127067042 016674 0 ustar 00yanhuang staff 000000 000000 add_subdirectory(binder)
add_subdirectory(buffer)
add_subdirectory(catalog)
add_subdirectory(common)
add_subdirectory(concurrency)
add_subdirectory(container)
add_subdirectory(execution)
add_subdirectory(recovery)
add_subdirectory(storage)
add_subdirectory(type)
add_subdirectory(planner)
add_subdirectory(primer)
add_subdirectory(optimizer)
add_library(bustub STATIC ${ALL_OBJECT_FILES})
set(BUSTUB_LIBS
bustub_binder
bustub_buffer
bustub_catalog
bustub_common
bustub_concurrency
bustub_execution
bustub_recovery
bustub_type
bustub_container_disk_hash
bustub_storage_disk
bustub_storage_index
bustub_storage_page
bustub_storage_table
bustub_planner
bustub_primer
bustub_optimizer
)
find_package(Threads REQUIRED)
set(BUSTUB_THIRDPARTY_LIBS
bustub_murmur3
duckdb_pg_query
fmt
libfort::fort
Threads::Threads
)
target_link_libraries(
bustub
${BUSTUB_LIBS}
${BUSTUB_THIRDPARTY_LIBS})
target_include_directories(
bustub PUBLIC $
$)
bustub/src/._optimizer 000755 000765 000024 00000000243 15127067042 016316 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/PaxHeader/optimizer 000755 000765 000024 00000000210 15127067042 020044 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.667884309
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/optimizer/ 000755 000765 000024 00000000000 15127067042 016154 5 ustar 00yanhuang staff 000000 000000 bustub/src/._binder 000755 000765 000024 00000000243 15127067042 015537 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/PaxHeader/binder 000755 000765 000024 00000000210 15127067042 017265 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.673464114
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/binder/ 000755 000765 000024 00000000000 15127067042 015375 5 ustar 00yanhuang staff 000000 000000 bustub/src/._planner 000755 000765 000024 00000000243 15127067042 015733 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/PaxHeader/planner 000755 000765 000024 00000000207 15127067042 017467 x ustar 00yanhuang staff 000000 000000 29 mtime=1767665186.67614737
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/planner/ 000755 000765 000024 00000000000 15127067042 015571 5 ustar 00yanhuang staff 000000 000000 bustub/src/._recovery 000755 000765 000024 00000000243 15127067042 016132 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/PaxHeader/recovery 000755 000765 000024 00000000210 15127067042 017660 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.676756497
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/recovery/ 000755 000765 000024 00000000000 15127067042 015770 5 ustar 00yanhuang staff 000000 000000 bustub/src/._include 000755 000765 000024 00000000243 15127067042 015717 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/PaxHeader/include 000755 000765 000024 00000000210 15127067042 017445 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.719588974
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/include/ 000755 000765 000024 00000000000 15127067042 015555 5 ustar 00yanhuang staff 000000 000000 bustub/src/._catalog 000755 000765 000024 00000000243 15127067042 015706 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/PaxHeader/catalog 000755 000765 000024 00000000210 15127067042 017434 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.721680604
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/catalog/ 000755 000765 000024 00000000000 15127067042 015544 5 ustar 00yanhuang staff 000000 000000 bustub/src/._storage 000755 000765 000024 00000000243 15127067042 015740 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/PaxHeader/storage 000755 000765 000024 00000000210 15127067042 017466 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.727652368
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/storage/ 000755 000765 000024 00000000000 15127067042 015576 5 ustar 00yanhuang staff 000000 000000 bustub/src/._container 000755 000765 000024 00000000243 15127067042 016256 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/PaxHeader/container 000755 000765 000024 00000000210 15127067042 020004 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.728846205
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/container/ 000755 000765 000024 00000000000 15127067042 016114 5 ustar 00yanhuang staff 000000 000000 bustub/src/._concurrency 000755 000765 000024 00000000243 15127067042 016626 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/PaxHeader/concurrency 000755 000765 000024 00000000210 15127067042 020354 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.731135002
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/concurrency/ 000755 000765 000024 00000000000 15127067042 016464 5 ustar 00yanhuang staff 000000 000000 bustub/src/._common 000755 000765 000024 00000000243 15127067042 015564 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/PaxHeader/common 000755 000765 000024 00000000210 15127067042 017312 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.732913173
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/common/ 000755 000765 000024 00000000000 15127067042 015422 5 ustar 00yanhuang staff 000000 000000 bustub/src/._type 000755 000765 000024 00000000243 15127067042 015255 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/PaxHeader/type 000755 000765 000024 00000000210 15127067042 017003 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.736162555
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/type/ 000755 000765 000024 00000000000 15127067042 015113 5 ustar 00yanhuang staff 000000 000000 bustub/src/._execution 000755 000765 000024 00000000243 15127067042 016277 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/PaxHeader/execution 000755 000765 000024 00000000210 15127067042 020025 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.742674738
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/execution/ 000755 000765 000024 00000000000 15127067042 016135 5 ustar 00yanhuang staff 000000 000000 bustub/src/._buffer 000755 000765 000024 00000000243 15127067042 015545 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/PaxHeader/buffer 000755 000765 000024 00000000210 15127067042 017273 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.744215283
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/buffer/ 000755 000765 000024 00000000000 15127067042 015403 5 ustar 00yanhuang staff 000000 000000 bustub/src/buffer/._lru_replacer.cpp 000644 000765 000024 00000000243 15127067042 021002 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/buffer/PaxHeader/lru_replacer.cpp 000644 000765 000024 00000000210 15127067042 022530 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.743091322
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/buffer/lru_replacer.cpp 000644 000765 000024 00000001335 15127067042 020570 0 ustar 00yanhuang staff 000000 000000 //===----------------------------------------------------------------------===//
//
// BusTub
//
// lru_replacer.cpp
//
// Identification: src/buffer/lru_replacer.cpp
//
// Copyright (c) 2015-2019, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include "buffer/lru_replacer.h"
namespace bustub {
LRUReplacer::LRUReplacer(size_t num_pages) {}
LRUReplacer::~LRUReplacer() = default;
auto LRUReplacer::Victim(frame_id_t *frame_id) -> bool { return false; }
void LRUReplacer::Pin(frame_id_t frame_id) {}
void LRUReplacer::Unpin(frame_id_t frame_id) {}
auto LRUReplacer::Size() -> size_t { return 0; }
} // namespace bustub
bustub/src/buffer/._CMakeLists.txt 000644 000765 000024 00000000243 15127067042 020357 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/buffer/PaxHeader/CMakeLists.txt 000644 000765 000024 00000000210 15127067042 022105 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.743361739
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/buffer/CMakeLists.txt 000644 000765 000024 00000000412 15127067042 020140 0 ustar 00yanhuang staff 000000 000000 add_library(
bustub_buffer
OBJECT
buffer_pool_manager.cpp
clock_replacer.cpp
lru_replacer.cpp
lru_k_replacer.cpp)
set(ALL_OBJECT_FILES
${ALL_OBJECT_FILES} $
PARENT_SCOPE)
bustub/src/buffer/._buffer_pool_manager.cpp 000644 000765 000024 00000000243 15127067042 022317 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/buffer/PaxHeader/buffer_pool_manager.cpp 000644 000765 000024 00000000210 15127067042 024045 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.743631073
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/buffer/buffer_pool_manager.cpp 000644 000765 000024 00000127265 15127067042 022120 0 ustar 00yanhuang staff 000000 000000 //===----------------------------------------------------------------------===//
//
// BusTub
//
// buffer_pool_manager.cpp
//
// Identification: src/buffer/buffer_pool_manager.cpp
//
// Copyright (c) 2015-2024, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "common/config.h"
#include "common/logger.h"
#include "common/macros.h"
#include "fmt/core.h"
#include "buffer/buffer_pool_manager.h"
#include "buffer/lru_k_replacer.h"
#include "storage/page/page_guard.h"
namespace bustub {
/**
* @brief The constructor for a `FrameHeader` that initializes all fields to default values.
*
* See the documentation for `FrameHeader` in "buffer/buffer_pool_manager.h" for more information.
*
* @param frame_id The frame ID / index of the frame we are creating a header for.
*/
FrameHeader::FrameHeader(frame_id_t frame_id) : frame_id_(frame_id), data_(BUSTUB_PAGE_SIZE, 0) { Reset(); }
/**
* @brief Get a raw const pointer to the frame's data.
*
* @return const char* A pointer to immutable data that the frame stores.
*/
auto FrameHeader::GetData() const -> const char * { return data_.data(); }
/**
* @brief Get a raw mutable pointer to the frame's data.
*
* @return char* A pointer to mutable data that the frame stores.
*/
auto FrameHeader::GetDataMut() -> char * { return data_.data(); }
/**
* @brief Resets a `FrameHeader`'s member fields.
*/
void FrameHeader::Reset() {
pin_count_.store(0);
is_dirty_ = false;
page_id_ = INVALID_PAGE_ID;
}
/**
* @brief Creates a new `BasicBufferPoolManager` instance and initializes all fields.
*
* See the documentation for `BasicBufferPoolManager` in "buffer/buffer_pool_manager.h" for more information.
*
* ### Implementation
*
* We have implemented the constructor for you in a way that makes sense with our reference solution. You are free to
* change anything you would like here if it doesn't fit with you implementation.
*
* Be warned, though! If you stray too far away from our guidance, it will be much harder for us to help you. Our
* recommendation would be to first implement the buffer pool manager using the stepping stones we have provided.
*
* Once you have a fully working solution (all Gradescope test cases pass), then you can try more interesting things!
*
* @param num_frames The size of the buffer pool.
* @param disk_manager The disk manager.
* @param k_dist The backward k-distance for the LRU-K replacer.
* @param log_manager The log manager. Please ignore this for P1.
*/
BasicBufferPoolManager::BasicBufferPoolManager(size_t num_frames, DiskManager *disk_manager, size_t k_dist,
LogManager *log_manager)
: num_frames_(num_frames),
next_page_id_(0),
bpm_latch_(std::make_shared()),
replacer_(std::make_shared(num_frames, k_dist)),
frames_cv_(std::make_shared()),
disk_scheduler_(std::make_unique(disk_manager)),
log_manager_(log_manager) {
// Not strictly necessary...
std::scoped_lock latch(*bpm_latch_);
// Initialize the monotonically increasing counter at 0.
next_page_id_.store(0);
// Allocate all of the in-memory frames up front.
frames_.reserve(num_frames_);
// The page table should have exactly `num_frames_` slots, corresponding to exactly `num_frames_` frames.
page_table_.reserve(num_frames_);
// Initialize all of the frame headers, and fill the free frame list with all possible frame IDs (since all frames are
// initially free).
for (size_t i = 0; i < num_frames_; i++) {
frames_.push_back(std::make_shared(i));
free_frames_.push(static_cast(i));
}
}
std::shared_ptr BasicBufferPoolManager::GetMappedFrameLocked(page_id_t page_id) {
LatchOwnerRecorder record(this, __func__);
auto iter = page_table_.find(page_id);
// if the page is mapped
if (iter != page_table_.end()) {
auto frame_id = iter->second;
auto header = frames_[frame_id];
BUSTUB_ENSURE(header->page_id_ == page_id, "Unexpected page_id");
BUSTUB_ENSURE((size_t)frame_id < num_frames_, "Invalid frame_id");
return header;
}
// if not mapped, simply return null
return nullptr;
}
/**
* @brief Returns the number of frames that this buffer pool manages.
*/
auto BasicBufferPoolManager::Size() const -> size_t { return num_frames_; }
void BasicBufferPoolManager::WaitForPageReady(std::unique_lock &lck, page_id_t page_id) {
io_cv_.wait(lck, [page_id, this]() { return io_pages_.count(page_id) == 0; });
}
void BasicBufferPoolManager::MarkPageBusyLocked(page_id_t page_id) { io_pages_.insert(page_id); }
void BasicBufferPoolManager::MarkPageReadyLocked(page_id_t page_id) {
BUSTUB_ENSURE(io_pages_.count(page_id), "page_id not in IO status");
io_pages_.erase(page_id);
io_cv_.notify_all();
}
/**
* @brief Allocates a new page on disk.
*
* ### Implementation
*
* You will maintain a thread-safe, monotonically increasing counter in the form of a `std::atomic`.
* See the documentation on [atomics](https://en.cppreference.com/w/cpp/atomic/atomic) for more information.
*
* Also, make sure to read the documentation for `DeletePage`! You can assume that you will never run out of disk
* space (via `DiskScheduler::IncreaseDiskSpace`), so this function _cannot_ fail.
*
* Once you have allocated the new page via the counter, make sure to call `DiskScheduler::IncreaseDiskSpace` so you
* have enough space on disk!
*
*
* @return The page ID of the newly allocated page.
*/
auto BasicBufferPoolManager::NewPage() -> page_id_t {
GlobalLock lck(*bpm_latch_, this, __func__);
if (free_pages_.empty()) {
auto page_id = next_page_id_++;
// this is lock protected in disk manager
disk_scheduler_->IncreaseDiskSpace(page_id);
return page_id;
} else {
auto page_id = free_pages_.front();
free_pages_.pop();
return page_id;
}
}
/**
* @brief Removes a page from the database, both on disk and in memory.
* means we no longer care about the data stored in this page and its frame.
*
* If the page is pinned in the buffer pool, this function does nothing and returns `false`. Otherwise, this function
* removes the page from both disk and memory (if it is still in the buffer pool), returning `true`.
*
* ### Implementation
*
* Think about all of the places a page or a page's metadata could be, and use that to guide you on implementing this
* function. You will probably want to implement this function _after_ you have implemented `CheckedReadPage` and
* `CheckedWritePage`.
*
* Ideally, we would want to ensure that all space on disk is used efficiently. That would mean the space that deleted
* pages on disk used to occupy should somehow be made available to new pages allocated by `NewPage`.
*
* If you would like to attempt this, you are free to do so. However, for this implementation, you are allowed to
* assume you will not run out of disk space and simply keep allocating disk space upwards in `NewPage`.
*
* For (nonexistent) style points, you can still call `DeallocatePage` in case you want to implement something slightly
* more space-efficient in the future.
*
* @param page_id The page ID of the page we want to delete.
* @return `false` if the page exists but could not be deleted, `true` if the page didn't exist or deletion succeeded.
*/
auto BasicBufferPoolManager::DeletePage(page_id_t page_id) -> bool {
GlobalLock lck(*bpm_latch_, this, __func__);
WaitForPageReady(lck, page_id);
auto frame_hdr = GetMappedFrameLocked(page_id);
// if not mapped, return true
if (!frame_hdr) {
disk_scheduler_->DeallocatePage(page_id);
free_pages_.push(page_id);
return true;
}
// if the page mapped and pinned, return false
if (frame_hdr->pin_count_ > 0) return false;
if (frame_hdr->is_dirty_) {
MarkPageBusyLocked(page_id);
FlushPageToDiskAsyncLocked(frame_hdr, [this, page_id, scheduler = disk_scheduler_.get()]() {
// we can't guarantee `disk_scheduler_` member is still valid when this callback is executed
// but other members will be, as this is the first member to destroy
scheduler->DeallocatePage(page_id);
GlobalLock lck(*bpm_latch_, this, __func__);
// recycle the page disk space
free_pages_.push(page_id);
MarkPageReadyLocked(page_id);
});
} else {
disk_scheduler_->DeallocatePage(page_id);
free_pages_.push(page_id);
}
// remove the page <=> frame mapping
page_table_.erase(page_id);
// clean records in replacer
// this ensure no one get this frame until later we recycle it
replacer_->Remove(frame_hdr->frame_id_);
// put the frame back in free-list
frame_hdr->Reset();
free_frames_.push(frame_hdr->frame_id_);
frames_cv_->notify_one();
return true;
}
std::shared_ptr BasicBufferPoolManager::AllocFrameLocked(std::unique_lock &lck, bool wait_for_page) {
LatchOwnerRecorder record(this, __func__);
if (wait_for_page) {
frames_cv_->wait_for(lck, std::chrono::seconds(3),
[this]() { return !free_frames_.empty() || replacer_->Size() > 0; });
}
if (!free_frames_.empty()) {
// simply get a free frame
auto frame_id = free_frames_.front();
free_frames_.pop();
return frames_[frame_id];
}
// find a new frame by LRU replacer
auto frame_id_opt = replacer_->Evict();
evict_counter_++;
if (!frame_id_opt.has_value()) {
// we will only fail the request after waiting for 3 seconds
return nullptr;
}
auto frame_hdr = frames_[frame_id_opt.value()];
auto page_id = frame_hdr->page_id_;
WaitForPageReady(lck, page_id);
// async flush the page if it's dirty
if (frame_hdr->is_dirty_) {
MarkPageBusyLocked(page_id);
FlushPageToDiskAsyncLocked(frame_hdr, [this, page_id]() {
GlobalLock lck(*bpm_latch_, this, __func__);
MarkPageReadyLocked(page_id);
});
}
// clean existing page_id <=> frame_id mapping
page_table_.erase(page_id);
frame_hdr->Reset();
return frame_hdr;
}
std::shared_ptr BasicBufferPoolManager::PrepareFrameForPageLocked(std::unique_lock &lck, page_id_t page_id, AccessType access_type, bool &load_page, bool wait_for_page) {
LatchOwnerRecorder record(this, __func__);
BUSTUB_ENSURE(page_id != INVALID_PAGE_ID, "Invalid page ID");
WaitForPageReady(lck, page_id);
load_page = false;
auto frame_hdr = GetMappedFrameLocked(page_id);
// if the page already mapped, simply return header
if (frame_hdr) return frame_hdr;
// if the page is not mapped, try find a frame
frame_hdr = AllocFrameLocked(lck, wait_for_page);
if (!frame_hdr) return frame_hdr;
// build the mapping
frame_hdr->SetPageID(page_id);
page_table_[page_id] = frame_hdr->frame_id_;
MarkPageBusyLocked(page_id);
load_page = true;
return frame_hdr;
}
void BasicBufferPoolManager::PinFrameLocked(std::shared_ptr frame_hdr, AccessType access_type) {
LatchOwnerRecorder record(this, __func__);
if (frame_hdr->pin_count_++ == 0)
replacer_->SetEvictable(frame_hdr->frame_id_, false);
}
void BasicBufferPoolManager::LoadPageToFrame(std::shared_ptr frame_hdr, page_id_t page_id, bool load_page) {
replacer_->RecordAccess(frame_hdr->frame_id_);
if (!load_page) return;
auto promise = disk_scheduler_->CreatePromise();
auto future = promise.get_future();
disk_scheduler_->Schedule(DiskRequest{false, frame_hdr->GetDataMut(), page_id, std::move(promise)});
future.get();
GlobalLock lck(*bpm_latch_, this, __func__);
MarkPageReadyLocked(page_id);
}
/**
* @brief Acquires an optional write-locked guard over a page of data. The user can specify an `AccessType` if needed.
*
* If it is not possible to bring the page of data into memory, this function will return a `std::nullopt`.
*
* Page data can _only_ be accessed via page guards. Users of this `BasicBufferPoolManager` are expected to acquire either a
* `ReadPageGuard` or a `WritePageGuard` depending on the mode in which they would like to access the data, which
* ensures that any access of data is thread-safe.
*
* There can only be 1 `WritePageGuard` reading/writing a page at a time. This allows data access to be both immutable
* and mutable, meaning the thread that owns the `WritePageGuard` is allowed to manipulate the page's data however they
* want. If a user wants to have multiple threads reading the page at the same time, they must acquire a `ReadPageGuard`
* with `CheckedReadPage` instead.
*
* ### Implementation
*
* There are 3 main cases that you will have to implement. The first two are relatively simple: one is when there is
* plenty of available memory, and the other is when we don't actually need to perform any additional I/O. Think about
* what exactly these two cases entail.
*
* The third case is the trickiest, and it is when we do not have any _easily_ available memory at our disposal. The
* buffer pool is tasked with finding memory that it can use to bring in a page of memory, using the replacement
* algorithm you implemented previously to find candidate frames for eviction.
*
* Once the buffer pool has identified a frame for eviction, several I/O operations may be necessary to bring in the
* page of data we want into the frame.
*
* There is likely going to be a lot of shared code with `CheckedReadPage`, so you may find creating helper functions
* useful.
*
* These two functions are the crux of this project, so we won't give you more hints than this. Good luck!
*
*
* @param page_id The ID of the page we want to write to.
* @param access_type The type of page access.
* @return std::optional An optional latch guard where if there are no more free frames (out of memory)
* returns `std::nullopt`, otherwise returns a `WritePageGuard` ensuring exclusive and mutable access to a page's data.
*/
auto BasicBufferPoolManager::CheckedWritePage(page_id_t page_id, AccessType access_type, bool wait_for_page) -> std::optional {
#ifdef DEBUG
write_counter_++;
#endif
bool load_page = false;
std::shared_ptr frame_hdr;
CheckLatchOwner();
{
GlobalLock lck(*bpm_latch_, this, __func__);
frame_hdr = PrepareFrameForPageLocked(lck, page_id, access_type, load_page, wait_for_page);
if (!frame_hdr) return std::nullopt;
frame_hdr->is_dirty_ = true;
PinFrameLocked(frame_hdr, access_type);
}
LoadPageToFrame(frame_hdr, page_id, load_page);
return WritePageGuard(page_id, frame_hdr, replacer_, bpm_latch_, frames_cv_);
}
/**
* @brief Acquires an optional read-locked guard over a page of data. The user can specify an `AccessType` if needed.
*
* If it is not possible to bring the page of data into memory, this function will return a `std::nullopt`.
*
* Page data can _only_ be accessed via page guards. Users of this `BasicBufferPoolManager` are expected to acquire either a
* `ReadPageGuard` or a `WritePageGuard` depending on the mode in which they would like to access the data, which
* ensures that any access of data is thread-safe.
*
* There can be any number of `ReadPageGuard`s reading the same page of data at a time across different threads.
* However, all data access must be immutable. If a user wants to mutate the page's data, they must acquire a
* `WritePageGuard` with `CheckedWritePage` instead.
*
* ### Implementation
*
* See the implementation details of `CheckedWritePage`.
*
*
* @param page_id The ID of the page we want to read.
* @param access_type The type of page access.
* @return std::optional An optional latch guard where if there are no more free frames (out of memory)
* returns `std::nullopt`, otherwise returns a `ReadPageGuard` ensuring shared and read-only access to a page's data.
*/
auto BasicBufferPoolManager::CheckedReadPage(page_id_t page_id, AccessType access_type, bool wait_for_page) -> std::optional {
#ifdef DEBUG
read_counter_++;
#endif
bool load_page = false;
std::shared_ptr frame_hdr;
CheckLatchOwner();
{
GlobalLock lck(*bpm_latch_, this, __func__);
frame_hdr = PrepareFrameForPageLocked(lck, page_id, access_type, load_page, wait_for_page);
if (!frame_hdr) return std::nullopt;
PinFrameLocked(frame_hdr, access_type);
}
LoadPageToFrame(frame_hdr, page_id, load_page);
return ReadPageGuard(page_id, frame_hdr, replacer_, bpm_latch_, frames_cv_);
}
/**
* @brief A wrapper around `CheckedWritePage` that unwraps the inner value if it exists.
*
* If `CheckedWritePage` returns a `std::nullopt`, **this function aborts the entire process.**
*
* This function should **only** be used for testing and ergonomic's sake. If it is at all possible that the buffer pool
* manager might run out of memory, then use `CheckedPageWrite` to allow you to handle that case.
*
* See the documentation for `CheckedPageWrite` for more information about implementation.
*
* @param page_id The ID of the page we want to read.
* @param access_type The type of page access.
* @return WritePageGuard A page guard ensuring exclusive and mutable access to a page's data.
*/
auto BasicBufferPoolManager::WritePage(page_id_t page_id, AccessType access_type) -> WritePageGuard {
auto guard_opt = CheckedWritePage(page_id, access_type, true);
if (!guard_opt.has_value()) {
fmt::println(stderr, "\n`CheckedWritePage` failed to bring in page {}\n", page_id);
std::abort();
}
return std::move(guard_opt).value();
}
/**
* @brief A wrapper around `CheckedReadPage` that unwraps the inner value if it exists.
*
* If `CheckedReadPage` returns a `std::nullopt`, **this function aborts the entire process.**
*
* This function should **only** be used for testing and ergonomic's sake. If it is at all possible that the buffer pool
* manager might run out of memory, then use `CheckedPageWrite` to allow you to handle that case.
*
* See the documentation for `CheckedPageRead` for more information about implementation.
*
* @param page_id The ID of the page we want to read.
* @param access_type The type of page access.
* @return ReadPageGuard A page guard ensuring shared and read-only access to a page's data.
*/
auto BasicBufferPoolManager::ReadPage(page_id_t page_id, AccessType access_type) -> ReadPageGuard {
auto guard_opt = CheckedReadPage(page_id, access_type, true);
if (!guard_opt.has_value()) {
fmt::println(stderr, "\n`CheckedReadPage` failed to bring in page {}\n", page_id);
std::abort();
}
return std::move(guard_opt).value();
}
void BasicBufferPoolManager::FlushPageToDiskAsyncLocked(std::shared_ptr hdr, std::function callback) {
std::shared_ptr buf;
if (io_buffer_.empty()) {
buf = std::make_shared();
} else {
buf = io_buffer_.front();
io_buffer_.pop();
}
std::memcpy(buf->data(), hdr->GetData(), BUSTUB_PAGE_SIZE);
auto promise = disk_scheduler_->CreatePromise();
auto future = promise.get_future();
// buffer must be captured to ensure its memory always valid and then put it back to pool
auto callback_wrapper = [buf, callback, this]() {
callback();
GlobalLock lck(*bpm_latch_, this, __func__);
io_buffer_.push(buf);
};
disk_scheduler_->Schedule(DiskRequest{true, buf->data(), hdr->page_id_, std::move(promise), callback_wrapper});
}
/**
* @brief Flushes a page's data out to disk.
*
* This function will write out a page's data to disk if it has been modified. If the given page is not in memory, this
* function will return `false`.
*
* ### Implementation
*
* You should probably leave implementing this function until after you have completed `CheckedReadPage` and
* `CheckedWritePage`, as it will likely be much easier to understand what to do.
*
*
* @param page_id The page ID of the page to be flushed.
* @return `false` if the page could not be found in the page table, otherwise `true`.
*/
auto BasicBufferPoolManager::FlushPage(page_id_t page_id) -> bool {
auto promise = disk_scheduler_->CreatePromise();
auto future = promise.get_future();
{
GlobalLock lck(*bpm_latch_, this, __func__);
WaitForPageReady(lck, page_id);
auto frame_hdr = GetMappedFrameLocked(page_id);
if (!frame_hdr) return false;
if (!frame_hdr->is_dirty_) return true;
frame_hdr->is_dirty_ = false;
MarkPageBusyLocked(page_id);
disk_scheduler_->Schedule(DiskRequest{true, frame_hdr->GetDataMut(), page_id, std::move(promise)});
}
{
future.get();
GlobalLock lck(*bpm_latch_, this, __func__);
MarkPageReadyLocked(page_id);
}
return true;
}
/**
* @brief Flushes all page data that is in memory to disk.
*
* ### Implementation
*
* You should probably leave implementing this function until after you have completed `CheckedReadPage`,
* `CheckedWritePage`, and `FlushPage`, as it will likely be much easier to understand what to do.
*
*/
void BasicBufferPoolManager::FlushAllPages() {
// for all pages in system, if it's in IO pending, could only be:
// 1. being flushed into disk
// 2. being load into disk due to Read/Write
// in either case, we can skip and don't have to wait to flush them
std::vector, page_id_t>> futures;
{
GlobalLock lck(*bpm_latch_, this, __func__);
for (auto [page_id, frame_id] : page_table_) {
auto frame_hdr = frames_[frame_id];
if (frame_hdr->is_dirty_ && io_pages_.count(page_id) == 0) {
frame_hdr->is_dirty_ = false;
MarkPageBusyLocked(page_id);
auto promise = disk_scheduler_->CreatePromise();
futures.emplace_back(make_pair(promise.get_future(), page_id));
disk_scheduler_->Schedule(DiskRequest{true, frame_hdr->GetDataMut(), page_id, std::move(promise)});
}
}
}
for (auto &[future, page_id] : futures) {
future.get();
GlobalLock lck(*bpm_latch_, this, __func__);
MarkPageReadyLocked(page_id);
}
}
/**
* @brief Retrieves the pin count of a page. If the page does not exist in memory, return `std::nullopt`.
*
* This function is thread safe. Callers may invoke this function in a multi-threaded environment where multiple threads
* access the same page.
*
* This function is intended for testing purposes. If this function is implemented incorrectly, it will definitely cause
* problems with the test suite and autograder.
*
* # Implementation
*
* We will use this function to test if your buffer pool manager is managing pin counts correctly. Since the
* `pin_count_` field in `FrameHeader` is an atomic type, you do not need to take the latch on the frame that holds the
* page we want to look at. Instead, you can simply use an atomic `load` to safely load the value stored. You will still
* need to take the buffer pool latch, however.
*
* Again, if you are unfamiliar with atomic types, see the official C++ docs
* [here](https://en.cppreference.com/w/cpp/atomic/atomic).
*
*
* @param page_id The page ID of the page we want to get the pin count of.
* @return std::optional The pin count if the page exists, otherwise `std::nullopt`.
*/
auto BasicBufferPoolManager::GetPinCount(page_id_t page_id) -> std::optional {
GlobalLock lck(*bpm_latch_, this, __func__);
auto frame_hdr = GetMappedFrameLocked(page_id);
if (!frame_hdr) return std::nullopt;
return frame_hdr->pin_count_.load();
}
auto BasicBufferPoolManager::CheckLatchOwner() -> void {
#ifdef DEBUG
std::scoped_lock lck(counter_latch_);
auto owner = latch_owner_.load();
if (owner != nullptr) {
latch_owner_counter_[owner]++;
}
#endif
}
/**
* @brief Destroys the `BasicBufferPoolManager`, freeing up all memory that the buffer pool was using.
*/
BasicBufferPoolManager::~BasicBufferPoolManager() {
}
/**
* @brief Creates a new `AdvBufferPoolManager` instance and initializes all fields.
*
* See the documentation for `AdvBufferPoolManager` in "buffer/buffer_pool_manager.h" for more information.
*
* ### Implementation
*
* We have implemented the constructor for you in a way that makes sense with our reference solution. You are free to
* change anything you would like here if it doesn't fit with you implementation.
*
* Be warned, though! If you stray too far away from our guidance, it will be much harder for us to help you. Our
* recommendation would be to first implement the buffer pool manager using the stepping stones we have provided.
*
* Once you have a fully working solution (all Gradescope test cases pass), then you can try more interesting things!
*
* @param num_frames The size of the buffer pool.
* @param disk_manager The disk manager.
* @param k_dist The backward k-distance for the LRU-K replacer.
* @param log_manager The log manager. Please ignore this for P1.
*/
AdvBufferPoolManager::AdvBufferPoolManager(size_t num_frames, DiskManager *disk_manager, size_t k_dist, LogManager *log_manager)
: BasicBufferPoolManager(num_frames, disk_manager, k_dist, log_manager) {
for (auto &page_table: page_table_) {
page_table.reserve(num_frames_);
}
}
std::shared_ptr AdvBufferPoolManager::GetMappedFrameLocked(page_id_t page_id) {
auto &page_table = page_table_[page_id % NUM_PARTITIONS];
auto iter = page_table.find(page_id);
// if the page is mapped
if (iter != page_table.end()) {
auto frame_id = iter->second;
auto header = frames_[frame_id];
BUSTUB_ENSURE(header->page_id_ == page_id, "Unexpected page_id");
BUSTUB_ENSURE((size_t)frame_id < num_frames_, "Invalid frame_id");
return header;
}
// if not mapped, simply return null
return nullptr;
}
void AdvBufferPoolManager::WaitForPageReady(std::unique_lock &partition, page_id_t page_id) {
const auto idx = page_id % NUM_PARTITIONS;
io_cv_[idx].wait(partition, [page_id, idx, this]() { return io_pages_[idx].count(page_id) == 0; });
}
void AdvBufferPoolManager::MarkPageBusyLocked(page_id_t page_id) {
const auto idx = page_id % NUM_PARTITIONS;
BUSTUB_ENSURE(io_pages_[idx].count(page_id) == 0, "page_id already in IO status");
io_pages_[idx].insert(page_id);
}
void AdvBufferPoolManager::MarkPageReadyLocked(page_id_t page_id) {
const auto idx = page_id % NUM_PARTITIONS;
BUSTUB_ENSURE(io_pages_[idx].count(page_id), "page_id not in IO status");
io_pages_[idx].erase(page_id);
io_cv_[idx].notify_all();
}
/**
* @brief Removes a page from the database, both on disk and in memory.
* means we no longer care about the data stored in this page and its frame.
*
* If the page is pinned in the buffer pool, this function does nothing and returns `false`. Otherwise, this function
* removes the page from both disk and memory (if it is still in the buffer pool), returning `true`.
*
* ### Implementation
*
* Think about all of the places a page or a page's metadata could be, and use that to guide you on implementing this
* function. You will probably want to implement this function _after_ you have implemented `CheckedReadPage` and
* `CheckedWritePage`.
*
* Ideally, we would want to ensure that all space on disk is used efficiently. That would mean the space that deleted
* pages on disk used to occupy should somehow be made available to new pages allocated by `NewPage`.
*
* If you would like to attempt this, you are free to do so. However, for this implementation, you are allowed to
* assume you will not run out of disk space and simply keep allocating disk space upwards in `NewPage`.
*
* For (nonexistent) style points, you can still call `DeallocatePage` in case you want to implement something slightly
* more space-efficient in the future.
*
* @param page_id The page ID of the page we want to delete.
* @return `false` if the page exists but could not be deleted, `true` if the page didn't exist or deletion succeeded.
*/
auto AdvBufferPoolManager::DeletePage(page_id_t page_id) -> bool {
const auto idx = page_id % NUM_PARTITIONS;
std::unique_lock partition(latches_[idx]);
WaitForPageReady(partition, page_id);
auto frame_hdr = GetMappedFrameLocked(page_id);
// if not mapped, return true
if (!frame_hdr) {
disk_scheduler_->DeallocatePage(page_id);
free_pages_.push(page_id);
return true;
}
// if the page mapped and pinned, return false
if (frame_hdr->pin_count_ > 0) return false;
// seems that we can delete the mapping to reuse the frame
// but we have to acquire the global lock as soon as possible
GlobalLock global(*bpm_latch_, this, __func__);
// although this frame is not pinned and can be evicted and took by someone else, the new owner can not acquire partition lock on victim page_id
// thus it won't be able to update `frame_hdr` to map it to new page_id
BUSTUB_ENSURE(frame_hdr->page_id_ == page_id, "Unexpected: frame mapped to different page_id");
// but it is possible some other thread has pinned this frame again, so we have to double check after acquired global lock
if (frame_hdr->pin_count_ > 0) return false;
// now we have TRUE ownership of this frame
// and guarantees no one else is writing to the frame data, thus we can safely copy it for async IO
if (frame_hdr->is_dirty_) {
MarkPageBusyLocked(page_id);
FlushPageToDiskAsync(frame_hdr, [this, page_id, scheduler = disk_scheduler_.get()]() {
// we can't guarantee `disk_scheduler_` member is still valid when this callback is executed
// but other members will be, as this is the first member to destroy
scheduler->DeallocatePage(page_id);
{
std::scoped_lock partition(latches_[page_id % NUM_PARTITIONS]);
MarkPageReadyLocked(page_id);
}
{
// recycle the page disk space
GlobalLock global(*bpm_latch_, this, __func__);
free_pages_.push(page_id);
}
});
} else {
disk_scheduler_->DeallocatePage(page_id);
free_pages_.push(page_id);
}
// remove the page <=> frame mapping
frame_hdr->Reset();
page_table_[idx].erase(page_id);
// clean records in replacer
// this ensure no one get this frame until later we recycle it
replacer_->Remove(frame_hdr->frame_id_);
// put the frame back in free-list
free_frames_.push(frame_hdr->frame_id_);
frames_cv_->notify_one();
return true;
}
std::shared_ptr AdvBufferPoolManager::AllocFrame(bool &timeout, bool wait_for_page) {
GlobalLock global(*bpm_latch_, this, __func__);
if (wait_for_page) {
frames_cv_->wait_for(global, std::chrono::seconds(3),
[this]() { return !free_frames_.empty() || replacer_->Size() > 0; });
}
if (!free_frames_.empty()) {
// simply get a free frame
auto frame_id = free_frames_.front(); free_frames_.pop();
auto frame_hdr = frames_[frame_id];
if (frame_hdr->pin_count_++ == 0) {
replacer_->SetEvictable(frame_hdr->frame_id_, false);
}
return frame_hdr;
}
// find a new frame by LRU replacer
auto frame_id_opt = replacer_->Evict();
evict_counter_++;
if (!frame_id_opt.has_value()) {
// we will only fail the request after waiting for 3 seconds
timeout = true;
return nullptr;
}
auto frame_hdr = frames_[frame_id_opt.value()];
auto page_id = frame_hdr->page_id_;
BUSTUB_ENSURE(page_id != INVALID_PAGE_ID, "Unexpected: invalid page_id");
auto idx = page_id % NUM_PARTITIONS;
TryLockGuard victim_lock(latches_[idx]);
if (victim_lock) {
// if the page to be evicted is in IO progress, we have to give up
if (io_pages_[idx].count(page_id)) {
replacer_->SetEvictable(frame_hdr->frame_id_, true);
frames_cv_->notify_all();
return nullptr;
}
// async flush the page if it's dirty
if (frame_hdr->is_dirty_) {
MarkPageBusyLocked(page_id);
FlushPageToDiskAsync(frame_hdr, [this, page_id]() {
std::scoped_lock lck(latches_[page_id % NUM_PARTITIONS]);
MarkPageReadyLocked(page_id);
});
}
// clean existing page_id <=> frame_id mapping
page_table_[idx].erase(page_id);
frame_hdr->Reset();
frame_hdr->pin_count_++;
replacer_->SetEvictable(frame_hdr->frame_id_, false);
return frame_hdr;
} else {
replacer_->SetEvictable(frame_hdr->frame_id_, true);
frames_cv_->notify_all();
return nullptr;
}
}
std::shared_ptr AdvBufferPoolManager::PrepareFrameForPage(page_id_t page_id, AccessType access_type, bool &load_page, bool is_write, bool wait_for_page) {
BUSTUB_ENSURE(page_id != INVALID_PAGE_ID, "Invalid page ID");
const auto idx = page_id % NUM_PARTITIONS;
auto &page_table = page_table_[idx];
std::shared_ptr frame_hdr;
std::shared_ptr defer(nullptr, [&](void *) {
if (is_write && frame_hdr != nullptr) {
frame_hdr->is_dirty_ = true;
}
});
restart:
{
std::unique_lock partition(latches_[idx]);
// Wait for any pending IO on this page to finish before proceeding.
// Returning a frame with unfinished IO may cause data races or inconsistent data.
WaitForPageReady(partition, page_id);
while (true) {
frame_hdr = GetMappedFrameLocked(page_id);
// if the page already mapped, we have to try to pin it first
// it not guaranteed to succeed as we only hold partial lock
if (frame_hdr) {
// if the frame is already pinned, we can return
auto old_pin_count = frame_hdr->pin_count_.load();
if (old_pin_count > 0) {
if (frame_hdr->pin_count_.compare_exchange_strong(old_pin_count, old_pin_count + 1)) {
return std::shared_ptr(frame_hdr);
}
} else {
// we have to up grade to global lock and check this Frame still valid to us
GlobalLock global(*bpm_latch_, this, __func__);
if (frame_hdr->page_id_ == page_id && frame_hdr->pin_count_ == 0) {
replacer_->SetEvictable(frame_hdr->frame_id_, false);
frame_hdr->pin_count_++;
return std::shared_ptr(frame_hdr);
}
}
} else {
break;
}
}
}
// if the page is not mapped, try find a frame
while (true) {
bool timeout = false;
frame_hdr = AllocFrame(timeout, wait_for_page);
if (frame_hdr) {
break;
} else {
if (timeout) return nullptr;
}
}
{
std::unique_lock partition(latches_[idx]);
WaitForPageReady(partition, page_id);
// if we find someone else already moved the page in
if (page_table.find(page_id) != page_table.end()) {
GlobalLock global(*bpm_latch_, this, __func__);
// this should always be true but no harm to double check
BUSTUB_ENSURE(--frame_hdr->pin_count_ == 0, "new allocated frame should only have pin_count=1");
replacer_->SetEvictable(frame_hdr->frame_id_, true);
replacer_->Remove(frame_hdr->frame_id_);
free_frames_.push(frame_hdr->frame_id_);
frames_cv_->notify_all();
goto restart;
}
// build the mapping
frame_hdr->SetPageID(page_id);
page_table[page_id] = frame_hdr->frame_id_;
MarkPageBusyLocked(page_id);
load_page = true;
return std::shared_ptr(frame_hdr);
}
}
void AdvBufferPoolManager::LoadPageToFrame(std::shared_ptr frame_hdr, page_id_t page_id, bool load_page) {
BUSTUB_ENSURE(frame_hdr->page_id_ == page_id, "page_id mismatch");
replacer_->RecordAccess(frame_hdr->frame_id_);
if (!load_page) return;
auto promise = disk_scheduler_->CreatePromise();
auto future = promise.get_future();
disk_scheduler_->Schedule(DiskRequest{false, frame_hdr->GetDataMut(), page_id, std::move(promise)});
future.get();
std::scoped_lock partition(latches_[page_id % NUM_PARTITIONS]);
MarkPageReadyLocked(page_id);
}
/**
* @brief Acquires an optional write-locked guard over a page of data. The user can specify an `AccessType` if needed.
*
* If it is not possible to bring the page of data into memory, this function will return a `std::nullopt`.
*
* Page data can _only_ be accessed via page guards. Users of this `AdvBufferPoolManager` are expected to acquire either a
* `ReadPageGuard` or a `WritePageGuard` depending on the mode in which they would like to access the data, which
* ensures that any access of data is thread-safe.
*
* There can only be 1 `WritePageGuard` reading/writing a page at a time. This allows data access to be both immutable
* and mutable, meaning the thread that owns the `WritePageGuard` is allowed to manipulate the page's data however they
* want. If a user wants to have multiple threads reading the page at the same time, they must acquire a `ReadPageGuard`
* with `CheckedReadPage` instead.
*
* ### Implementation
*
* There are 3 main cases that you will have to implement. The first two are relatively simple: one is when there is
* plenty of available memory, and the other is when we don't actually need to perform any additional I/O. Think about
* what exactly these two cases entail.
*
* The third case is the trickiest, and it is when we do not have any _easily_ available memory at our disposal. The
* buffer pool is tasked with finding memory that it can use to bring in a page of memory, using the replacement
* algorithm you implemented previously to find candidate frames for eviction.
*
* Once the buffer pool has identified a frame for eviction, several I/O operations may be necessary to bring in the
* page of data we want into the frame.
*
* There is likely going to be a lot of shared code with `CheckedReadPage`, so you may find creating helper functions
* useful.
*
* These two functions are the crux of this project, so we won't give you more hints than this. Good luck!
*
*
* @param page_id The ID of the page we want to write to.
* @param access_type The type of page access.
* @return std::optional An optional latch guard where if there are no more free frames (out of memory)
* returns `std::nullopt`, otherwise returns a `WritePageGuard` ensuring exclusive and mutable access to a page's data.
*/
auto AdvBufferPoolManager::CheckedWritePage(page_id_t page_id, AccessType access_type, bool wait_for_page) -> std::optional {
#ifdef DEBUG
write_counter_++;
#endif
bool load_page = false;
CheckLatchOwner();
auto frame_hdr = PrepareFrameForPage(page_id, access_type, load_page, true, wait_for_page);
if (!frame_hdr) return std::nullopt;
LoadPageToFrame(frame_hdr, page_id, load_page);
return WritePageGuard(page_id, frame_hdr, replacer_, bpm_latch_, frames_cv_);
}
/**
* @brief Acquires an optional read-locked guard over a page of data. The user can specify an `AccessType` if needed.
*
* If it is not possible to bring the page of data into memory, this function will return a `std::nullopt`.
*
* Page data can _only_ be accessed via page guards. Users of this `AdvBufferPoolManager` are expected to acquire either a
* `ReadPageGuard` or a `WritePageGuard` depending on the mode in which they would like to access the data, which
* ensures that any access of data is thread-safe.
*
* There can be any number of `ReadPageGuard`s reading the same page of data at a time across different threads.
* However, all data access must be immutable. If a user wants to mutate the page's data, they must acquire a
* `WritePageGuard` with `CheckedWritePage` instead.
*
* ### Implementation
*
* See the implementation details of `CheckedWritePage`.
*
*
* @param page_id The ID of the page we want to read.
* @param access_type The type of page access.
* @return std::optional An optional latch guard where if there are no more free frames (out of memory)
* returns `std::nullopt`, otherwise returns a `ReadPageGuard` ensuring shared and read-only access to a page's data.
*/
auto AdvBufferPoolManager::CheckedReadPage(page_id_t page_id, AccessType access_type, bool wait_for_page) -> std::optional {
#ifdef DEBUG
read_counter_++;
#endif
bool load_page = false;
CheckLatchOwner();
auto frame_hdr = PrepareFrameForPage(page_id, access_type, load_page, false, wait_for_page);
if (!frame_hdr) return std::nullopt;
LoadPageToFrame(frame_hdr, page_id, load_page);
return ReadPageGuard(page_id, frame_hdr, replacer_, bpm_latch_, frames_cv_);
}
void AdvBufferPoolManager::FlushPageToDiskAsync(std::shared_ptr hdr, std::function callback) {
std::shared_ptr buf;
{
std::scoped_lock lck(io_buffer_latch_);
if (io_buffer_.empty()) {
buf = std::make_shared();
} else {
buf = io_buffer_.front();
io_buffer_.pop();
}
}
{
// lock the page data to copy into buffer
std::shared_lock lck(hdr->rwlatch_);
std::memcpy(buf->data(), hdr->GetData(), BUSTUB_PAGE_SIZE);
}
auto promise = disk_scheduler_->CreatePromise();
auto future = promise.get_future();
// buffer must be captured to ensure its memory always valid and then put it back to pool
auto callback_wrapper = [buf, callback, this]() {
callback();
std::scoped_lock lck(io_buffer_latch_);
io_buffer_.push(buf);
};
disk_scheduler_->Schedule(DiskRequest{true, buf->data(), hdr->page_id_, std::move(promise), callback_wrapper});
}
/**
* @brief Flushes a page's data out to disk.
*
* This function will write out a page's data to disk if it has been modified. If the given page is not in memory, this
* function will return `false`.
*
* ### Implementation
*
* You should probably leave implementing this function until after you have completed `CheckedReadPage` and
* `CheckedWritePage`, as it will likely be much easier to understand what to do.
*
*
* @param page_id The page ID of the page to be flushed.
* @return `false` if the page could not be found in the page table, otherwise `true`.
*/
auto AdvBufferPoolManager::FlushPage(page_id_t page_id) -> bool {
std::promise promise{};
auto future = promise.get_future();
{
std::unique_lock partition(latches_[page_id % NUM_PARTITIONS]);
WaitForPageReady(partition, page_id);
auto frame_hdr = GetMappedFrameLocked(page_id);
if (!frame_hdr) return false;
if (!frame_hdr->is_dirty_) return true;
frame_hdr->is_dirty_ = false;
MarkPageBusyLocked(page_id);
disk_scheduler_->Schedule(DiskRequest{true, frame_hdr->GetDataMut(), page_id, std::move(promise)});
}
{
future.get();
std::scoped_lock partition(latches_[page_id % NUM_PARTITIONS]);
MarkPageReadyLocked(page_id);
}
return true;
}
/**
* @brief Flushes all page data that is in memory to disk.
*
* ### Implementation
*
* You should probably leave implementing this function until after you have completed `CheckedReadPage`,
* `CheckedWritePage`, and `FlushPage`, as it will likely be much easier to understand what to do.
*
*/
void AdvBufferPoolManager::FlushAllPages() {
BUSTUB_ASSERT(false, __func__);
}
/**
* @brief Retrieves the pin count of a page. If the page does not exist in memory, return `std::nullopt`.
*
* This function is thread safe. Callers may invoke this function in a multi-threaded environment where multiple threads
* access the same page.
*
* This function is intended for testing purposes. If this function is implemented incorrectly, it will definitely cause
* problems with the test suite and autograder.
*
* # Implementation
*
* We will use this function to test if your buffer pool manager is managing pin counts correctly. Since the
* `pin_count_` field in `FrameHeader` is an atomic type, you do not need to take the latch on the frame that holds the
* page we want to look at. Instead, you can simply use an atomic `load` to safely load the value stored. You will still
* need to take the buffer pool latch, however.
*
* Again, if you are unfamiliar with atomic types, see the official C++ docs
* [here](https://en.cppreference.com/w/cpp/atomic/atomic).
*
*
* @param page_id The page ID of the page we want to get the pin count of.
* @return std::optional The pin count if the page exists, otherwise `std::nullopt`.
*/
auto AdvBufferPoolManager::GetPinCount(page_id_t page_id) -> std::optional {
std::scoped_lock partition(latches_[page_id % NUM_PARTITIONS]);
auto frame_hdr = GetMappedFrameLocked(page_id);
if (!frame_hdr) return std::nullopt;
return frame_hdr->pin_count_.load();
}
AdvBufferPoolManager::~AdvBufferPoolManager() {
// make sure async threads are recycled before destruction
disk_scheduler_.reset();
}
} // namespace bustub
bustub/src/buffer/._lru_k_replacer.cpp 000644 000765 000024 00000000243 15127067042 021314 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/buffer/PaxHeader/lru_k_replacer.cpp 000644 000765 000024 00000000207 15127067042 023050 x ustar 00yanhuang staff 000000 000000 29 mtime=1767665186.74388724
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/buffer/lru_k_replacer.cpp 000644 000765 000024 00000015422 15127067042 021104 0 ustar 00yanhuang staff 000000 000000 //===----------------------------------------------------------------------===//
//
// BusTub
//
// lru_k_replacer.cpp
//
// Identification: src/buffer/lru_k_replacer.cpp
//
// Copyright (c) 2015-2022, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include "buffer/lru_k_replacer.h"
#include
#include
#include
#include
#include
#include "common/config.h"
#include "common/macros.h"
namespace bustub {
static uint64_t Now() {
static std::atomic_size_t counter = 0;
return counter++;
}
/**
*
* @brief a new LRUKReplacer.
* @param num_frames the maximum number of frames the LRUReplacer will be required to store
*/
LRUKReplacer::LRUKReplacer(size_t num_frames, size_t k)
: replacer_size_(num_frames),
k_(k), k_set_([this](frame_id_t lhs, frame_id_t rhs) { return this->Compare(lhs, rhs); }) {}
bool LRUKReplacer::Compare(frame_id_t lhs, frame_id_t rhs) {
const auto &lnode = node_store_[lhs];
const auto &rnode = node_store_[rhs];
return lnode.history_.front() < rnode.history_.front();
}
void LRUKReplacer::InsertToList(LRUKNode& node, frame_id_t frame_id) {
if (node.history_.size() >= k_) {
if (fast_mode_) {
k_list_.push_back(frame_id);
node.list_it_ = std::prev(k_list_.end());
} else {
auto [iter, success] = k_set_.insert(frame_id);
BUSTUB_ENSURE(success, "Found duplicate on frame_id");
node.set_it_ = iter;
}
} else {
inf_list_.push_back(frame_id);
node.list_it_ = std::prev(inf_list_.end());
}
}
void LRUKReplacer::RemoveFromList(LRUKNode& node) {
if (node.history_.size() >= k_) {
if (fast_mode_) {
k_list_.erase(node.list_it_);
node.list_it_ = k_list_.end();
} else {
k_set_.erase(node.set_it_);
node.set_it_ = k_set_.end();
}
} else {
inf_list_.erase(node.list_it_);
node.list_it_ = inf_list_.end();
}
}
/**
*
* @brief Find the frame with largest backward k-distance and evict that frame. Only frames
* that are marked as 'evictable' are candidates for eviction.
*
* A frame with less than k historical references is given +inf as its backward k-distance.
* If multiple frames have inf backward k-distance, then evict frame whose oldest timestamp
* is furthest in the past.
*
* Successful eviction of a frame should decrement the size of replacer and remove the frame's
* access history.
*
* @return the frame ID if a frame is successfully evicted, or `std::nullopt` if no frames can be evicted.
*/
auto LRUKReplacer::Evict() -> std::optional {
std::lock_guard lock(latch_);
if (!inf_list_.empty()) {
auto victim_id = inf_list_.front();
inf_list_.pop_front();
node_store_.erase(victim_id);
return victim_id;
}
if (fast_mode_) {
if (!k_list_.empty()) {
auto victim_id = k_list_.front();
k_list_.pop_front();
node_store_.erase(victim_id);
return victim_id;
}
} else {
if (!k_set_.empty()) {
auto victim_id = *k_set_.begin();
k_set_.erase(k_set_.begin());
node_store_.erase(victim_id);
return victim_id;
}
}
return std::nullopt;
}
/**
*
* @brief Record the event that the given frame id is accessed at current timestamp.
* Create a new entry for access history if frame id has not been seen before.
*
* If frame id is invalid (ie. larger than replacer_size_), throw an exception. You can
* also use BUSTUB_ASSERT to abort the process if frame id is invalid.
*
* @param frame_id id of frame that received a new access.
* @param access_type type of access that was received. This parameter is only needed for
* leaderboard tests.
*/
void LRUKReplacer::RecordAccess(frame_id_t frame_id, AccessType access_type) {
BUSTUB_ENSURE(frame_id >= 0 && (size_t)frame_id < replacer_size_, "Invalid frame_id");
std::lock_guard lock(latch_);
// is_evictable_ defaults to false
auto &node = node_store_[frame_id];
if (node.is_evictable_) {
RemoveFromList(node);
}
if (access_type == AccessType::Scan) {
// lower the priority of SCAN page
node.history_.clear();
} else if (access_type == AccessType::Index) {
auto now = Now();
while (node.history_.size() < k_) node.history_.push_back(now);
} else {
node.history_.push_back(Now());
}
while (node.history_.size() > k_) {
node.history_.pop_front();
}
if (node.is_evictable_) {
InsertToList(node, frame_id);
}
}
/**
* TODO(P1): Add implementation
*
* @brief Toggle whether a frame is evictable or non-evictable. This function also
* controls replacer's size. Note that size is equal to number of evictable entries.
*
* If a frame was previously evictable and is to be set to non-evictable, then size should
* decrement. If a frame was previously non-evictable and is to be set to evictable,
* then size should increment.
*
* If frame id is invalid, throw an exception or abort the process.
*
* For other scenarios, this function should terminate without modifying anything.
*
* @param frame_id id of frame whose 'evictable' status will be modified
* @param set_evictable whether the given frame is evictable or not
*/
void LRUKReplacer::SetEvictable(frame_id_t frame_id, bool set_evictable) {
BUSTUB_ASSERT(frame_id >= 0 && (size_t)frame_id < replacer_size_, "Invalid frame_id");
std::lock_guard lock(latch_);
auto &node = node_store_[frame_id];
if (node.is_evictable_ == set_evictable) return;
node.is_evictable_ = set_evictable;
if (set_evictable) {
InsertToList(node, frame_id);
} else {
RemoveFromList(node);
}
}
/**
*
* @brief Remove an evictable frame from replacer, along with its access history.
* This function should also decrement replacer's size if removal is successful.
*
* Note that this is different from evicting a frame, which always remove the frame
* with largest backward k-distance. This function removes specified frame id,
* no matter what its backward k-distance is.
*
* If Remove is called on a non-evictable frame, throw an exception or abort the
* process.
*
* If specified frame is not found, directly return from this function.
*
* @param frame_id id of frame to be removed
*/
void LRUKReplacer::Remove(frame_id_t frame_id) {
std::lock_guard lock(latch_);
auto iter = node_store_.find(frame_id);
if (iter == node_store_.end()) return;
auto &node = iter->second;
BUSTUB_ENSURE(node.is_evictable_, "Remove called on a non-evictable frame.");
RemoveFromList(node);
node_store_.erase(frame_id);
}
/**
*
* @brief Return replacer's size, which tracks the number of evictable frames.
*
* @return size_t
*/
auto LRUKReplacer::Size() -> size_t {
std::scoped_lock lck(latch_);
return inf_list_.size() + (fast_mode_ ? k_list_.size() : k_set_.size());
}
LRUKReplacer::~LRUKReplacer() {}
} // namespace bustub bustub/src/buffer/._lru_k_replacer.cpp.bak 000644 000765 000024 00000000243 15127067042 022050 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/buffer/PaxHeader/lru_k_replacer.cpp.bak 000644 000765 000024 00000000210 15127067042 023576 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.744125949
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/buffer/lru_k_replacer.cpp.bak 000644 000765 000024 00000015266 15127067042 021646 0 ustar 00yanhuang staff 000000 000000 //===----------------------------------------------------------------------===//
//
// BusTub
//
// lru_k_replacer.cpp
//
// Identification: src/buffer/lru_k_replacer.cpp
//
// Copyright (c) 2015-2022, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include "buffer/lru_k_replacer.h"
#include
#include
#include
#include
#include
#include "common/config.h"
#include "common/logger.h"
#include "common/macros.h"
namespace bustub {
static uint64_t Now() {
static std::atomic_size_t counter = 0;
return counter++;
}
/**
*
* @brief a new LRUKReplacer.
* @param num_frames the maximum number of frames the LRUReplacer will be required to store
*/
LRUKReplacer::LRUKReplacer(size_t num_frames, size_t k)
: replacer_size_(num_frames),
k_(k),
node_tree_([this](frame_id_t lhs, frame_id_t rhs) { return this->Compare(lhs, rhs); }) {}
bool LRUKReplacer::Compare(frame_id_t lhs, frame_id_t rhs) {
compare_counter++;
const auto HasEnoughVisit = [this](const LRUKNode &node) { return node.history_.size() == k_; };
auto &lnode = node_store_[lhs];
auto &rnode = node_store_[rhs];
if (lnode.history_.empty() && rnode.history_.empty()) return lhs < rhs;
if (lnode.history_.empty()) return true;
if (rnode.history_.empty()) return false;
if (!HasEnoughVisit(lnode) && HasEnoughVisit(rnode)) return true;
if (HasEnoughVisit(lnode) && !HasEnoughVisit(rnode)) return false;
if (lnode.history_.front() != rnode.history_.front()) {
return lnode.history_.front() < rnode.history_.front();
}
return lhs < rhs;
}
/**
*
* @brief Find the frame with largest backward k-distance and evict that frame. Only frames
* that are marked as 'evictable' are candidates for eviction.
*
* A frame with less than k historical references is given +inf as its backward k-distance.
* If multiple frames have inf backward k-distance, then evict frame whose oldest timestamp
* is furthest in the past.
*
* Successful eviction of a frame should decrement the size of replacer and remove the frame's
* access history.
*
* @return the frame ID if a frame is successfully evicted, or `std::nullopt` if no frames can be evicted.
*/
auto LRUKReplacer::Evict() -> std::optional {
std::scoped_lock lck(latch_);
if (node_tree_.empty()) return std::nullopt;
frame_id_t frame_id = *node_tree_.begin();
RemoveLocked(frame_id);
return frame_id;
}
/**
*
* @brief Record the event that the given frame id is accessed at current timestamp.
* Create a new entry for access history if frame id has not been seen before.
*
* If frame id is invalid (ie. larger than replacer_size_), throw an exception. You can
* also use BUSTUB_ASSERT to abort the process if frame id is invalid.
*
* @param frame_id id of frame that received a new access.
* @param access_type type of access that was received. This parameter is only needed for
* leaderboard tests.
*/
void LRUKReplacer::RecordAccess(frame_id_t frame_id, AccessType access_type) {
BUSTUB_ENSURE(frame_id < (frame_id_t)replacer_size_, "Invalid frame_id.");
std::scoped_lock lck(latch_);
// construct if not exist
auto &node = node_store_[frame_id];
if (node.is_evictable_) node_tree_.erase(frame_id);
// update access log
if (access_type == AccessType::Scan) {
// lower the priority of SCAN page
node.history_.clear();
} else if (access_type == AccessType::Index) {
auto now = Now();
while (node.history_.size() < k_) node.history_.push_back(now);
} else {
node.history_.push_back(Now());
}
while (node.history_.size() > k_) node.history_.pop_front();
// rebalance BST
if (node.is_evictable_) node_tree_.insert(frame_id);
}
/**
* TODO(P1): Add implementation
*
* @brief Toggle whether a frame is evictable or non-evictable. This function also
* controls replacer's size. Note that size is equal to number of evictable entries.
*
* If a frame was previously evictable and is to be set to non-evictable, then size should
* decrement. If a frame was previously non-evictable and is to be set to evictable,
* then size should increment.
*
* If frame id is invalid, throw an exception or abort the process.
*
* For other scenarios, this function should terminate without modifying anything.
*
* @param frame_id id of frame whose 'evictable' status will be modified
* @param set_evictable whether the given frame is evictable or not
*/
void LRUKReplacer::SetEvictable(frame_id_t frame_id, bool set_evictable) {
BUSTUB_ENSURE(frame_id < (frame_id_t)replacer_size_, "Invalid frame_id.");
std::scoped_lock lck(latch_);
auto &node = node_store_[frame_id];
if (!node.is_evictable_ && set_evictable) {
BUSTUB_ENSURE(node_tree_.count(frame_id) == 0, "frame_id exists in evictable set");
node_tree_.insert(frame_id);
}
if (node.is_evictable_ && !set_evictable) {
BUSTUB_ENSURE(node_tree_.erase(frame_id) > 0, "frame_id not exist in evictable set");
}
node.is_evictable_ = set_evictable;
}
/**
*
* @brief Remove an evictable frame from replacer, along with its access history.
* This function should also decrement replacer's size if removal is successful.
*
* Note that this is different from evicting a frame, which always remove the frame
* with largest backward k-distance. This function removes specified frame id,
* no matter what its backward k-distance is.
*
* If Remove is called on a non-evictable frame, throw an exception or abort the
* process.
*
* If specified frame is not found, directly return from this function.
*
* @param frame_id id of frame to be removed
*/
void LRUKReplacer::Remove(frame_id_t frame_id) {
std::scoped_lock lck(latch_);
RemoveLocked(frame_id);
}
void LRUKReplacer::RemoveLocked(frame_id_t frame_id) {
auto node = node_store_.find(frame_id);
if (node == node_store_.end()) return;
BUSTUB_ENSURE(node->second.is_evictable_, "Remove is called on a non-evictable frame.");
BUSTUB_ENSURE(node_tree_.erase(frame_id) == 1, "frame_id not found in BST.");
BUSTUB_ENSURE(node_store_.erase(frame_id) == 1, "frame_id not found in hash table.");
}
/**
* TODO(P1): Add implementation
*
* @brief Return replacer's size, which tracks the number of evictable frames.
*
* @return size_t
*/
auto LRUKReplacer::Size() -> size_t {
std::scoped_lock lck(latch_);
return node_tree_.size();
}
LRUKReplacer::~LRUKReplacer() {
BUSTUB_ENSURE(node_tree_.size() == node_store_.size(),
std::string("Total frames: ") + std::to_string(node_store_.size()) +
" mismatches evictable frames: " + std::to_string(node_tree_.size()));
LOG_DEBUG("LRUKReplacer Compare call count: %lld", compare_counter.load());
}
} // namespace bustub
bustub/src/buffer/._clock_replacer.cpp 000644 000765 000024 00000000243 15127067042 021273 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/buffer/PaxHeader/clock_replacer.cpp 000644 000765 000024 00000000210 15127067042 023021 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.744279075
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/buffer/clock_replacer.cpp 000644 000765 000024 00000001363 15127067042 021062 0 ustar 00yanhuang staff 000000 000000 //===----------------------------------------------------------------------===//
//
// BusTub
//
// clock_replacer.cpp
//
// Identification: src/buffer/clock_replacer.cpp
//
// Copyright (c) 2015-2019, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include "buffer/clock_replacer.h"
namespace bustub {
ClockReplacer::ClockReplacer(size_t num_pages) {}
ClockReplacer::~ClockReplacer() = default;
auto ClockReplacer::Victim(frame_id_t *frame_id) -> bool { return false; }
void ClockReplacer::Pin(frame_id_t frame_id) {}
void ClockReplacer::Unpin(frame_id_t frame_id) {}
auto ClockReplacer::Size() -> size_t { return 0; }
} // namespace bustub
bustub/src/execution/._topn_executor.cpp 000644 000765 000024 00000000243 15127067042 021753 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/execution/PaxHeader/topn_executor.cpp 000644 000765 000024 00000000210 15127067042 023501 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.736742932
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/execution/topn_executor.cpp 000644 000765 000024 00000001077 15127067042 021544 0 ustar 00yanhuang staff 000000 000000 #include "execution/executors/topn_executor.h"
namespace bustub {
TopNExecutor::TopNExecutor(ExecutorContext *exec_ctx, const TopNPlanNode *plan,
std::unique_ptr &&child_executor)
: AbstractExecutor(exec_ctx) {}
void TopNExecutor::Init() { throw NotImplementedException("TopNExecutor is not implemented"); }
auto TopNExecutor::Next(Tuple *tuple, RID *rid) -> bool { return false; }
auto TopNExecutor::GetNumInHeap() -> size_t { throw NotImplementedException("TopNExecutor is not implemented"); };
} // namespace bustub
bustub/src/execution/._fmt_impl.cpp 000644 000765 000024 00000000243 15127067042 020664 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/execution/PaxHeader/fmt_impl.cpp 000644 000765 000024 00000000210 15127067042 022412 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.737068558
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/execution/fmt_impl.cpp 000644 000765 000024 00000006236 15127067042 020457 0 ustar 00yanhuang staff 000000 000000 #include
#include "execution/expressions/column_value_expression.h"
#include "execution/plans/update_plan.h"
#include "execution/plans/window_plan.h"
#include "fmt/format.h"
#include "fmt/ranges.h"
#include "common/util/string_util.h"
#include "execution/expressions/abstract_expression.h"
#include "execution/plans/abstract_plan.h"
#include "execution/plans/aggregation_plan.h"
#include "execution/plans/hash_join_plan.h"
#include "execution/plans/limit_plan.h"
#include "execution/plans/projection_plan.h"
#include "execution/plans/sort_plan.h"
#include "execution/plans/topn_plan.h"
namespace bustub {
auto AbstractPlanNode::ChildrenToString(int indent, bool with_schema) const -> std::string {
if (children_.empty()) {
return "";
}
std::vector children_str;
children_str.reserve(children_.size());
auto indent_str = StringUtil::Indent(indent);
for (const auto &child : children_) {
auto child_str = child->ToString(with_schema);
auto lines = StringUtil::Split(child_str, '\n');
for (auto &line : lines) {
children_str.push_back(fmt::format("{}{}", indent_str, line));
}
}
return fmt::format("\n{}", fmt::join(children_str, "\n"));
}
auto AggregationPlanNode::PlanNodeToString() const -> std::string {
return fmt::format("Agg {{ types={}, aggregates={}, group_by={} }}", agg_types_, aggregates_, group_bys_);
}
auto WindowFunctionPlanNode::PlanNodeToString() const -> std::string {
std::string columns_str;
for (const auto &col : columns_) {
const auto &col_val = dynamic_cast(*col);
if (col_val.GetColIdx() == static_cast(-1)) {
columns_str += "placeholder, ";
continue;
}
columns_str += col->ToString() + ", ";
}
std::vector map_content;
map_content.reserve(window_functions_.size());
for (const auto &[k, v] : window_functions_) {
map_content.emplace_back(fmt::format(" {}=>{}", k, v));
}
return fmt::format("WindowFunc {{\n columns={},\n window_functions={{\n{}\n }}\n}}", columns_str,
fmt::join(map_content, ",\n"));
}
auto HashJoinPlanNode::PlanNodeToString() const -> std::string {
return fmt::format("HashJoin {{ type={}, left_key={}, right_key={} }}", join_type_, left_key_expressions_,
right_key_expressions_);
}
auto ProjectionPlanNode::PlanNodeToString() const -> std::string {
return fmt::format("Projection {{ exprs={} }}", expressions_);
}
auto UpdatePlanNode::PlanNodeToString() const -> std::string {
return fmt::format("Update {{ table_oid={}, target_exprs={} }}", table_oid_, target_expressions_);
}
auto SortPlanNode::PlanNodeToString() const -> std::string {
// Note(f24): A sort plan node will be converted to an external merge sort executor in
// Fall 2024. So `ExternalMergeSort` is returned instead of `Sort`.
return fmt::format("ExternalMergeSort {{ order_bys={} }}", order_bys_);
}
auto LimitPlanNode::PlanNodeToString() const -> std::string { return fmt::format("Limit {{ limit={} }}", limit_); }
auto TopNPlanNode::PlanNodeToString() const -> std::string {
return fmt::format("TopN {{ n={}, order_bys={}}}", n_, order_bys_);
}
} // namespace bustub
bustub/src/execution/._limit_executor.cpp 000644 000765 000024 00000000243 15127067042 022111 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/execution/PaxHeader/limit_executor.cpp 000644 000765 000024 00000000210 15127067042 023637 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.737389642
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/execution/limit_executor.cpp 000644 000765 000024 00000001673 15127067042 021704 0 ustar 00yanhuang staff 000000 000000 //===----------------------------------------------------------------------===//
//
// BusTub
//
// limit_executor.cpp
//
// Identification: src/execution/limit_executor.cpp
//
// Copyright (c) 2015-2021, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include "execution/executors/limit_executor.h"
namespace bustub {
LimitExecutor::LimitExecutor(ExecutorContext *exec_ctx, const LimitPlanNode *plan,
std::unique_ptr &&child_executor)
: AbstractExecutor(exec_ctx), plan_(plan), child_executor_(std::move(child_executor)), count_(0) {}
void LimitExecutor::Init() {
count_ = 0;
child_executor_->Init();
}
auto LimitExecutor::Next(Tuple *tuple, RID *rid) -> bool {
if (count_++ >= plan_->GetLimit()) return false;
return child_executor_->Next(tuple, rid);
}
} // namespace bustub
bustub/src/execution/._executor_factory.cpp 000644 000765 000024 00000000243 15127067042 022442 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/execution/PaxHeader/executor_factory.cpp 000644 000765 000024 00000000210 15127067042 024170 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.737638767
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/execution/executor_factory.cpp 000644 000765 000024 00000022272 15127067042 022233 0 ustar 00yanhuang staff 000000 000000 //===----------------------------------------------------------------------===//
//
// BusTub
//
// executor_factory.cpp
//
// Identification: src/execution/executor_factory.cpp
//
// Copyright (c) 2015-2021, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include "execution/executor_factory.h"
#include
#include
#include "execution/executors/abstract_executor.h"
#include "execution/executors/aggregation_executor.h"
#include "execution/executors/delete_executor.h"
#include "execution/executors/external_merge_sort_executor.h"
#include "execution/executors/filter_executor.h"
#include "execution/executors/hash_join_executor.h"
#include "execution/executors/index_scan_executor.h"
#include "execution/executors/init_check_executor.h"
#include "execution/executors/insert_executor.h"
#include "execution/executors/limit_executor.h"
#include "execution/executors/mock_scan_executor.h"
#include "execution/executors/nested_index_join_executor.h"
#include "execution/executors/nested_loop_join_executor.h"
#include "execution/executors/projection_executor.h"
#include "execution/executors/seq_scan_executor.h"
#include "execution/executors/sort_executor.h"
#include "execution/executors/topn_check_executor.h"
#include "execution/executors/topn_executor.h"
#include "execution/executors/topn_per_group_executor.h"
#include "execution/executors/update_executor.h"
#include "execution/executors/values_executor.h"
#include "execution/executors/window_function_executor.h"
#include "execution/plans/filter_plan.h"
#include "execution/plans/mock_scan_plan.h"
#include "execution/plans/projection_plan.h"
#include "execution/plans/sort_plan.h"
#include "execution/plans/topn_per_group_plan.h"
#include "execution/plans/topn_plan.h"
#include "execution/plans/values_plan.h"
#include "execution/plans/window_plan.h"
#include "storage/index/generic_key.h"
namespace bustub {
auto ExecutorFactory::CreateExecutor(ExecutorContext *exec_ctx, const AbstractPlanNodeRef &plan)
-> std::unique_ptr {
auto check_options_set = exec_ctx->GetCheckOptions()->check_options_set_;
switch (plan->GetType()) {
// Create a new sequential scan executor
case PlanType::SeqScan: {
return std::make_unique(exec_ctx, dynamic_cast(plan.get()));
}
// Create a new index scan executor
case PlanType::IndexScan: {
return std::make_unique(exec_ctx, dynamic_cast(plan.get()));
}
// Create a new insert executor
case PlanType::Insert: {
auto insert_plan = dynamic_cast(plan.get());
auto child_executor = ExecutorFactory::CreateExecutor(exec_ctx, insert_plan->GetChildPlan());
return std::make_unique(exec_ctx, insert_plan, std::move(child_executor));
}
// Create a new update executor
case PlanType::Update: {
auto update_plan = dynamic_cast(plan.get());
auto child_executor = ExecutorFactory::CreateExecutor(exec_ctx, update_plan->GetChildPlan());
return std::make_unique(exec_ctx, update_plan, std::move(child_executor));
}
// Create a new delete executor
case PlanType::Delete: {
auto delete_plan = dynamic_cast(plan.get());
auto child_executor = ExecutorFactory::CreateExecutor(exec_ctx, delete_plan->GetChildPlan());
return std::make_unique(exec_ctx, delete_plan, std::move(child_executor));
}
// Create a new limit executor
case PlanType::Limit: {
auto limit_plan = dynamic_cast(plan.get());
auto child_executor = ExecutorFactory::CreateExecutor(exec_ctx, limit_plan->GetChildPlan());
return std::make_unique(exec_ctx, limit_plan, std::move(child_executor));
}
// Create a new aggregation executor
case PlanType::Aggregation: {
auto agg_plan = dynamic_cast(plan.get());
auto child_executor = ExecutorFactory::CreateExecutor(exec_ctx, agg_plan->GetChildPlan());
return std::make_unique(exec_ctx, agg_plan, std::move(child_executor));
}
case PlanType::Window: {
auto window_plan = dynamic_cast(plan.get());
auto child_executor = ExecutorFactory::CreateExecutor(exec_ctx, window_plan->GetChildPlan());
return std::make_unique(exec_ctx, window_plan, std::move(child_executor));
}
// Create a new nested-loop join executor
case PlanType::NestedLoopJoin: {
auto nested_loop_join_plan = dynamic_cast(plan.get());
auto left = ExecutorFactory::CreateExecutor(exec_ctx, nested_loop_join_plan->GetLeftPlan());
auto right = ExecutorFactory::CreateExecutor(exec_ctx, nested_loop_join_plan->GetRightPlan());
if (check_options_set.find(CheckOption::ENABLE_NLJ_CHECK) != check_options_set.end()) {
auto left_check =
std::make_unique(exec_ctx, nested_loop_join_plan->GetLeftPlan(), std::move(left));
auto right_check =
std::make_unique(exec_ctx, nested_loop_join_plan->GetRightPlan(), std::move(right));
exec_ctx->AddCheckExecutor(left_check.get(), right_check.get());
return std::make_unique(exec_ctx, nested_loop_join_plan, std::move(left_check),
std::move(right_check));
}
return std::make_unique(exec_ctx, nested_loop_join_plan, std::move(left),
std::move(right));
}
// Create a new nested-index join executor
case PlanType::NestedIndexJoin: {
auto nested_index_join_plan = dynamic_cast(plan.get());
auto left = ExecutorFactory::CreateExecutor(exec_ctx, nested_index_join_plan->GetChildPlan());
return std::make_unique(exec_ctx, nested_index_join_plan, std::move(left));
}
// Create a new hash join executor
case PlanType::HashJoin: {
auto hash_join_plan = dynamic_cast(plan.get());
auto left = ExecutorFactory::CreateExecutor(exec_ctx, hash_join_plan->GetLeftPlan());
auto right = ExecutorFactory::CreateExecutor(exec_ctx, hash_join_plan->GetRightPlan());
return std::make_unique(exec_ctx, hash_join_plan, std::move(left), std::move(right));
}
// Create a new mock scan executor
case PlanType::MockScan: {
const auto *mock_scan_plan = dynamic_cast(plan.get());
return std::make_unique(exec_ctx, mock_scan_plan);
}
// Create a new projection executor
case PlanType::Projection: {
const auto *projection_plan = dynamic_cast(plan.get());
auto child = ExecutorFactory::CreateExecutor(exec_ctx, projection_plan->GetChildPlan());
return std::make_unique(exec_ctx, projection_plan, std::move(child));
}
// Create a new filter executor
case PlanType::Filter: {
const auto *filter_plan = dynamic_cast(plan.get());
auto child = ExecutorFactory::CreateExecutor(exec_ctx, filter_plan->GetChildPlan());
return std::make_unique(exec_ctx, filter_plan, std::move(child));
}
// Create a new filter executor
case PlanType::Values: {
const auto *values_plan = dynamic_cast(plan.get());
return std::make_unique(exec_ctx, values_plan);
}
// Create a new sort executor
case PlanType::Sort: {
const auto *sort_plan = dynamic_cast(plan.get());
auto child = ExecutorFactory::CreateExecutor(exec_ctx, sort_plan->GetChildPlan());
return std::make_unique>(exec_ctx, sort_plan, std::move(child));
}
// Create a new topN executor
case PlanType::TopN: {
const auto *topn_plan = dynamic_cast(plan.get());
auto child = ExecutorFactory::CreateExecutor(exec_ctx, topn_plan->GetChildPlan());
if (check_options_set.find(CheckOption::ENABLE_TOPN_CHECK) != check_options_set.end()) {
auto topn_executor = std::make_unique(exec_ctx, topn_plan, nullptr);
auto check = std::make_unique(exec_ctx, topn_plan, std::move(child), topn_executor.get());
topn_executor->SetChildExecutor(std::move(check));
return topn_executor;
}
return std::make_unique(exec_ctx, topn_plan, std::move(child));
}
// Create a new groupTopN executor
case PlanType::TopNPerGroup: {
const auto *group_topn_plan = dynamic_cast(plan.get());
auto child = ExecutorFactory::CreateExecutor(exec_ctx, group_topn_plan->GetChildPlan());
return std::make_unique(exec_ctx, group_topn_plan, std::move(child));
}
default:
UNREACHABLE("Unsupported plan type.");
}
}
} // namespace bustub
bustub/src/execution/._hash_join_executor.cpp 000644 000765 000024 00000000243 15127067042 022735 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/execution/PaxHeader/hash_join_executor.cpp 000644 000765 000024 00000000210 15127067042 024463 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.737900351
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/execution/hash_join_executor.cpp 000644 000765 000024 00000010067 15127067042 022525 0 ustar 00yanhuang staff 000000 000000 //===----------------------------------------------------------------------===//
//
// BusTub
//
// hash_join_executor.cpp
//
// Identification: src/execution/hash_join_executor.cpp
//
// Copyright (c) 2015-2021, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include "binder/table_ref/bound_join_ref.h"
#include "execution/expressions/abstract_expression.h"
#include "fmt/core.h"
#include "storage/table/tuple.h"
#include "type/value_factory.h"
#include "execution/executors/hash_join_executor.h"
#include
#include
#include
namespace bustub {
HashJoinExecutor::HashJoinExecutor(ExecutorContext *exec_ctx, const HashJoinPlanNode *plan,
std::unique_ptr &&left_child,
std::unique_ptr &&right_child)
: AbstractExecutor(exec_ctx), plan_(plan), left_child_(std::move(left_child)), right_child_(std::move(right_child)) {
if (!(plan->GetJoinType() == JoinType::LEFT || plan->GetJoinType() == JoinType::INNER)) {
// Note for Fall 2024: You ONLY need to implement left join and inner join.
throw bustub::NotImplementedException(fmt::format("join type {} not supported", plan->GetJoinType()));
}
}
auto HashJoinExecutor::GetJoinKeyFromTuple(const Tuple &tuple, const std::vector &exprs, const Schema &schema) -> JoinKey {
std::vector keys;
for (const auto &expr : exprs) {
keys.emplace_back(expr->Evaluate(&tuple, schema));
}
return {keys};
}
void HashJoinExecutor::Init() {
left_child_->Init();
right_child_->Init();
hash_.clear();
is_end_ = false;
left_.reset();
right_idx_ = 0;
right_iter_ = hash_.end();
const auto &exprs = plan_->RightJoinKeyExpressions();
const auto &schema = right_child_->GetOutputSchema();
RID rid;
Tuple tuple;
if (exprs.size() == 1) filter_ = std::make_unique(16 * 1024, 7);
while (right_child_->Next(&tuple, &rid)) {
const auto& key = GetJoinKeyFromTuple(tuple, exprs, schema);
hash_[key].emplace_back(tuple);
if (filter_) {
filter_->Insert(key.keys_[0]);
}
}
}
auto HashJoinExecutor::Next(Tuple *tuple, RID *rid) -> bool {
const auto& left_schema = left_child_->GetOutputSchema();
const auto& right_schema = right_child_->GetOutputSchema();
auto BuildResultTuple = [&](const Tuple& left, const Tuple& right, bool predicate) {
std::vector values;
for (uint32_t i = 0; i < left_schema.GetColumnCount(); i++) {
values.emplace_back(left.GetValue(&left_schema, i));
}
for (uint32_t i = 0; i < right_schema.GetColumnCount(); i++) {
if (predicate) {
values.emplace_back(right.GetValue(&right_schema, i));
} else {
values.emplace_back(ValueFactory::GetNullValueByType(right_schema.GetColumn(i).GetType()));
}
}
return Tuple(values, &GetOutputSchema());
};
RID rid_left;
const auto &exprs = plan_->LeftJoinKeyExpressions();
while (!is_end_) {
if (!left_) {
left_ = std::make_shared();
if (!left_child_->Next(&*left_, &rid_left)) {
is_end_ = true;
return false;
}
right_idx_ = 0;
const auto& key = GetJoinKeyFromTuple(*left_, exprs, left_schema);
// we query the bloom filter first if available
if (filter_ && !filter_->Contains(key.keys_[0])) {
right_iter_ = hash_.end();
} else {
right_iter_ = hash_.find(key);
}
if (right_iter_ == hash_.end()) {
auto left_tuple = *left_;
left_.reset();
if (plan_->GetJoinType() == JoinType::LEFT) {
*tuple = BuildResultTuple(left_tuple, Tuple::Empty(), false);
*rid = tuple->GetRid();
return true;
}
continue;
}
}
while (right_idx_ < right_iter_->second.size()) {
*tuple = BuildResultTuple(*left_, right_iter_->second[right_idx_++], true);
*rid = tuple->GetRid();
return true;
}
left_.reset();
}
return false;
}
} // namespace bustub
bustub/src/execution/._sort_executor.cpp 000644 000765 000024 00000000243 15127067042 021762 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/execution/PaxHeader/sort_executor.cpp 000644 000765 000024 00000000210 15127067042 023510 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.738100185
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/execution/sort_executor.cpp 000644 000765 000024 00000000713 15127067042 021547 0 ustar 00yanhuang staff 000000 000000 #include "execution/executors/sort_executor.h"
namespace bustub {
SortExecutor::SortExecutor(ExecutorContext *exec_ctx, const SortPlanNode *plan,
std::unique_ptr &&child_executor)
: AbstractExecutor(exec_ctx) {}
void SortExecutor::Init() { throw NotImplementedException("SortExecutor is not implemented"); }
auto SortExecutor::Next(Tuple *tuple, RID *rid) -> bool { return false; }
} // namespace bustub
bustub/src/execution/._index_scan_executor.cpp 000644 000765 000024 00000000243 15127067042 023106 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/execution/PaxHeader/index_scan_executor.cpp 000644 000765 000024 00000000210 15127067042 024634 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.738324894
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/execution/index_scan_executor.cpp 000644 000765 000024 00000005765 15127067042 022707 0 ustar 00yanhuang staff 000000 000000 //===----------------------------------------------------------------------===//
//
// BusTub
//
// index_scan_executor.cpp
//
// Identification: src/execution/index_scan_executor.cpp
//
// Copyright (c) 2015-19, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include "execution/executors/index_scan_executor.h"
#include "common/exception.h"
#include "common/macros.h"
#include "execution/execution_common.h"
#include "concurrency/transaction_manager.h"
#include "execution/expressions/constant_value_expression.h"
#include "type/value_factory.h"
namespace bustub {
IndexScanExecutor::IndexScanExecutor(ExecutorContext *exec_ctx, const IndexScanPlanNode *plan)
: AbstractExecutor(exec_ctx), plan_(plan) {
table_info_ = exec_ctx_->GetCatalog()->GetTable(plan_->table_oid_);
index_info_ = exec_ctx_->GetCatalog()->GetIndex(plan_->GetIndexOid());
const auto& predicate = plan_->filter_predicate_ ? plan_->filter_predicate_ : std::make_shared(ValueFactory::GetBooleanValue(true));
exec_ctx->GetTransaction()->AppendScanPredicate(table_info_->oid_, predicate);
exec_ctx->GetTransactionManager()->InsertScanPredicate(exec_ctx->GetTransaction(), table_info_->oid_, predicate);
}
void IndexScanExecutor::Init() {
cursor_ = 0;
}
auto IndexScanExecutor::Next(Tuple *tuple, RID *rid) -> bool {
if (plan_->filter_predicate_) {
return PointSearch(tuple, rid);
} else {
throw new NotImplementedException("not implemented");
}
}
auto IndexScanExecutor::PointSearch(Tuple *tuple_out, RID *rid_out) -> bool {
while (cursor_ < plan_->pred_keys_.size()) {
auto expr = plan_->pred_keys_[cursor_++];
auto value = dynamic_cast(expr.get());
BUSTUB_ENSURE(value != nullptr, "Invalid ConstantValueExpression");
auto key = Tuple({value->val_}, &index_info_->key_schema_);
std::vector result;
index_info_->index_->ScanKey(key, &result, exec_ctx_->GetTransaction());
if (result.size()) {
BUSTUB_ENSURE(result.size() == 1, "Unexpected: duplicate key.");
auto rid = result[0];
auto [meta, tuple, undo_link] = GetTupleAndUndoLink(exec_ctx_->GetTransactionManager(), table_info_->table_.get(), rid);
auto undo_logs_opt = CollectUndoLogs(rid, meta, tuple, undo_link, exec_ctx_->GetTransaction(), exec_ctx_->GetTransactionManager());
if (!undo_logs_opt.has_value()) continue;
const auto &undo_logs = *undo_logs_opt;
auto tuple_opt = ReconstructTuple(&table_info_->schema_, tuple, meta, undo_logs);
if (!tuple_opt.has_value()) continue;
tuple = *tuple_opt;
auto val = plan_->filter_predicate_->Evaluate(&tuple, table_info_->schema_);
BUSTUB_ENSURE(val.GetTypeId() == BOOLEAN, "Unexpected: predicate should be evaluated as boolean");
if (val.GetAs()) {
*tuple_out = tuple;
*rid_out = rid;
return true;
}
}
}
return false;
}
} // namespace bustub
bustub/src/execution/._nested_loop_join_executor.cpp 000644 000765 000024 00000000243 15127067042 024325 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/execution/PaxHeader/nested_loop_join_executor.cpp 000644 000765 000024 00000000210 15127067042 026053 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.738582478
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/execution/nested_loop_join_executor.cpp 000644 000765 000024 00000006431 15127067042 024115 0 ustar 00yanhuang staff 000000 000000 //===----------------------------------------------------------------------===//
//
// BusTub
//
// nested_loop_join_executor.cpp
//
// Identification: src/execution/nested_loop_join_executor.cpp
//
// Copyright (c) 2015-2021, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include "execution/executors/nested_loop_join_executor.h"
#include
#include
#include "binder/table_ref/bound_join_ref.h"
#include "common/exception.h"
#include "storage/table/tuple.h"
#include "type/type_id.h"
#include "type/value.h"
#include "type/value_factory.h"
namespace bustub {
NestedLoopJoinExecutor::NestedLoopJoinExecutor(ExecutorContext *exec_ctx, const NestedLoopJoinPlanNode *plan,
std::unique_ptr &&left_executor,
std::unique_ptr &&right_executor)
: AbstractExecutor(exec_ctx), plan_(plan), left_executor_(std::move(left_executor)), right_executor_(std::move(right_executor)) {
if (!(plan->GetJoinType() == JoinType::LEFT || plan->GetJoinType() == JoinType::INNER)) {
// Note for 2023 Fall: You ONLY need to implement left join and inner join.
throw bustub::NotImplementedException(fmt::format("join type {} not supported", plan->GetJoinType()));
}
}
void NestedLoopJoinExecutor::Init() {
left_executor_->Init();
right_executor_->Init();
is_end_ = false;
left_.reset();
}
auto NestedLoopJoinExecutor::Next(Tuple *tuple, RID *rid) -> bool {
const auto& left_schema = left_executor_->GetOutputSchema();
const auto& right_schema = right_executor_->GetOutputSchema();
auto BuildResultTuple = [&](const Tuple& left, const Tuple& right, bool predicate) {
std::vector values;
for (uint32_t i = 0; i < left_schema.GetColumnCount(); i++) {
values.emplace_back(left.GetValue(&left_schema, i));
}
for (uint32_t i = 0; i < right_schema.GetColumnCount(); i++) {
if (predicate) {
values.emplace_back(right.GetValue(&right_schema, i));
} else {
values.emplace_back(ValueFactory::GetNullValueByType(right_schema.GetColumn(i).GetType()));
}
}
return Tuple(values, &GetOutputSchema());
};
while (!is_end_) {
if (!left_) {
RID rid_left;
left_ = std::make_shared>();
left_->second = false;
if (!left_executor_->Next(&left_->first, &rid_left)) {
is_end_ = true;
return false;
}
right_executor_->Init();
}
Tuple right;
RID rid_right;
while (right_executor_->Next(&right, &rid_right)) {
auto value = plan_->Predicate()->EvaluateJoin(&left_->first, left_schema, &right, right_schema);
if (!value.IsNull() && value.GetAs()) {
const auto& result = BuildResultTuple(left_->first, right, true);
*tuple = result;
*rid = result.GetRid();
return left_->second = true;
}
}
if (plan_->GetJoinType() == JoinType::LEFT && !left_->second) {
const auto& result = BuildResultTuple(left_->first, right, false);
left_.reset();
*tuple = result;
*rid = result.GetRid();
return true;
}
left_.reset();
}
return false;
}
} // namespace bustub
bustub/src/execution/._update_executor.cpp 000644 000765 000024 00000000243 15127067042 022255 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/execution/PaxHeader/update_executor.cpp 000644 000765 000024 00000000207 15127067042 024011 x ustar 00yanhuang staff 000000 000000 29 mtime=1767665186.73884852
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/execution/update_executor.cpp 000644 000765 000024 00000014657 15127067042 022056 0 ustar 00yanhuang staff 000000 000000 //===----------------------------------------------------------------------===//
//
// BusTub
//
// update_executor.cpp
//
// Identification: src/execution/update_executor.cpp
//
// Copyright (c) 2015-2021, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include
#include
#include
#include
#include
#include "common/macros.h"
#include "execution/execution_common.h"
#include "concurrency/transaction_manager.h"
#include "fmt/core.h"
#include "storage/table/tuple.h"
#include "type/type_id.h"
#include "type/value_factory.h"
#include "execution/executors/update_executor.h"
namespace bustub {
UpdateExecutor::UpdateExecutor(ExecutorContext *exec_ctx, const UpdatePlanNode *plan,
std::unique_ptr &&child_executor)
: AbstractExecutor(exec_ctx), plan_(plan), child_executor_(std::move(child_executor)) {
}
void UpdateExecutor::Init() {
child_executor_->Init();
auto catalog = exec_ctx_->GetCatalog();
table_info_ = catalog->GetTable(plan_->GetTableOid());
indexes_ = catalog->GetTableIndexes(table_info_->name_);
output_schema_ = std::make_unique(GetOutputSchema());
executed_ = false;
}
auto UpdateExecutor::Next(Tuple *tuple_out, RID *) -> bool {
if (executed_) return false;
RID __rid_in;
Tuple __tuple_in;
std::vector>> buffer;
while (child_executor_->Next(&__tuple_in, &__rid_in)) {
buffer.emplace_back(std::tuple_cat(std::make_tuple(__rid_in), GetTupleAndUndoLink(exec_ctx_->GetTransactionManager(), table_info_->table_.get(), __rid_in)));
}
auto rows_affected = indexes_.empty() ? UpdateWithNoIndex(buffer) : UpdateWithIndex(buffer);
*tuple_out = Tuple({bustub::ValueFactory::GetIntegerValue(rows_affected)}, output_schema_.get());
return executed_ = true;
}
int UpdateExecutor::UpdateWithNoIndex(const std::vector>> &buffer) {
auto txn = exec_ctx_->GetTransaction();
auto txn_mgr = exec_ctx_->GetTransactionManager();
for (const auto &[rid, meta, tuple, link] : buffer) {
/*
* 1. Check tuple is not modified by other txn
*/
CheckWriteConflict(meta, txn);
/*
* 2. Do the actual update logic.
*/
UpdateTupleImpl(rid, meta, link, tuple, GetNewTuple(tuple), txn_mgr, txn, table_info_);
}
return buffer.size();
}
int UpdateExecutor::UpdateWithIndex(const std::vector>>& buffer) {
auto txn = exec_ctx_->GetTransaction();
auto txn_mgr = exec_ctx_->GetTransactionManager();
/*
* 1st PASS: mark all updated keys (old_key) as deleted
*/
std::unordered_set rid_updated;
std::vector> update_list;
std::vector> insert_list;
for (const auto &[rid, meta, tuple, link] : buffer) {
// ensure the tuple is not modified by other txn
CheckWriteConflict(meta, txn);
for (auto &index : indexes_) if (index->is_primary_key_) {
auto metadata = index->index_->GetMetadata();
const auto& tuple_new = GetNewTuple(tuple);
auto old_key = tuple.KeyFromTuple(table_info_->schema_, *metadata->GetKeySchema(), metadata->GetKeyAttrs());
auto new_key = tuple_new.KeyFromTuple(table_info_->schema_, *metadata->GetKeySchema(), metadata->GetKeyAttrs());
// if the primary key didn't change, we simply insert the new tuple into same RID
if (IsTupleContentEqual(old_key, new_key)) {
update_list.emplace_back(std::make_pair(rid, tuple_new));
continue;
}
// otherwise, we do the delete-then-insert strategy
{
std::vector result;
index->index_->ScanKey(old_key, &result, txn);
BUSTUB_ENSURE(result.size(), "Unexpected: key not found in B+ tree");
BUSTUB_ENSURE(rid == result[0], "Unexpected: RID changed in B+ tree");
}
DeleteTupleImpl(rid, meta, link, tuple, txn_mgr, txn, table_info_);
// if the new_key can be inserted into an existing RID, we save the information
// otherwise we have to create a new RID for the new Tuple
// we also validate if there's any write conflict: we can only write to each RID for only ONCE
// e.g. `UPDATE key SET key = 1` should FAIL
{
std::vector result;
index->index_->ScanKey(new_key, &result, txn);
if (result.size()) {
auto rid_new = result[0];
if (rid_updated.count(rid_new)) {
txn->SetTainted();
throw ExecutionException("Insert failed: write conflict on primary key.");
} else {
rid_updated.insert(rid_new);
// `tuple_new` needs to be written to `rid_new`, and generate undo log accordingly
update_list.emplace_back(std::make_pair(rid_new, tuple_new));
}
} else {
insert_list.emplace_back(std::make_tuple(index->index_.get(), new_key, tuple_new));
}
}
}
}
/*
* 2nd PASS: insert new tuples into correct storage of new_key & update index
*/
for (const auto &[rid_new, tuple_new] : update_list) {
const auto &[base_meta, base_tuple, base_link] = GetTupleAndUndoLink(txn_mgr, table_info_->table_.get(), rid_new);
CheckWriteConflict(base_meta, txn, false);
UpdateTupleImpl(rid_new, base_meta, base_link, base_meta.is_deleted_ ? std::nullopt : std::make_optional(base_tuple), tuple_new, txn_mgr, txn, table_info_);
}
for (const auto& [index, new_key, tuple_new]: insert_list) {
// if `new_key` not found in B+ tree, it means we have to insert new tuple into table heap, and setup new_key to point to it
// note that we can't re-use any existing RID, as that will cause 2 keys pointing to same RID
// since it's a new RID and won't have any conflict, we can do the INSERT now
txn_mgr->PessimisticPredicateCheck(txn, table_info_->oid_, tuple_new);
auto rid_new = table_info_->table_->InsertTuple({.ts_ = txn->GetTransactionTempTs(), .is_deleted_ = false}, tuple_new, exec_ctx_->GetLockManager(), txn, table_info_->oid_);
BUSTUB_ENSURE(rid_new.has_value(), "Invalid tuple size");
txn->AppendWriteSet(table_info_->oid_, *rid_new);
if (!index->InsertEntry(new_key, *rid_new, txn)) {
txn->SetTainted();
throw ExecutionException("Insert failed: key already exists.");
}
}
return buffer.size();
}
} // namespace bustub
bustub/src/execution/._CMakeLists.txt 000644 000765 000024 00000000243 15127067042 021111 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/execution/PaxHeader/CMakeLists.txt 000644 000765 000024 00000000210 15127067042 022637 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.739097687
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/execution/CMakeLists.txt 000644 000765 000024 00000001636 15127067042 020703 0 ustar 00yanhuang staff 000000 000000 add_library(
bustub_execution
OBJECT
aggregation_executor.cpp
delete_executor.cpp
execution_common.cpp
external_merge_sort_executor.cpp
executor_factory.cpp
filter_executor.cpp
fmt_impl.cpp
hash_join_executor.cpp
index_scan_executor.cpp
init_check_executor.cpp
insert_executor.cpp
limit_executor.cpp
mock_scan_executor.cpp
nested_index_join_executor.cpp
nested_loop_join_executor.cpp
plan_node.cpp
projection_executor.cpp
seq_scan_executor.cpp
sort_executor.cpp
topn_executor.cpp
topn_per_group_executor.cpp
topn_check_executor.cpp
update_executor.cpp
values_executor.cpp
window_function_executor.cpp
)
set(ALL_OBJECT_FILES
${ALL_OBJECT_FILES} $
PARENT_SCOPE)
bustub/src/execution/._seq_scan_executor.cpp 000644 000765 000024 00000000243 15127067042 022567 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/execution/PaxHeader/seq_scan_executor.cpp 000644 000765 000024 00000000210 15127067042 024315 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.739352688
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/execution/seq_scan_executor.cpp 000644 000765 000024 00000005101 15127067042 022350 0 ustar 00yanhuang staff 000000 000000 //===----------------------------------------------------------------------===//
//
// BusTub
//
// seq_scan_executor.cpp
//
// Identification: src/execution/seq_scan_executor.cpp
//
// Copyright (c) 2015-2021, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include "binder/tokens.h"
#include "execution/execution_common.h"
#include "execution/executors/seq_scan_executor.h"
#include
#include "common/macros.h"
#include "execution/expressions/constant_value_expression.h"
#include "storage/table/table_iterator.h"
#include "concurrency/transaction_manager.h"
#include "type/type_id.h"
#include "type/value_factory.h"
namespace bustub {
SeqScanExecutor::SeqScanExecutor(ExecutorContext *exec_ctx, const SeqScanPlanNode *plan) : AbstractExecutor(exec_ctx), plan_(plan) {
table_info_ = exec_ctx_->GetCatalog()->GetTable(plan_->GetTableOid());
const auto& predicate = plan_->filter_predicate_ ? plan_->filter_predicate_ : std::make_shared(ValueFactory::GetBooleanValue(true));
exec_ctx->GetTransaction()->AppendScanPredicate(table_info_->oid_, predicate);
exec_ctx->GetTransactionManager()->InsertScanPredicate(exec_ctx->GetTransaction(), table_info_->oid_, predicate);
}
void SeqScanExecutor::Init() {
table_iter_ = std::make_shared(table_info_->table_->MakeIterator());
}
auto SeqScanExecutor::Next(Tuple *tuple_out, RID *rid_out) -> bool {
while (!table_iter_->IsEnd()) {
const auto rid = table_iter_->GetRID();
++(*table_iter_);
auto [meta, tuple, undo_link] =
GetTupleAndUndoLink(exec_ctx_->GetTransactionManager(), table_info_->table_.get(), rid);
auto undo_logs_opt = CollectUndoLogs(rid, meta, tuple, undo_link, exec_ctx_->GetTransaction(),
exec_ctx_->GetTransactionManager());
// tuple is deleted at the moment
if (!undo_logs_opt.has_value()) continue;
const auto &undo_logs = *undo_logs_opt;
auto tuple_opt = ReconstructTuple(&table_info_->schema_, tuple, meta, undo_logs);
if (!tuple_opt.has_value()) continue;
tuple = *tuple_opt;
if (plan_->filter_predicate_) {
auto val = plan_->filter_predicate_->Evaluate(&tuple, table_info_->schema_);
BUSTUB_ENSURE(val.GetTypeId() == BOOLEAN, "Predicate should be evaluated as boolean");
if (!val.GetAs()) continue;
}
*tuple_out = tuple;
*rid_out = rid;
return true;
}
return false;
}
} // namespace bustub
bustub/src/execution/._filter_executor.cpp 000644 000765 000024 00000000243 15127067042 022260 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/execution/PaxHeader/filter_executor.cpp 000644 000765 000024 00000000207 15127067042 024014 x ustar 00yanhuang staff 000000 000000 29 mtime=1767665186.73959848
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/execution/filter_executor.cpp 000644 000765 000024 00000001644 15127067042 022051 0 ustar 00yanhuang staff 000000 000000 #include "execution/executors/filter_executor.h"
#include "common/exception.h"
#include "type/value_factory.h"
namespace bustub {
FilterExecutor::FilterExecutor(ExecutorContext *exec_ctx, const FilterPlanNode *plan,
std::unique_ptr &&child_executor)
: AbstractExecutor(exec_ctx), plan_(plan), child_executor_(std::move(child_executor)) {}
void FilterExecutor::Init() {
// Initialize the child executor
child_executor_->Init();
}
auto FilterExecutor::Next(Tuple *tuple, RID *rid) -> bool {
auto filter_expr = plan_->GetPredicate();
while (true) {
// Get the next tuple
const auto status = child_executor_->Next(tuple, rid);
if (!status) {
return false;
}
auto value = filter_expr->Evaluate(tuple, child_executor_->GetOutputSchema());
if (!value.IsNull() && value.GetAs()) {
return true;
}
}
}
} // namespace bustub
bustub/src/execution/._execution_common.cpp 000644 000765 000024 00000000243 15127067042 022430 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/execution/PaxHeader/execution_common.cpp 000644 000765 000024 00000000210 15127067042 024156 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.739873981
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/execution/execution_common.cpp 000644 000765 000024 00000044771 15127067042 022231 0 ustar 00yanhuang staff 000000 000000 //===----------------------------------------------------------------------===//
//
// BusTub
//
// execution_common.cpp
//
// Identification: src/execution/execution_common.cpp
//
// Copyright (c) 2024-2024, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include "execution/execution_common.h"
#include
#include
#include
#include
#include "binder/bound_order_by.h"
#include "catalog/catalog.h"
#include "catalog/column.h"
#include "catalog/schema.h"
#include "common/config.h"
#include "common/macros.h"
#include "concurrency/transaction.h"
#include "concurrency/transaction_manager.h"
#include "fmt/core.h"
#include "storage/table/table_heap.h"
#include "storage/table/tuple.h"
#include "type/type.h"
#include "type/value_factory.h"
namespace bustub {
std::unique_ptr GetSchema(const UndoLog& log, const Schema& base_schema) {
std::vector columns;
for (size_t i = 0; i < log.modified_fields_.size(); i++) {
if (log.modified_fields_[i]) {
columns.push_back(base_schema.GetColumn(i));
}
}
return std::make_unique(columns);
}
TupleComparator::TupleComparator(std::vector order_bys) : order_bys_(std::move(order_bys)) {}
auto TupleComparator::operator()(const SortEntry &entry_a, const SortEntry &entry_b) const -> bool {
BUSTUB_ENSURE(entry_a.first.size() == entry_b.first.size(), "# of sort key mismatch");
BUSTUB_ENSURE(entry_a.first.size() == order_bys_.size(), "# of order bys mismatch");
for (size_t i = 0; i < order_bys_.size(); i++) {
const auto& lhs = entry_a.first[i];
const auto& rhs = entry_b.first[i];
if (lhs.CompareNotEquals(rhs) == CmpBool::CmpTrue) {
if (order_bys_[i].first == OrderByType::ASC || order_bys_[i].first == OrderByType::DEFAULT) {
return lhs.CompareLessThan(rhs) == CmpBool::CmpTrue;
} else {
return lhs.CompareGreaterThan(rhs) == CmpBool::CmpTrue;
}
}
}
// every key equals, we should return false
return false;
}
auto GenerateSortKey(const Tuple &tuple, const std::vector &order_bys, const Schema &schema) -> SortKey {
std::vector keys;
for (const auto& [type, expr]: order_bys) {
keys.push_back(expr->Evaluate(&tuple, schema));
}
return keys;
}
/**
* Above are all you need for P3.
* You can ignore the remaining part of this file until P4.
*/
/**
* @brief Reconstruct a tuple by applying the provided undo logs from the base tuple. All logs in the undo_logs are
* applied regardless of the timestamp
*
* @param schema The schema of the base tuple and the returned tuple.
* @param base_tuple The base tuple to start the reconstruction from.
* @param base_meta The metadata of the base tuple.
* @param undo_logs The list of undo logs to apply during the reconstruction, the front is applied first.
* @return An optional tuple that represents the reconstructed tuple. If the tuple is deleted as the result, returns
* std::nullopt.
*/
auto ReconstructTuple(const Schema *schema, const Tuple &base_tuple, const TupleMeta &base_meta,
const std::vector &undo_logs) -> std::optional {
return ReconstructTupleImpl(schema, base_tuple, base_meta, undo_logs, nullptr);
}
// the tuple_history saves history from latest tuple until earliest tuple, inclusive
auto ReconstructTupleImpl(const Schema *schema, const Tuple &base_tuple, const TupleMeta &base_meta, const std::vector &undo_logs, std::vector> *tuple_history) -> std::optional {
// values for the reconstructed FULL tuples
// can ONLY be either full or empty
std::vector values;
if (!base_meta.is_deleted_) {
for (size_t i = 0; i < schema->GetColumnCount(); i++) {
values.emplace_back(base_tuple.GetValue(schema, i));
}
if (tuple_history) tuple_history->emplace_back(base_tuple);
} else {
if (tuple_history) tuple_history->emplace_back(std::nullopt);
}
for (auto &log : undo_logs) {
if (log.is_deleted_) {
values.clear();
if (tuple_history) tuple_history->emplace_back(std::nullopt);
} else {
// first fill the values with NULL
if (values.empty()) {
for (size_t i = 0; i < schema->GetColumnCount(); i++) {
values.emplace_back(ValueFactory::GetNullValueByType(schema->GetColumn(i).GetType()));
}
}
// then read undo logs and fill the values
size_t col_index = 0;
const auto log_schema = GetSchema(log, *schema);
for (size_t i = 0; i < log.modified_fields_.size(); i++)
if (log.modified_fields_[i]) {
const auto &value = log.tuple_.GetValue(log_schema.get(), col_index++);
values[i] = value;
}
if (tuple_history) tuple_history->emplace_back(Tuple(values, schema));
}
}
if (values.empty()) {
return {};
}
return Tuple(values, schema);
}
/**
* @brief Collects the undo logs sufficient to reconstruct the tuple w.r.t. the txn.
*
* @param rid The RID of the tuple.
* @param base_meta The metadata of the base tuple.
* @param base_tuple The base tuple.
* @param undo_link The undo link to the latest undo log.
* @param txn The transaction.
* @param txn_mgr The transaction manager.
* @return An optional vector of undo logs to pass to ReconstructTuple(). std::nullopt if the tuple did not exist at the
* time.
*/
auto CollectUndoLogs(RID rid, const TupleMeta &base_meta, const Tuple &base_tuple, std::optional undo_link,
Transaction *txn, TransactionManager *txn_mgr) -> std::optional> {
if (base_meta.ts_ >= TXN_START_ID) {
// note that UndoLogs should never contain temporary transaction timestamps
if (txn->GetTransactionTempTs() == base_meta.ts_) {
// the tuple only visible to the txn that modifying it
return std::vector();
}
}
// The tuple in the table heap is the most recent data relative to the read timestamp
if (txn->GetReadTs() >= base_meta.ts_) {
return std::vector();
}
// if base tuple not visible and we can't trace back, means the tuple did not exist at the timestamp
if (!undo_link.has_value()) {
return {};
}
std::vector undo_logs;
auto link = undo_link.value();
timestamp_t ts = base_meta.ts_;
while (ts > txn->GetReadTs() && link.IsValid()) {
auto log = txn_mgr->GetUndoLog(link);
link = log.prev_version_;
ts = log.ts_;
undo_logs.emplace_back(std::move(log));
}
// if all undo logs can not make ts < read_ts, then it means the tuple do not exist at read_ts
if (ts > txn->GetReadTs()) return {};
return undo_logs;
}
/**
* @brief Generates a new undo log as the transaction tries to modify this tuple at the first time.
*
* @param schema The schema of the table.
* @param base_tuple The base tuple before the update, the one retrieved from the table heap. nullptr if the tuple is
* deleted.
* @param target_tuple The target tuple after the update. nullptr if this is a deletion.
* @param ts The timestamp of the base tuple.
* @param prev_version The undo link to the latest undo log of this tuple.
* @return The generated undo log.
*/
auto GenerateNewUndoLog(const Schema *schema, const Tuple *base_tuple, const Tuple *target_tuple, timestamp_t ts,
UndoLink prev_version) -> UndoLog {
BUSTUB_ENSURE(base_tuple || target_tuple, "base and target can not be both NULL");
if (base_tuple == nullptr) {
return {.is_deleted_ = true, .ts_ = ts, .prev_version_ = prev_version};
}
if (target_tuple == nullptr) {
return {.is_deleted_ = false, .modified_fields_ = std::vector(schema->GetColumnCount(), true), .tuple_ = *base_tuple, .ts_ = ts, .prev_version_ = prev_version};
}
std::vector values;
std::vector columns;
std::vector modified_fields(schema->GetColumnCount(), false);
for (size_t i = 0; i < schema->GetColumnCount(); i++) {
const auto& src = base_tuple->GetValue(schema, i);
const auto& dst = target_tuple->GetValue(schema, i);
if (!src.CompareExactlyEquals(dst)) {
modified_fields[i] = true;
values.push_back(src);
columns.push_back(schema->GetColumn(i));
}
}
Schema log_schema(columns);
return {.is_deleted_ = false, .modified_fields_ = std::move(modified_fields), .tuple_ = Tuple(values, &log_schema), .ts_ = ts, .prev_version_ = prev_version};
}
/**
* @brief Generate the updated undo log to replace the old one, whereas the tuple is already modified by this txn once.
*
* @param schema The schema of the table.
* @param base_tuple The base tuple before the update, the one retrieved from the table heap. nullptr if the tuple is
* deleted.
* @param target_tuple The target tuple after the update. nullptr if this is a deletion.
* @param log The original undo log.
* @return The updated undo log.
*/
auto GenerateUpdatedUndoLog(const Schema *schema, const Tuple *base_tuple, const Tuple *target_tuple,
const UndoLog &log) -> UndoLog {
BUSTUB_ENSURE(base_tuple || target_tuple, "base and target can not be both NULL");
/*
* Hold invariant: the UndoLog always revert the `target_tuple` back to its original state at BEGIN of transaction.
*/
// CASE 1: for INSERT then following any updates, we simply do delete when undo
// CASE 2: if the tuple is deleted the inserted, the old UndoLog will revert it into good shape; we don't even check target_tuple
if (log.is_deleted_ || base_tuple == nullptr) {
return log;
}
// if tuple is updated then deleted now, we should reconstruct the original tuple, save all columns into undo log
// you can't simply return old undo log, as it's not compatible with `target_tuple == nullptr`
if (target_tuple == nullptr) {
auto tuple = ReconstructTuple(schema, *base_tuple, {.is_deleted_ = false}, {log});
return {.is_deleted_ = false,
.modified_fields_ = std::vector(schema->GetColumnCount(), true),
.tuple_ = *tuple,
.ts_ = log.ts_,
.prev_version_ = log.prev_version_};
}
std::vector values;
std::vector columns;
std::vector modified_fields = log.modified_fields_;
for (size_t i = 0, log_idx = 0; i < schema->GetColumnCount(); i++) {
if (modified_fields[i]) {
const auto log_schema = GetSchema(log, *schema);
values.push_back(log.tuple_.GetValue(log_schema.get(), log_idx++));
columns.push_back(schema->GetColumn(i));
} else {
const auto& src = base_tuple->GetValue(schema, i);
const auto& dst = target_tuple->GetValue(schema, i);
if (!src.CompareExactlyEquals(dst)) {
modified_fields[i] = true;
values.push_back(src);
columns.push_back(schema->GetColumn(i));
}
}
}
Schema log_schema(columns);
return {.is_deleted_ = false, .modified_fields_ = std::move(modified_fields), .tuple_ = Tuple(values, &log_schema), .ts_ = log.ts_, .prev_version_ = log.prev_version_};
}
void TxnMgrDbg(const std::string &info, TransactionManager *txn_mgr, const TableInfo *table_info,
TableHeap *table_heap) {
auto format_ts = [](timestamp_t ts) {
if (ts >= TXN_START_ID) {
return std::string("txn") + std::to_string(ts ^ TXN_START_ID);
} else {
return std::to_string(ts);
}
};
// always use stderr for printing logs...
fmt::println(stderr, "debug_hook: {}", info);
auto iter = table_heap->MakeEagerIterator();
while (!iter.IsEnd()) {
const auto &rid = iter.GetRID();
const auto &[meta, tuple] = iter.GetTuple();
++iter;
fmt::println(stderr, "RID={}/{} ts={} tuple={}", rid.GetPageId(), rid.GetSlotNum(), format_ts(meta.ts_),
meta.is_deleted_ ? "" : tuple.ToString(&table_info->schema_));
auto link = txn_mgr->GetUndoLink(rid);
if (!link.has_value()) continue;
while (link->IsValid()) {
const auto& log_opt = txn_mgr->GetUndoLogOptional(*link);
if (!log_opt.has_value()) break;
const auto& log = *log_opt;
auto schema = GetSchema(log, table_info->schema_);
fmt::println(stderr, " ts={} tuple={} link={}@[{}]", log.ts_, log.is_deleted_ ? "" : log.tuple_.ToString(schema.get()), format_ts(link->prev_txn_), link->prev_log_idx_);
link = log.prev_version_;
}
}
// We recommend implementing this function as traversing the table heap and print the version chain. An example output
// of our reference solution:
//
// debug_hook: before verify scan
// RID=0/0 ts=txn8 tuple=(1, , )
// txn8@0 (2, _, _) ts=1
// RID=0/1 ts=3 tuple=(3, , )
// txn5@0 ts=2
// txn3@0 (4, , ) ts=1
// RID=0/2 ts=4 tuple=(, , )
// txn7@0 (5, , ) ts=3
// RID=0/3 ts=txn6 tuple=(, , )
// txn6@0 (6, , ) ts=2
// txn3@1 (7, _, _) ts=1
}
void CheckWriteConflict(const TupleMeta &meta, Transaction *txn, bool check_deleted) {
if (meta.ts_ >= TXN_START_ID) {
if (meta.ts_ != txn->GetTransactionTempTs()) {
txn->SetTainted();
throw ExecutionException("Tuple being modified by another txn");
}
} else {
if (meta.ts_ > txn->GetReadTs()) {
txn->SetTainted();
throw ExecutionException("Tuple already updated by a newer txn");
}
}
// for DELETE AND UPDATE, we can not operate on an already deleted tuple
// but for INSERT, it is possible we insert into a deleted tuple through index
if (check_deleted) {
if (meta.is_deleted_) {
txn->SetTainted();
throw ExecutionException("Tuple already deleted by another txn");
}
}
}
void UpdateTupleImpl(const RID &rid, const TupleMeta &meta, const std::optional& link, const std::optional& base_tuple, const Tuple &tuple, TransactionManager* txn_mgr, Transaction *txn, std::shared_ptr table_info) {
txn_mgr->PessimisticPredicateCheck(txn, table_info->oid_, tuple);
if (base_tuple.has_value()) {
txn_mgr->PessimisticPredicateCheck(txn, table_info->oid_, *base_tuple);
}
auto check_func = [&meta](const TupleMeta &cur_meta, const Tuple &tuple, RID rid, std::optional) {
// 1. obviously, we need to ensure `ts` is still the same when persisting our changes
// 2. for INSERT scenario, we need also ensure is_deleted_ flag hasn't change when we're inserting into a deleted tuple
return meta == cur_meta;
};
bool update_result = false;
// within same txn, we might already modified this tuple
// this can be detected by checking if tuple meta has a txn ID as its ts
const TupleMeta new_meta{.ts_ = txn->GetTransactionTempTs(), .is_deleted_ = false};
const auto base_tuple_ptr = base_tuple.has_value() ? &*base_tuple : nullptr;
if (meta.ts_ != txn->GetTransactionTempTs()) {
// if the tuple is committed by other txn, we have to generate a new undo log for it
const auto &new_log = GenerateNewUndoLog(&table_info->schema_, base_tuple_ptr, &tuple, meta.ts_, link.has_value() ? *link : UndoLink{});
const auto new_link = txn->AppendUndoLog(new_log);
update_result = UpdateTupleAndUndoLink(txn_mgr, rid, new_link, table_info->table_.get(), txn, new_meta, tuple, check_func);
} else {
// if the tuple is being updated by current txn, we update the undo log in the current transaction if there is one
// and then update the TableHeap tuple.
using namespace std::placeholders;
if (link.has_value() && link->IsValid()) {
const auto &log = txn_mgr->GetUndoLog(*link);
const auto &updated_log = GenerateUpdatedUndoLog(&table_info->schema_, base_tuple_ptr, &tuple, log);
txn->ModifyUndoLog(link->prev_log_idx_, updated_log);
}
// TODO: actually we don't have to do any check here
update_result = table_info->table_->UpdateTupleInPlace(new_meta, tuple, rid, std::bind(check_func, _1, _2, _3, std::nullopt));
}
if (!update_result) {
txn->SetTainted();
throw ExecutionException("Update failed: tuple modified by another txn");
}
txn->AppendWriteSet(table_info->oid_, rid);
}
void DeleteTupleImpl(const RID &rid, const TupleMeta &meta, const std::optional& link, const Tuple &base_tuple, TransactionManager* txn_mgr, Transaction *txn, std::shared_ptr table_info, bool ignore_delete_in_txn) {
txn_mgr->PessimisticPredicateCheck(txn, table_info->oid_, base_tuple);
auto check_func = [&meta](const TupleMeta &cur_meta, const Tuple &tuple, RID rid, std::optional) {
return cur_meta.ts_ == meta.ts_;
};
// for physical storage of the tuple, we do soft delete
TupleMeta new_meta{.ts_ = txn->GetTransactionTempTs(), .is_deleted_ = true};
bool update_result = false;
bool add_write_set = true;
// within same txn, we might already modified this tuple
// this can be detected by checking if tuple meta has a txn ID as its ts
// if we're deleting a committed tuple:
if (meta.ts_ != txn->GetTransactionTempTs()) {
const auto &new_log = GenerateNewUndoLog(&table_info->schema_, &base_tuple, nullptr, meta.ts_, link.has_value() ? *link : UndoLink{});
const auto new_link = txn->AppendUndoLog(new_log);
update_result = UpdateTupleAndUndoLink(txn_mgr, rid, new_link, table_info->table_.get(), txn, new_meta, base_tuple, check_func);
} else {
if (link.has_value() && link->IsValid()) {
const auto &log = txn_mgr->GetUndoLog(*link);
const auto &updated_log = GenerateUpdatedUndoLog(&table_info->schema_, &base_tuple, nullptr, log);
txn->ModifyUndoLog(link->prev_log_idx_, updated_log);
} else if (ignore_delete_in_txn) {
/*
* Special handling for INSERT => UPDATE => DELETE scenario:
* If the tuple has no undo log and inserted in current txn, we simply mark it as deleted
* Note that:
* 1. It is impossible to have INSERT => UPDATE => DELETE => INSERT sequence on a tuple, since the last insert will generate different RID.
* 2. Also, the newly inserted tuple is not visible to other txn since it has temp ts, thus we don't need atomic update.
* 3. Set ts = 0 ensures once this txn committed, no other txn could see this tuple.
* 4. We don't add write set for this tuple to avoid its `ts` being updated at commit, or this tuple being validated at VerifyTxn.
*/
add_write_set = false;
new_meta.ts_ = 0;
}
using namespace std::placeholders;
update_result = table_info->table_->UpdateTupleInPlace(new_meta, base_tuple, rid, std::bind(check_func, _1, _2, _3, std::nullopt));
}
if (!update_result) {
txn->SetTainted();
throw ExecutionException("Update failed: tuple modified by another txn");
}
if (add_write_set) {
txn->AppendWriteSet(table_info->oid_, rid);
}
}
} // namespace bustub
bustub/src/execution/._values_executor.cpp 000644 000765 000024 00000000243 15127067042 022272 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/execution/PaxHeader/values_executor.cpp 000644 000765 000024 00000000210 15127067042 024020 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.740122732
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/execution/values_executor.cpp 000644 000765 000024 00000001363 15127067042 022061 0 ustar 00yanhuang staff 000000 000000 #include "execution/executors/values_executor.h"
namespace bustub {
ValuesExecutor::ValuesExecutor(ExecutorContext *exec_ctx, const ValuesPlanNode *plan)
: AbstractExecutor(exec_ctx), plan_(plan), dummy_schema_(Schema({})) {}
void ValuesExecutor::Init() { cursor_ = 0; }
auto ValuesExecutor::Next(Tuple *tuple, RID *rid) -> bool {
if (cursor_ >= plan_->GetValues().size()) {
return false;
}
std::vector values{};
values.reserve(GetOutputSchema().GetColumnCount());
const auto &row_expr = plan_->GetValues()[cursor_];
for (const auto &col : row_expr) {
values.push_back(col->Evaluate(nullptr, dummy_schema_));
}
*tuple = Tuple{values, &GetOutputSchema()};
cursor_ += 1;
return true;
}
} // namespace bustub
bustub/src/execution/._plan_node.cpp 000644 000765 000024 00000000243 15127067042 021014 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/execution/PaxHeader/plan_node.cpp 000644 000765 000024 00000000210 15127067042 022542 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.740393482
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/execution/plan_node.cpp 000644 000765 000024 00000005730 15127067042 020605 0 ustar 00yanhuang staff 000000 000000 #include
#include
#include
#include "binder/table_ref/bound_base_table_ref.h"
#include "catalog/catalog.h"
#include "catalog/column.h"
#include "catalog/schema.h"
#include "common/exception.h"
#include "execution/plans/aggregation_plan.h"
#include "execution/plans/nested_loop_join_plan.h"
#include "execution/plans/projection_plan.h"
#include "execution/plans/seq_scan_plan.h"
#include "execution/plans/window_plan.h"
namespace bustub {
auto SeqScanPlanNode::InferScanSchema(const BoundBaseTableRef &table) -> Schema {
std::vector schema;
for (const auto &column : table.schema_.GetColumns()) {
auto col_name = fmt::format("{}.{}", table.GetBoundTableName(), column.GetName());
schema.emplace_back(col_name, column);
}
return Schema(schema);
}
auto NestedLoopJoinPlanNode::InferJoinSchema(const AbstractPlanNode &left, const AbstractPlanNode &right) -> Schema {
std::vector schema;
for (const auto &column : left.OutputSchema().GetColumns()) {
schema.emplace_back(column);
}
for (const auto &column : right.OutputSchema().GetColumns()) {
schema.emplace_back(column);
}
return Schema(schema);
}
auto ProjectionPlanNode::InferProjectionSchema(const std::vector &expressions) -> Schema {
std::vector schema;
for (const auto &expr : expressions) {
auto type_id = expr->GetReturnType();
schema.emplace_back(expr->GetReturnType().WithColumnName(""));
}
return Schema(schema);
}
auto ProjectionPlanNode::RenameSchema(const Schema &schema, const std::vector &col_names) -> Schema {
std::vector output;
if (col_names.size() != schema.GetColumnCount()) {
throw bustub::Exception("mismatched number of columns");
}
size_t idx = 0;
for (const auto &column : schema.GetColumns()) {
output.emplace_back(col_names[idx++], column);
}
return Schema(output);
}
auto AggregationPlanNode::InferAggSchema(const std::vector &group_bys,
const std::vector &aggregates,
const std::vector &agg_types) -> Schema {
std::vector output;
output.reserve(group_bys.size() + aggregates.size());
for (const auto &column : group_bys) {
output.emplace_back(column->GetReturnType().WithColumnName(""));
}
for (size_t idx = 0; idx < aggregates.size(); idx++) {
// TODO(chi): correctly infer agg call return type
output.emplace_back("", TypeId::INTEGER);
}
return Schema(output);
}
auto WindowFunctionPlanNode::InferWindowSchema(const std::vector &columns) -> Schema {
std::vector output;
output.reserve(columns.size());
// TODO(avery): correctly infer window call return type
for (const auto &column : columns) {
output.emplace_back(column->GetReturnType().WithColumnName(""));
}
return Schema(output);
}
} // namespace bustub
bustub/src/execution/._projection_executor.cpp 000644 000765 000024 00000000243 15127067042 023147 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/execution/PaxHeader/projection_executor.cpp 000644 000765 000024 00000000210 15127067042 024675 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.740658066
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/execution/projection_executor.cpp 000644 000765 000024 00000002031 15127067042 022727 0 ustar 00yanhuang staff 000000 000000 #include "execution/executors/projection_executor.h"
#include "storage/table/tuple.h"
namespace bustub {
ProjectionExecutor::ProjectionExecutor(ExecutorContext *exec_ctx, const ProjectionPlanNode *plan,
std::unique_ptr &&child_executor)
: AbstractExecutor(exec_ctx), plan_(plan), child_executor_(std::move(child_executor)) {}
void ProjectionExecutor::Init() {
// Initialize the child executor
child_executor_->Init();
}
auto ProjectionExecutor::Next(Tuple *tuple, RID *rid) -> bool {
Tuple child_tuple{};
// Get the next tuple
const auto status = child_executor_->Next(&child_tuple, rid);
if (!status) {
return false;
}
// Compute expressions
std::vector values{};
values.reserve(GetOutputSchema().GetColumnCount());
for (const auto &expr : plan_->GetExpressions()) {
values.push_back(expr->Evaluate(&child_tuple, child_executor_->GetOutputSchema()));
}
*tuple = Tuple{values, &GetOutputSchema()};
return true;
}
} // namespace bustub
bustub/src/execution/._topn_check_executor.cpp 000644 000765 000024 00000000243 15127067042 023110 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/execution/PaxHeader/topn_check_executor.cpp 000644 000765 000024 00000000210 15127067042 024636 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.740806067
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/execution/topn_check_executor.cpp 000644 000765 000024 00000002752 15127067042 022702 0 ustar 00yanhuang staff 000000 000000 //===----------------------------------------------------------------------===//
//
// BusTub
//
// topn_check_executor.cpp
//
// Identification: src/execution/topn_check_executor.cpp
//
// Copyright (c) 2015-2021, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include "execution/executors/topn_check_executor.h"
#include "execution/executors/topn_executor.h"
namespace bustub {
TopNCheckExecutor::TopNCheckExecutor(ExecutorContext *exec_ctx, const TopNPlanNode *plan,
std::unique_ptr &&child_executor, TopNExecutor *topn_executor)
: AbstractExecutor{exec_ctx},
plan_(plan),
child_executor_{std::move(child_executor)},
topn_executor_(topn_executor) {}
void TopNCheckExecutor::Init() {
if (!child_executor_) {
return;
}
prev_ = 0;
// Initialize the child executor
child_executor_->Init();
}
auto TopNCheckExecutor::Next(Tuple *tuple, RID *rid) -> bool {
if (!child_executor_) {
return EXECUTOR_EXHAUSTED;
}
BUSTUB_ASSERT(topn_executor_->GetNumInHeap() <= plan_->GetN(), "Cannot store more than N elements");
if (prev_ > 0 && prev_ < plan_->GetN()) {
BUSTUB_ASSERT(topn_executor_->GetNumInHeap() - prev_ == 1, "Did you implement GetNumInHeap() properly?");
}
prev_ = topn_executor_->GetNumInHeap();
// Emit the next tuple
return child_executor_->Next(tuple, rid);
}
} // namespace bustub
bustub/src/execution/._external_merge_sort_executor.cpp 000644 000765 000024 00000000243 15127067042 025043 0 ustar 00yanhuang staff 000000 000000 Mac OS X 2 q ATTR com.apple.provenance Gx bustub/src/execution/PaxHeader/external_merge_sort_executor.cpp 000644 000765 000024 00000000210 15127067042 026571 x ustar 00yanhuang staff 000000 000000 30 mtime=1767665186.741042317
57 LIBARCHIVE.xattr.com.apple.provenance=AQIAg/TGRwN4ygg
49 SCHILY.xattr.com.apple.provenance= Gx
bustub/src/execution/external_merge_sort_executor.cpp 000644 000765 000024 00000011245 15127067042 024632 0 ustar 00yanhuang staff 000000 000000 //===----------------------------------------------------------------------===//
//
// BusTub
//
// external_merge_sort_executor.cpp
//
// Identification: src/execution/external_merge_sort_executor.cpp
//
// Copyright (c) 2015-2024, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#include "execution/executors/external_merge_sort_executor.h"
#include
#include
#include
#include
#include "common/config.h"
#include "common/macros.h"
#include "execution/execution_common.h"
#include "execution/plans/sort_plan.h"
namespace bustub {
template
ExternalMergeSortExecutor