.gitignore

-*
+# IDE
+.idea/
 
-!*.c
-!*.h
-!*.cpp
-!*.hpp
-!*.tcc
-!*.sql
-!*.script
-!*.patch
-!*.txt
-!*.sh
-!*.tex
-!*.bib
-!*.ods
-!*.png
-!*.eps
-!*.pdf
-!*.ll
-!*.md
-!*.cmd
-!*.csv
-!Makefile
-!Readme
-!empty
-!.gitignore
-
-# even if they are in subdirectories
-!*/
+# sample data
+tables/
 
 # build dirs
 cmake-build-*/

.gitlab-ci.yml

+# ---------------------------------------------------------------------------
+# TARDISDB
+# ---------------------------------------------------------------------------
+
+stages:
+    - build
+    - test
+
+build_debug:
+    stage: build
+    script: 
+        - mkdir -p build
+        - cd build
+        - cmake -GNinja -DCMAKE_BUILD_TYPE=Debug -DTUPLE_STREAM_REQUIRED=true ..
+        - ninja
+    cache:
+        key: "$CI_COMMIT_REF_NAME-debug"
+        paths:
+            - build/
+        policy: pull-push
+    artifacts:
+        paths:
+            - ./build/tester
+        expire_in: 1 hrs
+    tags:
+        - "clang-6.0"
+        - "llvm-6.0"
+        - "cmake"
+        - "python3"
+
+tester:
+    stage: test
+    script:
+        - ./build/tester
+    dependencies:
+        - build_debug
+    tags:
+        - "clang-6.0"
+        - "llvm-6.0"
+        - "cmake"
+        - "python3"
\ No newline at end of file

CMakeLists.txt

 cmake_minimum_required(VERSION 3.5)
 project(protodb)
 
-set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD 17)
+
+set(LIBXML_AVAILABLE false)
+set(ENABLE_PERFBENCHMARKING false)
+set(USE_DATA_VERSIONING true)
+set(USE_HYRISE false)
+set(TUPLE_STREAM_REQUIRED true)
+
+### set up boost
+if(APPLE)
+	list(APPEND CMAKE_PREFIX_PATH /usr/local/opt/boost/lib/cmake/Boost-1.72.0)
+endif(APPLE)
+find_package(Boost)
+INCLUDE_DIRECTORIES( ${Boost_INCLUDE_DIRS} )
 
 ### set up llvm
-find_package(LLVM REQUIRED CONFIG)
+if(APPLE)
+	list(APPEND CMAKE_PREFIX_PATH /usr/local/opt/llvm@7)
+	find_package(LLVM 7.1 REQUIRED CONFIG)
+else(NOT APPLE)
+	find_package(LLVM 7 REQUIRED CONFIG)
+endif(APPLE)
 message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
 message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
