PointConstructor.h

Go to the documentation of this file.

/*
 * Copyright 2022 HEAVY.AI, Inc.
 *
 * 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.
 */

#pragma once

#include "QueryEngine/GeoOperators/Codegen.h"

#include "Shared/SqlTypesLayout.h"

namespace spatial_type {

// ST_Point
class PointConstructor : public Codegen {
 public:
  PointConstructor(const Analyzer::GeoOperator* geo_operator) : Codegen(geo_operator) {
    CHECK_EQ(operator_->size(), size_t(2));
    const auto& ti = geo_operator->get_type_info();
    if (ti.get_notnull()) {
      is_nullable_ = false;
    } else {
      is_nullable_ = true;
    }
  }

  std::unique_ptr<CodeGenerator::NullCheckCodegen> getNullCheckCodegen(
      llvm::Value* null_lv,
      CgenState* cgen_state,
      Executor* executor) final {
    if (isNullable()) {
      // do the standard nullcheck codegen, but modify the null basic block to emplace the
      // null sentinel into the array
      auto nullcheck_codegen = std::make_unique<CodeGenerator::NullCheckCodegen>(
          cgen_state, executor, null_lv, getNullType(), getName() + "_nullcheck");

      auto& builder = cgen_state->ir_builder_;
      CHECK(pt_local_storage_lv_);

      auto prev_insert_block = builder.GetInsertBlock();
      auto crt_insert_block = nullcheck_codegen->null_check->cond_true_;
      CHECK(crt_insert_block);
      auto& instruction_list = crt_insert_block->getInstList();
      CHECK_EQ(instruction_list.size(), size_t(1));
      builder.SetInsertPoint(crt_insert_block, instruction_list.begin());

      auto x_coord_ptr = builder.CreateGEP(
          pt_local_storage_lv_->getType()->getScalarType()->getPointerElementType(),
          pt_local_storage_lv_,
          {cgen_state->llInt(0), cgen_state->llInt(0)},
          "x_coord_ptr");
      const auto& geo_ti = operator_->get_type_info();
      if (geo_ti.get_compression() == kENCODING_GEOINT) {
        // TODO: probably wrong
        builder.CreateStore(cgen_state->llInt(inline_int_null_val(SQLTypeInfo(kINT))),
                            x_coord_ptr);
      } else {
        builder.CreateStore(cgen_state->llFp(static_cast<double>(NULL_ARRAY_DOUBLE)),
                            x_coord_ptr);
      }
      builder.SetInsertPoint(prev_insert_block);

      return nullcheck_codegen;
    } else {
      return nullptr;
    }
  }

  size_t size() const final { return 2; }

  SQLTypeInfo getNullType() const final { return SQLTypeInfo(kBOOLEAN); }

  // returns arguments lvs and null lv
  std::tuple<std::vector<llvm::Value*>, llvm::Value*> codegenLoads(
      const std::vector<llvm::Value*>& arg_lvs,
      const std::vector<llvm::Value*>& pos_lvs,
      CgenState* cgen_state) final {
    CHECK_EQ(pos_lvs.size(),
             size());  // note both pos arguments should be the same, as both inputs are
                       // expected to be from the same table, though this is moot in this
                       // function as position argumnts are not used here
    CHECK_EQ(arg_lvs.size(), size_t(2));

    // TODO(adb): centralize nullcheck logic for all sqltypes
    llvm::Value* const x_is_null = codegenOperandIsNull(0u, arg_lvs[0], cgen_state);
    llvm::Value* const y_is_null = codegenOperandIsNull(1u, arg_lvs[1], cgen_state);
    llvm::Value* const is_null =
        x_is_null && y_is_null ? cgen_state->ir_builder_.CreateOr(x_is_null, y_is_null)
                               : std::max(x_is_null, y_is_null);

    if (is_nullable_ && !is_null) {
      // if the inputs are not null, set the output to be not null
      // TODO: we should do this in the translator and just confirm it here
      is_nullable_ = false;
    }

    // do the alloca before nullcheck codegen, as either way we will return a point array
    const auto& geo_ti = operator_->get_type_info();
    CHECK(geo_ti.get_type() == kPOINT);

    llvm::ArrayType* arr_type{nullptr};
    if (geo_ti.get_compression() == kENCODING_GEOINT) {
      auto elem_ty = llvm::Type::getInt32Ty(cgen_state->context_);
      arr_type = llvm::ArrayType::get(elem_ty, 2);
    } else {
      CHECK(geo_ti.get_compression() == kENCODING_NONE);
      auto elem_ty = llvm::Type::getDoubleTy(cgen_state->context_);
      arr_type = llvm::ArrayType::get(elem_ty, 2);
    }
    pt_local_storage_lv_ = cgen_state->ir_builder_.CreateAlloca(
        arr_type, nullptr, operator_->getName() + "_Local_Storage");

    return std::make_tuple(arg_lvs, is_null);
  }

  std::vector<llvm::Value*> codegen(const std::vector<llvm::Value*>& args,
                                    CodeGenerator::NullCheckCodegen* nullcheck_codegen,
                                    CgenState* cgen_state,
                                    const CompilationOptions& co) final {
    CHECK_EQ(args.size(), size_t(2));

    const auto& geo_ti = operator_->get_type_info();
    CHECK(geo_ti.get_type() == kPOINT);

    auto& builder = cgen_state->ir_builder_;
    CHECK(pt_local_storage_lv_);

    const bool is_compressed = geo_ti.get_compression() == kENCODING_GEOINT;

    // store x coord
    auto x_coord_ptr = builder.CreateGEP(
        pt_local_storage_lv_->getType()->getScalarType()->getPointerElementType(),
        pt_local_storage_lv_,
        {cgen_state->llInt(0), cgen_state->llInt(0)},
        "x_coord_ptr");
    if (is_compressed) {
      auto compressed_lv =
          cgen_state->emitExternalCall("compress_x_coord_geoint",
                                       llvm::Type::getInt32Ty(cgen_state->context_),
                                       {args.front()});
      builder.CreateStore(compressed_lv, x_coord_ptr);
    } else {
      builder.CreateStore(args.front(), x_coord_ptr);
    }

    // store y coord
    auto y_coord_ptr = builder.CreateGEP(
        pt_local_storage_lv_->getType()->getScalarType()->getPointerElementType(),
        pt_local_storage_lv_,
        {cgen_state->llInt(0), cgen_state->llInt(1)},
        "y_coord_ptr");
    if (is_compressed) {
      auto compressed_lv =
          cgen_state->emitExternalCall("compress_y_coord_geoint",
                                       llvm::Type::getInt32Ty(cgen_state->context_),
                                       {args.back()});
      builder.CreateStore(compressed_lv, y_coord_ptr);
    } else {
      builder.CreateStore(args.back(), y_coord_ptr);
    }

    llvm::Value* ret = pt_local_storage_lv_;
    if (is_nullable_) {
      CHECK(nullcheck_codegen);
      ret = nullcheck_codegen->finalize(ret, ret);
    }
    return {builder.CreateBitCast(ret,
                                  geo_ti.get_compression() == kENCODING_GEOINT
                                      ? llvm::Type::getInt32PtrTy(cgen_state->context_)
                                      : llvm::Type::getDoublePtrTy(cgen_state->context_)),
            cgen_state->llInt(static_cast<int32_t>(
                geo_ti.get_compression() == kENCODING_GEOINT ? 8 : 16))};
  }

 private:
  llvm::Value* codegenOperandIsNull(size_t idx,
                                    llvm::Value* value,
                                    CgenState* cgen_state) {
    auto const& ti = getOperand(idx)->get_type_info();
    if (ti.get_notnull()) {
      return nullptr;
    } else if (ti.is_integer()) {
      return cgen_state->ir_builder_.CreateICmpEQ(
          value, cgen_state->llInt(inline_int_null_val(ti)));
    } else if (ti.is_fp()) {
      return cgen_state->ir_builder_.CreateFCmpOEQ(
          value, cgen_state->llFp(inline_fp_null_val(ti)));
    } else {
      UNREACHABLE() << "Type is expected to be integer or floating point.";
      return {};
    }
  }

  llvm::AllocaInst* pt_local_storage_lv_{nullptr};
};

}  // namespace spatial_type