-include_directories(${LLVM_INCLUDE_DIRS} .)
+
+### tools
+include("${CMAKE_SOURCE_DIR}/vendor/googletest.cmake")
+include("${CMAKE_SOURCE_DIR}/vendor/gflags.cmake")
+if(ENABLE_PERFBENCHMARKING)
+	include("${CMAKE_SOURCE_DIR}/vendor/perfevent.cmake")
+endif(ENABLE_PERFBENCHMARKING)
+if(USE_HYRISE)
+	include("${CMAKE_SOURCE_DIR}/vendor/hyrise.cmake")
+endif(USE_HYRISE)
+
+include_directories(.
+		${LLVM_INCLUDE_DIRS}
+		${GFLAGS_INCLUDE_DIR}
+		${HYRISE_INCLUDE_DIR}
+		${CMAKE_SOURCE_DIR}/include/tardisdb
+		)
 add_definitions(${LLVM_DEFINITIONS})
 
 llvm_map_components_to_libnames(LLVM_LIBS
@@ -23,6 +57,38 @@ llvm_map_components_to_libnames(LLVM_LIBS
 	ScalarOpts
 )
 
+### libraries
+if(NOT USE_HYRISE)
+	include(tools/sqlParser/local.cmake)
+endif(NOT USE_HYRISE)
+include(tools/semanticalAnalyser/local.cmake)
+include(tools/queryCompiler/local.cmake)
+include(tools/queryExecutor/local.cmake)
+if(LIBXML_AVAILABLE)
+	include(tools/wikiParser/local.cmake)
+endif(LIBXML_AVAILABLE)
+
+### tests
+include("${CMAKE_SOURCE_DIR}/test/local.cmake")
+
+### executables
+add_executable(sql sql.cpp)
+target_link_libraries(sql dblib queryCompiler queryExecutor)
+
+### benchmarks
+add_executable(semanticalBench benchmark/semanticalBench.cpp)
+target_link_libraries(semanticalBench dblib queryCompiler queryExecutor gflags pthread)
+if(LIBXML_AVAILABLE)
+	target_compile_definitions(semanticalBench PUBLIC -D LIBXML_AVAILABLE=true)
+	target_link_libraries(semanticalBench wikiparser)
+endif(LIBXML_AVAILABLE)
+if(USE_DATA_VERSIONING)
+	target_compile_definitions(semanticalBench PUBLIC -D USE_DATA_VERSIONING=true)
+endif(USE_DATA_VERSIONING)
+if(ENABLE_PERFBENCHMARKING)
+	target_compile_definitions(semanticalBench PUBLIC -D PERF_AVAILABLE=true)
+endif(ENABLE_PERFBENCHMARKING)
+
 ### locate source files
 file(GLOB_RECURSE ALGEBRA_FILES "algebra/*.cpp" "algebra/*.hpp" "algebra/*.tcc")
 file(GLOB_RECURSE CODEGEN_FILES "codegen/*.cpp" "codegen/*.hpp" "codegen/*.tcc")
@@ -30,12 +96,12 @@ file(GLOB_RECURSE FOUNDATIONS_FILES "foundations/*.cpp" "foundations/*.hpp" "fou
 file(GLOB_RECURSE NATIVE_FILES "native/*.cpp" "native/*.hpp" "native/*.tcc")
 file(GLOB_RECURSE SQL_FILES "sql/*.cpp" "sql/*.hpp" "sql/*.tcc")
 file(GLOB_RECURSE QUERIES_FILES "queries/*.cpp" "queries/*.hpp" "queries/*.tcc")
-file(GLOB_RECURSE QUERY_COMPILER_FILES "query_compiler/*.cpp" "query_compiler/*.hpp" "query_compiler/*.tcc")
 #file(GLOB_RECURSE TESTS_FILES "tests/*.cpp" "tests/*.hpp" "tests/*.tcc")
 file(GLOB_RECURSE UTILS_FILES "utils/*.cpp" "utils/*.hpp" "utils/*.tcc")
 
-set(SOURCE_FILES
-	main.cpp
+set(THIRD_PARTY_FILES third_party/hexdump.cpp third_party/hexdump.hpp)
+
+set(DB_LIB_SOURCE_FILES
 	${ALGEBRA_FILES}
 	${CODEGEN_FILES}
 	${FOUNDATIONS_FILES}
@@ -44,19 +110,18 @@ set(SOURCE_FILES
 	${QUERIES_FILES}
 	${QUERY_COMPILER_FILES}
 	${UTILS_FILES}
+	${THIRD_PARTY_FILES}
 )
 
-set(THIRD_PARTY third_party/hexdump.cpp third_party/hexdump.hpp)
-
-set(TESTS
+set(TEST_SOURCE_FILES
 #    tests/join_test.cpp # TODO update
-	tests/if_test.cpp
-	tests/loop_test.cpp
-	tests/interop_test.cpp
-	tests/codegen_test.cpp
+#	tests/if_test.cpp
+#	tests/loop_test.cpp
+#	tests/interop_test.cpp
+#	tests/codegen_test.cpp
 	tests/types_test.cpp
 #    tests/query_test.cpp
-	tests/expression_test.cpp
+#	tests/expression_test.cpp
 	tests/groupby_test.cpp
 	tests/tests.cpp
 	tests/tests.hpp
@@ -84,15 +149,55 @@ add_custom_target(
 ### all generated files
 set(GENERATED_SOURCE_FILES ${LOADER_FILE})
 
+### main library
+add_library(dblib ${DB_LIB_SOURCE_FILES})
+if(TUPLE_STREAM_REQUIRED)
+	target_compile_definitions(dblib PUBLIC -D TUPLE_STREAM_REQUIRED=true)
+endif(TUPLE_STREAM_REQUIRED)
+if(USE_DATA_VERSIONING)
+	target_compile_definitions(dblib PUBLIC -D USE_DATA_VERSIONING=true)
+endif(USE_DATA_VERSIONING)
+target_link_libraries(dblib semanticalAnalyser LLVM)
+if(USE_HYRISE)
+	target_compile_definitions(dblib PUBLIC -D USE_HYRISE=true)
+	target_link_libraries(dblib hyriselib)
+else(NOT USE_HYRISE)
+	target_compile_definitions(dblib PUBLIC -D USE_HYRISE=false)
+	target_link_libraries(dblib sqlparser)
+endif(USE_HYRISE)
+
 ### main application
-add_executable(protodb ${SOURCE_FILES} ${GENERATED_SOURCE_FILES} ${THIRD_PARTY} ${TESTS})
-#target_link_libraries(protodb ${LLVM_LIBS})
-target_link_libraries(protodb LLVM)
+add_executable(protodb main.cpp ${GENERATED_SOURCE_FILES} ${TEST_SOURCE_FILES})
+target_link_libraries(protodb dblib queryCompiler queryExecutor)
 
 ### set up dependencies
 add_dependencies(GenerateLoader schema_parser)
 add_dependencies(protodb GenerateLoader)
 
 ### sub projects
-add_subdirectory(standalone_tests)
 add_subdirectory(schema_parser)
+
+### benchmarks
+set(RD_BENCH_SOURCE_FILES
+	benchmark/random.cpp
+)
+
+add_executable(rd_bench ${RD_BENCH_SOURCE_FILES})
+target_link_libraries(rd_bench dblib)
+
+### install
+MACRO(INSTALL_HEADERS_WITH_DIRECTORY HEADER_LIST)
+    FOREACH(HEADER ${${HEADER_LIST}})
+#		message(STATUS ${HEADER})
+		get_filename_component(DIR ${HEADER} DIRECTORY)
+#		message(STATUS ${DIR})
+        install(FILES ${HEADER} DESTINATION include/${DIR})
+    ENDFOREACH(HEADER)
+ENDMACRO(INSTALL_HEADERS_WITH_DIRECTORY)
+
+file(GLOB_RECURSE HS RELATIVE ${CMAKE_SOURCE_DIR} "*.hpp" "*.tcc")
+#message(STATUS ${HS})
+INSTALL_HEADERS_WITH_DIRECTORY(HS)
+
+install(TARGETS dblib DESTINATION lib)
+install(TARGETS sql protodb rd_bench DESTINATION bin)

LICENSE

+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed 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.

algebra/logical/expressions.hpp

@@ -9,7 +9,7 @@
 
 #include "codegen/CodeGen.hpp"
 #include "foundations/exceptions.hpp"
-#include "foundations/InformationUnit.hpp"
+#include "semanticAnalyser/logicalAlgebra/InformationUnit.hpp"
 #include "sql/SqlType.hpp"
 #include "sql/SqlValues.hpp"
 #include "sql/SqlOperators.hpp"

algebra/logical/operators.cpp

@@ -352,9 +352,14 @@ void TableScan::computeProduced()
     // collect the produced attributes
     for (const std::string & columnName : _table.getColumnNames()) {
         auto columnInformation = _table.getCI(columnName);
-        auto iu =  _context.iuFactory.createIU(*this, columnInformation);
+        auto iu =  _context.iuFactory.createIU(getUID(), columnInformation);
         produced.insert(iu);
     }
+
+    //Produce TID column
+    std::unique_ptr<ColumnInformation> &columnInformation = _table.getTIDColumnInformation();
+    auto iu =  _context.iuFactory.createIU(getUID(), columnInformation.get());
+    produced.insert(iu);
 }
 
 void TableScan::computeRequired()
@@ -364,6 +369,72 @@ void TableScan::computeRequired()
     iu_set_t expected = computeExpected(parent, this);
     required.insert(expected.begin(), expected.end());
 }
+//-----------------------------------------------------------------------------
+// Delete operator
+
+Delete::Delete(std::unique_ptr<Operator> child, iu_p_t &tidIU, Table & table) :
+    UnaryOperator(std::move(child)), _table(table), tidIU(std::move(tidIU)) { }
+
+Delete::~Delete() { }
+
+void Delete::accept(OperatorVisitor & visitor) {
+    visitor.visit(*this);
+}
+
+void Delete::computeProduced() {
+    produced.clear();
+}
+
+void Delete::computeRequired() {
+    // "selection" represents the required attributes of the Result operator
+    required.insert(tidIU);
+}
+
+//-----------------------------------------------------------------------------
+// Insert operator
+
+Insert::Insert(QueryContext & context, Table & table, Native::Sql::SqlTuple *tuple, branch_id_t branchId) :
+NullaryOperator(context), _table(table), sqlTuple(tuple), branchId(branchId) { }
+
+Insert::~Insert() { }
+
+void Insert::accept(OperatorVisitor & visitor) {
+    visitor.visit(*this);
+}
+
+void Insert::computeProduced() {
+    produced.clear();
+}
+
+void Insert::computeRequired() {
+
+}
+
+//-----------------------------------------------------------------------------
+// Update operator
+
+Update::Update(std::unique_ptr<Operator> child, std::vector<std::pair<iu_p_t,std::string>> &updateIUValuePairs, Table & table, branch_id_t branchId) :
+UnaryOperator(std::move(child)), _table(table), branchId(branchId), updateIUValuePairs(std::move(updateIUValuePairs)) { }
+
+Update::Update(std::unique_ptr<Operator> child, std::vector<std::pair<iu_p_t,std::string>> &updateIUValuePairs, Table & table) :
+UnaryOperator(std::move(child)), _table(table), branchId(0), updateIUValuePairs(std::move(updateIUValuePairs)) { }
+
+Update::~Update() { }
+
+void Update::accept(OperatorVisitor & visitor) {
+    visitor.visit(*this);
+}
+
+void Update::computeProduced() {
+    produced.clear();
+}
+
+void Update::computeRequired() {
+    // "selection" represents the required attributes of the Result operator
+    for (auto &iu : updateIUValuePairs) {
+        required.insert(iu.first);
+    }
+}
 
 //-----------------------------------------------------------------------------
 // Result operator
@@ -523,6 +594,27 @@ struct Verifier : public OperatorVisitor {
         op.getChild().accept(*this);
     }
 
+    void visit(Insert & op) override
+    {
+
+    }
+
+    void visit(Update & op) override
+    {
+        if (!_result) { return; }
+
+        test(op, op.getChild());
+        op.getChild().accept(*this);
+    }
+
+    void visit(Delete & op) override
+    {
+        if (!_result) { return; }
+
+        test(op, op.getChild());
+        op.getChild().accept(*this);
+    }
+
     void visit(Result & op) override
     {
         if (!_result) { return; }

algebra/logical/operators.hpp

@@ -3,10 +3,11 @@
 
 #include <cstdint>
 #include <memory>
+#include "native/sql/SqlTuple.hpp"
 
 #include "algebra/logical/expressions.hpp"
-#include "foundations/InformationUnit.hpp"
-#include "foundations/QueryContext.hpp"
+#include "semanticAnalyser/logicalAlgebra/InformationUnit.hpp"
+#include "queryCompiler/QueryContext.hpp"
 
 namespace Algebra {
 namespace Logical {
@@ -86,6 +87,9 @@ private:
 class GroupBy;
 class Join;
 class Map;
+class Update;
+class Insert;
+class Delete;
 class Result;
 class Select;
 class TableScan;
@@ -99,6 +103,9 @@ struct OperatorVisitor {
     virtual void visit(GroupBy & op) = 0;
     virtual void visit(Join & op) = 0;
     virtual void visit(Map & op) = 0;
+    virtual void visit(Update & op) = 0;
+    virtual void visit(Insert & op) = 0;
+    virtual void visit(Delete & op) = 0;
     virtual void visit(Result & op) = 0;
     virtual void visit(Select & op) = 0;
     virtual void visit(TableScan & op) = 0;
@@ -420,12 +427,95 @@ protected:
 
 };
 
+//-----------------------------------------------------------------------------
+// Update operator
+
+class Delete : public UnaryOperator {
+public:
+    Delete(std::unique_ptr<Operator> child, iu_p_t &tidIU, Table & table);
+
+    ~Delete() override;
+
+    void accept(OperatorVisitor & visitor) override;
+
+    Table & getTable() const { return _table; }
+
+    iu_p_t &getTIDIU() { return tidIU; }
+
+protected:
+    void computeProduced() override;
+    void computeRequired() override;
+
+    Table & _table;
+
+    iu_p_t tidIU;
+};
+
+//-----------------------------------------------------------------------------
+// Insert operator
+
+class Insert : public NullaryOperator {
+public:
+    Insert(QueryContext & context, Table & table, Native::Sql::SqlTuple *tuple, branch_id_t branchId);
+
+    ~Insert() override;
+
+    void accept(OperatorVisitor & visitor) override;
+
+    Table & getTable() const { return _table; }
+
+    Native::Sql::SqlTuple *getTuple() { return sqlTuple; }
+
+    branch_id_t getBranchId() { return branchId; }
+protected:
+    void computeProduced() override;
+    void computeRequired() override;
+
+    Table & _table;
+    branch_id_t branchId;
+    Native::Sql::SqlTuple *sqlTuple;
+};
+
+//-----------------------------------------------------------------------------
+// Update operator
+
+class Update : public UnaryOperator {
+public:
+    Update(std::unique_ptr<Operator> child, std::vector<std::pair<iu_p_t,std::string>> &updateIUValuePairs, Table & table, branch_id_t branchId);
+
+    Update(std::unique_ptr<Operator> child, std::vector<std::pair<iu_p_t,std::string>> &updateIUValuePairs, Table & table);
+
+
+    ~Update() override;
+
+    void accept(OperatorVisitor & visitor) override;
+
+    Table & getTable() const { return _table; }
+
+    branch_id_t getBranchId() { return branchId; }
+
+    std::vector<std::pair<iu_p_t,std::string>> &getUpdateIUValuePairs() { return updateIUValuePairs; }
+
+protected:
+    void computeProduced() override;
+    void computeRequired() override;
+
+    Table & _table;
+    branch_id_t branchId;
+
+    std::vector<std::pair<iu_p_t,std::string>> updateIUValuePairs;
+};
+
 //-----------------------------------------------------------------------------
 // Result operator
 
 class Result : public UnaryOperator {
 public:
-    enum class Type { PrintToStdOut } _type = Type::PrintToStdOut;
+#if TUPLE_STREAM_REQUIRED
+    enum class Type { PrintToStdOut, TupleStreamHandler } _type = Type::TupleStreamHandler;
+#else
+    enum class Type { PrintToStdOut, TupleStreamHandler } _type = Type::PrintToStdOut;
+#endif
 
     std::vector<iu_p_t> selection;
 
@@ -445,6 +535,12 @@ protected:
 
 class TableScan : public NullaryOperator {
 public:
+    TableScan(QueryContext & context, Table & table, branch_id_t branchId) :
+            NullaryOperator(context),
+            _table(table),
+            branchId(branchId)
+    { }
+
     TableScan(QueryContext & context, Table & table) :
             NullaryOperator(context),
             _table(table)
@@ -456,11 +552,14 @@ public:
 
     Table & getTable() const { return _table; }
 
+    branch_id_t getBranchId() { return branchId; }
+
 protected:
     void computeProduced() override;
     void computeRequired() override;
 
     Table & _table;
+    branch_id_t branchId;
 };
 
 //-----------------------------------------------------------------------------

algebra/physical/Delete.cpp

+#include <llvm/IR/TypeBuilder.h>
+
+#include "algebra/physical/Delete.hpp"
+#include "sql/SqlUtils.hpp"
+#include "sql/SqlValues.hpp"
+#include "foundations/version_management.hpp"
+
+using namespace Sql;
+
+namespace Algebra {
+    namespace Physical {
+
+        Delete::Delete(const logical_operator_t & logicalOperator, std::unique_ptr<Operator> input, iu_p_t &tidIU, Table & table)  :
+                UnaryOperator(std::move(logicalOperator), std::move(input)), table(table), tidIU(std::move(tidIU)) { }
+
+        Delete::~Delete()
+        { }
+
+        void Delete::produce()
+        {
+            tupleCountPtr = _codeGen->CreateAlloca(cg_size_t::getType());
+#ifdef __APPLE__
+            _codeGen->CreateStore(cg_size_t(0ull), tupleCountPtr);
+#else
+            _codeGen->CreateStore(cg_size_t(0ul), tupleCountPtr);
+#endif
+
+            child->produce();
+
+            cg_size_t tupleCnt(_codeGen->CreateLoad(tupleCountPtr));
+
+            Functions::genPrintfCall("Deleted %lu tuples\n", tupleCnt);
+        }
+
+#if !USE_DATA_VERSIONING
+        void delete_tuple_without_versioning(tid_t tid, Table & table, QueryContext & ctx) {
+            table.removeRow(tid);
+        }
+#endif
+
+        void Delete::consume(const iu_value_mapping_t & values, const Operator & src)
+        {
+            cg_size_t tid;
+            for (auto iu : getRequired()) {
+                if (iu->columnInformation->columnName.compare("tid") == 0) {
+                    tid = cg_size_t(values.at(iu)->getLLVMValue());
+                    break;
+                }
+            }
+
+            // Call the delete_tuple function in version_management.hpp
+            llvm::FunctionType * funcDeleteTupleTy = llvm::TypeBuilder<void (size_t, void *, void *), false>::get(_codeGen.getLLVMContext());
+            llvm::Function * func = llvm::cast<llvm::Function>( getThreadLocalCodeGen().getCurrentModuleGen().getModule().getOrInsertFunction("delete_tuple", funcDeleteTupleTy) );
+#if USE_DATA_VERSIONING
+            getThreadLocalCodeGen().getCurrentModuleGen().addFunctionMapping(func,(void *)&delete_tuple);
+#else
+            getThreadLocalCodeGen().getCurrentModuleGen().addFunctionMapping(func,(void *)&delete_tuple_without_versioning);
+#endif
+            llvm::CallInst * result = _codeGen->CreateCall(func, {tid, cg_ptr8_t::fromRawPointer(&table), _codeGen.getCurrentFunctionGen().getArg(1)});
+
+            // increment tuple counter
+            cg_size_t prevCnt(_codeGen->CreateLoad(tupleCountPtr));
+            _codeGen->CreateStore(prevCnt + 1ul, tupleCountPtr);
+        }
+
+    } // end namespace Physical
+} // end namespace Algebra
+

algebra/physical/Delete.hpp

+//
+// Created by Blum Thomas on 2020-05-21.
+//
+
+#ifndef PROTODB_DELETE_HPP
+#define PROTODB_DELETE_HPP
+
+#include "algebra/physical/Operator.hpp"
+
+namespace Algebra {
+    namespace Physical {
+
+        class Delete : public UnaryOperator {
+        public:
+            Delete(const logical_operator_t & logicalOperator, std::unique_ptr<Operator> input, iu_p_t &tidIU, Table & table);
+
+            virtual ~Delete();
+
+            void produce() override;
+            void consume(const iu_value_mapping_t & values, const Operator & src) override;
+
+        private:
+            Table & table;
+            llvm::Value * tupleCountPtr;
+
+            iu_p_t tidIU;
+        };
+    } // end namespace Physical
+} // end namespace Algebra
+
+
+#endif //PROTODB_DELETE_HPP

algebra/physical/HashJoin.cpp

@@ -179,7 +179,11 @@ using join_pair_vec_t = HashJoin::join_pair_vec_t;
 template<Side side>
 static cg_hash_t genJoinHash(const join_pair_vec_t & joinPairs, const iu_value_mapping_t & values)
 {
+#ifdef __APPLE__
+    cg_hash_t seed(0ull);
+#else
     cg_hash_t seed(0ul);
+#endif
 
     // iterate over each join pair and calculate the combined hash
     bool first = true;

algebra/physical/Insert.cpp

+#include "algebra/physical/Insert.hpp"
+#include "sql/SqlUtils.hpp"
+#include "sql/SqlValues.hpp"
+#include "foundations/version_management.hpp"
+#include <llvm/IR/TypeBuilder.h>
+
+#include <iostream>
+
+using namespace Sql;
+
+namespace Algebra {
+    namespace Physical {
+
+        Insert::Insert(const logical_operator_t & logicalOperator, Table & table, Native::Sql::SqlTuple *tuple, QueryContext &context, branch_id_t branchId) :
+                NullaryOperator(std::move(logicalOperator)) , table(table), tuple(tuple), context(context), branchId(branchId)
+        {
+
+        }
+
+        Insert::~Insert()
+        { }
+
+#if !USE_DATA_VERSIONING
+        tid_t insert_tuple_without_versioning(Native::Sql::SqlTuple & tuple, Table & table, QueryContext & ctx) {
+            tid_t tid;
+
+            // store tuple
+            table.addRow(0);
+            size_t column_idx = 0;
+            for (auto & value : tuple.values) {
+                void * ptr = const_cast<void *>(table.getColumn(column_idx).back());
+                value->store(ptr);
+                column_idx += 1;
+            }
+
+            return tid;
+        }
+#endif
+
+        void Insert::produce()
+        {
+            //Native::Sql::SqlTuple *tuplePtr = tuple.get();
+            /*llvm::FunctionType * funcTy = llvm::TypeBuilder<int (void*,void*,void*), false>::get(_codeGen.getLLVMContext());
+            llvm::CallInst * result = _codeGen.CreateCall(&insert_tuple, funcTy, {tuplePtr,tablePtr,contextPtr});*/
+            llvm::FunctionType * funcTy = llvm::TypeBuilder<void (void *, void *, void *), false>::get(_codeGen.getLLVMContext());
+            llvm::Function * func = llvm::cast<llvm::Function>( getThreadLocalCodeGen().getCurrentModuleGen().getModule().getOrInsertFunction("insert_tuple_with_binding", funcTy) );
+#if USE_DATA_VERSIONING
+            getThreadLocalCodeGen().getCurrentModuleGen().addFunctionMapping(func,(void *)&insert_tuple_with_binding);
+#else
+            getThreadLocalCodeGen().getCurrentModuleGen().addFunctionMapping(func,(void *)&insert_tuple_without_versioning);
+#endif
+            llvm::CallInst * result = _codeGen->CreateCall(func, {cg_ptr8_t::fromRawPointer(tuple), cg_ptr8_t::fromRawPointer(&table), _codeGen.getCurrentFunctionGen().getArg(1), cg_u32_t(branchId)});
+        }
+
+    } // end namespace Physical
+} // end namespace Algebra
+

algebra/physical/Insert.hpp

+#ifndef PROTODB_INSERT_HPP
+#define PROTODB_INSERT_HPP
+
+
+#include "algebra/physical/Operator.hpp"
+#include "native/sql/SqlTuple.hpp"
+
+namespace Algebra {
+    namespace Physical {
+
+/// The print operator
+        class Insert : public NullaryOperator {
+        public:
+            Insert(const logical_operator_t & logicalOperator, Table & table, Native::Sql::SqlTuple *tuple, QueryContext &context, branch_id_t branchId);
+
+            virtual ~Insert();
+
+            void produce() override;
+
+        private:
+            Native::Sql::SqlTuple *tuple;
+            Table & table;
+            QueryContext &context;
+            branch_id_t branchId;
+        };
+
+    } // end namespace Physical
+} // end namespace Algebra
+
+
+#endif //PROTODB_INSERT_HPP

algebra/physical/Operator.hpp

@@ -7,8 +7,8 @@
 
 #include "algebra/logical/operators.hpp"
 #include "codegen/CodeGen.hpp"
-#include "foundations/InformationUnit.hpp"
-#include "foundations/QueryContext.hpp"
+#include "semanticAnalyser/logicalAlgebra/InformationUnit.hpp"
+#include "queryCompiler/QueryContext.hpp"
 #include "sql/SqlType.hpp"
 #include "sql/SqlValues.hpp"
 

algebra/physical/Print.cpp

@@ -20,12 +20,20 @@ Print::~Print()
 void Print::produce()
 {
     tupleCountPtr = _codeGen->CreateAlloca(cg_size_t::getType());
+#ifdef __APPLE__
+    _codeGen->CreateStore(cg_size_t(0ull), tupleCountPtr);
+#else
     _codeGen->CreateStore(cg_size_t(0ul), tupleCountPtr);
+#endif
 
     child->produce();
 
     cg_size_t tupleCnt(_codeGen->CreateLoad(tupleCountPtr));
+#ifdef __APPLE__
+    IfGen check(tupleCnt == cg_size_t(0ull));
+#else
     IfGen check(tupleCnt == cg_size_t(0ul));
+#endif
     {
         Functions::genPrintfCall("Empty result set\n");
     }

algebra/physical/TableScan.cpp

@@ -4,23 +4,28 @@
 
 #include "algebra/physical/TableScan.hpp"
 
-#include <map>
+#include <llvm/IR/TypeBuilder.h>
+#include "foundations/version_management.hpp"
+#include <unordered_map>
 
-#include "codegen/PhiNode.hpp"
-#include "sql/SqlUtils.hpp"
+#include "sql/SqlTuple.hpp"
 
 using namespace Sql;
 
 namespace Algebra {
 namespace Physical {
 
-TableScan::TableScan(const logical_operator_t & logicalOperator, Table & table) :
+TableScan::TableScan(const logical_operator_t & logicalOperator, Table & table, branch_id_t branchId) :
         NullaryOperator(std::move(logicalOperator)),
-        table(table)
+        table(table),
+        branchId(branchId)
 {
     // collect all information which is necessary to access the columns
     for (auto iu : getRequired()) {
         auto ci = getColumnInformation(iu);
+        if (ci->columnName.compare("tid") == 0) {
+            continue;
+        }
 
         SqlType storedSqlType;
         if (ci->type.nullable) {
@@ -34,8 +39,15 @@ TableScan::TableScan(const logical_operator_t & logicalOperator, Table & table)
         llvm::Type * elemTy = toLLVMTy(storedSqlType);
         llvm::Type * columnTy = llvm::ArrayType::get(elemTy, tableSize);
         llvm::Value * columnPtr = createPointerValue(ci->column->front(), columnTy);
+        size_t columnIndex = 0;
+        for (int i = 0; i<table.getColumnCount(); i++) {
+            if (table.getColumnNames()[i].compare(ci->columnName) == 0) {
+                columnIndex = i;
+                break;
+            }
+        }
 
-        columns.emplace_back(ci, columnTy, columnPtr);
+        columns.emplace_back(ci, columnTy, columnPtr, columnIndex, nullptr);
     }
 }
 
@@ -47,68 +59,182 @@ void TableScan::produce()
     auto & funcGen = _codeGen.getCurrentFunctionGen();
 
     size_t tableSize = table.size();
-    if (tableSize < 1) {
-        return; // nothing to produce
-    }
+    if (tableSize < 1) return;  // nothing to produce
 
     // iterate over all tuples
+#ifdef __APPLE__
+    LoopGen scanLoop(funcGen, {{"index", cg_size_t(0ull)}});
+#else
     LoopGen scanLoop(funcGen, {{"index", cg_size_t(0ul)}});
+#endif
     cg_size_t tid(scanLoop.getLoopVar(0));
     {
         LoopBodyGen bodyGen(scanLoop);
 
-        auto branchId = _context.executionContext.branchId;
+#if USE_DATA_VERSIONING
         IfGen visibilityCheck(isVisible(tid, branchId));
         {
-            produce(tid);
+            produce(tid, branchId);
         }
         visibilityCheck.EndIf();
+#else
+        produce(tid);
+#endif
     }
     cg_size_t nextIndex = tid + 1ul;
     scanLoop.loopDone(nextIndex < tableSize, {nextIndex});
 }
 
-void TableScan::produce(cg_tid_t tid)
-{
+
+#if USE_DATA_VERSIONING
+void TableScan::produce(cg_tid_t tid, branch_id_t branchId) {
     iu_value_mapping_t values;
-    std::vector<value_op_t> sqlValues;
 
     // get null indicator column data
     auto & nullIndicatorTable = table.getNullIndicatorTable();
     iu_set_t required = getRequired();
 
+    cg_voidptr_t resultPtr;
+    cg_bool_t ptrIsNotNull(false);
+    if (branchId != master_branch_id) {
+        llvm::FunctionType * funcTy = llvm::TypeBuilder<void * (size_t, void * , void* , void *), false>::get(_codeGen.getLLVMContext());
+        llvm::Function * func = llvm::cast<llvm::Function>( getThreadLocalCodeGen().getCurrentModuleGen().getModule().getOrInsertFunction("get_latest_entry", funcTy) );
+        getThreadLocalCodeGen().getCurrentModuleGen().addFunctionMapping(func,(void *)&get_latest_entry);
+        llvm::CallInst * result = _codeGen->CreateCall(func, {tid, cg_ptr8_t::fromRawPointer(&table), cg_u32_t(branchId), _codeGen.getCurrentFunctionGen().getArg(1)});
+        resultPtr = cg_voidptr_t( llvm::cast<llvm::Value>(result) );
+#ifdef __APPLE__
+        ptrIsNotNull = cg_bool_t(cg_size_t(_codeGen->CreatePtrToInt(resultPtr, _codeGen->getIntNTy(64))) != cg_size_t(0ull));
+#else
+        ptrIsNotNull = cg_bool_t(cg_size_t(_codeGen->CreatePtrToInt(resultPtr, _codeGen->getIntNTy(64))) != cg_size_t(0ul));
+#endif
+    }
+
+
     size_t i = 0;
     for (auto iu : required) {
-        column_t & column = columns[i];
-        ci_p_t ci = std::get<0>(column);
+        // the final value
+        value_op_t sqlValue;
 
-        // calculate the SQL value pointer
-        llvm::Value * elemPtr = _codeGen->CreateGEP(
-            std::get<1>(column), std::get<2>(column), { cg_size_t(0ul), tid });
+        if (iu->columnInformation->columnName.compare("tid") == 0) {
 
+            //Add tid to the produced values
+            llvm::Value *tidValue = tid.getValue();
+            tidSqlValue = std::make_unique<LongInteger>(tidValue);
+            values[iu] = tidSqlValue.get();
+        } else {
+            column_t & column = columns[i];
+
+            ci_p_t ci = std::get<0>(column);
+
+            llvm::Value *elemPtr;
+            if (branchId != master_branch_id) {
+                elemPtr = getBranchElemPtr(tid,column,resultPtr,ptrIsNotNull);
+            } else {
+                elemPtr = getMasterElemPtr(tid,column);
+            }
+
+            // calculate the SQL value pointer
+
+            if (ci->type.nullable) {
+                assert(ci->nullIndicatorType == ColumnInformation::NullIndicatorType::Column);
+                // load null indicator
+                cg_bool_t isNull = genNullIndicatorLoad(nullIndicatorTable, tid, cg_unsigned_t(ci->nullColumnIndex));
+                SqlType notNullableType = toNotNullableTy(ci->type);
+                auto loadedValue = Value::load(elemPtr, notNullableType);
+                std::get<4>(column) = NullableValue::create(std::move(loadedValue), isNull);
+            } else {
+                // load the SQL value
+                std::get<4>(column) = Value::load(elemPtr, ci->type);
+            }
+
+            // map the value to the according iu
+            values[iu] = std::get<4>(column).get();
+
+            i += 1;
+        }
+    }
+
+    _parent->consume(values, *this);
+}
+#else
+void TableScan::produce(cg_tid_t tid) {
+    iu_value_mapping_t values;
+
+    // get null indicator column data
+    auto & nullIndicatorTable = table.getNullIndicatorTable();
+    iu_set_t required = getRequired();
+
+
+    size_t i = 0;
+    for (auto iu : required) {
         // the final value
         value_op_t sqlValue;
-        if (ci->type.nullable) {
-            assert(ci->nullIndicatorType == ColumnInformation::NullIndicatorType::Column);
-            // load null indicator
-            cg_bool_t isNull = genNullIndicatorLoad(nullIndicatorTable, tid, cg_unsigned_t(ci->nullColumnIndex));
-            SqlType notNullableType = toNotNullableTy(ci->type);
-            auto loadedValue = Value::load(elemPtr, notNullableType);
-            sqlValue = NullableValue::create(std::move(loadedValue), isNull);
+
+        if (iu->columnInformation->columnName.compare("tid") == 0) {
+            //Add tid to the produced values
+            llvm::Value *tidValue = tid.getValue();
+            tidSqlValue = std::make_unique<LongInteger>(tidValue);
+            values[iu] = tidSqlValue.get();
         } else {
-            // load the SQL value
-            sqlValue = Value::load(elemPtr, ci->type);
-        }
+            column_t & column = columns[i];
+
+            ci_p_t ci = std::get<0>(column);
+
+            llvm::Value *elemPtr = getMasterElemPtr(tid,column);
+
+            // calculate the SQL value pointer
 
-        // map the value to the according iu
-        values[iu] = sqlValue.get();
-        sqlValues.push_back( std::move(sqlValue) );
+            if (ci->type.nullable) {
+                assert(ci->nullIndicatorType == ColumnInformation::NullIndicatorType::Column);
+                // load null indicator
+                cg_bool_t isNull = genNullIndicatorLoad(nullIndicatorTable, tid, cg_unsigned_t(ci->nullColumnIndex));
+                SqlType notNullableType = toNotNullableTy(ci->type);
+                auto loadedValue = Value::load(elemPtr, notNullableType);
+                std::get<4>(column) = NullableValue::create(std::move(loadedValue), isNull);
+            } else {
+                // load the SQL value
+                std::get<4>(column) = Value::load(elemPtr, ci->type);
+            }
 
-        i += 1;
+            // map the value to the according iu
+            values[iu] = std::get<4>(column).get();
+
+            i += 1;
+        }
     }
 
     _parent->consume(values, *this);
 }
+#endif
+
+llvm::Value *TableScan::getMasterElemPtr(cg_tid_t &tid, column_t &column) {
+#ifdef __APPLE__
+    llvm::Value * elemPtr = _codeGen->CreateGEP(std::get<1>(column), std::get<2>(column), { cg_size_t(0ull), tid });
+#else
+    llvm::Value * elemPtr = _codeGen->CreateGEP(std::get<1>(column), std::get<2>(column), { cg_size_t(0ul), tid });
+#endif
+    return elemPtr;
+}
+
+llvm::Value *TableScan::getBranchElemPtr(cg_tid_t &tid, column_t &column, cg_voidptr_t &resultPtr, cg_bool_t &ptrIsNotNull) {
+    IfGen check( _codeGen.getCurrentFunctionGen(), ptrIsNotNull, {{"elemPtr", cg_int_t(0)}} );
+    {
+        llvm::Type * tupleTy = Sql::SqlTuple::getType(table.getTupleType());
+        llvm::Type * tuplePtrTy = llvm::PointerType::getUnqual(tupleTy);
+        llvm::Value * tuplePtr = _codeGen->CreatePointerCast(resultPtr, tuplePtrTy);
+
+        cg_size_t index_gen = cg_size_t(std::get<3>(column));
+        llvm::Value * valuePtr = _codeGen->CreateStructGEP(tupleTy, tuplePtr, std::get<3>(column));
+        check.setVar(0, valuePtr);
+    }
+    check.Else();
+    {
+        llvm::Value *elemPtr = getMasterElemPtr(tid,column);
+        check.setVar(0, elemPtr);
+    }
+    check.EndIf();
+    return check.getResult(0);
+}
 
 cg_bool_t TableScan::isVisible(cg_tid_t tid, cg_branch_id_t branchId)
 {

algebra/physical/TableScan.hpp

@@ -3,6 +3,7 @@
 
 #include "algebra/physical/Operator.hpp"
 #include "foundations/Database.hpp"
+#include "sql/SqlValues.hpp"
 
 namespace Algebra {
 namespace Physical {
@@ -10,21 +11,30 @@ namespace Physical {
 /// The table scan operator
 class TableScan : public NullaryOperator {
 public:
-    TableScan(const logical_operator_t & logicalOperator, Table & table);
+    TableScan(const logical_operator_t & logicalOperator, Table & table, branch_id_t branchId);
 
     virtual ~TableScan();
 
     void produce() override;
 
+#if USE_DATA_VERSIONING
+    void produce(cg_tid_t tid, branch_id_t branchId);
+#else
     void produce(cg_tid_t tid);
+#endif
 
 private:
+    using column_t = std::tuple<ci_p_t, llvm::Type *, llvm::Value *, size_t, Sql::value_op_t>;
+
     cg_bool_t isVisible(cg_tid_t tid, cg_branch_id_t branchId);
+    llvm::Value *getMasterElemPtr(cg_tid_t &tid, column_t &column);
+    llvm::Value *getBranchElemPtr(cg_tid_t &tid, column_t &column, cg_voidptr_t &resultPtr, cg_bool_t &ptrIsNotNull);
 
     Table & table;
+    branch_id_t branchId;
 
-    using column_t = std::tuple<ci_p_t, llvm::Type *, llvm::Value *>;
     std::vector<column_t> columns;
+    Sql::value_op_t tidSqlValue;
 };
 
 } // end namespace Physical

algebra/physical/TupleStream.cpp

+//
+// Created by Blum Thomas on 2020-06-16.
+//
+
+#include <llvm/IR/TypeBuilder.h>
+
+#include "TupleStream.hpp"
+#include "sql/SqlUtils.hpp"
+#include "sql/ValueTranslator.hpp"
+
+using namespace Sql;
+
+namespace Algebra {
+    namespace Physical {
+
+        TupleStream::TupleStream(const logical_operator_t & logicalOperator, std::unique_ptr<Operator> input) :
+                UnaryOperator(std::move(logicalOperator), std::move(input))
+        {
+            for (auto &iu : _logicalOperator.getRequired()) {
+                auto ci = getColumnInformation(iu);
+                if (ci->columnName.compare("tid") == 0) {
+                    continue;
+                }
+
+                columns.emplace_back(iu);
+            }
+        }
+
+        TupleStream::~TupleStream()
+        { }
+
+        void TupleStream::produce()
+        {
+            tupleCountPtr = _codeGen->CreateAlloca(cg_size_t::getType());
+#ifdef __APPLE__
+            _codeGen->CreateStore(cg_size_t(0ull), tupleCountPtr);
+#else
+            _codeGen->CreateStore(cg_size_t(0ul), tupleCountPtr);
+#endif
+
+            child->produce();
+        }
+
+        void TupleStream::consume(const iu_value_mapping_t & values, const Operator & src)
+        {
+            std::vector<Sql::Value*> tupleValues;
+            for (auto &column : columns) {
+                tupleValues.emplace_back(values.at(std::get<0>(column)));
+            }
+
+            // Convert the Sql::Value to Native::Sql::Value
+            std::vector<std::unique_ptr<Native::Sql::Value>> nativeValues;
+            for (auto &value : tupleValues) {
+                nativeValues.emplace_back(ValueTranslator::sqlValueToNativeSqlValue(value));
+            }
+
+            // Create a Native::Sql::Tuple needed by the update_tuple function in version_management.hpp
+            Native::Sql::SqlTuple* nativetuple = new Native::Sql::SqlTuple(std::move(nativeValues));
+
+            // Call the update_tuple function in version_management.hpp
+            llvm::FunctionType * funcUpdateTupleTy = llvm::TypeBuilder<void (void *), false>::get(_codeGen.getLLVMContext());
+            llvm::Function * func = llvm::cast<llvm::Function>( getThreadLocalCodeGen().getCurrentModuleGen().getModule().getOrInsertFunction("callHandler", funcUpdateTupleTy) );
+            llvm::CallInst * result = _codeGen->CreateCall(func, {cg_ptr8_t::fromRawPointer(nativetuple)});
+
+            // increment tuple counter
+            cg_size_t prevCnt(_codeGen->CreateLoad(tupleCountPtr));
+            _codeGen->CreateStore(prevCnt + 1ul, tupleCountPtr);
+        }
+
+    } // end namespace Physical
+} // end namespace Algebra
\ No newline at end of file

algebra/physical/TupleStream.hpp

+//
+// Created by Blum Thomas on 2020-06-16.
+//
+
+#ifndef PROTODB_TUPLESTREAM_HPP
+#define PROTODB_TUPLESTREAM_HPP
+
+#include "algebra/physical/Operator.hpp"
+
+namespace Algebra {
+    namespace Physical {
+
+/// The print operator
+        class TupleStream : public UnaryOperator {
+        public:
+            TupleStream(const logical_operator_t & logicalOperator, std::unique_ptr<Operator> input);
+
+            virtual ~TupleStream();
+
+            void produce() override;
+            void consume(const iu_value_mapping_t & values, const Operator & src) override;
+
+        private:
+            std::vector<iu_p_t> selection;
+
+
+            using column_t = std::tuple<iu_p_t>;
+            std::vector<column_t> columns;
+
+            llvm::Value * tupleCountPtr;
+        };
+
+    } // end namespace Physical
+} // end namespace Algebra
+
+
+#endif //PROTODB_TUPLESTREAM_HPP

algebra/physical/Update.cpp

+//
+// Created by josef on 03.01.17.
+//
+
+#include <llvm/IR/TypeBuilder.h>
+
+#include "algebra/physical/Update.hpp"
+#include "sql/SqlUtils.hpp"
+#include "sql/SqlValues.hpp"
+#include "sql/SqlTuple.hpp"
+#include "foundations/version_management.hpp"
+#include "sql/ValueTranslator.hpp"
+
+using namespace Sql;
+
+namespace Algebra {
+    namespace Physical {
+
+        Update::Update(const logical_operator_t & logicalOperator, std::unique_ptr<Operator> input, Table & table,
+                std::vector<std::pair<iu_p_t,std::string>> &updateIUs, branch_id_t branchId) :
+                UnaryOperator(std::move(logicalOperator), std::move(input)) , table(table),
+                _updateIUs(std::move(updateIUs)), branchId(branchId)
+        {
+            // collect all information which is necessary to access the columns
+            for (auto &iuPairs : _updateIUs) {
+                auto ci = getColumnInformation(iuPairs.first);
+                if (ci->columnName.compare("tid") == 0) {
+                    continue;
+                }
+
+                SqlType storedSqlType;
+                if (ci->type.nullable) {
+                    // the null indicator will be stored in the NullIndicatorTable
+                    storedSqlType = toNotNullableTy( ci->type );
+                } else {
+                    storedSqlType = ci->type;
+                }
+
+                std::unique_ptr<Sql::Value> sqlValue = nullptr;
+                if (iuPairs.second.compare("") != 0) {
+                    sqlValue = Sql::Value::castString(iuPairs.second,storedSqlType);
+                }
+
+                size_t tableSize = table.size();
+                llvm::Type * elemTy = toLLVMTy(storedSqlType);
+                llvm::Type * columnTy = llvm::ArrayType::get(elemTy, tableSize);
+                llvm::Value * columnPtr = createPointerValue(ci->column->front(), columnTy);
+                size_t columnIndex = 0;
+                for (int i = 0; i<table.getColumnCount(); i++) {
+                    if (table.getColumnNames()[i].compare(ci->columnName) == 0) {
+                        columnIndex = i;
+                        break;
+                    }
+                }
+
+                columns.emplace_back(ci, columnTy, columnPtr, columnIndex, std::move(sqlValue));
+            }
+        }
+
+        Update::~Update()
+        { }
+
+        void Update::produce()
+        {
+            tupleCountPtr = _codeGen->CreateAlloca(cg_size_t::getType());
+#ifdef __APPLE__
+            _codeGen->CreateStore(cg_size_t(0ull), tupleCountPtr);
+#else
+            _codeGen->CreateStore(cg_size_t(0ul), tupleCountPtr);
+#endif
+
+            child->produce();
+
+            cg_size_t tupleCnt(_codeGen->CreateLoad(tupleCountPtr));
+
+            //Functions::genPrintfCall("Updated %lu tuples\n", tupleCnt);
+        }
+
+        void Update::consume(const iu_value_mapping_t & values, const Operator & src)
+        {
+            // Get the tid of the consumed tuple
+            cg_size_t tid;
+            for (auto &iuPair : _updateIUs) {
+                if (iuPair.first->columnInformation->columnName.compare("tid") == 0) {
+                    tid = cg_size_t(values.at(iuPair.first)->getLLVMValue());
+                    break;
+                }
+            }
+
+
+#if USE_DATA_VERSIONING
+            // Collect all values needed for the row tuple in correct order
+            std::vector<Sql::Value*> tupleValues;
+            std::sort(columns.begin(), columns.end(), sortColumns);
+            for (auto &column : columns) {
+                for (auto &iuPair : _updateIUs) {
+                    if (iuPair.first->columnInformation->columnName.compare(std::get<0>(column)->columnName) == 0) {
+                        // If tuple value needs to be updated take the value offered by the operator; Else take the value pushed up in the tree
+                        std::unique_ptr<Sql::Value> &updateValue = std::get<4>(column);
+                        if (updateValue != nullptr) {
+                            tupleValues.emplace_back(updateValue.get());
+                        } else {
+                            tupleValues.emplace_back(values.at(iuPair.first));
+                        }
+                        break;
+                    }
+                }
+            }
+
+            // Convert the Sql::Value to Native::Sql::Value
+            std::vector<std::unique_ptr<Native::Sql::Value>> nativeValues;
+            for (auto &value : tupleValues) {
+                nativeValues.emplace_back(ValueTranslator::sqlValueToNativeSqlValue(value));
+            }
+
+            // Create a Native::Sql::Tuple needed by the update_tuple function in version_management.hpp
+            Native::Sql::SqlTuple* nativetuple = new Native::Sql::SqlTuple(std::move(nativeValues));
+
+            // Call the update_tuple function in version_management.hpp
+            llvm::FunctionType * funcUpdateTupleTy = llvm::TypeBuilder<void * (size_t, void *, void * , void *, void *), false>::get(_codeGen.getLLVMContext());
+            llvm::Function * func = llvm::cast<llvm::Function>( getThreadLocalCodeGen().getCurrentModuleGen().getModule().getOrInsertFunction("update_tuple_with_binding", funcUpdateTupleTy) );
+            getThreadLocalCodeGen().getCurrentModuleGen().addFunctionMapping(func,(void *)&update_tuple_with_binding);
+            llvm::CallInst * result = _codeGen->CreateCall(func, {tid, cg_u32_t(branchId), cg_ptr8_t::fromRawPointer(nativetuple), cg_ptr8_t::fromRawPointer(&table), _codeGen.getCurrentFunctionGen().getArg(1)});
+
+#else
+
+            for (auto &column : columns) {
+                Sql::Value *sqlValue = std::get<4>(column).get();
+                if (sqlValue == nullptr) continue;
+
+                // calculate the SQL value pointer
+#ifdef __APPLE__
+                llvm::Value * elemPtr = _codeGen->CreateGEP(std::get<1>(column), std::get<2>(column), { cg_size_t(0ull), tid });
+#else
+                llvm::Value * elemPtr = _codeGen->CreateGEP(std::get<1>(column), std::get<2>(column), { cg_size_t(0ul), tid });
+#endif
+                // map the value to the according iu
+
+                // Store the new value at desired position
+                sqlValue->store(elemPtr);
+            }
+#endif
+
+            // increment tuple counter
+            cg_size_t prevCnt(_codeGen->CreateLoad(tupleCountPtr));
+            _codeGen->CreateStore(prevCnt + 1ul, tupleCountPtr);
+        }
+
+    } // end namespace Physical
+} // end namespace Algebra
+

algebra/physical/Update.hpp

+#ifndef PROTODB_UPDATE_HPP
+#define PROTODB_UPDATE_HPP
+
+#include "algebra/physical/Operator.hpp"
+
+namespace Algebra {
+    namespace Physical {
+
+/// The print operator
+        class Update : public UnaryOperator {
+        public:
+            Update(const logical_operator_t & logicalOperator, std::unique_ptr<Operator> input, Table & table,
+                    std::vector<std::pair<iu_p_t,std::string>> &updateIUs, branch_id_t branchId);
+
+            virtual ~Update();
+
+            void produce() override;
+            void consume(const iu_value_mapping_t & values, const Operator & src) override;
+
+        private:
+            std::vector<std::pair<iu_p_t,std::string>> _updateIUs;
+            Table & table;
+            branch_id_t branchId;
+            llvm::Value * tupleCountPtr;
+
+            using column_t = std::tuple<ci_p_t, llvm::Type *, llvm::Value *, size_t, std::unique_ptr<Sql::Value>>;
+            std::vector<column_t> columns;
+
+            static bool sortColumns(column_t& a, column_t& b) {
+                return (std::get<3>(a) < std::get<3>(b));
+            }
+        };
+
+    } // end namespace Physical
+} // end namespace Algebra
+
+#endif //PROTODB_UPDATE_HPP